uint32_t getParamValue(fapi_uint16_tlv_t *tlv, uint16_t type)
{
- //uint16_t valueLen;
void *posPtr;
- //valueLen = tlv->tl.length;
posPtr = &tlv->tl.tag;
posPtr += sizeof(tlv->tl.tag);
posPtr += sizeof(tlv->tl.length);
/*TO DO: malloc to SSI memory */
if(type == FAPI_UINT_8)
{
- //temp = (uint8_t *)malloc(valueLen * sizeof(U8));
- //memcpy(temp, posPtr, valueLen);
return(*(uint8_t *)posPtr);
}
else if(type == FAPI_UINT_16)
uint8_t lwr_mac_procConfigReqEvt(void *msg)
{
#ifdef INTEL_FAPI
- uint8_t idx = 0;
- uint8_t index = 0;
- uint16_t *cellId;
- uint16_t cellIdx;
- uint32_t msgLen = 0;
- MacCellCfg macCfgParams;
+ uint8_t idx = 0;
+ uint8_t index = 0;
+ uint16_t *cellId;
+ uint16_t cellIdx;
+ uint32_t msgLen = 0;
+ MacCellCfg macCfgParams;
fapi_config_req_t *configReq;
DU_LOG("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \
}
/* Fetching DCI field values */
- dciFormatId = dlMsgInfo->dciFormatId;; /* Always set to 1 for DL */
+ dciFormatId = dlMsgInfo->dciFormatId; /* Always set to 1 for DL */
timeDomResAssign = pdcchInfo->dci.pdschCfg->pdschTimeAlloc.rowIndex -1;
VRB2PRBMap = pdcchInfo->dci.pdschCfg->pdschFreqAlloc.vrbPrbMapping;
modNCodScheme = pdcchInfo->dci.pdschCfg->codeword[0].mcsIndex;
else
{
DU_LOG("\nLWR_MAC: Failed filling PDCCH Pdu");
- return RFAILED;;
+ return RFAILED;
}
dlTtiReqPdu->pduType = PDCCH_PDU_TYPE;
dlTtiReqPdu->pdu.pdcch_pdu.bwpSize = bwp->freqAlloc.numPrb;
uint8_t bytePos;
uint8_t bitPos;
- uint8_t coreset1Size = 0;
+ uint8_t coreset1Size = 0;
uint16_t rbStart = 0;
uint16_t rbLen = 0;
uint8_t dciFormatId = 0;
uint16_t fillUlDciReq(SlotIndInfo currTimingInfo)
{
#ifdef INTEL_FAPI
- uint8_t cellIdx;
+ uint8_t cellIdx;
uint8_t numPduEncoded = 0;
uint32_t msgLen = 0;
uint32_t msgSize = 0;
typedef struct wlsBlockToFree
{
- void *ptr;
+ void *ptr;
uint32_t size;
}WlsBlockToFree;
DU_LOG("\nMAC : Received CRC indication");
GET_CELL_IDX(crcInd->cellId, cellIdx);
/* Considering one pdu and one preamble */
- crcIndInfo.cellId = macCb.macCell[cellIdx]->cellId;;
+ crcIndInfo.cellId = macCb.macCell[cellIdx]->cellId;
crcIndInfo.crnti = crcInd->crcInfo[0].rnti;
crcIndInfo.timingInfo.sfn = crcInd->timingInfo.sfn;
crcIndInfo.timingInfo.slot = crcInd->timingInfo.slot;
* ****************************************************************/
uint8_t MacProcRlcDlData(Pst* pstInfo, RlcData *dlData)
{
- uint8_t pduIdx;
- uint8_t *txPdu;
- uint16_t tbSize;
+ uint8_t pduIdx;
+ uint8_t *txPdu;
+ uint16_t tbSize;
MacDlData macDlData;
MacDlSlot *currDlSlot = NULLP;
uint8_t lcId, uint16_t pduLen, uint8_t *pdu)
{
Pst pst;
- RlcData *ulData;
+ RlcData *ulData;
/* Filling RLC Ul Data*/
MAC_ALLOC_SHRABL_BUF(ulData, sizeof(RlcData));
* ****************************************************************/
uint8_t MacProcDlCcchInd(Pst *pst, DlCcchIndInfo *dlCcchIndInfo)
{
- uint8_t ueIdx = 0;
- uint16_t cellIdx;
- uint16_t idx;
+ uint8_t ueIdx = 0;
+ uint16_t cellIdx;
+ uint16_t idx;
DlRlcBoInfo dlBoInfo;
memset(&dlBoInfo, 0, sizeof(DlRlcBoInfo));
memset(&srUciInd, 0, sizeof(SrUciIndInfo));
GET_CELL_IDX(macUciInd->cellId, cellIdx);
- srUciInd.cellId = macCb.macCell[cellIdx]->cellId;;
+ srUciInd.cellId = macCb.macCell[cellIdx]->cellId;
srUciInd.crnti = crnti;
srUciInd.slotInd.sfn = macUciInd->slotInd.sfn;
srUciInd.slotInd.slot = macUciInd->slotInd.slot;
#define RG_MAC_HDR_SIZE 250
#define RG_MAC_CE_SIZE 250
-U32 MacPtrAddress;
-U32 macHeader[2];
+uint32_t MacPtrAddress;
+uint32_t macHeader[2];
#define RG_ADD_DBuf(_dBuf,_size,_mBuf)\
{ \
ssGetDBufOfSize(mInfo->region,_size, &_dBuf); \
SUpdMsg(_mBuf, _dBuf,0);\
_dBuf->b_wptr = _dBuf->b_rptr = (_dBuf->b_datap->db_base + 5);\
- MacPtrAddress = (U32)_dBuf->b_wptr;\
+ MacPtrAddress = (uint32_t)_dBuf->b_wptr;\
}
#endif
#ifdef L2_OPTMZ
#define RG_FREE_TB(_tb)\
{\
- U32 lchIdx, pduIdx;\
+ uint32_t lchIdx, pduIdx;\
SResetMBuf(_tb->macHdr);\
SResetMBuf(_tb->macCes);\
_tb->tbPres = FALSE;\
#define RG_FREE_SAVED_TB(_tb)\
{\
- U32 lchIdx, pduIdx;\
+ uint32_t lchIdx, pduIdx;\
RG_FREE_MSG(_tb->macHdr);\
RG_FREE_MSG(_tb->macCes);\
_tb->tbPres = FALSE;\
**********************************************************/
#define RG_DROP_RGUDDATREQ_MBUF(_datReq)\
{\
- U32 idx5,idx6,idx7;\
+ uint32_t idx5,idx6,idx7;\
for (idx5=0; idx5 < _datReq.nmbOfTbs; idx5++)\
{\
for (idx6=0; idx6 < _datReq.datReqTb[idx5].nmbLch; idx6++)\
typedef struct rgUeUlAlloc
{
CmLteRnti rnti; /*!< Ue Id */
- U8 numPrb; /*!< Number of total PRB's allocated for this UE */
+ uint8_t numPrb; /*!< Number of total PRB's allocated for this UE */
} RgUeUlAlloc;
/**
* @brief Structure hold uplink allocation information for sub frames.
typedef struct rgUlSf
{
CmLteTimingInfo schdTime; /*!< scheduled frame and subframe number */
- U8 numUe; /*!< Number of UE's allocated in this uplink
- subframe */
+ uint8_t numUe; /*!< Number of UE's allocated in this uplink subframe */
RgUeUlAlloc *ueUlAllocInfo; /*!< Uplink alloc infor for this subframe */
} RgUlSf;
CmLList measLnk; /*!< MeasCb node */
RgInfL2MeasReq measReq; /*!< Request received for measurement */
CmLteTimingInfo startTime; /*!< Time at which measurement started */
- U32 sfnCycle; /*!< Count of Num of SFN wraps */
+ uint32_t sfnCycle; /*!< Count of Num of SFN wraps */
};
/** @brief
* Control block to store Logical Channels with Qci.
* */
struct rgQciCb
{
- U8 qci; /*< QCI for measurement */
- U32 prbCount; /*!< Cummulative PRB count */
- U8 mask; /*!< Measurement Active or Not*/
+ uint8_t qci; /*< QCI for measurement */
+ uint32_t prbCount; /*!< Cummulative PRB count */
+ uint8_t mask; /*!< Measurement Active or Not*/
CmLteTimingInfo startTime;/*!< Time at which measurement started */
};
#endif /* LTE_L2_MEAS */
{
RgPdcch pdcch;
Buffer *tb;
- U16 txPwrOffset; /*!< PDSCH Tx Pwr offset */
+ uint16_t txPwrOffset; /*!< PDSCH Tx Pwr offset */
} RgBcchTb;
typedef struct rgPcchTb
{
RgPdcch pdcch;
Buffer *tb;
- U16 txPwrOffset; /*!< PDSCH Tx Pwr offset */
+ uint16_t txPwrOffset; /*!< PDSCH Tx Pwr offset */
} RgPcchTb;
typedef struct rgRaRspAlloc
{
RgPdcch pdcch; /*!< NULLP if no Rsp allocation done for raRnti*/
Buffer *rar;
- U16 txPwrOffset; /*!< PDSCH Tx Pwr offset */
+ uint16_t txPwrOffset; /*!< PDSCH Tx Pwr offset */
}RgRaRspAlloc;
typedef struct rgBchTb
typedef struct rgDlSf
{
CmLteTimingInfo schdTime; /*!< scheduled frame and subframe number */
- Bool txDone; /*!< Flag to indicate transmission done */
+ Bool txDone; /*!< Flag to indicate transmission done */
/* ADD Changes for Downlink UE Timing Optimization */
#ifdef LTEMAC_DLUE_TMGOPTMZ
- U8 remDatReqCnt; /*!< Counter to maintain count of Ded data received.*/
+ uint8_t remDatReqCnt; /*!< Counter to maintain count of Ded data received.*/
/* Fix [ccpu00126310]: Tracks Data Requests from RLC for both loosely and tight coupled
RLC-MAC */
- Bool statIndDone; /*!< Marks sending of all status indication done */
+ Bool statIndDone; /*!< Marks sending of all status indication done */
#endif
- RgBchTb bch; /*!< BCH data for this frame */
- RgBcchTb bcch; /*!< BCCH allocation for this frame */
+ RgBchTb bch; /*!< BCH data for this frame */
+ RgBcchTb bcch; /*!< BCCH allocation for this frame */
#ifdef EMTC_ENABLE
- RgEmtcBcchTb emtcBcch; /*!< EMTC BCCH allocation for this frame */
+ RgEmtcBcchTb emtcBcch; /*!< EMTC BCCH allocation for this frame */
#endif
- RgPcchTb pcch; /*!< PCCH allocation for this frame */
- CmLListCp tbs; /*!< TBs or DL HARQ processes */
- U8 numRaRsp; /*!< No.of RaRsp */
- RgRaRspAlloc raRsp[RG_MAX_RA_RNTI]; /* Array of list of Ra Rsp
+ RgPcchTb pcch; /*!< PCCH allocation for this frame */
+ CmLListCp tbs; /*!< TBs or DL HARQ processes */
+ uint8_t numRaRsp; /*!< No.of RaRsp */
+ RgRaRspAlloc raRsp[RG_MAX_RA_RNTI]; /* Array of list of Ra Rsp
Allocations for each rarnti */
- U8 numTbReqsSent; /*!< Number of TB requests sent towards SMAC.
+ uint8_t numTbReqsSent; /*!< Number of TB requests sent towards SMAC.
Total numTbReqsSent will be equal to maximum secondary cells */
} RgDlSf;
RgLowSapCfgInfo sapCfg; /*!< SAP configuration information */
RgSapSts sapSts; /*!< Statistics related to SAP */
RgSapSta sapSta; /*!< SAP Status */
- U8 numBndRetries; /*!< Number of Bind Retries */
+ uint8_t numBndRetries; /*!< Number of Bind Retries */
}RgLowSapCb;
/**
*/
typedef struct RgMUXSubHdr
{
- U8 shLen;
- U8 shData[RG_MAX_SDU_SUB_HDR_LEN]; /* RRLCID/RFLCID + F-L (O) + L (O) */
+ uint8_t shLen;
+ uint8_t shData[RG_MAX_SDU_SUB_HDR_LEN]; /* RRLCID/RFLCID + F-L (O) + L (O) */
} RgMUXSubHdr;
*/
struct rgCellCb
{
- CmHashListEnt cellLstEnt; /*!< Hash list Entity for cell list */
- RgSchInstMap schInstMap; /*!< Sch Inst Info */
- CmLteCellId cellId; /*!< Cell ID */
+ CmHashListEnt cellLstEnt; /*!< Hash list Entity for cell list */
+ RgSchInstMap schInstMap; /*!< Sch Inst Info */
+ CmLteCellId cellId; /*!< Cell ID */
CmLteTimingInfo crntTime;
- U8 maxDlHqProcPerUe; /*!< Store based on FDD/TDD(UL/DL Index) */
+ uint8_t maxDlHqProcPerUe; /*!< Store based on FDD/TDD(UL/DL Index) */
CrgBwCfg bwCfg; /*!< Bandwidth Configuration */
CrgRachCfg rachCfg; /*!< RACH Configuration */
- RgUpSapCb *rguDlSap; /*!< RGU SAP Control Block for RLC DL */
- RgUpSapCb *rguUlSap; /*!< RGU SAP Control Block for RLC UL*/
- Inst macInst; /*!< MAC Instance id for this cell */
- U8 cellActvState; /*!< Bitmask indicating if cell is active:
+ RgUpSapCb *rguDlSap; /*!< RGU SAP Control Block for RLC DL */
+ RgUpSapCb *rguUlSap; /*!< RGU SAP Control Block for RLC UL*/
+ Inst macInst; /*!< MAC Instance id for this cell */
+ uint8_t cellActvState; /*!< Bitmask indicating if cell is active:
Cell is active only after BCCH, PCCH, DL
CCCH, UL CCCH and scheduler config */
CmLteLcId ulCcchId; /*!< LcId for uplink CCCH */
CmLteLcId dlCcchId; /*!< LcId for downlink CCCH */
- RgBcchBchLcCb bcchBchInfo; /*!< BCCH mapped on BCH
+ RgBcchBchLcCb bcchBchInfo; /*!< BCCH mapped on BCH
logical channel control block */
RgPcchLcCb pcchInfo; /*!< PCCH logical channel control block */
- U8 numBcchDlschInfo;
+ uint8_t numBcchDlschInfo;
RgBcchDlschLcCb bcchDlschInfo[RG_MAX_BCCH_DLSCH]; /*!< BCCH mapped on DLSCH
logical channel control block */
CmHashListCp ueLst; /*!< Hash list of UE control
cell */
RgDlSf subFrms[RG_NUM_SUB_FRAMES];
#ifdef LTE_L2_MEAS
- CmLListCp l2mList; /*!< List of all L2M requests
+ CmLListCp l2mList; /*!< List of all L2M requests
rgSchL2MeasCb */
- RgQciCb qciArray[LRG_MAX_QCI]; /*!< List of all qci's configured
+ RgQciCb qciArray[LRG_MAX_QCI]; /*!< List of all qci's configured
rgQciCb */
- RgUlSf ulSf[RG_NUM_UL_SUB_FRAMES]; /*!< UL Sub frame */
- Bool sndL2Meas; /*!< Send L2 Meas when No L2 Measuremnt timer is running*/
+ RgUlSf ulSf[RG_NUM_UL_SUB_FRAMES]; /*!< UL Sub frame */
+ Bool sndL2Meas; /*!< Send L2 Meas when No L2 Measuremnt timer is running*/
- U32 ttiCycle; /*!< Count of Number of 10240 Cycles
+ uint32_t ttiCycle; /*!< Count of Number of 10240 Cycles
completed */
#endif /* LTE_L2_MEAS */
RguFlowCntrlInd *flowCntrlInd; /*!<Pre Alloced buffer for flow control */
/* RRM_SP1_START */
- U32 qcisUlPrbCnt[RG_MAX_QCI_REPORTS]; /*!< GBR Lc PRB count */
+ uint32_t qcisUlPrbCnt[RG_MAX_QCI_REPORTS]; /*!< GBR Lc PRB count */
/* RRM_SP1_END */
#ifdef LTE_ADV
//RgLaaTbReq *laaCellHqPLst[RG_MAX_SCELL_PER_UE]; /*!< LAA: List containing of TBs requested per
Void * laaCb;
#endif
#ifdef EMTC_ENABLE
- U8 emtcEnable;
+ uint8_t emtcEnable;
#endif
};
*/
typedef struct rgUlHqEnt
{
- U8 maxHqRetx; /*!< Maximum number of harq
+ uint8_t maxHqRetx; /*!< Maximum number of harq
* re-transmissions */
} RgUlHqEnt;
#ifdef LTE_L2_MEAS
CmLteTimingInfo frstSegTimInfo; /*!< fisrt seg time information*/
CmLteTimingInfo nextSegTimInfo; /*!< next seg time information*/
RguL2MUlThrpSegInd segInd; /*!< UL thrgouthput indication*/
- U32 fSegTtiCycNum; /*!< First Seg tti cycles*/
- U32 nSegTtiCycNum; /*!< next seg tti cycles*/
+ uint32_t fSegTtiCycNum; /*!< First Seg tti cycles*/
+ uint32_t nSegTtiCycNum; /*!< next seg tti cycles*/
} RgL2MeasUlThrP;
#endif
/* Right now not keeping associated logical channels, searching for
* associated channels needed only during config */
LteLcgId lcgId; /*!< Group ID */
- U8 lcCount;
+ uint8_t lcCount;
#ifdef LTE_L2_MEAS
RgL2MeasUlThrP lcgBsInfo;
RgLcgCb lcgArr[RG_MAX_LCG_PER_UE]; /*!< Logical channel groups */
/* Added support for SPS*/
#ifdef LTEMAC_SPS
- Bool spsLcId[RG_MAX_LC_PER_UE]; /*!< Set to TRUE for SPS LCs */
- U8 implRelCntr; /*!< Number of empty sps transmissions for
+ Bool spsLcId[RG_MAX_LC_PER_UE]; /*!< Set to TRUE for SPS LCs */
+ uint8_t implRelCntr; /*!< Number of empty sps transmissions for
implicit(?) release */
- U8 implRelCnt; /*!< Configured value of implicitRelAfter +
+ uint8_t implRelCnt; /*!< Configured value of implicitRelAfter +
RG_ADDL_SPS_OCC_FOR_EXP_REL */
- U8 explRelCntr;/*!< Counter to track explicit release */
- U8 explRelCnt; /*!< Count to trigger explicit release */
+ uint8_t explRelCntr;/*!< Counter to track explicit release */
+ uint8_t explRelCnt; /*!< Count to trigger explicit release */
/*Added for explicit release - start*/
- U8 spsDatRcvd; /*!< Count to track SPS data for explicit
+ uint8_t spsDatRcvd; /*!< Count to track SPS data for explicit
release*/
- U32 totSpsDatRcvd; /*!< total number of SPS data recieved
+ uint32_t totSpsDatRcvd; /*!< total number of SPS data recieved
from activation*/
#endif
} RgUeUlCb;
typedef struct rgLchSchdData
{
CmLteLcId lcId; /*!< Logical channel ID */
- U32 schdSz; /*!< Scheduled logical channel data */
+ uint32_t schdSz; /*!< Scheduled logical channel data */
} RgLchSchdData;
/**
*/
typedef struct RgContResId
{
- U8 resId[RG_CRES_LEN];
+ uint8_t resId[RG_CRES_LEN];
}RgContResId;
/**
* Transport Block Info scheduled by the scheduler.
*/
typedef struct rgTbInfo{
- U8 numSchLch;
- RgLchSchdData schdData[RG_MAX_NUM_DED_LC];
- TknU8 schdTa; /*!< TA scheduled to be sent */
+ uint8_t numSchLch;
+ RgLchSchdData schdData[RG_MAX_NUM_DED_LC];
+ TknUInt8 schdTa; /*!< TA scheduled to be sent */
/* Changed as a result of CR timer implementation*/
- U8 contResCe; /*!< Contention Resolution CE scheduled
+ uint8_t contResCe; /*!< Contention Resolution CE scheduled
to be sent */
- RgContResId *contResId; /*!< Contention Resolution Identity */
+ RgContResId *contResId; /*!< Contention Resolution Identity */
#ifndef L2_OPTMZ
- Buffer *tb; /*!< Multiplexed Pdu */
+ Buffer *tb; /*!< Multiplexed Pdu */
#else
/* L2 Optimization for mUe/Tti:Pre-allocated MAC Hdr, MAC CEs and padding
* will be used to store and send to CL. These pointer will be allocated
#endif
/* Changes for MIMO feature addition */
/* Removed dependency on MIMO compile-time flag */
- U32 tbSz; /*!< TB size scheduled for the hqP */
- RgPdcch pdcch; /*!< PDCCH allocated for this HQ Proc */
+ uint32_t tbSz; /*!< TB size scheduled for the hqP */
+ RgPdcch pdcch; /*!< PDCCH allocated for this HQ Proc */
/* Adding Array of sfLnk in case of repetitions because same lnk in mutiple
* list causing issues*/
RgTbSfLnkInfo sfLnkInfo[2]; /*!< Used to queue it up on a subfrm */
RgDlSf *sf;
CmLteTimingInfo timingInfo; /*!<This field holds the scheduled time */
- TknU32 doa;
- TfuTxMode txMode;
- Bool puschRptUsd; /*!< True if Precoding Info in PDCCH has to be
+ TknUInt32 doa;
+ TfuTxMode txMode;
+ Bool puschRptUsd; /*!< True if Precoding Info in PDCCH has to be
in-accordance with the latest PUSCH report */
TfuDlCqiPuschInfo puschPmiInfo;/*!< PUSCH report details for explicit PMI
* information to PHY during a PDSCH */
/* LTE_ADV_FLAG_REMOVED_START */
#ifdef TFU_UPGRADE
- U8 pa; /* DL Power control paramter P_A
+ uint8_t pa; /* DL Power control paramter P_A
configured by higher layers
Ref: RRC 36.331, 6.3.2,
PDSCH-Config*/
#endif
- U8 isEnbSFR;
+ uint8_t isEnbSFR;
#ifdef LTE_ADV
- TknU8 sCellActCe; /*!< SCell Act ce scheduled to be sent */
+ TknUInt8 sCellActCe; /*!< SCell Act ce scheduled to be sent */
#endif
/* LTE_ADV_FLAG_REMOVED_END */
}RgTbInfo;
/**
- * @brief
+ * @brief`
* Downlink HARQ process information per UE.
*/
struct rgDlHqProcCb
{
- U8 procId; /*!< HARQ process ID */
+ uint8_t procId; /*!< HARQ process ID */
/* Changes for MIMO feature addition */
/* Removed dependency on MIMO compile-time flag */
- U8 numOfTBs;
+ uint8_t numOfTBs;
RgTbInfo tbInfo[RG_MAX_TB_PER_UE];
- U16 saveId; // laa
+ uint16_t saveId; // laa
#ifdef LTE_L2_MEAS
- U32 tbId[RGU_MAX_TB]; /*!< RLC's internal tbId */
- U16 status[RGU_MAX_TB]; /*!< Status back to RLC ACK/NACK*/
+ uint32_t tbId[RGU_MAX_TB]; /*!< RLC's internal tbId */
+ uint16_t status[RGU_MAX_TB]; /*!< Status back to RLC ACK/NACK*/
#endif /* LTE_L2_MEAS */
/* Changes for MIMO feature addition */
/* Removed dependency on MIMO compile-time flag */
*/
struct rgDlHqEnt
{
- U8 numHqProcs;
- RgDlHqProcCb *procs[RG_MAX_DL_HARQ_NUM]; /*!< Downlink harq processes */
- CmLListCp savedProcLst[RG_MAX_DL_HARQ_NUM]; /*!< laa: Saved TBs for the release Hq Procs*/
+ uint8_t numHqProcs;
+ RgDlHqProcCb *procs[RG_MAX_DL_HARQ_NUM]; /*!< Downlink harq processes */
+ CmLListCp savedProcLst[RG_MAX_DL_HARQ_NUM]; /*!< laa: Saved TBs for the release Hq Procs*/
};
typedef struct rgSCellAddCfgCfmInfo
{
CrgCfgTransId transId; /*!< Scell add transaction id*/
- U8 numSCells; /*!< Used to check if config cfm rcvd from all Scells*/
- U8 cfgCfgCount; /*!< Keep count of cfg confirms recvd */
- U8 mask; /*!< Cfg cfm mask */
+ uint8_t numSCells; /*!< Used to check if config cfm rcvd from all Scells*/
+ uint8_t cfgCfgCount; /*!< Keep count of cfg confirms recvd */
+ uint8_t mask; /*!< Cfg cfm mask */
}RgSCellAddCfgCfmInfo;
typedef struct rgSCelInfo
*/
typedef struct rgGenCb
{
- U8 tmrRes; /*!< Timer resolution */
+ uint8_t tmrRes; /*!< Timer resolution */
RgLmResponse trcResp; /*!< Response value for Trace Indication */
RgLmResponse ustaResp; /*!< Respones value for Alarms */
RgLmResponse bndCfmResp; /*!< Respones value for Bind Confirm */
TskInit rgInit; /*!< Task Init information */
S16 trcLen; /*!< trace length */
RgGenCb genCfg; /*!< General Config information */
- U8 numRguSaps; /*!< Numb of RGU SAP Control Block */
+ uint8_t numRguSaps; /*!< Numb of RGU SAP Control Block */
RgUpSapCb *rguSap; /*!< RGU SAP Control Block */
RgUpSapCb crgSap; /*!< CRG SAP Control Block */
RgLowSapCb tfuSap; /*!< TFU SAP Control Block */
RgCellCb *inactiveCell; /*!< Reference of last accessed cellCb*/
RgCellCb *cell; /*!< Reference of last accessed cellCb*/
RgCellCb *prevCell; /*!< Reference of last accessed cellCb*/
- U8 bufCnt; /*!< Count of buffers in buffersToFree[] */
+ uint8_t bufCnt; /*!< Count of buffers in buffersToFree[] */
Buffer *bufToFree[RG_MAX_DFRD_FREE_BUFS];/*!< List of Shared Buffers to be freed */
};
*/
typedef struct rgMacSdu
{
- CmLList sduLstEnt; /*!< List entry for MAC SDU subheader */
- CmLteLcId lcId; /*!< Logical channel ID */
- U16 len; /*!< Length of the SDU */
- Buffer *mBuf; /*!< SDU Buffer */
+ CmLList sduLstEnt; /*!< List entry for MAC SDU subheader */
+ CmLteLcId lcId; /*!< Logical channel ID */
+ uint16_t len; /*!< Length of the SDU */
+ Buffer *mBuf; /*!< SDU Buffer */
} RgMacSdu;
/**
*/
struct rgErrInfo
{
- U8 errType; /*!< Error Type */
- U16 errCause; /*!< Cause of Error */
+ uint8_t errType; /*!< Error Type */
+ uint16_t errCause; /*!< Cause of Error */
};
/**
typedef struct rgBldPduInfo
{
Void *datReq; /*!< Common/Dedicated Dat Request */
- U8 reqType; /*!< EVTRGUCDATREQ/EVTRGUDDATREQ */
+ uint8_t reqType; /*!< EVTRGUCDATREQ/EVTRGUDDATREQ */
MsgLen schdTbSz; /*!< Schedule TB size */
- U8 tbIndex; /*!< Transport Block Index */
- TknU8 ta; /*!< Timing Advance */
+ uint8_t tbIndex; /*!< Transport Block Index */
+ TknUInt8 ta; /*!< Timing Advance */
RgContResId *contResId; /*!< Contention Resolution ID */
#ifdef LTE_ADV
- TknU8 sCellActCe; /*!< SCell Act CE info */
+ TknUInt8 sCellActCe; /*!< SCell Act CE info */
#endif
} RgBldPduInfo;
/* APIs exposed by LIM */
#ifdef LTE_L2_MEAS /*LTE_L2_MEAS_PHASE2*/
-EXTERN S16 rgAddToL2MeasPerQci ARGS ((RgCellCb *cell,U8 qci));
+EXTERN S16 rgAddToL2MeasPerQci ARGS ((RgCellCb *cell,uint8_t qci));
#endif
EXTERN S16 rgLIMTfuBndReq ARGS((
Inst inst,
/*
* APIs exposed by LMM
*/
-EXTERN S16 rgLMMStartTmr ARGS((Inst inst,S16 tmrEvnt, U32 tmrVal, PTR cb));
+EXTERN S16 rgLMMStartTmr ARGS((Inst inst,S16 tmrEvnt, uint32_t tmrVal, PTR cb));
EXTERN S16 rgLMMStopTmr ARGS((Inst inst,S16 tmrEvnt, PTR cb));
EXTERN S16 rgLMMTmrExpiry ARGS((PTR cb, S16 tmrEvnt));
/* To send a Unsolicited Status Indication to Layer Manager */
-EXTERN S16 rgLMMStaInd ARGS((Inst inst,U16 category, U16 event, U16 cause, RgUstaDgn *dgn));
+EXTERN S16 rgLMMStaInd ARGS((Inst inst,uint16_t category, uint16_t event, uint16_t cause, RgUstaDgn *dgn));
/* To send a Trace Indication to Layer Manager.
* srcMbuf is not freed. caller has to take care. */
-EXTERN Void rgLMMTrcInd ARGS((Inst inst,Buffer *srcMbuf, U8 event));
+EXTERN Void rgLMMTrcInd ARGS((Inst inst,Buffer *srcMbuf, uint8_t event));
/* LIM uses this to forward the BndCfm to LMM. This function invokes a
* Control Confirmation to the LM. */
-EXTERN S16 rgLMMBndCfm ARGS((Pst *pst, SuId suId, U8 status));
+EXTERN S16 rgLMMBndCfm ARGS((Pst *pst, SuId suId, uint8_t status));
EXTERN S16 rgActvTmr ARGS((Ent ent, Inst inst ));
EXTERN S16 rgActvInit ARGS((Ent entity, Inst inst, Region
region, Reason reason));
*cfgReqInfo));
/* APIs Exposed by UIM */
-EXTERN S16 rgUIMRguBndCfm ARGS ((Inst inst,SuId suId, U8 status));
+EXTERN S16 rgUIMRguBndCfm ARGS ((Inst inst,SuId suId, uint8_t status));
EXTERN S16 rgUIMSndDedStaInd ARGS ((Inst inst,RgUpSapCb *rguDlSap,RgRguDedStaInd *staInd));
EXTERN S16 rgUIMSndCmnStaInd ARGS ((Inst inst,RgUpSapCb *rguDlSap,RgRguCmnStaInd *staInd));
EXTERN S16 rgUIMSndDedDatInd ARGS ((Inst inst,RgUpSapCb *rguDlSap,RgRguDedDatInd *datInd));
EXTERN S16 rgL2mCreateMeasCb ARGS((
RgCellCb *cell,
RgInfL2MeasReq *measInfo,
- U8 measType,
+ uint8_t measType,
RgErrInfo *err
));
EXTERN S16 rgL2mMeasReq ARGS((
));
#endif /* LTE_L2_MEAS */
EXTERN S16 rgUIMSndCmnDatInd ARGS ((Inst inst,RgUpSapCb *rguSap,RgRguCmnDatInd *datInd));
-EXTERN S16 rgUIMCrgBndCfm ARGS ((Inst inst,SuId suId,U8 status));
-EXTERN S16 rgUIMCrgCfgCfm ARGS ((Inst inst,CrgCfgTransId transId,U8 status));
+EXTERN S16 rgUIMCrgBndCfm ARGS ((Inst inst,SuId suId,uint8_t status));
+EXTERN S16 rgUIMCrgCfgCfm ARGS ((Inst inst,CrgCfgTransId transId,uint8_t status));
/*
((
Inst inst,
Buffer *mBuf,
-U16 *sduLen,
+uint16_t *sduLen,
RgErrInfo *err
));
* APIs exposed by DBM module
*/
-EXTERN S16 rgDBMInitInactvCellLst ARGS((U16 numBins));
+EXTERN S16 rgDBMInitInactvCellLst ARGS((uint16_t numBins));
EXTERN S16 rgDBMDeInitInactvCellLst ARGS((Void));
EXTERN S16 rgDBMInsInactvCellCb ARGS(( RgCellCb *cellCb));
EXTERN RgCellCb* rgDBMGetInactvCellCb ARGS(( CmLteCellId cellId));
EXTERN S16 rgDBMDelInactvCellCb ARGS(( RgCellCb *cellCb));
EXTERN RgCellCb* rgDBMGetNextInactvCellCb ARGS((RgCellCb *cellCb));
-EXTERN S16 rgDBMInitCellLst ARGS(( U16 numBins));
+EXTERN S16 rgDBMInitCellLst ARGS(( uint16_t numBins));
EXTERN S16 rgDBMDeInitCellLst ARGS((Void));
EXTERN S16 rgDBMInsCellCb ARGS(( RgCellCb *cellCb));
EXTERN RgCellCb* rgDBMGetCellCb ARGS(( CmLteCellId cellId));
#ifdef LTE_L2_MEAS
EXTERN Void rgDBMInsUlDedLcCb ARGS((RgUeCb *ueCb, CmLteLcId idx, LteLcgId gId,
- U8 qci));
+ uint8_t qci));
#else
EXTERN Void rgDBMInsUlDedLcCb ARGS((RgUeCb *ueCb,
CmLteLcId idx, LteLcgId gId));
* APIs exposed by DHM module
*/
EXTERN Void rgCFGFreeUeCb ARGS((RgCellCb *cell, RgUeCb *ue));
-EXTERN S16 rgDHMHqEntInit ARGS((Inst inst,RgDlHqEnt *hqE, U8 maxHqProcs));
+EXTERN S16 rgDHMHqEntInit ARGS((Inst inst,RgDlHqEnt *hqE, uint8_t maxHqProcs));
EXTERN Void rgDHMRlsHqProc ARGS((RgDlHqProcCb *hqP));
EXTERN Void rgDHMUeReset ARGS ((RgCellCb *cell, RgDlHqEnt *hqE));
EXTERN Void rgDHMHdlBufFree ARGS((Inst inst, Buffer **mBuf));
EXTERN Void rgDHMFreeTbBufs ARGS((Inst inst));
-EXTERN S16 rgDHMRlsHqProcTB ARGS((RgCellCb *cell, RgDlHqProcCb *hqP,U8 tbIndex));
-EXTERN S16 rgDHMGetHqProcFrmId ARGS((RgUeCb *ue, U8 idx, RgDlHqProcCb **hqP));
+EXTERN S16 rgDHMRlsHqProcTB ARGS((RgCellCb *cell, RgDlHqProcCb *hqP,uint8_t tbIndex));
+EXTERN S16 rgDHMGetHqProcFrmId ARGS((RgUeCb *ue, uint8_t idx, RgDlHqProcCb **hqP));
/* Changes for MIMO feature addition */
/* Removed dependency on MIMO compile-time flag */
EXTERN S16 rgDHMSndDatReq ARGS((RgCellCb *cellCb, RgDlSf *dlSf, RgTfuDatReqInfo *datInfo,
/*ccpu00117052 - MOD Passing double pointer for proper NULLP
assignment */
EXTERN Void rgFreeSBuf ARGS((Inst inst,Data **data, Size size));
-EXTERN Void rgFillDgnParams ARGS((Inst inst,RgUstaDgn *dgn,U8 dgnType));
-EXTERN Void rgUpdtRguDedSts ARGS((Inst inst,RgUpSapCb *rguSap,U8 stsType, RgRguDedDatReq *datReq));
-EXTERN Void rgUpdtRguCmnSts ARGS((Inst inst,RgUpSapCb *rguSap,U8 stsType));
-EXTERN Void rgUpdtCellCnt ARGS((Inst inst,U8 updtType));
-EXTERN Void rgUpdtUeCnt ARGS((Inst inst,U8 updtType));
+EXTERN Void rgFillDgnParams ARGS((Inst inst,RgUstaDgn *dgn,uint8_t dgnType));
+EXTERN Void rgUpdtRguDedSts ARGS((Inst inst,RgUpSapCb *rguSap,uint8_t stsType, RgRguDedDatReq *datReq));
+EXTERN Void rgUpdtRguCmnSts ARGS((Inst inst,RgUpSapCb *rguSap,uint8_t stsType));
+EXTERN Void rgUpdtCellCnt ARGS((Inst inst,uint8_t updtType));
+EXTERN Void rgUpdtUeCnt ARGS((Inst inst,uint8_t updtType));
EXTERN Void rgGetPstToInst ARGS((Pst *pst,Inst srcInst, Inst dstInst));
EXTERN S16 rgAllocEventMem ARGS((Inst inst,Ptr *memPtr,Size memSize));
EXTERN S16 rgGetEventMem ARGS((Inst inst,Ptr *ptr,Size len,Ptr memCp));
Bool isRar,
RgErrInfo *err
));
-EXTERN U16 rgMUXCalcRiv ARGS
+EXTERN uint16_t rgMUXCalcRiv ARGS
((
-U8 bw,
-U8 rbStart,
-U8 numRb
+uint8_t bw,
+uint8_t rbStart,
+uint8_t numRb
));
#ifdef ANSI
S16 rgCFGVldtCrgUeReset
(
-Inst inst,
-CrgRst *reset,
+Inst inst,
+CrgRst *reset,
RgCellCb **cell,
RgUeCb **ue,
RgErrInfo *errInfo
)
#else
S16 rgCFGVldtCrgUeReset(inst,reset, cell, ue, errInfo)
-Inst inst;
-CrgRst *reset;
+Inst inst;
+CrgRst *reset;
RgCellCb **cell;
RgUeCb **ue;
RgErrInfo *errInfo;
{
S16 ret;
RgCellCb *cell = NULLP;
- U8 idx;
+ uint8_t idx;
SuId rguUlSapId = 0;
SuId rguDlSapId = 0;
/* RLC SAP to allocate flowCntrlInd buffer*/
memset(&cell->ulSf[idx], 0, sizeof(RgUlSf));
}
- cell->ttiCycle = (U32)RG_TTI_CYCLE_INVLD;
+ cell->ttiCycle = (uint32_t)RG_TTI_CYCLE_INVLD;
#endif
/* Update Statistics */
rgUpdtCellCnt(inst,RG_CFG_ADD);
RgUeCb *ueCb = NULLP;
SuId rguUlSapId = 0;
SuId rguDlSapId = 0;
- U8 idx;
+ uint8_t idx;
RgErrInfo errInfo;
#ifdef LTE_ADV
#endif
{
RgUeCb *ue = NULLP;
- U8 idx = 0;
+ uint8_t idx = 0;
Inst dstMacInst;
RgPrgUeSCellCfgInfo ueSCellCb;
Pst dstInstPst;
(
RgCellCb *cell,
RgUeCb *ue,
-CrgRst *reset,
+CrgRst *reset,
RgErrInfo *errInfo
)
#else
S16 rgCFGCrgUeReset(cell, ue, reset, errInfo)
RgCellCb *cell;
RgUeCb *ue;
-CrgRst *reset;
+CrgRst *reset;
RgErrInfo *errInfo;
#endif
{
RgErrInfo *errInfo;
#endif
{
- RgCellCb *cell;
- U8 idx;
+ RgCellCb *cell;
+ uint8_t idx;
errInfo->errCause = RGERR_CFG_CRG_CELL_DEL;
RgErrInfo *errInfo;
#endif
{
- U8 dirVld = FALSE;
+ uint8_t dirVld = FALSE;
errInfo->errCause = RGERR_CFG_INVALID_CRG_DED_LC_CFG;
RgErrInfo *errInfo;
#endif
{
- U8 dirVld = FALSE;
+ uint8_t dirVld = FALSE;
errInfo->errCause = RGERR_CFG_INVALID_CRG_CMN_LC_CFG;
RgCellCb *cell;
#endif
{
- U8 sfIdx;
+ uint8_t sfIdx;
Inst inst = cell->macInst - RG_INST_START;
for(sfIdx = 0; sfIdx < RG_NUM_UL_SUB_FRAMES; sfIdx++)
RGDBGINFO(inst,(rgPBuf(inst), "Cell freed\n"));
/* Stack Crash Problem for TRACE5 Changes. Added return below */
- RETVOID;
+ return;
} /* rgCFGFreeCellCb */
/* Stack Crash Problem for TRACE5 Changes. Added return below */
- RETVOID;
+ return;
} /* rgCFGFreeInactvCellCb */
/* Stack Crash Problem for TRACE5 Changes. Added return below */
- RETVOID;
+ return;
} /* rgCFGFreeUeCb */
/***********************************************************
/* Stack Crash Problem for TRACE5 Changes. Added return below */
- RETVOID;
+ return;
} /* rgCFGFreeCmnLcLst */
/* Stack Crash Problem for TRACE5 Changes. Added return below */
- RETVOID;
+ return;
} /* rgCFGFreeUeLst */
#ifdef LTEMAC_SPS
/*Added Ue for Onging L2 Meas*/
#ifdef LTE_L2_MEAS
/*LTE_L2_MEAS_PHASE2*/
-S16 rgAddToL2MeasPerQci(RgCellCb *cell,U8 qci)
+S16 rgAddToL2MeasPerQci(RgCellCb *cell,uint8_t qci)
{
- S16 ret = ROK;
- CmLList *lnk;
- RgL2MeasCb *measCb;
- U16 idx;
+ S16 ret = ROK;
+ CmLList *lnk;
+ RgL2MeasCb *measCb;
+ uint16_t idx;
lnk = cell->l2mList.first;
while(lnk != NULLP )
#endif
{
S16 ret;
- U8 cfmStatus = CRG_CFG_CFM_OK;
+ uint8_t cfmStatus = CRG_CFG_CFM_OK;
RgErrInfo errInfo;
Bool isCfmRqrd = TRUE;
{
S16 ret;
- VOLATILE U32 startTime=0;
+ VOLATILE uint32_t startTime=0;
errInfo->errType = RGERR_COM_DEL_REQ;
#include "rg.x"
/* local defines */
-PRIVATE S16 rgDBMInitUeCbLst ARGS(( RgCellCb *cellCb, U16 numBins));
+PRIVATE S16 rgDBMInitUeCbLst ARGS(( RgCellCb *cellCb, uint16_t numBins));
PRIVATE Void rgDBMInitDedLcLst ARGS((RgUeCb *ueCb));
PRIVATE Void rgDBMInitCmnLcLst ARGS((RgCellCb *cellCb));
PRIVATE Void rgDBMInitRachLst ARGS((RgCellCb *cellCb));
#ifdef LTEMAC_SPS
PRIVATE S16 rgDBMInitSpsUeCbLst ARGS((
RgCellCb *cellCb,
-U16 numBins
+uint16_t numBins
));
#endif
PRIVATE S16 rgDBMInitUeCbLst
(
RgCellCb *cellCb,
-U16 numBins
+uint16_t numBins
)
#else
PRIVATE S16 rgDBMInitUeCbLst(cellCb, numBins)
RgCellCb *cellCb;
-U16 numBins;
+uint16_t numBins;
#endif
{
Inst inst = cellCb->macInst - RG_INST_START;
RgUeCb ue;
- return (cmHashListInit(&cellCb->ueLst, numBins, (U16)((PTR)&(ue.ueLstEnt) - (PTR)&ue), FALSE,
+ return (cmHashListInit(&cellCb->ueLst, numBins, (uint16_t)((PTR)&(ue.ueLstEnt) - (PTR)&ue), FALSE,
CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
} /* rgDBMInitUeCbLst */
PRIVATE S16 rgDBMInitSpsUeCbLst
(
RgCellCb *cellCb,
-U16 numBins
+uint16_t numBins
)
#else
PRIVATE S16 rgDBMInitSpsUeCbLst(cellCb, numBins)
RgCellCb *cellCb;
-U16 numBins;
+uint16_t numBins;
#endif
{
Inst inst = cellCb->macInst - RG_INST_START;
RgUeCb ue;
- return (cmHashListInit(&cellCb->spsUeLst, numBins, (U16) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
+ return (cmHashListInit(&cellCb->spsUeLst, numBins, (uint16_t) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
} /* rgDBMInitSpsUeCbLst */
#endif
{
return (cmHashListInsert(&cellCb->ueLst, (PTR)ueCb,
- (U8 *)&ueCb->ueId, (U16)sizeof(ueCb->ueId)));
+ (uint8_t *)&ueCb->ueId, (uint16_t)sizeof(ueCb->ueId)));
} /* rgDBMInsUeCb */
{
return (cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
- (U8 *)&ueCb->spsRnti, (U16)sizeof(ueCb->spsRnti)));
+ (uint8_t *)&ueCb->spsRnti, (uint16_t)sizeof(ueCb->spsRnti)));
} /* end of rgDBMInsSpsUeCb */
{
RgUeCb *ueCb = NULLP;
- cmHashListFind(&cellCb->ueLst, (U8 *)&ueId,
+ cmHashListFind(&cellCb->ueLst, (uint8_t *)&ueId,
sizeof(ueId), 0, (PTR *)&ueCb);
return (ueCb);
} /* rgDBMGetUeCb */
{
RgUeCb *ueCb = NULLP;
- cmHashListFind(&cellCb->spsUeLst, (U8 *)&spsRnti,
+ cmHashListFind(&cellCb->spsUeLst, (uint8_t *)&spsRnti,
sizeof(spsRnti), 0, (PTR *)&ueCb);
return (ueCb);
} /* rgDBMGetSpsUeCb */
#endif
{
#ifdef LTEMAC_SPS
- U8 idx;
+ uint8_t idx;
#endif
/* Initialize Dedicated logical channels */
#endif
- RETVOID;
+ return;
} /* rgDBMInitUe */
/**
RgUeCb *ueCb;
#endif
{
- U8 idx;
+ uint8_t idx;
for (idx = 0; idx < RG_MAX_LC_PER_UE; ++idx)
{
}
/* Stack Crash problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgDBMInitDedLcLst */
/**
RgCellCb *cellCb;
#endif
{
- U8 idx;
+ uint8_t idx;
cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
}
/* Stack Crash problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgDBMInitCmnLcLst */
/**
RgCellCb *cellCb;
#endif
{
- U8 idx;
+ uint8_t idx;
cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
cellCb->numBcchDlschInfo = 0;
/* Stack Crash problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgDBMFreeCmnLcLst */
/**
ueCb->dl.lcCb[idx-1].lcId = idx;
}
/* Stack Crash problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgDBMInsDlDedLcCb */
/**
ueCb->dl.lcCb[dlLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
/* Stack Crash problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgDBMDelDlDedLcCb */
RgUeCb *ueCb,
CmLteLcId idx,
LteLcgId gId,
-U8 qci
+uint8_t qci
)
#else
Void rgDBMInsUlDedLcCb(ueCb, idx, gId, qci)
RgUeCb *ueCb;
CmLteLcId idx;
LteLcgId gId;
-U8 qci;
+uint8_t qci;
#endif
#else
#ifdef ANSI
/* Stack Crash problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgDBMInsUlDedLcCb */
ueCb->ul.lcgArr[gId].lcCount = ueCb->ul.lcgArr[gId].lcCount + 1;
/* Stack Crash problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgDBMUpdUlDedLcCb */
/**
ueCb->ul.lcCb[ulLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
/* Stack Crash problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgDBMDelUlDedLcCb */
/**
CmLteLcId lcId;
#endif
{
- U8 idx;
+ uint8_t idx;
if(cellCb->bcchBchInfo.lcId == lcId)
{
CmLteLcId lcId;
#endif
{
- U8 idx;
+ uint8_t idx;
for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
{
cellCb->bcchBchInfo.lcId = idx;
/* Stack Crash problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgDBMInsBcchOnBch */
/**
cellCb->numBcchDlschInfo++;
/* Stack Crash problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgDBMInsBcchOnDlsch */
cellCb->pcchInfo.lcId = idx;
/* Stack Crash problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgDBMInsPcch */
/**
{
cmLListInit(&cellCb->raInfo.ueRachLst);
- RETVOID;
+ return;
} /* rgDBMInitRachLst */
/**
cmLListAdd2Tail(&cellCb->raInfo.ueRachLst,&ueCb->rachLstEnt);
- RETVOID;
+ return;
} /* rgDBMInsUeCbInRachLst */
/**
{
cmLListDelFrm(&cellCb->raInfo.ueRachLst, &ueCb->rachLstEnt);
- RETVOID;
+ return;
} /* rgDBMDelUeCbFromRachLst */
/**********************************************************************
S16 rgDHMFreeHqProcTB
(
RgDlHqProcCb *hqP,
-U8 tbIndex
+uint8_t tbIndex
);
#endif
(
Inst inst,
RgDlHqEnt *hqE,
-U8 maxHqProcs
+uint8_t maxHqProcs
)
#else
S16 rgDHMHqEntInit(inst,hqE, maxHqProcs)
Inst inst,
RgDlHqEnt *hqE;
-U8 maxHqProcs;
+uint8_t maxHqProcs;
#endif
{
- U8 idx1,idx2;
+ uint8_t idx1,idx2;
#ifdef L2_OPTMZ
Buffer *hdrDBuf = NULLP;
Buffer *ceDBuf = NULLP;
RgDlHqEnt *hqE;
#endif
{
- U8 i = 0;
+ uint8_t i = 0;
if(hqE->procs[0])
{
#endif
}
}
- RETVOID;
+ return;
} /* rgDHMUeReset*/
/**
{
RG_FREE_MSG(*mBuf);
}
- RETVOID;
+ return;
}
/**
* @brief This function is called to release the
#endif
{
RgCb *rgCbP = &rgCb[inst];
- U8 start = rgCbP->bufCnt;
- U8 end = 0;
+ uint8_t start = rgCbP->bufCnt;
+ uint8_t end = 0;
if (rgCbP->bufCnt < RG_MAX_FREE_BUFS_PERTTI)
{
SPutMsg(rgCbP->bufToFree[start]);
}
rgCbP->bufCnt = end;
- RETVOID;
+ return;
} /* rgDHMFreeTbBufs */
#ifdef ANSI
#endif
{
RgCb *rgCbP = &rgCb[inst];
- U8 start = rgCbP->bufCnt;
- U8 end = 0;
+ uint8_t start = rgCbP->bufCnt;
+ uint8_t end = 0;
while (start != end)
{
SPutMsg(rgCbP->bufToFree[start]);
}
rgCbP->bufCnt = end;
- RETVOID;
+ return;
} /* rgDHMFreeTbBufs */
(
RgCellCb *cell,
RgDlHqProcCb *hqP,
-U8 tbIndex
+uint8_t tbIndex
)
#else
S16 rgDHMRlsHqProcTB(cell, hqP, tbIndex)
RgCellCb *cell;
RgDlHqProcCb *hqP;
-U8 tbIndex;
+uint8_t tbIndex;
#endif
{
- U8 idx;
+ uint8_t idx;
#ifdef L2_OPTMZ
RgTfuDatReqTbInfo *tb; /* TB to be sent to CL/PHY*/
- // U32 lchIdx, pduIdx;
+ // uint32_t lchIdx, pduIdx;
#endif
if((tbIndex > RG_MAX_TB_PER_UE) ||
* Invoked by: ROM
*
* @param[in] RgUeCb *ue
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @param[in] RgDlHqProc **hqP
* @return S16
* -# ROK if successful
S16 rgDHMGetHqProcFrmId
(
RgUeCb *ue,
-U8 idx,
+uint8_t idx,
RgDlHqProcCb **hqP
)
#else
S16 rgDHMGetHqProcFrmId(ue, idx, hqP)
RgUeCb *ue;
-U8 idx;
+uint8_t idx;
RgDlHqProcCb **hqP;
#endif
{
return ROK;
} /* rgDHMGetHqProcFrmId */
-/*PRIVATE U32 dataAvl; */
+/*PRIVATE uint32_t dataAvl; */
/**
* @brief Handler for sending data to PHY
*
RgErrInfo *err;
#endif
{
- U8 i;
- Inst inst = cellCb->macInst - RG_INST_START;
+ uint8_t i;
+ Inst inst = cellCb->macInst - RG_INST_START;
RgTfuDatReqPduInfo *datReq;
RgBldPduInfo bldPdu;
/*Added this variable to figure out that whether this UE data
RgErrInfo *err;
#endif
{
-// U32 len;
- U8 i;
- U8 j;
+// uint32_t len;
+ uint8_t i;
+ uint8_t j;
RgBldPduInfo bldPdu;
- U8 tbIndex;
+ uint8_t tbIndex;
#ifdef L2_OPTMZ
RgTfuDatReqTbInfo *tb;
#endif
- tbIndex = (U8)(datReq->transId & 0x03);
+
+ tbIndex = (uint8_t)(datReq->transId & 0x03);
/* Accept all the data requests even if delayed in case nothing
* has been sent earlier on the harq proc.
*/
{
j++;
}
- rgDHMRlsHqProcTB(rgCb[inst].cell, hqProc, (U8)(j+1));
+ rgDHMRlsHqProcTB(rgCb[inst].cell, hqProc, (uint8_t)(j+1));
}
return RFAILED;
}
{
j++;
}
- rgDHMRlsHqProcTB(rgCb[inst].cell, hqProc, (U8)(j+1));
+ rgDHMRlsHqProcTB(rgCb[inst].cell, hqProc, (uint8_t)(j+1));
printf("\nrgDHMHndlDedDatReq:: hqP %p \n", (Void *)hqProc);
}
return RFAILED;
{
j++;
}
- rgDHMRlsHqProcTB(rgCb[inst].cell, hqProc, (U8)(j+1));
+ rgDHMRlsHqProcTB(rgCb[inst].cell, hqProc, (uint8_t)(j+1));
}
return RFAILED;
}
#endif
{
SuId rguDlSpId;/*need to use spID instead of suID*/
- U8 idx;
- U8 ueIdx;
- U8 lcIdx;
- U8 tbIndex=0,idx1;
+ uint8_t idx;
+ uint8_t ueIdx;
+ uint8_t lcIdx;
+ uint8_t tbIndex=0,idx1;
RgDlSf *dlSf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
Inst inst = cell->macInst - RG_INST_START;
// Bool isDStaReqrd = FALSE;
RgUeCb *ue;
RgDlHqProcCb *hqP;
RgInfUeAlloc *allocInfo;
- U8 activeSapCnt = 0;
- U8 staIndCnt = 0;
+ uint8_t activeSapCnt = 0;
+ uint8_t staIndCnt = 0;
#ifdef LTE_ADV
Bool hqPAdded = FALSE;
#endif
* @return Void
* None
**/
-//U8 crashFlag = 0;
+//uint8_t crashFlag = 0;
#ifdef ANSI
PRIVATE Void rgDHMBldTfuDatReq
(
#endif
#endif
- U8 i;
+ uint8_t i;
#ifdef L2_OPTMZ
- U32 lchIdx, pduIdx;
+ uint32_t lchIdx, pduIdx;
#endif
datReq->nmbOfTBs = 0;
datReq->nmbOfTBs++;
}
}
- RETVOID;
+ return;
} /* rgDHMBldTfuDatReq */
S16 rgDHMFreeHqProcTB
(
RgDlHqProcCb *hqP,
-U8 tbIndex
+uint8_t tbIndex
)
#else
S16 rgDHMFreeHqProcTB(hqP, tbIndex)
RgDlHqProcCb *hqP;
-U8 tbIndex;
+uint8_t tbIndex;
#endif
{
RgTfuDatReqTbInfo *tb; /* TB to be sent to CL/PHY*/
- U8 idx;
+ uint8_t idx;
if((tbIndex > RG_MAX_TB_PER_UE) ||
(tbIndex == 0))
RgDlHqEnt *hqE;
#endif
{
- U8 i;
+ uint8_t i;
if(hqE->procs)
{
assignment */
}
- RETVOID;
+ return;
} /* rgDHMFreeUe */
/**
return ROK;
}
-U32 gSaveVal;
+uint32_t gSaveVal;
\f
/**
* @brief Function for handling RaResp request received from scheduler to MAC
RgCellCb *cell = NULLP;
RgUeCb *ue;
RgDlHqProcCb *hqP;
- U8 idx1,idx2;
+ uint8_t idx1,idx2;
#ifdef LTE_L2_MEAS
- U8 tbId;
+ uint8_t tbId;
RguHarqStatusInd hqStaInd;
Bool isValidTbId = FALSE;
#endif
- U32 startTime=0;
+ uint32_t startTime=0;
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
_ret = SRemPreMsgMult(_unpkArray, (MsgLen) 2, _mBuf);\
if (_ret == ROK)\
{\
- *_rnti = (U16) PutHiByte(*_rnti, (U8) _unpkArray[0]);\
- *_rnti = (U16) PutLoByte(*_rnti, (U8) _unpkArray[1]);\
+ *_rnti = (uint16_t) PutHiByte(*_rnti, (uint8_t) _unpkArray[0]);\
+ *_rnti = (uint16_t) PutLoByte(*_rnti, (uint8_t) _unpkArray[1]);\
}\
}
Inst inst,
RgMacPdu *pdu,
RgMacSdu **sdu,
-U8 lcId,
-U16 sduLen,
+uint8_t lcId,
+uint16_t sduLen,
RgErrInfo *err
)
#else
Inst inst;
RgMacPdu *pdu;
RgMacSdu **sdu,
-U8 lcId;
-U16 sduLen;
+uint8_t lcId;
+uint16_t sduLen;
RgErrInfo *err;
#endif
{
Inst inst,
RgMacPdu *pdu,
Buffer *mBuf,
-U8 *lcId,
-U16 *len,
+uint8_t *lcId,
+uint16_t *len,
RgErrInfo *err
)
#else
Inst inst;
RgMacPdu *pdu;
Buffer *mBuf;
-U8 *lcId;
-U16 *len;
+uint8_t *lcId;
+uint16_t *len;
RgErrInfo *err;
#endif
{
- U8 byte;
- U8 fmt=0;
+ uint8_t byte;
+ uint8_t fmt=0;
*len = 0;
(
Inst inst,
RgMacPdu *pdu,
-RgInfCeInfo *ceInfo,
-Buffer *mBuf,
-U8 lcId,
-U16 subPduLen,
-RgErrInfo *err
+RgInfCeInfo *ceInfo,
+Buffer *mBuf,
+uint8_t lcId,
+uint16_t subPduLen,
+RgErrInfo *err
)
#else
PRIVATE S16 rgDUXExtCe(inst,pdu, ceInfo, mBuf,lcId,subPduLen, err)
Inst inst;
RgMacPdu *pdu;
-RgInfCeInfo *ceInfo;
-Buffer *mBuf;
-U8 lcId;
-U16 subPduLen;
-RgErrInfo *err;
+RgInfCeInfo *ceInfo;
+Buffer *mBuf;
+uint8_t lcId;
+uint16_t subPduLen;
+RgErrInfo *err;
#endif
{
S16 ret;
{
case RG_EXT_PHR_LCID:
{
- U8 Ci;
- U8 sCellIdx;
- U8 extPhrOctet;
- U8 extPhrPCmax;
+ uint8_t Ci;
+ uint8_t sCellIdx;
+ uint8_t extPhrOctet;
+ uint8_t extPhrPCmax;
RgInfExtPhrCEInfo *extPhr;
RG_UNPACK_EXT_PHR_CI(&Ci,mBuf,ret);
break;
case RG_LONG_BSR_LCID:
{
- U8 longBsr[3] = {0}; /* KW_FIXX */
+ uint8_t longBsr[3] = {0}; /* KW_FIXX */
RG_UNPACK_LONG_BSR(longBsr,mBuf,ret);
if(ret != ROK)
{
(
Inst inst,
RgMacPdu *pdu,
-RgInfCeInfo *ceInfo,
+RgInfCeInfo *ceInfo,
Buffer **mBuf,
-U8 lcId,
-U16 subPduLen,
+uint8_t lcId,
+uint16_t subPduLen,
RgErrInfo *err
)
#else
PRIVATE S16 rgDUXExtSdu(inst,pdu, ceInfo,mBuf,lcId,subPduLen,err)
Inst inst;
RgMacPdu *pdu;
-RgInfCeInfo *ceInfo;
+RgInfCeInfo *ceInfo;
Buffer **mBuf;
-U8 lcId;
-U16 subPduLen;
+uint8_t lcId;
+uint16_t subPduLen;
RgErrInfo *err;
#endif
{
RgErrInfo *err;
#endif
{
- U8 lcId;
- U16 subPduLen;
+ uint8_t lcId;
+ uint16_t subPduLen;
MsgLen len;
ceInfo->bitMask = 0x0000;
/* per 1024 REs. */
#endif
-//EXTERN U32 wrSmDfltNumCells;
+//EXTERN uint32_t wrSmDfltNumCells;
#define RGSCH_MAX_UE_PER_DL_SF 32
#define RGSCH_MAX_RARNTI_PER_DL_SF 4
#define SCH_INST_START 1
memcpy(s->ptNmb, sId.ptNmb, LRG_MAX_PT_NUM_SIZE);
/* Stack Crash Problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* end of rgGetSid */
*
* @param [in] RgCellCb *cell
* @param [in] RgInfL2MeasReq *measInfo
- * @param [in] U8 measType
+ * @param [in] uint8_t measType
* @param [out] RgErrInfo *err
* @return S16
* -# ROK
(
RgCellCb *cell,
RgInfL2MeasReq *measInfo,
-U8 measType,
+uint8_t measType,
RgErrInfo *err
)
#else
S16 rgL2mCreateMeasCb(cell, measInfo, measType, err)
RgCellCb *cell;
RgInfL2MeasReq *measInfo;
-U8 measType;
+uint8_t measType;
RgErrInfo *err;
#endif
{
// Inst inst = cell->macInst - RG_INST_START;
- U32 idx;
- RgL2MeasCb *measCb = NULLP;
- U8 qciVal = 0;
+ uint32_t idx;
+ RgL2MeasCb *measCb = NULLP;
+ uint8_t qciVal = 0;
UNUSED(measType);
UNUSED(err);
return RFAILED;
}
//Memcpy is already done in rgL2mAllocMeasCb
- /*memcpy(&measCb->measReq, (CONSTANT U8 *)measInfo,\
+ /*memcpy(&measCb->measReq, (CONSTANT uint8_t *)measInfo,\
sizeof(RgInfL2MeasReq));*/
rgL2mInsertMeasCb(cell, measCb, measInfo);
measCb->measReq.timePrd = measInfo->timePrd;
rgGetPstToInst(&pst,macInst, cell->schInstMap.schInst);
RgMacSchL2Meas(&pst, measCfm);
- RETVOID;
+ return;
}/* rgSndL2MeasCfm */
/** @brief This function sends the measurement stop confirm
rgGetPstToInst(&pst,macInst, cell->schInstMap.schInst);
RgMacSchL2MeasStop(&pst, measCfm);
- RETVOID;
+ return;
}/* rgSndL2MeasStopCfm */
/**
RgInfL2MeasStopReq *measInfo; /* Meas Req Info */
#endif
{
- S16 ret = ROK;
- CmLList *node = NULLP;
- RgL2MeasCb *measCb = NULLP;
- U8 idx;
- U8 qciVal;
- Inst inst;
- RgCellCb *cellCb = NULLP;
-
+ S16 ret = ROK;
+ CmLList *node = NULLP;
+ RgL2MeasCb *measCb = NULLP;
+ uint8_t idx;
+ uint8_t qciVal;
+ Inst inst;
+ RgCellCb *cellCb = NULLP;
RgInfL2MeasCfm measCfm;
RG_IS_INST_VALID(pst->dstInst);
RgInfL2MeasReq *measInfo;
#endif
{
- CmLList *lnk, *node;
- RgL2MeasCb *oldMeasCb;
- U16 diffTime;
+ CmLList *lnk, *node;
+ RgL2MeasCb *oldMeasCb;
+ uint16_t diffTime;
/*
* 1. Check if l2mList has any entries.
{
CmLList *node = NULLP;
RgL2MeasCb *measCb = NULLP;
- RgInfL2MeasCfm measCfm;
- U8 idx = 0;
- U8 qciVal = 0;
- U32 measPrd; /*LTE_L2_MEAS_PHASE2*/
+ RgInfL2MeasCfm measCfm;
+ uint8_t idx = 0;
+ uint8_t qciVal = 0;
+ uint32_t measPrd; /*LTE_L2_MEAS_PHASE2*/
CmLteTimingInfo crntTime;
- Inst inst = cell->macInst - RG_INST_START;
+ Inst inst = cell->macInst - RG_INST_START;
node = cell->l2mList.first;
*
* @param[in] Pst *pst
* @param[in] SuId suId
- * @param[in] U8 status
+ * @param[in] uint8_t status
* @return S16
* -# ROK
* -# RFAILED
(
Pst *pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 RgLiTfuBndCfm(pst, suId, status)
Pst *pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
Inst inst;
}
}
RG_FREE_MEM(datInd);
- RETVOID;
+ return;
} /* end of rgLIMUtlFreeDatIndEvnt*/
/**
{
Inst inst;
S16 ret;
- VOLATILE U32 startTime=0;
+ VOLATILE uint32_t startTime=0;
// printf("5GTF:: DatindRcvd\n");
TfuDatReqPduInfo *datInfo;
CmLList *node;
- U8 i;
+ uint8_t i;
/* Steps of freeing up the TfuDatReq.
* 1. Free the bch buffer.
}
}
RG_FREE_MEM(datReq);
- RETVOID;
+ return;
} /* end of rgLIMUtlFreeDatReqEvnt*/
#endif
/**
extern MacCb macCb;
/* forward references */
-PRIVATE U16 rgLMMGenCfg ARGS((
+PRIVATE uint16_t rgLMMGenCfg ARGS((
Inst inst,
RgCfg *cfg
));
-PRIVATE U16 rgLMMSapCfg ARGS((
+PRIVATE uint16_t rgLMMSapCfg ARGS((
Inst inst,
RgCfg *cfg,
Elmnt sapType
#ifdef DEBUGP
#ifdef RG_DEBUG
/* disabling debugs by default */
- rgCb[macInst].rgInit.dbgMask = 0xffffffff;
+ rgCb[macInst].rgInit.dbgMask = 0xffffffff;
#endif
#endif /* DEBUGP */
#ifdef SS_DIAG
RgMngmt *cfg; /* config structure */
#endif
{
- U16 ret = LCM_PRIM_OK;
- U16 reason = LCM_REASON_NOT_APPL;
+ uint16_t ret = LCM_PRIM_OK;
+ uint16_t reason = LCM_REASON_NOT_APPL;
RgMngmt cfm;
Pst cfmPst;
Inst inst;
- RG_DIAG_LVL0(inst,0x0a0b0001, RG_DIAG_NA, SS_DIAG_INV_ARG,
- "Received CfgReq for MAC layer, Entity = %d, Instance = %d\n",
- pst->srcEnt, pst->srcInst,0,0);
+
+ RG_DIAG_LVL0(inst,0x0a0b0001, RG_DIAG_NA, SS_DIAG_INV_ARG,\
+ "Received CfgReq for MAC layer, Entity = %d, Instance = %d\n", pst->srcEnt, pst->srcInst,0,0);
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
switch(cfg->hdr.elmId.elmnt)
{
case STGEN:
- reason = rgLMMGenCfg(inst,&cfg->t.cfg);
- break;
+ reason = rgLMMGenCfg(inst,&cfg->t.cfg);
+ break;
case STRGUSAP:
case STCRGSAP:
case STTFUSAP:
- reason = rgLMMSapCfg(inst,&cfg->t.cfg, cfg->hdr.elmId.elmnt);
- break;
+ reason = rgLMMSapCfg(inst,&cfg->t.cfg, cfg->hdr.elmId.elmnt);
+ break;
default:
- ret = LCM_PRIM_NOK;
- reason = LCM_REASON_INVALID_ELMNT;
- RLOG1(L_ERROR, "Invalid Elmnt=%d",
- cfg->hdr.elmId.elmnt);
- break;
+ ret = LCM_PRIM_NOK;
+ reason = LCM_REASON_INVALID_ELMNT;
+ RLOG1(L_ERROR, "Invalid Elmnt=%d",
+ cfg->hdr.elmId.elmnt);
+ break;
}
if (reason != LCM_REASON_NOT_APPL)
cfm.cfm.reason = reason;
RgMiLrgCfgCfm(&cfmPst, &cfm);
-
+
return ROK;
}/*-- RgMiLrgCfgReq --*/
RgMngmt cfm;
Inst inst;
-
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
/* Fill the post structure for sending the confirmation */
#ifdef MAC_SCH_STATS
{
RgGenSts *genSts = &(cfm.t.sts.s.genSts);
- U8 cqi = 0;
+ uint8_t cqi = 0;
for(cqi=0; cqi <= 14; cqi++)
{
/* Filling DL ACK/NACK stats */
}
}
#endif /* MAC_SCH_STATS*/
- }
- break;
+ }
+ break;
case STRGUSAP:
memcpy(&(cfm.t.sts.s.rguSts), &rgCb[inst].rguSap[sts->t.sts.sapInst].sapSts,
sizeof(RgSapSts));
if(sts->t.sts.action == ARST)
memset(&rgCb[inst].rguSap[sts->t.sts.sapInst].sapSts, 0, sizeof(RgSapSts));
- break;
+ break;
case STCRGSAP:
memcpy(&(cfm.t.sts.s.crgSts), &rgCb[inst].crgSap.sapSts,
sizeof(RgSapSts));
if(sts->t.sts.action == ARST)
memset(&rgCb[inst].crgSap.sapSts, 0, sizeof(RgSapSts));
- break;
+ break;
case STTFUSAP:
memcpy(&(cfm.t.sts.s.tfuSts), &rgCb[inst].tfuSap.sapSts,
sizeof(RgSapSts));
if(sts->t.sts.action == ARST)
memset(&rgCb[inst].tfuSap.sapSts, 0, sizeof(RgSapSts));
- break;
+ break;
default:
- cfm.cfm.status = LCM_PRIM_NOK;
- cfm.cfm.reason = LCM_REASON_INVALID_ELMNT;
- RLOG1(L_ERROR, "Invalid Elmnt = %d",sts->hdr.elmId.elmnt);
- break;
+ cfm.cfm.status = LCM_PRIM_NOK;
+ cfm.cfm.reason = LCM_REASON_INVALID_ELMNT;
+ RLOG1(L_ERROR, "Invalid Elmnt = %d",sts->hdr.elmId.elmnt);
+ break;
}
RgMiLrgStsCfm(&cfmPst,&cfm);
return ROK;
{
SGetDateTime(&cfm.t.ssta.dt);
if (SGetSBuf(cfmPst.region, cfmPst.pool,
- (Data **)&(cfm.t.ssta.s.sysId.ptNmb), LRG_MAX_PT_NUM_SIZE)
- != ROK)
+ (Data **)&(cfm.t.ssta.s.sysId.ptNmb), LRG_MAX_PT_NUM_SIZE)
+ != ROK)
{
- RLOG0(L_ERROR, "Memory Unavailable for Confirmation");
- return ROK;
+ RLOG0(L_ERROR, "Memory Unavailable for Confirmation");
+ return ROK;
}
memset((cfm.t.ssta.s.sysId.ptNmb), 0, LRG_MAX_PT_NUM_SIZE);
rgGetSId(&cfm.t.ssta.s.sysId);
RgMiLrgStaCfm(&cfmPst, &cfm);
break;
default:
- cfm.cfm.status = LCM_PRIM_NOK;
- cfm.cfm.reason = LCM_REASON_INVALID_ELMNT;
- RgMiLrgStaCfm(&cfmPst, &cfm);
- RLOG1(L_ERROR, "Invalid elmnt=%d",sta->hdr.elmId.elmnt);
- break;
+ cfm.cfm.status = LCM_PRIM_NOK;
+ cfm.cfm.reason = LCM_REASON_INVALID_ELMNT;
+ RgMiLrgStaCfm(&cfmPst, &cfm);
+ RLOG1(L_ERROR, "Invalid elmnt=%d",sta->hdr.elmId.elmnt);
+ break;
}
return ROK;
}/*-- RgMiLrgStaReq --*/
Pst cfmPst;
RgMngmt cfm;
Inst inst;
-
-
/* Fill the post structure for sending the confirmation */
RG_IS_INST_VALID(pst->dstInst);
RLOG0(L_ERROR, "Gen Cfg not done");
return ROK;
}
-
+
/* General Config done, process the Control request */
switch(cntrl->hdr.elmId.elmnt)
{
case STGEN:
- rgLMMGenCntrl(cntrl, &cfm, &cfmPst);
- break;
+ rgLMMGenCntrl(cntrl, &cfm, &cfmPst);
+ break;
case STTFUSAP:
case STRGUSAP:
case STCRGSAP:
- rgLMMSapCntrl(cntrl, &cfm, &cfmPst);
- break;
+ rgLMMSapCntrl(cntrl, &cfm, &cfmPst);
+ break;
default:
- cfm.cfm.status = LCM_PRIM_NOK;
- cfm.cfm.reason = LCM_REASON_INVALID_PAR_VAL;
- RgMiLrgCntrlCfm(&cfmPst, &cfm);
- RLOG1(L_ERROR, "invalid elmnt=%d",cntrl->hdr.elmId.elmnt);
- break;
+ cfm.cfm.status = LCM_PRIM_NOK;
+ cfm.cfm.reason = LCM_REASON_INVALID_PAR_VAL;
+ RgMiLrgCntrlCfm(&cfmPst, &cfm);
+ RLOG1(L_ERROR, "invalid elmnt=%d",cntrl->hdr.elmId.elmnt);
+ break;
}
return (ret);
}/*-- RgMiLrgCntrlReq --*/
*
* @param[in] Inst inst
* @param[in] RgCfg *cfg, the Configuaration information
- * @return U16
+ * @return uint16_t
* -# LCM_REASON_GENCFG_NOT_DONE
* -# LCM_REASON_INVALID_SAP
* -# LCM_REASON_NOT_APPL
**/
#ifdef ANSI
-PRIVATE U16 rgLMMSapCfg
+PRIVATE uint16_t rgLMMSapCfg
(
Inst inst,
RgCfg *cfg, /* Configuaration information */
Elmnt sapType /* Sap Type */
)
#else
-PRIVATE U16 rgLMMSapCfg(inst,cfg,sapType)
+PRIVATE uint16_t rgLMMSapCfg(inst,cfg,sapType)
Inst inst;
RgCfg *cfg; /* Configuaration information */
Elmnt sapType; /* Sap Type */
#endif
{
- U16 ret = LCM_REASON_NOT_APPL;
+ uint16_t ret = LCM_REASON_NOT_APPL;
RgLowSapCfgInfo *lowSapCfg = NULLP;
RgUpSapCfgInfo *upSapCfg = NULLP;
- RgUpSapCb *upSapCb = NULLP;
+ RgUpSapCb *upSapCb = NULLP;
- /* Check if Gen Config has been done */
+ /* Check if Gen Config has been done */
if(rgCb[inst].rgInit.cfgDone != TRUE)
- return (LCM_REASON_GENCFG_NOT_DONE);
+ return (LCM_REASON_GENCFG_NOT_DONE);
switch(sapType)
{
case STRGUSAP:
- if ((cfg->s.rguSap.spId > LRG_MAX_RGU_SAPS) &&
- (cfg->s.rguSap.selector != ODU_SELECTOR_TC) &&
- (cfg->s.rguSap.selector != ODU_SELECTOR_LC))
- {
- ret = LCM_REASON_INVALID_PAR_VAL;
- RLOG0(L_ERROR, "unsupported Selector value for RGU");
- break;
- }
- upSapCb = &(rgCb[inst].rguSap[cfg->s.rguSap.spId]);
- if(upSapCb->sapSta.sapState == LRG_NOT_CFG)
- {
- upSapCb->sapSta.sapState = LRG_UNBND;
- }
- upSapCfg = &(upSapCb->sapCfg);
- upSapCfg->sapPst.dstEnt = cfg->s.rguSap.ent;
- upSapCfg->sapPst.dstInst = cfg->s.rguSap.inst;
- upSapCfg->sapPst.dstProcId = cfg->s.rguSap.procId;
- upSapCfg->sapPst.srcEnt = rgCb[inst].rgInit.ent;
- upSapCfg->sapPst.srcInst = rgCb[inst].rgInit.inst;
- upSapCfg->sapPst.srcProcId = rgCb[inst].rgInit.procId;
- upSapCfg->sapPst.region = cfg->s.rguSap.mem.region;
- upSapCfg->sapPst.pool = cfg->s.rguSap.mem.pool;
- upSapCfg->sapPst.selector = cfg->s.rguSap.selector;
- upSapCfg->sapPst.route = cfg->s.rguSap.route;
- upSapCfg->sapPst.intfVer = 0;
- upSapCfg->sapPst.prior = cfg->s.rguSap.prior;
- upSapCfg->suId = cfg->s.rguSap.suId;
- upSapCfg->spId = cfg->s.rguSap.spId;
- /*T2K uses 2 saps, T3K uses 1 sap. change the rgRguDlSap to 1 only if
- * there is cfg request with sap is 1*/
- break;
+ if ((cfg->s.rguSap.spId > LRG_MAX_RGU_SAPS) &&
+ (cfg->s.rguSap.selector != ODU_SELECTOR_TC) &&
+ (cfg->s.rguSap.selector != ODU_SELECTOR_LC))
+ {
+ ret = LCM_REASON_INVALID_PAR_VAL;
+ RLOG0(L_ERROR, "unsupported Selector value for RGU");
+ break;
+ }
+ upSapCb = &(rgCb[inst].rguSap[cfg->s.rguSap.spId]);
+ if(upSapCb->sapSta.sapState == LRG_NOT_CFG)
+ {
+ upSapCb->sapSta.sapState = LRG_UNBND;
+ }
+ upSapCfg = &(upSapCb->sapCfg);
+ upSapCfg->sapPst.dstEnt = cfg->s.rguSap.ent;
+ upSapCfg->sapPst.dstInst = cfg->s.rguSap.inst;
+ upSapCfg->sapPst.dstProcId = cfg->s.rguSap.procId;
+ upSapCfg->sapPst.srcEnt = rgCb[inst].rgInit.ent;
+ upSapCfg->sapPst.srcInst = rgCb[inst].rgInit.inst;
+ upSapCfg->sapPst.srcProcId = rgCb[inst].rgInit.procId;
+ upSapCfg->sapPst.region = cfg->s.rguSap.mem.region;
+ upSapCfg->sapPst.pool = cfg->s.rguSap.mem.pool;
+ upSapCfg->sapPst.selector = cfg->s.rguSap.selector;
+ upSapCfg->sapPst.route = cfg->s.rguSap.route;
+ upSapCfg->sapPst.intfVer = 0;
+ upSapCfg->sapPst.prior = cfg->s.rguSap.prior;
+ upSapCfg->suId = cfg->s.rguSap.suId;
+ upSapCfg->spId = cfg->s.rguSap.spId;
+ /*T2K uses 2 saps, T3K uses 1 sap. change the rgRguDlSap to 1 only if
+ * there is cfg request with sap is 1*/
+ break;
case STCRGSAP:
- if ((cfg->s.crgSap.selector != ODU_SELECTOR_TC) &&
- (cfg->s.crgSap.selector != ODU_SELECTOR_LC))
- {
- ret = LCM_REASON_INVALID_PAR_VAL;
- RLOG0(L_ERROR, "unsupported Selector value for CRG");
- break;
- }
- if(rgCb[inst].crgSap.sapSta.sapState == LRG_NOT_CFG)
- {
- rgCb[inst].crgSap.sapSta.sapState = LRG_UNBND;
- }
- upSapCfg = &rgCb[inst].crgSap.sapCfg;
-
- upSapCfg->sapPst.dstEnt = cfg->s.crgSap.ent;
- upSapCfg->sapPst.dstInst = cfg->s.crgSap.inst;
- upSapCfg->sapPst.dstProcId = cfg->s.crgSap.procId;
- upSapCfg->sapPst.srcEnt = rgCb[inst].rgInit.ent;
- upSapCfg->sapPst.srcInst = rgCb[inst].rgInit.inst;
- upSapCfg->sapPst.srcProcId = rgCb[inst].rgInit.procId;
- upSapCfg->sapPst.region = cfg->s.crgSap.mem.region;
- upSapCfg->sapPst.pool = cfg->s.crgSap.mem.pool;
- upSapCfg->sapPst.selector = cfg->s.crgSap.selector;
- upSapCfg->sapPst.route = cfg->s.crgSap.route;
- upSapCfg->sapPst.intfVer = 0;
- upSapCfg->sapPst.prior = cfg->s.crgSap.prior;
- upSapCfg->suId = cfg->s.crgSap.suId;
- upSapCfg->spId = cfg->s.crgSap.spId;
- break;
+ if ((cfg->s.crgSap.selector != ODU_SELECTOR_TC) &&
+ (cfg->s.crgSap.selector != ODU_SELECTOR_LC))
+ {
+ ret = LCM_REASON_INVALID_PAR_VAL;
+ RLOG0(L_ERROR, "unsupported Selector value for CRG");
+ break;
+ }
+ if(rgCb[inst].crgSap.sapSta.sapState == LRG_NOT_CFG)
+ {
+ rgCb[inst].crgSap.sapSta.sapState = LRG_UNBND;
+ }
+ upSapCfg = &rgCb[inst].crgSap.sapCfg;
+
+ upSapCfg->sapPst.dstEnt = cfg->s.crgSap.ent;
+ upSapCfg->sapPst.dstInst = cfg->s.crgSap.inst;
+ upSapCfg->sapPst.dstProcId = cfg->s.crgSap.procId;
+ upSapCfg->sapPst.srcEnt = rgCb[inst].rgInit.ent;
+ upSapCfg->sapPst.srcInst = rgCb[inst].rgInit.inst;
+ upSapCfg->sapPst.srcProcId = rgCb[inst].rgInit.procId;
+ upSapCfg->sapPst.region = cfg->s.crgSap.mem.region;
+ upSapCfg->sapPst.pool = cfg->s.crgSap.mem.pool;
+ upSapCfg->sapPst.selector = cfg->s.crgSap.selector;
+ upSapCfg->sapPst.route = cfg->s.crgSap.route;
+ upSapCfg->sapPst.intfVer = 0;
+ upSapCfg->sapPst.prior = cfg->s.crgSap.prior;
+ upSapCfg->suId = cfg->s.crgSap.suId;
+ upSapCfg->spId = cfg->s.crgSap.spId;
+ break;
case STTFUSAP:
#ifndef CL_MAC_LWLC
- if ((cfg->s.tfuSap.selector != ODU_SELECTOR_TC) &&
- (cfg->s.tfuSap.selector != ODU_SELECTOR_LC))
- {
- ret = LCM_REASON_INVALID_PAR_VAL;
- RLOG0(L_ERROR, "unsupported Selector value for TFU");
- break;
- }
+ if ((cfg->s.tfuSap.selector != ODU_SELECTOR_TC) &&
+ (cfg->s.tfuSap.selector != ODU_SELECTOR_LC))
+ {
+ ret = LCM_REASON_INVALID_PAR_VAL;
+ RLOG0(L_ERROR, "unsupported Selector value for TFU");
+ break;
+ }
#endif
if (rgCb[inst].tfuSap.sapSta.sapState == LRG_NOT_CFG)
{
sizeof(TmrCfg));
break;
default:
- /* would never reach here */
- break;
+ /* would never reach here */
+ break;
}
return (ret);
}
*
* @param[in] Inst inst
* @param[in] RgCfg *cfg, the Configuaration information
- * @return U16
+ * @return uint16_t
* -# LCM_REASON_NOT_APPL
* -# LCM_REASON_INVALID_MSGTYPE
* -# LCM_REASON_MEM_NOAVAIL
**/
#ifdef ANSI
-PRIVATE U16 rgLMMGenCfg
+PRIVATE uint16_t rgLMMGenCfg
(
Inst inst,
RgCfg *cfg /* Configuaration information */
)
#else
-PRIVATE U16 rgLMMGenCfg(inst,cfg)
+PRIVATE uint16_t rgLMMGenCfg(inst,cfg)
Inst inst;
RgCfg *cfg; /* Configuaration information */
#endif
{
- U16 ret = LCM_REASON_NOT_APPL;
+ uint16_t ret = LCM_REASON_NOT_APPL;
/* Check if General Configuration is done already */
return (LCM_REASON_INVALID_MSGTYPE);
}
if ((cfg->s.genCfg.lmPst.selector != ODU_SELECTOR_TC) &&
- (cfg->s.genCfg.lmPst.selector != ODU_SELECTOR_LC))
+ (cfg->s.genCfg.lmPst.selector != ODU_SELECTOR_LC))
{
RLOG0(L_ERROR, "unsupported Selector value for RGU");
return (LCM_REASON_INVALID_PAR_VAL);
/* allocate RGR saps */
if (SGetSBuf(rgCb[inst].rgInit.region,
- rgCb[inst].rgInit.pool,
- (Data **)&rgCb[inst].rguSap,
- (sizeof(RgUpSapCb) * cfg->s.genCfg.numRguSaps)) != ROK)
+ rgCb[inst].rgInit.pool,
+ (Data **)&rgCb[inst].rguSap,
+ (sizeof(RgUpSapCb) * cfg->s.genCfg.numRguSaps)) != ROK)
{
RGDBGERRNEW(inst,(rgPBuf(inst), "\nrgGenCfg(): Failed to allocate mem for RGU SAP's.\n"));
return RFAILED;
#if 0
/* Timer Registration request to SSI */
if (SRegTmrMt(rgCb[inst].rgInit.ent, rgCb[inst].rgInit.inst,
- (S16)rgCb[inst].genCfg.tmrRes, rgActvTmr) != ROK)
+ (S16)rgCb[inst].genCfg.tmrRes, rgActvTmr) != ROK)
{
-
+
RLOG0(L_ERROR, "Failed to register timer");
SPutSBuf(rgCb[inst].rgInit.region,
- rgCb[inst].rgInit.pool,
- (Data *)rgCb[inst].rguSap,
- (sizeof(RgUpSapCb) * cfg->s.genCfg.numRguSaps));
+ rgCb[inst].rgInit.pool,
+ (Data *)rgCb[inst].rguSap,
+ (sizeof(RgUpSapCb) * cfg->s.genCfg.numRguSaps));
return (LCM_REASON_MEM_NOAVAIL);
}
#endif
{
RgCellCb *cell = rgCb[inst].cell;
- U8 idx;
+ uint8_t idx;
- /* Unbind the TFU Sap */
+ /* Unbind the TFU Sap */
if(rgCb[inst].tfuSap.sapSta.sapState == LRG_WAIT_BNDCFM)
{
rgLIMTfuUbndReq(inst,rgCb[inst].tfuSap.sapCfg.spId, LRG_UNBND);
if (rgCb[inst].tfuSap.sapCfg.bndTmr.enb == TRUE)
{
rgLMMStopTmr(inst,RG_BNDREQ_TMR, (PTR)&rgCb[inst].tfuSap);
- }
+ }
rgCb[inst].tfuSap.sapSta.sapState = LRG_UNBND;
}
if(rgCb[inst].tfuSap.sapSta.sapState == LRG_BND)
{
for(idx=0;idx < RG_NUM_SUB_FRAMES; idx++)
{
- rgTOMRlsSf(inst,&cell->subFrms[idx]);
+ rgTOMRlsSf(inst,&cell->subFrms[idx]);
}
rgCFGFreeCellCb(cell);
/* Deleting the RGU SAPs */
SPutSBuf(rgCb[inst].rgInit.region,
- rgCb[inst].rgInit.pool,
- (Data *)rgCb[inst].rguSap,
- (sizeof(RgUpSapCb) * rgCb[inst].numRguSaps));
+ rgCb[inst].rgInit.pool,
+ (Data *)rgCb[inst].rguSap,
+ (sizeof(RgUpSapCb) * rgCb[inst].numRguSaps));
rgCb[inst].rguSap = NULLP;
rgCb[inst].inactiveCell = NULLP;
/* De-register the Timer Service */
(Void) SDeregTmrMt(rgCb[inst].rgInit.ent, rgCb[inst].rgInit.inst,
- (S16)rgCb[inst].genCfg.tmrRes, rgActvTmr);
+ (S16)rgCb[inst].genCfg.tmrRes, rgActvTmr);
/* call back the task initialization function to intialize
* the global RgCb Struct */
rgActvInit(rgCb[inst].rgInit.ent, rgCb[inst].rgInit.inst, rgCb[inst].rgInit.region,
- rgCb[inst].rgInit.reason);
+ rgCb[inst].rgInit.reason);
- RETVOID;
+ return;
}
\f
cfm->cfm.status = LCM_PRIM_OK;
cfm->cfm.reason = LCM_REASON_NOT_APPL;
-
+
switch(cntrl->t.cntrl.action)
{
case SADBG:
/* Enable Debug Printing */
#ifdef DEBUGP
- rgCb[inst].rgInit.dbgMask |= cntrl->t.cntrl.s.rgDbgCntrl.dbgMask;
+ rgCb[inst].rgInit.dbgMask |= cntrl->t.cntrl.s.rgDbgCntrl.dbgMask;
#endif
- break;
+ break;
#ifdef SS_DIAG
- case SALOG:
- rgCb[inst].rgInit.logMask = cntrl->t.cntrl.s.logMask;
- break;
+ case SALOG:
+ rgCb[inst].rgInit.logMask = cntrl->t.cntrl.s.logMask;
+ break;
#endif
- default:
- cfm->cfm.status = LCM_PRIM_NOK;
- cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
- RLOG1(L_ERROR, "invalid subaction=%d",cntrl->t.cntrl.subAction);
- break;
- }
- break;
+ default:
+ cfm->cfm.status = LCM_PRIM_NOK;
+ cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
+ RLOG1(L_ERROR, "invalid subaction=%d",cntrl->t.cntrl.subAction);
+ break;
+ }
+ break;
case ADISIMM:
- /* Action is Diable immidiately */
- switch(cntrl->t.cntrl.subAction)
- {
- case SATRC:
- /* Disable Traces */
- rgCb[inst].rgInit.trc = FALSE;
- break;
- case SAUSTA:
- /* Disable Unsolicited Status (alarms) */
- rgCb[inst].rgInit.usta = FALSE;
- break;
- case SADBG:
- /* Disable Debug Printing */
+ /* Action is Diable immidiately */
+ switch(cntrl->t.cntrl.subAction)
+ {
+ case SATRC:
+ /* Disable Traces */
+ rgCb[inst].rgInit.trc = FALSE;
+ break;
+ case SAUSTA:
+ /* Disable Unsolicited Status (alarms) */
+ rgCb[inst].rgInit.usta = FALSE;
+ break;
+ case SADBG:
+ /* Disable Debug Printing */
#ifdef DEBUGP
- rgCb[inst].rgInit.dbgMask &=~cntrl->t.cntrl.s.rgDbgCntrl.dbgMask;
+ rgCb[inst].rgInit.dbgMask &=~cntrl->t.cntrl.s.rgDbgCntrl.dbgMask;
#endif
- break;
+ break;
#ifdef SS_DIAG
- case SALOG:
- rgCb[inst].rgInit.logMask = cntrl->t.cntrl.s.logMask;
- break;
+ case SALOG:
+ rgCb[inst].rgInit.logMask = cntrl->t.cntrl.s.logMask;
+ break;
#endif
- default:
- cfm->cfm.status = LCM_PRIM_NOK;
- cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
- RLOG1(L_ERROR, "invalid subaction=%d",cntrl->t.cntrl.subAction);
- break;
- }
- break;
+ default:
+ cfm->cfm.status = LCM_PRIM_NOK;
+ cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
+ RLOG1(L_ERROR, "invalid subaction=%d",cntrl->t.cntrl.subAction);
+ break;
+ }
+ break;
case ASHUTDOWN:
- /* Free all the memory dynamically allocated by MAC */
- rgLMMShutdown(inst);
- break;
+ /* Free all the memory dynamically allocated by MAC */
+ rgLMMShutdown(inst);
+ break;
default:
- cfm->cfm.status = LCM_PRIM_NOK;
- cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
- RLOG1(L_ERROR, "invalid action=%d",cntrl->t.cntrl.action);
- break;
+ cfm->cfm.status = LCM_PRIM_NOK;
+ cfm->cfm.reason = LCM_REASON_INVALID_PAR_VAL;
+ RLOG1(L_ERROR, "invalid action=%d",cntrl->t.cntrl.action);
+ break;
}
RgMiLrgCntrlCfm(cfmPst, cfm);
- RETVOID;
+ return;
}
\f
RETVOID;
}
RgMiLrgCntrlCfm(cfmPst, cfm);
- RETVOID;
+ return;
}
\f
cfmPst->region = cfm->hdr.response.mem.region;
cfmPst->pool = cfm->hdr.response.mem.pool;
- RETVOID;
+ return;
}
\f
*
* @param[in] Inst inst
* @param[in] S16 tmrEvnt, the Timer Event
- * @param[in] U32 tmrVal, the Wait Time
+ * @param[in] uint32_t tmrVal, the Wait Time
* @param[in] PTR cb, Entry for which Timer expired
* @return S16
* -# ROK
**/
#ifdef ANSI
-S16 rgLMMStartTmr
+ S16 rgLMMStartTmr
(
-Inst inst,
-S16 tmrEvnt, /* Timer Event */
-U32 tmrVal, /* Wait Time */
-PTR cb /* Entry for which Timer Expired */
-)
+ Inst inst,
+ S16 tmrEvnt, /* Timer Event */
+ uint32_t tmrVal, /* Wait Time */
+ PTR cb /* Entry for which Timer Expired */
+ )
#else
S16 rgLMMStartTmr(tmrEvnt, tmrVal, cb)
-Inst inst;
-S16 tmrEvnt; /* Timer Event */
-U32 tmrVal; /* Wait Time */
-PTR cb; /* Entry for which Timer Expired */
+ Inst inst;
+ S16 tmrEvnt; /* Timer Event */
+ uint32_t tmrVal; /* Wait Time */
+ PTR cb; /* Entry for which Timer Expired */
#endif
{
CmTmrArg arg;
- UNUSED(tmrEvnt);
+ UNUSED(tmrEvnt);
/* Initialize the arg structure */
memset(&arg, 0, sizeof(CmTmrArg));
#endif
{
CmTmrArg arg;
- U8 i;
+ uint8_t i;
S16 ret;
* status indication to the Layer Manager.
*
* @param[in] Inst inst
- * @param[in] U16 category, the Alarm category
- * @param[in] U16 event, the Alarm event
- * @param[in] U16 cause, the cause of the Alarm
+ * @param[in] uint16_t category, the Alarm category
+ * @param[in] uint16_t event, the Alarm event
+ * @param[in] uint16_t cause, the cause of the Alarm
* @param[in] RgUstaDgn *dgn, Alarm Diagonostics
* @return S16
* -# ROK
S16 rgLMMStaInd
(
Inst inst,
-U16 category,
-U16 event,
-U16 cause,
+uint16_t category,
+uint16_t event,
+uint16_t cause,
RgUstaDgn *dgn
)
#else
S16 rgLMMStaInd(inst,category, event, cause, dgn)
Inst inst;
-U16 category;
-U16 event;
-U16 cause;
+uint16_t category;
+uint16_t event;
+uint16_t cause;
RgUstaDgn *dgn;
#endif
{
*
* @param[in] Inst inst
* @param[in] Buffer *srcMbuf, the Message Buffer .
- * @param[in] U8 event, the trace event.
+ * @param[in] uint8_t event, the trace event.
* @return Void
**/
#ifdef ANSI
(
Inst inst,
Buffer *srcMbuf, /* Message Buffer */
-U8 event /* event */
+uint8_t event /* event */
)
#else
Void rgLMMTrcInd(inst,srcMbuf,event)
Inst inst;
Buffer *srcMbuf; /* Message Buffer */
-U8 event; /* event */
+uint8_t event; /* event */
#endif
{
Buffer *dstMbuf = NULLP;
if ((rgCb[inst].trcLen == LRG_NO_TRACE) || (srcMbuf == NULLP))
{
RLOG0(L_ERROR, "Trace Disabled.");
- RETVOID;
+ return;
}
memset(&trc, 0, sizeof(RgMngmt));
trc.hdr.transId = rgCb[inst].genCfg.trcResp.transId;
SGetDateTime(&trc.t.trc.dt);
-
+
/* Check if the whole buffer is to be sent in Trace indication */
if(rgCb[inst].trcLen == LRG_FULL_TRACE)
{
if (SCpyMsgMsg(srcMbuf, pst.region, pst.pool, &dstMbuf)
- != ROK)
+ != ROK)
{
- RLOG0(L_ERROR, "SCpyMsgMsg Failed.");
- RETVOID;
+ RLOG0(L_ERROR, "SCpyMsgMsg Failed.");
+ return;
}
trc.cfm.status = LCM_PRIM_OK;
trc.cfm.reason = LCM_REASON_NOT_APPL;
trc.t.trc.evnt = event;
-
+
/* Send Trace Indication to Layer manager */
RgMiLrgTrcInd(&pst, &trc, dstMbuf);
}
/* Get the length of the recvd message buffer */
if (SFndLenMsg(srcMbuf, &bufLen) != ROK)
{
- RLOG0(L_ERROR, "SFndLenMsg Failed.");
- RETVOID;
+ RLOG0(L_ERROR, "SFndLenMsg Failed.");
+ return;
}
/* Check if the recvd buffer size is less than request trace len */
if(bufLen < rgCb[inst].trcLen)
{
- /* Copy the whole of the recvd buffer in trace indication */
-
- if (SCpyMsgMsg(srcMbuf, pst.region, pst.pool, &dstMbuf)
- != ROK)
- {
- RLOG0(L_ERROR, "SCpyMsgMsg Failed.");
- RETVOID;
- }
-
- trc.cfm.status = LCM_PRIM_OK;
- trc.cfm.reason = LCM_REASON_NOT_APPL;
- trc.t.trc.evnt = event;
+ /* Copy the whole of the recvd buffer in trace indication */
+
+ if (SCpyMsgMsg(srcMbuf, pst.region, pst.pool, &dstMbuf)
+ != ROK)
+ {
+ RLOG0(L_ERROR, "SCpyMsgMsg Failed.");
+ return;
+ }
+
+ trc.cfm.status = LCM_PRIM_OK;
+ trc.cfm.reason = LCM_REASON_NOT_APPL;
+ trc.t.trc.evnt = event;
- /* Send Trace Indication to Layer manager */
- RgMiLrgTrcInd(&pst, &trc, dstMbuf);
+ /* Send Trace Indication to Layer manager */
+ RgMiLrgTrcInd(&pst, &trc, dstMbuf);
}
/* if the recvd buffer size is greater than request trace len */
if(bufLen >= rgCb[inst].trcLen)
{
- /* Get a temporary buffer to store the msg */
- if (rgAllocSBuf(inst,&tempBuf, rgCb[inst].trcLen) != ROK)
- {
- RLOG0(L_ERROR, "rgAllocSBuf Failed.");
- RETVOID;
- }
-
- /* Copy trcLen nos of bytes from the recvd message */
- if (SCpyMsgFix(srcMbuf,0,rgCb[inst].trcLen,tempBuf,&tempCnt) != ROK)
- {
- RLOG0(L_ERROR, "SCpyMsgFix Failed.");
- RETVOID;
- }
-
- if (SGetMsg(pst.region, pst.pool, &dstMbuf) != ROK)
- {
- RLOG0(L_ERROR, "dstMbuf Allocation Failed");
- RETVOID;
- }
- /* Copy the tempBuf data to dst mBuf */
- if (SCpyFixMsg(tempBuf,dstMbuf,0,rgCb[inst].trcLen,&tempCnt) != ROK)
- {
- RLOG0(L_ERROR, "SCpyFixMsg Failed.");
- RETVOID;
- }
-
- /*ccpu00117052 - MOD - Passing double pointer for proper NULLP
- assignment */
- /* Free the memory allocated for tempBuf */
- rgFreeSBuf(inst,&tempBuf, rgCb[inst].trcLen);
-
- trc.cfm.status = LCM_PRIM_OK;
- trc.cfm.reason = LCM_REASON_NOT_APPL;
- trc.t.trc.evnt = event;
-
- /* Send Trace Indication to Layer manager */
- RgMiLrgTrcInd(&pst, &trc, dstMbuf);
+ /* Get a temporary buffer to store the msg */
+ if (rgAllocSBuf(inst,&tempBuf, rgCb[inst].trcLen) != ROK)
+ {
+ RLOG0(L_ERROR, "rgAllocSBuf Failed.");
+ return;
+ }
+
+ /* Copy trcLen nos of bytes from the recvd message */
+ if (SCpyMsgFix(srcMbuf,0,rgCb[inst].trcLen,tempBuf,&tempCnt) != ROK)
+ {
+ RLOG0(L_ERROR, "SCpyMsgFix Failed.");
+ return;
+ }
+
+ if (SGetMsg(pst.region, pst.pool, &dstMbuf) != ROK)
+ {
+ RLOG0(L_ERROR, "dstMbuf Allocation Failed");
+ return;
+ }
+ /* Copy the tempBuf data to dst mBuf */
+ if (SCpyFixMsg(tempBuf,dstMbuf,0,rgCb[inst].trcLen,&tempCnt) != ROK)
+ {
+ RLOG0(L_ERROR, "SCpyFixMsg Failed.");
+ return;
+ }
+
+ /*ccpu00117052 - MOD - Passing double pointer for proper NULLP
+ assignment */
+ /* Free the memory allocated for tempBuf */
+ rgFreeSBuf(inst,&tempBuf, rgCb[inst].trcLen);
+
+ trc.cfm.status = LCM_PRIM_OK;
+ trc.cfm.reason = LCM_REASON_NOT_APPL;
+ trc.t.trc.evnt = event;
+
+ /* Send Trace Indication to Layer manager */
+ RgMiLrgTrcInd(&pst, &trc, dstMbuf);
}
}
- RETVOID;
+ return;
}
\f
*
* @param[in] Pst *pst, Post Structure
* @param[in] SuId suId, Service user ID
- * @param[in] U8 status, Status
+ * @param[in] uint8_t status, Status
* @return S16
* -# ROK
**/
(
Pst *pst, /* Post Structure */
SuId suId, /* Service user ID */
-U8 status /* Status */
+uint8_t status /* Status */
)
#else
S16 rgLMMBndCfm(pst,suId,status)
Pst *pst; /* Post Structure */
SuId suId; /* Service user ID */
-U8 status; /* Status */
+uint8_t status; /* Status */
#endif
{
Inst inst = pst->dstInst - RG_INST_START;
switch(rgCb[inst].tfuSap.sapSta.sapState)
{
case LRG_WAIT_BNDCFM:
- break;
+ break;
case LRG_BND:
- /* SAP is already bound */
- return ROK;
+ /* SAP is already bound */
+ return ROK;
default:
- return RFAILED;
+ return RFAILED;
}
cfmPst = rgCb[inst].rgInit.lmPst;
switch(status)
{
case CM_BND_OK: /* status is OK */
- /* Change SAP state to Bound */
- rgCb[inst].tfuSap.sapSta.sapState = LRG_BND;
- if (rgCb[inst].tfuSap.sapCfg.bndTmr.enb == TRUE)
- {
- ret = rgLMMStopTmr(inst,RG_BNDREQ_TMR, (PTR)&rgCb[inst].tfuSap);
- }
- /* Send Control Confirm with status as OK to Layer Manager */
- cntrlCfm.cfm.status = LCM_PRIM_OK;
- cntrlCfm.cfm.reason = LCM_REASON_NOT_APPL;
- break;
+ /* Change SAP state to Bound */
+ rgCb[inst].tfuSap.sapSta.sapState = LRG_BND;
+ if (rgCb[inst].tfuSap.sapCfg.bndTmr.enb == TRUE)
+ {
+ ret = rgLMMStopTmr(inst,RG_BNDREQ_TMR, (PTR)&rgCb[inst].tfuSap);
+ }
+ /* Send Control Confirm with status as OK to Layer Manager */
+ cntrlCfm.cfm.status = LCM_PRIM_OK;
+ cntrlCfm.cfm.reason = LCM_REASON_NOT_APPL;
+ break;
default:
- /* Change SAP state to UnBound */
- rgCb[inst].tfuSap.sapSta.sapState = LRG_UNBND;
- if (rgCb[inst].tfuSap.sapCfg.bndTmr.enb == TRUE)
- {
- ret = rgLMMStopTmr(inst,RG_BNDREQ_TMR, (PTR)&rgCb[inst].tfuSap);
- }
- /* Send Control Confirm with status as NOK to Layer Manager */
- cntrlCfm.cfm.status = LCM_PRIM_NOK;
- cntrlCfm.cfm.reason = LCM_REASON_NEG_CFM;
- break;
+ /* Change SAP state to UnBound */
+ rgCb[inst].tfuSap.sapSta.sapState = LRG_UNBND;
+ if (rgCb[inst].tfuSap.sapCfg.bndTmr.enb == TRUE)
+ {
+ ret = rgLMMStopTmr(inst,RG_BNDREQ_TMR, (PTR)&rgCb[inst].tfuSap);
+ }
+ /* Send Control Confirm with status as NOK to Layer Manager */
+ cntrlCfm.cfm.status = LCM_PRIM_NOK;
+ cntrlCfm.cfm.reason = LCM_REASON_NEG_CFM;
+ break;
}
rgCb[inst].tfuSap.numBndRetries = 0;
cntrlCfm.hdr.elmId.elmnt = STTFUSAP;
#ifdef ANSI
S16 rgActvTmr
(
- Ent ent,
- Inst inst
+Ent ent,
+Inst inst
)
#else
S16 rgActvTmr(ent, inst)
/* Check if any MAC timer has expired */
cmPrcTmr(&rgCb[macInst].tmrTqCp, rgCb[macInst].tmrTq, (PFV) rgLMMTmrExpiry);
-
+
return ROK;
-
+
} /* end of rgActvTmr */
/**********************************************************************
-
- End of file
-**********************************************************************/
+
+ End of file
+ **********************************************************************/
EXTERN S16 ssGetDBufOfSize(Region region,Size size,Buffer **dBuf);
#else
char* file = __FILE__;
-U32 line = __LINE__;
+uint32_t line = __LINE__;
#endif
/* local typedefs */
/* global variables */
-U32 rgDlrate_rgu;
+uint32_t rgDlrate_rgu;
/* local externs */
-PRIVATE Void rgMUXGet20bitRarGrnt ARGS((U8 ulBw,
+PRIVATE Void rgMUXGet20bitRarGrnt ARGS((uint8_t ulBw,
RgInfRarUlGrnt *msg3Grnt,
- U8 *grnt));
-EXTERN U16 rgMUXCalcRiv ARGS((U8 bw,
- U8 rbStart,
- U8 numRb));
+ uint8_t *grnt));
+EXTERN uint16_t rgMUXCalcRiv ARGS((uint8_t bw,
+ uint8_t rbStart,
+ uint8_t numRb));
#ifndef MS_MBUF_CORRUPTION
#define MS_BUF_ADD_ALLOC_CALLER()
#define RG_PACK_CE(_ce, _len, _ceBuf, _ret) {\
MS_BUF_ADD_ALLOC_CALLER(); \
- _ret = SAddPstMsgMult((U8 *)(&(_ce)), _len, _ceBuf);\
+ _ret = SAddPstMsgMult((uint8_t *)(&(_ce)), _len, _ceBuf);\
}
#define RG_MUX_CALC_LEN(_len,_lenBytes,_elmTotLen) {\
- U8 _hdrLen;\
+ uint8_t _hdrLen;\
_lenBytes = (_len <= 255) ? 1 : 2;\
_hdrLen = _lenBytes + RG_SDU_SHDR_LEN;\
_elmTotLen = _hdrLen + _len;\
{
if(pdu->schdTbSz >= RG_TA_ELM_LEN)
{
- U8 taVal; /* Moving from outer scope to available scope */
+ uint8_t taVal; /* Moving from outer scope to available scope */
RG_PACK_SHDR_FIXD_SZ(subHdr, RG_TA_LCID_IDX, ceBuf, ret);
if(ret != ROK)
*
* @param[in] Inst inst
* @param[in] MsgLen *schdTbSz
- * @param[in] U8 lcId
+ * @param[in] uint8_t lcId
* @param[in] Buffer *sdu
* @param[out] Buffer *sduBuf
* @param[out] RgErrInfo *err
(
Inst inst,
MsgLen *schdTbSz,
-U8 lcId,
+uint8_t lcId,
Buffer *sdu,
Buffer *sduBuf,
RgErrInfo *err
PRIVATE S16 rgMUXInsSdu(inst,schdTbSz, lcId, sdu, sduBuf, err)
Inst inst;
MsgLen *schdTbSz;
-U8 lcId;
+uint8_t lcId;
Buffer *sdu;
Buffer *sduBuf;
RgErrInfo *err;
{
S16 ret;
MsgLen msgLen = 0;
- U8 lenBytes;
+ uint8_t lenBytes;
MsgLen elmTotLen;
SFndLenMsg(sdu, &msgLen);
* -# RFAILED
**/
#ifdef L2_OPTMZ
-U32 padSize = 0;
+uint32_t padSize = 0;
#endif
#ifdef ANSI
S16 rgMUXAddPadd
{
if(pdu->tbIndex == 1)
{
- U16 idx1, idx2;
+ uint16_t idx1, idx2;
/* Adding this temporary variable for optimization */
RguDatReqTb *datReqTb = &dDatReq->datReqTb[0];
}
else if(pdu->tbIndex == 2)
{
- U16 idx1, idx2;
+ uint16_t idx1, idx2;
RguDatReqTb *datReqTb = &dDatReq->datReqTb[1];
for (idx1=0; (idx1 < datReqTb->nmbLch); idx1++)
{
{
RgRguDDatReqPerUe *dDatReq;
RgRguCmnDatReq *cDatReq;
- U32 lchIdx, pduIdx;
+ uint32_t lchIdx, pduIdx;
switch(pdu->reqType)
{
= cDatReq->pdu;
tb->lchInfo[tb->numLch].numPdu++;
tb->numLch++;
- RLOG3(L_INFO,"MSG4 is muxed numLch=%ld numPdu=%ld tbaddr =%p", tb->numLch,tb->lchInfo[tb->numLch-1].numPdu, (U32)tb);
+ RLOG3(L_INFO,"MSG4 is muxed numLch=%ld numPdu=%ld tbaddr =%p", tb->numLch,tb->lchInfo[tb->numLch-1].numPdu, (uint32_t)tb);
}
break;
{
if(pdu->tbIndex == 1)
{
- U16 idx1, idx2;
+ uint16_t idx1, idx2;
/* Adding this temporary variable for optimization */
RguDatReqTb *datReqTb = &dDatReq->datReqTb[0];
}
else if(pdu->tbIndex == 2)
{
- U16 idx1, idx2;
+ uint16_t idx1, idx2;
RguDatReqTb *datReqTb = &dDatReq->datReqTb[1];
tb->numLch = lchIdx = 0;
// prc_trace_format_string(0x40,3,": AddSdus: numOfLch=%d numOfPdu=%d, schdSz=%d", datReqTb->nmbLch, datReqTb->lchData[0].pdu.numPdu, pdu->schdTbSz);
{
Buffer *mBuf1; /* MAC hearder */
Buffer *mBuf2; /* MAC CEs */
- //U32 lchIdx, pduIdx;
+ //uint32_t lchIdx, pduIdx;
/* Reseting macHdr and macCes pointers */
if(tb->macHdr)
{
Buffer *datBuf = NULLP;
S16 ret;
- U8 data[RG_RAR_ELEM_LEN];
- U8 hdrByte;
+ uint8_t data[RG_RAR_ELEM_LEN];
+ uint8_t hdrByte;
MsgLen schdTbSz;
- U8 idx;
+ uint8_t idx;
Inst inst = cell->macInst - RG_INST_START;
schdTbSz = alloc->schdTbSz;
{
rgMUXGet20bitRarGrnt(cell->bwCfg.ulTotalBw, &(alloc->crntiInfo[idx].grnt), &data[1]);
}
- data[1] |= ((U8)((alloc->crntiInfo[idx].ta.val) << 4));
+ data[1] |= ((uint8_t)((alloc->crntiInfo[idx].ta.val) << 4));
data[4] = (alloc->crntiInfo[idx].tmpCrnti) >> 8;
- data[5] = (U8) (alloc->crntiInfo[idx].tmpCrnti);
+ data[5] = (uint8_t) (alloc->crntiInfo[idx].tmpCrnti);
RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
"Rar,Rapid=%d, Temp CRNTI:%d",
#ifdef ANSI
PRIVATE Void rgMUXGet20bitRarGrnt
(
-U8 ulBw,
+uint8_t ulBw,
RgInfRarUlGrnt *msg3Grnt,
-U8 *grnt
+uint8_t *grnt
)
#else
PRIVATE Void rgMUXGet20bitRarGrnt(ulBw, msg3Grnt, grnt)
-U8 ulBw;
+uint8_t ulBw;
RgInfRarUlGrnt *msg3Grnt;
-U8 *grnt;
+uint8_t *grnt;
#endif
{
- U16 riv = rgMUXCalcRiv(ulBw, msg3Grnt->rbStart, msg3Grnt->numRb);
+ uint16_t riv = rgMUXCalcRiv(ulBw, msg3Grnt->rbStart, msg3Grnt->numRb);
grnt[2] = msg3Grnt->cqiBit; /* cqi bit is 0, output from sched */
grnt[2] |= (msg3Grnt->delayBit << 1);
grnt[1] = (msg3Grnt->iMcsCrnt >> 3);
/* Forcing right shift to insert 0 as the LSB:
* since this is assumed in the computation */
- grnt[1] |= (U8)((riv << 1) & 0xFE);
+ grnt[1] |= (uint8_t)((riv << 1) & 0xFE);
- grnt[0] = (U8)((riv >> 7) & 0x07);
+ grnt[0] = (uint8_t)((riv >> 7) & 0x07);
grnt[0] |= ((msg3Grnt->hop & 0x01) << 3);
- RETVOID;
+ return;
} /* rgMUXGet20bitRarGrnt */
/***********************************************************
*
**********************************************************/
#ifdef ANSI
-U16 rgMUXCalcRiv
+uint16_t rgMUXCalcRiv
(
-U8 bw,
-U8 rbStart,
-U8 numRb
+uint8_t bw,
+uint8_t rbStart,
+uint8_t numRb
)
#else
-U16 rgMUXCalcRiv(bw, rbStart, numRb)
-U8 bw;
-U8 rbStart;
-U8 numRb;
+uint16_t rgMUXCalcRiv(bw, rbStart, numRb)
+uint8_t bw;
+uint8_t rbStart;
+uint8_t numRb;
#endif
{
- U8 numRbMinus1 = numRb - 1;
- U16 riv;
+ uint8_t numRbMinus1 = numRb - 1;
+ uint16_t riv;
if (numRbMinus1 <= bw/2)
{
Bool *isCfmRqrd;
#endif
{
- U8 idx = 0;
+ uint8_t idx = 0;
Inst dstMacInst;
Pst dstInstPst;
RgPrgUeSCellLchDelInfo delLcCb;
Bool *isCfmRqrd;
#endif
{
- U8 idx = 0;
+ uint8_t idx = 0;
Inst dstMacInst;
RgPrgUeSCellLchModInfo lchCfgCb;
Pst dstInstPst;
Bool *isCfmRqrd;
#endif
{
- U8 idx = 0;
+ uint8_t idx = 0;
Inst dstMacInst;
RgPrgUeSCellLchAddInfo lchCfgCb;
Pst dstInstPst;
/**
* @brief Typedef for uplink Dedicated Logical channel group Id.
*/
-typedef U8 RgPrgLteLcgId;
+typedef uint8_t RgPrgLteLcgId;
/**
* @brief Structure to hold uplink Dedicated Logical channel info.
typedef struct rgPrgUlLcInfo
{
CmLteLcId lcId; /*!< Logical channel ID */
- RgPrgLteLcgId lcgId; /*!< Logical channel group */
+ RgPrgLteLcgId lcgId; /*!< Logical channel group */
#ifdef LTE_L2_MEAS
- U8 qci; /*!< QCI for this logical channel control block */
+ uint8_t qci; /*!< QCI for this logical channel control block */
Bool measOn; /*!< TRUE if Timing Info needs to be fetched for
Scheduled UL IP throughput else FALSE */
/* Right now not keeping associated logical channels, searching for
* associated channels needed only during config */
RgPrgLteLcgId lcgId; /*!< Group ID */
- U8 lcCount; /*!< Lc count */
+ uint8_t lcCount; /*!< Lc count */
Bool isGbr; /*!< Indicate if LCG is GBR LCG */
}RgPrgLcgInfo;
CmLteRnti ueId; /*!< UE identifier */
CmLteCellId cellId; /*!< Cell ID */
- U8 maxUlHqRetx; /*!< Maximum number of harq
+ uint8_t maxUlHqRetx; /*!< Maximum number of harq
* re-transmissions */
RgPrgUlLcInfo ulLcInfo[RG_MAX_LC_PER_UE]; /*!< Dedicated Uplink
logical channel information */
{
CmLteRnti ueId; /*!< UE identifier */
CmLteCellId sCellId; /*!< SCell ID */
- U8 status; /*!< Status: OK/NOK */
- U8 event; /*!< type of event */
+ uint8_t status; /*!< Status: OK/NOK */
+ uint8_t event; /*!< type of event */
}RgPrgCfgCfmInfo;
/**
struct ulLchRecfgS
{
- U8 lcgId; /*!< Logical channel group ID */
+ uint8_t lcgId; /*!< Logical channel group ID */
} ulLchRecfg; /*!< Uplink logical channel reconfiguration
information */
}RgPrgUeSCellLchModInfo;
CmLteCellId cellId; /*!< Cell ID */
CmLteRnti crnti; /*!< CRNTI for DTCH and DCCH */
CmLteLcId lcId; /*!< Logical channel ID */
- U8 dir; /*!< Indicates Direction. Direction can take following
+ uint8_t dir; /*!< Indicates Direction. Direction can take following
values:<br>
PRG_DIR_TX<br>
PRG_DIR_RX<br>
*/
typedef struct rgPrgUlLchCfg
{
- U8 ulTrchType; /*!< Indicates type of UL transport channel:
+ uint8_t ulTrchType; /*!< Indicates type of UL transport channel:
Validated only for BCCH at MAC.
UL Transport channel type can take following values:<br>
CM_LTE_TRCH_RACH<br>
CM_LTE_TRCH_UL_SCH */
- U8 lcgId; /*!< Logical channel group ID */
+ uint8_t lcgId; /*!< Logical channel group ID */
} RgPrgUlLchCfg;
*/
typedef struct rgPrgDlLchCfg
{
- U8 dlTrchType; /*!< Indicates type of DL transport channel:
+ uint8_t dlTrchType; /*!< Indicates type of DL transport channel:
Validated only for BCCH at MAC. DL Transport
channel type can take following values:<br>
CM_LTE_TRCH_BCH<br>
CM_LTE_LCH_DCCH<br>
CM_LTE_LCH_DTCH */
- U8 dir; /*!< Indicates Direction. Direction can take following
+ uint8_t dir; /*!< Indicates Direction. Direction can take following
values:<br>
PRG_DIR_TX<br>
PRG_DIR_RX<br>
RgPrgDlLchCfg dlInfo; /*!< Downlink logical channel configuration info */
RgPrgUlLchCfg ulInfo; /*!< Uplink logical channel configuration info */
#ifdef LTE_L2_MEAS
- U8 qci; /*!< QCI for the logical channel.
+ uint8_t qci; /*!< QCI for the logical channel.
Valid Range:[0-255] (Actual QCI - 1). */
#endif /* LTE_L2_MEAS */
#ifdef PTRGUIRGU
/** @brief Confirmation from MAC to RLC for the bind/Unbind
* request for the interface saps */
-EXTERN S16 PtUiRguBndCfm ARGS((Pst* pst, SuId suId, U8 status));
+EXTERN S16 PtUiRguBndCfm ARGS((Pst* pst, SuId suId, uint8_t status));
/** @brief Data Indication from MAC to RLC to
* forward the data received for common channels*/
EXTERN S16 PtUiRguCDatInd ARGS((Pst* pst, SuId suId, RguCDatIndInfo * datInd));
#ifdef PTRGUICRG
/** @brief Confirmation from MAC to RRC for the bind/Unbind
* request for the interface saps */
-EXTERN S16 PtUiCrgBndCfm ARGS((Pst* pst, SuId suId, U8 status));
+EXTERN S16 PtUiCrgBndCfm ARGS((Pst* pst, SuId suId, uint8_t status));
/** @brief Configuration Confirm from MAC to RRC */
-EXTERN S16 PtUiCrgCfgCfm ARGS((Pst* pst, SuId suId, CrgCfgTransId transId, U8 status));
+EXTERN S16 PtUiCrgCfgCfm ARGS((Pst* pst, SuId suId, CrgCfgTransId transId, uint8_t status));
#endif /*--#ifdef PTRGUICRG--*/
#ifdef PTRGUIRGR
/** @brief Confirmation from MAC to RRM for the bind/Unbind
* request for the interface saps */
-EXTERN S16 PtUiRgrBndCfm ARGS((Pst* pst, SuId suId, U8 status));
+EXTERN S16 PtUiRgrBndCfm ARGS((Pst* pst, SuId suId, uint8_t status));
/** @brief Configuration Confirm from MAC to RRM */
-EXTERN S16 PtUiRgrCfgCfm ARGS((Pst* pst, SuId suId, RgrCfgTransId transId, U8 status));
+EXTERN S16 PtUiRgrCfgCfm ARGS((Pst* pst, SuId suId, RgrCfgTransId transId, uint8_t status));
EXTERN S16 PtUiRgrTtiInd ARGS((Pst* pst, SuId suId, RgrTtiIndInfo *ttiInd));
/* Added for SI Enhancement*/
#ifdef RGR_SI_SCH
-EXTERN S16 PtUiRgrSiCfgCfm ARGS((Pst* pst, SuId suId, RgrCfgTransId transId, U8 status));
+EXTERN S16 PtUiRgrSiCfgCfm ARGS((Pst* pst, SuId suId, RgrCfgTransId transId, uint8_t status));
EXTERN S16 PtUiRgrWarningSiCfgCfm ARGS((Pst* pst, SuId suId,
- RgrCfgTransId transId, U8 siId, U8 status));
+ RgrCfgTransId transId, uint8_t siId, uint8_t status));
#endif/*RGR_SI_SCH*/
#endif /*--#ifdef PTRGUIRGR--*/
#ifdef PTRGUIRGM
S16 PtUiRgmPrbRprtInd ARGS((Pst* pst, SuId suId, RgmPrbRprtInd *prbRprtInd));
-S16 PtUiRgmBndCfm ARGS((Pst* pst, SuId suId, U8 status));
+S16 PtUiRgmBndCfm ARGS((Pst* pst, SuId suId, uint8_t status));
S16 PtUiRgmTransModeInd ARGS((Pst* pst, SuId suId, RgmTransModeInd *transModeInd));
#endif
S16 RgUiRgmSendPrbRprtInd ARGS((Pst* pst, SuId suId, RgmPrbRprtInd *prbRprtInd));
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 RgUiRgrBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 RgUiRgmBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] RgrCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
(
Pst* pst,
RgrCfgTransId transId,
-U8 status
+uint8_t status
)
#else
S16 RgUiRgrCfgCfm(pst, transId, status)
Pst* pst;
RgrCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 RgUiCrgBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] CrgCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
Pst* pst,
SuId suId,
CrgCfgTransId transId,
-U8 status
+uint8_t status
)
#else
S16 RgUiCrgCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
CrgCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 RgUiRguBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] RgrCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
Pst* pst,
SuId suId,
RgrCfgTransId transId,
-U8 status
+uint8_t status
)
#else
S16 RgUiRgrSiCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] RgrCfgTransId transId
-* @param[in] U8 siId
-* @param[in] U8 status
+* @param[in] uint8_t siId
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
Pst* pst,
SuId suId,
RgrCfgTransId transId,
-U8 siId,
-U8 status
+uint8_t siId,
+uint8_t status
)
#else
S16 RgUiRgrWarningSiCfgCfm(pst, suId, transId, siId,status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
-U8 siId;
-U8 status;
+uint8_t siId;
+uint8_t status;
#endif
{
return ((*RgUiRgrWarningSiCfgCfmMt[pst->selector])
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 PtUiCrgBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] CrgCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
Pst* pst,
SuId suId,
CrgCfgTransId transId,
-U8 status
+uint8_t status
)
#else
S16 PtUiCrgCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
CrgCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 PtUiRguBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 PtUiRgrBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] RgrCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
Pst* pst,
SuId suId,
RgrCfgTransId transId,
-U8 status
+uint8_t status
)
#else
S16 PtUiRgrCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] RgrCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
Pst* pst,
SuId suId,
RgrCfgTransId transId,
-U8 status
+uint8_t status
)
#else
S16 PtUiRgrSiCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] RgrCfgTransId transId
-* @param[in] U8 siId
-* @param[in] U8 status
+* @param[in] uint8_t siId
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
Pst* pst,
SuId suId,
RgrCfgTransId transId,
-U8 siId,
-U8 status
+uint8_t siId,
+uint8_t status
)
#else
S16 PtUiRgrWarningSiCfgCfm(pst, suId, transId, siId, status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
-U8 siId;
-U8 status;
+uint8_t siId;
+uint8_t status;
#endif
{
UNUSED(pst);
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 PtUiRgmBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
if (NULLP == elem)
{
SsRngInfoTbl[SS_RNG_BUF_ULMAC_TO_ULRLC].pktDrop++;
- U32 i,j;
+ uint32_t i,j;
for(i = 0; i< datInd->numLch; i++)
{
for(j = 0; j < datInd->lchData[i].pdu.numPdu; j++)
{
/* Read from Ring Buffer and process PDCP packets */
- U8 rngBufDeqIndx = 0;
+ uint8_t rngBufDeqIndx = 0;
PRIVATE Pst rgDDatRbfuPst ={1,1,ENTMAC,0,ENTRLC,1,PRIOR0,RTESPEC,EVTRGUDDATREQ,0,0,2,0};
PRIVATE Pst rgCDatRbfuPst ={1,1,ENTMAC,0,ENTRLC,1,PRIOR0,RTESPEC,EVTRGUCDATREQ,0,0,2,0};
Void *elmIndx = NULLP;
while(NULLP != elmIndx)
{
datReqRing= (RguInfoRingElem *)elmIndx;
- SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC_DAT_REQ].nPktProc++;;//Number of pkt processed in tti
+ SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC_DAT_REQ].nPktProc++;//Number of pkt processed in tti
if(datReqRing->msg)
{
if(datReqRing->event == EVTRGUDDATREQ)
{
/* Read from Ring Buffer and process PDCP packets */
- U8 rngBufDeqIndx = 0;
+ uint8_t rngBufDeqIndx = 0;
PRIVATE Pst rgDStaRbfuPst ={1,1,ENTMAC,0,ENTRLC,1,PRIOR0,RTESPEC,EVTRGUDSTARSP,0,0,2,0};
PRIVATE Pst rgCStaRbfuPst ={1,1,ENTMAC,0,ENTRLC,1,PRIOR0,RTESPEC,EVTRGUCSTARSP,0,0,2,0};
Void *elmIndx = NULLP;
while(NULLP != elmIndx)
{
staRspRing= (RguInfoRingElem *)elmIndx;
- SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC].nPktProc++;;//Number of pkt processed in tti
+ SsRngInfoTbl[SS_RNG_BUF_DLRLC_TO_DLMAC].nPktProc++;//Number of pkt processed in tti
if(staRspRing->msg!= NULLP)
{
rgFreeSBuf(inst,(Data **)&ue, sizeof(*ue));
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
} /* rgRAMFreeUeCb */
RgErrInfo *err;
#endif
{
- U8 idx1,idx2;
+ uint8_t idx1,idx2;
Buffer *rarPdu;
RgDlSf *dlSf;
- U8 idx;
+ uint8_t idx;
if(NULLP == rarInfo->raRntiInfo)
{
#if 0
RgCellCb *cell;
RgUeCb *ue;
- U8 idx1,idx2;
+ uint8_t idx1,idx2;
RgDlHqProcCb *hqProc;
- U8 hqPId;
+ uint8_t hqPId;
RgErrInfo err;
Pst schPst;
RgInfDedBoRpt boRpt;
#ifdef LTEMAC_DLUE_TMGOPTMZ
S16 ret;
#endif
- U32 idx;
- //U8 datReqFailCnt = 0;
+ uint32_t idx;
+ //uint8_t datReqFailCnt = 0;
if (((cell = rgCb[inst].cell) == NULLP)
for(idx = 0; idx < datReq->nmbOfUeGrantPerTti; idx++)
{
- timingInfo.slot = (U8)((datReq->datReq[idx].transId >> 8) & 0XFF);
- timingInfo.sfn = (U16)((datReq->datReq[idx].transId >> 16) & 0xFFFF);
+ timingInfo.slot = (uint8_t)((datReq->datReq[idx].transId >> 8) & 0XFF);
+ timingInfo.sfn = (uint16_t)((datReq->datReq[idx].transId >> 16) & 0xFFFF);
sf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
if( (sf->txDone == TRUE) ||
rgUpdtRguDedSts(inst,cell->rguDlSap,RG_RGU_SDU_DROP, datReq);
#ifdef CA_DBG
{
- EXTERN U32 dbgDelayedDatReqInMac;
+ EXTERN uint32_t dbgDelayedDatReqInMac;
dbgDelayedDatReqInMac++;
}
#endif /* CA_DBG */
continue;
}
- hqPId = (U8)(datReq->datReq[idx].transId);
+ hqPId = (uint8_t)(datReq->datReq[idx].transId);
hqPId = hqPId >> 2;
/* get harq process and invoke DHM */
rgDHMGetHqProcFrmId(ue, hqPId, &hqProc);
/*Get the timing Info*/
/* ADD Changes for Downlink UE Timing Optimization */
#ifdef LTEMAC_DLUE_TMGOPTMZ
- timingInfo.slot = (U8)((datReq->transId >> 8) & 0XFF);
- timingInfo.sfn = (U16)((datReq->transId >> 16) & 0xFFFF);
+ timingInfo.slot = (uint8_t)((datReq->transId >> 8) & 0XFF);
+ timingInfo.sfn = (uint16_t)((datReq->transId >> 16) & 0xFFFF);
#endif
}
else
/*Get the timing Info*/
/* ADD Changes for Downlink UE Timing Optimization */
#ifdef LTEMAC_DLUE_TMGOPTMZ
- timingInfo.slot = (U8)(datReq->transId & 0XFF);
- timingInfo.sfn = (U16)((datReq->transId >> 8) & 0xFFFF);
+ timingInfo.slot = (uint8_t)(datReq->transId & 0XFF);
+ timingInfo.sfn = (uint16_t)((datReq->transId >> 8) & 0xFFFF);
#endif
}
{
Inst inst = cell->macInst - RG_INST_START;
RgUeCb *ue;
- U8 hqPId;
+ uint8_t hqPId;
RgDlHqProcCb *hqProc;
CmLteTimingInfo timingInfo;
RgDlSf *sf;
}
}
- timingInfo.slot = (U8)((datReq->transId >> 8) & 0XFF);
- timingInfo.sfn = (U16)((datReq->transId >> 16) & 0xFFFF);
+ timingInfo.slot = (uint8_t)((datReq->transId >> 8) & 0XFF);
+ timingInfo.sfn = (uint16_t)((datReq->transId >> 16) & 0xFFFF);
sf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
if( (sf->txDone == TRUE) ||
return RFAILED;
}
- hqPId = (U8)(datReq->transId);
+ hqPId = (uint8_t)(datReq->transId);
hqPId = hqPId >> 2;
/* get harq process and invoke DHM */
RgUstaDgn dgn; /* Alarm diagnostics structure */
#endif
- timingInfo.slot = (U8)(datReq->transId & 0XFF);
- timingInfo.sfn = (U16)((datReq->transId >> 8) & 0xFFFF);
+
+ timingInfo.slot = (uint8_t)(datReq->transId & 0XFF);
+ timingInfo.sfn = (uint16_t)((datReq->transId >> 8) & 0xFFFF);
sf = &cell->subFrms[(timingInfo.slot % RG_NUM_SUB_FRAMES)];
if( (sf->txDone == TRUE) ||
{
RgCellCb *cell;
RgUeCb *ue;
- U8 lcgId;
- U8 loop;
+ uint8_t lcgId;
+ uint8_t loop;
if(((cell = rgCb[inst].cell) != NULLP)
&&(cell->cellId == measReq->cellId))
This assumes that BO is not received more than 4 frames in advance from the enodeb application */
if (cell->bcchBchInfo.lcId == staRsp->lcId)
{
- U16 nextBchSfn;
+ uint16_t nextBchSfn;
nextBchSfn = (cell->crntTime.sfn + 4 - (cell->crntTime.sfn%4)) % RG_MAX_SFN;
if ((staRsp->u.timeToTx.sfn != nextBchSfn) ||
RgCellCb *cellCb,
TfuDatInfo *datInfo,
RgInfCeInfo *ceInfo,
-U16 slot
+uint16_t slot
));
PRIVATE S16 rgTOMProcCCCHSduInDatInd ARGS((
RgCellCb *cellCb,
TfuDatInfo *datInfo,
RgInfCeInfo *ceInfo,
-U16 slot
+uint16_t slot
));
S16 rgHndlFlowCntrl
TB, which is not guaranteed if higher Range values are used */
/* Note: taking value 10 for BSR index 1 */
#ifndef MAC_5GTF_UPDATE
-PRIVATE U32 rgLwrBsrTbl[64] = {
+PRIVATE uint32_t rgLwrBsrTbl[64] = {
0, 10, 10, 12, 14, 17, 19, 22, 26,
31, 36, 42, 49, 57, 67, 78, 91,
107, 125, 146, 171, 200, 234, 274, 321,
};
#else
-PRIVATE U32 rgLwrBsrTbl[64] = {
+PRIVATE uint32_t rgLwrBsrTbl[64] = {
0,10,13,16,19,23,29,35,43,53,65,80,98,120,147,181,223,274,337,414,
509,625,769,945,1162,1429,1757,2161,2657,3267,4017,4940,6074,7469,
9185,11294,13888,17077,20999,25822,31752,39045,48012,59039,72598,
}
/* global variables */
-U32 rgUlrate_tfu;
+uint32_t rgUlrate_tfu;
#ifdef EMTC_ENABLE
-EXTERN U32 grgUlrate_tfu;
+EXTERN uint32_t grgUlrate_tfu;
#endif
/** @brief This function fills the PDSCH data of a downlink subframe
TfuDatReqPduInfo *datReq=NULLP;
/* Moving node declaration to limited scope for optimization */
RgDlHqProcCb *hqCb;
- U8 idx;
+ uint8_t idx;
Inst inst = cellCb->macInst - RG_INST_START;
return ROK;
} /* end of */
-U32 rgMacGT;
+uint32_t rgMacGT;
/** @brief This function allocates the RgMacPdu that will be populated by DEMUX
* with the SubHeaders list and the values of the Control elements.
Mem evntMem;
RgUstaDgn dgn; /* Alarm diagnostics structure */
- VOLATILE U32 startTime=0;
+ VOLATILE uint32_t startTime=0;
evntMem.region = rgCb[inst].rgInit.region;
}
}
RG_FREE_MEM(pdu);
- RETVOID;
+ return;
} /* end of rgTOMUtlFreePduEvnt */
/** @brief This function allocates the RgMacPdu that will be populated by DEMUX
Mem evntMem;
RgUstaDgn dgn; /* Alarm diagnostics structure */
- VOLATILE U32 startTime=0;
+ VOLATILE uint32_t startTime=0;
evntMem.region = rgCb[inst].rgInit.region;
{
RG_FREE_MEM(sfInfo);
- RETVOID;
+ return;
} /* end of rgTOMUtlFreePduEvnt */
#ifdef LTE_L2_MEAS
RgRguDedDatInd *dDatInd;
#endif
{
- U8 lcId;
- U8 lcgId;
- U8 loop;
+ uint8_t lcId;
+ uint8_t lcgId;
+ uint8_t loop;
dDatInd->burstInd = RGU_L2M_UL_BURST_END;
for(loop=0;loop<dDatInd->numLch;loop++)
* @param [in] RgUeCb *ueCb
* @param [in] CmLteRnti rnti
* @param [in] RgMacPdu *pdu
- * @param [out] U32 *lcgBytes
+ * @param [out] uint32_t *lcgBytes
*
* @return S16
* -# ROK
RgMacPdu *pdu,
Bool isSpsRnti,
Bool *spsToBeActvtd,
- U16 *sduSize,
- U16 slot,
- U32 *lcgBytes
+ uint16_t *sduSize,
+ uint16_t slot,
+ uint32_t *lcgBytes
)
#else
PRIVATE S16 rgTOMUtlProcMsg(cellCb, ueCb, pdu, isSpsRnti,spsToBeActvtd,sduSize, slot, lcgBytes)
RgMacPdu *pdu;
Bool isSpsRnti;
Bool *spsToBeActvtd;
- U16 *sduSize;
- U16 slot;
- U32 *lcgBytes;
+ uint16_t *sduSize;
+ uint16_t slot;
+ uint32_t *lcgBytes;
#endif
#else /* LTEMAC_SPS */
#ifdef ANSI
RgCellCb *cellCb,
RgUeCb *ueCb,
RgMacPdu *pdu,
- U16 slot,
- U32 *lcgBytes
+ uint16_t slot,
+ uint32_t *lcgBytes
)
#else
PRIVATE S16 rgTOMUtlProcMsg(cellCb, ueCb, pdu, slot, lcgBytes)
RgCellCb *cellCb;
RgUeCb *ueCb;
RgMacPdu *pdu;
- U16 slot;
- U32 *lcgByes;
+ uint16_t slot;
+ uint32_t *lcgByes;
#endif
#endif
{
#endif
#ifdef LTE_L2_MEAS
- U8 idx1;
- U8 idx2;
- RgUlSf *ulSf;
- U16 totalBytesRcvd = 0;
- U16 sduLen[RGU_MAX_LC] = {0};
- U8 qciVal[RGU_MAX_LC] = {0};
- U8 numPrb = 0;
+ uint8_t idx1;
+ uint8_t idx2;
+ RgUlSf *ulSf;
+ uint16_t totalBytesRcvd = 0;
+ uint16_t sduLen[RGU_MAX_LC] = {0};
+ uint8_t qciVal[RGU_MAX_LC] = {0};
+ uint8_t numPrb = 0;
#endif
- U8 lcgId;
- MsgLen bufSz;
+ uint8_t lcgId;
+ MsgLen bufSz;
/* Moved outside of LTE_L2_MEAS
* scope as this pointer will now be used to
(
RgMacPdu *pdu,
RgInfSfDatInd *sfInfo,
-RgInfCeInfo *ceInfo,
-CmLteRnti rnti,
-Bool spsToBeActvtd,
-U16 sduSize,
-U32 *lcgBytes
+RgInfCeInfo *ceInfo,
+CmLteRnti rnti,
+Bool spsToBeActvtd,
+uint16_t sduSize,
+uint32_t *lcgBytes
)
#else
PRIVATE S16 rgTOMUtlInsSchInfo (pdu, sfInfo, ceInfo, rnti,spsToBeActvtd,sduSize, lcgBytes)
RgMacPdu *pdu;
-RgInfSfDatInd *sfInfo;
-RgInfCeInfo *ceInfo;
-CmLteRnti rnti;
-Bool spsToBeActvtd;
-U16 sduSize;
-U32 *lcgBytes;
+RgInfSfDatInd *sfInfo;
+RgInfCeInfo *ceInfo;
+CmLteRnti rnti;
+Bool spsToBeActvtd;
+uint16_t sduSize;
+uint32_t *lcgBytes;
#endif
#else
RgInfSfDatInd *sfInfo,
RgInfCeInfo *ceInfo,
CmLteRnti rnti,
-U32 *lcgBytes
+uint32_t *lcgBytes
)
#else
PRIVATE S16 rgTOMUtlInsSchInfo (pdu, sfInfo, ceInfo, rnti, lcgBytes)
RgInfSfDatInd *sfInfo;
RgInfCeInfo *ceInfo;
CmLteRnti rnti;
-U32 *lcgBytes;
+uint32_t *lcgBytes;
#endif
#endif
{
S16 ret;
RgInfUeDatInd *ueInfo;
- U32 lcgId = 0;
- U32 idx = 0;
+ uint32_t lcgId = 0;
+ uint32_t idx = 0;
RG_TOM_INF_ALLOC(sfInfo, sizeof(RgInfUeDatInd), ueInfo, ret);
CmLList *node;
TfuDatInfo *datInfo;
RgLowSapCb *tfuSap;
- U16 slot;
+ uint16_t slot;
#ifdef LTEMAC_SPS
Bool isSpsRnti=FALSE;
Pst schPst1;
// RgInfSpsRelInfo relInfo;
- Bool spsToBeActvtd = FALSE;
- U16 sduSize = 0;
+ Bool spsToBeActvtd = FALSE;
+ uint16_t sduSize = 0;
#endif
- U32 lcgBytes[RGINF_MAX_LCG_PER_UE];
+ uint32_t lcgBytes[RGINF_MAX_LCG_PER_UE];
#ifdef STUB_TTI_HANDLING_5GTF
{
datInfo = (TfuDatInfo*)node->node;
{
- //extern U32 ulrate_tfu;
+ //extern uint32_t ulrate_tfu;
MsgLen len;
SFndLenMsg(datInfo->mBuf, &len);
#ifdef STUB_TTI_HANDLING_5GTF
rgTOML2MCompileActiveLCs (cellCb, ueCb, pdu, &ceInfo);
#endif
#ifdef LTEMAC_SPS
- if ((ret = rgTOMUtlProcMsg(cellCb, ueCb, pdu, isSpsRnti,&spsToBeActvtd,&sduSize, slot, (U32 *)&lcgBytes)) != ROK)
+ if ((ret = rgTOMUtlProcMsg(cellCb, ueCb, pdu, isSpsRnti,&spsToBeActvtd,&sduSize, slot, (uint32_t *)&lcgBytes)) != ROK)
#else
- if ((ret = rgTOMUtlProcMsg (cellCb, ueCb, pdu, slot, (U32 *)&lcgBytes)) != ROK)
+ if ((ret = rgTOMUtlProcMsg (cellCb, ueCb, pdu, slot, (uint32_t *)&lcgBytes)) != ROK)
#endif /* LTEMAC_SPS */
{
rgTOMUtlFreePduEvnt (pdu, TRUE);
#ifdef LTEMAC_SPS
- if(rgTOMUtlInsSchInfo(pdu, sfInfo, &ceInfo, datInfo->rnti,spsToBeActvtd,sduSize, (U32 *)&lcgBytes) != ROK)
+ if(rgTOMUtlInsSchInfo(pdu, sfInfo, &ceInfo, datInfo->rnti,spsToBeActvtd,sduSize, (uint32_t *)&lcgBytes) != ROK)
#else
- if(rgTOMUtlInsSchInfo(pdu, sfInfo, &ceInfo, datInfo->rnti, (U32 *)&lcgBytes) != ROK)
+ if(rgTOMUtlInsSchInfo(pdu, sfInfo, &ceInfo, datInfo->rnti, (uint32_t *)&lcgBytes) != ROK)
#endif
{
/* Update PRB used for all GBR QCIs to scheduler */
memcpy( &sfInfo->qcisUlPrbCnt[0],
&cellCb->qcisUlPrbCnt[0],
- (RGM_MAX_QCI_REPORTS * sizeof(U32)));
+ (RGM_MAX_QCI_REPORTS * sizeof(uint32_t)));
/* clear the cellCb ul prb value */
memset(&cellCb->qcisUlPrbCnt[0], 0,
- (RGM_MAX_QCI_REPORTS * sizeof(U32)));
+ (RGM_MAX_QCI_REPORTS * sizeof(uint32_t)));
/* RRM_RBC_Y */
#endif
{
Inst inst = cell->macInst - RG_INST_START;
- U8 idx;
+ uint8_t idx;
RgUlSf *ulSf;
S16 ret;
RgDlSf *dlSf;
#endif
{
- U8 idx;
+ uint8_t idx;
if(dlSf->txDone == FALSE)
RLC-MAC */
dlSf->statIndDone = FALSE;
#endif
- if (dlSf->tbs.count)
- {
- U8 i;
+ if (dlSf->tbs.count)
+ {
+ uint8_t i;
CmLList *node;
RgDlHqProcCb *hqP;
- RGDBGERRNEW(inst, (rgPBuf(inst),
+ RGDBGERRNEW(inst, (rgPBuf(inst),
"Error Stale TBs in Subframes TBS list\n"));
node = dlSf->tbs.first;
- while(node)
- {
- hqP = (RgDlHqProcCb*)node->node;
- node = node->next;
+ while(node)
+ {
+ hqP = (RgDlHqProcCb*)node->node;
+ node = node->next;
if (hqP)
{
for(i=0;i< RG_MAX_TB_PER_UE;i++)
cmLListInit(&dlSf->tbs);
dlSf->txDone = FALSE;
dlSf->numRaRsp = 0;
- RETVOID;
+ return;
}
/**
{
RguFlowCntrlInd *flowCntrlInd;
Pst *pst;
- U32 ueIdx;
- U32 lcIdx;
+ uint32_t ueIdx;
+ uint32_t lcIdx;
pst = &cell->rguDlSap->sapCfg.sapPst;
/* flowCntrlInd is alloced in cell init time and will be re-used throughout */
RgCellCb *cell;
RgDlSf *dlSf;
RgErrInfo err;
- VOLATILE U32 startTime=0;
+ VOLATILE uint32_t startTime=0;
Inst inst;
RgCellCb *cellCb,
TfuDatInfo *datInfo,
RgInfCeInfo *ceInfo,
-U16 slot
+uint16_t slot
)
#else
PRIVATE S16 rgTOMProcCrntiCEInDatInd( pdu, prevUeCb, cellCb, datInfo, ceInfo, slot)
RgCellCb *cellCb;
TfuDatInfo *datInfo;
RgInfCeInfo *ceInfo;
-U16 slot;
+uint16_t slot;
#endif
{
RgUeCb *ueCb = NULLP;
#ifdef LTEMAC_SPS
Bool spsToBeActvtd;
- U16 sduSize;
+ uint16_t sduSize;
#endif
RgCellCb *cellCb,
TfuDatInfo *datInfo,
RgInfCeInfo *ceInfo,
-U16 slot
+uint16_t slot
)
#else
PRIVATE S16 rgTOMProcCCCHSduInDatInd( pdu, prevUeCb, cellCb, datInfo, ceInfo, slot)
RgCellCb *cellCb;
TfuDatInfo *datInfo;
RgInfCeInfo *ceInfo;
-U16 slot;
+uint16_t slot;
#endif
{
RgUeCb *ueCb = NULLP;
#ifdef LTEMAC_SPS
Bool spsToBeActvtd;
- U16 sduSize;
+ uint16_t sduSize;
#endif
RgInfCeInfo *ceInfo;
#endif
{
- U8 lcgId;
- U8 bsr;
+ uint8_t lcgId;
+ uint8_t bsr;
if(ceInfo->bitMask & RG_TRUNC_BSR_CE_PRSNT)
{
#endif
{
ueCb->ul.hqEnt.maxHqRetx = (ueCfg->ueUlHqCfg.maxUlHqTx - 1);
- RETVOID;
+ return;
} /* rgUHMCrgUeCfg */
/**
{
ueCb->ul.hqEnt.maxHqRetx = (ueRecfg->ueUlHqRecfg.maxUlHqTx - 1);
- RETVOID;
+ return;
} /* rgUHMCrgUeCfg */
/**********************************************************************
#if defined(SPLIT_RLC_DL_TASK) && defined(RLC_MAC_STA_RSP_RBUF)
S16 rgBatchProc(Void);
#endif
-U8 rgRguDlSap;
-U8 rgRguUlSap;
+uint8_t rgRguDlSap;
+uint8_t rgRguUlSap;
/**
* @brief Handler for Bind request.
*
*
* @param[in] Inst inst
* @param[in] SuId suId
- * @param[in] U8 status
+ * @param[in] uint8_t status
* @return S16
* -# ROK
* -# RFAILED
(
Inst inst,
SpId spId,
-U8 status
+uint8_t status
)
#else
S16 rgUIMRguBndCfm(inst,spId, status)
Inst inst;
SpId spId;
-U8 status;
+uint8_t status;
#endif
{
S16 ret = ROK;
S16 ret = ROK;
Inst inst;
#ifndef NO_ERRCLS
- U32 id;
- U32 id1;
- U32 id2;
- U32 id3;
+ uint32_t id;
+ uint32_t id1;
+ uint32_t id2;
+ uint32_t id3;
#endif
RG_IS_INST_VALID(pst->dstInst);
#endif
{
Inst inst;
-
- S16 ret = ROK;
- VOLATILE U32 startTime = 0;
+ S16 ret = ROK;
+ VOLATILE uint32_t startTime = 0;
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
*
* @param[in] Inst inst
* @param[in] SuId suId
- * @param[in] U8 status
+ * @param[in] uint8_t status
* @return S16
* -# ROK
* -# RFAILED
(
Inst inst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 rgUIMCrgBndCfm(inst,suId, status)
Inst inst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
{
Inst inst;
S16 ret = ROK;
- U8 cfmStatus = 0x00ff;
- U8 prntTrans[CRG_CFG_TRANSID_SIZE+1];
+ uint8_t cfmStatus = 0x00ff;
+ uint8_t prntTrans[CRG_CFG_TRANSID_SIZE+1];
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
*
* @param[in] Inst inst
* @param[in] CrgCfgTransId transId
- * @param[in] U8 status
+ * @param[in] uint8_t status
* @return S16
* -# ROK
* -# RFAILED
(
Inst inst,
CrgCfgTransId transId,
-U8 status
+uint8_t status
)
#else
S16 rgUIMCrgCfgCfm(inst,transId, status)
Inst inst;
CrgCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
S16 ret = ROK;
- U8 prntTrans[CRG_CFG_TRANSID_SIZE+1];
+ uint8_t prntTrans[CRG_CFG_TRANSID_SIZE+1];
memcpy(prntTrans, transId.trans, CRG_CFG_TRANSID_SIZE);
prntTrans[CRG_CFG_TRANSID_SIZE] = '\0';
Pst pst = {0};
SpId spId = 0;
RguDStaRspInfo *staRsp;
- U32 elmIndx = 0;
+ uint32_t elmIndx = 0;
#ifndef LTE_ADV
/* Fill pst */
pst.srcProcId = 1;
#else
#endif
- elmIndx = (U32)SRngGetRIndx(SS_RNG_BUF_DLRLC_TO_DLMAC);
+ elmIndx = (uint32_t)SRngGetRIndx(SS_RNG_BUF_DLRLC_TO_DLMAC);
while(NULLP != elmIndx)
{
staRsp = (RguDStaRspInfo *)elmIndx;
staRsp = NULLP;
SRngIncrRIndx(SS_RNG_BUF_DLRLC_TO_DLMAC);
- if((elmIndx = (U32)SRngGetRIndx(SS_RNG_BUF_DLRLC_TO_DLMAC)) == NULLP)
+ if((elmIndx = (uint32_t)SRngGetRIndx(SS_RNG_BUF_DLRLC_TO_DLMAC)) == NULLP)
break;
}
return ROK;
* previously allocated by rgAllocSBuf() and size. It
* deallocates the memory.
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: ccpu00117052 - MOD- changed the Data parameter from
* pointer to address of pointer so that
if ((data == NULLP) || (*data == NULLP) || (size == 0))
{
- RETVOID;
+ return;
}
/* Deallocate buffer */
if (ret != ROK)
{
- RETVOID;
+ return;
}
*data = NULLP;
- RETVOID;
+ return;
} /* end of rgFreeSharableBuf */
* previously allocated by rgAllocSBuf() and size. It
* deallocates the memory.
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: ccpu00117052 - MOD- changed the Data parameter from
* pointer to address of pointer so that
if ((data == NULLP) || (*data == NULLP) || (size == 0))
{
- RETVOID;
+ return;
}
if (ret != ROK)
{
RGLOGERROR(inst,ERRCLS_DEBUG, ERG029, (ErrVal) 0, "rgFreeSBuf failed.\n");
- RETVOID;
+ return;
}
*data = NULLP;
- RETVOID;
+ return;
} /* end of rgFreeSBuf */
(
Inst inst,
RgUstaDgn *dgn,
-U8 dgnType
+uint8_t dgnType
)
#else
Void rgFillDgnParams(inst,dgn, dgnType)
Inst inst;
RgUstaDgn *dgn;
-U8 dgnType;
+uint8_t dgnType;
#endif
{
switch(dgnType)
{
case LRG_USTA_DGNVAL_MEM:
- dgn->type = (U8) LRG_USTA_DGNVAL_MEM;
+ dgn->type = (uint8_t) LRG_USTA_DGNVAL_MEM;
dgn->u.mem.region = rgCb[inst].rgInit.region;
dgn->u.mem.pool = rgCb[inst].rgInit.pool;
break;
break;
}
- RETVOID;
+ return;
} /* end of rgFillDgnParams */
Void rgUpdtRguDedSts
(
Inst inst,
-RgUpSapCb *rguDlSap,
-U8 stsType, /* Statistics type to update */
+RgUpSapCb *rguDlSap,
+uint8_t stsType, /* Statistics type to update */
RgRguDedDatReq *datReq /* DatReq pointer */
)
#else
Void rgUpdtRguDedSts(inst,rguDlSap,stsType, datReq)
Inst inst;
-RgUpSapCb *rguDlSap;
-U8 stsType; /* Statistics type to update */
+RgUpSapCb *rguDlSap;
+uint8_t stsType; /* Statistics type to update */
RgRguDedDatReq *datReq; /* DatReq pointer */
#endif
{
- U8 idx1,idx2;
- U32 idx;
+ uint8_t idx1,idx2;
+ uint32_t idx;
switch(stsType)
{
break;
}
- RETVOID;
+ return;
} /* rgUpdtRguDedSts */
(
Inst inst,
RgUpSapCb *rguDlSap,
-U8 stsType /* Statistics type to update */
+uint8_t stsType /* Statistics type to update */
)
#else
Void rgUpdtRguCmnSts(inst,rguDlSap,stsType)
Inst inst;
RgUpSapCb *rguDlSap;
-U8 stsType; /* Statistics type to update */
+uint8_t stsType; /* Statistics type to update */
#endif
{
break;
}
- RETVOID;
+ return;
} /* rgUpdtRguCmnSts */
Void rgUpdtCellCnt
(
Inst inst,
-U8 updtType
+uint8_t updtType
)
#else
Void rgUpdtCellCnt(inst,updtType)
Inst inst;
-U8 updtType;
+uint8_t updtType;
#endif
{
break;
}
- RETVOID;
+ return;
} /* rgUpdtCellCnt */
Void rgUpdtUeCnt
(
Inst inst,
-U8 updtType
+uint8_t updtType
)
#else
Void rgUpdtUeCnt (inst,updtType)
Inst inst;
-U8 updtType;
+uint8_t updtType;
#endif
{
switch (updtType)
default:
break;
}
- RETVOID;
+ return;
} /* rgUpdtUeCnt */
/*
#endif
{
Mem sMem;
- VOLATILE U32 startTime=0;
+ VOLATILE uint32_t startTime=0;
sMem.region = rgCb[inst].rgInit.region;
sMem.pool = rgCb[inst].rgInit.pool;
pst->intfVer = 0;
pst->route = RTESPEC;
- RETVOID;
+ return;
} /* end of rgGetPstToInst */
/***********************************************************
Inst inst;
RgCellCb *cell= NULLP;
RgUeCb *ue;
- U8 idx;
+ uint8_t idx;
RG_IS_INST_VALID(pst->dstInst);
inst = pst->dstInst - RG_INST_START;
#endif
{
Inst inst = cell->macInst - RG_INST_START;
- U8 idx = 0;
+ uint8_t idx = 0;
Inst sCellInstIdx;
Pst dstInstPst;
RgPrgUeSCellDelInfo ueSCellDelInfo;
Pst dstInstPst;
RgPrgUeSCellDelInfo ueIdChngReq;
RgUeCb *ue;
- U8 idx;
+ uint8_t idx;
#ifdef L2_OPTMZ
TfuDelDatReqInfo delDatReq;
#endif
}
}
- RETVOID;
+ return;
} /* end of rgUtlHndlCrntiRls */
/**
/* Update poll bit in the buffer */
#define RLC_UPD_POLL_BIT(_gCb, _retx, _poll) \
{ \
- U8 fHdr; \
+ uint8_t fHdr; \
\
if (_poll != _retx->amHdr.p) \
{ \
#define RLC_PRNT_MEMINFO(_cb) \
do \
{ \
- U32 _memInfo; \
+ uint32_t _memInfo; \
if(_cb->init.dbgMask & (RLC_DBGMASK_MEM_INFO)) \
{ \
RLC_PRNT_HLINE(_cb,("\nMemory Information:\n")); \
#endif /* __cplusplus */
/** @brief Local typedefs */
-typedef U32 RlcSn; /*!< Sequence Number length */
+typedef uint32_t RlcSn; /*!< Sequence Number length */
typedef RguDDatIndInfo KwDatIndInfo;
typedef struct _amRlcStats
{
- U32 numDLStaPduSent;
- U32 numDLNacksInStaPdu;
- U32 numDLBytesUnused;
- U32 numDLPollTimerExpiresSrb;
- U32 numDLPollTimerExpiresDrb;
- U32 numDLMaxRetx;
- U32 numDLRetransPdus;
- U32 numULPdusDiscarded;
- U32 numULReOrdTimerExpires;
- U32 numULStaPduRcvd;
- U32 numULNackInStaPduRcvd;
- U32 numRlcAmCellSduTx; /* Count of SDUs transmitted in DL for all UEs */
- U32 numRlcAmCellSduBytesTx; /*Total number of bytes transmitted in DL for all Ues */
- U32 numRlcAmCellRetxPdu; /*Count of PDUs retransmitted for all Ues */
- U32 numRlcAmMaxRetx; /*Total number of Max-RLC retransmissions hit for all the Ues */
- U32 numRlcAmCellDupPduRx; /*Count of Duplicate PDUs detected for a UE in UL for all Ues */
- U32 numRlcAmCellDropOutWinRx; /*Count of PDUs dropped due to Out of Window reception for all Ues */
- U32 numRlcAmCellSduRx; /* Count of SDUs received in UL for all UEs*/
- U32 numRlcAmCellSduBytesRx;/*Total number of bytes received in UL for all Ues*/
- U32 numRlcAmCellNackRx; /*Total number of UL PDUs nacked for all the Ues*/
- U32 numRlcAmCellWinStall; /*Number of window stalls detected for all the Ues */
+ uint32_t numDLStaPduSent;
+ uint32_t numDLNacksInStaPdu;
+ uint32_t numDLBytesUnused;
+ uint32_t numDLPollTimerExpiresSrb;
+ uint32_t numDLPollTimerExpiresDrb;
+ uint32_t numDLMaxRetx;
+ uint32_t numDLRetransPdus;
+ uint32_t numULPdusDiscarded;
+ uint32_t numULReOrdTimerExpires;
+ uint32_t numULStaPduRcvd;
+ uint32_t numULNackInStaPduRcvd;
+ uint32_t numRlcAmCellSduTx; /* Count of SDUs transmitted in DL for all UEs */
+ uint32_t numRlcAmCellSduBytesTx; /*Total number of bytes transmitted in DL for all Ues */
+ uint32_t numRlcAmCellRetxPdu; /*Count of PDUs retransmitted for all Ues */
+ uint32_t numRlcAmMaxRetx; /*Total number of Max-RLC retransmissions hit for all the Ues */
+ uint32_t numRlcAmCellDupPduRx; /*Count of Duplicate PDUs detected for a UE in UL for all Ues */
+ uint32_t numRlcAmCellDropOutWinRx; /*Count of PDUs dropped due to Out of Window reception for all Ues */
+ uint32_t numRlcAmCellSduRx; /* Count of SDUs received in UL for all UEs*/
+ uint32_t numRlcAmCellSduBytesRx;/*Total number of bytes received in UL for all Ues*/
+ uint32_t numRlcAmCellNackRx; /*Total number of UL PDUs nacked for all the Ues*/
+ uint32_t numRlcAmCellWinStall; /*Number of window stalls detected for all the Ues */
}AMRLCStats;
typedef struct _umRlcStats
{
- U32 numDLBytesUnused;
- U32 numDLMaxRetx;
- U32 numULPdusDiscarded;
- U32 numULReOrdTimerExpires;
- U32 numULPdusOutsideWindow;
+ uint32_t numDLBytesUnused;
+ uint32_t numDLMaxRetx;
+ uint32_t numULPdusDiscarded;
+ uint32_t numULReOrdTimerExpires;
+ uint32_t numULPdusOutsideWindow;
}UMRLCStats;
typedef struct _rlcStats
*/
typedef struct rlcUmHdr
{
- U8 fi; /*!< Framing Info */
- RlcSn sn; /*!< Sequence number */
- U16 numLi; /*!< Number of LIs */
- U16 li[RLC_MAX_UL_LI]; /*!< Array of LIs */
+ uint8_t fi; /*!< Framing Info */
+ RlcSn sn; /*!< Sequence number */
+ uint16_t numLi; /*!< Number of LIs */
+ uint16_t li[RLC_MAX_UL_LI]; /*!< Array of LIs */
}RlcUmHdr;
/**
*/
typedef struct rlcAmHdr
{
- U8 dc; /*!< Data/Control PDU */
- U8 p; /*!< Poll bit */
- U8 si; /*!< Segmentation Info: 5GNR */
- RlcSn sn; /*!< Sequence number */
- U32 so; /*!< Segment offset */
+ uint8_t dc; /*!< Data/Control PDU */
+ uint8_t p; /*!< Poll bit */
+ uint8_t si; /*!< Segmentation Info: 5GNR */
+ RlcSn sn; /*!< Sequence number */
+ uint32_t so; /*!< Segment offset */
}RlcAmHdr;
/* structures used for encoding/decoding the headers */
typedef struct rlcCntrlInfo
{
- U16 val;
- U8 len;
- U16 idx;
- U8 emtBits;
- U16 e1Idx;
- U16 e2Idx;
- U8 e1eb;
+ uint16_t val;
+ uint8_t len;
+ uint16_t idx;
+ uint8_t emtBits;
+ uint16_t e1Idx;
+ uint16_t e2Idx;
+ uint8_t e1eb;
}RlcCntrlInfo;
typedef struct rlcHdrInfo
{
- U32 val;
- U8 len;
- U8 eb;
- U8 *hdr;
- U16 idx;
- U8 pEb;
- U8 pLen;
+ uint32_t val;
+ uint8_t len;
+ uint8_t eb;
+ uint8_t *hdr;
+ uint16_t idx;
+ uint8_t pEb;
+ uint8_t pLen;
}RlcHdrInfo;
typedef struct rlcExtHdr
{
- U32 val;
- U16 len;
- U8 hdr;
- U8 pLen;
+ uint32_t val;
+ uint16_t len;
+ uint8_t hdr;
+ uint8_t pLen;
}RlcExtHdr;
/**
{
struct
{
- U32 numActvUe; /*!< number of active Ue */
- U32 sampOc; /*!< Total number of sampling occasion */
+ uint32_t numActvUe; /*!< number of active Ue */
+ uint32_t sampOc; /*!< Total number of sampling occasion */
}actUe;
struct
{
- U32 dLoss; /*!< Total number of lost packets */
- U32 posPkts; /*!< Total number of positively acknowlegded
+ uint32_t dLoss; /*!< Total number of lost packets */
+ uint32_t posPkts; /*!< Total number of positively acknowlegded
packets */
}uuLoss;
struct /*!< For DL IP throughput */
{
- U32 volSummation; /*!< Sum of data in bytes */
- U32 timeSummation; /*!< Sum of time difference in milli sec*/
+ uint32_t volSummation; /*!< Sum of data in bytes */
+ uint32_t timeSummation; /*!< Sum of time difference in milli sec*/
}dlIpThruput;
struct /*!< For UL IP throughput */
{
- U32 volSummation; /*!< Sum of data in bytes */
- U32 timeSummation; /*!< Sum of time difference in milli sec*/
+ uint32_t volSummation; /*!< Sum of data in bytes */
+ uint32_t timeSummation; /*!< Sum of time difference in milli sec*/
}ulIpThruput;
/* Discard new changes starts */
struct /*!< For UL IP throughput */
{
- U32 discSdus; /*!< Total RLC SDUs discarded */
- U32 totSdus; /*!< Total RLC SDUs received */
+ uint32_t discSdus; /*!< Total RLC SDUs discarded */
+ uint32_t totSdus; /*!< Total RLC SDUs received */
}dlDisc;
struct /*!< For UL IP throughput */
{
- U64 sduDelay; /*!< Total SDUs delay */
- U32 numSdus;
+ uint64_t sduDelay; /*!< Total SDUs delay */
+ uint32_t numSdus;
}dlPjSduDelay;
- U32 totDrbsPerQci; /*!< Total Count of DRB's for this QCI */
+ uint32_t totDrbsPerQci; /*!< Total Count of DRB's for this QCI */
}RlcL2Cntr;
struct rlcSduSnMap
CmLList lstEnt;
Bool failMarked;
Bool fullySent;
- U32 sduId;
- U16 numSn;
- U16 snList[RLC_MAX_PDU_MAP];
- U16 harqAck;
- U16 reqSent;
- U16 rspRcvd;
+ uint32_t sduId;
+ uint16_t numSn;
+ uint16_t snList[RLC_MAX_PDU_MAP];
+ uint16_t harqAck;
+ uint16_t reqSent;
+ uint16_t rspRcvd;
};
typedef struct rlcSnSduMap
{
- U16 sn;
- CmLteLcId lChId; /*!< Logical channel Id */
- U16 numSdu;
+ uint16_t sn;
+ CmLteLcId lChId; /*!< Logical channel Id */
+ uint16_t numSdu;
#ifdef LTE_RLC_R9
Bool isBurstSplitted; /*!< true: burst for this LCH is splitted */
#endif /* LTE_RLC_R9 */
typedef struct rlcTbSnMap
{
CmHashListEnt hlTbEnt;
- U32 tbId;
- U16 prevNumSn;
- U16 numSn;
- RlcSnSduMap snSduMap[RGU_MAX_PDU * RGU_MAX_LC];
+ uint32_t tbId;
+ uint16_t prevNumSn;
+ uint16_t numSn;
+ RlcSnSduMap snSduMap[RGU_MAX_PDU * RGU_MAX_LC];
}RlcTbSnMap;
typedef struct rlcL2MeasCbUeMeasInfo
CmLteCellId cellId; /*!< UE ID (Used only for IP Throughput
in UL/DL */
Bool isValid; /*! < is this UE entry valid */
- U8 numLcId; /*!< Holds the number of LCh for which Ul Ip
+ uint8_t numLcId; /*!< Holds the number of LCh for which Ul Ip
measurement is ON */
- U8 lcId[RLC_MAX_LCH_PER_UE]; /*!< Holds the list of LCh for which Ul ip
+ uint8_t lcId[RLC_MAX_LCH_PER_UE]; /*!< Holds the list of LCh for which Ul ip
measurement is ON */
RlcL2Cntr measData[LKW_MAX_QCI];
- U16 numQci; /*!< number of valid qcI */
- U8 qci[LKW_MAX_QCI]; /*!< list of valid qcI */
+ uint16_t numQci; /*!< number of valid qcI */
+ uint8_t qci[LKW_MAX_QCI]; /*!< list of valid qcI */
}RlcL2MeasCbUeMeasInfo;
typedef struct rlcL2MeasCbIpThMeas
{
- U8 numUes;
- U8 totNumQci;
- U8 totQci[LKW_MAX_QCI];
+ uint8_t numUes;
+ uint8_t totNumQci;
+ uint8_t totQci[LKW_MAX_QCI];
RlcL2MeasCbUeMeasInfo ueInfoLst[LKW_MAX_UE]; /*Added for handling meas for multiple ues*/
}RlcL2MeasCbIpThMeas;
typedef struct rlcL2MeasCbNonIpThMeas
{
- U16 numSamples; /*!< Number of samples to take on numActUe */
- U16 numQci; /*!< number of valid qcI */
- U8 qci[LKW_MAX_QCI]; /*!< list of valid qcI */
+ uint16_t numSamples; /*!< Number of samples to take on numActUe */
+ uint16_t numQci; /*!< number of valid qcI */
+ uint8_t qci[LKW_MAX_QCI]; /*!< list of valid qcI */
RlcL2Cntr measData[LKW_MAX_QCI]; /*!< Measurement CB */
}RlcL2MeasCbNonIpThMeas;
* RLC L2 Measurement CB */
typedef struct rlcL2MeasCb
{
- U8 measType; /*!< Bit-wise set measurement types */
+ uint8_t measType; /*!< Bit-wise set measurement types */
RlcL2MeasCbIpNonIpThMeasVal val; /* Union of IP tpt or non-ip tpt */
}RlcL2MeasCb;
* RLC L2 Measurement Evt CB */
typedef struct rlcL2MeasEvtCb
{
- U32 transId; /*!< TransId of Measurement Req */
- U32 cbIdx; /*!< TransId of Measurement Req */
+ uint32_t transId; /*!< TransId of Measurement Req */
+ uint32_t cbIdx; /*!< TransId of Measurement Req */
CmTimer l2Tmr; /* NOT USED */ /*!< L2 Timer per request */
TmrCfg l2TmrCfg; /* NOT USED */ /*!< Time period of measurement */
- RlcL2MeasCb measCb; /*!< Measurement CB */
+ RlcL2MeasCb measCb; /*!< Measurement CB */
EpcTime startTime; /* NOT USED */ /*!< start time when meas starts*/
}RlcL2MeasEvtCb;
* RLC L2 Measurement Rb CB */
typedef struct rlcL2MeasRbCb
{
- U8 measOn; /*!< Measurements that are running */
+ uint8_t measOn; /*!< Measurements that are running */
RlcL2Cntr *l2Sts[RLC_MAX_L2MEAS_EVT]; /*!< L2 Mesurement statistics */
}RlcL2MeasRbCb;
* RLC L2 CB */
typedef struct rlcL2Cb
{
- U16 rlcNumMeas; /*!< Number of measurements going on */
+ uint16_t rlcNumMeas; /*!< Number of measurements going on */
RlcL2MeasEvtCb rlcL2EvtCb[LKW_MAX_L2MEAS]; /*!< Pointers to Measurement Cb */
- U8 measOn[LKW_MAX_QCI]; /*!< Measurement on */
- U32 numActUe[LKW_MAX_QCI]; /*!< Measurement on */
+ uint8_t measOn[LKW_MAX_QCI]; /*!< Measurement on */
+ uint32_t numActUe[LKW_MAX_QCI]; /*!< Measurement on */
}RlcL2Cb;
* burst sdus in DL for a RB */
typedef struct rlcOutStngSduInfo
{
- U32 sduId; /*!< SDU Id of sdu */
+ uint32_t sduId; /*!< SDU Id of sdu */
MsgLen sduLen; /*!< Size of sdu */
- U32 numTb; /*!< Hold the number of TBs for this sdu in DL */
+ uint32_t numTb; /*!< Hold the number of TBs for this sdu in DL */
}RlcOutStngSduInfo;
/**
* throughput for a RB */
typedef struct rlcL2MeasDlIpTh
{
- Bool isBurstAct; /*!< Set to TRUE when burst is active in DL */
- U64 burstStartTime; /*!< Holds the starting time of the burst */
- U32 burstEndSduId; /*!< Sdu ID when burst ends */
- U8 lastSduIdx; /*!< Holds the index of last outStanding sdu */
+ Bool isBurstAct; /*!< Set to TRUE when burst is active in DL */
+ uint64_t burstStartTime; /*!< Holds the starting time of the burst */
+ uint32_t burstEndSduId; /*!< Sdu ID when burst ends */
+ uint8_t lastSduIdx; /*!< Holds the index of last outStanding sdu */
RlcOutStngSduInfo outStngSduArr[RLC_L2MEAS_MAX_OUTSTNGSDU];/*!< Hold the burst sdu information */
}RlcL2MeasDlIpTh;
* throughput for a RB */
typedef struct rlcL2MeasIpThruput
{
- U32 dataVol; /*!< Holds volume of new data in bytes
+ uint32_t dataVol; /*!< Holds volume of new data in bytes
for UL IP throughput */
- U32 ttiCnt; /*!< Holds ttiCnt received from MAC in UL */
- U32 prevTtiCnt; /*!< Holds previous ttiCnt received from MAC in UL */
+ uint32_t ttiCnt; /*!< Holds ttiCnt received from MAC in UL */
+ uint32_t prevTtiCnt; /*!< Holds previous ttiCnt received from MAC in UL */
RlcL2MeasDlIpTh dlIpTh;
}RlcL2MeasIpThruput;
Pst pst; /*!< Service user post structure */
SpId spId; /*!< Service provider Id */
SuId suId; /*!< Service user Id */
- U8 state; /*!< Sap Status */
+ uint8_t state; /*!< Sap Status */
RlcCkwCntSts sts; /*!< Statistics */
}RlcCkwSapCb;
Pst pst; /*!< Service user post structure */
SpId spId; /*!< Service provider Id */
SuId suId; /*!< Service user Id */
- U8 state; /*!< Sap Status */
- RlcKwuSapSts sts; /*!< Statistics */
+ uint8_t state; /*!< Sap Status */
+ RlcKwuSapSts sts; /*!< Statistics */
}RlcKwuSapCb;
/**
Pst pst; /*!< Service user post structure */
SpId spId; /*!< Service provider Id */
SuId suId; /*!< Service user Id */
- U8 state; /*!< Sap Status */
+ uint8_t state; /*!< Sap Status */
CmTimer bndTmr; /*!< Bind Timer */
- U16 bndTmrInt; /*!< Timer Interval */
- U8 retryCnt; /*!< Bind Retry Count */
+ uint16_t bndTmrInt; /*!< Timer Interval */
+ uint8_t retryCnt; /*!< Bind Retry Count */
}RlcRguSapCb;
/**
Pst pst; /*!< Service user post structure */
SpId spId; /*!< Service provider Id */
SuId suId; /*!< Service user Id */
- U8 state; /*!< Sap Status */
+ uint8_t state; /*!< Sap Status */
CmTimer bndTmr; /*!< Bind Timer */
- U16 bndTmrInt; /*!< Timer Interval */
- U8 retryCnt; /*!< Bind Retry Count */
+ uint16_t bndTmrInt; /*!< Timer Interval */
+ uint8_t retryCnt; /*!< Bind Retry Count */
}RlcUdxUlSapCb;
/**
*/
typedef struct rlcUdxDlSapCb
{
- Pst pst; /*!< Service user post structure */
- SpId spId; /*!< Service provider Id */
- SuId suId; /*!< Service user Id */
- U8 state; /*!< Sap Status */
+ Pst pst; /*!< Service user post structure */
+ SpId spId; /*!< Service provider Id */
+ SuId suId; /*!< Service user Id */
+ uint8_t state; /*!< Sap Status */
}RlcUdxDlSapCb;
/**
*/
typedef struct rlcDlCb
{
- U8 numKwuSaps; /*!< Number of RLC Data Saps */
- U8 numUdxSaps; /*!< Number of RLC Data Saps */
- RlcKwuSapCb *rlcKwuDlSap; /*!< KWU Sap Control Block */
- RlcUdxDlSapCb *udxDlSap; /*!< UDX DL Sap Control Block */
- RlcRguSapCb *rguDlSap; /*!< RGU Sap Control Block */
+ uint8_t numKwuSaps; /*!< Number of RLC Data Saps */
+ uint8_t numUdxSaps; /*!< Number of RLC Data Saps */
+ RlcKwuSapCb *rlcKwuDlSap; /*!< KWU Sap Control Block */
+ RlcUdxDlSapCb *udxDlSap; /*!< UDX DL Sap Control Block */
+ RlcRguSapCb *rguDlSap; /*!< RGU Sap Control Block */
CmHashListCp cellLstCp; /*!< Hashlist of CellCb */
CmHashListCp ueLstCp; /*!< Hashlist of UeCb */
- RlcDlDataToBeFreed toBeFreed; /*!< Pointer to data to be freed */
+ RlcDlDataToBeFreed toBeFreed; /*!< Pointer to data to be freed */
Pst selfPst; /*!< Pst to post events to self */
Buffer *selfPstMBuf; /*!< Buffer used for self post */
Bool shutdownReceived; /*!< Request for shutdown recevied */
typedef struct rlcUlCb
{
RlcCkwSapCb ckwSap; /*!< CKW Sap Conrol Block */
- U8 numKwuSaps; /*!< Number of RLC Data Saps */
- U8 numUdxSaps; /*!< Number of RLC Data Saps */
+ uint8_t numKwuSaps; /*!< Number of RLC Data Saps */
+ uint8_t numUdxSaps; /*!< Number of RLC Data Saps */
RlcUdxUlSapCb *udxUlSap; /*!< UDX DL Sap Control Block */
RlcKwuSapCb *rlcKwuUlSap; /*!< KWU Sap Control Block */
RlcRguSapCb *rguUlSap; /*!< RGU Sap Control Block */
RlcGenCfg genCfg; /*!< General Configuration Structure */
RlcGenSts genSts; /*!< General Statistics */
S16 trcLen; /*!< Trace Length */
- U8 trcMask; /*!< Trace Mask */
+ uint8_t trcMask; /*!< Trace Mask */
CmTqType rlcTq[RLC_TMR_LEN]; /*!< Timer queue */
CmTqCp rlcTqCp; /*!< Timer queue control point */
union
void rlcStartTmr ARGS((RlcCb *gCb, PTR cb, S16 tmrEvnt));
-void rlcStopTmr ARGS((RlcCb *gCb, PTR cb, U8 tmrType));
+void rlcStopTmr ARGS((RlcCb *gCb, PTR cb, uint8_t tmrType));
bool rlcChkTmr ARGS((RlcCb *gCb,PTR cb, S16 tmrEvnt));
#ifdef LTE_L2_MEAS
Void rlcLmmSendAlarm ARGS (( RlcCb *gCb,
- U16 category,
- U16 event,
- U16 cause,
+ uint16_t category,
+ uint16_t event,
+ uint16_t cause,
SuId suId,
- U32 ueId,
- U8 qci));
+ uint32_t ueId,
+ uint8_t qci));
S16 RlcMiRlcDlL2MeasReq ARGS (( Pst *pst, RlcL2MeasReqEvt *measReqEvt ));
-S16 RlcMiRlcDlL2MeasSendReq ARGS((Pst *pst,U8 measType));
-S16 RlcMiRlcDlL2MeasStopReq ARGS((Pst *pst,U8 measType));
+S16 RlcMiRlcDlL2MeasSendReq ARGS((Pst *pst,uint8_t measType));
+S16 RlcMiRlcDlL2MeasStopReq ARGS((Pst *pst,uint8_t measType));
S16 RlcMiRlcUlL2MeasReq ARGS (( Pst *pst, RlcL2MeasReqEvt *measReqEvt ));
-S16 RlcMiRlcUlL2MeasSendReq ARGS((Pst *pst,U8 measType));
-S16 RlcMiRlcUlL2MeasStopReq ARGS((Pst *pst,U8 measType));
+S16 RlcMiRlcUlL2MeasSendReq ARGS((Pst *pst,uint8_t measType));
+S16 RlcMiRlcUlL2MeasStopReq ARGS((Pst *pst,uint8_t measType));
Void rlcUtlPlcMeasDatInL2Sts ARGS((RlcL2Cntr *measData,
RlcL2MeasRbCb *rbL2Cb,
- U8 measType));
+ uint8_t measType));
#else /* LTE_L2_MEAS */
Void rlcLmmSendAlarm ARGS ((RlcCb *gCb,
- U16 category,
- U16 event,
- U16 cause,
+ uint16_t category,
+ uint16_t event,
+ uint16_t cause,
SuId suId,
- U32 ueId));
+ uint32_t ueId));
#endif /* LTE_L2_MEAS */
#ifdef __cplusplus
//UDAY
#ifdef L2_OPTMZ
-extern U32 rlcAmmStaPduList[512];
- U32 rlcAmmStaPduListCnt = 0;
+extern uint32_t rlcAmmStaPduList[512];
+ uint32_t rlcAmmStaPduListCnt = 0;
#endif
**/
#define RLC_MODULE (RLC_DBGMASK_AM | RLC_DBGMASK_DL)
-U32 rlcStatusPduCnt, rlcStatusAckCnt, rlcStatusNcnt, rlcSduSndCnt;
+uint32_t rlcStatusPduCnt, rlcStatusAckCnt, rlcStatusNcnt, rlcSduSndCnt;
/* local defines */
PRIVATE Void rlcGetNxtRetx ARGS ((RlcCb *gCb, RlcRetx **retx));
PRIVATE Void rlcConstructAmHdr ARGS ((RlcAmHdr *amHdr,
- U8 *hdr,
- U8 snLen,
- U16 *idx));
+ uint8_t *hdr,
+ uint8_t snLen,
+ uint16_t *idx));
PRIVATE Void rlcAmmDlUpdateTxAndReTxBufForAckSn ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcNackInfo *nackInfo,
CmLList *retxNode,
RlcNackInfo *nackSnInfo,
-U8 idx
+uint8_t idx
));
PRIVATE Void rlcAmmDlUpdTxAndReTxBufForLessThanNackSn ARGS(
}
}
- RETVOID;
+ return;
}
/**
{
amDl->txNextAck = sn;
- RETVOID;
+ return;
}
/**
rlcRemRetxPdu(gCb, rbCb, retx);
- RETVOID;
+ return;
}
/**
if (*retx == NULLP)
{
RLOG0(L_FATAL, "Memory allocation failed");
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
gRlcStats.amRlcStats.numDLRetransPdus++;
- RETVOID;
+ return;
} /*rlcAmmDlMoveSduByteSegFrmTxtoRetxBuffer */
/**
txBuf = rlcUtlGetTxBuf(AMDL.txBufLst, nackSnInfo->sn);
if (txBuf == NULLP)
{
- RETVOID;
+ return;
}
lnk = txBuf->pduLst.first;
while(lnk)
rlcUtlDelTxBuf(AMDL.txBufLst, txBuf,gCb);
}
- RETVOID;
+ return;
}
/**
(*retxNode) = retx->lstEnt.next;
}
- RETVOID;
+ return;
}
/* process the pdus/segments in the re-transmit buffer with
break;
}
} /* end of retxNode while loop*/
- RETVOID;
+ return;
}
/**
* @param[in]RlcNackInfo *nackSnInfo,
* @param[in]RlcRetx *retx;
* @param[in]RlcSn sn,
-* @param[in]U8 idx
+* @param[in]uint8_t idx
*
* @return Void
*
RlcNackInfo *nackInfo,
CmLList *retxNode,
RlcNackInfo *nackSnInfo,
-U8 idx
+uint8_t idx
)
#else
PRIVATE Void RlcDlAmmGetNackSnInfoFrmNackRangeIdx(amDl, nackInfo, retxNode, nackSnInfo, idx)
(
RlcAmDl *amDl;
RlcNackInfo *nackInfo;
-CmLList *retxNode;
+CmLList *retxNode;
RlcNackInfo *nackSnInfo;
-U8 idx;
+uint8_t idx;
)
#endif
{
{
nackSnInfo->soStart = 0;
nackSnInfo->soEnd = 0;
- RETVOID;
+ return;
}
txBuf = rlcUtlGetTxBuf(amDl->txBufLst, nackSnInfo->sn);
if(txBuf != NULLP)
while(node)
{
RlcDlPduInfo *pduInfo = (RlcDlPduInfo *)(node->node);
- U16 pduSoEnd = pduInfo->amHdr.so + pduInfo->sduMap.sduSz - 1;
+ uint16_t pduSoEnd = pduInfo->amHdr.so + pduInfo->sduMap.sduSz - 1;
if((!idx) && (pduInfo->amHdr.so == nackInfo->soStart))
{
nackSnInfo->isSegment = TRUE;
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
rbCb->rlcId.cellId);
/* RLC_SHRABL_STATIC_BUF_ALLOC(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo)); */
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
- RETVOID;
+ return;
}
/* Venki - stopping the poll retx timer */
RlcSn transWinStartSn = AMDL.txNextAck; /*used to track the SN from which
to start processing the transmission
buffer */
- U32 idx = 0;
+ uint32_t idx = 0;
/* if any NACKs then txNextAck should be equal to the first NACK_SN*/
txNextAck = pStaPdu->nackInfo[0].sn;
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
RLC_SHRABL_STATIC_BUF_FREE(rlckwuSap->pst.region, rlckwuSap->pst.pool, datCfm, sizeof(KwuDatCfmInfo));
- RETVOID;
+ return;
}
/* clear all the SNs < NACK_SN from re-transmission list */
}
else
{
- U8 idx1 = 0;
+ uint8_t idx1 = 0;
/* Update issegment, soStart, soEnd ,sn in nackSnInfo and handle
* nack sn*/
do
rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL);
}
- RETVOID;
+ return;
}
/**
return bo;
}
-U32 kwRxSdu;
+uint32_t kwRxSdu;
/**
* @brief Handler to queue the SDUs received from PDCP
* @param[in] datReq Ptr to the datReq sent from PDCP
*
* @return Void
- * -# RETVOID
+ * -# void
*/
void rlcAmmQSdu(RlcCb *gCb, RlcDlRbCb *rbCb, Buffer *mBuf, KwuDatReqInfo *datReq)
{
rlcUtlAddReTxPduToBeFreedQueue(gCb, retx);
rlcUtlRaiseDlCleanupEvent(gCb);
- RETVOID;
+ return;
}
/**
{
if (AMDL.maxReTxReached == TRUE)
{
- RETVOID;
+ return;
}
if(retx->pendingReTrans == FALSE)
rlcRemRetxPdu(gCb,rbCb, retx);
- RETVOID;
+ return;
}
}
- RETVOID;
+ return;
}
/**
"Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
rlcUtlRaiseDlCleanupEvent(gCb);
}
- RETVOID;
+ return;
}
/**
if (txBuf == NULLP)
{
- RETVOID;
+ return;
}
pduNode = txBuf->pduLst.first;
while(pduNode)
/* so that it is not processed again */
rlcUtlRemovTxBuf(AMDL.txBufLst, txBuf, gCb);
- RETVOID;
+ return;
}
/**
"Memory allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
RlcUiKwuStaInd(&rlckwuSap->pst, rlckwuSap->suId, staInd);
#endif /* KW_PDCP */
- RETVOID;
+ return;
}
/**
else
{
*retx = NULLP;
- RETVOID;
+ return;
}
}while((*retx)->pendingReTrans == FALSE);
/* ccpu00135170 Removing KLOCK warning */
if(resetRb == NULLP)
{
- RETVOID;
+ return;
}
RLC_MEM_CPY(resetRb, rbCb, sizeof(RlcDlRbCb));
newAmDl->snLen = oldAmDl->snLen;
newAmDl->snModMask = oldAmDl->snModMask;
newAmDl->pollRetxTmrInt = oldAmDl->pollRetxTmrInt;
- rbCb->boUnRprtdCnt = (U32)0;
- rbCb->lastRprtdBoToMac = (U32)0;
+ rbCb->boUnRprtdCnt = (uint32_t)0;
+ rbCb->lastRprtdBoToMac = (uint32_t)0;
cmInitTimers(&(resetRb->m.amDl.pollRetxTmr), 1);
/* AGHOSH changes end */
"UeId [%d]: UeCb not found RBID;%d",
rlcId.ueId,
rlcId.rbId);
- RETVOID;
+ return;
}
if(rlcId.rbType == CM_LTE_SRB)
/* allocate the TX array again */
#ifndef LTE_TDD
- U32 hashIndex;
+ uint32_t hashIndex;
RLC_ALLOC(gCb,
resetRb->m.amDl.txBufLst,
(RLC_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
rlcDlUtlResetReestInProgress(ueCb->drbCb[rlcId.rbId]);
}
- RETVOID;
+ return;
}
/**
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-U32 sduId
+uint32_t sduId
)
#else
S16 rlcAmmDiscSdu(gCb, rbCb, sduId)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-U32 sduId;
+uint32_t sduId;
#endif
{
return (RFAILED);
}
rlcAmmSendDedLcBoStatus(gCb, rbCb, &AMDL);
- RETVOID;
+ return;
}
/* Get the last node in retxLst */
RLC_LLIST_LAST_RETX(amDl->retxLst, retx);
}
}
- RETVOID;
+ return;
}
/**
MODAMT(sn, mSn, AMDL.txNextAck,AMDL.snModMask);
}
- RETVOID;
+ return;
}
/**
MODAMT(sn, mSn, AMDL.txNextAck,AMDL.snModMask);
}
- RETVOID;
+ return;
}
hdr[0] = hdr[0] | ((amHdr->si & 0x3) << 4);
if(snLen == RLC_AM_CFG_12BIT_SN_LEN)
{
- hdr[0] = hdr[0] | (U8)((amHdr->sn & 0xF00) >> 8);
- hdr[1] = (U8)(amHdr->sn & 0x0FF);
+ hdr[0] = hdr[0] | (uint8_t)((amHdr->sn & 0xF00) >> 8);
+ hdr[1] = (uint8_t)(amHdr->sn & 0x0FF);
(*idx)++;
}
else
{
- hdr[0] = hdr[0] | (U8)((amHdr->sn & 0x30000) >> 16);
- hdr[1] = (U8)((amHdr->sn & 0xFF00) >> 8);
+ hdr[0] = hdr[0] | (uint8_t)((amHdr->sn & 0x30000) >> 16);
+ hdr[1] = (uint8_t)((amHdr->sn & 0xFF00) >> 8);
(*idx)++;
- hdr[2] = (U8)(amHdr->sn & 0xFF);
+ hdr[2] = (uint8_t)(amHdr->sn & 0xFF);
(*idx)++;
}
if ((amHdr->si == RLC_SI_MID_SEG) || (amHdr->si == RLC_SI_LAST_SEG))
{
(*idx)++;
- hdr[(*idx)] = (U8)((amHdr->so & 0xFF00)>> 8);
+ hdr[(*idx)] = (uint8_t)((amHdr->so & 0xFF00)>> 8);
(*idx)++;
- hdr[(*idx)] = (U8)(amHdr->so & 0xFF);
+ hdr[(*idx)] = (uint8_t)(amHdr->so & 0xFF);
}
return;
amDl->nxtRetx = retx;
}
- RETVOID;
+ return;
}
/**
if (txBuf == NULLP)
{
- RETVOID;
+ return;
}
while(txBuf->pduLst.first)
{
if (*retx == NULLP)
{
RLOG0(L_FATAL, "Memory allocation failed");
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_RES */
/* Remove PDU from txBuf */
rlcUtlDelTxBuf(amDl->txBufLst, txBuf,gCb);
- RETVOID;
+ return;
}
rlcUtlRaiseDlCleanupEvent(gCb);
- RETVOID;
+ return;
}
/**
"UEID:%d CELLID:%d", ack_sn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
cntrlPdu[0] |= (ack_sn & 0xF00)>> 8;
- cntrlPdu[1] = (U8)ack_sn;
+ cntrlPdu[1] = (uint8_t)ack_sn;
}
}
}
/* 18 BIT Nack SN encode */
- cntrlPdu[encIdx] = (U8)((sn & 0x3FC00) >> 10);
+ cntrlPdu[encIdx] = (uint8_t)((sn & 0x3FC00) >> 10);
/* Next Octet */
- cntrlPdu[encIdx + 1] = (U8)((sn & 0x3FC) >> 2);
+ cntrlPdu[encIdx + 1] = (uint8_t)((sn & 0x3FC) >> 2);
/* Next Octet */
- cntrlPdu[encIdx + 2] = (U8)((sn & 0x3)<< 6);
+ cntrlPdu[encIdx + 2] = (uint8_t)((sn & 0x3)<< 6);
if (rlcNackInfo->isSegment)
{
/* Add soStart and soEnd */
/* SOstart */
cntrlPdu[encIdx + 3] = (rlcNackInfo->soStart) >> 8;
- cntrlPdu[encIdx + 4] = (U8)rlcNackInfo->soStart;
+ cntrlPdu[encIdx + 4] = (uint8_t)rlcNackInfo->soStart;
/* SOend */
cntrlPdu[encIdx + 5] = (rlcNackInfo->soEnd) >> 8;
- cntrlPdu[encIdx + 6] = (U8)(rlcNackInfo->soEnd);
+ cntrlPdu[encIdx + 6] = (uint8_t)(rlcNackInfo->soEnd);
}
if (rlcNackInfo->nackRange)
RlcExtHdr *hdrInfo;
#endif
{
- U8 hdr;
- U8 pLen = hdrInfo->pLen;
- U8 len = (U8)hdrInfo->len;
- U16 val;
- U8 tHdr;
- U8 fLen;
- U8 rLen;
- /* U8 rLen1 = 0; */
- U16 tVal;
+ uint8_t hdr;
+ uint8_t pLen = hdrInfo->pLen;
+ uint8_t len = (uint8_t)hdrInfo->len;
+ uint16_t val;
+ uint8_t tHdr;
+ uint8_t fLen;
+ uint8_t rLen;
+ /* uint8_t rLen1 = 0; */
+ uint16_t tVal;
hdr = hdrInfo->hdr;
hdrInfo->hdr = hdr;
hdrInfo->val = val;
- RETVOID;
+ return;
}
RlcCb *gCb,
RlcDlRbCb *rbCb,
Buffer *cntrlPdu,
-U8 *fByte
+uint8_t *fByte
)
#else
PRIVATE Void rgAmmUlHndlStatusPdu(udxPst,suId,gCb, rbCb, cntrlPdu, fByte)
RlcCb *gCb;
RlcDlRbCb *rbCb;
Buffer *cntrlPdu;
-U8 *fByte;
+uint8_t *fByte;
#endif
{
- U8 e1;
+ uint8_t e1;
RlcExtHdr hdrInfo;
RlcUdxStaPdu *pStaPdu;
- U8 e3; /* NACK RANGE : 5GNR */
- U32 snLen;
- U32 snRange;
- U32 resrvdBitsAckSn;
- U32 resrvdBitsNackSn;
+ uint8_t e3; /* NACK RANGE : 5GNR */
+ uint32_t snLen;
+ uint32_t snRange;
+ uint32_t resrvdBitsAckSn;
+ uint32_t resrvdBitsNackSn;
RLCDBGP_BRIEF(gCb, "rgAmmUlHndlStatusPdu(rbCb, cntrlPdu, fByte) \n");
if (hdrInfo.hdr & 0xE0)
{
RLCDBGP_ERROR(gCb, "rgAmmUlHndlStatusPdu: Reserved value for CPT received \n");
- RETVOID;
+ return;
}
RLC_ALLOC_SHRABL_BUF(udxPst->region,
/* Memory allocation failure can not be expected */
if(!pStaPdu)
{
- RETVOID;
+ return;
}
#endif
/* Check if NACK Exists */
hdrInfo.len = RLC_E1_LEN;
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- e1 = (U8)hdrInfo.val;
+ e1 = (uint8_t)hdrInfo.val;
RLCDBGP_DETAIL(gCb, "rgAmmUlHndlStatusPdu: ACK SN = %d \n", pStaPdu->ackSn);
/* Extract the Reserved Bits after ACK SN field */
hdrInfo.len = RLC_E1_LEN;
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- e1 = (U8)hdrInfo.val;
+ e1 = (uint8_t)hdrInfo.val;
/* Extract e2 */
/* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
already present*/
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- /* e2 = (U8) hdrInfo.val;*/
+ /* e2 = (uint8_t) hdrInfo.val;*/
/* Store e2 value */
- pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (U8) hdrInfo.val;
+ pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (uint8_t) hdrInfo.val;
/* Extract e3 : 5GNR */
/* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
already present*/
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- e3 = (U8) hdrInfo.val;
+ e3 = (uint8_t) hdrInfo.val;
/* Extract Reserved Bits after NACK SN */
hdrInfo.len = resrvdBitsNackSn;
/* Extract NACK range field */
hdrInfo.len = RLC_NACK_RANGE_LEN;
rgAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- snRange = (U8)hdrInfo.val;
+ snRange = (uint8_t)hdrInfo.val;
pStaPdu->nackInfo[pStaPdu->nackCnt].nackRange = snRange;
//rlcUlUdxStaUpdReq(&(sapCb->pst), sapCb->spId, &rbCb->rlcId, pStaPdu);
rlcUlUdxStaUpdReq(udxPst, suId, &rbCb->rlcId, pStaPdu);
- RETVOID;
+ return;
}
S16 rlcProcDlStatusPdu(Pst *udxPst,SuId suId,
{
RlcDlRbCb *rbCb = NULLP;
RlcDlUeCb *ueCb = NULLP;
- U8 fByte;
- U8 temp;
+ uint8_t fByte;
+ uint8_t temp;
S16 retVal = RFAILED;
RlcCb *gCb;
Pst dlRlcPst = *udxPst;
#ifndef RGL_SPECIFIC_CHANGES
#ifndef TENB_ACC
#ifndef LTE_PAL_ENB
-extern U32 ulrate_rgu;
+extern uint32_t ulrate_rgu;
#endif
#endif
#endif
#ifndef TENB_ACC
#ifndef TENB_T2K3K_SPECIFIC_CHANGES
#ifndef LTE_PAL_ENB
-extern U32 isMemThreshReached(Region region);
+extern uint32_t isMemThreshReached(Region region);
#endif
#else
#ifndef LTE_PAL_ENB
-extern U32 isMemThreshReached(Region region);
+extern uint32_t isMemThreshReached(Region region);
#endif
#endif
#endif
PRIVATE Void rlcAmmUlHndlStatusPdu ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *cntrlPdu,
- U8 *fByte));
+ uint8_t *fByte));
/******************************************************************************
}
#ifdef XEON_SPECIFIC_CHANGES
-extern U32 gRlcDatIndUL;
+extern uint32_t gRlcDatIndUL;
#endif
#ifdef T2K_TRIGGER_RLC_REEST
-U32 drpRlcDrbPack;
+uint32_t drpRlcDrbPack;
#endif
/**
* @brief Handler to process the PDUs received from MAC and send it to PDCP
/* Changed the condition to TRUE from ROK */
if(isMemThreshReached(rlcCb[0]->init.region) == TRUE)
{
- extern U32 rlculdrop;
+ extern uint32_t rlculdrop;
rlculdrop++;
RLC_FREE_BUF(pdu);
continue;
/*ccpu00142274 - UL memory based flow control*/
if(isMemThreshReached(rlcCb[0]->init.region) != ROK)
{
- extern U32 rlculdrop;
+ extern uint32_t rlculdrop;
rlculdrop++;
RLC_FREE_BUF(pdu);
continue;
RlcCb *gCb,
Buffer *pdu,
RlcAmHdr *amHdr,
-U8 *fByte
+uint8_t *fByte
)
#else
PRIVATE S16 rlcAmmExtractHdrOld(gCb, pdu, amHdr, fByte)
RlcCb *gCb;
Buffer *pdu;
RlcAmHdr *amHdr;
-U8 *fByte;
+uint8_t *fByte;
#endif
{
- U8 e;
- U8 snByte;
- U16 sn;
+ uint8_t e;
+ uint8_t snByte;
+ uint16_t sn;
MsgLen pduSz;
MsgLen totalSz = 0;
RlcExtHdr hdrInfo;
e = amHdr->e = (*fByte & RLC_E_POS)>> RLC_E_SHT;
SRemPreMsg(&snByte, pdu);
- sn = (U16)(((*fByte & RLC_SN_POS) << RLC_BYTE_LEN ) | snByte);
+ sn = (uint16_t)(((*fByte & RLC_SN_POS) << RLC_BYTE_LEN ) | snByte);
amHdr->sn = sn;
if (amHdr->rf == 1)
{
/* Extract extn part of the header */
hdrInfo.len = RLC_LSF_LEN;
rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
- amHdr->lsf = (U8)hdrInfo.val;
+ amHdr->lsf = (uint8_t)hdrInfo.val;
hdrInfo.len = RLC_SO_LEN;
rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
{
hdrInfo.len = RLC_E_LEN;
rlcAmmExtractElmnt(gCb, pdu, &hdrInfo);
- e = amHdr->e = (U8)hdrInfo.val;
+ e = amHdr->e = (uint8_t)hdrInfo.val;
/* Extract LI value*/
hdrInfo.len = RLC_LI_LEN;
/* Check if NACK Exists */
hdrInfo.len = RLC_E1_LEN;
rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- e1 = (U8)hdrInfo.val;
+ e1 = (uint8_t)hdrInfo.val;
DU_LOG("\nRLC: rlcAmmUlHndlStatusPdu: ACK SN = %d UEID:%d CELLID:%d",
pStaPdu->ackSn, rbCb->rlcId.ueId, rbCb->rlcId.cellId);
hdrInfo.len = RLC_E1_LEN;
rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- e1 = (U8)hdrInfo.val;
+ e1 = (uint8_t)hdrInfo.val;
/* Extract e2 */
/* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
already present*/
rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- /* e2 = (U8) hdrInfo.val;*/
+ /* e2 = (uint8_t) hdrInfo.val;*/
/* Store e2 value */
- pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (U8) hdrInfo.val;
+ pStaPdu->nackInfo[pStaPdu->nackCnt].isSegment = (uint8_t) hdrInfo.val;
/* Extract e3 : 5GNR */
/* hdrInfo.len = RLC_E1_LEN; --> previusly stored value (for e1) is
already present*/
rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- e3 = (U8) hdrInfo.val;
+ e3 = (uint8_t) hdrInfo.val;
/* Extract Reserved Bits after NACK SN */
hdrInfo.len = resrvdBitsNackSn;
/* Extract NACK range field */
hdrInfo.len = RLC_NACK_RANGE_LEN;
rlcAmmExtractElmnt(gCb, cntrlPdu, &hdrInfo);
- snRange = (U8)hdrInfo.val;
+ snRange = (uint8_t)hdrInfo.val;
pStaPdu->nackInfo[pStaPdu->nackCnt].nackRange = snRange;
rbCb->m.amUl.isOutOfSeq = FALSE;
}
- RETVOID;
+ return;
}
/**
amUl->rxNextStatusTrig = amUl->rxNextHighestRcvd;
}
- RETVOID;
+ return;
} /* rlcAmmReOrdTmrExp */
/**
rlcAmmUlAssembleCntrlInfo(gCb,rbCb);
}
- RETVOID;
+ return;
} /* rlcAmmStaProTmrExp */
/**
{
uint8_t hdr;
uint8_t pLen = hdrInfo->pLen;
- uint8_t len = (U8)hdrInfo->len;
+ uint8_t len = (uint8_t)hdrInfo->len;
uint32_t val;
uint8_t tHdr;
uint8_t fLen;
uint8_t rLen;
- /* U8 rLen1 = 0; */
+ /* uint8_t rLen1 = 0; */
uint16_t tVal;
hdr = hdrInfo->hdr;
{
RLC_FREE_BUF_WC(rbCb->m.amUl.partialSdu);
}
- RETVOID;
+ return;
} /* rlcAmmFreeUlRbCb */
* -# RFAILED
*
*/
-PRIVATE S16 rlcHdlMeasDlUeIdChg(RlcCb *gCb, U8 cellId,U8 oldUeId, U8 newUeId)
+PRIVATE S16 rlcHdlMeasDlUeIdChg(RlcCb *gCb, uint8_t cellId,uint8_t oldUeId, uint8_t newUeId)
{
RlcL2MeasEvtCb *measEvtCb = NULLP;
RlcL2MeasCb *measCb = NULLP;
- U16 cntr;
- U16 ueIdx = 0;
+ uint16_t cntr;
+ uint16_t ueIdx = 0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
* -# RFAILED
*
*/
-PRIVATE S16 rlcDelFrmDlL2Meas(RlcCb *gCb, U8 cellId,U8 ueId)
+PRIVATE S16 rlcDelFrmDlL2Meas(RlcCb *gCb, uint8_t cellId,uint8_t ueId)
{
RlcL2MeasEvtCb *measEvtCb = NULLP;
RlcL2MeasCb *measCb = NULLP;
- U16 cntr;
- U16 ueIdx = 0;
+ uint16_t cntr;
+ uint16_t ueIdx = 0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
}
-PRIVATE S16 rlcAddToDlL2Meas(RlcCb *gCb, RlcDlRbCb *rlcRbCb,U8 cellId,U8 ueId)
+PRIVATE S16 rlcAddToDlL2Meas(RlcCb *gCb, RlcDlRbCb *rlcRbCb,uint8_t cellId,uint8_t ueId)
{
RlcL2MeasEvtCb *measEvtCb = NULLP;
RlcL2MeasCb *measCb = NULLP;
- U16 cntr;
- U16 cntr1;
- U16 ueIdx = 0;
- U16 qciIdx = 0;
- U16 *numQci;
+ uint16_t cntr;
+ uint16_t cntr1;
+ uint16_t ueIdx = 0;
+ uint16_t qciIdx = 0;
+ uint16_t *numQci;
#ifndef XEON_SPECIFIC_CHANGES
- U8 freeIdx = gCb->genCfg.maxUe;
+ uint8_t freeIdx = gCb->genCfg.maxUe;
#else
- U16 freeIdx = LKW_MAX_UE;
+ uint16_t freeIdx = LKW_MAX_UE;
#endif
ueCb->lCh[rbCb->lch.lChId - 1].dlRbCb = rbCb;
#ifndef LTE_TDD
- U32 hashIndex;
+ uint32_t hashIndex;
RLC_ALLOC(gCb,
rbCb->m.amDl.txBufLst,
(RLC_TX_BUF_BIN_SIZE * sizeof(CmLListCp)));
RlcDlUeCb *ueCb = NULLP; /* UE Control Block */
RlcDlCellCb *cellCb; /* Cell Control Block */
RlcDlRbCb *rlcRbCb; /* KW RB Control Block */
- U8 reason; /* Rb Identifier */
+ uint8_t reason; /* Rb Identifier */
RLOG_ARG3(L_DEBUG,DBG_RBID,entCfg->rbId,
"rlcCfgAddRb(cellId(%d),UEID:%d cfgType(%d))",
RlcDlRbCb tRbCb; /* KW RB Control Block */
RlcDlCellCb *cellCb; /* Cell Control Block */
RlcDlUeCb *ueCb; /* Ue Control Block */
- U8 ret;
+ uint8_t ret;
RLOG_ARG3(L_DEBUG,DBG_UEID,ueId,
"rlcCfgReCfgRb(cellId(%d), cfgType(%d)) RBID:%d",
#endif
{
RlcDlCellCb *cellCb; /* UE Control Block */
- U8 rbId; /* RB Identifier */
+ uint8_t rbId; /* RB Identifier */
RLOG_ARG2(L_DEBUG,DBG_RBID,entCfg->rbId,
"rlcCfgDelCell( cellId(%d), cfgType(%d)",
ueCb->cellId = newUeInfo->cellId;
if(ROK != cmHashListInsert(&(gCb->u.dlCb->ueLstCp),
- (PTR)ueCb, (U8 *)&(ueCb->ueId),
- (U16) sizeof(CmLteRnti)))
+ (PTR)ueCb, (uint8_t *)&(ueCb->ueId),
+ (uint16_t) sizeof(CmLteRnti)))
{
RLOG_ARG1(L_ERROR,DBG_CELLID,newUeInfo->cellId,
* -# RFAILED
*
*/
-PRIVATE S16 rlcHdlMeasUlUeIdChg(RlcCb *gCb, U8 cellId,U8 oldUeId, U8 newUeId)
+PRIVATE S16 rlcHdlMeasUlUeIdChg(RlcCb *gCb, uint8_t cellId,uint8_t oldUeId, uint8_t newUeId)
{
RlcL2MeasCb *measCb = NULLP;
- U16 cntr;
- U16 ueIdx = 0;
+ uint16_t cntr;
+ uint16_t ueIdx = 0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
* -# RFAILED
*
*/
-PRIVATE S16 rlcDelFrmUlL2Meas(RlcCb *gCb, U8 cellId,U8 ueId)
+PRIVATE S16 rlcDelFrmUlL2Meas(RlcCb *gCb, uint8_t cellId,uint8_t ueId)
{
RlcL2MeasCb *measCb = NULLP;
- U16 cntr;
- U16 ueIdx = 0;
+ uint16_t cntr;
+ uint16_t ueIdx = 0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
{
- U32 myIdx =0;
+ uint32_t myIdx =0;
S16 ret; /* Return value */
RlcUlUeCb *ueCb = NULL;
}
-PRIVATE S16 rlcAddToUlL2Meas(RlcCb *gCb, RlcUlRbCb *rlcRbCb,U8 cellId,U8 ueId)
+PRIVATE S16 rlcAddToUlL2Meas(RlcCb *gCb, RlcUlRbCb *rlcRbCb,uint8_t cellId,uint8_t ueId)
{
RlcL2MeasCb *measCb = NULLP;
- U16 cntr;
- U16 cntr1;
- U16 ueIdx = 0;
- U16 qciIdx = 0;
- U16 *numQci;
+ uint16_t cntr;
+ uint16_t cntr1;
+ uint16_t ueIdx = 0;
+ uint16_t qciIdx = 0;
+ uint16_t *numQci;
#ifndef XEON_SPECIFIC_CHANGES
- U8 freeIdx = gCb->genCfg.maxUe;
+ uint8_t freeIdx = gCb->genCfg.maxUe;
#else
- U16 freeIdx = LKW_MAX_UE;
+ uint16_t freeIdx = LKW_MAX_UE;
#endif
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
{
if (( cfgTmpData->cellCb->rbCb[cfgToValidate->rbId] != NULLP))
{
- cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_PRSNT;;
+ cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_PRSNT;
return RFAILED;
}
}
cfgEntData->rbCb);
if(cfgEntData->rbCb != NULLP)
{
- cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_PRSNT;;
+ cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_RB_PRSNT;
return RFAILED;
}
}
/*Allocating the memory for receive buffer */
if(CM_LTE_MODE_UM == cfgToValidate->entMode)
{
- U16 winLen;
+ uint16_t winLen;
cfgEntData->rbCb->m.umUl.umWinSz = RLC_POWER(2,
else if(CM_LTE_MODE_AM == cfgToValidate->entMode)
{
#ifndef LTE_TDD
- U32 hashIndex;
+ uint32_t hashIndex;
RLC_ALLOC(gCb,
cfgEntData->rbCb->m.amUl.recBufLst,
(RLC_RCV_BUF_BIN_SIZE * sizeof(CmLListCp )));
break;
}
}
- RETVOID;
+ return;
}
\f
/* Check for ueId is present or not */
if ( cfgTmpData->ueId == 0 )
{
- cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;;
+ cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;
RLOG_ARG1(L_ERROR,DBG_UEID,cfgTmpData->ueId,
"UeId is 0 for CELLID;%d",
cfgTmpData->cellId);
RLOG_ARG1(L_ERROR,DBG_CELLID, cfgTmpData->cellId,
"UeId [%d]: UeCb not found",
cfgTmpData->ueId);
- cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;;
+ cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_UE_UNKWN;
return RFAILED;
}
return ROK;
rlcDelFrmUlL2Meas(gCb,cfgTmpData->cellId,cfgTmpData->ueId);
#endif
rlcDbmDelUlUeCb(gCb,cfgTmpData->ueCb, FALSE);
- RETVOID;
+ return;
}
\f
/* Check for cellId is present or not */
if ( cellId == 0 )
{
- cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;;
+ cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;
RLOG_ARG0(L_ERROR,DBG_CELLID,cellId , "CellId is 0");
return RFAILED;
}
rlcDbmFetchUlCellCb(gCb,cellId, &cfgTmpData->cellCb);
if (!cfgTmpData->cellCb)
{
- cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;;
+ cfgEntData->entUlCfgCfm.status.reason = CKW_CFG_REAS_CELL_UNKWN;
RLOG_ARG0(L_ERROR, DBG_CELLID,cellId, "CellCb not found");
return RFAILED;
}
{
rlcDbmDelUlCellCb(gCb,cfgInfo->cellCb);
- RETVOID;
+ return;
}
\f
/**
break;
}
}
- RETVOID;
+ return;
}
\f
/**
cfgTmpData->ueCb->cellId =newUeInfo->cellId;
if(ROK != cmHashListInsert(&(gCb->u.ulCb->ueLstCp),
(PTR)cfgTmpData->ueCb,
- (U8 *)&(cfgTmpData->ueCb->ueId),
- (U16) sizeof(CmLteRnti)))
+ (uint8_t *)&(cfgTmpData->ueCb->ueId),
+ (uint16_t) sizeof(CmLteRnti)))
{
RLOG_ARG1(L_ERROR,DBG_CELLID,newUeInfo->cellId,
newUeInfo->ueId);
}
- RETVOID;
+ return;
}
/********************************************************************30**
#ifdef TENB_STATS
-EXTERN TSL2UeStatsCb* TSL2MapUeStatsBlk (U16 rnti);
+EXTERN TSL2UeStatsCb* TSL2MapUeStatsBlk (uint16_t rnti);
#endif
/**
* @file gp_dbm_dl.c
/* Initialize ueCb Hash List */
if(ROK != cmHashListInit(&(gCb->u.dlCb->ueLstCp),
- (U16) RLC_UE_LIST_BUCKET_SIZE,
- (U16) 0,
+ (uint16_t) RLC_UE_LIST_BUCKET_SIZE,
+ (uint16_t) 0,
(Bool) FALSE,
- (U16) CM_HASH_KEYTYPE_CONID,
+ (uint16_t) CM_HASH_KEYTYPE_CONID,
RLC_GET_MEM_REGION(gCb),
RLC_GET_MEM_POOL(gCb)))
{
/* Initialize cellCb Hash List */
if(ROK != cmHashListInit(&(gCb->u.dlCb->cellLstCp),
- (U16) RLC_CELL_LIST_BUCKET_SIZE,
- (U16) 0,
+ (uint16_t) RLC_CELL_LIST_BUCKET_SIZE,
+ (uint16_t) 0,
(Bool) FALSE,
- (U16) CM_HASH_KEYTYPE_CONID,
+ (uint16_t) CM_HASH_KEYTYPE_CONID,
RLC_GET_MEM_REGION(gCb),
RLC_GET_MEM_POOL(gCb)))
{
#ifdef LTE_L2_MEAS_RLC
/* Initialize qcI Hash List */
if(ROK != cmHashListInit(&(rlcCb.rlcL2Cb.qciHlCp),
- (U16) RLC_QCI_LIST_BUCKET_SIZE,
- (U16) 0,
+ (uint16_t) RLC_QCI_LIST_BUCKET_SIZE,
+ (uint16_t) 0,
(Bool) TRUE,
- (U16) CM_HASH_KEYTYPE_DEF,
+ (uint16_t) CM_HASH_KEYTYPE_DEF,
rlcCb.init.region,
rlcCb.init.pool))
{
/* Initialize tbHlCp Hash List */
if(ROK != cmHashListInit(&(rlcCb.rlcL2Cb.tbHlCp),
- (U16) RLC_TB_LIST_BUCKET_SIZE,
- (U16) 0,
+ (uint16_t) RLC_TB_LIST_BUCKET_SIZE,
+ (uint16_t) 0,
(Bool) FALSE,
- (U16) CM_HASH_KEYTYPE_DEF,
+ (uint16_t) CM_HASH_KEYTYPE_DEF,
rlcCb.init.region,
rlcCb.init.pool))
{
#endif /* LTE_L2_MEAS */
- RETVOID;
+ return;
} /* rlcDbmDlDeInit */
\f
(
RlcCb *gCb,
RlcDlRbCb **rbCbLst,
-U8 numRbCb
+uint8_t numRbCb
)
#else
Void rlcDbmDelAllDlRb(gCb, rbCbLst, numRbCb)
RlcCb *gCb;
RlcDlRbCb **rbCbLst;
-U8 numRbCb;
+uint8_t numRbCb;
#endif
{
- U32 idx;
+ uint32_t idx;
for (idx = 0; idx < numRbCb; idx++)
}
- RETVOID;
+ return;
} /* rlcDbmDelAllDlRb */
\f
if (ROK != cmHashListInsert(&(gCb->u.dlCb->ueLstCp),
(PTR)tUeCb,
- (U8 *)&(tUeCb->ueId),
- (U16) sizeof(CmLteRnti)))
+ (uint8_t *)&(tUeCb->ueId),
+ (uint16_t) sizeof(CmLteRnti)))
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellId,
"UeId[%u] HashList Insertion Failed",
/* Deallocate ueCb */
RLC_FREE(gCb,ueCb, sizeof(RlcDlUeCb));
- RETVOID;
+ return;
} /* kwDbmDelUeCb */
\f
ueCb = NULLP;
}
- RETVOID;
+ return;
} /* kwDbmDelAllUe */
/* kw005.201 added support for L2 Measurement */
RlcDlUeCb *ueCb;
#endif
{
- U8 tbIdx;
+ uint8_t tbIdx;
RlcL2MeasTb *l2MeasTb = NULLP;
for(tbIdx = 0; tbIdx < RLC_MAX_TB_PER_UE; tbIdx++)
{
ueCb->l2MeasTbCb[tbIdx] = NULLP;
}
}
- RETVOID;
+ return;
}/* End of kwDbmDelL2MeasTb */
#endif /* LTE_L2_MEAS */
\f
if(ROK != cmHashListInsert(&(gCb->u.dlCb->cellLstCp),
(PTR) tCellCb,
- (U8 *)&(tCellCb->cellId),
- (U16) sizeof(CmLteCellId)))
+ (uint8_t *)&(tCellCb->cellId),
+ (uint16_t) sizeof(CmLteCellId)))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellId,"HashList Insertion Failed");
return RFAILED;
*cellCb = NULLP;
if(ROK != cmHashListFind(&(gCb->u.dlCb->cellLstCp),
- (U8 *)&(cellId),
+ (uint8_t *)&(cellId),
sizeof(CmLteCellId),
RLC_DEF_SEQ_NUM,
(PTR*) cellCb))
/* Deallocate cellCb */
RLC_FREE(gCb, cellCb, sizeof(RlcDlCellCb));
- RETVOID;
+ return;
} /* kwDbmDelCellCb */
\f
cellCb = NULLP;
}
- RETVOID;
+ return;
} /* rlcDbmDelAllDlCell */
\f
{
/* Initialize ueCb Hash List */
if(ROK != cmHashListInit(&(gCb->u.ulCb->ueLstCp),
- (U16) RLC_UE_LIST_BUCKET_SIZE,
- (U16) 0,
+ (uint16_t) RLC_UE_LIST_BUCKET_SIZE,
+ (uint16_t) 0,
(Bool) FALSE,
- (U16) CM_HASH_KEYTYPE_CONID,
+ (uint16_t) CM_HASH_KEYTYPE_CONID,
RLC_GET_MEM_REGION(gCb),
RLC_GET_MEM_POOL(gCb)))
{
/* Initialize cellCb Hash List */
if(ROK != cmHashListInit(&(gCb->u.ulCb->cellLstCp),
- (U16) RLC_CELL_LIST_BUCKET_SIZE,
- (U16) 0,
+ (uint16_t) RLC_CELL_LIST_BUCKET_SIZE,
+ (uint16_t) 0,
(Bool) FALSE,
- (U16) CM_HASH_KEYTYPE_CONID,
+ (uint16_t) CM_HASH_KEYTYPE_CONID,
RLC_GET_MEM_REGION(gCb),
RLC_GET_MEM_POOL(gCb)))
{
}
if(ROK != cmHashListInit(&(gCb->u.ulCb->transIdLstCp),
- (U16) RLC_TRANS_ID_LST_BKT_SIZE,
- (U16) 0,
+ (uint16_t) RLC_TRANS_ID_LST_BKT_SIZE,
+ (uint16_t) 0,
(Bool) FALSE,
- (U16) CM_HASH_KEYTYPE_CONID,
+ (uint16_t) CM_HASH_KEYTYPE_CONID,
RLC_GET_MEM_REGION(gCb),
RLC_GET_MEM_POOL(gCb)))
{
cmHashListDeinit(&(rlcCb.rlcL2Cb.qciHlCp));
#endif /* LTE_L2_MEAS */
- RETVOID;
+ return;
} /* kwDbmDeInit */
rlcId->cellId,
rlcId->ueId,
RLC_MAX_RB_PER_CELL);
- RETVOID;
+ return;
}
rlcDbmFetchUlCellCb(gCb,rlcId->cellId, &cellCb);
"CellCb not found RBID:%d UEID:%d",
rlcId->rbId,
rlcId->ueId);
- RETVOID;
+ return;
}
*rbCb = cellCb->rbCb[rlcId->rbId];
rlcId->rbType,
rlcId->cellId,
rlcId->ueId);
- RETVOID;
+ return;
}
if (rlcDbmFetchUlUeCb(gCb,rlcId->ueId, rlcId->cellId, &ueCb) != ROK)
"UeId [%d]: UeCb not found RBID:%d",
rlcId->ueId,
rlcId->rbId);
- RETVOID;
+ return;
}
RLC_DBM_GET_RBCB_FROM_UECB(rlcId->rbId, rlcId->rbType, ueCb, *rbCb);
}
- RETVOID;
+ return;
} /* rlcDbmFetchUlRbCbByRbId */
\f
(
RlcCb *gCb,
RlcUlRbCb **rbCbLst,
-U8 numRbCb
+uint8_t numRbCb
)
#else
Void rlcDbmDelAllUlRb(gCb, rbCbLst, numRbCb)
RlcCb *gCb;
RlcUlRbCb **rbCbLst;
-U8 numRbCb;
+uint8_t numRbCb;
#endif
{
- U32 idx; /* Index */
+ uint32_t idx; /* Index */
for (idx = 0; idx < numRbCb; idx++)
{
}
}
- RETVOID;
+ return;
} /* kwDbmDelAllRb */
\f
if(ROK != cmHashListInsert(&(gCb->u.ulCb->ueLstCp),
(PTR)ueCb,
- (U8 *)&(ueCb->ueId),
- (U16) sizeof(CmLteRnti)))
+ (uint8_t *)&(ueCb->ueId),
+ (uint16_t) sizeof(CmLteRnti)))
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellId,
"UeId[%u] HashList Insertion Failed",
return (cmHashListInsert(&(gCb->u.ulCb->transIdLstCp),
(PTR)cfg,
- (U8 *)&(cfg->transId),
- (U16) sizeof(cfg->transId)));
+ (uint8_t *)&(cfg->transId),
+ (uint16_t) sizeof(cfg->transId)));
}
\f
S16 rlcDbmFindUlTransaction
(
RlcCb *gCb,
-U32 transId,
+uint32_t transId,
RlcUlCfgTmpData **cfg
)
#else
S16 rlcDbmFindUlTransaction(gCb, cfg)
RlcCb *gCb;
-U32 transId;
+uint32_t transId;
RlcUlCfgTmpData **cfg;
#endif
{
if(ROK != cmHashListFind(&(gCb->u.ulCb->transIdLstCp),
- (U8 *) &transId,
+ (uint8_t *) &transId,
sizeof (transId),
RLC_DEF_SEQ_NUM,(PTR *) cfg))
{
/* Deallocate ueCb */
RLC_FREE(gCb,ueCb, sizeof(RlcUlUeCb));
- RETVOID;
+ return;
}
\f
/**
ueCb = NULLP;
}
- RETVOID;
+ return;
}
if(ROK != cmHashListInsert(&(gCb->u.ulCb->cellLstCp),
(PTR) tCellCb,
- (U8 *)&(tCellCb->cellId),
- (U16) sizeof(CmLteCellId)))
+ (uint8_t *)&(tCellCb->cellId),
+ (uint16_t) sizeof(CmLteCellId)))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,tCellCb->cellId,
"HashList Insertion Failed");
/* Deallocate cellCb */
RLC_FREE(gCb, cellCb, sizeof(RlcUlCellCb));
- RETVOID;
+ return;
} /* kwDbmDelCellCb */
\f
cellCb = NULLP;
}
- RETVOID;
+ return;
}
\f
rlcDbmUlDeInit(gCb);
- RETVOID;
+ return;
}
if(((_rlcRbCb)->rlcId.rbType == CM_LTE_DRB) && \
((_rlcCb)->u.dlCb->rlcL2Cb.measOn[_rlcRbCb->qci] & LKW_L2MEAS_DL_DISC)) \
{ \
- U32 idx1; \
+ uint32_t idx1; \
for (idx1 = 0; idx1 < LKW_MAX_L2MEAS; idx1++) \
{ \
if(_rlcCb->u.dlCb->rlcL2Cb.rlcL2EvtCb[idx1].measCb.measType & LKW_L2MEAS_DL_DISC) \
{
struct _t
{
- U16 sfn; /*!< Sub frame number for BCCH/PCCH */
- U16 slot; /*!< Subframe number */
+ uint16_t sfn; /*!< Sub frame number for BCCH/PCCH */
+ uint16_t slot; /*!< Subframe number */
CmLteRnti rnti; /*!< RNTI for CCCH */
#ifdef EMTC_ENABLE
- U8 emtcDiReason; /*!< DI reason */
- U8 pnb; /*!<narrow band on which Ue performs Paging*/
+ uint8_t emtcDiReason; /*!< DI reason */
+ uint8_t pnb; /*!<narrow band on which Ue performs Paging*/
#endif
}tm; /*!< SDU for TM mode */
struct _u
{
- U32 sduId; /*!< SDU Identifier */
- Bool isSegmented; /*!< Flag to indicate if the SDU is segmented */
+ uint32_t sduId; /*!< SDU Identifier */
+ Bool isSegmented; /*!< Flag to indicate if the SDU is segmented */
}um; /*!< SDU for UM mode */
struct _a
{
- U32 sduId; /*!< SDU Identifier */
+ uint32_t sduId; /*!< SDU Identifier */
MsgLen rcvdSz; /*!< Recvd SDU Size from peer */
Bool isSegmented; /*!< Is SDU segmented */
RlcSn sn; /*!< SN assigned to this SDU*/
*/
typedef struct rlcBoRep
{
- S32 bo; /*!< Buffer occupancy */
- U16 estHdrSz; /*!< Estimated header size for the bo */
- Bool staPduPrsnt; /*!< Indicate control bo present or not */
- U32 staPduBo; /*!< Indicate bo for control PDU */
- U32 oldestSduArrTime;
+ S32 bo; /*!< Buffer occupancy */
+ uint16_t estHdrSz; /*!< Estimated header size for the bo */
+ Bool staPduPrsnt; /*!< Indicate control bo present or not */
+ uint32_t staPduBo; /*!< Indicate bo for control PDU */
+ uint32_t oldestSduArrTime;
} RlcBoRep;
/**
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
KwLchMapInfo lchMapInfo; /*!< Logical channel mapping info */
- U32 totMacGrant;
+ uint32_t totMacGrant;
#endif /* LTE_L2_MEAS */
}RlcDatReq;
typedef struct rlcUmDl
{
CmLListCp sduQ; /*!< SDU queue for UM */
- U8 snLen; /*!< Sequence number length */
+ uint8_t snLen; /*!< Sequence number length */
S32 bo; /*!< Buffer occupancy */
S32 estHdrSz; /*!< Estimated header size for BO */
- RlcSn vtUs; /*!< VT(US) */
- U16 modBitMask; /*!< Bitmask for modulus to wrap around vars*/
- U16 numLi; /*!< Number of LIs */
- U16 li[RLC_MAX_LI]; /*!< Length Indicator array */
+ RlcSn vtUs; /*!< VT(US) */
+ uint16_t modBitMask; /*!< Bitmask for modulus to wrap around vars*/
+ uint16_t numLi; /*!< Number of LIs */
+ uint16_t li[RLC_MAX_LI]; /*!< Length Indicator array */
}RlcUmDl;
/**
Buffer *seg; /*!< Buffer of PDU or Segment */
MsgLen segSz; /*!< Segment Size */
MsgLen hdrSz; /*!< Header size for the segment */
- RlcAmHdr amHdr; /*!< AM header Info */
- U16 soEnd; /*!< Segment Offset End */
- RlcSn retxCnt; /*!< Retransmission count */
+ RlcAmHdr amHdr; /*!< AM header Info */
+ uint16_t soEnd; /*!< Segment Offset End */
+ RlcSn retxCnt; /*!< Retransmission count */
Bool yetToConst; /*!< Yet to construct seg flag */
Bool pendingReTrans; /*!< Is node waiting for re-transmission */
- RlcSduMap sduMap; /*!< SDU mapped with PDU */
+ RlcSduMap sduMap; /*!< SDU mapped with PDU */
}RlcRetx;
/**
typedef struct rlcAmDl
{
CmLListCp sduQ; /*!< SDU queue */
- RlcSdu *nxtTx; /*!< Next SDU to be transmitted */
+ RlcSdu *nxtTx; /*!< Next SDU to be transmitted */
CmTimer pollRetxTmr; /*!< T_poll_retransmit Timer */
- U16 pollRetxTmrInt; /*!< Timer Interval */
+ uint16_t pollRetxTmrInt; /*!< Timer Interval */
S16 pollPdu; /*!< Poll_PDU */
S32 pollByte; /*!< Poll_Byte */
- U8 maxRetx; /*!< Max_Retx_Threshold */
+ uint8_t maxRetx; /*!< Max_Retx_Threshold */
S32 cntrlBo; /*!< BO of control pdu */
S32 retxBo; /*!< BO of Retransmission PDUs */
- U32 estHdrSz; /*!< Estimated header size for the BO */
+ uint32_t estHdrSz; /*!< Estimated header size for the BO */
S32 bo; /*!< BO of new PDUs */
#ifndef LTE_TDD
CmLListCp *txBufLst; /*!< Transmission buffer list of type RlcTx */
// RlcTx *txBuf[1024]; /*!< Transmission buffer */
#endif
CmLListCp retxLst; /*!< Retransmission PDU list */
- RlcRetx *nxtRetx; /*!< Next node to be retransmitted */
- RlcSn txNext; /*!< 5GNR: TX_Next, in LTE VT(S) */
- RlcSn txNextAck; /*!< 5GNR: TX_Next_Ack, in LTE VT(A)*/
+ RlcRetx *nxtRetx; /*!< Next node to be retransmitted */
+ RlcSn txNext; /*!< 5GNR: TX_Next, in LTE VT(S) */
+ RlcSn txNextAck; /*!< 5GNR: TX_Next_Ack, in LTE VT(A)*/
S16 pduWoPoll; /*!< PDU without poll bit counter */
S32 byteWoPoll; /*!< Byte without poll bit counter */
- RlcSn pollSn; /*!< Poll SN */
+ RlcSn pollSn; /*!< Poll SN */
Buffer *mBuf; /*!< this can be removed later
Stores the Control Pdu */
Bool maxReTxReached; /*!< Set when the DL MAX Retx exceeded */
- RlcUdxDlStaPdu* pStaPdu; /*!< The Control Pdu passed from UL*/
- U8 snLen; /*!< Sequence number length:12 bit or 18 bit : 5GNR RLC */
- U32 snModMask; /*!< (2 Pwr SnLen - 1): 5GNR RLC */
+ RlcUdxDlStaPdu* pStaPdu; /*!< The Control Pdu passed from UL*/
+ uint8_t snLen; /*!< Sequence number length:12 bit or 18 bit : 5GNR RLC */
+ uint32_t snModMask; /*!< (2 Pwr SnLen - 1): 5GNR RLC */
}RlcAmDl;
/*@}*/
*/
typedef struct _rlcDlRbCb
{
- U8 qci; /*!< qci of the RB */
+ uint8_t qci; /*!< qci of the RB */
#ifdef LTE_L2_MEAS
RlcDlUeCb *ueCb; /*!< Pointer to UeCb */
RlcL2MeasRbCb rbL2Cb; /*!< RB measurement L2 Cb */
seconds for an PDCP SDU for this RB */
/* Discard new changes ends */
CmLteRlcId rlcId; /*!< RLC Identifier */
- RlcLchInfo lch; /*!< Logical Channel Info */
+ RlcLchInfo lch; /*!< Logical Channel Info */
CmLteRlcMode mode; /*!< Entity Mode */
- U8 dir; /*!< Direction for UL/DL */
+ uint8_t dir; /*!< Direction for UL/DL */
Inst inst; /*!< Tapa Instance where rb created */
SpId k1wuSapId; /*!< KWU sap Id, to get the KwuSapCb */
SpId udxSapId; /*!< UDX sap Id, to get the UdxSapCb */
- U32 transId; /*!< Transaction Id for RLC */
- Bool reestInProgress; /*!< Is reestablishment in progress */
+ uint32_t transId; /*!< Transaction Id for RLC */
+ Bool reestInProgress; /*!< Is reestablishment in progress */
SpId rguSapId; /*!< RGU Instance SAP corresponding to this RB */
union
{
}m; /*!< RLC mode specific Info */
CmLList rlsLnk; /*!< Link to add to release list */
Bool cleanupStarted; /*!< Whether cleanup of RB is in progress or not */
- U32 lastRprtdBoToMac; /*!< Last Reported BO to MAC Layer */
- U32 boUnRprtdCnt; /*!< Count to keep track of periodic BO Update */
+ uint32_t lastRprtdBoToMac; /*!< Last Reported BO to MAC Layer */
+ uint32_t boUnRprtdCnt; /*!< Count to keep track of periodic BO Update */
}RlcDlRbCb;
/**
typedef struct rlcContSduLst
{
CmLteLcId lcId; /*!< Holds the lcId of rbCb */
- U8 numSdus; /*!< Number sdus in sduIdx array */
- U8 sduIdx[RLC_L2MEAS_MAX_OUTSTNGSDU]; /*!< Hold the index to KwOutStngSduLst */
+ uint8_t numSdus; /*!< Number sdus in sduIdx array */
+ uint8_t sduIdx[RLC_L2MEAS_MAX_OUTSTNGSDU]; /*!< Hold the index to KwOutStngSduLst */
}RlcContSduLst;
typedef struct rlcSduInfo
{
typedef struct rlclchInfo
{
CmLteLcId lcId; /*!< Holds the lcId of rbCb */
- U8 numSdus; /*!< Number sdus belonged to the this LC */
- RlcSduInfo sduInfo[RLC_L2MEAS_SDUIDX];
+ uint8_t numSdus; /*!< Number sdus belonged to the this LC */
+ RlcSduInfo sduInfo[RLC_L2MEAS_SDUIDX];
}RlclchInfo;
/** @struct RlcL2MeasTb
*/
typedef struct rlcL2MeasTb
{
- U8 numLcId; /* number of logical channels in this TbCb */
+ uint8_t numLcId; /* number of logical channels in this TbCb */
RlcContSduLst sduInfo[RLC_MAX_ACTV_DRB]; /*!< Contained sduLst for
outstanding sdu */
- U8 numLchInfo;
+ uint8_t numLchInfo;
RlclchInfo lchInfo[RLC_MAX_ACTV_DRB]; /* Holds the LC info details
used for DL delay L2 Meas*/
- U32 txSegSduCnt; /*!< This holds the no.of partially
+ uint32_t txSegSduCnt; /*!< This holds the no.of partially
transmitted SDU per TB which can be used for UU loss Meas*/
}RlcL2MeasTb;
#endif
*/
struct rlcDlUeCb
{
- CmHashListEnt ueHlEnt; /*!< Hash list entry for UeCb */
- CmLteRnti ueId; /*!< UE Id */
- CmLteCellId cellId; /*!< Cell Id */
- RlcDlRbCb *srbCb[RLC_MAX_SRB_PER_UE]; /*!< SRB RbCbs within a UE */
- RlcDlRbCb *drbCb[RLC_MAX_DRB_PER_UE]; /*!< DRB RbCbs within a UE */
- RlcDlLch lCh[RLC_MAX_LCH_PER_UE]; /*!< Array of Logical channels */
+ CmHashListEnt ueHlEnt; /*!< Hash list entry for UeCb */
+ CmLteRnti ueId; /*!< UE Id */
+ CmLteCellId cellId; /*!< Cell Id */
+ RlcDlRbCb *srbCb[RLC_MAX_SRB_PER_UE]; /*!< SRB RbCbs within a UE */
+ RlcDlRbCb *drbCb[RLC_MAX_DRB_PER_UE]; /*!< DRB RbCbs within a UE */
+ RlcDlLch lCh[RLC_MAX_LCH_PER_UE]; /*!< Array of Logical channels */
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- U16 numActRb[LKW_MAX_QCI]; /*!< number of RBs Active */
- U8 tbIdx; /*!< TBIDx for measTbCb */
- RlcL2MeasTb *l2MeasTbCb[RLC_MAX_TB_PER_UE]; /*!< Array of Measurement tbCb */
+ uint16_t numActRb[LKW_MAX_QCI]; /*!< number of RBs Active */
+ uint8_t tbIdx; /*!< TBIDx for measTbCb */
+ RlcL2MeasTb *l2MeasTbCb[RLC_MAX_TB_PER_UE]; /*!< Array of Measurement tbCb */
#endif /* LTE_L2_MEAS */
#ifdef TENB_STATS
TSL2UeStatsCb *tenbStats; /*!< UE Stats Holder */
CmLteLcId lcId,
RlcDlRbCb **rbCb));
-Void rlcDbmDelAllDlRb ARGS ((RlcCb *gCb, RlcDlRbCb **rbCbLst, U8 numRbCb));
+Void rlcDbmDelAllDlRb ARGS ((RlcCb *gCb, RlcDlRbCb **rbCbLst, uint8_t numRbCb));
S16 rlcDbmDlShutdown ARGS ((RlcCb *gCb));
-Void rlcUtlGetCurrTime ARGS((U32 *time));
-Void rlcUtlTrigPdbFlowCntrl ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, U32 pktAdmitCnt ));
+Void rlcUtlGetCurrTime ARGS((uint32_t *time));
+Void rlcUtlTrigPdbFlowCntrl ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, uint32_t pktAdmitCnt ));
#ifdef LTE_L2_MEAS
Void rlcDbmDelAllDlL2MeasTbFrmUe ARGS ((RlcCb *gCb, RlcDlUeCb *ueCb));
KwuDatReqInfo *datReq,
Buffer *mBuf));
-Void rlcUmmDiscSdu ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, U32 sduId));
+Void rlcUmmDiscSdu ARGS ((RlcCb *gCb, RlcDlRbCb *rbCb, uint32_t sduId));
Void rlcDlUmmReEstablish ARGS ((RlcCb *gCb,
CmLteRlcId rlcId,
RlcDlRbCb *rbCb,
RlcUdxStaPdu *pStaPdu));
-S16 rlcAmmDiscSdu ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, U32 sduId));
+S16 rlcAmmDiscSdu ARGS((RlcCb *gCb, RlcDlRbCb *rbCb, uint32_t sduId));
Void rlcAmmPollRetxTmrExp ARGS((RlcCb *gCB, RlcDlRbCb *rbCb));
#endif /* LTE_L2_MEAS */
Void rlcUtlCalcLiForSdu ARGS ((RlcCb *gCb,
- U16 numLi,
+ uint16_t numLi,
MsgLen msgLen,
S16 *pduSz));
#ifdef LTE_L2_MEAS
Void rlcUtlUpdateContainedSduLst ARGS ((
-U8 sduIdx,
+uint8_t sduIdx,
RlcContSduLst *contSduLst
));
Void rlcUtlUpdateOutStandingSduLst ARGS ((
RlcL2MeasDlIpTh *dlIpThPut,
-U8 sduIdx,
-MsgLen sduLen,
-U32 sduId,
-Bool newIdx
+uint8_t sduIdx,
+MsgLen sduLen,
+uint32_t sduId,
+Bool newIdx
));
Void rlcUtlUpdateBurstSdus ARGS((
RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcContSduLst *contSduLst,
-S32 dataVol,
-U32 schPduSz
+S32 dataVol,
+uint32_t schPduSz
));
RlcL2MeasTb * rlcUtlGetCurMeasTb ARGS((
S16 rlcUtlSndDlL2MeasCfm ARGS ((RlcCb *gCb, RlcL2MeasEvtCb *measEvtCb));
S16 rlcUtlProcHarqInd ARGS (( RlcCb *gCb, RguHarqStatusInd *staInd, RlcDlUeCb *ueCb,
- U8 tbIdx));
+ uint8_t tbIdx));
Void rlcUtlResetDlL2MeasInRlcRb ARGS ((RlcCb *gCb,
RlcL2MeasCb *measCb,
- U8 measType));
+ uint8_t measType));
-S16 RlcMiLkwL2MeasStopCfm ARGS((Pst *pst, U8 measType,U8 status));
+S16 RlcMiLkwL2MeasStopCfm ARGS((Pst *pst, uint8_t measType,uint8_t status));
S16 rlcUtlValidateIpThL2Meas ARGS((RlcL2MeasReqEvt *measReqEvt,
RlcL2MeasCfmEvt *measCfmEvt));
S16 rlcFetchLchInfo ARGS ((RlcL2MeasReqEvt *measReqEvt,
RlcL2MeasCfmEvt *measCfmEvt,
- U16 ueId,
+ uint16_t ueId,
CmLteLcId *lChId,
- U8 *numLch));
+ uint8_t *numLch));
-S16 rlcUtlNotifyMacUlIp ARGS ((RlcL2MeasCb *measCb,U16 ueIdx, Bool enable,
- CmLteLcId *lChId, U8 *numLCh));
+S16 rlcUtlNotifyMacUlIp ARGS ((RlcL2MeasCb *measCb,uint16_t ueIdx, Bool enable,
+ CmLteLcId *lChId, uint8_t *numLCh));
#endif
uint8_t rlcProcDlData(Pst *pst, KwuDatReqInfo* datReq, Buffer *buf);
S16 rlcUtlDlBatchProcPkts(Void);
S16 rlcDlBatchProc(Void);
#if (defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
-U32 isDatReqProcessed;
+uint32_t isDatReqProcessed;
void rlcUtlDlBatchProcHqStaInd ARGS ((Void));
#endif
#endif
//UDAY
#ifdef L2_OPTMZ
-U32 rlcAmmStaPduList[512] = {0};
+uint32_t rlcAmmStaPduList[512] = {0};
EXTERN S16 ssGetDBufOfSize ARGS((Region region, Size size, Buffer **dBuf));
#endif
S16 rlcDlInitExt ARGS (( Void ));
SGetMsg(1, 0 , &mBuf);
ssGetDBufOfSize(1 , 1800, &bufPtr);
SUpdMsg(mBuf, bufPtr, 0);
- rlcAmmStaPduList[i] = (U32)mBuf;
+ rlcAmmStaPduList[i] = (uint32_t)mBuf;
}
#endif
/* call external function for intialization */
#ifdef ANSI
S16 RlcLiRguBndCfm
(
-Pst *pst,
-SuId suId,
-U8 status
+Pst *pst,
+SuId suId,
+uint8_t status
)
#else
S16 RlcLiRguBndCfm (pst, suId, status)
-Pst *pst;
-SuId suId;
-U8 status;
+Pst *pst;
+SuId suId;
+uint8_t status;
#endif
{
- U16 event; /* Event */
- U16 cause; /* Cause */
+ uint16_t event; /* Event */
+ uint16_t cause; /* Cause */
RlcRguSapCb *rguSap; /* RGU SAP Control Block */
RlcCb *tRlcCb;
{
RlcCb *tRlcCb;
RlcDlRbCb *rbCb = NULLP;
- U32 idx;
- U32 lcIdx;
+ uint32_t idx;
+ uint32_t lcIdx;
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
for (idx = 0; idx < flowCntrlInd->numUes; idx++)
{
RlcUeKey ueKey;
- S16 ret;
- RlcDlUeCb *ueCb;
- U8 tbIdx;
- RlcCb *tRlcCb;
+ S16 ret;
+ RlcDlUeCb *ueCb;
+ uint8_t tbIdx;
+ RlcCb *tRlcCb;
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
ueKey.cellId = staInd->cellId;
RlcCb *rlcCb[MAX_RLC_INSTANCES];
EXTERN S16 rlcActvTmr ARGS ((Ent ent, Inst inst));
-PRIVATE Void rlcLmmSendCfm ARGS ((RlcCb *gCb,Pst *pst,RlcMngmt *cfm,U8 type,
+PRIVATE Void rlcLmmSendCfm ARGS ((RlcCb *gCb,Pst *pst,RlcMngmt *cfm,uint8_t type,
Header *hdr));
PRIVATE S16 rlcLmmGenCfg ARGS ((RlcCb *gCb, RlcGenCfg *cfg));
PRIVATE S16 rlcLmmCfgKwuSap ARGS ((RlcCb *gCb,RlcSapCfg *cfg));
#if 0
/* Register the timer */
/*Pradeep: changing the SRegTmrMt() to SRegTmr()*/
- if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (U16)cfg->timeRes,
+ if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (uint16_t)cfg->timeRes,
rlcActvTmr) != ROK)
{
RLC_FREE(gCb,gCb->u.dlCb->udxDlSap, rlcUdxSapSize);
/* Register the timer */
#if 0
- if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (U16)cfg->timeRes,
+ if(SRegTmrMt(gCb->init.ent, gCb->init.inst, (uint16_t)cfg->timeRes,
rlcActvTmr) != ROK)
{
RLC_FREE(gCb,gCb->u.ulCb->udxUlSap, rlcUdxSapSize);
PRIVATE Void rlcLmmSendCfm
(
RlcCb *gCb,
-Pst *pst,
+Pst *pst,
RlcMngmt *cfm,
-U8 type,
-Header *hdr
+uint8_t type,
+Header *hdr
)
#else
PRIVATE Void rlcLmmSendCfm(gCb,pst, cfm, type, hdr)
RlcCb gCb;
-Pst *pst;
+Pst *pst;
RlcMngmt *cfm;
-U8 type;
-Header *hdr;
+uint8_t type;
+Header *hdr;
#endif
{
Pst rPst; /* Reply post structure */
break;
}
- RETVOID;
+ return;
}
#endif
{
S16 ret = ROK;
- U16 cntr;
- U8 measType;
+ uint16_t cntr;
+ uint8_t measType;
RlcL2MeasCfmEvt measCfmEvt;
RlcCb *tRlcCb;
S16 RlcMiLkwL2MeasStopReq
(
Pst *pst,
-U8 measType
+uint8_t measType
)
#else
S16 RlcMiLkwL2MeasStopReq (pst, measType)
Pst *pst;
-U8 measType;
+uint8_t measType;
#endif
{
S16 ret = ROK;
RlcL2MeasEvtCb *measEvtCb = NULLP;
- U16 cntr;
- U8 status = ROK;
+ uint16_t cntr;
+ uint8_t status = ROK;
RlcCb *tRlcCb;
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
S16 RlcMiLkwL2MeasSendReq
(
Pst *pst,
-U8 measType
+uint8_t measType
)
#else
S16 RlcMiLkwL2MeasSendReq (pst, measType)
Pst *pst;
-U8 measType;
+uint8_t measType;
#endif
{
/*S16 ret = ROK;*/
RlcL2MeasEvtCb *measEvtCb = NULLP;
- U16 cntr;
+ uint16_t cntr;
RlcCb *tRlcCb;
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
RlcMngmt *cntrl;
#endif
{
- S16 reason; /* reason for failure */
- U8 sAction; /* subaction field */
+ S16 reason; /* reason for failure */
+ uint8_t sAction; /* subaction field */
reason = LCM_REASON_NOT_APPL;
sAction = cntrl->t.cntrl.subAction;
gCb->init.usta = FALSE;
}
- RETVOID;
+ return;
}
/**
#endif
{
RlcRguSapCb *rguSap;
- U32 idx;
+ uint32_t idx;
if (gCb->genCfg.rlcMode == LKW_RLC_MODE_DL)
{
#ifdef ANSI
Void rlcLmmSendAlarm
(
-RlcCb *gCb,
-U16 category,
-U16 event,
-U16 cause,
-SuId suId,
-U32 ueId,
-U8 qci
+RlcCb *gCb,
+uint16_t category,
+uint16_t event,
+uint16_t cause,
+SuId suId,
+uint32_t ueId,
+uint8_t qci
)
#else
Void rlcLmmSendAlarm(category, event, cause, suId, ueId, qci)
RlcCb *gCb;
-U16 category;
-U16 event;
-U16 cause;
-SuId suId;
-U32 ueId;
-U8 qci;
+uint16_t category;
+uint16_t event;
+uint16_t cause;
+SuId suId;
+uint32_t ueId;
+uint8_t qci;
#endif
#else /* LTE_L2_MEAS */
#ifdef ANSI
Void rlcLmmSendAlarm
(
-RlcCb *gCb,
-U16 category,
-U16 event,
-U16 cause,
-SuId suId,
-U32 ueId
+RlcCb *gCb,
+uint16_t category,
+uint16_t event,
+uint16_t cause,
+SuId suId,
+uint32_t ueId
)
#else
Void rlcLmmSendAlarm(category, event, cause, suId, ueId)
-RlcCb *gCb;
-U16 category;
-U16 event;
-U16 cause;
-SuId suId;
-U32 ueId;
+RlcCb *gCb;
+uint16_t category;
+uint16_t event;
+uint16_t cause;
+SuId suId;
+uint32_t ueId;
#endif
#endif /* LTE_L2_MEAS */
{
if(gCb->init.usta == FALSE)
{
- RETVOID;
+ return;
}
usta.hdr.elmId.elmnt = STGEN;
RlcMiLkwStaInd(&(gCb->init.lmPst), &usta);
- RETVOID;
+ return;
}
#ifndef SS_RBUF
RguDedDatInd1 *rguDatInd = NULLP;
- U8 rngBufDeqIndx = 0;
+ uint8_t rngBufDeqIndx = 0;
elmIndx = SRngGetRIndx(SS_RNG_BUF_ULMAC_TO_ULRLC);
while(NULLP != elmIndx)
{
rguDatInd = (RguDedDatInd1 *)elmIndx;
datInd = (RguDDatIndInfo*) rguDatInd->msg;
- SsRngInfoTbl[SS_RNG_BUF_ULMAC_TO_ULRLC].nPktProc++;;//Number of pkt processed in tti
+ SsRngInfoTbl[SS_RNG_BUF_ULMAC_TO_ULRLC].nPktProc++;//Number of pkt processed in tti
if(datInd != NULLP)
{
RlcProcDedLcUlData(&rlcUlRbfuPst, 0, datInd);
{
RguDDatIndInfo *datInd;
PTR elem;
- U8 numLch;
- U8 numPdu;
+ uint8_t numLch;
+ uint8_t numPdu;
/* Free SS_RNG_BUF_ULMAC_TO_ULRLC */
while((SDeqSRngBuf (SS_RNG_BUF_ULMAC_TO_ULRLC, &elem) == ROK))
S16 RlcMiLkwL2MeasStopCfm
(
Pst *pst,
-U8 measType,
-U8 status
+uint8_t measType,
+uint8_t status
)
#else
S16 RlcMiLkwL2MeasStopCfm(pst, measType,status)
Pst *pst;
-U8 measType;
-U8 status;
+uint8_t measType;
+uint8_t status;
#endif
{
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
-U8 status /* Status */
+uint8_t status /* Status */
)
#else
S16 RlcUiKwuBndCfm(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
-U8 status; /* Status */
+uint8_t status; /* Status */
#endif
{
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
-U8 status /* Status */
+uint8_t status /* Status */
)
#else
S16 RlcUiCkwBndCfm(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
-U8 status; /* Status */
+uint8_t status; /* Status */
#endif
{
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
-U32 transId,
+uint32_t transId,
CkwUeInfo *ueInfo,
CmStatus status
)
S16 RlcUiCkwUeIdChgCfm(pst, suId, transId,ueInfo,status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
-U32 transId;
+uint32_t transId;
CkwUeInfo *ueInfo;
CmStatus status;
#endif
Void *elmIndx = NULLP;
RxmBufReq *datReq = NULLP;
#ifdef LTE_ADV
- U32 dlPktCount = 0;
+ uint32_t dlPktCount = 0;
#endif
- U8 rngBufDeqIndx = 0;
- U32 rngBufDeqMaxCnt;
- U32 rngBufCurrCnt;
+ uint8_t rngBufDeqIndx = 0;
+ uint32_t rngBufDeqMaxCnt;
+ uint32_t rngBufCurrCnt;
rngBufDeqMaxCnt = SS_RNG_MAX_DLPDCP_TO_DLRLC_DQ_CNT;
#ifdef TENB_T2K3K_SPECIFIC_CHANGES
{
/* Read from Ring Buffer and process PDCP packets */
- U8 rngBufDeqIndx = 0;
- U32 rngBufDeqMaxCnt;
+ uint8_t rngBufDeqIndx = 0;
+ uint32_t rngBufDeqMaxCnt;
#ifdef TENB_T2K3K_SPECIFIC_CHANGES
- U32 rngBufCurrCnt;
+ uint32_t rngBufCurrCnt;
#endif
/* Memory regions different for BRCM and Intel */
/*dstProcId,srcProcId,dstEnt,dstInst,srcEnt,srcInst,prior,route,event,region,pool,selector*/
datReq.rlcId = kwuDatReqDetl->rlcId;
datReq.sduId = kwuDatReqDetl->sduId;
datReq.lcType = kwuDatReqDetl->lcType;
- SsRngInfoTbl[SS_RNG_BUF_DLPDCP_TO_DLRLC].nPktProc++;;//Number of pkt processed in tti
+ SsRngInfoTbl[SS_RNG_BUF_DLPDCP_TO_DLRLC].nPktProc++;//Number of pkt processed in tti
if(kwuDatReqDetl->mBuf != NULLP)
{
rlcProcDlData(&rlcDlRbfuPst, kwuDatReqDetl->spId, &datReq, kwuDatReqDetl->mBuf);
Pool pool;
#endif
{
- U32 cnt=0;
+ uint32_t cnt=0;
cmLListInit(&inUseL2UeStatsLst);
cmLListInit(&freeL2UeStatsLst);
l2UeStats[cnt] = statsCb;
}
- RETVOID;
+ return;
}
/*
#ifdef ANSI
TSL2UeStatsCb* TSL2AllocUeStatsBlk
(
- U16 rnti
+ uint16_t rnti
)
#else
TSL2UeStatsCb* TSL2AllocUeStatsBlk(rnti)
- U16 rnti;
+ uint16_t rnti;
#endif
{
CmLList *tmp = NULLP;
statsCb = (TSL2UeStatsCb *)(tmp->node);
cmLListAdd2Tail(&inUseL2UeStatsLst, tmp);
- statsCb->stats.rnti = (U32)rnti;
+ statsCb->stats.rnti = (uint32_t)rnti;
statsCb->inUse = TRUE;
return (statsCb);
#ifdef ANSI
Void TSL2DeallocUeStatsBlk
(
- U16 rnti,
+ uint16_t rnti,
TSL2UeStatsCb *statsCb
)
#else
Void TSL2DeallocUeStatsBlk(rnti, statsCb)
- U16 rnti;
+ uint16_t rnti;
TSL2UeStatsCb *statsCb;
#endif
{
freeL2UeStatsLst.crnt = freeL2UeStatsLst.first;
cmLListInsAfterCrnt(&freeL2UeStatsLst, &statsCb->lnk);
- RETVOID;
+ return;
}
/*
#ifdef ANSI
TSL2CellStatsCb* TSL2AllocCellStatsBlk
(
- U32 cellId
+ uint32_t cellId
)
#else
TSL2CellStatsCb* TSL2AllocCellStatsBlk(cellId)
- U32 cellId;
+ uint32_t cellId;
#endif
{
if (cellId != 1)
#ifdef ANSI
Void TSL2DeallocCellStatsBlk
(
- U32 cellId
+ uint32_t cellId
)
#else
Void TSL2DeallocCellStatsBlk(cellId)
- U32 cellId;
+ uint32_t cellId;
#endif
{
- RETVOID;
+ return;
}
/*
SuId suId;
#endif
{
- U32 idx;
+ uint32_t idx;
for (idx = 0; idx < L2_STATS_MAX_UES; idx++)
{
TSL2UeStatsCb *statsCb = l2UeStats[idx];
- U32 rnti;
+ uint32_t rnti;
if (statsCb->inUse != TRUE)
{
continue;
for (idx = 0; idx < L2_STATS_MAX_CELLS; idx++)
{
TSL2CellStatsCb *statsCellCb = l2CellStats[idx];
- U32 cellId;
+ uint32_t cellId;
if (pst->selector == 0)
{
/* Loose Coupling */
memset(l2CellStats[idx], 0x00, sizeof(TSInfL2CellStats));
statsCellCb->cellId = cellId;
}
- RETVOID;
+ return;
}
#endif /* TENB_STATS */
/**********************************************************************
PRIVATE Void rlcTmmSendBoSta ARGS((RlcCb *gCb, RlcDlRbCb *rbCb,
MsgLen bo, KwuDatReqInfo *datReqInfo));
-extern U32 rgMacGT ;
+extern uint32_t rgMacGT ;
/** @addtogroup tmmode */
/*@{*/
"Memory Allocation failed UEID:%d CELLID:%d",
rbCb->rlcId.ueId,
rbCb->rlcId.cellId);
- RETVOID;
+ return;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
#ifdef CCPU_OPT
sdu->lstEnt.node = (PTR)sdu;
rlcTmmSendBoSta(gCb, rbCb, sdu->sduSz, datReqInfo);
- RETVOID;
+ return;
}
/**
rlcUtlEmptySduQ(gCb,&rbCb->m.tm.sduQ);
#endif
- RETVOID;
+ return;
}
/**
*
#if defined(PRE_DEF_UE_CTX) || defined(PRE_DEF_UE_CTX_HO)
#ifdef EG_GEN_LOAD_5GTF
-extern U32 loadStart;
+extern uint32_t loadStart;
#endif
EXTERN S16 PjUiPjuDatInd(Pst* pst,SuId suId,CmLtePdcpId * pdcpId,Buffer *mBuf);
Void AddUeContext
(
CmLteRnti crnti,
-U8 rrcMsgType
+uint8_t rrcMsgType
)
#else
Void AddUeContext(crnti,rrcMsgType)
CmLteRnti crnti,
-U8 rrcMsgType
+uint8_t rrcMsgType
#endif
{
KwuDatIndInfo *datIndInfo; /* Data Indication Information */
- U8 rrcConReq[6] ={ 0x50, 0x30, 0x30, 0x30, 0x30, 0x34 };
- U8 rrcConSetupComplete[34] ={ 0x20, 0x00, 0x3e, 0x0e, 0x82, 0x02, 0x10, 0x12, 0x20, 0x02, 0x20, 0x64, 0xa8, 0x2c, 0x48, 0x05, 0x00, 0x80, 0x00, 0x08, 0x04, 0x03, 0xa0, 0x02, 0xa0, 0x10, 0x12, 0x20, 0x02, 0x20, 0x64, 0xa8, 0x2c, 0x48};
+ uint8_t rrcConReq[6] ={ 0x50, 0x30, 0x30, 0x30, 0x30, 0x34 };
+ uint8_t rrcConSetupComplete[34] ={ 0x20, 0x00, 0x3e, 0x0e, 0x82, 0x02, 0x10, 0x12, 0x20, 0x02, 0x20, 0x64, 0xa8, 0x2c, 0x48, 0x05, 0x00, 0x80, 0x00, 0x08, 0x04, 0x03, 0xa0, 0x02, 0xa0, 0x10, 0x12, 0x20, 0x02, 0x20, 0x64, 0xa8, 0x2c, 0x48};
#ifndef CA_PAL_5GTF
- U8 rrcUeCapabilityInfo[12] ={0x38, 0x01, 0x00, 0x80, 0x1b, 0xff, 0x0c, 0x00, 0x20, 0x00, 0x80, 0x00};
+ uint8_t rrcUeCapabilityInfo[12] ={0x38, 0x01, 0x00, 0x80, 0x1b, 0xff, 0x0c, 0x00, 0x20, 0x00, 0x80, 0x00};
#else
- /* U8 rrcUeCapabilityInfo[44] ={0x38,0x01,0x02,0x84,0x9b,0xff,0x0c,0x00,0x20,0x00,0x80,0x1f,0xfe,0xf4,0x4f,0xe0,0x40,0x03,0x80,0x11,0x04,0x0c,0x20,0x88,0x20,0x7f,0xff,0xff,0xff,0xf3,0xff,0x81,0xff,0xff,0xff,0xff,0x7f,0xf0,0x3f,0xff,0xff,0xff,0xe0,0x00};
+ /* uint8_t rrcUeCapabilityInfo[44] ={0x38,0x01,0x02,0x84,0x9b,0xff,0x0c,0x00,0x20,0x00,0x80,0x1f,0xfe,0xf4,0x4f,0xe0,0x40,0x03,0x80,0x11,0x04,0x0c,0x20,0x88,0x20,0x7f,0xff,0xff,0xff,0xf3,0xff,0x81,0xff,0xff,0xff,0xff,0x7f,0xf0,0x3f,0xff,0xff,0xff,0xe0,0x00};
*/
-U8 rrcUeCapabilityInfo[] =
+uint8_t rrcUeCapabilityInfo[] =
{
0x38,0x01,0x03,0x34,0x9b,0xff,0x0c,0x00,0x20,0x00,0x80,0x1f,0xfe,0xf4,0x4f,0xe0
,0x40,0x09,0x80,0x11,0x04,0x0c,0x20,0x88,0x20,0x63,0x04,0x41,0x03,0x20,0x22,0x08
};
#endif
- U8 rrcSecurityModeComplete[2] ={0x28, 0x80};
- U8 rrcReconfigComplete[2] ={0x10, 0x80};
+ uint8_t rrcSecurityModeComplete[2] ={0x28, 0x80};
+ uint8_t rrcReconfigComplete[2] ={0x10, 0x80};
Buffer *pdu;
#endif
#endif
}
- RETVOID;
+ return;
}
#endif
/** @addtogroup tmmode */
{
RLOG_ARG0(L_DEBUG,DBG_RBID,rbCb->rlcId.rbId,"do nothing for TMM for ReEstablish");
- RETVOID;
+ return;
}
#ifdef _cplusplus
}
}
- RETVOID;
+ return;
}
/**
}
}
- RETVOID;
+ return;
}
#ifdef ANSI
PRIVATE S16 cmUnpkUdxStruct
(
-Buffer *srcMBuf,
-U32 offset,
-U8 *dstBuf,
-U32 size
+Buffer *srcMBuf,
+uint32_t offset,
+uint8_t *dstBuf,
+uint32_t size
)
#else
PRIVATE S16 cmUnpkUdxStruct(dstMBuf,srcBuf,size)
-Buffer *srcMBuf;
-U32 offset;
-U8 *dstBuf;
+Buffer *srcMBuf;
+uint32_t offset;
+uint8_t *dstBuf;
MsgLen size;
#endif
{
#ifdef ANSI
PRIVATE S16 cmPkUdxStruct
(
-U8 *srcBuf,
-MsgLen size,
-Buffer *dstMBuf
+uint8_t *srcBuf,
+MsgLen size,
+Buffer *dstMBuf
)
#else
PRIVATE S16 cmPkUdxStruct(dstMBuf,srcBuf,size)
-U8 *srcBuf;
-MsgLen size;
-Buffer *dstMBuf;
+uint8_t *srcBuf;
+MsgLen size;
+Buffer *dstMBuf;
#endif
{
(
Pst *pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 cmPkUdxBndCfm(pst, suId, status)
Pst *pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
S16 ret1;
#ifdef LCUDX
case UDX_SEL_LC:
{
- cmPkUdxStruct((U8 *)cfgInfo, sizeof(RlcCfgInfo),mBuf);
+ cmPkUdxStruct((uint8_t *)cfgInfo, sizeof(RlcCfgInfo),mBuf);
/* Need Not free CfgInfo here as it is stored
in UL */
break;
#ifdef LCUDX
case UDX_SEL_LC:
{
- cmPkUdxStruct((U8 *)cfgCfmInfo, sizeof(RlcCfgCfmInfo),mBuf);
+ cmPkUdxStruct((uint8_t *)cfgCfmInfo, sizeof(RlcCfgCfmInfo),mBuf);
/* Need to free the cfgCfmInfo here as it is allocated
buffer call SPutStaticBuffer */
SPutStaticBuffer(pst->region,pst->pool,(Data *) cfgCfmInfo,
(
Pst *pst,
SpId spId,
-U32 transId,
+uint32_t transId,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo
)
S16 cmPkUdxUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
Pst *pst;
SpId spId;
-U32 transId;
+uint32_t transId;
CkwUeInfo *ueInfo;
CkwUeInfo *newUeInfo;
#endif
#ifdef LCUDX
case UDX_SEL_LC:
{
- cmPkUdxStruct((U8 *)newUeInfo, sizeof(CkwUeInfo),mBuf);
- cmPkUdxStruct((U8 *)ueInfo, sizeof(CkwUeInfo),mBuf);
+ cmPkUdxStruct((uint8_t *)newUeInfo, sizeof(CkwUeInfo),mBuf);
+ cmPkUdxStruct((uint8_t *)ueInfo, sizeof(CkwUeInfo),mBuf);
/* No need to free ueInfo here as it is stored */
break;
}
(
Pst *pst,
SuId suId,
-U32 transId,
+uint32_t transId,
CmStatus status
)
#else
S16 cmPkUdxUeIdChgCfm(pst, suId, transId, status)
Pst *pst;
SuId suId;
-U32 transId;
+uint32_t transId;
CmStatus status;
#endif
{
{
case UDX_SEL_LC:
{
- cmPkUdxStruct((U8 *)pStaPdu, sizeof(RlcUdxBufLst),mBuf);
- cmPkUdxStruct((U8 *)rlcId, sizeof(CmLteRlcId),mBuf);
+ cmPkUdxStruct((uint8_t *)pStaPdu, sizeof(RlcUdxBufLst),mBuf);
+ cmPkUdxStruct((uint8_t *)rlcId, sizeof(CmLteRlcId),mBuf);
break;
}
case UDX_SEL_LWLC:
{
case UDX_SEL_LC:
{
- cmPkUdxStruct((U8 *)rlcId, sizeof(CmLteRlcId),mBuf);
+ cmPkUdxStruct((uint8_t *)rlcId, sizeof(CmLteRlcId),mBuf);
break;
}
case UDX_SEL_LWLC:
{
case UDX_SEL_LC:
{
- cmPkUdxStruct((U8 *)pStaPdu, sizeof(RlcUdxStaPdu),mBuf);
- cmPkUdxStruct((U8 *)rlcId, sizeof(CmLteRlcId),mBuf);
+ cmPkUdxStruct((uint8_t *)pStaPdu, sizeof(RlcUdxStaPdu),mBuf);
+ cmPkUdxStruct((uint8_t *)rlcId, sizeof(CmLteRlcId),mBuf);
SPutStaticBuffer(pst->region,pst->pool,(Data *) pStaPdu,
sizeof(RlcUdxStaPdu),0);
{
case UDX_SEL_LC:
{
- cmPkUdxStruct((U8 *)pStaPdu, sizeof(RlcUdxDlStaPdu),mBuf);
- cmPkUdxStruct((U8 *)rlcId, sizeof(CmLteRlcId),mBuf);
+ cmPkUdxStruct((uint8_t *)pStaPdu, sizeof(RlcUdxDlStaPdu),mBuf);
+ cmPkUdxStruct((uint8_t *)rlcId, sizeof(CmLteRlcId),mBuf);
/* Free status Pdu here for LC */
SPutStaticBuffer(pst->region,pst->pool,(Data *) pStaPdu,
sizeof(RlcUdxDlStaPdu),0);
{
case UDX_SEL_LC:
{
- cmPkUdxStruct((U8 *)measReqEvt, sizeof(RlcL2MeasReqEvt),mBuf);
+ cmPkUdxStruct((uint8_t *)measReqEvt, sizeof(RlcL2MeasReqEvt),mBuf);
break;
}
case UDX_SEL_LWLC:
S16 cmPkUdxL2MeasSendReq
(
Pst *pst,
-U8 measType
+uint8_t measType
)
#else
S16 cmPkUdxL2MeasSendReq(pst, measReqEvt)
Pst *pst;
-U8 measType
+uint8_t measType
#endif
{
S16 ret1;
S16 cmPkUdxL2MeasStopReq
(
Pst *pst,
-U8 measType
+uint8_t measType
)
#else
S16 cmPkUdxL2MeasStopReq(pst, measType)
Pst *pst;
-U8 measType
+uint8_t measType
#endif
{
S16 ret1;
#endif
{
SuId suId = 0;
- U8 status = 0;
+ uint8_t status = 0;
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EUDXXXX, pst);
CMCHKUNPKLOG(oduPackUInt8, &status, mBuf, EUDXXXX, pst);
case UDX_SEL_LC:
{
#if(ERRCLASS & ERRCLS_DEBUG)
- ret1 = cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpCfgInfo,sizeof(RlcCfgInfo));
+ ret1 = cmUnpkUdxStruct(mBuf,0,(uint8_t *)&tmpCfgInfo,sizeof(RlcCfgInfo));
if(ret1 != ROK)
{
SPutMsg(mBuf);
return ( ret1 );
}
#else
- cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpCfgInfo,sizeof(RlcCfgInfo));
+ cmUnpkUdxStruct(mBuf,0,(uint8_t *)&tmpCfgInfo,sizeof(RlcCfgInfo));
#endif /* ERRCLASS & ERRCLS_DEBUG */
cfgInfo = &tmpCfgInfo;
break;
return (ret1);
}
- ret1 = cmUnpkUdxStruct(mBuf,0,(U8 *)cfgCfmInfo, sizeof(RlcCfgCfmInfo));
+ ret1 = cmUnpkUdxStruct(mBuf,0,(uint8_t *)cfgCfmInfo, sizeof(RlcCfgCfmInfo));
#if(ERRCLASS & ERRCLS_DEBUG)
if(ret1 != ROK)
{
#endif
{
SpId spId = 0;
- U32 transId = 0;
+ uint32_t transId = 0;
CkwUeInfo tmpUeInfo;
CkwUeInfo tmpNewUeInfo;
CkwUeInfo *ueInfo;
#ifdef LCUDX
case UDX_SEL_LC:
{
- cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpNewUeInfo, sizeof(CkwUeInfo));
- cmUnpkUdxStruct(mBuf,sizeof(CkwUeInfo),(U8 *)&tmpUeInfo, sizeof(CkwUeInfo));
+ cmUnpkUdxStruct(mBuf,0,(uint8_t *)&tmpNewUeInfo, sizeof(CkwUeInfo));
+ cmUnpkUdxStruct(mBuf,sizeof(CkwUeInfo),(uint8_t *)&tmpUeInfo, sizeof(CkwUeInfo));
ueInfo = &tmpUeInfo;
newUeInfo = &tmpNewUeInfo;
#endif
{
SuId suId = 0;
- U32 transId = 0;
+ uint32_t transId = 0;
CmStatus status;
memset(&status, 0, sizeof(CmStatus));
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return (ret1);
}
- ret1 = cmUnpkUdxStruct(mBuf,0,(U8 *)pStaPdu, sizeof(RlcUdxStaPdu));
- ret1 = cmUnpkUdxStruct(mBuf,sizeof(RlcUdxStaPdu),(U8 *)&tmpRlcId,sizeof(CmLteRlcId));
+ ret1 = cmUnpkUdxStruct(mBuf,0,(uint8_t *)pStaPdu, sizeof(RlcUdxStaPdu));
+ ret1 = cmUnpkUdxStruct(mBuf,sizeof(RlcUdxStaPdu),(uint8_t *)&tmpRlcId,sizeof(CmLteRlcId));
rlcId = &tmpRlcId;
break;
}
#endif /* ERRCLASS & ERRCLS_ADD_RES */
return (ret1);
}
- ret1 = cmUnpkUdxStruct(mBuf,0, (U8 *)pStaPdu, sizeof(RlcUdxDlStaPdu));
- ret1 = cmUnpkUdxStruct(mBuf,sizeof(RlcUdxDlStaPdu),(U8 *)&tmpRlcId,sizeof(CmLteRlcId));
+ ret1 = cmUnpkUdxStruct(mBuf,0, (uint8_t *)pStaPdu, sizeof(RlcUdxDlStaPdu));
+ ret1 = cmUnpkUdxStruct(mBuf,sizeof(RlcUdxDlStaPdu),(uint8_t *)&tmpRlcId,sizeof(CmLteRlcId));
rlcId = &tmpRlcId;
break;
}
{
case UDX_SEL_LC:
{
- cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpRlcId,sizeof(CmLteRlcId));
+ cmUnpkUdxStruct(mBuf,0,(uint8_t *)&tmpRlcId,sizeof(CmLteRlcId));
rlcId = &tmpRlcId;
break;
}
{
case UDX_SEL_LC:
{
- cmUnpkUdxStruct(mBuf,0,(U8 *)&tmpMeasReqEvt,sizeof(RlcL2MeasReqEvt));
+ cmUnpkUdxStruct(mBuf,0,(uint8_t *)&tmpMeasReqEvt,sizeof(RlcL2MeasReqEvt));
measReqEvt = &tmpMeasReqEvt;
break;
}
Buffer *mBuf;
#endif
{
- U8 measType = 0; /* KW_FIX */
+ uint8_t measType = 0; /* KW_FIX */
switch (pst->selector)
{
Buffer *mBuf;
#endif
{
- U8 measType = 0; /* KW_FIX */
+ uint8_t measType = 0; /* KW_FIX */
switch (pst->selector)
{
typedef struct rlcNackInfo
{
- U8 nackRange;
- U8 isSegment;
- U32 sn; /*!< Nack Sn */
- U16 soStart; /*!< Segment offset start */
- U16 soEnd; /*!< Segment offset End */
+ uint8_t nackRange;
+ uint8_t isSegment;
+ uint32_t sn; /*!< Nack Sn */
+ uint16_t soStart; /*!< Segment offset start */
+ uint16_t soEnd; /*!< Segment offset End */
}RlcNackInfo;
typedef struct rlcUdxStaPdu
{
- U32 ackSn;
+ uint32_t ackSn;
/* TODO : RLC_MAX_NACK_CNT should set to MAx SR delay
It is tradeoff to consider array based instead of dynamic
as there are chances where we might loose Status information
on spill over*/
- U8 nackCnt; /* Cnt of Nacks in the array*/
+ uint8_t nackCnt; /* Cnt of Nacks in the array*/
RlcNackInfo nackInfo[RLC_MAX_NACK_CNT];
}RlcUdxStaPdu;
typedef struct rlcStatusPdu
{
- U32 ackSn;
+ uint32_t ackSn;
RlcNackInfo nackInfo[RLC_MAX_NACK_CNT];
- U16 nackCount;
- U16 controlBo;
+ uint16_t nackCount;
+ uint16_t controlBo;
}RlcUdxDlStaPdu;
/* ### Umapathi*/
* @brief
* UDX APIs
*/
-typedef S16 (*UdxBndCfm) ARGS((Pst* pst, SuId suId,U8 status ));
+typedef S16 (*UdxBndCfm) ARGS((Pst* pst, SuId suId,uint8_t status ));
typedef S16 (*UdxBndReq) ARGS((Pst* pst, SuId suId,SpId spId ));
typedef S16 (*UdxUeIdChgReq) ARGS((Pst *pst,
SpId spId,
- U32 transId,
+ uint32_t transId,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo));
typedef S16 (*UdxUeIdChgCfm) ARGS((Pst *pst,
SuId suId,
- U32 transId,
+ uint32_t transId,
CmStatus status));
typedef S16 (*UdxStaUpdCfm) ARGS((Pst* pst,
RlcL2MeasReqEvt *measReqEvt));
typedef S16 (*UdxL2MeasSendReq) ARGS((Pst* pst,
- U8 measType));
+ uint8_t measType));
typedef S16 (*UdxL2MeasStopReq) ARGS((Pst* pst,
- U8 measType));
+ uint8_t measType));
#endif
#ifdef LCUDX
-S16 cmPkUdxBndCfm ARGS((Pst* pst, SuId suId,U8 status ));
+S16 cmPkUdxBndCfm ARGS((Pst* pst, SuId suId,uint8_t status ));
S16 cmPkUdxBndReq ARGS((Pst* pst, SuId suId,SpId spId ));
S16 cmPkUdxUbndReq ARGS((Pst* pst, SuId suId,Reason reason));
S16 cmPkUdxCfgReq ARGS((Pst *pst, SpId spId, RlcCfgInfo *cfgInfo));
S16 cmPkUdxCfgCfm ARGS(( Pst* pst,SuId suId,RlcCfgCfmInfo *cfmInfo));
S16 cmPkUdxStaUpdReq ARGS((Pst* pst,SpId spId,CmLteRlcId *rlcId,
RlcUdxStaPdu *pStaPdu ));
-S16 cmPkUdxUeIdChgReq ARGS((Pst *pst, SpId spId, U32 transId,
+S16 cmPkUdxUeIdChgReq ARGS((Pst *pst, SpId spId, uint32_t transId,
CkwUeInfo *ueInfo, CkwUeInfo *newUeInfo));
-S16 cmPkUdxUeIdChgCfm ARGS((Pst *pst, SuId suId, U32 transId,
+S16 cmPkUdxUeIdChgCfm ARGS((Pst *pst, SuId suId, uint32_t transId,
CmStatus status));
#ifdef LTE_L2_MEAS
S16 cmPkUdxL2MeasReq ARGS((Pst *pst, RlcL2MeasReqEvt *measReqEvt));
-S16 cmPkUdxL2MeasSendReq ARGS((Pst *pst, U8 measType));
-S16 cmPkUdxL2MeasStopReq ARGS((Pst *pst, U8 measType));
+S16 cmPkUdxL2MeasSendReq ARGS((Pst *pst, uint8_t measType));
+S16 cmPkUdxL2MeasStopReq ARGS((Pst *pst, uint8_t measType));
#endif
S16 cmUnpkUdxBndCfm ARGS((UdxBndCfm func,Pst* pst, Buffer *mBuf ));
S16 rlcDlUdxBndReq ARGS((Pst* pst, SuId suId, SpId spId));
-S16 rlcDlUdxBndCfm ARGS((Pst* pst, SuId suId, U8 status));
+S16 rlcDlUdxBndCfm ARGS((Pst* pst, SuId suId, uint8_t status));
-S16 rlcUlUdxBndCfm ARGS((Pst* pst, SuId suId, U8 status));
+S16 rlcUlUdxBndCfm ARGS((Pst* pst, SuId suId, uint8_t status));
S16 rlcDlUdxCfgCfm ARGS((Pst* pst, SuId suId, RlcCfgCfmInfo *cfmInfo));
S16 rlcDlUdxUeIdChgCfm ARGS((Pst *pst,
SuId suId,
- U32 transId,
+ uint32_t transId,
CmStatus status));
S16 rlcUlUdxUeIdChgCfm ARGS((Pst *pst,
SuId suId,
- U32 transId,
+ uint32_t transId,
CmStatus status));
S16 rlcUlUdxUbndReq ARGS((Pst* pst, SuId suId, Reason reason));
S16 rlcUlUdxUeIdChgReq ARGS((Pst *pst,
SpId spId,
- U32 transId,
+ uint32_t transId,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo));
S16 rlcDlUdxUeIdChgReq ARGS((Pst *pst,
SpId spId,
- U32 transId,
+ uint32_t transId,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo));
#ifdef LTE_L2_MEAS
S16 rlcDlUdxL2MeasReq ARGS((Pst *pst, RlcL2MeasReqEvt *measReqEvt));
-S16 rlcDlUdxL2MeasSendReq ARGS((Pst *pst, U8 status));
+S16 rlcDlUdxL2MeasSendReq ARGS((Pst *pst, uint8_t status));
-S16 rlcDlUdxL2MeasStopReq ARGS((Pst *pst, U8 status));
+S16 rlcDlUdxL2MeasStopReq ARGS((Pst *pst, uint8_t status));
S16 rlcUlUdxL2MeasReq ARGS((Pst* pst, RlcL2MeasReqEvt *measReqEvt));
-S16 rlcUlUdxL2MeasSendReq ARGS((Pst *pst, U8 status));
+S16 rlcUlUdxL2MeasSendReq ARGS((Pst *pst, uint8_t status));
-S16 rlcUlUdxL2MeasStopReq ARGS((Pst* pst, U8 measType));
+S16 rlcUlUdxL2MeasStopReq ARGS((Pst* pst, uint8_t measType));
#endif
#endif
#endif
{
RlcCfgCfmInfo *cfgCfm;
- U8 idx;
- RlcCb *tRlcCb;
+ uint8_t idx;
+ RlcCb *tRlcCb;
Pst *pstUdxCfm;
#if (ERRCLASS & ERRCLS_INT_PAR)
(
Pst *pst,
SpId spId,
-U32 transId,
+uint32_t transId,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo
)
S16 rlcDlUdxUeIdChgReq(pst,spId,transId,ueInfo,newUeInfo)
Pst *pst;
SpId spId;
-U32 transId;
+uint32_t transId;
CkwUeInfo *ueInfo;
CkwUeInfo *newUeInfo;
#endif
RlcL2MeasReqEvt *measReqEvt;
#endif
{
- U32 cntr;
- U8 measType;
- VOLATILE U32 startTime = 0;
+ uint32_t cntr;
+ uint8_t measType;
+ VOLATILE uint32_t startTime = 0;
RlcCb *tRlcCb;
/*starting Task*/
else
{
/* for nonIpThroughput meas, enable only for the sent QCIs */
- U32 i;
+ uint32_t i;
for(i = 0; i < LKW_MAX_QCI; i++)
{
tRlcCb->u.dlCb->rlcL2Cb.measOn[i] |= measType;
S16 rlcDlUdxL2MeasStopReq
(
Pst *pst,
-U8 measType
+uint8_t measType
)
#else
S16 rlcDlUdxL2MeasStopReq (pst, measType)
Pst *pst;
-U8 measType;
+uint8_t measType;
#endif
{
/* S16 ret = ROK;*/
RlcL2MeasEvtCb *measEvtCb = NULLP;
- U16 cntr;
- U8 status = ROK;
+ uint16_t cntr;
+ uint8_t status = ROK;
/* RlcL2MeasCfmEvt measCfmEvt; */
- VOLATILE U32 startTime = 0;
+ VOLATILE uint32_t startTime = 0;
RlcCb *tRlcCb=NULLP;
/*starting Task*/
S16 rlcDlUdxL2MeasSendReq
(
Pst *pst,
-U8 measType
+uint8_t measType
)
#else
S16 rlcDlUdxL2MeasSendReq (pst, measType)
Pst *pst;
-U8 measType;
+uint8_t measType;
#endif
{
RlcL2MeasEvtCb *measEvtCb;
- U16 cntr;
+ uint16_t cntr;
- VOLATILE U32 startTime = 0;
+ VOLATILE uint32_t startTime = 0;
RlcCb *tRlcCb;
tRlcCb = RLC_GET_RLCCB(pst->dstInst);
#define UDX_MAX_SEL 3
#ifndef LCKWULUDX
-PRIVATE S16 PtDlUdxBndCfm ARGS(( Pst *pst,SuId suId,U8 status ));
+PRIVATE S16 PtDlUdxBndCfm ARGS(( Pst *pst,SuId suId,uint8_t status ));
PRIVATE S16 PtDlUdxCfgCfm ARGS((Pst *pst, SuId suId, RlcCfgCfmInfo *cfmInfo));
-PRIVATE S16 PtDlUdxUeIdChgCfm ARGS(( Pst *pst, SuId suId,U32 transId,
+PRIVATE S16 PtDlUdxUeIdChgCfm ARGS(( Pst *pst, SuId suId,uint32_t transId,
CmStatus status));
PRIVATE S16 PtDlUdxStaUpdCfm ARGS(( Pst* pst,SuId suId,CmLteRlcId *rlcId,
RlcUdxBufLst *pBufLst));
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
-U8 status /* Status */
+uint8_t status /* Status */
)
#else
PRIVATE S16 PtDlUdxBndCfm(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
-U8 status; /* Status */
+uint8_t status; /* Status */
#endif
{
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
-U32 transId,
+uint32_t transId,
CmStatus status
)
#else
PRIVATE S16 PtDlUdxUeIdChgCfm(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
-U32 transId;
+uint32_t transId;
CmStatus status;
#endif
{
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
-U8 status /* Status */
+uint8_t status /* Status */
)
#else
S16 rlcDlUdxBndCfm(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
-U8 status; /* Status */
+uint8_t status; /* Status */
#endif
{
(
Pst *pst, /* post structure */
SuId suId, /* Service User Id */
-U32 transId,
+uint32_t transId,
CmStatus status
)
#else
S16 rlcDlUdxUeIdChgCfm(pst, suId, status)
Pst *pst; /* post structure */
SuId suId; /* Service User Id */
-U32 transId;
+uint32_t transId;
CmStatus status;
#endif
{
PRIVATE S16 PtUlUdxCfgReq ARGS((Pst *pst, SpId spId, RlcCfgInfo *cfgInfo));
PRIVATE S16 PtUlUdxStaUpdReq ARGS((Pst* pst,SpId spId,CmLteRlcId *rlcId,
RlcUdxStaPdu *pStaPdu ));
-PRIVATE S16 PtUlUdxUeIdChgReq ARGS((Pst *pst, SpId spId, U32 transId,
+PRIVATE S16 PtUlUdxUeIdChgReq ARGS((Pst *pst, SpId spId, uint32_t transId,
CkwUeInfo *ueInfo, CkwUeInfo *newUeInfo));
PRIVATE S16 PtUlUdxStaPduReq ARGS(( Pst* pst,SpId spId, CmLteRlcId *rlcId,
RlcUdxDlStaPdu *pStaPdu ));
(
Pst *pst, /* post structure */
SpId spId, /* Service User Id */
-U32 transId, /* transaction Id */
+uint32_t transId, /* transaction Id */
CkwUeInfo *ueInfo, /* Config Info */
CkwUeInfo *newUeInfo /* Config Info */
)
PRIVATE S16 PtUlUdxUeIdChgReq(pst, spId,transId, ueInfo, newUeInfo)
Pst *pst; /* post structure */
SpId spId; /* Service User Id */
-U32 transId; /* transaction Id */
+uint32_t transId; /* transaction Id */
CkwUeInfo *ueInfo; /* Config Info */
CkwUeInfo *newUeInfo; /* Config Info */
#endif
#ifdef ANSI
PRIVATE S16 PtUlUdxL2MeasSendReq
(
-Pst* pst,
-U8 status
+Pst* pst,
+uint8_t status
)
#else
PRIVATE S16 PtUlUdxL2MeasSendReq(pst, status )
-Pst* pst;
-U8 status
+Pst* pst;
+uint8_t status
#endif
{
#ifdef ANSI
PRIVATE S16 PtUlUdxL2MeasStopReq
(
-Pst* pst,
-U8 status
+Pst* pst,
+uint8_t status
)
#else
PRIVATE S16 PtUlUdxL2MeasStopReq(pst, status )
-Pst* pst;
-U8 status
+Pst* pst;
+uint8_t status
#endif
{
(
Pst *pst, /* post structure */
SpId spId, /* Service User Id */
-U32 transId, /* transaction Id */
+uint32_t transId, /* transaction Id */
CkwUeInfo *ueInfo, /* Config Info */
CkwUeInfo *newUeInfo /* Config Info */
)
S16 rlcUlUdxUeIdChgReq(pst, spId,transId, ueInfo, newUeInfo)
Pst *pst; /* post structure */
SpId spId; /* Service User Id */
-U32 transId; /* transaction Id */
+uint32_t transId; /* transaction Id */
CkwUeInfo *ueInfo; /* Config Info */
CkwUeInfo *newUeInfo; /* Config Info */
#endif
#ifdef ANSI
S16 rlcUlUdxL2MeasSendReq
(
-Pst* pst,
-U8 measType
+Pst* pst,
+uint8_t measType
)
#else
S16 rlcUlUdxL2MeasSendReq(pst,measReqEvt)
-Pst* pst;
-U8 measType;
+Pst* pst;
+uint8_t measType;
#endif
{
#ifdef ANSI
S16 rlcUlUdxL2MeasStopReq
(
-Pst* pst,
-U8 measType
+Pst* pst,
+uint8_t measType
)
#else
S16 rlcUlUdxL2MeasStopReq(pst,measReqEvt)
-Pst* pst;
-U8 measType;
+Pst* pst;
+uint8_t measType;
#endif
{
(
Pst *pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 rlcUlUdxBndCfm (pst, suId, status)
Pst *pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
- U16 event;
- U16 cause;
+ uint16_t event;
+ uint16_t cause;
RlcUdxUlSapCb *udxSap; /* RGU SAP Control Block */
RlcCb *tRlcCb;
(
Pst *pst,
SuId suId,
-U32 transId,
+uint32_t transId,
CmStatus status
)
#else
S16 rlcUlUdxUeIdChgCfm (pst, suId, cfmInfo)
Pst *pst;
SuId suId;
-U32 transId;
+uint32_t transId;
CmStatus status;
#endif
{
#endif
{
RlcCfgInfo *cfg;
- U32 idx;
- U32 maxEnt;
+ uint32_t idx;
+ uint32_t maxEnt;
cfg = cfgTmpData->cfgInfo;
maxEnt = (cfg->numEnt < CKW_MAX_ENT_CFG)? cfg->numEnt:CKW_MAX_ENT_CFG;
RlcCb *tRlcCb;
RlcUlCfgTmpData *cfgTmpData;
- static U32 transCount;
+ static uint32_t transCount;
#if (ERRCLASS & ERRCLS_INT_PAR)
if (pst->dstInst >= MAX_RLC_INSTANCES)
(
Pst *pst,
SpId spId,
-U32 transId,
+uint32_t transId,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo
)
S16 RlcUiCkwUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
Pst *pst;
SpId spId;
-U32 transId;
+uint32_t transId;
CkwUeInfo *ueInfo;
CkwUeInfo *newUeInfo;
#endif
RlcCfgInfo *cfg;
#endif
{
- U8 idx;
+ uint8_t idx;
cfgTmpData->ueId = cfg->ueId;
cfgTmpData->cellId = cfg->cellId;
}
}/* switch end */
}/* for end */
- RETVOID;
+ return;
}
\f
*/
typedef struct rlcUmUl
{
- U8 snLen; /**< Sequence number length */
- U8 reOrdTmrInt; /**< Timer Interval */
+ uint8_t snLen; /**< Sequence number length */
+ uint8_t reOrdTmrInt; /**< Timer Interval */
RlcUmRecBuf **recBuf; /**< Reception buffer */
RlcSn umWinSz; /**< UM window size */
- U16 modBitMask; /**< Bitmask for modulus to wrap around variables */
+ uint16_t modBitMask; /**< Bitmask for modulus to wrap around variables */
RlcSn sn; /**< Sequence number */
RlcSn vrUr; /**< VR(UR) - Receive state variable */
RlcSn vrUh; /**< VR(UH) - Highest received state variable */
CmLList lstEnt; /**< List entry for PDU segment */
Buffer *seg; /**< PDU segment */
MsgLen segSz; /**< Buffer Size */
- U16 soEnd; /**< Segment Offset End */
- RlcAmHdr amHdr; /**< AM header */
+ uint16_t soEnd; /**< Segment Offset End */
+ RlcAmHdr amHdr; /**< AM header */
}RlcSeg;
/*@}*/
CmLList lnk; /**< Link to the receive buffer list */
Buffer *pdu; /**< PDU buffer */
MsgLen pduSz; /**< Buffer Size */
- RlcAmHdr amHdr; /**< AM header Info */
+ RlcAmHdr amHdr; /**< AM header Info */
CmLListCp segLst; /**< PDU Segments list */
- RlcSeg *expByteSeg; /**< Next expected byte segment */
- U16 expSo; /**< Next expected seg offset */
+ RlcSeg *expByteSeg; /**< Next expected byte segment */
+ uint16_t expSo; /**< Next expected seg offset */
Bool allRcvd; /**< All bytes received or not */
Bool isDelvUpperLayer; /**< Is it sent to upper layer */
}RlcAmRecBuf;
Bool staTrg; /**< Whether status trigger occured */
Buffer *partialSdu; /**< Partially received SDU */
RlcSn expSn; /**< Expected SN for reassembly */
- U16 expSo; /**< Expected SO for reassembly */
+ uint16_t expSo; /**< Expected SO for reassembly */
CmTimer staProhTmr; /**< T_status_prohibit Timer */
- U16 staProhTmrInt; /**< Timer Interval */
+ uint16_t staProhTmrInt; /**< Timer Interval */
CmTimer reOrdTmr; /**< T_reordering Timer */
- U8 reOrdTmrInt; /**< Timer Interval */
+ uint8_t reOrdTmrInt; /**< Timer Interval */
Bool gatherStaPduInfo; /**< Gather STATUS PDU creation info*/
Bool isOutOfSeq; /**< To identify whether packets are Out-Of-Seq or not */
- U8 snLen; /*!< Sequence number length:12 bit or 18 bit : 5GNR RLC */
- U32 snModMask; /*!< (2 Pwr SnLen - 1): 5GNR RLC */
+ uint8_t snLen; /*!< Sequence number length:12 bit or 18 bit : 5GNR RLC */
+ uint32_t snModMask; /*!< (2 Pwr SnLen - 1): 5GNR RLC */
}RlcAmUl;
/*@}*/
#ifdef LTE_L2_MEAS
RlcL2MeasRbCb rbL2Cb; /**< RB measurement L2 Cb */
RlcUlUeCb *ueCb; /*!< Pointer to UeCb */
- U8 qci; /**< qci of the RB */
+ uint8_t qci; /**< qci of the RB */
RlcL2MeasIpThruput l2MeasIpThruput; /**< Holds related parameter for
DL/Ul ip throughput>*/
#endif /* LTE_L2_MEAS */
CmLteRlcId rlcId; /**< RLC Identifier */
RlcLchInfo lch; /**< Logical Channel Info */
CmLteRlcMode mode; /**< Entity Mode */
- U8 dir; /**< Direction for UL/DL */
+ uint8_t dir; /**< Direction for UL/DL */
Inst inst; /**< Tapa where Rb created Instance id */
SpId k1wuSapId; /**< KWU sap Id, to get the KwuSapCb */
SpId udxSapId; /**< KWU sap Id, to get the KwuSapCb */
- U32 transId; /**< Transaction Id for RLC */
+ uint32_t transId; /**< Transaction Id for RLC */
union
{
RlcUmUl umUl; /**< UM mode Ul elements */
RlcUlLch lCh[RLC_MAX_LCH_PER_UE]; /**< Logical channels of an UE*/
/* kw005.201 added support for L2 Measurement */
#ifdef LTE_L2_MEAS
- U32 firstPacketTTI; /*!< is first packet of the burst */
- U16 numActRb[LKW_MAX_QCI]; /**< number of RBs Active */
+ uint32_t firstPacketTTI; /*!< is first packet of the burst */
+ uint16_t numActRb[LKW_MAX_QCI]; /**< number of RBs Active */
Bool isUlBurstActive; /*!<Has the Burst started for UL IP Thrpt meas */
#endif /* LTE_L2_MEAS */
};
{
CmHashListEnt transHlEnt; /**< List Entry of
Transaction*/
- U32 transId; /**< Locally generated Transaction Id */
- U32 uprLyrTransId; /**< Transaction Id generated by upper layer.
+ uint32_t transId; /**< Locally generated Transaction Id */
+ uint32_t uprLyrTransId; /**< Transaction Id generated by upper layer.
This is used while sending confirm to the User Layer */
CmLteCellId cellId; /**< Cell Id */
CmLteRnti ueId; /**< Ue Id */
Void rlcDbmDelAllUlRb ARGS ((RlcCb *gCb,
RlcUlRbCb **rbCbLst,
- U8 numRbCb));
+ uint8_t numRbCb));
S16 rlcDbmAddUlTransaction ARGS((RlcCb *gCb, RlcUlCfgTmpData *cfg));
S16 rlcDbmFindUlTransaction ARGS((RlcCb *gCb,
- U32 transId,
+ uint32_t transId,
RlcUlCfgTmpData **cfg));
S16 rlcDbmDelUlTransaction ARGS((RlcCb *gCb, RlcUlCfgTmpData *cfg));
Void rlcUmmProcessPdus ARGS((RlcCb *gCb,
RlcUlRbCb *rbCb,
KwPduInfo *pduInfo,
- U32 ttiCnt));
+ uint32_t ttiCnt));
#else
Void rlcUmmProcessPdus ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
Void rlcAmmProcessPdus ARGS((RlcCb *gCb,
RlcUlRbCb *rbCb,
KwPduInfo *pduInfo,
- U32 ttiCnt));
+ uint32_t ttiCnt));
#else
Void rlcAmmProcessPdus ARGS((RlcCb *gCb,
RlcUlRbCb *rbCb,
Void rlcUtlCalUlIpThrPutIncTTI ARGS ((RlcCb *gCb,
RlcUlRbCb *rbCb,
- U32 ttiCnt));
+ uint32_t ttiCnt));
Void rlcUtlCalUlIpThrPut ARGS((RlcCb *gCb,
RlcUlRbCb *rbCb,
Buffer *pdu,
- U32 ttiCnt));
+ uint32_t ttiCnt));
S16 rlcUtlSndUlL2MeasCfm ARGS ((RlcCb *gCb, RlcL2MeasEvtCb *measEvtCb));
Void rlcUtlResetUlL2MeasInRlcRb ARGS((RlcCb *gCb,
RlcL2MeasCb *measCb,
- U8 measType));
+ uint8_t measType));
S16 rlcUtlValidateIpThL2Meas ARGS ((RlcL2MeasReqEvt *measReqEvt,
RlcL2MeasCfmEvt *measCfmEvt));
/* variables for logging :declared in BRDCM cl */
#ifndef TENB_ACC
-extern U32 dldrops_kwu_um;
-extern U32 dlpkt_um;
-extern U32 buffer_occ;
-extern U32 dlrate_kwu;
+extern uint32_t dldrops_kwu_um;
+extern uint32_t dlpkt_um;
+extern uint32_t buffer_occ;
+extern uint32_t dlrate_kwu;
#endif
PRIVATE void rlcUmmEstHdrSz ARGS ((RlcUmDl *umUl));
PRIVATE Void rlcUmmCreatePdu ARGS ((RlcCb *gCb,
RlcDlRbCb *rbCb,
Buffer *pdu,
- U8 fi,
+ uint8_t fi,
KwPduInfo *datReqPduInfo));
/** @addtogroup ummode */
for SRB 1 */
rlcDlUtlResetReestInProgress(rbCb);
- RETVOID;
+ return;
}
/**
* @brief Handler to create the header and complete a PDU.
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-U32 sduId
+uint32_t sduId
)
#else
Void rlcUmmDiscSdu(gCb,rbCb,sduId)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-U32 sduId;
+uint32_t sduId;
#endif
{
CmLList *tmpNode; /* Temporary Node in SDU queue */
}
}
- RETVOID;
+ return;
}
/*
cmLListCatLList(&(gCb->u.dlCb->toBeFreed.sduLst),&(rbCb->m.umDl.sduQ));
rlcUtlRaiseDlCleanupEvent(gCb);
- RETVOID;
+ return;
} /* rlcUmmFreeDlRbCb */
/********************************************************************30**
#ifndef TENB_ACC
#ifndef LTE_PAL_ENB
-extern U32 isMemThreshReached(Region region);
+extern uint32_t isMemThreshReached(Region region);
#endif
#endif
/**
/* In the UM Mode always send reestablish-indication to Upper Latyer*/
RlcUiKwuReEstCmpInd(&rlcKwSap->pst, rlcKwSap->suId, *rlcId);
- RETVOID;
+ return;
}
/**
if ( e && umHdr->numLi < RLC_MAX_UL_LI)
{
- U8 tmp = ((dst[1]) & 0x08) >> 3;
+ uint8_t tmp = ((dst[1]) & 0x08) >> 3;
umHdr->li[umHdr->numLi] = ( dst[1] & 0x07) << 8;
}
RLC_FREE_WC(gCb,rbCb->m.umUl.recBuf, (windSz ) * sizeof(RlcUmRecBuf*));
rbCb->m.umUl.recBuf = NULLP;
- RETVOID;
+ return;
}
EXTERN SsRngBufCnt rngCb;
#if (defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS))
-extern U32 isDatReqProcessed;
+extern uint32_t isDatReqProcessed;
#endif
#define RLC_MODULE (RLC_DBGMASK_DUT | RLC_DBGMASK_DL) /* for debugging purpose */
#if (defined(MAC_RLC_HARQ_STA_RBUF) && defined(LTE_L2_MEAS)) || defined (SS_RBUF)
else
{
cmHashListInsert(&(rlcCb.rlcL2Cb.tbHlCp),(PTR)tbSnMap,
- (U8 *) &(tbSnMap->tbId), (U16)sizeof(tbSnMap->tbId));
+ (uint8_t *) &(tbSnMap->tbId), (uint16_t)sizeof(tbSnMap->tbId));
rlcCb.rlcL2Cb.curTbSnMap = NULLP;
}
#endif /* LTE_L2_MEAS */
}
}
#endif
- RETVOID;
+ return;
}
/**
rlcUtlSendDedLcBoStatus(gCb, rbCb, 0, 0, FALSE,0);
- RETVOID;
+ return;
}
/**
RlcDlUeCb *ueCb;
#endif
{
- U32 rbIdx;
+ uint32_t rbIdx;
for(rbIdx = 0;rbIdx < RLC_MAX_SRB_PER_UE;rbIdx++)
{
}
}
- RETVOID;
+ return;
}
/**
cmLListInit(&(toBeFreed->reTxLst));
cmLListInit(&(toBeFreed->txLst));
- RETVOID;
+ return;
}
/**
#endif
{
cmLListAdd2Tail(&(gCb->u.dlCb->toBeFreed.reTxLst), &(retx->lstEnt));
- RETVOID;
+ return;
}
/**
{
pdu->rlsLnk.node = (PTR)pdu;
cmLListAdd2Tail(&(gCb->u.dlCb->toBeFreed.txLst), &(pdu->rlsLnk));
- RETVOID;
+ return;
}
/*
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-U32 *toBeFreed
+uint32_t *toBeFreed
)
#else
PRIVATE Bool rlcUtlFreeDlAmRbMemory(gCb, rbCb, toBeFreed)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-U32 *toBeFreed
+uint32_t *toBeFreed
#endif
{
RlcRetx *retx; /* retransmission buffer */
(*toBeFreed)--;
}
- return (FALSE);;
+ return (FALSE);
}
/**
RlcCb *gCb;
#endif
{
- U32 toBeFreed;
+ uint32_t toBeFreed;
/* safety check, in case some event was still lying in the queue after
the dlCb was deleted*/
if(!gCb->u.dlCb)
{
- RETVOID;
+ return;
}
RlcDlDataToBeFreed* pToBeFreed = &gCb->u.dlCb->toBeFreed;
rlcUtlRaiseDlCleanupEvent(gCb);
}
- RETVOID;
+ return;
}
*/
S16 rlcUtlL2MeasDlInit(RlcCb *gCb)
{
- U16 cntr;
+ uint16_t cntr;
gCb->u.dlCb->rlcL2Cb.rlcNumMeas=0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
RlcCb *gCb,
RlcDlRbCb *rbCb,
RlcContSduLst *contSduLst,
-S32 dataVol,
-U32 schPduSz
+S32 dataVol,
+uint32_t schPduSz
)
#else
Void rlcUtlUpdateBurstSdus (gCb, rbCb, contSduLst, dataVol, schPduSz)
RlcCb *gCb;
RlcDlRbCb *rbCb;
RlcContSduLst *contSduLst;
-S32 dataVol;
-U32 schPduSz;
+S32 dataVol;
+uint32_t schPduSz;
#endif
{
- RlcL2MeasDlIpTh *l2MeasDlIpThruput = NULLP;
- RlcL2MeasTb *l2MeasTb = NULLP;
- U8 idx;
- U8 currTbIdx;
- VOLATILE U32 startTime = 0;
+ RlcL2MeasDlIpTh *l2MeasDlIpThruput = NULLP;
+ RlcL2MeasTb *l2MeasTb = NULLP;
+ uint8_t idx;
+ uint8_t currTbIdx;
+ VOLATILE uint32_t startTime = 0;
RlcContSduLst *dstContSduLst;
if(l2MeasTb->numLcId >= RLC_MAX_ACTV_DRB)
{
/* ccpu00143043 */
- RETVOID;
+ return;
}
l2MeasTb->sduInfo[l2MeasTb->numLcId].lcId = rbCb->lch.lChId;
/* Copy all the sduIdx from sduInfo to tb sduInfo */
/*stopping Task*/
SStopTask(startTime, PID_RLC_DLIP_TPT_BURSTCALC);
- RETVOID;
+ return;
}
/**
* @brief
#ifdef ANSI
Void rlcUtlUpdateContainedSduLst
(
-U8 sduIdx,
+uint8_t sduIdx,
RlcContSduLst *contSduLst
)
#else
Void rlcUtlUpdateContainedSduLst(sduIdx, contSduLst)
-U8 sduIdx;
+uint8_t sduIdx;
RlcContSduLst *contSduLst;
#endif
{
contSduLst->sduIdx[contSduLst->numSdus] = sduIdx;
contSduLst->numSdus++;
}
- RETVOID;
+ return;
}
/**
Void rlcUtlUpdateOutStandingSduLst
(
RlcL2MeasDlIpTh *dlIpThPut,
-U8 sduIdx,
+uint8_t sduIdx,
MsgLen sduLen,
-U32 sduId,
+uint32_t sduId,
Bool newIdx
)
#else
Void rlcUtlUpdateOutStandingSduLst(dlIpThPut, sduIdx, sduLen, sduId, newIdx)
RlcL2MeasDlIpTh *dlIpThPut;
-U8 sduIdx;
+uint8_t sduIdx;
MsgLen sduLen;
-U32 sduId;
+uint32_t sduId;
Bool newIdx;
#endif
{
dlIpThPut->outStngSduArr[sduIdx].sduId = sduId;
dlIpThPut->outStngSduArr[sduIdx].sduLen = sduLen;
}
- RETVOID;
+ return;
}
#ifdef ANSI
RlcL2MeasTb * rlcUtlGetCurMeasTb
#endif
{
RlcL2MeasTb *curL2MeasTb;
- U16 idx;
+ uint16_t idx;
if((curL2MeasTb = rbCb->ueCb->l2MeasTbCb[rbCb->ueCb->tbIdx]) == NULLP)
{
#ifdef ANSI
S16 rlcUtlProcHarqInd
(
-RlcCb *gCb,
+RlcCb *gCb,
RguHarqStatusInd *hqStaInd,
-RlcDlUeCb *ueCb,
-U8 tbIdx
+RlcDlUeCb *ueCb,
+uint8_t tbIdx
)
#else
S16 rlcUtlProcHarqInd(gCb, hqStaInd, ueCb, tbIdx)
RlcCb *gCb;
-RguHarqStatusInd *hqStaInd;
-RlcDlUeCb *ueCb;
-U8 tbIdx;
+RguHarqStatusInd *hqStaInd;
+RlcDlUeCb *ueCb;
+uint8_t tbIdx;
#endif
{
#ifdef LTE_L2_MEAS
- RlcDlRbCb *rlcRbCb; /* KW Control Block */
- RlcL2MeasTb *l2MeasTb = NULLP; /* Measurement TbCb */
- U8 lcIdx; /* Logical channel id index */
- U8 sduIndx; /* sdu index to out standing sdu list in rbCb */
- U32 numSdus; /* number of sdus in the outstanding sdu list */
+ RlcDlRbCb *rlcRbCb; /* KW Control Block */
+ RlcL2MeasTb *l2MeasTb = NULLP; /* Measurement TbCb */
+ uint8_t lcIdx; /* Logical channel id index */
+ uint8_t sduIndx; /* sdu index to out standing sdu list in rbCb */
+ uint32_t numSdus; /* number of sdus in the outstanding sdu list */
RlcOutStngSduInfo *outStngSduArr; /* Outstanding sdu list */
- Ticks ackTime;
- Ticks delay;
- U32 totlSduCnt = 0;
+ Ticks ackTime;
+ Ticks delay;
+ uint32_t totlSduCnt = 0;
#endif
- U8 timeAddedFlag;
- S16 ret;
- VOLATILE U32 startTime = 0;
+ uint8_t timeAddedFlag;
+ S16 ret;
+ VOLATILE uint32_t startTime = 0;
/*kw005.201 Code added for DL IP thruput measurement*/
/*starting Task*/
RlcL2MeasEvtCb *measEvtCb;
#endif
{
- U32 qciIdx;
- RlcL2MeasCb *measCb = NULLP;
- RlcL2MeasCfmEvt measCfmEvt;
- U32 posPkts;
- U32 dLoss;
-
- U64 dlDataVol;
- U64 dlTime;
- U16 cntr;
+ uint32_t qciIdx;
+ RlcL2MeasCb *measCb = NULLP;
+ RlcL2MeasCfmEvt measCfmEvt;
+ uint32_t posPkts;
+ uint32_t dLoss;
+ uint64_t dlDataVol;
+ uint64_t dlTime;
+ uint16_t cntr;
/* Discard new changes starts */
- U8 qci = 0;
- U32 cfmIdx =0;
+ uint8_t qci = 0;
+ uint32_t cfmIdx =0;
/* Discard new changes ends */
/* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
(
RlcCb *gCb,
RlcL2MeasCb *measCb,
-U8 measType
+uint8_t measType
)
#else
Void rlcUtlResetDlL2MeasInRlcRb(gCb, measCb, measType)
RlcCb *gCb;
RlcL2MeasCb *measCb;
-U8 measType;
+uint8_t measType;
#endif
{
- U32 ueIdx;
- U32 qciIdx;
+ uint32_t ueIdx;
+ uint32_t qciIdx;
RlcDlUeCb *ueCb = NULL;
/* for now the only meas should be DL discard in this case */
if (measCb->measType & LKW_L2MEAS_DL_DISC)
{
- U32 i;
+ uint32_t i;
for(i = 0; i < measCb->val.nonIpThMeas.numQci; i++)
{
- U8 qciVal = measCb->val.nonIpThMeas.qci[i];
+ uint8_t qciVal = measCb->val.nonIpThMeas.qci[i];
measCb->val.nonIpThMeas.measData[qciVal].dlDisc.discSdus = 0;
measCb->val.nonIpThMeas.measData[qciVal].dlDisc.totSdus = 0;
}
if (measCb->measType & LKW_L2MEAS_DL_DELAY)
{
- U32 i;
+ uint32_t i;
for(i = 0; i < measCb->val.nonIpThMeas.numQci; i++)
{
- U8 qciVal = measCb->val.nonIpThMeas.qci[i];
+ uint8_t qciVal = measCb->val.nonIpThMeas.qci[i];
measCb->val.nonIpThMeas.measData[qciVal].dlPjSduDelay.sduDelay = 0;
}
}
else if(dlRbCb->mode == CM_LTE_MODE_AM)
{
- U32 j, numTxPdus=0;
+ uint32_t j, numTxPdus=0;
for(j = 0; j <= (RLC_AM_GET_WIN_SZ(dlRbCb->m.amDl.snLen)); j++)
{
RlcTx *txBuf = rlcUtlGetTxBuf(dlRbCb->m.amDl.txBufLst, j);
(PTR) ueCb,
(PTR *)&ueCb))
{
- U32 i;
+ uint32_t i;
for(i = 0; i< RLC_MAX_SRB_PER_UE; i++)
{
RlcDlRbCb* dlRbCb = ueCb->srbCb[i];
* @b Description
* This function returns current time
*
- * @param[in] U32
+ * @param[in] uint32_t
*
*
* @return Void
(
RlcCb *gCb,
RlcDlRbCb *rbCb,
-U32 pktAdmitCnt
+uint32_t pktAdmitCnt
)
#else
Void rlcUtlTrigPdbFlowCntrl(gCb,rbCb,pktAdmitCnt)
RlcCb *gCb;
RlcDlRbCb *rbCb;
-U32 pktAdmitCnt;
+uint32_t pktAdmitCnt;
#endif
{
KwuFlowCntrlIndInfo *flowCntrlInfo;
RlcCb *gCb;
#endif
{
- U32 hashKey;
+ uint32_t hashKey;
CmLListCp *txBufLstCp;
hashKey = (txBuf->sn % RLC_TX_BUF_BIN_SIZE );
//printf("D-sn(%d)\n", txBuf->hdr.sn);
cmLListDelFrm(txBufLstCp, &txBuf->lnk);
RLC_FREE_WC(gCb, txBuf, sizeof(RlcTx));
- RETVOID;
+ return;
} /* rlcUtlDelTxBuf */
/**
RlcCb *gCb;
#endif
{
- U32 hashKey;
+ uint32_t hashKey;
CmLListCp *txBufLstCp;
hashKey = (txBuf->sn % RLC_TX_BUF_BIN_SIZE );
txBufLstCp = &txBufLst[hashKey];
//printf("D-sn(%d)\n", txBuf->hdr.sn);
cmLListDelFrm(txBufLstCp, &txBuf->lnk);
- RETVOID;
+ return;
} /* rlcUtlRemovTxBuf */
{
if(ulRbCb->mode == CM_LTE_MODE_UM)
{
- U32 i;
- U32 pdusInReceptionBuffer = 0;
- U32 windSz = ulRbCb->m.umUl.umWinSz << 1;
+ uint32_t i;
+ uint32_t pdusInReceptionBuffer = 0;
+ uint32_t windSz = ulRbCb->m.umUl.umWinSz << 1;
for(i = 0; i< windSz; i++)
{
}
else if(ulRbCb->mode == CM_LTE_MODE_AM)
{
- U32 i;
- U32 pdusInReceptionBuffer = 0;
- U32 totalSegs = 0;
- U32 windSz = RLC_AM_GET_WIN_SZ(ulRbCb->m.amUl.snLen) << 1;
+ uint32_t i;
+ uint32_t pdusInReceptionBuffer = 0;
+ uint32_t totalSegs = 0;
+ uint32_t windSz = RLC_AM_GET_WIN_SZ(ulRbCb->m.amUl.snLen) << 1;
for(i = 0; i< windSz; i++)
{
(PTR) ueCb,
(PTR *)&ueCb))
{
- U32 i;
+ uint32_t i;
for(i = 0; i< RLC_MAX_SRB_PER_UE; i++)
{
RlcUlRbCb* ulRbCb = ueCb->srbCb[i];
*/
S16 rlcUtlL2MeasUlInit(RlcCb *gCb)
{
- U16 cntr;
+ uint16_t cntr;
gCb->u.ulCb->rlcL2Cb.rlcNumMeas=0;
for(cntr = 0; cntr < LKW_MAX_L2MEAS; cntr++)
(
RlcCb *gCb,
RlcUlRbCb *rbCb,
-U32 ttiCnt
+uint32_t ttiCnt
)
#else
Void rlcUtlCalUlIpThrPutIncTTI(gCb, rbCb, ttiCnt)
RlcCb *gCb;
RlcUlRbCb *rbCb;
-U32 ttiCnt;
+uint32_t ttiCnt;
#endif
{
- VOLATILE U32 startTime = 0;
+ VOLATILE uint32_t startTime = 0;
/*starting Task*/
SStartTask(&startTime, PID_RLC_IP_TPT_INCTTI);
#ifdef ANSI
Void rlcUtlCalUlIpThrPut
(
-RlcCb *gCb,
-RlcUlRbCb *rbCb,
-Buffer *pdu,
-U32 ttiCnt
+RlcCb *gCb,
+RlcUlRbCb *rbCb,
+Buffer *pdu,
+uint32_t ttiCnt
)
#else
Void rlcUtlCalUlIpThrPut(gCb, rbCb, pdu, ttiCnt)
- RlcCb *gCb;
- RlcUlRbCb *rbCb;
- Buffer *pdu;
- U32 ttiCnt;
+RlcCb *gCb;
+RlcUlRbCb *rbCb;
+Buffer *pdu;
+uint32_t ttiCnt;
#endif
{
MsgLen rlcSduSz = 0; /*Holds length of Rlc Sdu*/
- VOLATILE U32 startTime = 0;
+ VOLATILE uint32_t startTime = 0;
/*starting Task*/
SStartTask(&startTime, PID_RLC_IP_TPT_INCVOL);
{
#ifdef LTE_L2_MEAS_RLC
- U16 qciIdx;
+ uint16_t qciIdx;
RlcL2MeasCb *measCb;
/* Clean up the RB data structures */
RlcL2MeasEvtCb *measEvtCb;
#endif
{
- U32 qciIdx;
- RlcL2MeasCb *measCb;
- RlcL2MeasCfmEvt measCfmEvt;
-
- U64 ulDataVol;
- U64 ulTime;
- U16 cntr;
+ uint32_t qciIdx;
+ RlcL2MeasCb *measCb;
+ RlcL2MeasCfmEvt measCfmEvt;
+ uint64_t ulDataVol;
+ uint64_t ulTime;
+ uint16_t cntr;
/* Discard new changes starts */
- U8 qci = 0;
- U32 cfmIdx =0;
+ uint8_t qci = 0;
+ uint32_t cfmIdx =0;
/* Discard new changes ends */
/* kw006.201 ccpu00120058 emoved 64 bit compilation warning */
RlcL2MeasReqEvt *measReqEvt,
RlcL2MeasCfmEvt *measCfmEvt,
CmLteLcId *lChId,
-U8 *numLCh
+uint8_t *numLCh
)
#else
S16 rlcUtlValidateL2Meas(measReqEvt, measCfmEvt, lChId, numLCh)
RlcL2MeasReqEvt *measReqEvt;
RlcL2MeasCfmEvt *measCfmEvt;
CmLteLcId *lChId;
-U8 *numLCh;
+uint8_t *numLCh;
#endif
{
- U8 measType;
- S16 ret;
- U8 qciIdx;
- U8 qci;
- U8 idx;
- U8 *qciVal;
- U8 numQci;
+ uint8_t measType;
+ S16 ret;
+ uint8_t qciIdx;
+ uint8_t qci;
+ uint8_t idx;
+ uint8_t *qciVal;
+ uint8_t numQci;
RlcUlRbCb *rbCb;
-
- RlcUlUeCb *ueCb;
+ RlcUlUeCb *ueCb;
RbCb **rbCbLst;
- U8 rbIdx;
- U8 lsbNibble = 0;
- U8 msbNibble = 0;
- U8 numFaild = 0;
+ uint8_t rbIdx;
+ uint8_t lsbNibble = 0;
+ uint8_t msbNibble = 0;
+ uint8_t numFaild = 0;
idx = 0;
rbCb = NULLP;
{
qci = qciVal[qciIdx];
ret = cmHashListFind(&(rlcCb.rlcL2Cb.qciHlCp),
- (U8 *)&qci, (U16)sizeof(qci), 0, (PTR *)&rbCb);
+ (uint8_t *)&qci, (uint16_t)sizeof(qci), 0, (PTR *)&rbCb);
if(ret != ROK)
{
measCfmEvt->val.nonIpThMeas.measCfm[measCfmEvt->val.nonIpThMeas.numCfm].qci = qci;
RlcL2MeasCfmEvt *measCfmEvt;
#endif
{
- U8 measType;
- U8 lsbNibble = 0;
- U8 msbNibble = 0;
+ uint8_t measType;
+ uint8_t lsbNibble = 0;
+ uint8_t msbNibble = 0;
measType = measReqEvt->measReq.measType;
/* Check for the range of measType */
(
RlcCb *gCb,
RlcL2MeasCb *measCb,
-U8 measType
+uint8_t measType
)
#else
Void rlcUtlResetUlL2MeasInRlcRb(measCb, measType)
RlcCb *gCb;
RlcL2MeasCb *measCb;
-U8 measType;
+uint8_t measType;
#endif
{
- U32 rbIdx;
- U32 ueIdx;
- U32 qciIdx;
+ uint32_t rbIdx;
+ uint32_t ueIdx;
+ uint32_t qciIdx;
RlcUlUeCb *ueCb = NULL;
(
RlcL2Cntr *measData,
RlcL2MeasRbCb *rbL2Cb,
-U8 measType
+uint8_t measType
)
#else
Void rlcUtlPlcMeasDatInL2Sts(measData, rbL2Cb, measType)
RlcL2Cntr *measData;
RlcL2MeasRbCb *rbL2Cb;
-U8 measType;
+uint8_t measType;
#endif
{
/* We should check the number of measType in the request. This can be done
{
uint32_t hashKey;
CmLListCp *recBufLstCp;
- RlcAmRecBuf *recBuf;
+ RlcAmRecBuf *recBuf;
CmLList *node = NULLP;
hashKey = (sn % RLC_RCV_BUF_BIN_SIZE );
*/
void rlcUtlDelRecBuf(CmLListCp *recBufLst, RlcAmRecBuf *recBuf, RlcCb *gCb)
{
- uint32_t hashKey;
+ uint32_t hashKey;
CmLListCp *recBufLstCp;
hashKey = (recBuf->amHdr.sn % RLC_RCV_BUF_BIN_SIZE );
/* filling IPv4 header */
CmIpv4Hdr ipv4Hdr;
MsgLen mLen;
- U32 ipv4_du, ipv4_cu;
+ uint32_t ipv4_du, ipv4_cu;
cmInetAddr((S8*)DU_IP_V4_ADDR, &ipv4_du);
cmInetAddr((S8*)CU_IP_V4_ADDR, &ipv4_cu);
ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
ipv4Hdr.hdrVer = 0x45;
ipv4Hdr.proto = 1;
- ipv4Hdr.srcAddr = CM_INET_NTOH_U32(ipv4_du);
- ipv4Hdr.destAddr = CM_INET_NTOH_U32(ipv4_cu);
+ ipv4Hdr.srcAddr = CM_INET_NTOH_UINT32(ipv4_du);
+ ipv4Hdr.destAddr = CM_INET_NTOH_UINT32(ipv4_cu);
/* Packing IPv4 header into buffer */
S16 ret, cnt, idx;
#if (ERRCLASS & ERRCLS_ADD_RES)
CmLList *lnk;
#endif
- U32 idx;
+ uint32_t idx;
RgSchL2MeasCb *measCb = NULLP;
#ifdef DEBUGP
Inst inst = (pst->dstInst - SCH_INST_START); /* Scheduler instance Id */
CmLList *node = NULLP;
RgSchL2MeasCb *measCb = NULLP;
LrgSchMeasCfmInfo measCfm;
- U8 idx;
+ uint8_t idx;
for (idx = 0; idx < instCb->numSaps; idx++)
{
S16 ret = ROK;
RgSchCellCb *cell;
RgSchCb *instCb = &rgSchCb[(pst->dstInst - SCH_INST_START)];
- U8 idx;
+ uint8_t idx;
cell = NULLP;
for (idx = 0; idx < instCb->numSaps; idx++)
#endif
{
S16 ret = ROK;
- U8 cfmStatus = RGR_CFG_CFM_NOK;
- U8 prntTrans[RGR_CFG_TRANSID_SIZE+1];
+ uint8_t cfmStatus = RGR_CFG_CFM_NOK;
+ uint8_t prntTrans[RGR_CFG_TRANSID_SIZE+1];
Inst instId = pst->dstInst-SCH_INST_START;
memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
{
Inst instId = pst->dstInst-SCH_INST_START;
S16 ret = ROK;
- U8 cfmStatus = RGR_CFG_CFM_NOK;
- U8 prntTrans[RGR_CFG_TRANSID_SIZE+1];
+ uint8_t cfmStatus = RGR_CFG_CFM_NOK;
+ uint8_t prntTrans[RGR_CFG_TRANSID_SIZE+1];
memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
prntTrans[RGR_CFG_TRANSID_SIZE] = '\0';
Pst *pst,
SpId spId,
RgrCfgTransId transId,
-U8 siId
+uint8_t siId
)
#else
S16 RgUiRgrWarningSiStopReq(pst,spId, transId, siId)
Pst *pst;
SpId spId;
RgrCfgTransId transId;
-U8 siId;
+uint8_t siId;
#endif
{
Inst instId = pst->dstInst-SCH_INST_START;
#endif
{
S16 ret = ROK;
- U8 prntTrans[RGR_CFG_TRANSID_SIZE+1];
+ uint8_t prntTrans[RGR_CFG_TRANSID_SIZE+1];
Inst instId = pst->dstInst-SCH_INST_START;
memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
RgSchCmnUlUeSpsInfo *ulSpsUe ;
#endif
/* RRM_RBC_X */
- U32 idx;
+ uint32_t idx;
/* RRM_RBC_Y */
#ifdef LTE_L2_MEAS
- U8 qci;
- U16 datIndActQci = 0;
- U16 combDatIndActQci = 0; /* Prev and Latest Dat Ind combined */
- U16 tempUeActQci = 0; /* UE specific Active QCIs */
- U16 diffBits = 0;
- U8 lcCount;
+ uint8_t qci;
+ uint16_t datIndActQci = 0;
+ uint16_t combDatIndActQci = 0; /* Prev and Latest Dat Ind combined */
+ uint16_t tempUeActQci = 0; /* UE specific Active QCIs */
+ uint16_t diffBits = 0;
+ uint8_t lcCount;
#endif
/* No need to chk for cell being NULL as MAC wouldn't have found instance if
CmLList *lnk;
RgSchL2MeasCb *measCb = NULLP;
RgSchCb *instCb = &rgSchCb[inst];
- U32 idx;
+ uint32_t idx;
LrgSchMeasCfmInfo schMeasCfm;
- U8 qciVal;
- U8 idx1; /*LTE_L2_MEAS_PHASE2*/
- U8 qciVal1;
+ uint8_t qciVal;
+ uint8_t idx1; /*LTE_L2_MEAS_PHASE2*/
+ uint8_t qciVal1;
/* Find the cellCb using cellId in measInfo. Iterate through all cells
* in rgrsapCb in RgschCb */
*
* @param[in] Pst *pst
* @param[in] SuId suId
- * @param[in] U8 status
+ * @param[in] uint8_t status
* @return S16
* -# ROK
* -# RFAILED
(
Pst *pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 RgLiTfuSchBndCfm(pst, suId, status)
Pst *pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
S16 ret;
(
Pst *pst,
SuId suId,
-TfuErrIndInfo *errInd
+TfuErrIndInfo *errInd
)
#else
S16 RgLiTfuErrInd(pst, suId, errInd)
Pst *pst;
SuId suId;
-TfuErrIndInfo *errInd;
+TfuErrIndInfo *errInd;
#endif
{
S16 ret = ROK;
/*CA_DEV_DS_FIX*/
#define RGSCH_INVALID_CELL_IDX 255
#define RGSCH_PCELL_INDEX 0
-#define RG_SCH_CELLINDEX(_cell) (U8)((_cell->cellId >= rgSchCb[_cell->instIdx].genCfg.startCellId) ?\
+#define RG_SCH_CELLINDEX(_cell) (uint8_t)((_cell->cellId >= rgSchCb[_cell->instIdx].genCfg.startCellId) ?\
(_cell->cellId - rgSchCb[_cell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1): 0)
#define RG_SCH_GET_SCELL_INDEX(_ueCb, _cell) _ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(_cell)]
/* RACHO */
#define RGSCH_DROP_RGUDDATREQ_MBUF(_datReq)\
{\
- U32 idx1,idx2,idx;\
+ uint32_t idx1,idx2,idx;\
if (_datReq != NULLP)\
{\
for (idx=0; idx < _datReq->numLch; idx++)\
**********************************************************/
#define RGSCH_DROP_RGUCDATREQ_MBUF(_datReq)\
{\
- U32 idx1;\
+ uint32_t idx1;\
if (_datReq != NULLP)\
{\
for (idx1 = 0; idx1 < RGU_MAX_PDUSET; idx1++)\
#define RGSCH_MAX(x, y) ((x) >= (y) ? (x) : (y))
#define RGSCH_CEIL(x, y) (((x) + (y)-1) / (y))
#define RGSCH_FLOOR(x, y) ((x) / (y))
-#define RGSCH_CEILING(x) (((x) - (U8)(x)) ? (U8)(x+1) : (U8)x)
+#define RGSCH_CEILING(x) (((x) - (uint8_t)(x)) ? (uint8_t)(x+1) : (uint8_t)x)
#define RGSCH_DIV_ROUND(x, y) (((x) + (y)/2) / (y))
#define RGSCH_RARSP_WAIT_PERIOD 3
#define RG_SCH_PARSE_MULTI_PMI(_bitLen, _totPmiBitLen, _psMode12,\
_acqiCb, _revArray,_sbOffst )\
{\
- U8 _loop =0;\
+ uint8_t _loop =0;\
for(_loop =0; _loop<(_totPmiBitLen/_bitLen); _loop++)\
{\
- (_psMode12)->subbandArr[_loop].pmi = (U8)rgSCHUtlParse(_revArray,\
- _sbOffst,(U8)(_sbOffst+_bitLen), (U8)TFU_MAX_CQI_BYTES);\
+ (_psMode12)->subbandArr[_loop].pmi = (uint8_t)rgSCHUtlParse(_revArray,\
+ _sbOffst,(uint8_t)(_sbOffst+_bitLen), (uint8_t)TFU_MAX_CQI_BYTES);\
_sbOffst+=_bitLen;\
(_psMode12)->subbandArr[_loop].subBand.numRb = (_acqiCb).k;\
(_psMode12)->subbandArr[_loop].subBand.rbStart = \
- (U8) ((_acqiCb).k * (_loop));\
+ (uint8_t) ((_acqiCb).k * (_loop));\
}\
}
#define RG_SCH_HQP_TIME_ON_PCELL 32 /*!< Time in milliseconds to be allowed
for transmission of TB on PCell*/
/* SR_RACH_STATS */
-EXTERN U32 rgNumPrachRecvd; /* Num of Rach Req received including dedicated preambles */
-EXTERN U32 rgNumRarSched; /* Num of RARs sent */
-EXTERN U32 rgNumBI; /* Num of BackOff Ind sent */
-EXTERN U32 rgNumMsg3CrcPassed; /* Num of CRC success for Msg3 */
-EXTERN U32 rgNumMsg3CrcFailed ; /* Num of CRC fail for Msg 3 */
-EXTERN U32 rgNumMsg3FailMaxRetx ; /* Num of Msg3 fail after Max Retx attempts */
-EXTERN U32 rgNumMsg4Ack ; /* Num of Acks for Msg4 Tx */
-EXTERN U32 rgNumMsg4Nack ;
+EXTERN uint32_t rgNumPrachRecvd; /* Num of Rach Req received including dedicated preambles */
+EXTERN uint32_t rgNumRarSched; /* Num of RARs sent */
+EXTERN uint32_t rgNumBI; /* Num of BackOff Ind sent */
+EXTERN uint32_t rgNumMsg3CrcPassed; /* Num of CRC success for Msg3 */
+EXTERN uint32_t rgNumMsg3CrcFailed ; /* Num of CRC fail for Msg 3 */
+EXTERN uint32_t rgNumMsg3FailMaxRetx ; /* Num of Msg3 fail after Max Retx attempts */
+EXTERN uint32_t rgNumMsg4Ack ; /* Num of Acks for Msg4 Tx */
+EXTERN uint32_t rgNumMsg4Nack ;
/* Num of Nacks for Msg4 Tx */
-EXTERN U32 rgNumMsg4FailMaxRetx ; /* Num of Msg4 Tx failed after Max Retx attempts */
-EXTERN U32 rgNumSrRecvd; /* Num of Sched Req received */
-EXTERN U32 rgNumSrGrant; /* Num of Sched Req Grants sent */
-EXTERN U32 rgNumMsg3CrntiCE; /* Num of Msg 3 CRNTI CE received */
-EXTERN U32 rgNumDedPream ; /* Num of Dedicated Preambles recvd */
-EXTERN U32 rgNumMsg3CCCHSdu; /* Num of Msg 3 CCCH Sdus recvd */
-EXTERN U32 rgNumCCCHSduCrntiNotFound ; /*UE Ctx not found for CCCH SDU Msg 3 */
-EXTERN U32 rgNumCrntiCeCrntiNotFound ; /*UE Ctx not found for CRNTI CE Msg 3 */
-EXTERN U32 rgNumMsg4WithCCCHSdu ; /* Num of Msg4 with CCCH Sdu */
-EXTERN U32 rgNumMsg4WoCCCHSdu ; /* Num of Msg4 without CCCH Sdu */
-EXTERN U32 rgNumMsg4Dtx ; /* Num of DTX received for Msg 4 */
-EXTERN U32 rgNumMsg3AckSent ; /* Num of PHICH Ack sent for Msg 3 */
-EXTERN U32 rgNumMsg3NackSent ; /* Num of PHICH Nack sent for Msg 3 */
-EXTERN U32 rgNumMsg4PdcchWithCrnti ; /* Num of PDCCH for CRNTI based contention resolution */
-EXTERN U32 rgNumRarFailDuetoRntiExhaustion ; /* Num of RACH Failures due to RNTI pool exhaution */
-EXTERN U32 rgNumTAModified ; /* Num of times TA received is different from prev value */
-EXTERN U32 rgNumTASent ; /* Num of TA Command sent */
-EXTERN U32 rgNumMsg4ToBeTx ; /* Num of times MSG4 that should be sent */
-EXTERN U32 rgNumMsg4Txed ; /* Num of MSG4 actually sent *//* ysNumMsg4ToBeTx -ysNumMsg4Txed == Failed MSG4 TX */
-EXTERN U32 rgNumMsg3DtxRcvd; /* CRC Fail with SINR < 0 */
-
-EXTERN U32 rgNumDedPreamUECtxtFound;
+EXTERN uint32_t rgNumMsg4FailMaxRetx ; /* Num of Msg4 Tx failed after Max Retx attempts */
+EXTERN uint32_t rgNumSrRecvd; /* Num of Sched Req received */
+EXTERN uint32_t rgNumSrGrant; /* Num of Sched Req Grants sent */
+EXTERN uint32_t rgNumMsg3CrntiCE; /* Num of Msg 3 CRNTI CE received */
+EXTERN uint32_t rgNumDedPream ; /* Num of Dedicated Preambles recvd */
+EXTERN uint32_t rgNumMsg3CCCHSdu; /* Num of Msg 3 CCCH Sdus recvd */
+EXTERN uint32_t rgNumCCCHSduCrntiNotFound ; /*UE Ctx not found for CCCH SDU Msg 3 */
+EXTERN uint32_t rgNumCrntiCeCrntiNotFound ; /*UE Ctx not found for CRNTI CE Msg 3 */
+EXTERN uint32_t rgNumMsg4WithCCCHSdu ; /* Num of Msg4 with CCCH Sdu */
+EXTERN uint32_t rgNumMsg4WoCCCHSdu ; /* Num of Msg4 without CCCH Sdu */
+EXTERN uint32_t rgNumMsg4Dtx ; /* Num of DTX received for Msg 4 */
+EXTERN uint32_t rgNumMsg3AckSent ; /* Num of PHICH Ack sent for Msg 3 */
+EXTERN uint32_t rgNumMsg3NackSent ; /* Num of PHICH Nack sent for Msg 3 */
+EXTERN uint32_t rgNumMsg4PdcchWithCrnti ; /* Num of PDCCH for CRNTI based contention resolution */
+EXTERN uint32_t rgNumRarFailDuetoRntiExhaustion ; /* Num of RACH Failures due to RNTI pool exhaution */
+EXTERN uint32_t rgNumTAModified ; /* Num of times TA received is different from prev value */
+EXTERN uint32_t rgNumTASent ; /* Num of TA Command sent */
+EXTERN uint32_t rgNumMsg4ToBeTx ; /* Num of times MSG4 that should be sent */
+EXTERN uint32_t rgNumMsg4Txed ; /* Num of MSG4 actually sent *//* ysNumMsg4ToBeTx -ysNumMsg4Txed == Failed MSG4 TX */
+EXTERN uint32_t rgNumMsg3DtxRcvd; /* CRC Fail with SINR < 0 */
+
+EXTERN uint32_t rgNumDedPreamUECtxtFound;
#endif /* __RGSCH__ */
\f
/**********************************************************************
typedef struct rgSchHistNode
{
- U32 line;
+ uint32_t line;
S8* file;
const S8* func;
Void * dbgVal; /* This is specific to the data struct being debug
for example if the debugging is done fo list
then this should contain the node address */
- U32 action;
+ uint32_t action;
}RgSchHistNode;
#define MAX_HIST_NODES 50
typedef struct rgSchHistInfo
{
- U32 histCount;
+ uint32_t histCount;
RgSchHistNode hist[MAX_HIST_NODES];
}RgSchHistInfo;
typedef struct _rgSchdApis RgSchdApis;
#ifdef LTE_TDD
typedef struct rgSchTddPhichOffInfo RgSchTddPhichOffInfo;
-typedef U8 RgSchTddNpValTbl[RGSCH_TDD_MAX_P_PLUS_ONE_VAL];
+typedef uint8_t RgSchTddNpValTbl[RGSCH_TDD_MAX_P_PLUS_ONE_VAL];
#endif
/* Added support for SPS*/
#ifdef LTEMAC_SPS
Void (*rgSCHFreeDlLc) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, RgSchDlLcCb *dlLc));
Void (*rgSCHFreeLcg) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, RgSchLcgCb *lcg));
S16 (*rgSCHRgrLchDel) ARGS((RgSchCellCb *cell, RgSchUeCb *ue,CmLteLcId lcId, \
- U8 lcgId));
+ uint8_t lcgId));
Void (*rgSCHActvtUlUe) ARGS((RgSchCellCb *cell, RgSchUeCb *ue));
Void (*rgSCHActvtDlUe) ARGS((RgSchCellCb *cell, RgSchUeCb *ue));
Void (*rgSCHHdlUlTransInd) ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
CmLteTimingInfo timingInfo));
Void (*rgSCHUeReset) ARGS((RgSchCellCb *cell, RgSchUeCb *ue));
- S16 (*rgSCHUpdBsrShort) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, RgSchLcgCb *ulLcg, U8 bsr, RgSchErrInfo *err));
- S16 (*rgSCHUpdBsrTrunc) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, RgSchLcgCb *ulLcg, U8 bsr, RgSchErrInfo *err));
- S16 (*rgSCHUpdBsrLong) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, U8 bsArr[], RgSchErrInfo *err));
- S16 (*rgSCHUpdPhr) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, U8 phr, RgSchErrInfo *err));
+ S16 (*rgSCHUpdBsrShort) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, RgSchLcgCb *ulLcg, uint8_t bsr, RgSchErrInfo *err));
+ S16 (*rgSCHUpdBsrTrunc) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, RgSchLcgCb *ulLcg, uint8_t bsr, RgSchErrInfo *err));
+ S16 (*rgSCHUpdBsrLong) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, uint8_t bsArr[], RgSchErrInfo *err));
+ S16 (*rgSCHUpdPhr) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, uint8_t phr, RgSchErrInfo *err));
S16 (*rgSCHUpdExtPhr) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, RgInfExtPhrCEInfo * extPhr, RgSchErrInfo *err));
#ifdef RG_UNUSED
S16 (*rgSCHUpdUlHqProc) ARGS((RgSchCellCb *cell, RgSchUlHqProcCb *curProc,
RgSchUlAlloc *(*rgSCHFirstRcptnReq) ARGS((RgSchCellCb *cell));
RgSchUlAlloc *(*rgSCHNextRcptnReq) ARGS((RgSchCellCb *cell,
RgSchUlAlloc *alloc));
- RgSchUlAlloc *(*rgSCHFirstHqFdbkAlloc) ARGS((RgSchCellCb *cell, U8 idx));
+ RgSchUlAlloc *(*rgSCHFirstHqFdbkAlloc) ARGS((RgSchCellCb *cell, uint8_t idx));
RgSchUlAlloc *(*rgSCHNextHqFdbkAlloc) ARGS((RgSchCellCb *cell,
- RgSchUlAlloc *alloc,U8 idx));
+ RgSchUlAlloc *alloc,uint8_t idx));
Void (*rgSCHDlProcAddToRetx) ARGS((RgSchCellCb *cell,RgSchDlHqProcCb *hqP));
Void (*rgSCHDlCqiInd) ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
Bool isPucchInfo, Void *dlCqi, CmLteTimingInfo timingInfo));
Void (*rgSCHDlProcAck) ARGS((RgSchCellCb *cell, RgSchDlHqProcCb *hqP));
Void (*rgSCHDlProcDtx) ARGS((RgSchCellCb *cell, RgSchDlHqProcCb *hqP));
Void (*rgSCHDlRelPdcchFbk) ARGS((RgSchCellCb *cell, RgSchUeCb * ue,
- U8 isAck));
+ uint8_t isAck));
Void (*rgSCHUlSpsRelInd) ARGS((RgSchCellCb *cell, RgSchUeCb * ue,
Bool isExplRel));
Void (*rgSCHUlSpsActInd) ARGS((RgSchCellCb *cell, RgSchUeCb * ue,
- U16 sduSuze));
+ uint16_t sduSuze));
Void (*rgSCHUlCrcFailInd) ARGS((RgSchCellCb *cell, RgSchUeCb * ue,
CmLteTimingInfo crcTime));
*/
typedef struct rgSchIotRes
{
- U32 resType;
+ uint32_t resType;
PTR allctdBy;
CmLteTimingInfo timeStart;
CmLteTimingInfo timeEnd;
- U32 tSize;
- U8 freqStart;
- U8 freqEnd;
- U32 fSize;
+ uint32_t tSize;
+ uint8_t freqStart;
+ uint8_t freqEnd;
+ uint32_t fSize;
CmLList lnk; /*!< Link to other Fragments or Allocs in resMngmt */
CmLList cbLnk; /*!< Link to other allocs in a given control block (ueCb) */
CmLList resLnk;/*!<Link to resList in UE*/
*/
typedef struct rgSchIotResCb
{
- U32 poolSz;
+ uint32_t poolSz;
RgSchIotRes *resources;
CmLListCp resPool;
- U8 maxFreqSz; /*!< Max Number of RBs/SCs/CCEs per Subframe */
- U32 deltaTime; /*!< PDCCH/PUSCH/PDSCH Delta w.r.t current time */
+ uint8_t maxFreqSz; /*!< Max Number of RBs/SCs/CCEs per Subframe */
+ uint32_t deltaTime; /*!< PDCCH/PUSCH/PDSCH Delta w.r.t current time */
RgSchIotRes *contRes; /*!< Represents continuous availability of resource
in frequency and time domain */
CmLListCp fragList; /*!< Represents list of fragmented resourcesi b4
S16 rgSCHUtlIotResMngmtInit ARGS((
RgSchCellCb *cell,
- U32 pdcchPoolSz,
- U32 pdcchDelta,
- U32 pdcchMaxFreqSz,
- U32 pdschPoolSz,
- U32 pdschDelta,
- U32 pdschMaxFreqSz,
- U32 puschPoolSz,
- U32 puschDelta,
- U32 puschMaxFreqSz
+ uint32_t pdcchPoolSz,
+ uint32_t pdcchDelta,
+ uint32_t pdcchMaxFreqSz,
+ uint32_t pdschPoolSz,
+ uint32_t pdschDelta,
+ uint32_t pdschMaxFreqSz,
+ uint32_t puschPoolSz,
+ uint32_t puschDelta,
+ uint32_t puschMaxFreqSz
));
Void rgSCHUtlIotResMngmtDeinit ARGS((
RgSchIotRes *rgSCHUtlIotAllocRes ARGS((
RgSchIotResCb *resCb,
- U32 fStart,
- U32 fSize,
+ uint32_t fStart,
+ uint32_t fSize,
CmLteTimingInfo tStart,
- U32 tSize,
+ uint32_t tSize,
Bool isForEnable
));
RgSchIotRes *rgSCHUtlEmtcAllocRes ARGS((
RgSchIotResCb *resCb,
- U32 *fStart,
- U32 *fEnd,
+ uint32_t *fStart,
+ uint32_t *fEnd,
CmLteTimingInfo tStart,
- U32 tSize,
- U32 numPrb,
+ uint32_t tSize,
+ uint32_t numPrb,
Bool isRetx
));
S16 rgSCHUtlEmtcResMngmtInit ARGS((
RgSchCellCb *cell,
- U32 pdschPoolSz,
- U32 pdschDelta,
- U32 pdschMaxFreqSz,
- U32 puschPoolSz,
- U32 puschDelta,
- U32 puschMaxFreqSz,
- U32 pucchPoolSz,
- U32 pucchDelta,
- U32 pucchMaxFreqSz
+ uint32_t pdschPoolSz,
+ uint32_t pdschDelta,
+ uint32_t pdschMaxFreqSz,
+ uint32_t puschPoolSz,
+ uint32_t puschDelta,
+ uint32_t puschMaxFreqSz,
+ uint32_t pucchPoolSz,
+ uint32_t pucchDelta,
+ uint32_t pucchMaxFreqSz
));
Void rgSCHUtlEmtcResMngmtDeinit ARGS((
typedef struct rgSchUePCqiSrsSrCfgIdxTbl
{
- U16 min; /*!< start ISRB Index */
- U16 max; /*!< end ISRB Index */
- U16 peri; /*!< SRS Periodicity in ms */
- U16 offset; /*!< Offset with ISRB value */
+ uint16_t min; /*!< start ISRB Index */
+ uint16_t max; /*!< end ISRB Index */
+ uint16_t peri; /*!< SRS Periodicity in ms */
+ uint16_t offset; /*!< Offset with ISRB value */
}RgSchUePCqiSrsSrCfgIdxTbl;
/**
typedef struct rgSchUeSrsCfgIdxTbl
{
- U16 min; /*!< start ISRB Index */
- U16 max; /*!< end ISRB Index */
- U16 peri; /*!< SRS Periodicity in ms */
- U16 offset1; /*!< Offset with ISRB value */
- U16 offset2; /*!< Offset with ISRB value */
+ uint16_t min; /*!< start ISRB Index */
+ uint16_t max; /*!< end ISRB Index */
+ uint16_t peri; /*!< SRS Periodicity in ms */
+ uint16_t offset1; /*!< Offset with ISRB value */
+ uint16_t offset2; /*!< Offset with ISRB value */
}RgSchUeSrsCfgIdxTbl;
*/
typedef struct rgSchUeGrp
{
- U8 beamBitMask; /*!< Beam bit mask */
- //U8 numUe; /*!< Ue present in Group */
+ uint8_t beamBitMask; /*!< Beam bit mask */
+ //uint8_t numUe; /*!< Ue present in Group */
}RgSchUeGrp;
/**
{
RgSchUeGrp ueGrp5gConf[MAX_5GTF_GROUP]; /*!< Contains all the group configured */
RgSchSfType dynConfig[MAX_5GTF_SUBFRAME_INFO]; /*!< Get config from config file as of now */
- U8 numUes;
- U8 uePerGrpPerTti; /*!< Num of UEs to be scheduled in a group per TTI */
- U8 ueGrpPerTti; /*!< Num of Groups to ne scheduled per Tti */
- U8 numCCs;
- U8 bwPerCC;
- U8 cfi;
- U8 totVrbg;
+ uint8_t numUes;
+ uint8_t uePerGrpPerTti; /*!< Num of UEs to be scheduled in a group per TTI */
+ uint8_t ueGrpPerTti; /*!< Num of Groups to ne scheduled per Tti */
+ uint8_t numCCs;
+ uint8_t bwPerCC;
+ uint8_t cfi;
+ uint8_t totVrbg;
}RgSch5gtfCellCb;
#endif // 5GTF
typedef struct rgSchUeSrsCb
{
RgSchUeUlSrsCfg srsCfg; /*!< SRS Specific configuration */
- U16 peri; /*!< Periodicity */
- U16 offset; /*!< subframe Offset */
- U16 nSrsTrIdx;
+ uint16_t peri; /*!< Periodicity */
+ uint16_t offset; /*!< subframe Offset */
+ uint16_t nSrsTrIdx;
/*!< Next Tranmission instance
Referenence: 36.213 Section:8.2
((10*sfn +sf-sfOffset))/mod(peri)) */
CmLList srsLstEnt; /*!< SRS List for next tranmission instance subframe */
- U8 selectedAnt; /*!< Selected Antenna for SRS Reception*/
- U16 srsDist; /*!< crnt Distance to get RI Transmission */
+ uint8_t selectedAnt; /*!< Selected Antenna for SRS Reception*/
+ uint16_t srsDist; /*!< crnt Distance to get RI Transmission */
Bool srsRecpPrcsd; /*!< SRS Recpeption processed as part of PUCCH
// or PUSCH processing in current TTI or not */
typedef struct rgSchUeBwSubSzBwParts
{
- U8 rbStart; /* RB Start */
- U8 rbEnd; /* RB End */
- U8 subSize; /* k */
- U8 bwParts; /* J */
+ uint8_t rbStart; /* RB Start */
+ uint8_t rbEnd; /* RB End */
+ uint8_t subSize; /* k */
+ uint8_t bwParts; /* J */
}RgSchUeBwSubSzBwParts;
typedef struct rgSchUePCqiCb
{
RgrUePrdDlCqiCfg cqiCfg; /*!< Cqi Pmi Configuration */
- U16 cqiPeri; /*!< Periodicity */
- U16 cqiOffset; /*!< CQI offset */
- U16 riOffset; /*!< RI Offset */
- U16 riPeri; /*!< RI periodicity */
- U16 nCqiTrIdx;
+ uint16_t cqiPeri; /*!< Periodicity */
+ uint16_t cqiOffset; /*!< CQI offset */
+ uint16_t riOffset; /*!< RI Offset */
+ uint16_t riPeri; /*!< RI periodicity */
+ uint16_t nCqiTrIdx;
/*!< Next Active Tranmission instace index ,
precompute CQI/PMI
Transmission Instance
few will be used for subbands.
*/
- U16 nRiTrIdx; /*!< Next Active Transmission instance for RI
+ uint16_t nRiTrIdx; /*!< Next Active Transmission instance for RI
Transmission Instance Referenence:
36.213 Section:8.2 */
- U16 riDist; /*!< crnt Distance to get RI Transmission */
- U16 h; /*!< Precompute and store H */
- U8 riNumBits; /*Precomputed value as it doesn't change
+ uint16_t riDist; /*!< crnt Distance to get RI Transmission */
+ uint16_t h; /*!< Precompute and store H */
+ uint8_t riNumBits; /*Precomputed value as it doesn't change
on-the-fly */
/* 1. In the case where wideband RI reporting is configured
(Mode 1-0 or 1-1)
interf input */
Bool isWb; /*! < Is True when a WideBand CQI is to be
Transmitted in a SubBand CQI Config*/
- U8 bpIdx; /*Index of the Bandwidth Part*/
- U8 label; /*Label L associated */
- U8 J; /*Number of Bandwidth Parts*/
+ uint8_t bpIdx; /*Index of the Bandwidth Part*/
+ uint8_t label; /*Label L associated */
+ uint8_t J; /*Number of Bandwidth Parts*/
CmLList cqiLstEnt;/*!< List CQI UEs for next transmission
instance */
CmLList riLstEnt; /*!< List RI UEs for next transmission
instance */
Bool invalidateCqi; /*!< If TRUE, ignore the WB/SB CQI report*/
- U8 perRiVal; /*!< Latest Periodic RI value reported */
+ uint8_t perRiVal; /*!< Latest Periodic RI value reported */
Bool riRecpPrcsd; /*!< RI Recpeption processed as part of
PUCCH or PUSCH processing in current
TTI or not */
CQI CB */
RgSchHistInfo histElem;
#ifdef EMTC_ENABLE
- U8 rgSchPucchRepNumCount; /*!< CQI repetition count for CATM1 */
+ uint8_t rgSchPucchRepNumCount; /*!< CQI repetition count for CATM1 */
#endif
}RgSchUePCqiCb;
typedef struct rgSchUeSrCfgIdx
{
- U16 sIsr; /*!< Start ISR Index */
- U16 eIsr; /*!< End ISR Index */
- U16 peri; /*!< SR Periodicity */
- U16 offset; /*!< offset */
+ uint16_t sIsr; /*!< Start ISR Index */
+ uint16_t eIsr; /*!< End ISR Index */
+ uint16_t peri; /*!< SR Periodicity */
+ uint16_t offset; /*!< offset */
}RgSchUeSrCfgIdx;
#ifdef RG_UNUSED
/* Reference : 36.213 Table 10.1-5 */
typedef struct rgSchUeSrCb
{
RgSchUeSrCfg srCfg; /*!< SR configuration */
- U16 offset; /*!< SR offset */
- U16 peri; /*!< SR periodicity */
+ uint16_t offset; /*!< SR offset */
+ uint16_t peri; /*!< SR periodicity */
- U16 nSrTrIdx; /*!< Next Active Tranmission Instance Index ,
+ uint16_t nSrTrIdx; /*!< Next Active Tranmission Instance Index ,
Referenence: 36.213 Section:10.1 */
/*
*/
#ifdef EMTC_ENABLE
- U8 rgSchPucchRepNumCount; /*!< SR repetition count for CATM1 */
+ uint8_t rgSchPucchRepNumCount; /*!< SR repetition count for CATM1 */
#endif
CmLList srLstEnt; /*!< Next Transmission instance SR UE list */
typedef struct rgSchUeACqiCb
{
RgrUeAprdDlCqiCfg aCqiCfg;/*!< Cqi Pmi Configuration */
- U8 L; /*Unique Label through which positioning of Subbands
+ uint8_t L; /*Unique Label through which positioning of Subbands
will be conveyed by the UE */
- U8 N; /*Total Bandwidth / Num of Subbands*/
- U8 M; /*Number of Selected Subbands*/
- U8 riNumBits;
- U8 k; /*k - SB size. 36.213 Tables:7.2.1-3, 7.2.1-5*/
- U8 cqiPmiSzR1; /*CQIPMI Size for Rank =1*/
- U8 cqiPmiSzRn1; /*CQIPMI Size for Rank > 1*/
- U32 aCqiTrigWt; /* Metric to track Aperiodic CQI Trigger occassion */
+ uint8_t N; /*Total Bandwidth / Num of Subbands*/
+ uint8_t M; /*Number of Selected Subbands*/
+ uint8_t riNumBits;
+ uint8_t k; /*k - SB size. 36.213 Tables:7.2.1-3, 7.2.1-5*/
+ uint8_t cqiPmiSzR1; /*CQIPMI Size for Rank =1*/
+ uint8_t cqiPmiSzRn1; /*CQIPMI Size for Rank > 1*/
+ uint32_t aCqiTrigWt; /* Metric to track Aperiodic CQI Trigger occassion */
RgSchCqiReqField cqiReqField; /* Cqi Request field. This Value can be 00 01 10 11, based upon
the cell present in which trigger list form App */
}RgSchUeACqiCb;
/*ccpu00116923 - ADD - SRS present support*/
#ifdef LTE_TDD
-typedef U8 RgSchTddCellSpSrsSubfrmTbl[RGSCH_CELLSP_SRS_SF_CONFIGS][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchTddCellSpSrsSubfrmTbl[RGSCH_CELLSP_SRS_SF_CONFIGS][RGSCH_NUM_SUB_FRAMES];
#else
-typedef U8 RgSchFddCellSpSrsSubfrmTbl[RGSCH_CELLSP_SRS_SF_CONFIGS][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchFddCellSpSrsSubfrmTbl[RGSCH_CELLSP_SRS_SF_CONFIGS][RGSCH_NUM_SUB_FRAMES];
#endif
*/
typedef struct rgSchTddSubfrmInfo
{
- U8 switchPoints; /*!< Number of DL-UL switch points */
- U8 numFrmHf1; /*!< Number of subframes for half frame 1
+ uint8_t switchPoints; /*!< Number of DL-UL switch points */
+ uint8_t numFrmHf1; /*!< Number of subframes for half frame 1
Present for both 5ms and 10ms periodicity */
- U8 numFrmHf2; /*!< Number of subframes for half frame 2
+ uint8_t numFrmHf2; /*!< Number of subframes for half frame 2
Present only for 5ms periodicity */
} RgSchTddSubfrmInfo;
*/
typedef struct rgSchTddDlAscSetIdxK
{
- U8 numFdbkSubfrms; /*!< Number of Feedbacks for DL Subframes */
- U8 subfrmNum[RGSCH_NUM_SUB_FRAMES-1]; /*!< List of Subframe Number */
+ uint8_t numFdbkSubfrms; /*!< Number of Feedbacks for DL Subframes */
+ uint8_t subfrmNum[RGSCH_NUM_SUB_FRAMES-1]; /*!< List of Subframe Number */
} RgSchTddDlAscSetIdxK;
/** @brief PRACH Information for a frequency resource. */
typedef struct rgrSchTddPrachInfo
{
- U8 freqIdx; /*!< Frequency Index */
- U8 sfn; /*!< Even/Odd/All Radio Frames */
- U8 halfFrm; /*!< First/Second Half Frame */
- U8 ulStartSfIdx; /*!< Uplink Start Subframe Index*/
+ uint8_t freqIdx; /*!< Frequency Index */
+ uint8_t sfn; /*!< Even/Odd/All Radio Frames */
+ uint8_t halfFrm; /*!< First/Second Half Frame */
+ uint8_t ulStartSfIdx; /*!< Uplink Start Subframe Index*/
} RgSchTddPrachInfo;
/** @brief PRACH resource Information for each of the
* frequency resources. */
typedef struct rgrSchTddPrachRscInfo
{
- U8 numRsc; /*!< Number of frequency resources*/
+ uint8_t numRsc; /*!< Number of frequency resources*/
RgSchTddPrachInfo prachInfo[RGSCH_TDD_MAX_FREQ_RSRC]; /*!< PRACH Information */
} RgSchTddPrachRscInfo;
*/
struct rgSchTddSplSubfrmInfo
{
- U8 norDlDwPts; /*!< DL Normal CP: DwPTS in Ts */
- U8 norDlNorUpPts; /*!< DL Normal CP: UL Normal CP:UpPTS in Ts */
- U8 norDlExtUpPts; /*!< DL Normal CP: UL Extended CP: UpPTS in Ts */
- U8 extDlDwPts; /*!< DL Extended CP: DwPTS in Ts */
- U8 extDlNorUpPts; /*!< DL Extended CP: UL Normal CP:UpPTS in Ts */
- U8 extDlExtUpPts; /*!< DL Extended CP: UL Extended CP: UpPTS in Ts */
+ uint8_t norDlDwPts; /*!< DL Normal CP: DwPTS in Ts */
+ uint8_t norDlNorUpPts; /*!< DL Normal CP: UL Normal CP:UpPTS in Ts */
+ uint8_t norDlExtUpPts; /*!< DL Normal CP: UL Extended CP: UpPTS in Ts */
+ uint8_t extDlDwPts; /*!< DL Extended CP: DwPTS in Ts */
+ uint8_t extDlNorUpPts; /*!< DL Extended CP: UL Normal CP:UpPTS in Ts */
+ uint8_t extDlExtUpPts; /*!< DL Extended CP: UL Extended CP: UpPTS in Ts */
};
/**
*/
typedef struct rgSchTddRachRspInfo
{
- U8 sfnOffset; /*!< SFN offset with respect to
+ uint8_t sfnOffset; /*!< SFN offset with respect to
expected RACH available for
scheduling */
- U8 numSubfrms; /* Number of subframes present */
- U8 subframe[RGSCH_NUM_SUB_FRAMES]; /*!< List of Subframe numbers */
+ uint8_t numSubfrms; /* Number of subframes present */
+ uint8_t subframe[RGSCH_NUM_SUB_FRAMES]; /*!< List of Subframe numbers */
} RgSchTddRachRspInfo;
typedef RgSchTddRachRspInfo RgSchTddRachDelInfo;
*/
typedef struct rgSchTddRachRspLst
{
- U8 numRadiofrms; /*!< Number of radio frames */
+ uint8_t numRadiofrms; /*!< Number of radio frames */
RgSchTddRachRspInfo rachRsp[2]; /*!< RACH Occasions for which response
can be sent */
RgSchTddRachDelInfo delInfo; /*!< Previous RACH responses for
*/
typedef struct rgSchTddUlAscInfo
{
- U8 subframe; /*!< Subframe number */
- U8 sfnOffset; /*!< SFN offset with respect to expected
+ uint8_t subframe; /*!< Subframe number */
+ uint8_t sfnOffset; /*!< SFN offset with respect to expected
UL data reception time */
} RgSchTddUlAscInfo;
*/
typedef struct rgSchTddPuschOffInfo
{
- U8 subframe; /*!< Subframe number */
- U8 sfnOffset; /*!< SFN offset with respect to expected
+ uint8_t subframe; /*!< Subframe number */
+ uint8_t sfnOffset; /*!< SFN offset with respect to expected
UL data reception time */
} RgSchTddPuschOffInfo;
*/
struct rgSchTddPhichOffInfo
{
- U8 numSubfrms; /*!< Number of subframes */
+ uint8_t numSubfrms; /*!< Number of subframes */
/* ACC-TDD */
- U8 subframe; /*!< The Uplink Subframe number corresponding
+ uint8_t subframe; /*!< The Uplink Subframe number corresponding
to the phich */
- U8 sfnOffset; /*!< SFN offset with respect to expected
+ uint8_t sfnOffset; /*!< SFN offset with respect to expected
UL data reception time */
};
*/
typedef struct rgSchTddDlFdbkInfo
{
- U8 subframe; /*!< Subframe number */
- U8 sfnOffset; /*!< SFN offset with respect to current
+ uint8_t subframe; /*!< Subframe number */
+ uint8_t sfnOffset; /*!< SFN offset with respect to current
scheduled time */
- U8 m; /*!< m factor used in Downlink Association
+ uint8_t m; /*!< m factor used in Downlink Association
Set Index */
#ifdef LTE_ADV /*Naw:: This is not correct */
CmLListCp n1PucchResLst; /*!< List for storing the used N1 resource */
*/
typedef struct rgSchTddSplSubfrmCfg
{
- U16 dwPts; /*!< DwPTS in OFDM Symbol Duration */
- U16 upPts; /*!< UpPTS in OFDM Symbol Duration */
+ uint16_t dwPts; /*!< DwPTS in OFDM Symbol Duration */
+ uint16_t upPts; /*!< UpPTS in OFDM Symbol Duration */
Bool isDlDataAllowed; /*!< To allow scheduling of DL data on
special subframe */
} RgSchTddSplSubfrmCfg;
*/
typedef struct rgSchTddANInfo
{
- U16 sfn; /*!< ACK/NACK is sent for PDU in this SFN */
- U8 subframe; /*!< ACK/NACK is sent for PDU in this subframe */
- U8 dlDai; /*!< Downlink Assignment Index for
+ uint16_t sfn; /*!< ACK/NACK is sent for PDU in this SFN */
+ uint8_t subframe; /*!< ACK/NACK is sent for PDU in this subframe */
+ uint8_t dlDai; /*!< Downlink Assignment Index for
UL-DL Configuration 1-6 */
- U8 ulDai; /*!< DAI for uplink */
- U8 latestMIdx; /*!< Last transmitted DL subframe 'm' index */
- U8 n1ResTpcIdx; /*!< N1 Res idx for scell assigned in TPC command */
+ uint8_t ulDai; /*!< DAI for uplink */
+ uint8_t latestMIdx; /*!< Last transmitted DL subframe 'm' index */
+ uint8_t n1ResTpcIdx; /*!< N1 Res idx for scell assigned in TPC command */
Bool isSpsOccasion; /*!< To indicate the presence of SPS occasion */
#ifdef LTE_ADV
- U8 wUlDai; /*!< Max Ul dai in all the cells */
+ uint8_t wUlDai; /*!< Max Ul dai in all the cells */
#endif
} RgSchTddANInfo;
#endif
*/
typedef struct rgSchUlIMcsInfo
{
- U8 qm;
- U8 iTbs;
+ uint8_t qm;
+ uint8_t iTbs;
} RgSchUlIMcsTbl[29];
EXTERN RgSchUlIMcsTbl rgUlIMcsTbl;
typedef struct rgSchUeCatTbl
{
- U32 maxUlBits;/*Maximum number of
+ uint32_t maxUlBits;/*Maximum number of
bits of an UL-SCH
transport block
transmitted within a
TTI*/
- U32 maxDlBits[4];/*Maximum number of
+ uint32_t maxDlBits[4];/*Maximum number of
bits of a DLSCH
transport block
received within a TTI*/
/* correcting DL harq softbuffer limitation logic */
- U32 maxSftChBits;/*Total number of soft channel bits*/
+ uint32_t maxSftChBits;/*Total number of soft channel bits*/
Bool ul64qamSup;/*Support for 64QAM in UL*/
/* Changes for MIMO feature addition */
/* Removed dependency on MIMO compile-time flag */
- U32 maxDlTbBits;/*Maximum number of DL-SCH
+ uint32_t maxDlTbBits;/*Maximum number of DL-SCH
transport block bits
received within a TTI*/
- U8 maxTxLyrs;/*Maximum number of supported
+ uint8_t maxTxLyrs;/*Maximum number of supported
layers for spatial multiplexing
in DL*/
} RgSchUeCatTbl[CM_MAX_UE_CAT_SUPP + 1];
/* Changes for MIMO feature addition */
/* Removed dependency on MIMO compile-time flag */
-typedef U32 RgSchTbSzTbl[RGSCH_MAX_NUM_LYR_PERCW][RGSCH_NUM_ITBS][RGSCH_MAX_NUM_RB];
+typedef uint32_t RgSchTbSzTbl[RGSCH_MAX_NUM_LYR_PERCW][RGSCH_NUM_ITBS][RGSCH_MAX_NUM_RB];
#ifdef LTE_TDD
-typedef U8 RgSchRaPrmblToRaFrmTbl[RGSCH_MAX_TDD_RA_PREAMBLE_FMT+1];
+typedef uint8_t RgSchRaPrmblToRaFrmTbl[RGSCH_MAX_TDD_RA_PREAMBLE_FMT+1];
#else
/* Added matrix 'rgRaPrmblToRaFrmTbl' for computation of RA
sub-frames from preamble format */
-typedef U8 RgSchRaPrmblToRaFrmTbl[RGSCH_MAX_RA_PREAMBLE_FMT+1];
+typedef uint8_t RgSchRaPrmblToRaFrmTbl[RGSCH_MAX_RA_PREAMBLE_FMT+1];
#endif
EXTERN RgSchRaPrmblToRaFrmTbl rgRaPrmblToRaFrmTbl;
-EXTERN U8 rgRvTable[4];
+EXTERN uint8_t rgRvTable[4];
typedef struct rgDciFmt
{
- U8 dciType;
+ uint8_t dciType;
union
{
RgDciFmt1AInfo dci1a;
* Information about one PDCCH.
*/
typedef struct rgSchPdcch {
- U8 nCce; /*!< CCE index */
+ uint8_t nCce; /*!< CCE index */
CmLteAggrLvl aggrLvl; /*!< Aggregation level */
TfuDciInfo dci; /*!< PDCCH format */
- U16 rnti; /*!< RNTI to who the PDCCH is allocated */
+ uint16_t rnti; /*!< RNTI to who the PDCCH is allocated */
#if (defined (LTE_TDD))
- U8 dlDai; /*!< DAI associated with this PDCCH.
+ uint8_t dlDai; /*!< DAI associated with this PDCCH.
THis is used for F1BCS resource calulcation */
#endif
/* Added support for SPS*/
CmLteTimingInfo relFbkTiming; /*!< Feebback timing information for release
PDCCH */
Bool isSpsRnti; /*!< TRUE if rnti is SPS RNTI */
- U16 crnti; /*!< CRNTI to who the PDCCH is allocated */
+ uint16_t crnti; /*!< CRNTI to who the PDCCH is allocated */
#endif
CmLList lnk; /*!< To link PDCCHs in a subframe */
#ifdef EMTC_ENABLE
#endif
RgSchUeCb *ue; /*!< Pointer to the UE Control Block */
RgSchPdcchSearchSpace pdcchSearchSpace; /*!< Search Space from this PDCCH allocated */
- U8 dciNumOfBits; /*!< Size of DCI in bits */
+ uint8_t dciNumOfBits; /*!< Size of DCI in bits */
} RgSchPdcch;
/**
* PDCCH information for cell.
*/
typedef struct rgSchPdcchInfo {
- U8 *map; /*!< Bit map of PDCCHs */
- U8 currCfi; /*!< Number of CCEs */
- U16 nCce; /*!< Total CCEs */
+ uint8_t *map; /*!< Bit map of PDCCHs */
+ uint8_t currCfi; /*!< Number of CCEs */
+ uint16_t nCce; /*!< Total CCEs */
CmLListCp pdcchs; /*!< List of RgSchPdcch */
} RgSchPdcchInfo;
typedef struct rgSchPhich
{
CmLList lnk; /*!< To link PHICHs in a subframe */
- U8 hqFeedBack; /*!< Harq Feed Back */
- U8 rbStart; /*!< Starting RB */
- U8 nDmrs; /*!< 3 bits for DMRS cyclic shift */
+ uint8_t hqFeedBack; /*!< Harq Feed Back */
+ uint8_t rbStart; /*!< Starting RB */
+ uint8_t nDmrs; /*!< 3 bits for DMRS cyclic shift */
/* changes for passing iphich at TFU;*/
Bool isForMsg3; /*! < Phich Ack/Nack conveyed for MSG 3 */
#ifdef LTE_TDD
- U8 iPhich; /*!< For determining phich group */
+ uint8_t iPhich; /*!< For determining phich group */
#endif
} RgSchPhich;
{
RgSchPdcch *pdcch;
Buffer *tb;
- U16 tbSize;
+ uint16_t tbSize;
} RgSchBcchTb;
typedef struct rgSchPcchTb
{
RgSchPdcch *pdcch;
Buffer *tb;
- U16 tbSize;
+ uint16_t tbSize;
} RgSchPcchTb;
typedef struct rgSchRaRspAlloc
{
- U16 raRnti;
- U32 tbSz;
- TknU8 backOffInd; /*!< Backoff index value */
+ uint16_t raRnti;
+ uint32_t tbSz;
+ TknUInt8 backOffInd; /*!< Backoff index value */
CmLListCp raRspLst; /*!< List of RaCbs */
CmLListCp contFreeUeLst; /*! List of HandOver or PdcchOrder UEs */
RgSchPdcch *pdcch; /*!< NULLP if no Rsp allocation done for raRnti*/
typedef struct rgSchBchTb
{
Buffer *tb; /*!< BCH data for this frame */
- U16 tbSize; /*!< Non-Zero if bch data is scheduled for this SF */
+ uint16_t tbSize; /*!< Non-Zero if bch data is scheduled for this SF */
}RgSchBchTb;
/* Added support for SPS*/
@brief Downlink Resource allocation type information. */
struct rgSchDlSfAllocInfo
{
- U32 raType0Mask; /*!< RBG allocation mask for type 0*/
- U32 raType1Mask[RG_SCH_NUM_RATYPE1_32BIT_MASK]; /*!< RA Type 1
+ uint32_t raType0Mask; /*!< RBG allocation mask for type 0*/
+ uint32_t raType1Mask[RG_SCH_NUM_RATYPE1_32BIT_MASK]; /*!< RA Type 1
allocation mask */
- U32 raType1UsedRbs[RG_SCH_NUM_RATYPE1_32BIT_MASK];/*!< RA Type 1 Used RBs
+ uint32_t raType1UsedRbs[RG_SCH_NUM_RATYPE1_32BIT_MASK];/*!< RA Type 1 Used RBs
per subset */
- U32 nxtRbgSubset; /*!< Next RBG subset to be used for allocation */
- U32 raType2Mask[RG_SCH_NUM_RATYPE2_32BIT_MASK];
+ uint32_t nxtRbgSubset; /*!< Next RBG subset to be used for allocation */
+ uint32_t raType2Mask[RG_SCH_NUM_RATYPE2_32BIT_MASK];
/*!< Mask for resource allocation type 2 */
};
#endif /* LTEMAC_SPS */
@brief RGR RB range for SFR */
typedef struct rgrPwrHiCCRange
{
- U8 startRb; /*<! Start RB for power high cell centre user */
- U8 endRb; /*<! End RB for power high cell centre user */
+ uint8_t startRb; /*<! Start RB for power high cell centre user */
+ uint8_t endRb; /*<! End RB for power high cell centre user */
} RgrPwrHiCCRange;
typedef struct rgSchSFRTotalPoolInfo
Bool CCRetx; /* to check if there is any CC retransmission */
Bool CC1; /* Cell centre pool 1 */
Bool CC2; /* cell centre pool 2 */
- U8 CCPool1BwAvlbl; /* Cell Centre Bw available for Pool1 */
- U8 CCPool2BwAvlbl; /* Cell Centre Bw available for Pool2 */
- U8 CEPoolBwAvlbl; /* Cell Edge Bw available for CE Pool */
+ uint8_t CCPool1BwAvlbl; /* Cell Centre Bw available for Pool1 */
+ uint8_t CCPool2BwAvlbl; /* Cell Centre Bw available for Pool2 */
+ uint8_t CEPoolBwAvlbl; /* Cell Edge Bw available for CE Pool */
}RgSchSFRTotalPoolInfo;
typedef struct rgSchSFRPoolInfo
{
/*Fixed RB Range of the Pool. Fixed by user configuration*/
- U16 poolstartRB;
- U16 poolendRB;
- U16 bw; /*!< Number of RBs in the pool */
+ uint16_t poolstartRB;
+ uint16_t poolendRB;
+ uint16_t bw; /*!< Number of RBs in the pool */
/*Dynamic Values */
- U8 type2Start; /*!< Start RB for the next type 2 allocation */
- U8 type2End; /*!< End position of Type2 allocation with in the bit mask */
- U8 type0End; /*!< End position of Type0 allocation with in the bit mask */
+ uint8_t type2Start; /*!< Start RB for the next type 2 allocation */
+ uint8_t type2End; /*!< End position of Type2 allocation with in the bit mask */
+ uint8_t type0End; /*!< End position of Type0 allocation with in the bit mask */
- U16 bwAlloced; /*!< Number of RBs already allocated by DLFS */
+ uint16_t bwAlloced; /*!< Number of RBs already allocated by DLFS */
Bool CCPool2Exists; /*!< To check if the last pool in the RB allocation is a CC pool */
struct rgSchSFRPoolInfo * adjCCPool; /*!< The CC pool adjacent to this CE Pool SFR_FIX */
RgrPwrHiCCRange pwrHiCCRange; /*!< Power High Range which can be used by CC user based on RNTP info */
typedef struct rgSchPuschBwInfo
{
- U8 numSb; /*!< PUSCH BW in subbands */
- U8 startRb; /*!< Starting RB for PUSCH BW */
+ uint8_t numSb; /*!< PUSCH BW in subbands */
+ uint8_t startRb; /*!< Starting RB for PUSCH BW */
}RgSchPuschBwInfo;
typedef struct rgSchDynCfiCb
{
- U8 isDynCfiEnb; /*!< Dynamic CFI feature Flag */
- U8 maxCfi; /*!< max possible CFI in the cell */
- U8 switchOvrWinLen; /*!< Length of Switchover window */
- U16 cceFailCnt; /*!< Number of CCE allocation Failures in a
+ uint8_t isDynCfiEnb; /*!< Dynamic CFI feature Flag */
+ uint8_t maxCfi; /*!< max possible CFI in the cell */
+ uint8_t switchOvrWinLen; /*!< Length of Switchover window */
+ uint16_t cceFailCnt; /*!< Number of CCE allocation Failures in a
CCE failure sample period */
- U16 *cceFailSamples; /*!< Array holding samples of Avg number
+ uint16_t *cceFailSamples; /*!< Array holding samples of Avg number
of CCE allocation failures */
- U16 cceFailSum; /*!< Moving sum of the CCE faliures of
+ uint16_t cceFailSum; /*!< Moving sum of the CCE faliures of
N samples */
- U16 cfiStepUpTtiCnt; /*!< No.of TTIs to take decision for CFI
+ uint16_t cfiStepUpTtiCnt; /*!< No.of TTIs to take decision for CFI
step Up */
- U16 cceUsed; /*!< Total CCEs used in current monitoring
+ uint16_t cceUsed; /*!< Total CCEs used in current monitoring
interval */
- U16 lowCceCnt; /*!< Number of TTI in which CCEs used is
+ uint16_t lowCceCnt; /*!< Number of TTI in which CCEs used is
less than available CCEs in
lower CFI */
- U16 cfiStepDownTtiCnt; /*!< No.of TTIs to take decision for CFI
+ uint16_t cfiStepDownTtiCnt; /*!< No.of TTIs to take decision for CFI
step Down */
- U32 cfiSwitches; /*!< Total number of CFI switches */
- U32 cfiIncr; /*!< Total number of CFI increments */
- U32 cfiDecr; /*!< Total number of CFI decrements */
+ uint32_t cfiSwitches; /*!< Total number of CFI switches */
+ uint32_t cfiIncr; /*!< Total number of CFI increments */
+ uint32_t cfiDecr; /*!< Total number of CFI decrements */
/*!< Total CCE per CFI */
- U8 cfi2NCceTbl[RG_SCH_MAX_MPHICH][RG_SCH_CMN_MAX_CFI];
+ uint8_t cfi2NCceTbl[RG_SCH_MAX_MPHICH][RG_SCH_CMN_MAX_CFI];
- U8 numFailSamples; /*!< Number of CCE Allocation Failure
+ uint8_t numFailSamples; /*!< Number of CCE Allocation Failure
samples */
- U16 failSamplePrd; /*!< Failure Sample Period */
- U16 ttiCnt; /*!< TTI count to track monitoring period
+ uint16_t failSamplePrd; /*!< Failure Sample Period */
+ uint16_t ttiCnt; /*!< TTI count to track monitoring period
and sample period expiry */
RgSchPuschBwInfo bwInfo[RG_SCH_CMN_MAX_CFI]; /*!< PUSCH BW info */
- U8 pdcchSfIdx; /*!< Subframe Idx for CFI applying */
- U8 prevCceFailIdx; /*!< To maintain Previous Index of
+ uint8_t pdcchSfIdx; /*!< Subframe Idx for CFI applying */
+ uint8_t prevCceFailIdx; /*!< To maintain Previous Index of
CCE failure array */
Bool switchOvrInProgress; /*!< Switchover is in progress */
Bool dynCfiRecfgPend; /*!< Flag for pending dynamic cfi reconfig */
*/
typedef struct rgSchSfBeamInfo
{
- U16 totVrbgAvail; /*!< Total VRBG available */
- //U16 totRb; /*!< Total RB per Beam */
- U16 totVrbgRequired; /*!< total Rbs requested for beam */
- U16 totVrbgAllocated; /*!< total Rbs allocated for beam */
- U16 vrbgStart; /*!< VRBG start for beam */
+ uint16_t totVrbgAvail; /*!< Total VRBG available */
+ //uint16_t totRb; /*!< Total RB per Beam */
+ uint16_t totVrbgRequired; /*!< total Rbs requested for beam */
+ uint16_t totVrbgAllocated; /*!< total Rbs allocated for beam */
+ uint16_t vrbgStart; /*!< VRBG start for beam */
} RgSchSfBeamInfo;
#endif
typedef struct rgSchDlSf
{
- U8 cceCnt; /*!< Number of CCEs used in the subframe */
+ uint8_t cceCnt; /*!< Number of CCEs used in the subframe */
Bool isCceFailure; /*!< TRUE if PDCCH allocation is failed for
this subframe */
- U8 dlUlBothCmplt; /*!< To track that DL and UL both scheduling
+ uint8_t dlUlBothCmplt; /*!< To track that DL and UL both scheduling
is done */
- U8 sfNum; /*!< Number of the subframe */
- U16 bw; /*!< Number of RBs in the cell */
- U16 bwAlloced; /*!< Number of RBs already allocated by DLFS */
- U16 bwAssigned; /*!< Number of RBs already allocated by scheduler */
+ uint8_t sfNum; /*!< Number of the subframe */
+ uint16_t bw; /*!< Number of RBs in the cell */
+ uint16_t bwAlloced; /*!< Number of RBs already allocated by DLFS */
+ uint16_t bwAssigned; /*!< Number of RBs already allocated by scheduler */
/* LTE_ADV_FLAG_REMOVED_START */
RgSchSFRTotalPoolInfo sfrTotalPoolInfo; /* SFR Pool Info*/
TknStrOSXL rntpInfo; /* RNTP Info for the complete subframe*/
/* LTE_ADV_FLAG_REMOVED_END */
- U8 type2Start; /*!< Start RB for the next type 2 allocation */
- U8 type2End; /*!< End position of Type2 allocation with
+ uint8_t type2Start; /*!< Start RB for the next type 2 allocation */
+ uint8_t type2End; /*!< End position of Type2 allocation with
in the bit mask */
- U8 type0End; /*!< End position of Type0 allocation with
+ uint8_t type0End; /*!< End position of Type0 allocation with
in the bit mask */
- U8 lstRbgDfct; /*!< The last RBG deficit RBs, Ex. if DLBW = 97,
+ uint8_t lstRbgDfct; /*!< The last RBG deficit RBs, Ex. if DLBW = 97,
* RBGsz = 4, lstRbgDfct = 3 */
Bool txDone; /*!< Flag to indicate if transmission is done*/
- U32 numDlActvUes; /* 4UE_TTI_DELTA: num of active Ues */
+ uint32_t numDlActvUes; /* 4UE_TTI_DELTA: num of active Ues */
RgSchBchTb bch; /*!< BCH data for this frame */
RgSchBcchTb bcch; /*!< BCCH allocation for this frame */
RgSchPcchTb pcch; /*!< PCCH allocation for this frame */
Void *laaCb;
CmLListCp msg4HqPLst; /*!< Msg4 Hq Procs that are scheduled in Perticular SF */
/* CA dev End */
- U8 remUeCnt; /*!< Remaining number of UEs that can be scheduled */
+ uint8_t remUeCnt; /*!< Remaining number of UEs that can be scheduled */
Bool schdAmbrNxt;/*!< Flag indicates to pick an AMBR LC after GBR LC */
/*[ccpu00138609]-ADD- Counter to track the number of Msg4/DL CCCH UEs */
- U8 schdCcchUe; /*!< Num of Msg4/DL CCCH UEs scheduled in
+ uint8_t schdCcchUe; /*!< Num of Msg4/DL CCCH UEs scheduled in
the DL Sf */
#ifdef LTE_TDD
- U8 nCce; /*!< Number of CCEs */
+ uint8_t nCce; /*!< Number of CCEs */
RgSchTddPhichOffInfo phichOffInfo; /*!< PHICH Information */
RgSchTddDlFdbkInfo dlFdbkInfo; /*!< HARQ Ack/Nack feedback expected time */
RgSchTddUlAscInfo ulAscInfo; /*!< UL Association set Information */
#ifdef LTEMAC_SPS
Bool isSPSOcc; /*!< TRUE if this SF has SPS Occasion allocation */
RgSchDlSfAllocInfo dlSfAllocInfo;/*!< Allocation information for DL SF */
- U32 spsAllocdBw; /*!< Number of RBs allocated for SPS */
+ uint32_t spsAllocdBw; /*!< Number of RBs allocated for SPS */
RgSchPdcch *relPdcch; /*!< Only one release PDCCH scheduled per
sub-frame */
#ifdef LTE_TDD
* for release PDCCH (DL) */
#endif
#endif
- U32 schedLcCount; /*!< Num of LCs scheduled in this TTI */
- U32 totalLcCntOfSlctdUes; /*!< total Lc count of all UE's selected in
+ uint32_t schedLcCount; /*!< Num of LCs scheduled in this TTI */
+ uint32_t totalLcCntOfSlctdUes; /*!< total Lc count of all UE's selected in
* this TTI*/
- U32 totPrbReq; /*!< Sum of PRBs required by selected UEs
+ uint32_t totPrbReq; /*!< Sum of PRBs required by selected UEs
in this subframe */
#ifdef BEST_EFFORT_2_UE_PER_TTI
- U32 beTotPrbReq;
+ uint32_t beTotPrbReq;
#endif
/* CA dev Start */
- U8 dlIdx;
+ uint8_t dlIdx;
/* CA dev Start */
#ifdef LTE_ADV
CmLListCp n1PucchResLst; /*!< List for storing the used N3 resource */
#endif
#ifdef RG_5GTF
RgSchSfBeamInfo sfBeamInfo[MAX_5GTF_BEAMS]; /*!< Per info Beam per sf*/
- U8 numGrpPerTti; /*!< number of Group per TTI*/
- U8 numUePerGrp; /*!< number of UE per group in TTI*/
+ uint8_t numGrpPerTti; /*!< number of Group per TTI*/
+ uint8_t numUePerGrp; /*!< number of UE per group in TTI*/
#endif
} RgSchDlSf;
@brief Downlink Resource allocation type 0 information. */
typedef struct rgSchDlRbAllocRaType0
{
- U8 numDlAlloc; /*!< Number of downlink allocations */
- U32 dlAllocBitMask; /*!< Downlink allocations done for the UE */
+ uint8_t numDlAlloc; /*!< Number of downlink allocations */
+ uint32_t dlAllocBitMask; /*!< Downlink allocations done for the UE */
} RgSchDlRbAllocRaType0;
/* Added support for SPS*/
@brief Downlink Resource allocation type 1 information. */
typedef struct rgSchDlRbAllocRaType1
{
- U8 numDlAlloc; /*!< Number of downlink allocations */
- U8 shift; /*!< Indicates if the shift is triggered in the
+ uint8_t numDlAlloc; /*!< Number of downlink allocations */
+ uint8_t shift; /*!< Indicates if the shift is triggered in the
allocation */
- U8 rbgSubset; /*!< RBG subset number selected for the allocation*/
- U32 dlAllocBitMask; /*!< Downlink allocations done for the UE */
+ uint8_t rbgSubset; /*!< RBG subset number selected for the allocation*/
+ uint32_t dlAllocBitMask; /*!< Downlink allocations done for the UE */
} RgSchDlRbAllocRaType1;
#endif /* LTEMAC_SPS */
/**
typedef struct rgSchDlRbAllocRaType2
{
Bool isLocal; /*!< True if localised VRB */
- U8 rbStart; /*!< Starting RB */
- U8 numRb; /*!< Number of RBs */
+ uint8_t rbStart; /*!< Starting RB */
+ uint8_t numRb; /*!< Number of RBs */
} RgSchDlRbAllocRaType2;
typedef struct rgSchcmnDlGrnt
{
- U16 schdTime; /*!< Time at which Harq proc has been scheduled */
- U8 rbStrt; /*!< Starting RB of the allocation */
- U8 numRb; /*!< Number of RBs allocated */
- U8 iMcs; /*!< Index to the MCS */
- U8 rv; /*!< RV for HARQ (re)transmission */
- U8 rvIdx; /*!< RVIdx for HARQ(re)transmission */
+ uint16_t schdTime; /*!< Time at which Harq proc has been scheduled */
+ uint8_t rbStrt; /*!< Starting RB of the allocation */
+ uint8_t numRb; /*!< Number of RBs allocated */
+ uint8_t iMcs; /*!< Index to the MCS */
+ uint8_t rv; /*!< RV for HARQ (re)transmission */
+ uint8_t rvIdx; /*!< RVIdx for HARQ(re)transmission */
#ifdef RG_5GTF /* ToDo:: Anoop need to check for other fields required*/
- U8 vrbgStart;
- U8 numVrbg;
- U16 rbAssign;
- U8 xPDSCHRange;
- U8 SCID;
+ uint8_t vrbgStart;
+ uint8_t numVrbg;
+ uint16_t rbAssign;
+ uint8_t xPDSCHRange;
+ uint8_t SCID;
TfuDciFormat dciFormat; /*!< DCI format for the allocation */
/* ToDo */
#endif
Bool schdlngForTb;/*!< Indicates if this TB has been scheduled */
/*ccpu00120365:-ADD-is this TB disabled. Refer to 36.213-7.1.7.2 */
Bool isDisabled; /*!< Indicates if this TB is disabled */
- U32 bytesReq; /*!< Number of bytes required to be allocated
+ uint32_t bytesReq; /*!< Number of bytes required to be allocated
for each TB: filled in by RR/MAX C/I/PFS */
- U32 bytesAlloc; /*!< Num of bytes allocated for each TB */
- U8 iTbs; /*!< Itbs for allocation for this allocation
+ uint32_t bytesAlloc; /*!< Num of bytes allocated for each TB */
+ uint8_t iTbs; /*!< Itbs for allocation for this allocation
* of TB */
- U8 imcs; /*!< Imcs for allocation for this allocation
+ uint8_t imcs; /*!< Imcs for allocation for this allocation
* of TB */
- U8 noLyr; /*!< No. of SM layers for this TB transmission */
+ uint8_t noLyr; /*!< No. of SM layers for this TB transmission */
RgSchDlHqTbCb *tbCb; /*!< address of TB Control Block */
#ifdef RG_5GTF
RgSchDlCmnGrnt cmnGrnt; /*! < Alloc info to store 5GTF RAR sched */
* with RETX in case of TM3 and TM4 */
Bool swpFlg; /*!< Swap Flag to indicate TB to CW association
* incase of 2 TB transmission */
- U8 precIdxInfo; /*!< Precoding index information stored */
- U8 numTxLyrs; /*!< Number of SM layers scheduled for Transmission */
+ uint8_t precIdxInfo; /*!< Precoding index information stored */
+ uint8_t numTxLyrs; /*!< Number of SM layers scheduled for Transmission */
}RgSchMimoAllocInfo;
{
CmLteRnti rnti; /*!< RNTI for allocation: used only for RARs and
dedicated transmissions */
- U8 rbsReq; /*!< Number of RBs required to be allocated:
+ uint8_t rbsReq; /*!< Number of RBs required to be allocated:
filled in by RR/MAX C/I/PFS */
RgSchDlSf *dlSf; /*!< DL sub-frame for which allocation is to be
done: filled in by RR/MAX C/I/PFS */
TfuDciFormat dciFormat; /*!< DCI format for the allocation */
- U8 raType; /*!< Resource allocation Type */
+ uint8_t raType; /*!< Resource allocation Type */
RgSchPdcch *pdcch; /*!< Pointer to allocated PDCCH */
union allocInfoU
{
#endif
RgSchDlRbAllocRaType2 raType2; /*!< Resource allocation type 2 information */
} allocInfo; /*!< Resource allocation information */
- U8 rbsAlloc; /*!< Number of RBs allocated */
- U8 numRapids; /*!< Number of RAPIDs serviced within RAR*/
+ uint8_t rbsAlloc; /*!< Number of RBs allocated */
+ uint8_t numRapids; /*!< Number of RAPIDs serviced within RAR*/
/* Nprb indication at PHY for common Ch */
- U8 nPrb; /*!< NPRB column num. either 2 or 3 */
- U32 raIndex;
+ uint8_t nPrb; /*!< NPRB column num. either 2 or 3 */
+ uint32_t raIndex;
Bool schdFirst;
/* Add BI sub-header size to the tbSize requirement */
- U8 biEstmt;
+ uint8_t biEstmt;
RgSchMimoAllocInfo mimoAllocInfo; /*!< Mimo specific allocation params */
RgSchDlTbAllocInfo tbInfo[2]; /*!< Allocation information for each TB. */
/* Added support for SPS*/
#ifdef LTEMAC_SPS
- U8 cqiForTx; /*!< Assumed value of CQI at which transmission is
+ uint8_t cqiForTx; /*!< Assumed value of CQI at which transmission is
scheduled */
RgSchDlSfAllocInfo resAllocInfo; /*!< Resource allocation information for
the current allocation for
RgSchEmtcDlRbAlloc emtcAllocInfo; /*!< EMTC DL RB alloc Info */
#endif
#ifdef RG_5GTF
- U8 vrbgReq;
+ uint8_t vrbgReq;
#endif
} RgSchDlRbAlloc;
*/
typedef struct rgSchUlGrnt
{
- U8 iMcs; /*!< Original MCS index */
- U8 iMcsCrnt; /*!< Current MCS index of the grant */
- U8 hop; /*!< Hopping flag, set to 0 in this version */
- U8 rbStart; /*!< Start Resource block of allocation */
- U8 numRb; /*!< Number of resource blocks allocated */
- U8 tpc; /*!< TPC command for the uplink grant */
- U8 nDmrs; /*!< n1DMRS for the uplink grant */
- U8 delayBit; /*!< Delay bit, for msg3 grant, set to 1 */
+ uint8_t iMcs; /*!< Original MCS index */
+ uint8_t iMcsCrnt; /*!< Current MCS index of the grant */
+ uint8_t hop; /*!< Hopping flag, set to 0 in this version */
+ uint8_t rbStart; /*!< Start Resource block of allocation */
+ uint8_t numRb; /*!< Number of resource blocks allocated */
+ uint8_t tpc; /*!< TPC command for the uplink grant */
+ uint8_t nDmrs; /*!< n1DMRS for the uplink grant */
+ uint8_t delayBit; /*!< Delay bit, for msg3 grant, set to 1 */
/* Added for Uplink Adaptive retransmission */
Bool isRtx; /*!< To indicate if this grant is for a RETX */
/* To include the length and ModOrder in DataRecp Req. */
- U16 datSz; /*!< Length of the Data */
+ uint16_t datSz; /*!< Length of the Data */
TfuModScheme modOdr; /*!< Modulation order */
#ifdef RG_5GTF
- U8 vrbgStart;
- U8 numVrbg;
- U16 rbAssign;
- U8 xPUSCHRange;
- U8 SCID;
- U8 PMI;
- U8 uciOnxPUSCH;
- U8 hqProcId;
+ uint8_t vrbgStart;
+ uint8_t numVrbg;
+ uint16_t rbAssign;
+ uint8_t xPUSCHRange;
+ uint8_t SCID;
+ uint8_t PMI;
+ uint8_t uciOnxPUSCH;
+ uint8_t hqProcId;
Bool ndi;
TfuDciFormat dciFrmt;
- U8 numLyr;
+ uint8_t numLyr;
#endif
} RgSchUlGrnt;
struct rgSchUlRetxAlloc
{
CmLteRnti rnti; /*!< RNTI */
- U8 numSb; /*!< Number of subbands */
- U32 tbSz; /*!< Transmission Block Size */
- U8 iMcs; /*!< Original MCS index */
+ uint8_t numSb; /*!< Number of subbands */
+ uint32_t tbSz; /*!< Transmission Block Size */
+ uint8_t iMcs; /*!< Original MCS index */
RgSchUeCb *ue; /*!< UE assocated with allocation */
Bool forMsg3; /*!< If allocation is for Msg3 */
/* PHR handling for MSG3 */
#endif
#ifdef RG_5GTF
TfuDciFormat dciFrmt;
- U8 numLyr;
- U8 vrbgStart;
- U8 numVrbg;
+ uint8_t numLyr;
+ uint8_t vrbgStart;
+ uint8_t numVrbg;
TfuModScheme modOdr; /*!< Modulation order */
#endif
};
*/
typedef struct rgSchUlHole
{
- U8 start; /*!< Beginning of hole */
- U8 num; /*!< Number of elements making up the hole */
+ uint8_t start; /*!< Beginning of hole */
+ uint8_t num; /*!< Number of elements making up the hole */
struct rgSchUlHole *prv; /*!< Previous hole */
struct rgSchUlHole *nxt; /*!< Next hole */
struct rgSchUlAlloc *nxtAlloc; /*!< Next allocation */
{
RgSchUlHqProcCb *hqProc; /*!< HARQ process */
CmLteRnti rnti; /*!< RNTI */
- U8 sbStart; /*!< Subband start idx */
- U8 numSb; /*!< Number of subbands */
+ uint8_t sbStart; /*!< Subband start idx */
+ uint8_t numSb; /*!< Number of subbands */
RgSchUlGrnt grnt; /*!< Grant info */
/* Not keeping grant attributes now */
RgSchPdcch *pdcch; /*!< Associated PDCCH */
*/
typedef struct rgSchUlAllocMem
{
- U8 maxAllocs; /*!< Maximum possible allocations per subframe */
+ uint8_t maxAllocs; /*!< Maximum possible allocations per subframe */
RgSchUlAlloc *firstFree; /*!< First free index */
RgSchUlAlloc *allocs; /*!< Array of 'maxAllocs' elems */
} RgSchUlAllocMem;
*/
typedef struct rgSchUlAllocDb
{
- U8 count; /*!< Number of allocations */
+ uint8_t count; /*!< Number of allocations */
RgSchUlAlloc *first; /*!< First allocation */
RgSchUlAllocMem mem; /*!< Alloc pool management */
} RgSchUlAllocDb;
*/
typedef struct rgSchUlHoleMem
{
- U8 maxHoles; /*!< Maximum possible holes per subframe */
+ uint8_t maxHoles; /*!< Maximum possible holes per subframe */
RgSchUlHole *firstFree; /*!< First free index */
RgSchUlHole *holes; /*!< Array of 'maxHoles' elems */
} RgSchUlHoleMem;
*/
typedef struct rgSchUlHoleDb
{
- U8 count; /*!< Number of holes */
+ uint8_t count; /*!< Number of holes */
RgSchUlHole *first; /*!< First hole */
RgSchUlHoleMem mem; /*!< Hole pool management */
} RgSchUlHoleDb;
*/
typedef struct rgSchUlSf
{
- U8 idx; /*!< Identifier for uplink subframe (range: 0-7)
+ uint8_t idx; /*!< Identifier for uplink subframe (range: 0-7)
- maps to HARQ proc ID */
CmLListCp reTxLst; /*!< Retransmission List*/
#ifdef LTE_TDD
RgSchTddPuschOffInfo puschOffset; /*!< PUSCH offset information */
- U8 ulSfIdx; /*!< The Uplink subframe number
+ uint8_t ulSfIdx; /*!< The Uplink subframe number
in the TDD frame. Range [2-9]
Used only in TDD Cfg 0 */
#endif
- U32 totPrb; /*!< Total PRB used in this sub frame */
+ uint32_t totPrb; /*!< Total PRB used in this sub frame */
/* ccpu00129725 -DEL- removed Platform flag */
/* Fix:ccpu00120610 add a counter to keep track of remaining allocations */
- U8 *allocCountRef; /*!< Allocation count in this
+ uint8_t *allocCountRef; /*!< Allocation count in this
* subframe, it is a reference to the actual
* counter held in allocDb (no additional
* logic needed to maintain this) */
/* Added for Uplink Adaptive retransmission */
RgSchUlAllocDb *allocDb; /*!< Allocation info */
RgSchUlHoleDb *holeDb; /*!< Holes info */
- U8 availSubbands; /*!< Number of total available subbands
+ uint8_t availSubbands; /*!< Number of total available subbands
* for the current sub-frame */
- U8 numACqiCount; /*!< Used to Restrict 2 Aperiodic cqi per TTI*/
+ uint8_t numACqiCount; /*!< Used to Restrict 2 Aperiodic cqi per TTI*/
#ifdef RG_5GTF
RgSchSfBeamInfo sfBeamInfo[MAX_5GTF_BEAMS]; /*!< Per info Beam per sf*/
- U8 numGrpPerTti; /*!< number of Group per TTI*/
- U8 numUePerGrp; /*!< number of UE per group in TTI*/
+ uint8_t numGrpPerTti; /*!< number of Group per TTI*/
+ uint8_t numUePerGrp; /*!< number of UE per group in TTI*/
#endif
} RgSchUlSf;
typedef struct rgSchClcBoRpt
{
CmLList boLstEnt; /*!< Linked list entity for BO list */
- U32 bo; /*!< Bo in bytes */
+ uint32_t bo; /*!< Bo in bytes */
CmLteTimingInfo timeToTx; /*!< Time at which the BO needs to be satisfied
(data to be sent to PHY) */
#ifdef EMTC_ENABLE
- U8 emtcDIReason; /*!< Reason for DI message to send. */
- U8 pnb; /*!< Paging narrowBand on which Ue performs reception of paging*/
+ uint8_t emtcDIReason; /*!< Reason for DI message to send. */
+ uint8_t pnb; /*!< Paging narrowBand on which Ue performs reception of paging*/
#endif
CmLteTimingInfo maxTimeToTx;
- U8 retxCnt;
- U16 i;
- U8 nPrb; /*! NPRB column. Allowed values {2,3} */
+ uint8_t retxCnt;
+ uint16_t i;
+ uint8_t nPrb; /*! NPRB column. Allowed values {2,3} */
/* Corrected allocation for common channels */
- U8 mcs;
+ uint8_t mcs;
} RgSchClcBoRpt;
/**
*/
typedef struct rgSchClcDlLcCb
{
- U8 lcId; /*!< Logical channel ID */
+ uint8_t lcId; /*!< Logical channel ID */
Bool si;
CmLListCp boLst; /*!< List of BOs reported (RgSchClcBoRpt) */
} RgSchClcDlLcCb;
*/
typedef struct rgSchSrsTxOffst
{
- U8 count; /*!< Number of offsets in the array */
- U8 offst[RGSCH_MAX_SRS_TX_OFFSET]; /*!< SRS TX offset value */
+ uint8_t count; /*!< Number of offsets in the array */
+ uint8_t offst[RGSCH_MAX_SRS_TX_OFFSET]; /*!< SRS TX offset value */
} RgSchSrsTxOffst;
/**
RgSchSrsTxOffst srsTxOffst; /*!< Transmission offset for SRS */
/*ccpu00116923 - ADD - SRS present support*/
#ifdef TFU_UPGRADE
- U8 srsSubFrameCfg;/*!< SRS subframe configuration index per cell.
+ uint8_t srsSubFrameCfg;/*!< SRS subframe configuration index per cell.
Range - [0-15] */
#endif
} RgSchSrsCfg;
*/
typedef struct rgSchRntiLnk
{
- U16 rnti; /*!< RNTI */
+ uint16_t rnti; /*!< RNTI */
/*Fix: Overcome race condition between MAC and Scheduler delete*/
CmLList rntiGrdPoolLnk; /*!< Link for RNTI guard pool*/
struct rgSchRntiLnk *prv; /*!< Link to previous RNTI */
*/
typedef struct rgSchRntiDb
{
- U16 rntiStart; /*!< Start RNTI */
- U16 maxRntis; /*!< Maximum number of RNTIs managed by MAC */
- U16 count;
+ uint16_t rntiStart; /*!< Start RNTI */
+ uint16_t maxRntis; /*!< Maximum number of RNTIs managed by MAC */
+ uint16_t count;
RgSchRntiLnk *freeRnti; /*!< first free RNTI in the list */
RgSchRntiLnk *lastRnti; /*!< last RNTI in the list */
RgSchRntiLnk *rntiPool; /*!< Linked list of RNTIs */
typedef struct rgSchRaInfoCb
{
#ifdef LTE_TDD
- U8 maxRaSize; /*!< Number of RA-RNTIs stored
+ uint8_t maxRaSize; /*!< Number of RA-RNTIs stored
across radio frames */
- U8 lstSize; /*!< list size */
+ uint8_t lstSize; /*!< list size */
CmLListCp *raReqLst; /*!< Each array elem is linked
list of RgRaReqInfo
(per ra-rnti) */
CmLList harqRTTEnt; /*!< Entry into the HARQ RTT timer list */
CmLList harqRetxEnt; /*!< Entry into the harqRetxQ */
- U16 rttIndx; /*!< Current Index into HARQ RTT Q */
- U16 reTxIndx; /*!< Current Index into Re-Tx Q */
- U8 retxTmrReduction; /*!< Due to platform specific timing diff between
+ uint16_t rttIndx; /*!< Current Index into HARQ RTT Q */
+ uint16_t reTxIndx; /*!< Current Index into Re-Tx Q */
+ uint8_t retxTmrReduction; /*!< Due to platform specific timing diff between
UL HARQ processing and UL Scheduling, the
drx retx timer may start at a later time, than
actual. That delay in starting the timer is
*/
struct rgSchUlHqProcCb
{
- U8 ndi; /*!< NDI */
- U8 remTx; /*!< Number of remaining transmissions */
+ uint8_t ndi; /*!< NDI */
+ uint8_t remTx; /*!< Number of remaining transmissions */
RgSchUlAlloc *alloc; /*!< Uplink allocation */
/* Renamed rcvdDatInd to rcvdCrcInd */
Bool rcvdCrcInd; /*!< Set to true when data rcvd, false when
decode failure. */
- U8 rvIdx; /*!< Redundancy version index */
- TknU8 rvIdxPhy; /*!< Whatever is given by PHY. To be inspected in case
+ uint8_t rvIdx; /*!< Redundancy version index */
+ TknUInt8 rvIdxPhy; /*!< Whatever is given by PHY. To be inspected in case
of NACK.Always initialised to 'not present' */
CmLList reTxLnk; /*!< Retransmission List */
RgSchUlRetxAlloc reTxAlloc; /*!< Retransmission allocation
information */
Bool isRetx; /*!< Awaiting retransmission */
- U8 procId; /*!< HARQ Process ID */
- U8 ulSfIdx; /*!< UL Subframe Index */
+ uint8_t procId; /*!< HARQ Process ID */
+ uint8_t ulSfIdx; /*!< UL Subframe Index */
#ifdef LTE_TDD
/* Changes for passing iPhich at TFU*/
- U8 iPhich; /*!< Needed to Calculate PHICH
+ uint8_t iPhich; /*!< Needed to Calculate PHICH
location. For TDD only */
#endif
#ifdef LTEMAC_SPS
*/
typedef struct rgSchUlHqCb
{
- U8 maxHqRetx; /*!< Maximum number of harq
+ uint8_t maxHqRetx; /*!< Maximum number of harq
* re-transmissions */
- U8 numHqPrcs; /*!< Number of HARQ Processes */
+ uint8_t numHqPrcs; /*!< Number of HARQ Processes */
#ifdef LTE_TDD
RgSchUlHqProcCb *hqProcCb; /*!< Uplink harq process info */
#else
RgSchUlHqProcCb hqProcCb[RGSCH_NUM_UL_HQ_PROC]; /*!< Uplink harq process info */
#endif
#ifdef LTE_L2_MEAS
- U8 numBusyHqProcs; /*!< Total Num of Hq procs in use */
+ uint8_t numBusyHqProcs; /*!< Total Num of Hq procs in use */
#endif
#ifdef EMTC_ENABLE
void *sch;
* */
typedef struct rgSchRaPreambles
{
- U8 dedPream; /*!< Dedicated RA Preamble received */
- U8 preamGrpA; /*!< Randomly selected preambles in low range */
- U8 preamGrpB; /*!< Randomly selected preambles in high range */
+ uint8_t dedPream; /*!< Dedicated RA Preamble received */
+ uint8_t preamGrpA; /*!< Randomly selected preambles in low range */
+ uint8_t preamGrpB; /*!< Randomly selected preambles in high range */
}RgSchRaPreambles;
/**
{
Bool cntActive; /* Set to TRUE if counting activated */
CmLteTimingInfo startTime; /*!< Start Time */
- U8 timePrd; /*!< Period For which meas to be done */
- U32 prbCount; /*!< PRB Count Updated every Per TTI */
+ uint8_t timePrd; /*!< Period For which meas to be done */
+ uint32_t prbCount; /*!< PRB Count Updated every Per TTI */
} RgSchAvgPrbDl;
/**
{
Bool cntActive; /*!< Set to TRUE if counting activated */
CmLteTimingInfo startTime; /*!< Start Time */
- U8 timePrd; /*!< Period For which meas to be done */
- U32 prbCount; /*!< PRB Count Updated every Per TTI */
+ uint8_t timePrd; /*!< Period For which meas to be done */
+ uint32_t prbCount; /*!< PRB Count Updated every Per TTI */
} RgSchAvgPrbUl;
/** @brief
RgInfPrbCfm avgPrbQciUl; /*!< Used to store result from MAC */
Bool cfmRcvd; /*!< Used to check if confirm received from MAC */
/*!< For average PRB usage in UL */
- U16 sfnCycle; /*<! Count of Num of SFN wraps */
- U32 dlTotalBw; /*!< Total DL Bw between meas Req and Meas Send Req */
- U32 ulTotalBw; /*!< Total UL Bw between meas Req and Meas Send Req */
+ uint16_t sfnCycle; /*<! Count of Num of SFN wraps */
+ uint32_t dlTotalBw; /*!< Total DL Bw between meas Req and Meas Send Req */
+ uint32_t ulTotalBw; /*!< Total UL Bw between meas Req and Meas Send Req */
};
typedef struct rgSchTbCnt
{
- U32 tbTransDlTotalCnt; /*!< Total DL TB count */
- U32 tbTransDlFaulty; /*!< Total DL Faulty TB count */
- U32 tbTransUlTotalCnt; /*!< Total UL TB count */
- U32 tbTransUlFaulty; /*!< Total UL Faulty TB count */
+ uint32_t tbTransDlTotalCnt; /*!< Total DL TB count */
+ uint32_t tbTransDlFaulty; /*!< Total DL Faulty TB count */
+ uint32_t tbTransUlTotalCnt; /*!< Total UL TB count */
+ uint32_t tbTransUlFaulty; /*!< Total UL Faulty TB count */
}RgSchTbCnt;
#endif /* LTE_L2_MEAS */
/** @brief
* */
struct rgSchQciCb
{
- U8 qci; /*!< QCI of the Logical Channel */
- U32 dlPrbCount; /*!< Cumulative Prb Count for this QCI */
- U32 dlUeCount; /*!< Cumulative number of active UE's */
- U32 dlTotal_UeCount; /*!< Cummulative count added for every sampling
+ uint8_t qci; /*!< QCI of the Logical Channel */
+ uint32_t dlPrbCount; /*!< Cumulative Prb Count for this QCI */
+ uint32_t dlUeCount; /*!< Cumulative number of active UE's */
+ uint32_t dlTotal_UeCount; /*!< Cummulative count added for every sampling
Occasion*/
- U32 ulUeCount; /*!< Cumulative number of active UE's */
- U32 ulTotal_UeCount; /*!< Cummulative count added for every sampling
+ uint32_t ulUeCount; /*!< Cumulative number of active UE's */
+ uint32_t ulTotal_UeCount; /*!< Cummulative count added for every sampling
Occasion*/
};
struct rgSchLcgCb
{
/* Right now not keeping associated logical channels, searching for
* associated channels needed only during config */
- U8 lcgId; /*!< Group ID */
+ uint8_t lcgId; /*!< Group ID */
Void *sch;
#ifdef LTE_L2_MEAS
- U8 numLch; /*!< Number fo LC's for this LCG*/
+ uint8_t numLch; /*!< Number fo LC's for this LCG*/
RgSchUlLcCb *lcArray[RGSCH_MAX_LC_PER_UE]; /*!< Dedicated Uplink logical
channel per LCG */
#endif /* LTE_L2_MEAS */
/* Added support for SPS*/
#ifdef LTEMAC_SPS
- U8 lcCnt;
- U8 lcId[RGR_MAX_SPS_LC];
+ uint8_t lcCnt;
+ uint8_t lcId[RGR_MAX_SPS_LC];
#endif
};
struct rgSchUlLcCb
{
Bool isValid; /*!< If this struct holds valid values*/
- U8 lcId; /*!< Logical channel ID */
- U8 lcgArrIdx; /*!< Index of this LC in the LCG Array*/
+ uint8_t lcId; /*!< Logical channel ID */
+ uint8_t lcgArrIdx; /*!< Index of this LC in the LCG Array*/
RgSchLcgCb *lcg; /*!< Logical channel group */
RgrLchQosCfg ulQos; /*!< UL Qos parameters */
/* After Merging from 2.1 to 2.2 */
*/
typedef struct rgSchHoPoUeGrnt
{
- U8 rapId; /*!< dedicated rapId */
- U8 hop; /*!< Hopping flag, set to 0 in this version */
- U8 rbStart; /*!< Start Resource block of allocation */
- U8 numRb; /*!< Number of resource blocks allocated */
- U8 tpc; /*!< TPC command for the uplink grant */
- U8 iMcsCrnt; /*!< Current MCS index of the grant */
- TknU16 ta; /*!< Timing Adjustment */
+ uint8_t rapId; /*!< dedicated rapId */
+ uint8_t hop; /*!< Hopping flag, set to 0 in this version */
+ uint8_t rbStart; /*!< Start Resource block of allocation */
+ uint8_t numRb; /*!< Number of resource blocks allocated */
+ uint8_t tpc; /*!< TPC command for the uplink grant */
+ uint8_t iMcsCrnt; /*!< Current MCS index of the grant */
+ TknUInt16 ta; /*!< Timing Adjustment */
CmLList raRspLnk; /*!< To link UE to RaRsp cont free list */
/* Added support for SPS*/
- U16 datSz; /*!< Length of the Data */
+ uint16_t datSz; /*!< Length of the Data */
Bool cqiReqBit; /*!< Aperiodic CQI is requested or not */
} RgSchHoPoUeGrnt;
*/
typedef struct rgSchCmnSpsUlUeSchdInfo
{
- U32 allocBwMask[RGSCH_SPS_ULBW_MASK_LEN]; /*!< Bitmask indicating the allocation info
+ uint32_t allocBwMask[RGSCH_SPS_ULBW_MASK_LEN]; /*!< Bitmask indicating the allocation info
for the UE. Bit set at position 'x'
indicates subband 'x' is allocated */
- U8 scaledCqi; /*!< Assumed value of CQI for transmission */
- U16 actvSfLstIdx; /*!< Index into cell-wide UL SPS sub-frame
+ uint8_t scaledCqi; /*!< Assumed value of CQI for transmission */
+ uint16_t actvSfLstIdx; /*!< Index into cell-wide UL SPS sub-frame
table during activation */
CmLteTimingInfo ulSpsActvOcc; /*!< Time at which SPS is activated/reactivated
for the UE */
activation/reactivation/release */
Bool isUlSpsActv; /*!< Indicates if UE's UL SPS is
active currently */
- U8 measGapMask[RGSCH_SPS_MG_MASK_LEN]; /*!< Indicates the UL sub-frames with
+ uint8_t measGapMask[RGSCH_SPS_MG_MASK_LEN]; /*!< Indicates the UL sub-frames with
ongoing measurement gap. Mask is
of size (80/8) */
- U8 state; /*!< State of the UE: can be one of
+ uint8_t state; /*!< State of the UE: can be one of
ACTV_REACTV_SENT (pdcch for
(re)activation sent),REL_SENT,
ULSPS_ACTV */
RgSchCmnSpsUlUeSchdInfo ulSpsSchdInfo; /*!< Scheduled info for UL SPS
active UE */
- U8 spsOccIdx; /*!< N value for nxt sps occasion */
+ uint8_t spsOccIdx; /*!< N value for nxt sps occasion */
- U32 packetSize; /*!< Packet size for SPS - SPS allocation*/
- U32 spsSduSize; /*!< SDU Size recvd on SPS Occasion*/
- U32 spsGrantSize; /*!< Grant size for SPS allocation */
+ uint32_t packetSize; /*!< Packet size for SPS - SPS allocation*/
+ uint32_t spsSduSize; /*!< SDU Size recvd on SPS Occasion*/
+ uint32_t spsGrantSize; /*!< Grant size for SPS allocation */
CmLteTimingInfo lastSpsDatRecvdTime; /*!< timing info on which the
SPS data is recieved*/
CmLListCp *spsList; /*!< Pointer to the SPS list of which
UE is a part */
- U32 actPdcchCrcFailCount; /*!< Num of consecutive CRC fails for
+ uint32_t actPdcchCrcFailCount; /*!< Num of consecutive CRC fails for
SPS Activation PDCCH */
- U32 crcFailCntSpsOcc; /*!< Consecutive CRC fail for SPS Occasion
+ uint32_t crcFailCntSpsOcc; /*!< Consecutive CRC fail for SPS Occasion
TX */
- U32 relPdcchSntCnt; /*!< Num ber Rel PDCCH sent to UE*/
+ uint32_t relPdcchSntCnt; /*!< Num ber Rel PDCCH sent to UE*/
#ifdef RGSCH_SPS_STATS
- U32 crcFailStats;
- U32 crcPassStats;
- U32 totalBsr;
- U32 numBsrRpt;
+ uint32_t crcFailStats;
+ uint32_t crcPassStats;
+ uint32_t totalBsr;
+ uint32_t numBsrRpt;
#endif
} RgSchCmnUlUeSpsInfo;
RgSchUlLcCb lcCb[RGSCH_MAX_LC_PER_UE]; /*!< Dedicated Uplink logical channel
information */
RgSchLcgCb lcgArr[RGSCH_MAX_LCG_PER_UE]; /*!< Logical channel groups */
- U8 ulInactvMask; /*!< Bitmask indicating if UE is inactive for UL scheduling */
+ uint8_t ulInactvMask; /*!< Bitmask indicating if UE is inactive for UL scheduling */
CmLList ulInactvLnk; /*!< Link to the inactive UE List for UL */
RgSchHoPoUeGrnt rarGrnt; /*!< UE's RAR grant Information */
RgrUeTxAntSelCfg ulTxAntSel;/*!< UL Transmit antenna selection Cfg Info */
/* Added support for SPS*/
#ifdef LTEMAC_SPS
RgrUeSpsUlCfg ulSpsCfg; /*!< UL SPS configuration information */
- U8 explicitRelCnt; /*!< Number of subframes after sending
+ uint8_t explicitRelCnt; /*!< Number of subframes after sending
release to consider it successful */
- U16 spsPrdcty; /*!< Shall store the SPS periodicity of the
+ uint16_t spsPrdcty; /*!< Shall store the SPS periodicity of the
UE. Needed to round-off in case of
TDD */
CmLteTimingInfo relPdcchSchdTime; /*!< This field holds the scheduled time
of SPS rel PDCCH*/
#endif
#ifdef LTE_L2_MEAS
- U32 nPrb; /*!< Number of resource block allocated */
+ uint32_t nPrb; /*!< Number of resource block allocated */
#endif
#ifdef TFU_UPGRADE
- U8 betaHqOffst; /*!< Delta HARQ offset used in the case where HARQ
+ uint8_t betaHqOffst; /*!< Delta HARQ offset used in the case where HARQ
feedback is multiplexed with PUSCH data. */
- U8 betaCqiOffst;/*!< Beta offset for CQI[0-15]. Given by RRC*/
- U8 betaRiOffst;/*!Beta offset for RI[0-15]. Given by RRC */
+ uint8_t betaCqiOffst;/*!< Beta offset for CQI[0-15]. Given by RRC*/
+ uint8_t betaRiOffst;/*!Beta offset for RI[0-15]. Given by RRC */
#endif
- U32 cqiRiSz; /*!<Size of Periodic/Aperiodic CQI or RI depending
+ uint32_t cqiRiSz; /*!<Size of Periodic/Aperiodic CQI or RI depending
on the occassion */
- U32 betaOffstVal; /*!< beta offset of CQI or RI depending
+ uint32_t betaOffstVal; /*!< beta offset of CQI or RI depending
on the occassion*/
- U32 maxBytesPerUePerTti; /*!< Maximum bytes that can be allocated
+ uint32_t maxBytesPerUePerTti; /*!< Maximum bytes that can be allocated
* in 1 scheduling instance per UE */
- U32 minReqBytes; /*!< The buffer amount of lcg0 */
- U32 totalBsr; /*!< Total BSR as reported by UE (in bytes) */
- U32 nonLcg0Bs; /*!< Total BSR for LCG1/LCG2/LCG3 */
- U32 nonGbrLcgBs; /*!< Total BSR as reported by UE (in bytes) for non-GBR LCG's*/
- U32 effBsr; /*!< BSR yet to be satisfied in allocations */
-
- U32 cfgdAmbr; /*!< Byte rate of UE Ambr per Refresh Cycle */
- U32 effAmbr; /*!< Remaining Bytes of Byte rate available in a refresh Cycle */
+ uint32_t minReqBytes; /*!< The buffer amount of lcg0 */
+ uint32_t totalBsr; /*!< Total BSR as reported by UE (in bytes) */
+ uint32_t nonLcg0Bs; /*!< Total BSR for LCG1/LCG2/LCG3 */
+ uint32_t nonGbrLcgBs; /*!< Total BSR as reported by UE (in bytes) for non-GBR LCG's*/
+ uint32_t effBsr; /*!< BSR yet to be satisfied in allocations */
+
+ uint32_t cfgdAmbr; /*!< Byte rate of UE Ambr per Refresh Cycle */
+ uint32_t effAmbr; /*!< Remaining Bytes of Byte rate available in a refresh Cycle */
CmLteTimingInfo ulTransTime; /*!< Timing info of the latest reception of
any UL data/signal from UE */
#ifdef LTEMAC_SPS
*/
typedef struct rgSchCcchSchdInfo
{
- U32 totBytes; /*!< Total bytes allocated */
+ uint32_t totBytes; /*!< Total bytes allocated */
CmLList retxLnk; /*!< To link hqP to retx Queues */
- U8 rvIdx; /*!< Rv Index */
+ uint8_t rvIdx; /*!< Rv Index */
} RgSchCcchSchdInfo;
/**
*/
typedef struct rgSchDlGrnt
{
- U16 schdTime; /*!< Time at which Harq proc has been scheduled */
- U8 rbStrt; /*!< Starting RB of the allocation */
- U8 numRb; /*!< Number of RBs allocated */
- U8 iMcs; /*!< Index to the MCS */
- U8 rv; /*!< RV for HARQ (re)transmission */
- U8 rvIdx; /*!< RVIdx for HARQ(re)transmission */
+ uint16_t schdTime; /*!< Time at which Harq proc has been scheduled */
+ uint8_t rbStrt; /*!< Starting RB of the allocation */
+ uint8_t numRb; /*!< Number of RBs allocated */
+ uint8_t iMcs; /*!< Index to the MCS */
+ uint8_t rv; /*!< RV for HARQ (re)transmission */
+ uint8_t rvIdx; /*!< RVIdx for HARQ(re)transmission */
#ifdef RG_5GTF /* ToDo:: Anoop need to check for other fields required*/
- U8 vrbgStart;
- U8 numVrbg;
- U16 rbAssign;
- U8 xPDSCHRange;
- U8 SCID;
+ uint8_t vrbgStart;
+ uint8_t numVrbg;
+ uint16_t rbAssign;
+ uint8_t xPDSCHRange;
+ uint8_t SCID;
TfuDciFormat dciFormat; /*!< DCI format for the allocation */
/* ToDo */
#endif
*/
typedef struct rgSchLchAllocInfo
{
- U8 lcId; /*!< Logical channel ID */
- U32 schdData; /*!< Scheduled logical channel data */
+ uint8_t lcId; /*!< Logical channel ID */
+ uint32_t schdData; /*!< Scheduled logical channel data */
} RgSchLchAllocInfo;
/** @brief This structure is part of the downlink HARQ process, this structure
CmLList harqRTTEnt; /*!< Entry into the HARQ RTT timer list */
CmLList harqRetxEnt; /*!< Entry into the harqRetxQ */
- U16 rttIndx; /*!< Current Index into HARQ RTT Q */
- U16 reTxIndx; /*!< Current Index into Re-Tx Q */
- U8 retxTmrReduction; /*!< Due to platform specific timing diff between
+ uint16_t rttIndx; /*!< Current Index into HARQ RTT Q */
+ uint16_t reTxIndx; /*!< Current Index into Re-Tx Q */
+ uint8_t retxTmrReduction; /*!< Due to platform specific timing diff between
DL HARQ processing and DL Scheduling, the
drx retx timer may start at a later time, than
actual. That delay in starting the timer is
*/
struct rgSchDlHqTbCb
{
- U8 tbIdx; /*!< Index of this TB (0/1). Initialized
+ uint8_t tbIdx; /*!< Index of this TB (0/1). Initialized
at HqEnt allocation */
- U32 tbSz; /*!< TB size scheduled for this TB */
- U8 txCntr; /*!< Transmission counter */
- U8 ndi; /*!< New Data Indicator 0 or 1*/
- TknU8 schdTa; /*!< TA scheduled to be sent */
+ uint32_t tbSz; /*!< TB size scheduled for this TB */
+ uint8_t txCntr; /*!< Transmission counter */
+ uint8_t ndi; /*!< New Data Indicator 0 or 1*/
+ TknUInt8 schdTa; /*!< TA scheduled to be sent */
/* CR timer implementation changes*/
- U8 contResCe;
- U8 numLch; /*!< No. of DL Logical Channels scheduled
+ uint8_t contResCe;
+ uint8_t numLch; /*!< No. of DL Logical Channels scheduled
for this TB */
CmLteTimingInfo timingInfo; /*!< This field holds the scheduled time */
RgSchLchAllocInfo lchSchdDataArr[RGSCH_MAX_NUM_DED_LC];
RgSchLchAllocInfo *lchSchdData;
RgSchCcchSchdInfo ccchSchdInfo;/*!< CCCH TX/RETX scheduler Info */
- U8 fbkRepCntr; /*!< Counter to ANRep Feedback */
- U8 fbkRecpRepCntr; /*!< Counter to ANRep Feedback */
+ uint8_t fbkRepCntr; /*!< Counter to ANRep Feedback */
+ uint8_t fbkRecpRepCntr; /*!< Counter to ANRep Feedback */
CmLList anRepLnk[6]; /*!< Links for ANRep we need
these many links to
simultaneously hold the
hqProcs in multiple
subframes. */
RgSchDlSf *crntSubfrm[6]; /*!< Pointer to subframes */
- U8 ackCount; /*!< Counter for ACKs */
- U8 isAckNackDtx; /* ACK or NACK or DTX*/
- U8 nackCount; /* NACK Counter */
- U8 dtxCount; /* DTX Counter */
+ uint8_t ackCount; /*!< Counter for ACKs */
+ uint8_t isAckNackDtx; /* ACK or NACK or DTX*/
+ uint8_t nackCount; /* NACK Counter */
+ uint8_t dtxCount; /* DTX Counter */
RgSchDlGrnt dlGrnt; /*!< Scheduler grant */
Bool taSnt; /*!< TA sent or not */
#ifdef LTE_TDD
CmLteTimingInfo fdbkTime; /*!< Expected feedback time */
- U8 m; /*!< Subframe Order Index within the subframe
+ uint8_t m; /*!< Subframe Order Index within the subframe
downlink association index K */
RgSchTddSfType sfType; /*!< Identifies the first Tx subframe type */
- U8 pucchFdbkIdx;/*!< DL subframe idx for which fdbk is expected */
- U8 dai; /*!< DAI associated with this TB.
+ uint8_t pucchFdbkIdx;/*!< DL subframe idx for which fdbk is expected */
+ uint8_t dai; /*!< DAI associated with this TB.
THis is used for F1BCS resource calulcation */
#ifdef XEON_TDD_SPCL
- U8 initTxNumRbs;/*!< Number of Rbs Allocated in First TX */
+ uint8_t initTxNumRbs;/*!< Number of Rbs Allocated in First TX */
#endif
#endif
/* 3.1 MIMO */
- U8 numLyrs; /*!< Number of layers using which this TB is
+ uint8_t numLyrs; /*!< Number of layers using which this TB is
being transmitted */
RgSchHqTbState state; /*!< State of this Trasport Block */
RgSchDlHqProcCb *hqP; /*!< Reference to the TB container */
/* Freeing up the HARQ proc blocked for
* indefinite time in case of Retx */
- U8 cntrRetxAllocFail; /*!< Number of times allocation failed
+ uint8_t cntrRetxAllocFail; /*!< Number of times allocation failed
for the retransmission of this TB */
#ifdef LTE_ADV
- TknU8 schdSCellActCe; /* !< SCell Act values and whether
+ TknUInt8 schdSCellActCe; /* !< SCell Act values and whether
scheduled or not */
#endif
- U32 firstSchedTime; /*!< First time when the TB was scheduled */
- U8 minRlcReordrTmr; /*!< Min RLC reorder timer of all LCs
+ uint32_t firstSchedTime; /*!< First time when the TB was scheduled */
+ uint8_t minRlcReordrTmr; /*!< Min RLC reorder timer of all LCs
scheduled in this hqP*/
};
CmLList lnk; /*!< To link with other HARQ processes */
RgSchDlHqEnt *hqE; /*!< HARQ entity */
#ifdef LTE_TDD
- U8 txCntr; /*!< Transmission counter */
+ uint8_t txCntr; /*!< Transmission counter */
#endif
- U8 procId; /*!< Harq process ID */
+ uint8_t procId; /*!< Harq process ID */
Void *sch; /*!< Cmn sched Hq control block */
/* 3.1 MIMO */
RgSchDlHqTbCb tbInfo[2]; /*!< TB related information for 1+1(if any) TBs */
RgSchDrxDlHqProcCb drxCb; /*!< DRX control block */
#ifdef TFU_UPGRADE
- U8 tbCnt; /*!< Count of the number TBs being sent with a
+ uint8_t tbCnt; /*!< Count of the number TBs being sent with a
Reception Requesti */
#endif
#ifdef LTEMAC_SPS
- TknU16 spsN1PucchRes; /*!< N1Pucch resource for HARQ process at SPS
+ TknUInt16 spsN1PucchRes; /*!< N1Pucch resource for HARQ process at SPS
ocassions: present only when HqP contains
Data without PDCCH */
#endif
scheduling grant over this hqProc */
Bool cwSwpEnabled; /*!< Set if CW swap enabled */
/*f1b_Sprint3*/
- U8 tpc; /*!< TPC command to be used for Secondary cell
+ uint8_t tpc; /*!< TPC command to be used for Secondary cell
N1PUCCH resource Index*/
/*f1b_Sprint3*/
/*CA Dev Start*/
#ifdef EMTC_ENABLE
Void *emtcHqInfo;/*!< emtc specfic hq info */
#endif
- U8 dlDai; /*!< DL DAI assosciated with this harq proc */
- U8 ulDai; /*!< UL DAI assosciated with this harq proc */
+ uint8_t dlDai; /*!< DL DAI assosciated with this harq proc */
+ uint8_t ulDai; /*!< UL DAI assosciated with this harq proc */
#ifdef BRDCM
/*CA Dev End*/
- U32 isPuschFdbk;
+ uint32_t isPuschFdbk;
#endif
Void * laaCb;
CmLListCp *hqPLst; /*!< pointer to either inUse of free list of hqE */
TfuDciFormat prevDciFormat; /*!< Previous alloction DCI format used for ERR Ind prcessing */
/* LAA DBG Only */
- U32 tbSizeAtEstimate[2];
- U32 tbSizeAtFnlz[2];
- U32 tbSizeOfMvdTb[2];
- U32 itbsAtEstimate[2];
- U32 prbAtEstimate;
+ uint32_t tbSizeAtEstimate[2];
+ uint32_t tbSizeAtFnlz[2];
+ uint32_t tbSizeOfMvdTb[2];
+ uint32_t itbsAtEstimate[2];
+ uint32_t prbAtEstimate;
};
/**
RgSchUeCb *ue; /*!< Parent UE */
CmLListCp free; /*!< List of free HARQ processes */
CmLListCp inUse; /*!< List of in-use HARQ processes */
- U8 maxHqTx; /*!< Maximum number of harq transmissions */
+ uint8_t maxHqTx; /*!< Maximum number of harq transmissions */
RgSchDlHqProcCb *msg4Proc; /*!< Points to MSG4 HARQ process */
#ifdef RGR_V1
/* CR timer changes*/
to identify feedback for CCCH SDU
transmissions done without cont res CE*/
#endif
- U8 numHqPrcs; /*!< Number of HARQ Processes */
+ uint8_t numHqPrcs; /*!< Number of HARQ Processes */
#ifdef LTE_TDD
RgSchDlHqProcCb *procs; /*!< Downlink harq processes */
#else
*/
typedef struct rgSchUeDlTaCb
{
- U16 cfgTaTmr; /*!< Configured TA timer value */
- U8 ta; /*!< TA value for UE */
- U8 numRemSf; /*!< Number of subframes left to apply TA */
+ uint16_t cfgTaTmr; /*!< Configured TA timer value */
+ uint8_t ta; /*!< TA value for UE */
+ uint8_t numRemSf; /*!< Number of subframes left to apply TA */
RgSchTaState state; /*!< Indicates HARQ state for TA */
/*rg003.301[ccpu00121813] ADD added new var*/
Bool outStndngTa; /*!< if new TA is rcvd before it gets
applied at UE*/
- U8 outStndngTaval; /*!< outstanding TA val */
+ uint8_t outStndngTaval; /*!< outstanding TA val */
} RgSchUeDlTaCb;
/**
*/
struct rgSchDlLcCb
{
- U8 lcId; /*!< Logical channel ID */
- U32 bo;
+ uint8_t lcId; /*!< Logical channel ID */
+ uint32_t bo;
RgSchUeCb *ue; /* UE to which this LC belongs to */
/* Not validating DlQos for DCCH */
CmLteLcType lcType; /* Logical channel Type*/
RgrLchSpsCfg dlLcSpsCfg; /*!< SPS configuration for DL logical channel */
#endif
#ifdef CCPU_OPT
- U16 estRlcHdrSz; /*!< Estimated RLC header size */
+ uint16_t estRlcHdrSz; /*!< Estimated RLC header size */
Bool staPduPrsnt; /*!< Indicate the status pdu present or not*/
#endif
- U32 staPduBo; /*!< Indicate the Status PDU BO.
+ uint32_t staPduBo; /*!< Indicate the Status PDU BO.
This amount is already included in original BO */
Void *sch; /*!< Holds Scheduler Info pointer */
- U32 prbsReqd; /*!< PRBs reqd in DL for each UE in MUE scenario*/
+ uint32_t prbsReqd; /*!< PRBs reqd in DL for each UE in MUE scenario*/
CmLList schdLnk; /*!< Link to ueCb inserted in toBeSchdList in DL*/
- U32 oldestSduArrTime; /*!< oldest SDU arrival time for this LC */
+ uint32_t oldestSduArrTime; /*!< oldest SDU arrival time for this LC */
CmLList lcFlowCntrlEnt; /*!<link to Lc in flow Cntrl lst */
CmLList lcPdbFbkLnk; /*!<link to LC in LC flow contrl monitoring lst */
Bool setMaxUlPrio; /*!<set if Poll bit is sent in the PDU */
typedef struct rgSchN1PucchResCb
{
- U16 n1PucchIdx; /* !< N1 resource */
+ uint16_t n1PucchIdx; /* !< N1 resource */
CmLList n1Lnk; /* !< Link for adding into dlsf N1 used list */
}RgSchN1PucchResCb;
typedef struct rgSchN3PucchResCb
{
- U16 n3PucchIdx; /* !< N3 resource */
+ uint16_t n3PucchIdx; /* !< N3 resource */
CmLList n3Lnk; /* !< Link for adding into dlsf N3 used list */
- U8 sCellIdx; /* !< Allocated by which scell */
+ uint8_t sCellIdx; /* !< Allocated by which scell */
}RgSchN3PucchResCb;
typedef struct rgSchSCellN3ResCb
{
- U8 antP0N3ResCount; /* !< Number of N3 res for antenna port 0*/
- U8 antP1N3ResCount; /* !< Number of N3 res for antenna port 0*/
+ uint8_t antP0N3ResCount; /* !< Number of N3 res for antenna port 0*/
+ uint8_t antP1N3ResCount; /* !< Number of N3 res for antenna port 0*/
RgSchN3PucchResCb antP0N3Res[RG_SCH_MAX_NUM_N3PUCCH_PER_UE]; /* !< Antenna Port 0 N3 resources*/
RgSchN3PucchResCb antP1N3Res[RG_SCH_MAX_NUM_N3PUCCH_PER_UE]; /* !< Antenna Port 1 N3 resources*/
}RgSchSCellN3ResCb;
typedef struct rgSchSCellN1ResCb
{
- U8 cw1N1ResCount; /* !< Number of N1 res for CW 1*/
- U8 cw2N1ResCount; /* !< Number of N1 res for CW 2*/
+ uint8_t cw1N1ResCount; /* !< Number of N1 res for CW 1*/
+ uint8_t cw2N1ResCount; /* !< Number of N1 res for CW 2*/
RgSchN1PucchResCb cw1N1Res[RG_SCH_MAX_NUM_N1PUCCH_PER_UE]; /* !< CW1 N1 resources*/
RgSchN1PucchResCb cw2N1Res[RG_SCH_MAX_NUM_N1PUCCH_PER_UE]; /* !< CW2 N1 resources*/
}RgSchSCellN1ResCb;
#ifdef LTE_ADV
typedef struct rgSchN3PucchRes
{
- U16 n3PucchIdx; /* !< N3 resource */
- U8 tpcIdx;
+ uint16_t n3PucchIdx; /* !< N3 resource */
+ uint8_t tpcIdx;
}RgSchN3PucchRes;
#endif
typedef struct rgSchDlHqInfo
{
/*f1b_Sprint3*/
#ifdef LTE_TDD
- U8 numOfCells; /*!<This will be used to store number of unique cells in
+ uint8_t numOfCells; /*!<This will be used to store number of unique cells in
this subframe*/
Bool isSCellPdschPres; /*!< Flag to indicate whether any PDSCH transmission
present in secondary cell. Used for CSI/HARQ collision
Bool isPuschHarqRecpPres;/*!< Flag to indicate pusch recp req is pres or not */
RgrSchFrmt1b3TypEnum uciFrmtTyp; /*!< Store value of format1b or format3.
*/
- U8 totalTbCnt; /*!< This will be used to store total number of TBs
+ uint8_t totalTbCnt; /*!< This will be used to store total number of TBs
across all harqProcs.It will be used to identify
PUCCH format type to be used in this SF*/
CmLList dlSfUeLnk; /*!< list entry into dlsf->ueLst */
typedef struct rgUeMeasGapCfg
{
Bool isMesGapEnabled; /*!< Is Measuremnet gap enabled or disabled */
- U8 gapPrd; /*!< Gap period 40ms/80ms */
- U8 gapOffst; /*!< Gap offset - Vaue is 0 to 1*/
+ uint8_t gapPrd; /*!< Gap period 40ms/80ms */
+ uint8_t gapOffst; /*!< Gap offset - Vaue is 0 to 1*/
} RgUeMeasGapCfg;
/**
typedef struct rgSchUeMeasGapCb
{
Bool isMesGapEnabled;/*!< TRUE if Measurement gap is enabled for this UE */
- U8 isMeasuring; /*!< Set to TRUE during measurement gap */
- U8 gapPrd; /*!< Measurement gap period configuration for the UE */
- U8 gapOffst; /*!< Measurement gap offset for the UE */
+ uint8_t isMeasuring; /*!< Set to TRUE during measurement gap */
+ uint8_t gapPrd; /*!< Measurement gap period configuration for the UE */
+ uint8_t gapOffst; /*!< Measurement gap offset for the UE */
CmLList measQLnk; /*!< To Link to the measurement gap list */
CmLList ackNakQLnk; /*!< To Link to the ACK NACK Rep list */
CmTimer measGapTmr; /*!< Timer for Measurement Gap */
typedef struct rgSchUeAckNakRepCb
{
Bool isAckNackEnabled; /*!< Is ACK/NACK Enabled*/
- U8 isAckNakRep; /*!< Set to TRUE during ACK-NACK repetition prd */
- U8 cfgRepCnt; /*!< Configured value for the repetition counter */
- U8 repCntr; /*!< Actual repetition counter */
- U16 pucchRes; /*!< PUCCH resource for repetition */
+ uint8_t isAckNakRep; /*!< Set to TRUE during ACK-NACK repetition prd */
+ uint8_t cfgRepCnt; /*!< Configured value for the repetition counter */
+ uint8_t repCntr; /*!< Actual repetition counter */
+ uint16_t pucchRes; /*!< PUCCH resource for repetition */
CmTimer ackNakRepUlInactvTmr; /*!< UL Inactive timer for ack-nack repetition */
CmTimer ackNakRepDlInactvTmr; /*!< DL Inactive timer for ack-nack repetition */
CmTimer ackNakRepTmr; /*!< Timer for ack-nack repetition */
{
RgrTxMode oldTMode; /*!< UE's Previous Transmission Mode */
RgrTxMode txMode; /*!< UE's Transmission Mode */
- TknU32 doa; /*!< DOA indicator for this UE */
+ TknUInt32 doa; /*!< DOA indicator for this UE */
Bool puschFdbkVld; /*!< True if Precoding Info in PDCCH has to be
in-accordance with the latest PUSCH report */
TfuDlCqiPuschInfo puschPmiInfo; /*!< PUSCH report details for explicit PMI
*/
typedef struct rgSchCqiRawPuschMode31
{
- U8 wideBCqiCw0; /*!< Length of Wideband CQI Codeword 0 */
- U8 totLenSbDiffCqiCw0; /*!< Length of SubBand Differential CQI Codeword 0 */
- U8 r1WideBCqiCw1; /*!< Length of Wideband CQI Codeword 1 for Rank =1*/
- U8 r1TotLenSbDiffCqiCw1; /*!< Length of SubBand Differential CQI Codeword 1 for Rank = 1*/
- U8 rg1WideBCqiCw1; /*!< Length of Wideband CQI Codeword 1 for Rank > 1*/
- U8 rg1TotLenSbDiffCqiCw1; /*!< Length of SubBand Differential CQI Codeword 1 for Rank > 1*/
- U8 r1PmiBitLen; /*!< Length of PMI Bits for Rank = 1*/
- U8 rg1PmiBitLen; /*!< Length of PMI Bits for Rank > 1*/
+ uint8_t wideBCqiCw0; /*!< Length of Wideband CQI Codeword 0 */
+ uint8_t totLenSbDiffCqiCw0; /*!< Length of SubBand Differential CQI Codeword 0 */
+ uint8_t r1WideBCqiCw1; /*!< Length of Wideband CQI Codeword 1 for Rank =1*/
+ uint8_t r1TotLenSbDiffCqiCw1; /*!< Length of SubBand Differential CQI Codeword 1 for Rank = 1*/
+ uint8_t rg1WideBCqiCw1; /*!< Length of Wideband CQI Codeword 1 for Rank > 1*/
+ uint8_t rg1TotLenSbDiffCqiCw1; /*!< Length of SubBand Differential CQI Codeword 1 for Rank > 1*/
+ uint8_t r1PmiBitLen; /*!< Length of PMI Bits for Rank = 1*/
+ uint8_t rg1PmiBitLen; /*!< Length of PMI Bits for Rank > 1*/
} RgSchCqiRawPuschMode31;
/** @brief This structure that stores the length of Bits that
*/
typedef struct rgSchCqiRawPuschMode30
{
- U8 wideBCqiCw; /*!< Length of Wideband CQI */
- U8 totLenSbDiffCqi; /*!< Length of SubBand Differential CQI */
+ uint8_t wideBCqiCw; /*!< Length of Wideband CQI */
+ uint8_t totLenSbDiffCqi; /*!< Length of SubBand Differential CQI */
} RgSchCqiRawPuschMode30;
/** @brief This structure that stores the length of Bits that
*/
typedef struct rgSchCqiRawPuschMode22
{
- U8 wideBCqiCw0; /*!< Length of Wideband CQI Codeword 0 */
- U8 sBDiffCqiCw0; /*!< Length of SubBand Differential CQI Codeword 0 */
- U8 r1WideBCqiCw1; /*!< Length of Wideband CQI Codeword 1 for Rank =1 */
- U8 r1SbDiffCqiCw1; /*!< Length of SubBand Differential CQI Codeword 1 for Rank =1*/
- U8 rg1WideBCqiCw1; /*!< Length of Wideband CQI Codeword 1 for Rank > 1*/
- U8 rg1SbDiffCqiCw1; /*!< Length of SubBand Differential CQI Codeword 1 for Rank >1*/
- U8 posOfM; /*!< Position of M selected SubBands */
- U8 r1PmiBitLen; /*!< Length of PMI Bits for Rank =1*/
- U8 rg1PmiBitLen; /*!< Length of PMI Bits for Rank >1*/
+ uint8_t wideBCqiCw0; /*!< Length of Wideband CQI Codeword 0 */
+ uint8_t sBDiffCqiCw0; /*!< Length of SubBand Differential CQI Codeword 0 */
+ uint8_t r1WideBCqiCw1; /*!< Length of Wideband CQI Codeword 1 for Rank =1 */
+ uint8_t r1SbDiffCqiCw1; /*!< Length of SubBand Differential CQI Codeword 1 for Rank =1*/
+ uint8_t rg1WideBCqiCw1; /*!< Length of Wideband CQI Codeword 1 for Rank > 1*/
+ uint8_t rg1SbDiffCqiCw1; /*!< Length of SubBand Differential CQI Codeword 1 for Rank >1*/
+ uint8_t posOfM; /*!< Position of M selected SubBands */
+ uint8_t r1PmiBitLen; /*!< Length of PMI Bits for Rank =1*/
+ uint8_t rg1PmiBitLen; /*!< Length of PMI Bits for Rank >1*/
} RgSchCqiRawPuschMode22;
/** @brief This structure that stores the length of Bits that
*/
typedef struct rgSchCqiRawPuschMode20
{
- U8 wideBCqiCw; /*!< Length of Wideband CQI */
- U8 subBandDiffCqi; /*!< Length of SubBand Differential CQI */
- U8 posOfM; /*!< Position of M selected SubBands */
+ uint8_t wideBCqiCw; /*!< Length of Wideband CQI */
+ uint8_t subBandDiffCqi; /*!< Length of SubBand Differential CQI */
+ uint8_t posOfM; /*!< Position of M selected SubBands */
} RgSchCqiRawPuschMode20;
/** @brief This structure that stores the length of Bits that
*/
typedef struct rgSchCqiRawPuschMode12
{
- U8 wideBCqiCw0; /*!< Length of Wideband CQI Codeword 0 */
- U8 r1WideBCqiCw1; /*!< Length of Wideband CQI Codeword 1 for Rank =1*/
- U8 rg1WideBCqiCw1; /*!< Length of Wideband CQI Codeword for Rank > 1 */
- U8 r1TotalPmiBitLen; /*!< Aggregate length of PMI Bits for Rank =1 */
- U8 rg1TotalPmiBitLen; /*!< Aggregate length of PMI Bits for Rank > 1 */
+ uint8_t wideBCqiCw0; /*!< Length of Wideband CQI Codeword 0 */
+ uint8_t r1WideBCqiCw1; /*!< Length of Wideband CQI Codeword 1 for Rank =1*/
+ uint8_t rg1WideBCqiCw1; /*!< Length of Wideband CQI Codeword for Rank > 1 */
+ uint8_t r1TotalPmiBitLen; /*!< Aggregate length of PMI Bits for Rank =1 */
+ uint8_t rg1TotalPmiBitLen; /*!< Aggregate length of PMI Bits for Rank > 1 */
} RgSchCqiRawPuschMode12;
typedef struct rgSchDlCqiRawPusch
{
TfuDlCqiPuschMode mode; /*!< PUSCH CQI mode */
- TknU8 ri; /*!< Rank Indicator for TM 3,4 */
+ TknUInt8 ri; /*!< Rank Indicator for TM 3,4 */
union
{
RgSchCqiRawPuschMode12 mode12Info; /*!< Mode 1-2 information */
typedef struct rgSchPuschRawCqiInfoPerCell
{
- U8 sCellIdx; /*!< Serving cell idx of the cell for
+ uint8_t sCellIdx; /*!< Serving cell idx of the cell for
this cqi info*/
RgSchDlCqiRawPusch puschRawCqiInfo; /*!< Raw CQI Bit Width for PUSCH */
} RgSchPuschRawCqiInfoPerCell;
typedef struct rgSchPuschRawCqiInfoForSCells
{
- U8 numOfCells; /* Num of cells for which Apcqi is comming*/
+ uint8_t numOfCells; /* Num of cells for which Apcqi is comming*/
RgSchPuschRawCqiInfoPerCell cqiBitWidth[CM_LTE_MAX_CELLS];
} RgSchPuschRawCqiInfoForSCells;
typedef struct rgSchPucchRawCqiInfoPerCell
{
- U8 sCellIdx; /*!< Serving cell idx of the cell for
+ uint8_t sCellIdx; /*!< Serving cell idx of the cell for
this cqi info*/
TfuDlCqiPucch pucchRawCqiInfo; /*!< Raw CQI Bit Width for PUCCH */
} RgSchPucchRawCqiInfoPerCell;
CmHashListEnt ueLstEnt; /*!< Hash List entity for UE List */
RgSchUeCb *ue; /*!< Pointer to UECB */
#ifdef LTE_ADV
- U8 sCellIdx; /*!< Serving Cell Index */
- U16 sCellId; /*!< Secondary Cell Id */
+ uint8_t sCellIdx; /*!< Serving Cell Index */
+ uint16_t sCellId; /*!< Secondary Cell Id */
RgSCellStateEnum sCellState; /* !< For holding the current state of the sec cell */
CmLList sCellLnk; /*!< Node for adding this UE in secondary cell */
#endif
RgrUeTxModeCfg txMode; /*!< UE transmission mode in Secondary */
#ifdef LTE_TDD
RgSchTddANInfo *anInfo; /*!< ACK/NACK related Information */
- U8 nextFreeANIdx; /*!< Next Available ANInfo Index */
+ uint8_t nextFreeANIdx; /*!< Next Available ANInfo Index */
#endif
- U8 reqForCqi; /*!< set to True if Aperiodic CQI from UE is required */
+ uint8_t reqForCqi; /*!< set to True if Aperiodic CQI from UE is required */
#ifdef TFU_UPGRADE
RgSchUeACqiCb acqiCb; /* ! < Aperiodic CQI Report Control Block*/
RgSchUePCqiCb cqiCb; /*!< Periodic CQI PMI RI Control Block */
- TknU8 pA; /* PA value configured by RRM
+ TknUInt8 pA; /* PA value configured by RRM
ref: RRC 36.331, 6.3.2, PDSCH-Config*/
/* RgSchUeRawCqiBitWidthInfo rawCqiBitW[MAX_CQI_RI_RPT_BUFF]; */
#endif
- U8 cqiRiWritIdx; /*!< write index to be used whenever CQI/RI reception
+ uint8_t cqiRiWritIdx; /*!< write index to be used whenever CQI/RI reception
request is being filled*/
- U8 cqiRiReadIdx; /*!< Read index to be used whenevr CQI/RI indication
+ uint8_t cqiRiReadIdx; /*!< Read index to be used whenevr CQI/RI indication
is recieved from PHY*/
CmTimer deactTmr; /*!< SCell deactivation timer */
CmTimer actDelayTmr; /*!< SCell timer */
RgSchDlLcCb *lcCb[RGSCH_MAX_LC_PER_UE];/*!< Dedicated Downlink logical channels in
UE */
RgrUeDlCqiCfg ueDlCqiCfg; /*!< UE DL CQI config */
- U8 dlInactvMask; /*!< Bitmask indicating if UE is inactive for DL scheduling */
+ uint8_t dlInactvMask; /*!< Bitmask indicating if UE is inactive for DL scheduling */
RgSchCqiReqField reqForCqi; /*!< set to True if Aperiodic CQI from UE is required */
Bool pCqiPrsnt; /*!< set to True if periodic CQI from UE is expected */
Bool acqiResGrntd; /*!< Aperiodic CQI resources granted in RB Estimation */
RgSchPdcch spsOccPdcch; /*!< PDCCH information for SPS ocassion */
#endif
/* CA dev Start */
- U8 numHqDlSfInfo;
+ uint8_t numHqDlSfInfo;
#ifdef LTE_TDD
RgSchDlHqInfo *dlSfHqInfo;
#else
#endif
#endif
/* Moved from rgSchCmnDlUe to Here, as this shouldn't be present per cell*/
- U32 ambrCfgd; /*!< UE's configured AMBR scaled to Refresh Cycle */
+ uint32_t ambrCfgd; /*!< UE's configured AMBR scaled to Refresh Cycle */
/* CA dev End */
/* Added to restrict max TB Bits in case of more than one CCs for a UE */
- U32 aggTbBits; /*!< Aggregated Transport Block Bits this UE can receive per TTI*/
+ uint32_t aggTbBits; /*!< Aggregated Transport Block Bits this UE can receive per TTI*/
CmLteTimingInfo lstSchTime; /*!< Last Time UE got Scheduled */
} RgSchUeDlCb;
typedef struct rgSchUeHdFddSfInfo
{
- U16 sfn; /*!< Store the sfn for updated state
+ uint16_t sfn; /*!< Store the sfn for updated state
Default Value= 0xffff
*/
- U8 subFrmDir;
+ uint8_t subFrmDir;
/*!< 0x00= DFLT
0x01= DL DATA +(OPT:CNTRL INFO)
0x02= DL CNTRL
Bool srRcvd; /*!< TRUE if SR is received from the UE. */
Bool raRcvd; /*!< TRUE if Random access request is received using a
dedicated preamble for this UE. */
- U16 onDurTmrLen; /*!< Length of onDuration Timer [1 - 200]. */
- U16 drxStartOffset; /*!< Value of the DRX Starting Offset [0 - 2559]. */
+ uint16_t onDurTmrLen; /*!< Length of onDuration Timer [1 - 200]. */
+ uint16_t drxStartOffset; /*!< Value of the DRX Starting Offset [0 - 2559]. */
S16 onDurExpDistance; /*!< Keeps track of actual distance */
- U16 drxRetransTmrLen; /*!< Length of DRX Retransmission timer [1 - 33].*/
+ uint16_t drxRetransTmrLen; /*!< Length of DRX Retransmission timer [1 - 33].*/
- U16 inactvtyTmrLen; /*!< Length of drx-Inactivity Timer [1 - 2560]. */
+ uint16_t inactvtyTmrLen; /*!< Length of drx-Inactivity Timer [1 - 2560]. */
S16 drxInactDistance; /*!< Keeps track of actual distance */
Bool isLongCycle;
- U16 longDrxCycle; /*!< Value of the DRX long cycle [10 - 2560]. */
+ uint16_t longDrxCycle; /*!< Value of the DRX long cycle [10 - 2560]. */
Bool isShortCycleCfgd; /*!< TRUE if short cycle is enabled. */
- U8 shortCycleTmrLen; /*!< Value of DRX short cycle Timer [1-16]. */
- U16 shortDrxCycle; /*!< Value of the DRX short cycle [2 - 640]. */
+ uint8_t shortCycleTmrLen; /*!< Value of DRX short cycle Timer [1-16]. */
+ uint16_t shortDrxCycle; /*!< Value of the DRX short cycle [2 - 640]. */
S16 drxShortCycleDistance; /*!< Keeps track of actual distance */
/* The following elements track current indices into the drxQ present at the
* cell level. These indicies help in fast deletion in case of UE Delete,
* otherwise it might have required a linear search. */
- U16 onDurIndx; /*!< The current index for onDuration Queue. */
- U16 onDurExpIndx; /*!< The current index for onDuration Queue. */
- U16 drxInactvIndx; /*!< The current index for drx-InactityTmr Queue. */
- U16 shortCycleIndx; /*!< The current index for Short Cycle Queue. */
-
- U8 shortCycleTmr; /*!< Counter to keep track of Short DRX Cycle. */
- U32 drxDlInactvMask; /*!< Downlink Mask to track InActivity */
- U32 drxUlInactvMask; /*!< Uplink Mask to track InActivity */
- U32 drxDlInactvMaskPerCell[CM_LTE_MAX_CELLS]; /*!< Downlink Mask to track InActivity per cell */
- U32 drxUlInactvMaskPerCell[CM_LTE_MAX_CELLS]; /*!< Uplink Mask to track InActivity per cell */
+ uint16_t onDurIndx; /*!< The current index for onDuration Queue. */
+ uint16_t onDurExpIndx; /*!< The current index for onDuration Queue. */
+ uint16_t drxInactvIndx; /*!< The current index for drx-InactityTmr Queue. */
+ uint16_t shortCycleIndx; /*!< The current index for Short Cycle Queue. */
+
+ uint8_t shortCycleTmr; /*!< Counter to keep track of Short DRX Cycle. */
+ uint32_t drxDlInactvMask; /*!< Downlink Mask to track InActivity */
+ uint32_t drxUlInactvMask; /*!< Uplink Mask to track InActivity */
+ uint32_t drxDlInactvMaskPerCell[CM_LTE_MAX_CELLS]; /*!< Downlink Mask to track InActivity per cell */
+ uint32_t drxUlInactvMaskPerCell[CM_LTE_MAX_CELLS]; /*!< Uplink Mask to track InActivity per cell */
} RgSchDrxUeCb;
#ifdef RGR_CQI_REPT
typedef struct RgSchCqiInfo
{
- U8 cqiCount; /* To keep track of CQI reports
+ uint8_t cqiCount; /* To keep track of CQI reports
received so far */
RgrUeCqiRept cqiRept[RGR_CQIRPTS_MAXN]; /* Array to maintain CQI reports */
}RgSchCqiInfo;
/*<! Sizes of DCI 0/1/1A/2/2A */
typedef struct rgSchUeDciSize {
#ifdef EMTC_ENABLE
- U8 cmnSize[TFU_DCI_FORMAT_6_2+1]; /*!< DCI 0/1A/6-0A/6-1A final size in common Search Space and scrambled by C-RNTI */
- U8 dedSize[TFU_DCI_FORMAT_6_2+1]; /*!< DCI 0/1/1A/2/2A/6-0A/6-1A final size in UE Search Space and scrambled by C-RNTI */
+ uint8_t cmnSize[TFU_DCI_FORMAT_6_2+1]; /*!< DCI 0/1A/6-0A/6-1A final size in common Search Space and scrambled by C-RNTI */
+ uint8_t dedSize[TFU_DCI_FORMAT_6_2+1]; /*!< DCI 0/1/1A/2/2A/6-0A/6-1A final size in UE Search Space and scrambled by C-RNTI */
#else
- U8 cmnSize[TFU_DCI_FORMAT_1A+1]; /*!< DCI 0/1A final size in common Search Space and scrambled by C-RNTI */
- U8 dedSize[TFU_DCI_FORMAT_2A+1]; /*!< DCI 0/1/1A/2/2A final size in UE Search Space and scrambled by C-RNTI */
+ uint8_t cmnSize[TFU_DCI_FORMAT_1A+1]; /*!< DCI 0/1A final size in common Search Space and scrambled by C-RNTI */
+ uint8_t dedSize[TFU_DCI_FORMAT_2A+1]; /*!< DCI 0/1/1A/2/2A final size in UE Search Space and scrambled by C-RNTI */
#endif
- U8 noUlCcSize[TFU_DCI_FORMAT_2A+1]; /*!< DCI 1/1A final size in UE/Common Search Space when the cell
+ uint8_t noUlCcSize[TFU_DCI_FORMAT_2A+1]; /*!< DCI 1/1A final size in UE/Common Search Space when the cell
is SCell and no corresponding UL CC configured */
} RgSchUeDciSize;
#ifdef RG_PFS_STATS
typedef struct rgSchPerRefreshStats {
- U32 remGbr;
- U32 remDeltaMbr;
- U32 totByteSchd;
- U32 lcSchdOcc;
+ uint32_t remGbr;
+ uint32_t remDeltaMbr;
+ uint32_t totByteSchd;
+ uint32_t lcSchdOcc;
}RgSchPerRefreshStats;
typedef struct rgSchLcStats
{
//Bool isLcCntSet;
- //U32 schdOccCnt;
- U32 ueSchdOcc[CM_LTE_MAX_CELLS];
- U32 gbrSatisfiedCnt;
+ //uint32_t schdOccCnt;
+ uint32_t ueSchdOcc[CM_LTE_MAX_CELLS];
+ uint32_t gbrSatisfiedCnt;
Bool ignoredFirstRefresh;
- U32 gbrRefreshCycleCnt;
- U32 totGbrBytesSchd;
- U32 totMbrBytesSchd;
- U32 achvdFracDataRate;
+ uint32_t gbrRefreshCycleCnt;
+ uint32_t totGbrBytesSchd;
+ uint32_t totMbrBytesSchd;
+ uint32_t achvdFracDataRate;
Bool isRecvdBo;
#define RGSCH_NUM_STATS_PER_REFRESH 50
- U32 startIdx;
- U32 lastIdx;
- U32 favCellCnt[CM_LTE_MAX_CELLS];
+ uint32_t startIdx;
+ uint32_t lastIdx;
+ uint32_t favCellCnt[CM_LTE_MAX_CELLS];
RgSchPerRefreshStats perRefresh[RGSCH_NUM_STATS_PER_REFRESH];
}RgSchLcStats;
typedef struct rgSchCqiStats
{
- U32 totalCqiOcc;
- U32 avgCqi;
+ uint32_t totalCqiOcc;
+ uint32_t avgCqi;
}RgSchCqiStats;
typedef struct rgSchPfsStats
{
RgSchLcStats lcStats[RGSCH_MAX_LC_PER_UE];
- //U32 ueSchdOcc[CM_LTE_MAX_CELLS];
- U32 refreshCycleCnt;
+ //uint32_t ueSchdOcc[CM_LTE_MAX_CELLS];
+ uint32_t refreshCycleCnt;
RgSchCqiStats cqiStats[CM_LTE_MAX_CELLS];
Bool isCaUe;
}RgSchPfsStats;
*/
typedef struct rgSch5gtfUeCb
{
- U8 grpId; // Group Id
- U8 BeamId; // Beam Id of UE
- U8 numCC; // num Carrier configured for UE
- U8 mcs; // MCS configured
- U8 maxPrb; // Max Prb configured for UE
+ uint8_t grpId; // Group Id
+ uint8_t BeamId; // Beam Id of UE
+ uint8_t numCC; // num Carrier configured for UE
+ uint8_t mcs; // MCS configured
+ uint8_t maxPrb; // Max Prb configured for UE
CmLteTimingInfo nxtCqiRiOccn; /*!< Next CQI RI Occn */
- U16 cqiRiPer; /*!< CQI RI periodicity in SFs */
- U8 rank; /*!< Latest Rank Report from UE */
+ uint16_t cqiRiPer; /*!< CQI RI periodicity in SFs */
+ uint8_t rank; /*!< Latest Rank Report from UE */
}RgSch5gtfUeCb;
#endif
*/
struct rgSchUeCb
{
- U32 totalBo; /*!<Sum of DL BO across all logical channels*/
- U32 totalPrbRequired;/*!<Num of PRB reqd to satisfy DL totlBo*/
+ uint32_t totalBo; /*!<Sum of DL BO across all logical channels*/
+ uint32_t totalPrbRequired;/*!<Num of PRB reqd to satisfy DL totlBo*/
/* Added support for SPS*/
#ifdef LTEMAC_SPS
CmHashListEnt spsUeLstEnt; /*!< Hash List entity for UE List */
- U32 spsOccasionCnt; /*!< Total number of SPS occasion cnt*/
+ uint32_t spsOccasionCnt; /*!< Total number of SPS occasion cnt*/
#endif
#ifdef CQI_CONFBITMASK_DROP
- U8 cqiConfBitMask;
- U8 prevCqi;
+ uint8_t cqiConfBitMask;
+ uint8_t prevCqi;
#endif
RgSchRntiLnk *rntiLnk; /*!< Link to RNTI for the UE */
CmLteRnti ueId; /*!< UE identifier */
CmLteTimingInfo relPdcchTxTime; /*!< Time at which release pdcch is
transmitted */
#ifdef LTE_TDD
- U8 relPdcchValm; /*!< 'm' for relPdcch */
+ uint8_t relPdcchValm; /*!< 'm' for relPdcch */
#endif
CmLteTimingInfo relPdcchFbkTiming;/*!< Release PDCCH feedback timing for
the UE: value used by DHM */
indication */
CmLteTimingInfo macCeRptTime;/*!< Timing info of the last received
* MAC CE (BSR/PHR) */
- U32 y[RGSCH_NUM_SUB_FRAMES]; /*!< 'Y' values calculated
+ uint32_t y[RGSCH_NUM_SUB_FRAMES]; /*!< 'Y' values calculated
using C-RNTI and subframe
no based on formula
present in sec 9.1.1 of
*/
struct
{
- U32 bo; /*!< Buffer occupancy for
+ uint32_t bo; /*!< Buffer occupancy for
CCCH */
} dlCcchInfo; /*!< Params for DL
CCCH */
tmr has to be started for DL */
#ifdef TFU_UPGRADE
- U8 validTxAnt; /*! < Tx Antenna selected after computing the CQI among two Antennas*/
+ uint8_t validTxAnt; /*! < Tx Antenna selected after computing the CQI among two Antennas*/
- U8 cqiRiWritIdx; /*!< write index to be used whenever CQI/RI reception
+ uint8_t cqiRiWritIdx; /*!< write index to be used whenever CQI/RI reception
request is being filled*/
- U8 cqiRiReadIdx; /*!< Read index to be used whenevr CQI/RI indication
+ uint8_t cqiRiReadIdx; /*!< Read index to be used whenevr CQI/RI indication
is recieved from PHY*/
RgSchUeRawCqiBitWidthInfo rawCqiBitW[MAX_CQI_RI_RPT_BUFF];
- U8 initNumRbs; /* No. of RBs allocated for UL Data New Transmission */
+ uint8_t initNumRbs; /* No. of RBs allocated for UL Data New Transmission */
#endif
/* ccpu00117452 - MOD - Changed macro name from
#ifdef LTE_L2_MEAS
- U8 qciActiveLCs[LRG_MAX_QCI]; /* This structure has number of active LCs per
+ uint8_t qciActiveLCs[LRG_MAX_QCI]; /* This structure has number of active LCs per
Qci for this UE */ /* L2_COUNTERS */
- U16 ulActiveLCs; /* This is a bitmask - Each bit representing a QCI
+ uint16_t ulActiveLCs; /* This is a bitmask - Each bit representing a QCI
LSB - QCI 1 ... When bit is set, UE has an active
LC for that QCI */
- U16 lastDatIndLCs; /* This is a bitmask - Each bit representing a QCI
+ uint16_t lastDatIndLCs; /* This is a bitmask - Each bit representing a QCI
for which Data for received in UL
LSB - QCI 1 ... When bit is set, UE has an active
LC for that QCI */
#ifdef RGSCH_SPS_STATS
CmLteTimingInfo lastSpsLcBoRptTime;
CmLteTimingInfo lastSpsLcSchedTime;
- U64 absTimeBo;
- U64 absTimeSched;
+ uint64_t absTimeBo;
+ uint64_t absTimeSched;
#endif
- U8 refreshOffset; /*!< UE referesh offset */
- U8 csgMmbrSta; /*!< CSG Membership status configured */
+ uint8_t refreshOffset; /*!< UE referesh offset */
+ uint8_t csgMmbrSta; /*!< CSG Membership status configured */
#ifdef TENB_STATS
TSL2UeStatsCb *tenbStats; /*!< UE Stats Holder */
#endif
PUCCH reception filling */
#endif
#ifdef LTE_ADV
- TknU32 sCellDeactTmrVal; /* !< SCell Deactivation Timer Value */
- U8 f1bCsAVal; /* !< A value mentioned in table 10.12.2.1-1 of 36.213. This will tell
+ TknUInt32 sCellDeactTmrVal; /* !< SCell Deactivation Timer Value */
+ uint8_t f1bCsAVal; /* !< A value mentioned in table 10.12.2.1-1 of 36.213. This will tell
the max number of tbs possible based on TM mode of each configured
scell. It is used only for F1B with channel selection*/
#endif
RgrSchFrmt1b3TypEnum uciFrmtTyp; /*!< Store value of format1bcs or format3.It
is updated from upper layer*/
/*f1b_Sprint3*/
- U8 numSCells; /* !< number of configured SCells */
- U8 cellIdToCellIdxMap[CM_LTE_MAX_CELLS]; /*!< Mapping info of Cell Id to Cell Idx */
+ uint8_t numSCells; /* !< number of configured SCells */
+ uint8_t cellIdToCellIdxMap[CM_LTE_MAX_CELLS]; /*!< Mapping info of Cell Id to Cell Idx */
RgSchUeCellInfo *cellInfo[CM_LTE_MAX_CELLS]; /*!< DL Sec Cell Information */
#ifdef TFU_UPGRADE
RgSchUePCqiCb *nPCqiCb; /*!< Pointer to Periodic Cqi CB for which next CQI is expected*/
RgSchUePCqiCb *nPRiCb; /*!< Pointer to Periodic Cqi CB for which next RI is expected*/
#endif
- U8 remBoCnt; /*!< count of occurence when BO is not fullfilled
+ uint8_t remBoCnt; /*!< count of occurence when BO is not fullfilled
in a TTI */
- U8 *zeroBoCnt; /*!< pointer of count of occurence when BO is
+ uint8_t *zeroBoCnt; /*!< pointer of count of occurence when BO is
Zero */
#ifdef LTE_ADV
Bool isScellExplicitDeAct; /*!< TRUE when SCELL deactivation timer is Infinity/Not configured */
Bool allocCmnUlPdcch; /*!< If this flag is TRUE, allocate PDCCH from Common
search space */
- U8 simulAckNackCQIFormat3; /* !< Flag for simultanious A/N and CQI on PUCCH Format 3 */
+ uint8_t simulAckNackCQIFormat3; /* !< Flag for simultanious A/N and CQI on PUCCH Format 3 */
#endif
RgSchUeDciSize dciSize; /*!< DCI Sizes */
RgrAccessStratumRls accessStratumRls; /*!< UE Release */
{
RgSchLowSapCfgInfo sapCfg; /*!< SAP configuration info */
RgSapSta sapSta; /*!< SAP Status */
- U8 numBndRetries; /*!< Number of Bind Retries */
+ uint8_t numBndRetries; /*!< Number of Bind Retries */
RgSchCellCb *cell; /*!< Cell associated with this SAP */
CmTimer tmrBlk; /*!< Timer Block associated with this SAP */
}RgSchLowSapCb;
typedef struct rgSchConfigIdx
{
- U8 configurationIndex; /* New RGR Cell cfg */
+ uint8_t configurationIndex; /* New RGR Cell cfg */
SfnEnum sfn;
- U8 subframes[10];
+ uint8_t subframes[10];
} RgSchConfigIdx;
typedef struct rgSchRapId
{
- U8 rapId;
+ uint8_t rapId;
CmLteTimingInfo lastAllocPRACHMaskIdx;
} RgSchRapId;
*/
typedef struct rgSchBwRbgInfo
{
- U8 numRbs; /*!< Total number of RBs for which information is
+ uint8_t numRbs; /*!< Total number of RBs for which information is
stored */
- U8 numRbgs; /*!< Number of RBGs for the BW (rounded off to the
+ uint8_t numRbgs; /*!< Number of RBGs for the BW (rounded off to the
closest RBG number */
- U8 rbgSize; /*!< RBG size */
- U8 lastRbgSize; /*!< Last RBG size : in number of RBs */
- U8 rbgSubsetSize[RG_SCH_NUM_RATYPE1_SUBSETS]; /*!< RBG Subset 0,1,2,3
+ uint8_t rbgSize; /*!< RBG size */
+ uint8_t lastRbgSize; /*!< Last RBG size : in number of RBs */
+ uint8_t rbgSubsetSize[RG_SCH_NUM_RATYPE1_SUBSETS]; /*!< RBG Subset 0,1,2,3
sizes: number of RBs
*/
}RgSchBwRbgInfo;
typedef struct sib1Info
{
Buffer *sib1;
- U8 mcs;
- U8 nPrb;
+ uint8_t mcs;
+ uint8_t nPrb;
MsgLen msgLen;
}RgSchSib1Info;
typedef struct siInfo
{
Buffer *si;
- U8 mcs;
- U8 nPrb;
+ uint8_t mcs;
+ uint8_t nPrb;
MsgLen msgLen;
}RgSchSiInfo;
@brief SI Context information per SI. */
typedef struct rgSchSiCtx
{
- U8 siId; /*!< SI Id */
+ uint8_t siId; /*!< SI Id */
CmLteTimingInfo timeToTx; /*!< Time at which the SI for this SI
context need to be scheduled.*/
CmLteTimingInfo maxTimeToTx;/*!< Max Time to TX for this SI */
- U8 retxCntRem; /*!< SI retransmit count remaining */
- U16 i; /*!< Value used to calculate the Riv of SI */
+ uint8_t retxCntRem; /*!< SI retransmit count remaining */
+ uint16_t i; /*!< Value used to calculate the Riv of SI */
Bool warningSiFlag; /*!< Flag for Warning SI */
} RgSchSiCtx;
{
CmLList lnk;
Buffer *pdu;
- U8 mcs;
- U8 nPrb;
+ uint8_t mcs;
+ uint8_t nPrb;
MsgLen msgLen;
}RgSchWarningSiPdu;
/* ccpu00136659: CMAS ETWS design changes */
RgSchWarningSiSeg warningSiMsg;
/*!< Each node contains LList of si segments. */
- U8 siId; /*!< Warning SI ID */
- U8 idx; /*!< Warning SI Idx in RgSchWarningSiInfo */
+ uint8_t siId; /*!< Warning SI ID */
+ uint8_t idx; /*!< Warning SI Idx in RgSchWarningSiInfo */
}RgSchWarningSiInfo;
/**
/* R8 Upgrade */
typedef struct rgSchBiInfo
{
- U16 prevBiTime; /*!< Previous BI Value in ms Calculated and
+ uint16_t prevBiTime; /*!< Previous BI Value in ms Calculated and
Sent in Previous Response */
CmLteTimingInfo biTime; /*!< Time at which previous BI sent */
} RgSchBiInfo;
/* RRM_SP1_START */
typedef struct rgSchQciPrbUsage
{
- U8 qci; /*!< QCI of the Logical Channel */
- U32 dlTotPrbUsed; /*!< total PRB used for DL within one interval*/
- U32 ulTotPrbUsed; /*!< total PRB used for UL within one interval*/
+ uint8_t qci; /*!< QCI of the Logical Channel */
+ uint32_t dlTotPrbUsed; /*!< total PRB used for DL within one interval*/
+ uint32_t ulTotPrbUsed; /*!< total PRB used for UL within one interval*/
}RgSchQciPrbUsage;
/* RRM_SP1_END */
typedef struct rgSchPrbUsage
{
Bool prbRprtEnabld; /*!< reporting is enabled or not*/
- U16 rprtPeriod; /*!< reporting interval to send PRB usage to the
+ uint16_t rprtPeriod; /*!< reporting interval to send PRB usage to the
RRM (in subframes)*/
CmLteTimingInfo startTime; /*!< timing information when the summation is
started in terms of sfn and subframe*/
RgrAbsConfig absCfg; /*!< Configuration of ABS feature */
RgSchAbsSfEnum absDlSfInfo; /*< Flag to indicate current scheduling
DL subframe is ABS subframe or not */
- U8 absPatternDlIdx;
- U32 absLoadTtiCnt;
- U32 absLoadInfo[RGR_ABS_PATTERN_LEN];
+ uint8_t absPatternDlIdx;
+ uint32_t absLoadTtiCnt;
+ uint32_t absLoadInfo[RGR_ABS_PATTERN_LEN];
} RgSchLteAdvFeatureCb;
/* LTE_ADV_FLAG_REMOVED_END */
* mentioned, baseSize is the final size of the DCI */
typedef struct rgSchCellDciSize {
#ifdef EMTC_ENABLE
- U8 baseSize[TFU_DCI_FORMAT_6_2+1]; /*!< Fixed Base Size of DCI 0/1/1A/6-0A/6-1A/6-0B/6-1B/6-2 without any adjustment */
- U8 size[TFU_DCI_FORMAT_6_2+1]; /*!< DCI 0/1A final size in common Search Space and not scrambled by C-RNTI
+ uint8_t baseSize[TFU_DCI_FORMAT_6_2+1]; /*!< Fixed Base Size of DCI 0/1/1A/6-0A/6-1A/6-0B/6-1B/6-2 without any adjustment */
+ uint8_t size[TFU_DCI_FORMAT_6_2+1]; /*!< DCI 0/1A final size in common Search Space and not scrambled by C-RNTI
DCi 3/3A final sizes
DCI 2/2A final sizes
DCI 6-0A/6-0B final sizes
DCI 6-1A/6-1B final sizes
DCI 6-2 final sizes */
#else
- U8 baseSize[TFU_DCI_FORMAT_1A+1]; /*!< Fixed Base Size of DCI 0/1/1A without any adjustment */
- U8 size[TFU_DCI_FORMAT_3A+1]; /*!< DCI 0/1A final size in common Search Space and not scrambled by C-RNTI
+ uint8_t baseSize[TFU_DCI_FORMAT_1A+1]; /*!< Fixed Base Size of DCI 0/1/1A without any adjustment */
+ uint8_t size[TFU_DCI_FORMAT_3A+1]; /*!< DCI 0/1A final size in common Search Space and not scrambled by C-RNTI
DCi 3/3A final sizes
DCI 2/2A final sizes */
#endif
- U8 dci0HopSize; /*!< DCI 0 Hop Size */
+ uint8_t dci0HopSize; /*!< DCI 0 Hop Size */
} RgSchCellDciSize;
/**
*/
typedef struct rgSchMeasCb
{
- U32 dlTpt; /*!< DL Bytes served in a fixed time PERIOD */
- U32 dlBytesCnt; /*!< DL Bytes served from start of this time period */
- U32 ulTpt; /*!< DL Bytes served in a fixed time PERIOD */
- U32 ulBytesCnt; /*!< UL Bytes served from start of this time period */
+ uint32_t dlTpt; /*!< DL Bytes served in a fixed time PERIOD */
+ uint32_t dlBytesCnt; /*!< DL Bytes served from start of this time period */
+ uint32_t ulTpt; /*!< DL Bytes served in a fixed time PERIOD */
+ uint32_t ulBytesCnt; /*!< UL Bytes served from start of this time period */
}RgSchMeasCb;
/**
*/
typedef struct rgSchThrsldsCb
{
- U8 maxDlItbs;
- U8 maxUlItbs;
+ uint8_t maxDlItbs;
+ uint8_t maxUlItbs;
}RgSchThrsldsCb;
/**
* @brief
*/
typedef struct rgSchCpuOvrLdCntrlCb
{
- U8 cpuOvrLdIns;
- U32 tgtDlTpt;
- U32 tgtUlTpt;
- U8 dlNxtIndxDecNumUeTti; /*!< Total DL num UE per TTI reduction instruction applied */
- U8 ulNxtIndxDecNumUeTti; /*!< Total UL num UE per TTI reduction instruction applied */
- U8 maxUeNewTxPerTti[10]; /*!< list of subframe where DL num UE per TTI reduction applied */
- U8 maxUeNewRxPerTti[10]; /*!< list of subframe where UL num UE per TTI reduction applied */
+ uint8_t cpuOvrLdIns;
+ uint32_t tgtDlTpt;
+ uint32_t tgtUlTpt;
+ uint8_t dlNxtIndxDecNumUeTti; /*!< Total DL num UE per TTI reduction instruction applied */
+ uint8_t ulNxtIndxDecNumUeTti; /*!< Total UL num UE per TTI reduction instruction applied */
+ uint8_t maxUeNewTxPerTti[10]; /*!< list of subframe where DL num UE per TTI reduction applied */
+ uint8_t maxUeNewRxPerTti[10]; /*!< list of subframe where UL num UE per TTI reduction applied */
}RgSchCpuOvrLdCntrlCb;
/**
CmLteCellId cellId; /*!< Cell ID */
Inst instIdx; /*!< Index of the scheduler instance */
Inst macInst; /*!< Index of the MAC instance */
- U8 schTickDelta; /* 4UE_TTI_DELTA */
+ uint8_t schTickDelta; /* 4UE_TTI_DELTA */
Bool stopSiSch; /*!< If TRUE Bcch,Pcch Scheduling is not done */
- U8 stopDlSch; /*!< If TRUE DL scheduling is not done */
+ uint8_t stopDlSch; /*!< If TRUE DL scheduling is not done */
Bool stopUlSch; /*!< If TRUE UL scheduling is not done */
Bool isDlDataAllwd; /*!< FALSE for Uplink subframes */
RgrDlHqCfg dlHqCfg; /*!< HARQ related configuration */
Bool isCpUlExtend; /*!< Cyclic prefix : TRUE-extended/FALSE-normal */
Bool isCpDlExtend; /*!< Cyclic prefix : TRUE-extended/FALSE-normal */
- U8 numTxAntPorts; /*!< Number of Tx antenna ports */
+ uint8_t numTxAntPorts; /*!< Number of Tx antenna ports */
RgrBwCfg bwCfg; /*!< Bandwidth Configuration */
- U8 pbchRbStart; /*!< Indicates the Start RB of the center 6 RBs of DL BW */
- U8 pbchRbEnd; /*!< Indicates the Start RB of the center 6 RBs of DL BW */
- U8 numCellRSPerSf; /*!< Indicates the number of cell specific
+ uint8_t pbchRbStart; /*!< Indicates the Start RB of the center 6 RBs of DL BW */
+ uint8_t pbchRbEnd; /*!< Indicates the Start RB of the center 6 RBs of DL BW */
+ uint8_t numCellRSPerSf; /*!< Indicates the number of cell specific
Reference symbols in a Subframe */
RgrPhichCfg phichCfg; /*!< PHICH Config Information */
RgrPucchCfg pucchCfg; /*!< PUCCH Config Information */
CmLteTimingInfo rcpReqTime; /*!< SFN, SF for UL reception Request */
RgSchCfgCfb rgCfgInfo; /*!< Control block for configuration related
information */
- U8 ulCcchId; /*!< LcId for uplink CCCH */
- U8 dlCcchId; /*!< LcId for downlink CCCH */
+ uint8_t ulCcchId; /*!< LcId for uplink CCCH */
+ uint8_t dlCcchId; /*!< LcId for downlink CCCH */
RgSchClcDlLcCb cmnLcCb[RGSCH_MAX_CMN_LC_CB]; /*!< BCCH/PCCH logical channel control block */
CmHashListCp ueLst; /*!< Hash list of UE control
blocks: RgSchUeCb */
CmLListCp pdcchLst; /*!< List of free RgSchPdcch structures */
CmTqCp tqCp;
CmTqType tq[RGSCH_UE_TQ_SIZE];
- U8 crntSfIdx; /*!< Current index for allocation */
+ uint8_t crntSfIdx; /*!< Current index for allocation */
#ifdef LTE_TDD
RgInfSfAlloc sfAllocArr[RGSCH_SF_ALLOC_SIZE]; /*!< Subframe Allocation
info to be sent to MAC */
#endif
RgInfRlsHqInfo rlsHqArr[RGSCH_NUM_SUB_FRAMES]; /*!< Harq Release
info to be sent to MAC */
- U8 crntHqIdx; /*!< Current index for Harq release info */
+ uint8_t crntHqIdx; /*!< Current index for Harq release info */
RgSchLowSapCb *tfuSap;
/* Added for sending TTI tick to RRM */
#if (defined(RGR_RRM_TICK) || defined(RGR_CQI_REPT))
RgSchUpSapCb *rgmSap; /*!< Pointer to the cell's RGM SAP
Control Block */
#ifdef RGR_RRM_TICK
- U8 rrmTtiIndPrd; /*!< Periodicity of TTI indication from
+ uint8_t rrmTtiIndPrd; /*!< Periodicity of TTI indication from
MAC towards RGR user. Range [1-255]. A
value of 1 means one tick per System
Frame and 2 means one tick per 2 System
RgSchAckNakRepCb ackNakRepCb; /*!< Ack-Nack Repetition control block */
#ifdef LTE_TDD
RgSchTddRachRspLst *rachRspLst; /*!< List of awaiting RACH responses */
- U8 numDlSubfrms; /*!< Number of DL subframes */
- U8 ulDlCfgIdx; /*!< UL-DL Configuration Index */
- U8 ackNackFdbkArrSize; /*!< Maximum Number of Ack/Nack
+ uint8_t numDlSubfrms; /*!< Number of DL subframes */
+ uint8_t ulDlCfgIdx; /*!< UL-DL Configuration Index */
+ uint8_t ackNackFdbkArrSize; /*!< Maximum Number of Ack/Nack
feedback information to be
stored */
S8 tddHqSfnCycle; /*!< Counter to keep track of the
N1 resources for scell in case of F1B CS */
#else
RgSchDlSf *subFrms[RGSCH_NUM_DL_slotS];
- U16 nCce;
+ uint16_t nCce;
#endif
RgSchDynCfiCb dynCfiCb; /*!< Dynamic CFI control block */
/* Changes for MIMO feature addition */
- U8 noOfRbgs; /*!< Number of RBGs for this bw */
- U8 rbgSize; /*!< RBG Size */
+ uint8_t noOfRbgs; /*!< Number of RBGs for this bw */
+ uint8_t rbgSize; /*!< RBG Size */
/* Added support for SPS*/
#ifdef LTEMAC_SPS
RgSchBwRbgInfo dlBwRbgInfo; /*!< RBG information for the configured
RgSchTbCnt dlUlTbCnt; /*!< Count of DL and UL TB transmitteed and Faulty
TB (for wich NACK is received) */
#endif /* LTE_L2_MEAS */
- U8 ulAvailBw; /*!< Total Uplink band width available
+ uint8_t ulAvailBw; /*!< Total Uplink band width available
for this sub frame */
#ifdef TFU_UPGRADE
RgSchPerPucchCb pCqiSrsSrLst[RG_SCH_PCQI_SRS_SR_TRINS_SIZE];
RgSchSiCb siCb; /*!< SI Control Block */
#endif /*RGR_SI_SCH */
RgSchPrbUsage prbUsage; /*!< measures average PRB usage for configured interval*/
- U16 t300TmrVal; /*!< t300Timer value configured in Frames */
+ uint16_t t300TmrVal; /*!< t300Timer value configured in Frames */
/* LTE_ADV_FLAG_REMOVED_START */
TknStrOSXL rntpAggrInfo; /*!< RNTP Info */
RgrLoadInfReqInfo loadInfReqInfo; /*!< Consists startRb & endRb
RgSchLteAdvFeatureCb lteAdvCb; /*!< Control block for LTE Adv
features */
/* LTE_ADV_FLAG_REMOVED_END */
-
U32 dlNumUeSchedPerTti[RG_MAX_NUM_UE_PER_TTI]; /*!<DL mUe/Tti histograms*/
-
U32 ulNumUeSchedPerTti[RG_MAX_NUM_UE_PER_TTI]; /*!<UL mUe/Tti histograms*/
+
uint32_t dlNumUeSchedPerTti[RG_MAX_NUM_UE_PER_TTI]; /*!<DL mUe/Tti histograms*/
+
uint32_t ulNumUeSchedPerTti[RG_MAX_NUM_UE_PER_TTI]; /*!<UL mUe/Tti histograms*/
Bool overLoadBackOffEnab; /*!< Overload Rach Backoff enable/disable */
- U8 overLoadBackOffval; /*!< Overload Rach BackOff value */
- U8 refreshUeCnt[RGSCH_MAX_REFRESH_OFFSET]; /*! To maintain number of UE refreshed per subframe */
- U8 minDlResNonCsg; /*!< Minimum DL resources reserved for Non CSG UEs */
- U8 minUlResNonCsg; /*!< Minimum UL resources reserved for CSG UEs */
+ uint8_t overLoadBackOffval; /*!< Overload Rach BackOff value */
+ uint8_t refreshUeCnt[RGSCH_MAX_REFRESH_OFFSET]; /*! To maintain number of UE refreshed per subframe */
+ uint8_t minDlResNonCsg; /*!< Minimum DL resources reserved for Non CSG UEs */
+ uint8_t minUlResNonCsg; /*!< Minimum UL resources reserved for CSG UEs */
Bool isAutoCfgModeEnb; /*!< Indicates Auto config of TM mode is enabled or
disabled. True - Enabled, False - Disabled */
CmLListCp lcMonitorLst; /*LC Lst used for flow cntrl */
-
U32 prbCnt; /*!<PRB usage in flow control interval*/
- U32 maxPrbCnt; /*!<Max PRB cnt after which Flow Cntrl
+
uint32_t prbCnt; /*!<PRB usage in flow control interval*/
+ uint32_t maxPrbCnt; /*!<Max PRB cnt after which Flow Cntrl
can be triggered */
RgSchCpuOvrLdCntrlCb cpuOvrLdCntrl; /*!< CPU Overload control state info */
RgSchMeasCb measurements; /*!< Cell level measurements */
Bool isPucchFormat3Sptd;
#endif
#ifdef RG_PFS_STATS
- U32 totalPrb;
- U32 totalTime;
+ uint32_t totalPrb;
+ uint32_t totalTime;
#endif
Void * laaCb;
#ifdef EMTC_ENABLE
/* TODO:: Below members need to be moved
* to emtc specific files and have void *
* here */
- U8 emtcEnable;
+ uint8_t emtcEnable;
Void *emtcCb;
RgSchRntiDb emtcRntiDb; /*!< RNTIs DB: range of rntis to be managed by MAC */
#endif
*/
typedef struct rgSchGenCb
{
- U8 tmrRes; /*!< Timer resolution */
+ uint8_t tmrRes; /*!< Timer resolution */
RgSchLmResponse *bndCfmResp; /*!< Respones value for Bind Confirm */
RgSchLmResponse ustaResp; /*!< Respones value for Alarms */
- U8 startCellId; /*!< Starting Cell Id */
+ uint8_t startCellId; /*!< Starting Cell Id */
#ifdef LTE_ADV
Bool forceCntrlSrbBoOnPCel; /*!< value 1 means force scheduling
of RLC control BO and SRB BO on
typedef struct rgSchDynTddSfType
{
- U8 sfType; /*!< 0= NOT Defined
+ uint8_t sfType; /*!< 0= NOT Defined
1= DL Cntrl + DL Data
2= DL Cntrl + DL Data + UL Cntrl
3= DL Cntrl + UL Data
typedef struct rgSchDynTddCb
{
Bool isDynTddEnbld; /*!< Is dynamic TDD enabled */
- U8 crntDTddSfIdx; /*!< Pivot Index corresponding
+ uint8_t crntDTddSfIdx; /*!< Pivot Index corresponding
cell's current subframe */
RgSchDynTddSfType sfInfo[RG_SCH_DYNTDD_MAX_SFINFO];
}RgSchDynTddCb;
{
TskInit rgSchInit; /*!< Task Init info */
RgSchGenCb genCfg; /*!< General Config info */
- U8 numSaps; /*!< Num RGR Saps = Num TFU Saps */
+ uint8_t numSaps; /*!< Num RGR Saps = Num TFU Saps */
RgSchUpSapCb *rgrSap; /*!< RGR SAP Control Block */
RgSchLowSapCb *tfuSap; /*!< TFU SAP Control Block */
RgSchUpSapCb *rgmSap; /*!< TFU SAP Control Block */
CmTqCp tmrTqCp; /*!< Timer Task Queue Cntrl Point */
CmTqType tmrTq[RGSCH_TQ_SIZE]; /*!< Timer Task Queue */
- U8 rgSchDlDelta; /* 4UE_TTI_DELTA */
- U8 rgSchCmnDlDelta;
- U8 rgSchUlDelta;
+ uint8_t rgSchDlDelta; /* 4UE_TTI_DELTA */
+ uint8_t rgSchCmnDlDelta;
+ uint8_t rgSchUlDelta;
RgSchCellCb *cells[CM_LTE_MAX_CELLS]; /* Array to store cellCb ptr */
RgrSchedEnbCfg rgrSchedEnbCfg; /*!< eNB level RR/PFS Config */
Void *rgSchEnbPfsDl; /*!< eNB level PFS DL Block */
RgSchRaState raState; /*!< Random access state */
struct
{
- U32 bo; /*!< Buffer occupancy for CCCH */
+ uint32_t bo; /*!< Buffer occupancy for CCCH */
} dlCcchInfo; /*!< Params for DL CCCH */
- U8 msg3HqProcId; /*!< Msg3 Harq Process ID */
+ uint8_t msg3HqProcId; /*!< Msg3 Harq Process ID */
/*ccpu00128820 - DEL - msg3HqProcRef is delete for Msg3 alloc double delete issue*/
RgSchUlHqProcCb msg3HqProc; /*!< msg3HqProcRef points to this initially */
RgSchUeCb *ue; /*!< NULL initially */
Bool toDel; /*!< To delete this RaCb after msg4 reject */
- TknU8 phr; /*!< To store the PHR, if received along with
+ TknUInt8 phr; /*!< To store the PHR, if received along with
Msg3 */
CmLList rspLnk; /*!< Used to link RACB to a frame for resp */
- U8 rapId; /*!< RAP ID */
- TknU16 ta; /*!< Timing Adjustment */
+ uint8_t rapId; /*!< RAP ID */
+ TknUInt16 ta; /*!< Timing Adjustment */
RgSchUlGrnt msg3Grnt; /*!< Msg3 grant as given by the UL Sched */
- U32 y[RGSCH_NUM_SUB_FRAMES]; /*!< y values using tmpCrnti by DLSCHED */
+ uint32_t y[RGSCH_NUM_SUB_FRAMES]; /*!< y values using tmpCrnti by DLSCHED */
RgSchDlHqEnt *dlHqE; /*!< DL HARQ module */
- U8 ccchCqi; /*!< DL Cqi obtained from RaReq and Used for CCCH */
+ uint8_t ccchCqi; /*!< DL Cqi obtained from RaReq and Used for CCCH */
RgSchDlRbAlloc rbAllocInfo; /*!< RB Allocation Info for MSG4 Trans/Retrans */
/* PHR handling for MSG3 */
CmLteTimingInfo msg3AllocTime; /*!< Allocation time for msg3 grant */
CmLteTimingInfo expiryTime; /*!< Expiry time for Guard/Contention
Resolution timers */
- U32 ccchSduBo; /*!<To store CCCH SDU BO if it arrives while
+ uint32_t ccchSduBo; /*!<To store CCCH SDU BO if it arrives while
ContRes CE is transmitting or retransmitting*/
#endif
#ifdef EMTC_ENABLE
*/
struct rgSchErrInfo
{
- U8 errType; /*!< Error Type */
- U16 errCause; /*!< Cause of Error */
+ uint8_t errType; /*!< Error Type */
+ uint16_t errCause; /*!< Cause of Error */
};
/* Global Variables */
#ifdef LTE_TDD
#ifdef LTEMAC_SPS
-EXTERN U8 rgSchTddSpsDlMaxRetxTbl[RGSCH_MAX_TDD_UL_DL_CFG];
+EXTERN uint8_t rgSchTddSpsDlMaxRetxTbl[RGSCH_MAX_TDD_UL_DL_CFG];
#endif
-typedef U8 RgSchTddUlDlSubfrmTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchTddUlDlSubfrmTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
EXTERN RgSchTddUlDlSubfrmTbl rgSchTddUlDlSubfrmTbl;
typedef struct rgSchTddSplSubfrmInfo RgSchTddSplSubfrmInfoTbl[RGSCH_MAX_TDD_SPL_SUBFRM_CFG];
/* ccpu00132282 */
EXTERN RgSchTddDlAscSetIdxKTbl rgSchTddDlHqPucchResCalTbl;
-typedef U8 RgSchTddPhichMValTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchTddPhichMValTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
EXTERN RgSchTddPhichMValTbl rgSchTddPhichMValTbl;
-typedef U8 RgSchTddKPhichTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchTddKPhichTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
EXTERN RgSchTddKPhichTbl rgSchTddKPhichTbl;
typedef RgSchTddPhichOffInfo RgSchTddPhichOffInfoTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
-typedef U8 RgSchTddUlAscIdxKDashTbl[RGSCH_MAX_TDD_UL_DL_CFG-1][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchTddUlAscIdxKDashTbl[RGSCH_MAX_TDD_UL_DL_CFG-1][RGSCH_NUM_SUB_FRAMES];
EXTERN RgSchTddUlAscIdxKDashTbl rgSchTddUlAscIdxKDashTbl;
#ifdef LTEMAC_SPS
-typedef U8 RgSchTddInvDlAscSetIdxTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchTddInvDlAscSetIdxTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
EXTERN RgSchTddInvDlAscSetIdxTbl rgSchTddInvDlAscSetIdxTbl;
#endif
-typedef U8 RgSchTddPuschTxKTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchTddPuschTxKTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
EXTERN RgSchTddPuschTxKTbl rgSchTddPuschTxKTbl;
-typedef U8 RgSchTddUlNumHarqProcTbl[RGSCH_MAX_TDD_UL_DL_CFG];
+typedef uint8_t RgSchTddUlNumHarqProcTbl[RGSCH_MAX_TDD_UL_DL_CFG];
EXTERN RgSchTddUlNumHarqProcTbl rgSchTddUlNumHarqProcTbl;
-typedef U8 RgSchTddDlNumHarqProcTbl[RGSCH_MAX_TDD_UL_DL_CFG];
+typedef uint8_t RgSchTddDlNumHarqProcTbl[RGSCH_MAX_TDD_UL_DL_CFG];
EXTERN RgSchTddDlNumHarqProcTbl rgSchTddDlNumHarqProcTbl;
/* Number of ACK/NACK Feedback to be stored based on UL-DL Configuration Index */
-typedef U8 RgSchTddANFdbkMapTbl[RGSCH_MAX_TDD_UL_DL_CFG];
+typedef uint8_t RgSchTddANFdbkMapTbl[RGSCH_MAX_TDD_UL_DL_CFG];
EXTERN RgSchTddANFdbkMapTbl rgSchTddANFdbkMapTbl;
/* Number of UL subframes */
EXTERN RgSchTddMaxUlSubfrmTbl rgSchTddMaxUlSubfrmTbl;
/* Number of UL subframes */
-typedef U8 RgSchTddNumUlSubfrmTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchTddNumUlSubfrmTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
EXTERN RgSchTddNumUlSubfrmTbl rgSchTddNumUlSubfrmTbl;
/* Number of low UL subframes Indices*/
-typedef U8 RgSchTddLowUlSubfrmIdxTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchTddLowUlSubfrmIdxTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
EXTERN RgSchTddLowUlSubfrmIdxTbl rgSchTddLowUlSubfrmIdxTbl;
/* Number of high UL subframes Indices*/
-typedef U8 RgSchTddHighUlSubfrmIdxTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchTddHighUlSubfrmIdxTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
EXTERN RgSchTddHighUlSubfrmIdxTbl rgSchTddHighUlSubfrmIdxTbl;
/* Number of low DL subframes Indices*/
-typedef U8 RgSchTddLowDlSubfrmIdxTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchTddLowDlSubfrmIdxTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
EXTERN RgSchTddLowDlSubfrmIdxTbl rgSchTddLowDlSubfrmIdxTbl;
/* Number of high DL subframes Indices*/
-typedef U8 RgSchTddHighDlSubfrmIdxTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchTddHighDlSubfrmIdxTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
EXTERN RgSchTddHighDlSubfrmIdxTbl rgSchTddHighDlSubfrmIdxTbl;
/* Number of DL subframes and Special subframes with DwPTS */
-typedef U8 RgSchTddNumDlSubfrmTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchTddNumDlSubfrmTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
EXTERN RgSchTddNumDlSubfrmTbl rgSchTddNumDlSubfrmTbl;
/* Number of DL subframes and Special subframes with DwPTS */
typedef RgSchTddSubfrmInfo RgSchTddMaxDlSubfrmTbl[RGSCH_MAX_TDD_UL_DL_CFG];
EXTERN RgSchTddMaxDlSubfrmTbl rgSchTddMaxDlSubfrmTbl;
-typedef U8 RgSchTddMsg3SubfrmTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchTddMsg3SubfrmTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
EXTERN RgSchTddMsg3SubfrmTbl rgSchTddMsg3SubfrmTbl;
#ifdef LTEMAC_SPS
typedef RgSchTddMsg3SubfrmTbl RgSchTddSpsUlRsrvTbl;
EXTERN RgSchTddMsg3SubfrmTbl rgSchTddSpsUlRsrvTbl;
#endif
-typedef U8 RgSchTddRlsDlSubfrmTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
+typedef uint8_t RgSchTddRlsDlSubfrmTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
EXTERN RgSchTddRlsDlSubfrmTbl rgSchTddRlsDlSubfrmTbl;
-EXTERN U8 rgSchTddPucchTxTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
+EXTERN uint8_t rgSchTddPucchTxTbl[RGSCH_MAX_TDD_UL_DL_CFG][RGSCH_NUM_SUB_FRAMES];
#endif
#ifdef LTE_ADV
EXTERN RgSchCellCb* rgSchUtlGetCellCb ARGS((
Inst inst,
-U16 cellId
+uint16_t cellId
));
EXTERN Void rgSCHSCellDlUeReset ARGS((
EXTERN Void rgSCHSCellHndlFdbkInd ARGS((
RgSchDlHqProcCb *hqP,
-U8 tbIdx,
-U8 fdbk,
+uint8_t tbIdx,
+uint8_t fdbk,
Bool maxHqRetxReached
));
EXTERN S16 rgSCHSCellTrigActDeact ARGS((
RgSchCellCb *cell,
RgSchUeCb *ueCb,
-U8 sCellIdx,
-U8 action
+uint8_t sCellIdx,
+uint8_t action
));
EXTERN S16 rgSCHSCellDelUe ARGS((
EXTERN Void rgSCHSCellSelectAndActDeAct ARGS ((
RgSchCellCb *PCell,
RgSchUeCb *ueCb,
-U8 action
+uint8_t action
));
EXTERN S16 rgSCHSCellPCqiCfg ARGS((
RgSchUeCb *ueCb,
RgrUePrdDlCqiCfg *cqiCfg,
CmLteUeCategory ueCat,
-U8 sCellIdx
+uint8_t sCellIdx
));
EXTERN Void rgSCHUtlSndUeSCellDel2Mac ARGS ((
CmLteRnti rnti
));
-EXTERN U8 rgSCHUtlGetMaxTbSupp ARGS ((
+EXTERN uint8_t rgSCHUtlGetMaxTbSupp ARGS ((
RgrTxMode txMode
));
#endif/*LTE_ADV*/
RgSchCellCb *cellCb,
Ptr cb,
S16 tmrEvnt,
- U32 tmrVal));
+ uint32_t tmrVal));
EXTERN Void rgSCHTmrStopTmr ARGS((
RgSchCellCb *cellCb,
* APIs exposed by LMM
*/
EXTERN S16 rgSCHLmmStartTmr ARGS ((Inst instId, S16 tmrEvnt,
- U32 tmrVal, PTR cb));
+ uint32_t tmrVal, PTR cb));
EXTERN S16 rgSCHLmmStopTmr ARGS((Inst instId, S16 tmrEvnt, PTR cb));
EXTERN S16 rgSCHLmmTmrExpiry ARGS((PTR cb, S16 tmrEvnt));
/* This function invokes a Control Confirmation to the LM from scheduler. */
-EXTERN S16 rgSCHLmmBndCfm ARGS((Pst *pst, SuId suId, U8 status));
+EXTERN S16 rgSCHLmmBndCfm ARGS((Pst *pst, SuId suId, uint8_t status));
EXTERN S16 schActvTmr ARGS((Ent entity, Inst inst));
/* To send a Unsolicited Status Indication to Layer Manager */
-EXTERN S16 rgSCHLmmStaInd ARGS((Inst instId, U16 category, U16 event,
- U16 cause, RgUstaDgn *dgn));
+EXTERN S16 rgSCHLmmStaInd ARGS((Inst instId, uint16_t category, uint16_t event,
+ uint16_t cause, RgUstaDgn *dgn));
EXTERN S16 schActvTsk ARGS((Pst *pst, Buffer *mBuf));
EXTERN Void SchFillCfmPst ARGS((Pst *reqPst,Pst *cfmPst,RgMngmt *cfm));
-EXTERN U16 SchInstCfg ARGS((RgCfg *cfg, Inst inst));
+EXTERN uint16_t SchInstCfg ARGS((RgCfg *cfg, Inst inst));
EXTERN Void printSchCellInfo ARGS((Void));
EXTERN Void rgSCHLmmGenCntrl ARGS((RgMngmt *cntrl,RgMngmt *cfm,Pst *cfmPst));
EXTERN Void rgSCHLmmSapCntrl ARGS((RgMngmt *cntrl,RgMngmt *cfm,Pst *cfmPst));
RgSchCb *instCb, SpId spId,
RgrCfgTransId transId, RgrSiCfgReqInfo *cfgReqInfo));
EXTERN S16 rgSCHUtlRgrSiCfgCfm ARGS ((Inst inst, SpId spId,
- RgrCfgTransId transId,U8 status));
+ RgrCfgTransId transId,uint8_t status));
EXTERN S16 rgSCHGomHndlWarningSiCfg ARGS(( Region reg, Pool pool,
RgSchCb *instCb, SpId spId, RgrCfgTransId transId,
RgrWarningSiCfgReqInfo *warningSiCfgReqInfo));
EXTERN Void rgSCHGomHndlWarningSiStopReq ARGS(( Region reg, Pool pool,
- RgSchCb *instCb, U8 siId,
+ RgSchCb *instCb, uint8_t siId,
RgrCfgTransId transId, SpId spId));
-EXTERN S16 rgSCHUtlRgrWarningSiCfgCfm ARGS ((Inst inst, SpId spId, U8 siId,
- RgrCfgTransId transId,U8 status));
+EXTERN S16 rgSCHUtlRgrWarningSiCfgCfm ARGS ((Inst inst, SpId spId, uint8_t siId,
+ RgrCfgTransId transId,uint8_t status));
#endif /* RGR_SI_SCH */
/* LTE_ADV_FLAG_REMOVED_START */
EXTERN S16 rgSchDSFRRntpInfoInit ARGS ((TknStrOSXL *rntpPtr, RgSchCellCb *cell,
- U16 bw));
+ uint16_t bw));
EXTERN S16 rgSchDSFRRntpInfoFree ARGS ((TknStrOSXL *rntpPtr, RgSchCellCb *cell,
- U16 bw));
+ uint16_t bw));
EXTERN S16 rgSchUpdtRNTPInfo ARGS ((RgSchCellCb *cell, RgSchDlSf *sf,
RgrLoadInfReqInfo *loadInfReq));
EXTERN S16 rgSCHCfgVldtRgrLoadInf ARGS(( Inst inst, RgrLoadInfReqInfo *loadInfReq,
RgSchCellCb *cell,
RgrUeCfg *ueCfg
));
-EXTERN S16 rgSCHRamProcRaReq ARGS((U8 raReqCnt, RgSchCellCb *cell, CmLteRnti raRnti,
+EXTERN S16 rgSCHRamProcRaReq ARGS((uint8_t raReqCnt, RgSchCellCb *cell, CmLteRnti raRnti,
TfuRachInfo *raReqInd,
CmLteTimingInfo timingInfo,
RgSchUeCb *ue,
#ifdef LTE_TDD
EXTERN S16 rgSCHRamDelRaReq ARGS((RgSchCellCb *cell,
CmLteTimingInfo timingInfo,
- U8 raIdx));
+ uint8_t raIdx));
#endif
EXTERN S16 rgSCHRamAddToRaInfoSchdLst(RgSchCellCb *cell, RgSchRaCb *raCb);
CmLteTimingInfo frm));
#else /* MAC_SCH_STATS */
EXTERN Void rgSCHUhmProcDatInd ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
- CmLteTimingInfo frm, U8 cqi));
+ CmLteTimingInfo frm, uint8_t cqi));
#endif
EXTERN Void rgSCHUhmProcMsg3DatInd ARGS((RgSchUlHqProcCb *hqProc));
EXTERN Void rgSCHUhmProcMsg3Failure ARGS((RgSchUlHqProcCb *hqProc));
#ifndef MAC_SCH_STATS
EXTERN Void rgSCHUhmProcHqFailure ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
- CmLteTimingInfo frm, TknU8 rv));
+ CmLteTimingInfo frm, TknUInt8 rv));
#else /* MAC_SCH_STATS */
EXTERN Void rgSCHUhmProcHqFailure ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
- CmLteTimingInfo frm, TknU8 rv, U8 cqi));
+ CmLteTimingInfo frm, TknUInt8 rv, uint8_t cqi));
#endif
EXTERN RgSchUlHqProcCb* rgSCHUhmGetUlHqProc ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
- U8 idx));
-EXTERN Void rgSCHUhmNewTx ARGS((RgSchUlHqProcCb *hqProc, U8 maxHqRetx,
+ uint8_t idx));
+EXTERN Void rgSCHUhmNewTx ARGS((RgSchUlHqProcCb *hqProc, uint8_t maxHqRetx,
RgSchUlAlloc *alloc));
EXTERN Void rgSCHUhmFreeProc ARGS((RgSchUlHqProcCb *hqProc,
RgSchCellCb *cell));
RgrUeRecfg *ueRecfg));
EXTERN Void rgSCHUhmFreeUe ARGS(( RgSchCellCb *cellCb, RgUeUlHqCb *hqEnt));
EXTERN S16 rgSCHUhmAppendPhich ARGS(( RgSchCellCb *cellCb,
- CmLteTimingInfo frm, U8 idx));
+ CmLteTimingInfo frm, uint8_t idx));
/* APIs exposed by DBM */
EXTERN S16 rgSCHDbmInitCell ARGS((RgSchCellCb *cellCb));
EXTERN RgSchCfgElem* rgSCHDbmDelPndngRgrCfgElem ARGS(( RgSchCellCb *cellCb,
RgSchCfgElem *cfgElem));
-EXTERN S16 rgSCHDbmRntiDbInit ARGS(( RgSchCellCb *cellCb, U16 rntiStart, U16 maxRntis));
+EXTERN S16 rgSCHDbmRntiDbInit ARGS(( RgSchCellCb *cellCb, uint16_t rntiStart, uint16_t maxRntis));
EXTERN Void rgSCHDbmRntiDbDeInit ARGS(( RgSchCellCb *cellCb));
EXTERN RgSchRntiLnk* rgSCHDbmGetRnti ARGS(( RgSchCellCb *cellCb));
EXTERN Void rgSCHDbmRlsRnti ARGS(( RgSchCellCb *cellCb, RgSchRntiLnk *rntiLnk));
EXTERN S16 rgSCHDhmGetMsg4HqProc ARGS((RgSchRaCb *raCb, CmLteTimingInfo timeInfo));
EXTERN Void rgSCHDhmRlsHqProc ARGS((RgSchDlHqProcCb *hqP));
/* ccpu00118350 : Correcting NDI manipulation of Harq */
-EXTERN Void rgSCHDhmRlsHqpTb ARGS((RgSchDlHqProcCb *hqP, U8 tbIdx, Bool togNdi));
+EXTERN Void rgSCHDhmRlsHqpTb ARGS((RgSchDlHqProcCb *hqP, uint8_t tbIdx, Bool togNdi));
EXTERN Void rgSCHUtlDlHqPTbAddToTx ARGS((RgSchDlSf *subFrm,
-RgSchDlHqProcCb *hqP, U8 tbIdx ));
+RgSchDlHqProcCb *hqP, uint8_t tbIdx ));
EXTERN Void rgSCHDhmHqTbRetx ARGS(( RgSchDlHqEnt *hqE,
-CmLteTimingInfo timingInfo, RgSchDlHqProcCb *hqP, U8 tbIdx));
+CmLteTimingInfo timingInfo, RgSchDlHqProcCb *hqP, uint8_t tbIdx));
EXTERN Void rgSCHUtlDlHqPTbAddToTx ARGS((RgSchDlSf *subFrm,
-RgSchDlHqProcCb *hqP, U8 tbIdx ));
+RgSchDlHqProcCb *hqP, uint8_t tbIdx ));
EXTERN Void rgSCHDhmHqTbRetx ARGS(( RgSchDlHqEnt *hqE,
-CmLteTimingInfo timingInfo, RgSchDlHqProcCb *hqP, U8 tbIdx));
+CmLteTimingInfo timingInfo, RgSchDlHqProcCb *hqP, uint8_t tbIdx));
#ifdef RG_UNUSED
-EXTERN S16 rgSCHDhmGetHqProcFrmId ARGS((RgSchCellCb *cell, RgSchUeCb *ue, U8 idx,
+EXTERN S16 rgSCHDhmGetHqProcFrmId ARGS((RgSchCellCb *cell, RgSchUeCb *ue, uint8_t idx,
RgSchDlHqProcCb **hqP));
#endif
/* Changes for MIMO feature addition */
EXTERN Void rgSCHDhmSchdTa ARGS((RgSchUeCb *ueCb, RgSchDlHqTbCb *tbInfo));
-EXTERN S16 rgSCHDhmHqFdbkInd ARGS((Void *cb, U8 cbType, RgSchCellCb *cellCb,
+EXTERN S16 rgSCHDhmHqFdbkInd ARGS((Void *cb, uint8_t cbType, RgSchCellCb *cellCb,
CmLteTimingInfo timingInfo, RgTfuHqInfo *fdbk, RgInfRlsHqInfo
*rlsHqBufs,RgSchErrInfo *err));
#ifdef EMTC_ENABLE
-EXTERN S16 rgSCHDhmEmtcHqFdbkInd ARGS((Void *cb, U8 cbType, RgSchCellCb *cellCb,
+EXTERN S16 rgSCHDhmEmtcHqFdbkInd ARGS((Void *cb, uint8_t cbType, RgSchCellCb *cellCb,
CmLteTimingInfo timingInfo, RgTfuHqInfo *fdbk, RgInfRlsHqInfo
*rlsHqBufs,RgSchErrInfo *err));
EXTERN S16 rgSCHUtlAddToResLst
/*CA Dev Start */
EXTERN S16 rgSCHDhmPrcFdbkForTb(RgSchCellCb *cell,RgSchUeCb *ue,
RgSchDlHqProcCb *hqP,RgSchDlSf *sf,Bool isMsg4,
- U16 rnti,U8 tbCnt,CmLteTimingInfo timingInfo, U8 isAck,
+ uint16_t rnti,uint8_t tbCnt,CmLteTimingInfo timingInfo, uint8_t isAck,
RgInfRlsHqInfo *rlsHqBufs,RgSchErrInfo *err
);
/*CA Dev End */
EXTERN Void rgSCHDhmRgrCellRecfg ARGS((RgSchCellCb *cellCb, RgrCellRecfg
*cellRecfg, RgSchErrInfo *err));
EXTERN Void rgSCHDhmFreeUe ARGS((RgSchUeCb *ueCb));
-EXTERN Void rgSCHDhmUpdTa ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb, U8 ta));
+EXTERN Void rgSCHDhmUpdTa ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb, uint8_t ta));
EXTERN Void rgSCHDhmProcTAExp ARGS((RgSchUeCb *ue));
/* Changes for MIMO feature addition */
EXTERN S16 rgSCHDhmAddLcData ARGS((Inst inst, RgSchLchAllocInfo *lchData,
#ifdef LTE_TDD
EXTERN S16 rgSCHDhmTddRlsSubFrm ARGS((RgSchCellCb *cell, CmLteTimingInfo uciTimingInfo));
-EXTERN S16 rgSCHCfgVldtTddDrxCycCfg ARGS((RgSchCellCb *cell, U16 drxCycle,
- U8 onDurTmr, U16 offSet));
+EXTERN S16 rgSCHCfgVldtTddDrxCycCfg ARGS((RgSchCellCb *cell, uint16_t drxCycle,
+ uint8_t onDurTmr, uint16_t offSet));
#endif
/* Added support for SPS*/
#ifdef LTEMAC_SPS
EXTERN S16 rgSCHDhmGetHqProcFrmId ARGS((
RgSchCellCb *cell,
-RgSchUeCb *ue,
-U8 idx,
-RgSchDlHqProcCb **hqP
+RgSchUeCb *ue,
+uint8_t idx,
+RgSchDlHqProcCb **hqP
));
#endif /* LTEMAC_SPS */
/* Freeing up the HARQ proc blocked for
));
EXTERN Void rgSCHMeasGapANRepDlInactvTmrExpry ARGS((
RgSchUeCb *ue,
-U8 tmrEvnt
+uint8_t tmrEvnt
));
EXTERN Void rgSCHMeasGapANRepUlInactvTmrExpry ARGS((
RgSchUeCb *ue,
-U8 tmrEvnt
+uint8_t tmrEvnt
));
EXTERN Void rgSCHMeasGapANRepTmrExpry ARGS((
RgSchUeCb *ue
RgSchCellCb *cell,
RgSchL2MeasCb *measCb,
LrgSchMeasCfmInfo *cfm,
- U32 measTime
+ uint32_t measTime
));
EXTERN Void rgSchL2mFillCfmPst ARGS((
Pst *pst,
));
EXTERN S16 rgSCHL2Meas ARGS((
RgSchCellCb *cell,
- U8 isCalrCrcInd
+ uint8_t isCalrCrcInd
));
#endif /* LTE_L2_MEAS */
/* Added changes of TFU_UPGRADE */
F64 n
));
- EXTERN U32 rgSCHUtlParse ARGS
+ EXTERN uint32_t rgSCHUtlParse ARGS
((
- U8 *buff,
- U8 startPos,
- U8 endPos,
- U8 buffSize
+ uint8_t *buff,
+ uint8_t startPos,
+ uint8_t endPos,
+ uint8_t buffSize
));
- EXTERN U8 rgSCHUtlFindDist ARGS
+ EXTERN uint8_t rgSCHUtlFindDist ARGS
((
-U16 crntTime,
-U16 tempIdx
+uint16_t crntTime,
+uint16_t tempIdx
));
#endif
EXTERN Bool rgSCHUtlPdcchAvail ARGS((RgSchCellCb *cell, RgSchPdcchInfo
#ifdef LTE_TDD
/* Changes for passing iPhich at TFU interface*/
EXTERN S16 rgSCHUtlAddPhich ARGS((RgSchCellCb *cellCb, CmLteTimingInfo frm,
- U8 hqFeedBack, U8 nDmrs, U8 rbStart, U8 iPhich));
+ uint8_t hqFeedBack, uint8_t nDmrs, uint8_t rbStart, uint8_t iPhich));
#else
EXTERN S16 rgSCHUtlAddPhich ARGS((RgSchCellCb *cellCb, CmLteTimingInfo frm,
- U8 hqFeedBack, U8 nDmrs, U8 rbStart,Bool isForMsg3));
+ uint8_t hqFeedBack, uint8_t nDmrs, uint8_t rbStart,Bool isForMsg3));
#endif
EXTERN RgSchDlSf* rgSCHUtlSubFrmGet ARGS((RgSchCellCb *cell,
CmLteTimingInfo frm));
EXTERN Void rgSCHUtlSubFrmPut ARGS((RgSchCellCb *cell, RgSchDlSf *sf));
-EXTERN U8 rgSCHUtlLog32bitNbase2 ARGS((U32 n));
+EXTERN uint8_t rgSCHUtlLog32bitNbase2 ARGS((uint32_t n));
/* Added support for SPS*/
CmLteTimingInfo timingInfo));
#endif
#ifdef LTE_TDD
-EXTERN U8 rgSCHUtlCalcNCce ARGS((U8 bw, RgrPhichNg ng, U8 cfi, U8 mPhich,
- U8 numAntna, Bool isEcp));
+EXTERN uint8_t rgSCHUtlCalcNCce ARGS((uint8_t bw, RgrPhichNg ng, uint8_t cfi, uint8_t mPhich,
+ uint8_t numAntna, Bool isEcp));
#else
-EXTERN U8 rgSCHUtlCalcNCce ARGS((U8 bw, RgrPhichNg ng, U8 cfi, U8 numAntna, Bool
+EXTERN uint8_t rgSCHUtlCalcNCce ARGS((uint8_t bw, RgrPhichNg ng, uint8_t cfi, uint8_t numAntna, Bool
isEcp));
#endif
#ifdef LTE_TDD
/* Changes for passing iPhich at TFU interface*/
-EXTERN S16 rgSCHUtlGetPhichInfo ARGS((RgSchUlHqProcCb *hqProc, U8 *rbStartRef,
- U8 *nDmrsRef, U8 *iPhich));
+EXTERN S16 rgSCHUtlGetPhichInfo ARGS((RgSchUlHqProcCb *hqProc, uint8_t *rbStartRef,
+ uint8_t *nDmrsRef, uint8_t *iPhich));
#else
-EXTERN S16 rgSCHUtlGetPhichInfo ARGS((RgSchUlHqProcCb *hqProc, U8 *rbStartRef,
- U8 *nDmrsRef));
+EXTERN S16 rgSCHUtlGetPhichInfo ARGS((RgSchUlHqProcCb *hqProc, uint8_t *rbStartRef,
+ uint8_t *nDmrsRef));
#endif
/* Added changes of TFU_UPGRADE */
#ifndef TFU_UPGRADE
/* To include the length and ModOrder in DataRecp Req. */
/* Updating NDI and HARQ proc Id */
EXTERN S16 rgSCHUtlAllocRcptInfo ARGS((RgSchUlAlloc *alloc, CmLteRnti *rnti,
- U8 *iMcsRef, U8 *rbStartRef, U8 *numRbRef, U8 *rvRef, U16 *size,
+ uint8_t *iMcsRef, uint8_t *rbStartRef, uint8_t *numRbRef, uint8_t *rvRef, uint16_t *size,
TfuModScheme *modType,Bool *isRtx,
-U8 *nDmrs,
+uint8_t *nDmrs,
Bool *ndi,
-U8 *hqPId));
+uint8_t *hqPId));
#else
EXTERN S16 rgSCHUtlAllocRcptInfo ARGS((
RgSchCellCb *cell,
EXTERN S16 rgSCHUtlRgrLcCfg ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
RgSchDlLcCb *dl, RgrLchCfg *cfg,RgSchErrInfo *errInfo));
EXTERN S16 rgSCHUtlRgrLcDel ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
- CmLteLcId lcId, U8 lcgId));
+ CmLteLcId lcId, uint8_t lcgId));
EXTERN S16 rgSCHUtlRgrLcRecfg ARGS ((RgSchCellCb *cell,RgSchUeCb *ue,
RgSchDlLcCb *dlLc,RgrLchRecfg *recfg,RgSchErrInfo *err));
EXTERN S16 rgSCHUtlRgrLcgCfg ARGS ((RgSchCellCb *cell,RgSchUeCb *ue,
EXTERN S16 rgSCHUtlRgrLcgRecfg ARGS ((RgSchCellCb *cell,RgSchUeCb *ue,
RgrLcgRecfg *recfg,RgSchErrInfo *err));
EXTERN Void rgSCHUtlRgrLcgDel ARGS ((RgSchCellCb *cell,RgSchUeCb *ue,
- U8 lcgId));
+ uint8_t lcgId));
EXTERN Void rgSCHUtlDlCqiInd ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
TfuDlCqiRpt *dlCqiInd, CmLteTimingInfo timingInfo));
EXTERN S16 rgSCHUtlGetCfgPerOff ARGS
((
RgSchPerTbl tbl,
-U16 cfgIdx,
-U16 *peri,
-U16 *offset
+uint16_t cfgIdx,
+uint16_t *peri,
+uint16_t *offset
));
#endif
EXTERN Void rgSCHUtlDlRlsSubFrm ARGS((RgSchCellCb *cell, CmLteTimingInfo subFrm));
EXTERN Void rgSCHUtlDlProcAddToRetx ARGS((RgSchCellCb *cell,
RgSchDlHqProcCb *hqP));
-EXTERN S16 rgSCHUtlRegSch ARGS((U8 schIdx, RgSchdApis *apis));
+EXTERN S16 rgSCHUtlRegSch ARGS((uint8_t schIdx, RgSchdApis *apis));
EXTERN Void rgSCHUtlDlHqProcAddToTx ARGS((RgSchDlSf *subFrm, RgSchDlHqProcCb *hqP));
/* Changes for MIMO feature addition */
EXTERN Void rgSCHUtlDlHqPTbRmvFrmTx ARGS((RgSchDlSf *subFrm,
- RgSchDlHqProcCb *hqP, U8 tbIdx, Bool isRepeating));
+ RgSchDlHqProcCb *hqP, uint8_t tbIdx, Bool isRepeating));
EXTERN S16 rgSCHUtlRgrUeRecfg ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
RgrUeRecfg *recfg, RgSchErrInfo *err));
EXTERN Void rgSCHUtlFreeDlLc ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
RgSchErrInfo *err));
EXTERN S16 rgSCHUtlSrRcvd ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
CmLteTimingInfo, RgSchErrInfo *err));
-EXTERN Void rgSCHUtlUpdBsrShort ARGS((RgSchCellCb *cell, RgSchUeCb *ue, U8 lcgId,
- U8 bsr, RgSchErrInfo *err));
-EXTERN Void rgSCHUtlUpdBsrTrunc ARGS((RgSchCellCb *cell, RgSchUeCb *ue, U8 lcgId,
- U8 bsr, RgSchErrInfo *err));
+EXTERN Void rgSCHUtlUpdBsrShort ARGS((RgSchCellCb *cell, RgSchUeCb *ue, uint8_t lcgId,
+ uint8_t bsr, RgSchErrInfo *err));
+EXTERN Void rgSCHUtlUpdBsrTrunc ARGS((RgSchCellCb *cell, RgSchUeCb *ue, uint8_t lcgId,
+ uint8_t bsr, RgSchErrInfo *err));
EXTERN Void rgSCHUtlUpdBsrLong ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
- U8 bsr1,U8 bsr2,U8 bsr3,U8 bsr4, RgSchErrInfo *err));
+ uint8_t bsr1,uint8_t bsr2,uint8_t bsr3,uint8_t bsr4, RgSchErrInfo *err));
EXTERN S16 rgSCHUtlUpdPhr ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
- U8 phr, RgSchErrInfo *err));
+ uint8_t phr, RgSchErrInfo *err));
EXTERN S16 rgSCHUtlUpdExtPhr ARGS(( RgSchCellCb *cell, RgSchUeCb *ue,
RgInfExtPhrCEInfo * extPhr, RgSchErrInfo *err));
-EXTERN S16 rgSCHUtlDataRcvd ARGS((RgSchCellCb *cell, RgSchUeCb *ue, U8 numLc,
- RgSchUlLcCb *lcArr[], U16 bytesArr[], RgSchErrInfo *err));
+EXTERN S16 rgSCHUtlDataRcvd ARGS((RgSchCellCb *cell, RgSchUeCb *ue, uint8_t numLc,
+ RgSchUlLcCb *lcArr[], uint16_t bytesArr[], RgSchErrInfo *err));
EXTERN Void rgSCHUtlUlCqiInd ARGS(( RgSchCellCb *cell, RgSchUeCb *ue,
TfuUlCqiRpt *ulCqiInfo));
EXTERN Void rgSCHUtlPucchDeltaPwrInd ARGS(( RgSchCellCb *cell, RgSchUeCb *ue,
EXTERN RgSchUlAlloc *rgSCHUtlFirstRcptnReq ARGS((RgSchCellCb *cell));
EXTERN RgSchUlAlloc *rgSCHUtlNextRcptnReq ARGS((RgSchCellCb *cell,
RgSchUlAlloc *alloc));
-EXTERN RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc ARGS((RgSchCellCb *cell, U8 idx));
+EXTERN RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc ARGS((RgSchCellCb *cell, uint8_t idx));
EXTERN RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc ARGS((RgSchCellCb *cell,
- RgSchUlAlloc *alloc, U8 idx));
+ RgSchUlAlloc *alloc, uint8_t idx));
EXTERN S16 rgSCHUtlTfuBndReq ARGS((Inst inst, SuId suId, SpId spId));
EXTERN S16 rgSCHUtlTfuUBndReq ARGS((Inst inst, RgSchLowSapCfgInfo sapCfg, Reason reason));
#ifdef EMTC_ENABLE
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
EXTERN Void rgSCHUtlFreeSBuf ARGS((Inst inst, Data **data, Size size));
-EXTERN Void rgSCHUtlFillDgnParams ARGS((Inst inst, RgUstaDgn *dgn,U8 dgnType));
+EXTERN Void rgSCHUtlFillDgnParams ARGS((Inst inst, RgUstaDgn *dgn,uint8_t dgnType));
EXTERN Void rgSCHUtlGetPstToLyr ARGS((Pst *pst,RgSchCb *schCb,Inst macInst));
EXTERN S16 rgSCHUtlFillRgInfCmnLcInfo ARGS((RgSchDlSf *sf,RgInfSfAlloc *sfAlloc,
CmLteLcId lcId, Bool sendInd));
EXTERN S16 rgSCHUtlHndlCcchBoUpdt ARGS((RgSchCellCb *cell,RgInfCmnBoRpt *boRpt));
EXTERN S16 rgSCHUtlHndlBcchPcchBoUpdt ARGS((RgSchCellCb *cell,RgInfCmnBoRpt
*boUpdt));
-EXTERN S16 rgSCHUtlRgrBndCfm ARGS ((Inst inst, SuId suId,U8 status));
+EXTERN S16 rgSCHUtlRgrBndCfm ARGS ((Inst inst, SuId suId,uint8_t status));
/* Added for sending TTI tick to RRM */
#ifdef RGR_RRM_TICK
EXTERN S16 rgSCHUtlRgrTtiInd ARGS ((RgSchCellCb *cell, RgrTtiIndInfo *ttiInd));
#endif
EXTERN S16 schSendCfgCfm ARGS ((Region reg, Pool pool, \
- RgrCfgTransId transId, U8 status));
+ RgrCfgTransId transId, uint8_t status));
EXTERN S16 rgSCHUtlProcMsg3 ARGS((RgInfSfDatInd *subfrmInfo, RgSchCellCb *cellCb,
RgSchUeCb *ueCb, CmLteRnti rnti,RgInfUeDatInd *pdu,
RgSchErrInfo *err ));
EXTERN Void rgSCHUtlHdlUlTransInd ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
CmLteTimingInfo timingInfo));
#ifdef TFU_UPGRADE
-EXTERN Void rgSCHUtlUpdACqiTrigWt ARGS((RgSchUeCb *ue,RgSchUeCellInfo *sCellInfo, U8 isAck));
+EXTERN Void rgSCHUtlUpdACqiTrigWt ARGS((RgSchUeCb *ue,RgSchUeCellInfo *sCellInfo, uint8_t isAck));
#endif
/* Nprb indication at PHY for common Ch */
/* Corrected allocation for common channels */
-EXTERN S32 rgSCHUtlGetAllwdCchTbSz ARGS((U32 bo, U8 *nPrb, U8 *mcs
+EXTERN S32 rgSCHUtlGetAllwdCchTbSz ARGS((uint32_t bo, uint8_t *nPrb, uint8_t *mcs
));
/* CR timer changes*/
EXTERN S16 rgSCHUtlUpdtBo ARGS((RgSchCellCb *cell,
CmLListCp *siPduLst));
EXTERN Void rgSCHUtlFreeWarningSiPdu ARGS((RgSchCellCb *cell));
EXTERN Buffer *rgSCHUtlGetWarningSiPdu ARGS((RgSchCellCb *cell));
-EXTERN S16 rgSCHUtlGetMcsAndNPrb ARGS((RgSchCellCb *cell, U8 *nPrb, U8 *mcs, MsgLen *msgLen));
-EXTERN S16 rgSCHUtlCalMcsAndNPrb ARGS((RgSchCellCb *cell, U8 cfgType, MsgLen msgLen, U8 siId));
+EXTERN S16 rgSCHUtlGetMcsAndNPrb ARGS((RgSchCellCb *cell, uint8_t *nPrb, uint8_t *mcs, MsgLen *msgLen));
+EXTERN S16 rgSCHUtlCalMcsAndNPrb ARGS((RgSchCellCb *cell, uint8_t cfgType, MsgLen msgLen, uint8_t siId));
#endif/*RGR_SI_SCH*/
#ifdef LTE_TDD
-EXTERN S16 rgSCHUtlAllocUeANFdbkInfo ARGS((RgSchUeCb *ue,U8 servCellIdx));
-EXTERN Void rgSCHUtlDelUeANFdbkInfo ARGS((RgSchUeCb *ue,U8 servCellIdx));
+EXTERN S16 rgSCHUtlAllocUeANFdbkInfo ARGS((RgSchUeCb *ue,uint8_t servCellIdx));
+EXTERN Void rgSCHUtlDelUeANFdbkInfo ARGS((RgSchUeCb *ue,uint8_t servCellIdx));
EXTERN S16 rgSCHUtlInitUeANFdbkInfo ARGS((RgSchTddANInfo *anInfo));
-EXTERN RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo ARGS((RgSchUeCb *ueCb, CmLteTimingInfo *timeInfo,U8 servCellIdx));
-EXTERN U8 rgSCHUtlGetDlSfIdx ARGS((RgSchCellCb *cell, CmLteTimingInfo *timeInfo));
+EXTERN RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo ARGS((RgSchUeCb *ueCb, CmLteTimingInfo *timeInfo,uint8_t servCellIdx));
+EXTERN uint8_t rgSCHUtlGetDlSfIdx ARGS((RgSchCellCb *cell, CmLteTimingInfo *timeInfo));
EXTERN Void rgSCHUtlPrachCfgInit ARGS((RgSchCellCb *cell, RgrCellCfg *cellCfg ));
EXTERN Void rgSCHUtlGetNxtDlSfInfo ARGS((CmLteTimingInfo curDlTime, RgSchCellCb *cell, RgSchDlSf *dlSf, RgSchDlSf **nxtDlsf, CmLteTimingInfo *nxtDlTime));
-EXTERN Void rgSCHUtlGetPrevDlSfInfo ARGS((RgSchCellCb * cell, CmLteTimingInfo curDlTime, CmLteTimingInfo *prevDlTime, U8 *numSubfrm));
+EXTERN Void rgSCHUtlGetPrevDlSfInfo ARGS((RgSchCellCb * cell, CmLteTimingInfo curDlTime, CmLteTimingInfo *prevDlTime, uint8_t *numSubfrm));
#endif
EXTERN Void rgSCHCmnDlSch ARGS
((
EXTERN S16 rgSCHUtlSpsActInd ARGS((
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
-U16 spsSduSize
+uint16_t spsSduSize
));
EXTERN Void rgSCHUtlHdlCrcFailInd ARGS((
EXTERN S16 rgSCHUtlUlSfInit ARGS((
RgSchCellCb *cell,
RgSchUlSf *sf,
- U8 idx,
- U8 maxUePerSf
+ uint8_t idx,
+ uint8_t maxUePerSf
));
EXTERN Void rgSCHUtlUlSfDeinit ARGS((
RgSchCellCb *cell,
RgSchUlSf *sf
));
EXTERN RgSchUlAlloc *rgSCHUtlUlAllocGetHole ARGS((
- RgSchUlSf *sf,
- U8 numRb,
+ RgSchUlSf *sf,
+ uint8_t numRb,
RgSchUlHole *hole
));
EXTERN RgSchUlAlloc *rgSCHUtlUlAllocGetCompHole ARGS((
- RgSchUlSf *sf,
+ RgSchUlSf *sf,
RgSchUlHole *hole
));
EXTERN RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole ARGS((
- RgSchUlSf *sf,
- U8 numRb,
+ RgSchUlSf *sf,
+ uint8_t numRb,
RgSchUlHole *hole
));
EXTERN Void rgSCHUtlUlAllocRls ARGS((
EXTERN S16 rgSCHUtlUlAllocMemInit ARGS((
RgSchCellCb *cell,
RgSchUlAllocMem *mem,
- U8 maxAllocs
+ uint8_t maxAllocs
));
EXTERN Void rgSCHUtlUlAllocMemDeinit ARGS((
RgSchCellCb *cell,
EXTERN S16 rgSCHUtlUlHoleMemInit ARGS((
RgSchCellCb *cell,
RgSchUlHoleMem *mem,
- U8 maxHoles,
+ uint8_t maxHoles,
RgSchUlHole **holeRef
));
EXTERN Void rgSCHUtlUlHoleMemDeinit ARGS((
));
EXTERN RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc ARGS((
RgSchUlSf *sf,
- U8 startSb,
- U8 numSb
+ uint8_t startSb,
+ uint8_t numSb
));
/******* </AllocHolesMemMgmnt>: END *****/
EXTERN Void rgSCHDrxStrtInActvTmr ARGS((RgSchCellCb *cell,
CmLListCp *ueLst,
- U8 direction));
+ uint8_t direction));
EXTERN S16 rgSCHUtlGetDrxSchdUesInDl ARGS((RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
RgSchDlHqProcCb *dlHq,
CmLListCp *ulInActvLst));
EXTERN Void rgSCHDrxStartHarqRTTTmr ARGS((RgSchCellCb *cell,
RgSchDlHqProcCb *hqP,
- U8 tbCnt));
+ uint8_t tbCnt));
EXTERN Void rgSCHDrxUeHqReset ARGS((RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqEnt *hqE,
- U8 cellIdx));
+ uint8_t cellIdx));
#ifdef TFU_UPGRADE
#ifdef LTE_TDD
EXTERN Void rgSCHCmnHdFddChkUlAllow ARGS((
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
- U8 *flag));
+ uint8_t *flag));
EXTERN Void rgSCHCmnHdFddChkDlAllow ARGS((
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
RgSchCellCb *cellCb,
RgSchUeCb *ueCb));
EXTERN Void rgSCHHdFddGetSfn ARGS((
- U16 *sfn,
+ uint16_t *sfn,
CmLteTimingInfo timeInfo,
S16 offset));
#endif /* ifdef LTEMAC_HDFDD */
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrStaIndInfo *staInfo,
-U8 numCqiRept
+uint8_t numCqiRept
));
#endif /* End of RGR_CQI_REPT */
S16 rgSCHUtlRgrUeStaInd ARGS((
-RgSchCellCb *cell,
+RgSchCellCb *cell,
RgrUeStaIndInfo *rgrUeSta
));
S16 rgSCHUtlRgmBndCfm ARGS((
Inst instId,
SuId suId,
-U8 status
+uint8_t status
));
Void rgSCHDhmDelHqEnt ARGS((
RgSchCellCb *cell,
RgSchCellCb *cell
));
-U8 rgSchUtlCfg0ReTxIdx ARGS((
+uint8_t rgSchUtlCfg0ReTxIdx ARGS((
RgSchCellCb *cell,
CmLteTimingInfo phichTime,
-U8 hqFdbkIdx
+uint8_t hqFdbkIdx
));
EXTERN S16 rgSCHUtlBuildNSendLcgReg ARGS((
RgSchCellCb *cell,
CmLteRnti crnti,
-U8 lcgId,
+uint8_t lcgId,
Bool isGbr
));
EXTERN Void rgSCHUtlPdcchInit ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
- U16 nCce));
+ uint16_t nCce));
EXTERN Void rgSCHDynCfiReCfg ARGS((
RgSchCellCb *cell,
Bool isDynCfiEnb
));
Void rgSchUtlCalcTotalPrbReq ARGS((RgSchCellCb *cell,
RgSchUeCb *ue,
- U32 bo,
- U32 *prbReqrd));
-EXTERN U8 rgSchUtlGetNumSbs ARGS((
+ uint32_t bo,
+ uint32_t *prbReqrd));
+EXTERN uint8_t rgSchUtlGetNumSbs ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 *numSbs
+uint32_t *numSbs
));
-EXTERN U8 rgSchUtlSortInsUeLst ARGS((
-RgSchCellCb *cell,
+EXTERN uint8_t rgSchUtlSortInsUeLst ARGS((
+RgSchCellCb *cell,
CmLListCp *ueLst,
CmLList *node,
-U8 subbandRequired
+uint8_t subbandRequired
));
EXTERN S16 rgSCHUtlResetCpuOvrLdState ARGS((
RgSchCellCb *cell,
- U8 cnrtCpuOvrLdIns
+ uint8_t cnrtCpuOvrLdIns
));
EXTERN Void rgSCHUtlCpuOvrLdAdjItbsCap ARGS((
RgSchCellCb *cell
EXTERN Void rgSCHTomUtlGetTrigSet ARGS((
RgSchCellCb *cell,
RgSchUeCb *ueCb,
- U8 cqiReq,
- U8 *triggerSet
+ uint8_t cqiReq,
+ uint8_t *triggerSet
));
EXTERN Void rgSCHUtlUpdUeDciSize ARGS((
EXTERN Void rgSchCmnPreDlSch ARGS ((
RgSchCellCb **cell,
- U8 nCell,
+ uint8_t nCell,
RgSchCellCb **cellLst
));
RgSchCellCb *cell
));
-EXTERN U8 rgSCHCmnGetBiIndex ARGS ((
+EXTERN uint8_t rgSCHCmnGetBiIndex ARGS ((
RgSchCellCb *cell,
-U32 ueCount
+uint32_t ueCount
));
EXTERN uint8_t SchSendCfgCfm(Pst *pst, RgMngmt *cfm);
));
EXTERN S16 rgSCHEmtcCfgVldtDrxReTxCfg ARGS((
-U16 reTxTmr
+uint16_t reTxTmr
));
EXTERN S16 rgSCHEmtcCfgVldtDrxUlReTxCfg ARGS((
-U16 reTxTmr
+uint16_t reTxTmr
));
#endif
RgSchRaCb *raCb,RgSchUeCb *ue, RgSchErrInfo *errInfo));
PRIVATE S16 rgSCHCfgRgrCmnLcCfg ARGS((RgSchCellCb *cell, RgrCmnLchCfg *lcCfg,
RgSchErrInfo *errInfo));
-Void rgSCHSCellFreeBuf ARGS((Inst inst,RgSchUeCb *ue,RgrUeRecfg *ueRecfg,U8 idx));
+Void rgSCHSCellFreeBuf ARGS((Inst inst,RgSchUeCb *ue,RgrUeRecfg *ueRecfg,uint8_t idx));
#ifdef RGR_SI_SCH
PRIVATE S16 rgSCHCfgVldtRgrCellSiCfg ARGS(( Inst inst, RgrSiCfg *siCfg));
#endif/*RGR_SI_SCH */
/* LTE_ADV_FLAG_REMOVED_START */
PRIVATE S16 rgSCHCfgVldtRgrCellLteAdvCfg ARGS(( Inst inst,
- RgrLteAdvancedCellConfig *lteAdvCfg, U8 dlTotalBw));
+ RgrLteAdvancedCellConfig *lteAdvCfg, uint8_t dlTotalBw));
/* LTE_ADV_FLAG_REMOVED_END */
PRIVATE S16 rgSCHCfgVldtDrxUeCfg ARGS ((RgSchCellCb *cell,
RgrUeDrxCfg *ueDrxCfg));
-PRIVATE S16 rgSCHCfgVldtDrxOnDurCfg ARGS((U8 onDurTmr));
-PRIVATE S16 rgSCHCfgVldtDrxInActvCfg ARGS((U16 inActvTmr));
-PRIVATE S16 rgSCHCfgVldtDrxReTxCfg ARGS((U8 reTxTmr));
+PRIVATE S16 rgSCHCfgVldtDrxOnDurCfg ARGS((uint8_t onDurTmr));
+PRIVATE S16 rgSCHCfgVldtDrxInActvCfg ARGS((uint16_t inActvTmr));
+PRIVATE S16 rgSCHCfgVldtDrxReTxCfg ARGS((uint8_t reTxTmr));
PRIVATE S16 rgSCHCfgVldtDrxLngCycCfg ARGS((RgrDrxLongCycleOffst lngCycleOffst));
-PRIVATE S16 rgSCHCfgVldtDrxLngCyclTmrs ARGS((U16 val));
+PRIVATE S16 rgSCHCfgVldtDrxLngCyclTmrs ARGS((uint16_t val));
PRIVATE S16 rgSCHCfgVldtDrxShrtCycCfg ARGS((RgrDrxShortDrx shrtCycCfg));
PRIVATE S16 rgSCHCfgVldtRgrCellCsgParamCfg ARGS((Inst inst,
RgrCellCsgParamCfg *csgParam));
S16 rgSCHCfgAcqiUeReCfg ARGS(( RgSchCellCb *cellCb, RgSchUeCb *ueCb,
RgrUeAprdDlCqiCfg *acqiCfg, CmLteUeCategory ueCat ));
-S16 rgSCHUtlGetCfgPerOff ARGS(( RgSchPerTbl tbl, U16 cfgIdx,
- U16 *peri, U16 *offset ));
+S16 rgSCHUtlGetCfgPerOff ARGS(( RgSchPerTbl tbl, uint16_t cfgIdx,
+ uint16_t *peri, uint16_t *offset ));
S16 rgSCHCfgRiUeCfg ARGS((RgSchCellCb *cellCb, RgSchUeCb *ueCb,
RgrUePrdDlCqiCfg *cqiCfg, CmLteUeCategory ueCat ));
S16 rgSCHCfgPCqiSrsSrUeDel ARGS ((RgSchCellCb *cellCb,
RgSchUeCb *ueCb));
-PRIVATE Void rgSCHCfgUtlFetchAcqiBitSz ARGS (( RgSchUeACqiCb *acqiCb,U8 numTxAnt,
- U8* cqiPmiSzR1,U8* cqiPmiSzRn1 ));
+PRIVATE Void rgSCHCfgUtlFetchAcqiBitSz ARGS (( RgSchUeACqiCb *acqiCb,uint8_t numTxAnt,
+ uint8_t* cqiPmiSzR1,uint8_t* cqiPmiSzRn1 ));
/* Added the function to be used instead of the
* MACRO RG_SCH_GET_PERIODICITY_TBL */
PRIVATE CONSTANT RgSchUePCqiSrsSrCfgIdxTbl* rgSCHCfgUtlGetPcqiSrsSrRiTbl ARGS ((
RgSchPerTbl tblType,
- U8 * min,
- U8 * max));
+ uint8_t * min,
+ uint8_t * max));
#endif /* TFU_UPGRADE */
PRIVATE Void rgSCHCfgUeTaRecfg ARGS (( RgSchCellCb *cellCb,
#ifdef EMTC_ENABLE
S16 rgSCHEmtcCfgVldtDrxOnDurCfg
(
-U16 onDurTmr
+uint16_t onDurTmr
);
Void rgSCHUtlUpdEmtcY
(
/*Reference:36.213: Derived from Table: 7.2.1-5 for Label L.
The Label L is CEIL(log2(BinCoe(N and M)))*/
-CONSTANT U8 RgSCHUeAcqi2022LBitWidth[6][28] ={
+CONSTANT uint8_t RgSCHUeAcqi2022LBitWidth[6][28] ={
{0,1,2,2,3,3,3,3,4,4,4,4,4,4,4,4,5,5,5,5,5,5,5,5,5,5,5,5},
{0,0,2,3,4,4,5,5,6,6,6,7,7,7,7,7,8,8,8,8,8,8,8,9,9,9,9,9},
{0,0,0,2,4,5,6,6,7,7,8,8,9,9,9,10,10,10,10,11,11,11,11,11,12,12,12,12},
#endif
-EXTERN U8 rgSchCmnHarqRtt[];
+EXTERN uint8_t rgSchCmnHarqRtt[];
#ifdef EMTC_ENABLE
EXTERN S16 rgSCHEmtcCellAlloc ARGS((RgSchCellCb *cel));
EXTERN Void rgSCHEmtcCellFree ARGS((RgSchCellCb *cel));
EXTERN Void rgSCHEmtcUeInfoFree ARGS((RgSchCellCb *cell, RgSchUeCb *ue));
-EXTERN U8 rgSchfillPucchSrRepNumCountemtc ARGS((RgSchUeCb *ueCb));
-EXTERN U8 rgSchfillPucchCqiRepNumCountemtc ARGS((RgSchUePCqiCb *cqiCb, RgSchUeCb *ueCb));
+EXTERN uint8_t rgSchfillPucchSrRepNumCountemtc ARGS((RgSchUeCb *ueCb));
+EXTERN uint8_t rgSchfillPucchCqiRepNumCountemtc ARGS((RgSchUePCqiCb *cqiCb, RgSchUeCb *ueCb));
EXTERN S16 rgEmtcvalidateSiCfg ARGS((RgrSiCfgReqInfo *siCfg,RgSchCellCb *cell));
#endif
/* forward references */
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_CELL_CFG;
/* check if cell exists already */
- if ((U8 *)cell != NULLP)
+ if ((uint8_t *)cell != NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Cell Id already exists");
return RFAILED;
if (cellCfg->phichCfg.ngEnum > RGR_NG_TWO)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid PHICH Ng configuration %d",
- (U8)cellCfg->phichCfg.ngEnum);
+ (uint8_t)cellCfg->phichCfg.ngEnum);
return RFAILED;
}
/* Validation for extended PHICH Duration */
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid cfi value for"
"Extended PHICH duration cfi:%d dlBw:%d",
- (U8)cellCfg->cfiCfg.cfi, cellCfg->bwCfg.dlTotalBw);
+ (uint8_t)cellCfg->cfiCfg.cfi, cellCfg->bwCfg.dlTotalBw);
return RFAILED;
}
if ((cellCfg->phichCfg.isDurExtend == TRUE) &&
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid cfi value for"
"Extended PHICH duration cfi:%d dlBw:%d",
- (U8)cellCfg->cfiCfg.cfi, cellCfg->bwCfg.dlTotalBw);
+ (uint8_t)cellCfg->cfiCfg.cfi, cellCfg->bwCfg.dlTotalBw);
return RFAILED;
}
RLOG4(L_INFO,"CA_DBG:: PUCCH configuration:"
if (cellCfg->srsCfg.isSrsCfgSetup && cellCfg->srsCfg.srsBwEnum > RGR_SRS_BWCFG_7)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId, "Invalid SRS configuration: "
- " srsBw %d", (U8)cellCfg->srsCfg.srsBwEnum);
+ " srsBw %d", (uint8_t)cellCfg->srsCfg.srsBwEnum);
return RFAILED;
}
#ifdef RGR_V1
if(cellCfg->rachCfg.contResTmr)
{
- U8 idx;
+ uint8_t idx;
#ifdef LTE_TDD
idx = cellCfg->ulDlCfgIdx;
#else
#endif
/* maxMsg4TxDelay = (HARQ_RTT * MAX_MSG4_HARQ_RETX) +
3 TTI (MAX L1+L2 processing delay at the UE) */
- U8 maxMsg4TxDelay = (cellCfg->dlHqCfg.maxMsg4HqTx-1) *
+ uint8_t maxMsg4TxDelay = (cellCfg->dlHqCfg.maxMsg4HqTx-1) *
rgSchCmnHarqRtt[idx] + 3;
|| (ueCfg->txMode.txModeEnum > RGR_UE_TM_7)))
{
RLOG_ARG2(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid transmission mode for"
- " UE is %d", ueCfg->cellId,(U8)ueCfg->txMode.txModeEnum);
+ " UE is %d", ueCfg->cellId,(uint8_t)ueCfg->txMode.txModeEnum);
return RFAILED;
}
if (ueCfg->ueCatEnum > CM_LTE_UE_CAT_8)
{
RLOG_ARG2(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid category for UE %d",
- ueCfg->cellId,(U8)ueCfg->ueCatEnum);
+ ueCfg->cellId,(uint8_t)ueCfg->ueCatEnum);
return RFAILED;
}
{
RLOG_ARG2(L_ERROR,DBG_CRNTI,ueCfg->crnti,"CELLID:%d Invalid transmission mode for"
" UE (%d) for the configured Cell Antenna Ports",ueCfg->cellId,
- (U8)ueCfg->txMode.txModeEnum);
+ (uint8_t)ueCfg->txMode.txModeEnum);
return RFAILED;
}
}
if (cellRecfg->srsRecfg.isSrsCfgSetup && cellRecfg->srsRecfg.srsBwEnum > RGR_SRS_BWCFG_7)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Invalid SRS configuration: "
- "srsBw %d", (U8)cellRecfg->srsRecfg.srsBwEnum);
+ "srsBw %d", (uint8_t)cellRecfg->srsRecfg.srsBwEnum);
return RFAILED;
}
RgSchErrInfo *err;
#endif
{
- U8 idx;
+ uint8_t idx;
Inst inst = cell->instIdx;
RgSchCellCb *secCellCb = NULLP;
- U8 sCellidx = 0;
+ uint8_t sCellidx = 0;
RgSchUeCellInfo *sCellInfo = NULLP;
RgrUeSecCellCfg *sCellInfoCfg = NULLP;
#ifdef TFU_UPGRADE
{
Inst inst = cell->instIdx;
RgrUeSCellAckPucchCfg *sCellPucchRecfg = NULLP;
- U8 idx;
+ uint8_t idx;
RGSCHDBGINFONEW(inst, (rgSchPBuf(inst),
"--------------------------------------------------------------------\n"
return RFAILED;
}
- for(U8 idx = 0; idx < ueRecfg->ueSCellCfgInfo.numSCells; idx++)
+ for(uint8_t idx = 0; idx < ueRecfg->ueSCellCfgInfo.numSCells; idx++)
{
ueSCellDedCfg = &ueRecfg->ueSCellCfgInfo.ueSCellDedCfg[idx];
if(ROK != rgSchUtlVldtCellId(inst, ueSCellDedCfg->sCellId))
(ueSCellDedCfg->txMode.txModeEnum > RGR_UE_TM_9))
{
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst), "SCELL Invalid transmission mode for"
- " UE %d\n", (U8)ueSCellDedCfg->txMode.txModeEnum));
+ " UE %d\n", (uint8_t)ueSCellDedCfg->txMode.txModeEnum));
return RFAILED;
}
#endif
ue->ueId, cell->cellId));
/* Free all Added scell in this transaction */
- for(U8 idx = 0; idx < ueRecfg->ueSCellCfgInfo.numSCells; idx++)
+ for(uint8_t idx = 0; idx < ueRecfg->ueSCellCfgInfo.numSCells; idx++)
{
sCellInfoCfg = &ueRecfg->ueSCellCfgInfo.ueSCellDedCfg[idx];
sCellInfo = ue->cellInfo[(sCellInfoCfg->sCellIdx)];
((*ue)->csgMmbrSta == ueRecfg->csgMmbrSta))
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"UE ID [%d] invalid CSG Membership reconfig :%d ",
- ueRecfg->newCrnti, (U8)ueRecfg->csgMmbrSta);
+ ueRecfg->newCrnti, (uint8_t)ueRecfg->csgMmbrSta);
return RFAILED;
}
/* Validate values */
(ueRecfg->txMode.txModeEnum > RGR_UE_TM_7)))
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid transmission mode %d"
- "for NEW CRNTI:%d", (U8)ueRecfg->txMode.txModeEnum,ueRecfg->newCrnti);
+ "for NEW CRNTI:%d", (uint8_t)ueRecfg->txMode.txModeEnum,ueRecfg->newCrnti);
return RFAILED;
}
#ifndef TFU_UPGRADE
(ueRecfg->prdDlCqiRecfg.cqiPmiCfgIdx > 1024))))
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid Periodic CQI INFO"
- "OLD CRNTI:%d NEW CRNTI:%d",(U8)ueRecfg->oldCrnti,ueRecfg->newCrnti);
+ "OLD CRNTI:%d NEW CRNTI:%d",(uint8_t)ueRecfg->oldCrnti,ueRecfg->newCrnti);
return RFAILED;
}
#endif
(ueRecfg->prdDlCqiRecfg.prdModeEnum > RGR_PRD_CQI_MOD21))
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid periodic mode config for"
- " DL CQI %d NEW CRNTI:%d", (U8)ueRecfg->prdDlCqiRecfg.prdModeEnum,ueRecfg->newCrnti);
+ " DL CQI %d NEW CRNTI:%d", (uint8_t)ueRecfg->prdDlCqiRecfg.prdModeEnum,ueRecfg->newCrnti);
return RFAILED;
}
#else
(ueRecfg->cqiCfg.cqiSetup.prdModeEnum > RGR_PRD_CQI_MOD21))
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid periodic mode config for "
- "DL CQI %d for NEW CRNTI:%d",(U8)ueRecfg->cqiCfg.cqiSetup.prdModeEnum,ueRecfg->newCrnti);
+ "DL CQI %d for NEW CRNTI:%d",(uint8_t)ueRecfg->cqiCfg.cqiSetup.prdModeEnum,ueRecfg->newCrnti);
return RFAILED;
}
#endif /* TFU_UPGRADE */
if (ueRecfg->ueCatEnum > CM_LTE_UE_CAT_8)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid category %d for NEW CRNTI:%d",
- (U8)ueRecfg->ueCatEnum,ueRecfg->newCrnti);
+ (uint8_t)ueRecfg->ueCatEnum,ueRecfg->newCrnti);
return RFAILED;
}
(*cell)->bwCfg.dlTotalBw <= 7)))
{
RLOG_ARG2(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid aperiodic mode config for"
- " DL CQI %d for NEW CRNTI:%d", (U8)ueRecfg->aprdDlCqiRecfg.aprdModeEnum,ueRecfg->newCrnti);
+ " DL CQI %d for NEW CRNTI:%d", (uint8_t)ueRecfg->aprdDlCqiRecfg.aprdModeEnum,ueRecfg->newCrnti);
return RFAILED;
}
if ((ueRecfg->ueRecfgTypes & RGR_UE_ULPWR_RECFG) &&
RgrCellCfg *cellCfg;
#endif
{
- U8 cfi;
+ uint8_t cfi;
#ifdef LTE_TDD
- U8 ulDlCfgIdx = cellCfg->ulDlCfgIdx;
- U8 mphIdx;
- U8 maxMPhich;
- U16 numDlSf;
+ uint8_t ulDlCfgIdx = cellCfg->ulDlCfgIdx;
+ uint8_t mphIdx;
+ uint8_t maxMPhich;
+ uint16_t numDlSf;
#endif
cell->dynCfiCb.isDynCfiEnb = cellCfg->isDynCfiEnb;
/* Allocating memory for CCE failure average array based on
* monitoring interval and CCE failure sample period */
if((rgSCHUtlAllocSBuf(cell->instIdx, (Data**)&(cell->dynCfiCb.cceFailSamples),
- (cell->dynCfiCb.numFailSamples * sizeof(U16)))) != ROK)
+ (cell->dynCfiCb.numFailSamples * sizeof(uint16_t)))) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
return RFAILED;
RgrCellCfg *cellCfg;
#endif
{
- U8 idx;
+ uint8_t idx;
for(idx = 0; idx < MAX_5GTF_GROUP; idx++)
{
#endif
#ifdef XEON_LMT_ITBS
-EXTERN U16 gWrMaxDlItbs;
-EXTERN U16 gWrMaxUlItbs;
+EXTERN uint16_t gWrMaxDlItbs;
+EXTERN uint16_t gWrMaxUlItbs;
#endif
/**
* @brief Handler for the cell configuration request from RRM to MAC.
#endif
{
S16 ret;
- U8 idx;
+ uint8_t idx;
Pst pst;
RgInfCellReg cellRegReq;
RgSchCellCb *cell = NULLP;
Inst inst = instCb->rgSchInit.inst;
- U32 Idx1 = (U8)((cellCfg->cellId - instCb->genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
+ uint32_t Idx1 = (uint8_t)((cellCfg->cellId - instCb->genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
errInfo->errCause = RGSCHERR_CFG_RGR_CELL_CFG;
}
}
#endif
- if ((U8 *)cell == NULLP)
+ if ((uint8_t *)cell == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
return RFAILED;
{
cell->lteAdvCb.absCfg =
cellCfg->rgrLteAdvCfg.absCfg;
- memset(cell->lteAdvCb.absLoadInfo, 0, sizeof(U32)*RGR_ABS_PATTERN_LEN);
+ memset(cell->lteAdvCb.absLoadInfo, 0, sizeof(uint32_t)*RGR_ABS_PATTERN_LEN);
cell->lteAdvCb.absLoadTtiCnt = 0;
}
RgSchRaCb *raCb=NULLP;
RgSchUeCb *ue = NULLP;
Inst inst = cell->instIdx;
- U32 lcgCnt;
+ uint32_t lcgCnt;
RgSchDlHqEnt *hqEnt = NULLP;
#ifdef LTE_TDD
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 maxSubframes ;
- U8 maxDlSubframes;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t maxSubframes ;
+ uint8_t maxDlSubframes;
#endif
- U32 idx = 0;
+ uint32_t idx = 0;
#ifdef TFU_UPGRADE
RgSchUePCqiCb *cqiCb = NULLP;
#endif
/* Allocate the Ue control block */
if (((rgSCHUtlAllocSBuf(inst, (Data **)&ue, sizeof(RgSchUeCb))) != ROK) ||
- ((U8 *)ue == NULLP))
+ ((uint8_t *)ue == NULLP))
{
RLOG_ARG1(L_ERROR,DBG_CELLID,ueCfg->cellId, "Memory allocation"
" FAILED for CRNTI:%d", ueCfg->crnti);
}
#else
{
- U8 cellIdx=0;
+ uint8_t cellIdx=0;
for (cellIdx = 0;cellIdx < MAX_5GTF_CELL ; cellIdx++)
{
for (idx =0;idx < ue->dl.numHqDlSfInfo; idx++)
rgSCHUtlUpdPhr(cell, ue, raCb->phr.val, errInfo);
}
- RETVOID;
+ return;
}
/**
Bool isDynCfiEnb;
#endif
{
- U8 idx;
+ uint8_t idx;
RgSchCmnDlCell *cellSchDl = RG_SCH_CMN_GET_DL_CELL(cell);
if(isDynCfiEnb)
S16 ret;
Inst inst = cell->instIdx;
/* LTE_ADV_FLAG_REMOVED_START */
- U8 i = 0;
- U16 len; /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
+ uint8_t i = 0;
+ uint16_t len; /* dsfr_pal_fixes ** 21-March-2013 ** SKS */
/* LTE_ADV_FLAG_REMOVED_END */
errInfo->errCause = RGSCHERR_CFG_RGR_CELL_RECFG;
}
}
/*Calculating the length of RNTP array based on Dl Bandwidth */
- len = (U16)((cell->bwCfg.dlTotalBw % 8 == 0) ? (cell->bwCfg.dlTotalBw/8) : (cell->bwCfg.dlTotalBw/8 + 1)); /* KW fix for LTE_ADV */
+ len = (uint16_t)((cell->bwCfg.dlTotalBw % 8 == 0) ? (cell->bwCfg.dlTotalBw/8) : (cell->bwCfg.dlTotalBw/8 + 1)); /* KW fix for LTE_ADV */
if(cell->rntpAggrInfo.pres == NOTPRSNT)
{
if((rgSCHUtlAllocSBuf(inst, (Data**)&(cell->rntpAggrInfo.val),
- (len * sizeof(U8)))) != ROK)
+ (len * sizeof(uint8_t)))) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,
"Memory allocation FAILED for RNTP Alloc");
#endif
{
#ifdef LTE_ADV
- U8 sCellIdx;
+ uint8_t sCellIdx;
#endif
S16 ret;
RgSchRaCb *raCb;
RgSchRaCb *oldRaCb;
RgSchDlHqEnt **hqEnt = &(RG_SCH_CMN_GET_UE_HQE(ue, cell));
- U8 idx;
+ uint8_t idx;
/* Handle CRNTI change in reconfiguration */
if (ueRecfg->oldCrnti != ueRecfg->newCrnti)
RgSchErrInfo *errInfo;
#endif
{
- U32 idx;
+ uint32_t idx;
RgSchRaCb *raCb;
errInfo->errCause = RGSCHERR_CFG_RGR_UE_RESET;
#ifdef LTE_ADV
if(ueDelInfo->u.ueScellRel.ueDelTypes & RGR_UE_SCELL_DEL_RECFG)
{
- for(U8 idx = 0; idx < ueDelInfo->u.ueScellRel.ueSCellRelCfgInfo.numSCells; idx++)
+ for(uint8_t idx = 0; idx < ueDelInfo->u.ueScellRel.ueSCellRelCfgInfo.numSCells; idx++)
{
if(NULLP != (secCellCb = (RgSchCellCb *)rgSchUtlGetCellCb(inst, \
ueDelInfo->u.ueScellRel.ueSCellRelCfgInfo.ueSCellRelDedCfg[idx].sCellId)))
RgSchUeCb *ue;
RgSchDlLcCb *dlLc;
#ifdef LTE_L2_MEAS
- U8 lcId;
- U8 idx;
+ uint8_t lcId;
+ uint8_t idx;
RgSchUlLcCb *ulLc;
#endif
{
RgSchUeCb *ue = NULLP;
#ifdef LTE_L2_MEAS
- U8 lcCount = 0;
+ uint8_t lcCount = 0;
#endif
- U8 lcgId = 0;
+ uint8_t lcgId = 0;
lcgId = lcDelInfo->u.lcgDel.lcgId;
RgSchErrInfo *errInfo;
#endif
{
- U8 idx;
+ uint8_t idx;
RgrCmnLchCfg *lcCfg;
- U8 dirVld = FALSE;
- U8 bitMask = 0x00;
- U8 cnt=0;
+ uint8_t dirVld = FALSE;
+ uint8_t bitMask = 0x00;
+ uint8_t cnt=0;
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_CMN_LC_CFG;
#endif
{
- U8 idx = 0;
+ uint8_t idx = 0;
/* peridicity validation done in SPS module */
if ((dlSpsCfg->numPucchVal > RG_SCH_MAX_NUM_N1PUCCH_PER_UE) ||
"Downlink LCId:%d CRNTI:%d", lcCfg->lcId,lcCfg->crnti);
return RFAILED;
}
- if ((U8 *)dlLc == NULLP)
+ if ((uint8_t *)dlLc == NULLP)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,lcCfg->cellId,"Memory allocation FAILED for "
"Downlink LCID:%d CRNTI:%d", lcCfg->lcId,lcCfg->crnti);
#ifdef RG_UNUSED
//#ifdef LTE_L2_MEAS
- U32 idx;
+ uint32_t idx;
RgSchUlLcCb *ulLc;
#endif
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Memory allocation FAILED for ");
return RFAILED;
}
- if ((U8 *)ulLc == NULLP)
+ if ((uint8_t *)ulLc == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Memory allocation FAILED for ");
return RFAILED;
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHCfgFreeDlDedLcCb */
memset(cmnDlLc, 0, sizeof(*cmnDlLc));
cmnDlLc->lcId = RGSCH_INVALID_LC_ID;
- RETVOID;
+ return;
} /* rgSCHCfgFreeDlCmnLcCb */
Buffer *pdu;
RgSchWarningSiInfo *warningSi;
RgSchWarningSiPdu *warningSiPdu;
- U8 idx;
+ uint8_t idx;
/* ccpu00132385- SI Warning PDUs which are not processed need to be deleted */
/* Search for used index in WarningSi */
(Void)rgSCHDrxCellDel(cell);
rgSCHUtlFreeSBuf(inst, (Data**)&(cell->dynCfiCb.cceFailSamples),
- (cell->dynCfiCb.numFailSamples * sizeof(U16)));
+ (cell->dynCfiCb.numFailSamples * sizeof(uint16_t)));
#ifdef TENB_STATS
TSL2DeallocCellStatsBlk(cell->cellId);
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHCfgFreeCellCb */
RgUeUlHqCb *ulHqEnt;
RgSchDlLcCb *dlLc;
Inst inst = cell->instIdx;
- U8 lcCnt;
- U8 lcgId;
+ uint8_t lcCnt;
+ uint8_t lcgId;
/* Free all logical channel info per UE */
while((dlLc = rgSCHDbmGetNextDlDedLcCb(ue, NULLP)) != NULLP)
rgSCHUtlFreeSBuf(inst, (Data **)&ue, sizeof(*ue));
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHCfgFreeUeCb */
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHCfgFreeRgrCfgLst */
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHCfgFreeCmnLcLst */
#endif
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHCfgFreeUeLst */
RgrSiCfg *siCfg;
#endif
{
- U8 idx; /* idx for iteration */
+ uint8_t idx; /* idx for iteration */
UNUSED(inst);
(
Inst inst,
RgrLteAdvancedCellConfig *lteAdvCfg,
- U8 dlTotalBw
+ uint8_t dlTotalBw
)
#else
PRIVATE S16 rgSCHCfgVldtRgrCellLteAdvCfg(inst, lteAdvCfg, dlTotalBw)
Inst inst;
RgrLteAdvancedCellConfig *lteAdvCfg;
- U8 dlTotalBw;
+ uint8_t dlTotalBw;
#endif
{
- U8 temp[RGR_ABS_PATTERN_LEN];
- U32 idx;
+ uint8_t temp[RGR_ABS_PATTERN_LEN];
+ uint32_t idx;
UNUSED(inst);
if((lteAdvCfg->pres & RGR_SFR) && (RGR_ENABLE == lteAdvCfg->sfrCfg.status))
#endif
{
MsgLen msgLen = 0;
- U8 numSi;
+ uint8_t numSi;
errInfo->errCause = RGSCHERR_CFG_INVALID_RGR_SI_CFG;
#endif
#endif
{
- U16 srsPeri=0;
- U16 srsOffset=0;
- U8 srsSubframe=0;
+ uint16_t srsPeri=0;
+ uint16_t srsOffset=0;
+ uint8_t srsSubframe=0;
if ( RGR_SCH_SRS_SETUP == srsCfg->type )
{
CmLteUeCategory ueCat;
#endif
{
- U8 M; /*Num of Subbands -- Applicable only for Mode 2-0 and 2-2*/
- U8 k; /*SubBand Size (RB) --
+ uint8_t M; /*Num of Subbands -- Applicable only for Mode 2-0 and 2-2*/
+ uint8_t k; /*SubBand Size (RB) --
Holds different values depending on Mode*/
- U8 cqiPmiSzR1; /*CQIPMI Size for Rank =1*/
- U8 cqiPmiSzRn1; /*CQIPMI Size for Rank > 1*/
+ uint8_t cqiPmiSzR1; /*CQIPMI Size for Rank =1*/
+ uint8_t cqiPmiSzRn1; /*CQIPMI Size for Rank > 1*/
cqiPmiSzR1 = 0;
cqiPmiSzRn1 = 0;
#endif
{
CmLteTimingInfo timingInfo;
- U16 crntTime;
- U16 cqiTrInstTime;
- U8 j; /*Bandwidth Parts*/
- U8 temp;
- U8 loop;
+ uint16_t crntTime;
+ uint16_t cqiTrInstTime;
+ uint8_t j; /*Bandwidth Parts*/
+ uint8_t temp;
+ uint8_t loop;
RgSchUePCqiCb *cqiCb = NULLP;
crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)+
if(RGR_UE_PCQI_SB_REP == cqiCfg->cqiSetup.cqiRepType)
{
- U8 k; /*SubBand Size (RB) */
+ uint8_t k; /*SubBand Size (RB) */
RG_SCH_GET_CQI_J_VAL(cellCb->bwCfg.dlTotalBw, j);
RG_SCH_GET_CQI_K_VAL(cellCb->bwCfg.dlTotalBw, k);
cqiCb->J = j; /*Number of Bandwidth Parts*/
CmLteUeCategory ueCat;
#endif
{
- U16 crntTime;
- U16 riTrInsTime;
- U8 j; /*Bandwidth parts. Valid for Modes 2-0, 2-1*/
- U16 periodicity;
- U16 tempIdx;
+ uint16_t crntTime;
+ uint16_t riTrInsTime;
+ uint8_t j; /*Bandwidth parts. Valid for Modes 2-0, 2-1*/
+ uint16_t periodicity;
+ uint16_t tempIdx;
RgSchUePCqiCb *cqiCb = NULLP;
crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
% RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
if(periodicity >= RG_SCH_PCQI_SRS_SR_TRINS_SIZE)
{
- cqiCb->riDist = rgSCHUtlFindDist((U16)(crntTime + TFU_RECPREQ_DLDELTA),
- (U16) tempIdx);
+ cqiCb->riDist = rgSCHUtlFindDist((uint16_t)(crntTime + TFU_RECPREQ_DLDELTA),
+ (uint16_t) tempIdx);
}
else
{
RgrUeUlSrsCfg *srsCfg;
#endif
{
- U16 srsTrInsTime;
- U16 crntTime;
- U16 tempIdx;
+ uint16_t srsTrInsTime;
+ uint16_t crntTime;
+ uint16_t tempIdx;
crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
+(cellCb->crntTime.slot);
{
tempIdx = tempIdx + ueCb->srsCb.peri;
}
- ueCb->srsCb.nSrsTrIdx =(U16) (tempIdx
+ ueCb->srsCb.nSrsTrIdx =(uint16_t) (tempIdx
% RG_SCH_PCQI_SRS_SR_TRINS_SIZE);
if(ueCb->srsCb.peri >= RG_SCH_PCQI_SRS_SR_TRINS_SIZE)
{
#ifdef LTE_TDD
- ueCb->srsCb.srsDist = rgSCHUtlFindDist((U8)(crntTime+TFU_DELTA),
- (U16)tempIdx);
+ ueCb->srsCb.srsDist = rgSCHUtlFindDist((uint8_t)(crntTime+TFU_DELTA),
+ (uint16_t)tempIdx);
#else
- ueCb->srsCb.srsDist = rgSCHUtlFindDist((U8)(crntTime + TFU_RECPREQ_DLDELTA),
- (U16)tempIdx);
+ ueCb->srsCb.srsDist = rgSCHUtlFindDist((uint8_t)(crntTime + TFU_RECPREQ_DLDELTA),
+ (uint16_t)tempIdx);
#endif
}
else
RgrUeSrCfg *srCfg;
#endif
{
- U16 srTrInsTime;
- U16 crntTime;
+ uint16_t srTrInsTime;
+ uint16_t crntTime;
crntTime = (cellCb->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
#endif
{
#ifdef LTE_ADV
- U32 cellIdx;
- U32 sCellCnt = 0;
+ uint32_t cellIdx;
+ uint32_t sCellCnt = 0;
#endif
RgSchUePCqiCb *cqiRiCb = NULLP;
* find the periodicty, offset for a given config index from the table
* - Return ROK
* @param[in] RgSchPerTbl tbl
- * @param[in] U16 cfgIdx
- * @param[out] U16 *peri
- * @param[out] U16 *offset
+ * @param[in] uint16_t cfgIdx
+ * @param[out] uint16_t *peri
+ * @param[out] uint16_t *offset
*
* @return S16
* -# ROK
S16 rgSCHUtlGetCfgPerOff
(
RgSchPerTbl tbl,
- U16 cfgIdx,
- U16 *peri,
- U16 *offset
+ uint16_t cfgIdx,
+ uint16_t *peri,
+ uint16_t *offset
)
#else
S16 rgSCHUtlGetCfgPerOff ( tbl, cfgIdx, peri, offset)
RgSchPerTbl tbl;
- U16 cfgIdx;
- U16 *peri;
- U16 *offset;
+ uint16_t cfgIdx;
+ uint16_t *peri;
+ uint16_t *offset;
#endif
{
- U8 mid;
- U8 min = 0;
- U8 max = 0;
+ uint8_t mid;
+ uint8_t min = 0;
+ uint8_t max = 0;
CONSTANT RgSchUePCqiSrsSrCfgIdxTbl* table;
/* Added the function instead of the MACRO to get the
* for decoding.
*
* Ret : Void
- * ROK - RETVOID
+ * ROK - void
*
* Notes:
*
PRIVATE Void rgSCHCfgUtlFetchAcqiBitSz
(
RgSchUeACqiCb *acqiCb,
- U8 numTxAnt,
- U8* cqiPmiSzR1,
- U8* cqiPmiSzRn1
+ uint8_t numTxAnt,
+ uint8_t* cqiPmiSzR1,
+ uint8_t* cqiPmiSzRn1
)
#else
PRIVATE Void rgSCHCfgUtlFetchAcqiBitSz(acqiCb, numTxAnt, cqiPmiSzR1, cqiPmiSzRn1)
RgSchUeACqiCb *acqiCb;
- U8 numTxAnt;
- U8* cqiPmiSzR1;
- U8* cqiPmiSzRn1;
+ uint8_t numTxAnt;
+ uint8_t* cqiPmiSzR1;
+ uint8_t* cqiPmiSzRn1;
#endif
{
- U32 confRepMode;
+ uint32_t confRepMode;
confRepMode = acqiCb->aCqiCfg.aprdModeEnum;
switch(confRepMode)
default:
break;
}
- RETVOID;
+ return;
}
/* Added the function rgSCHCfgUtlGetPcqiCrsSrRiTbl to be used
* instead of the MACRO RG_SCH_GET_PERIODICITY_TBL */
* Desc : Get the Srs Cqi Crs Ri Table
*
* Ret : Void
- * ROK - RETVOID
+ * ROK - void
*
* Notes:
*
PRIVATE CONSTANT RgSchUePCqiSrsSrCfgIdxTbl * rgSCHCfgUtlGetPcqiSrsSrRiTbl
(
RgSchPerTbl tblType,
- U8* min,
- U8* max
+ uint8_t* min,
+ uint8_t* max
)
#else
PRIVATE CONSTANT RgSchUePCqiSrsSrCfgIdxTbl * rgSCHCfgUtlGetPcqiSrsSrRiTbl(tblType, min, max)
RgSchPerTbl tblType;
- U8* min;
- U8* max;
+ uint8_t* min;
+ uint8_t* max;
#endif
{
CONSTANT RgSchUePCqiSrsSrCfgIdxTbl * table;
#ifdef ANSI
PRIVATE S16 rgSCHCfgVldtDrxOnDurCfg
(
-U8 onDurTmr
+uint8_t onDurTmr
)
#else
PRIVATE S16 rgSCHCfgVldtDrxOnDurCfg(onDurTmr)
-U8 onDurTmr;
+uint8_t onDurTmr;
#endif
{
#ifdef ANSI
PRIVATE S16 rgSCHCfgVldtDrxInActvCfg
(
-U16 inActvTmr
+uint16_t inActvTmr
)
#else
PRIVATE S16 rgSCHCfgVldtDrxInActvCfg(inActvTmr)
-U16 inActvTmr;
+uint16_t inActvTmr;
#endif
{
switch ( inActvTmr )
#ifdef ANSI
PRIVATE S16 rgSCHCfgVldtDrxReTxCfg
(
-U8 reTxTmr
+uint8_t reTxTmr
)
#else
PRIVATE S16 rgSCHCfgVldtDrxReTxCfg(reTxTmr)
-U8 reTxTmr;
+uint8_t reTxTmr;
#endif
{
switch ( reTxTmr )
#ifdef ANSI
PRIVATE S16 rgSCHCfgVldtDrxLngCyclTmrs
(
-U16 val
+uint16_t val
)
#else
PRIVATE S16 rgSCHCfgVldtDrxLngCyclTmrs(val)
-U16 val;
+uint16_t val;
#endif
{
rgSCHTmrStartTmr(cell, ueCb, RG_SCH_TMR_TA, ueCb->dl.taCb.cfgTaTmr);
}
}
- RETVOID;
+ return;
} /* rgSCHCfgUeTaRecfg */
/* ccpu00117452 - MOD - Changed macro name from
PRIVATE S16 rgSchAddToL2Meas(RgSchCellCb *cellCb,RgSchDlLcCb *dlLc)
{
CmLList *lnk;
- U16 idx;
+ uint16_t idx;
RgSchL2MeasCb *measCb = NULLP;
lnk = cellCb->l2mList.first;
* @param[in] Inst inst
* @param[in] RgSchUeCb *ue
* @param[int] RgrUeRecfg *ueRecfg
- * @param[out] U8 idx
+ * @param[out] uint8_t idx
* @return VOID
**/
#ifdef ANSI
Inst inst,
RgSchUeCb *ue,
RgrUeRecfg *ueRecfg,
-U8 idx
+uint8_t idx
)
#else
Void rgSCHSCellFreeBuf(inst ,ue, ueRecfg, idx)
Inst inst;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
-U8 idx;
+uint8_t idx;
#endif
{
RgSchUeCellInfo *sCellInfo = NULLP;
RgrUeSecCellCfg *sCellInfoRecfg = NULLP;
- for(U8 i = 0; i <= idx; i++)
+ for(uint8_t i = 0; i <= idx; i++)
{
sCellInfoRecfg = &ueRecfg->ueSCellCfgInfo.ueSCellDedCfg[i];
sCellInfo = ue->cellInfo[(sCellInfoRecfg->sCellIdx)];
}
}
- RETVOID;
+ return;
}
#endif
/**********************************************************************
{
RgSchRrCList *first; /* first entry in list */
RgSchRrCList *crnt; /* entry last accessed */
- U32 count; /* number of entries */
+ uint32_t count; /* number of entries */
};
EXTERN Void rgSCHRrCListInit ARGS ((RgSchRrCListCp *lList));
#endif /* __cplusplus */
#ifdef EMTC_ENABLE
-EXTERN U32 emtcStatsUlTomSrInd;
-EXTERN U32 emtcStatsUlBsrTmrTxp;
+EXTERN uint32_t emtcStatsUlTomSrInd;
+EXTERN uint32_t emtcStatsUlBsrTmrTxp;
#endif
#define RG_ITBS_DIFF(_x, _y) ((_x) > (_y) ? (_x) - (_y) : (_y) - (_x))
EXTERN S16 rgSCHCmnPrecompEmtcMsg3Vars
ARGS((
RgSchCmnUlCell *cellUl,
-U8 ccchCqi,
-U16 msgSzA,
-U8 sbSize,
+uint8_t ccchCqi,
+uint16_t msgSzA,
+uint8_t sbSize,
Bool isEcp
));
Void rgSCHEmtcCmnUeCcchSduDel
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlSf *dlSf,
-U8 rbStrt,
-U8 numRb
+uint8_t rbStrt,
+uint8_t numRb
);
PRIVATE S16 rgSCHCmnBuildRntpInfo (
RgSchCellCb *cell,
-U8 *rntpPtr,
-U8 startRb,
-U8 nmbRb,
-U16 bw
+uint8_t *rntpPtr,
+uint8_t startRb,
+uint8_t nmbRb,
+uint16_t bw
);
#endif
PRIVATE Void rgSCHCmnNonDlfsType0Alloc
RgSchDlRbAlloc *allocInfo,
RgSchUeCb *ue
);
-PRIVATE U8 rgSchCmnUlRvIdxToIMcsTbl[4] = {32, 30, 31, 29};
+PRIVATE uint8_t rgSchCmnUlRvIdxToIMcsTbl[4] = {32, 30, 31, 29};
PRIVATE Void rgSCHCmnUlNonadapRetx ARGS((
RgSchCmnUlCell *cellUl,
RgSchUlAlloc *alloc,
-U8 idx
+uint8_t idx
));
PRIVATE Void rgSCHCmnUlSfRlsRetxProcs ARGS((
RgSchCellCb *cell,
PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 maxRb,
-U32 *numSb,
-U8 *iTbs,
-U32 hqSz,
-U32 stepDownItbs,
-U32 effTgt
+uint32_t maxRb,
+uint32_t *numSb,
+uint8_t *iTbs,
+uint32_t hqSz,
+uint32_t stepDownItbs,
+uint32_t effTgt
));
#endif
PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1 ARGS((
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
));
PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A ARGS((
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
));
PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B ARGS((
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
));
PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2 ARGS((
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
));
PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A ARGS((
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
));
#endif
PRIVATE Void rgSCHCmnGetRefreshPer ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
- U32 *waitPer));
+ uint32_t *waitPer));
PRIVATE S16 rgSCHCmnApplyUeRefresh ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue));
#endif
#ifdef LTE_TDD
-PRIVATE U32 rgSCHCmnCalcDwPtsTbSz ARGS
+PRIVATE uint32_t rgSCHCmnCalcDwPtsTbSz ARGS
((
RgSchCellCb *cell,
-U32 bo,
-U8 *rb,
-U8 *iTbs,
-U8 lyr,
-U8 cfi
+uint32_t bo,
+uint8_t *rb,
+uint8_t *iTbs,
+uint8_t lyr,
+uint8_t cfi
));
PRIVATE Void rgSCHCmnCalcDwPtsTbSz2Cw ARGS
((
RgSchCellCb *cell,
-U32 bo,
-U8 *rb,
-U8 maxRb,
-U8 *iTbs1,
-U8 *iTbs2,
-U8 lyr1,
-U8 lyr2,
-U32 *tb1Sz,
-U32 *tb2Sz,
-U8 cfi
+uint32_t bo,
+uint8_t *rb,
+uint8_t maxRb,
+uint8_t *iTbs1,
+uint8_t *iTbs2,
+uint8_t lyr1,
+uint8_t lyr2,
+uint32_t *tb1Sz,
+uint32_t *tb2Sz,
+uint8_t cfi
));
#endif
#endif
typedef Void (*RgSchCmnDlAllocRbFunc) ARGS((RgSchCellCb *cell, RgSchDlSf *subFrm,
-RgSchUeCb *ue, U32 bo, U32 *effBo, RgSchDlHqProcCb *proc,
+RgSchUeCb *ue, uint32_t bo, uint32_t *effBo, RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo));
-typedef U8 (*RgSchCmnDlGetPrecInfFunc) ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
- U8 numLyrs, Bool bothCwEnbld));
+typedef uint8_t (*RgSchCmnDlGetPrecInfFunc) ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
+ uint8_t numLyrs, Bool bothCwEnbld));
PRIVATE Void rgSCHCmnDlAllocTxRbTM1 ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
#ifdef LTE_ADV
-PRIVATE U8 rgSchGetN1ResCount ARGS ((
+PRIVATE uint8_t rgSchGetN1ResCount ARGS ((
RgSchUeCb *ue,
- U16 servCellId
+ uint16_t servCellId
));
Bool rgSchCmnChkDataOnlyOnPcell
(
RgSchDlSf *dlSf
);
#endif /*LTE_ADV */
-U8 rgSCHCmnCalcPcqiBitSz
+uint8_t rgSCHCmnCalcPcqiBitSz
(
RgSchUeCb *ueCb,
- U8 numTxAnt
+ uint8_t numTxAnt
);
#ifndef LTE_ADV
#endif
-PRIVATE U8 rgSCHCmnDlTM3PrecInf2 ARGS((
+PRIVATE uint8_t rgSCHCmnDlTM3PrecInf2 ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
));
-PRIVATE U8 rgSCHCmnDlTM3PrecInf4 ARGS((
+PRIVATE uint8_t rgSCHCmnDlTM3PrecInf4 ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
));
-PRIVATE U8 rgSCHCmnDlTM4PrecInf2 ARGS((
+PRIVATE uint8_t rgSCHCmnDlTM4PrecInf2 ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
));
-PRIVATE U8 rgSCHCmnDlTM4PrecInf4 ARGS((
+PRIVATE uint8_t rgSCHCmnDlTM4PrecInf4 ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
));
/* Functions specific to each transmission mode for DL RB Allocation*/
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqTbCb *tbInfo,
-U8 noLyr,
-U8 *numRb,
-U32 *effBo
+uint8_t noLyr,
+uint8_t *numRb,
+uint32_t *effBo
));
PRIVATE S16 rgSCHCmnDlAlloc2CwRetxRb ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc,
-U8 *numRb,
+uint8_t *numRb,
Bool *swpFlg,
-U32 *effBo
+uint32_t *effBo
));
PRIVATE Void rgSCHCmnDlTM3TxTx ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
PRIVATE Void rgSCHCmnNonDlfsUpdTyp2Alloc ARGS((
RgSchCellCb *cell,
RgSchDlSf *dlSf,
-U8 rbStrt,
-U8 numRb
+uint8_t rbStrt,
+uint8_t numRb
));
/* LTE_ADV_FLAG_REMOVED_START */
#ifndef LTE_TDD
PRIVATE Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc ARGS((
RgSchCellCb *cell,
RgSchDlSf *dlSf,
-U8 rbStrt,
-U8 numRb
+uint8_t rbStrt,
+uint8_t numRb
));
#endif
/* LTE_ADV_FLAG_REMOVED_END */
RgSchUeCb *ue,
RgSchDlHqTbCb *reTxTb,
RgSchDlHqTbCb *txTb,
-U8 *numRb,
-U32 *effBo
+uint8_t *numRb,
+uint32_t *effBo
));
PRIVATE S16 rgSCHCmnDlAlloc2CwTxRb ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc,
-U32 bo,
-U8 *numRb,
-U32 *effBo
+uint32_t bo,
+uint8_t *numRb,
+uint32_t *effBo
));
PRIVATE S16 rgSCHCmnDlAlloc1CwTxRb ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqTbCb *tbInfo,
-U32 bo,
-U8 *numRb,
-U32 *effBo
+uint32_t bo,
+uint8_t *numRb,
+uint32_t *effBo
));
#ifndef LTEMAC_SPS
PRIVATE Void rgSCHCmnFillHqPTb ARGS((
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
-U8 tbAllocIdx,
+uint8_t tbAllocIdx,
RgSchPdcch *pdcch
));
#endif
#ifdef LTEMAC_SPS
PRIVATE Void rgSCHCmnDlGetBestFitHole ARGS((
-U32 *allocMask,
-U8 numMaskRbs,
-U32 *crntAllocMask,
-U8 rbsReq,
-U8 *allocStart,
-U8 *allocNumRbs,
+uint32_t *allocMask,
+uint8_t numMaskRbs,
+uint32_t *crntAllocMask,
+uint8_t rbsReq,
+uint8_t *allocStart,
+uint8_t *allocNumRbs,
Bool isPartialAlloc
));
#ifdef RGSCH_SPS_UNUSED
-PRIVATE U32 rgSCHCmnGetRaType1Mask ARGS((
-U8 rbIdx,
-U8 rbgSize,
-U8 *type1Subset
+PRIVATE uint32_t rgSCHCmnGetRaType1Mask ARGS((
+uint8_t rbIdx,
+uint8_t rbgSize,
+uint8_t *type1Subset
));
#endif
-PRIVATE U32 rgSCHCmnGetRaType0Mask ARGS((
-U8 rbIdx,
-U8 rbgSize
+PRIVATE uint32_t rgSCHCmnGetRaType0Mask ARGS((
+uint8_t rbIdx,
+uint8_t rbgSize
));
-PRIVATE U32 rgSCHCmnGetRaType2Mask ARGS((
-U8 rbIdx,
-U8 *maskIdx
+PRIVATE uint32_t rgSCHCmnGetRaType2Mask ARGS((
+uint8_t rbIdx,
+uint8_t *maskIdx
));
#endif
RgSchDlHqProcCb *proc
));
-U16 rgSCHCmnGetSiSetId ARGS((
-U16 sfn,
-U8 sf,
-U16 minPeriodicity
+uint16_t rgSCHCmnGetSiSetId ARGS((
+uint16_t sfn,
+uint8_t sf,
+uint16_t minPeriodicity
));
#ifdef RG_5GTF
//TODO_SID: Currenly table is only for 100 Prbs. Need to modify wrt VRBG table 8.1.5.2.1-1 V5G_213
-U32 rgSch5gtfTbSzTbl[MAX_5GTF_MCS] =
+uint32_t rgSch5gtfTbSzTbl[MAX_5GTF_MCS] =
{1864, 5256, 8776, 13176, 17576, 21976, 26376, 31656, 35176, 39576, 43976, 47496, 52776, 59376, 66392};
-U32 g5gtfTtiCnt = 0;
-U32 gUl5gtfSrRecv = 0;
-U32 gUl5gtfBsrRecv = 0;
-U32 gUl5gtfUeSchPick = 0;
-U32 gUl5gtfPdcchSchd = 0;
-U32 gUl5gtfAllocAllocated = 0;
-U32 gUl5gtfUeRbAllocDone = 0;
-U32 gUl5gtfUeRmvFnlzZeroBo = 0;
-U32 gUl5gtfUeFnlzReAdd = 0;
-U32 gUl5gtfPdcchSend = 0;
-U32 gUl5gtfRbAllocFail = 0;
-U32 ul5gtfsidUlMarkUl = 0;
-U32 ul5gtfsidDlSchdPass = 0;
-U32 ul5gtfsidDlAlreadyMarkUl = 0;
-U32 ul5gtfTotSchdCnt = 0;
+uint32_t g5gtfTtiCnt = 0;
+uint32_t gUl5gtfSrRecv = 0;
+uint32_t gUl5gtfBsrRecv = 0;
+uint32_t gUl5gtfUeSchPick = 0;
+uint32_t gUl5gtfPdcchSchd = 0;
+uint32_t gUl5gtfAllocAllocated = 0;
+uint32_t gUl5gtfUeRbAllocDone = 0;
+uint32_t gUl5gtfUeRmvFnlzZeroBo = 0;
+uint32_t gUl5gtfUeFnlzReAdd = 0;
+uint32_t gUl5gtfPdcchSend = 0;
+uint32_t gUl5gtfRbAllocFail = 0;
+uint32_t ul5gtfsidUlMarkUl = 0;
+uint32_t ul5gtfsidDlSchdPass = 0;
+uint32_t ul5gtfsidDlAlreadyMarkUl = 0;
+uint32_t ul5gtfTotSchdCnt = 0;
#endif
/* CQI Offset Index to Beta CQI Offset value mapping,
* stored as parts per 1000. Reserved is set to 0.
* Refer 36.213 sec 8.6.3 Tbl 8.6.3-3 */
-U32 rgSchCmnBetaCqiOffstTbl[16] = {0, 0, 1125,
+uint32_t rgSchCmnBetaCqiOffstTbl[16] = {0, 0, 1125,
1250, 1375, 1625, 1750, 2000, 2250, 2500, 2875,
3125, 3500, 4000, 5000, 6250};
-U32 rgSchCmnBetaHqOffstTbl[16] = {2000, 2500, 3125,
+uint32_t rgSchCmnBetaHqOffstTbl[16] = {2000, 2500, 3125,
4000, 5000, 6250, 8000,10000, 12625, 15875, 20000,
31000, 50000,80000,126000,0};
-U32 rgSchCmnBetaRiOffstTbl[16] = {1250, 1625, 2000,
+uint32_t rgSchCmnBetaRiOffstTbl[16] = {1250, 1625, 2000,
2500, 3125, 4000, 5000, 6250, 8000, 10000,12625,
15875,20000,0,0,0};
S8 rgSchCmnDlCqiDiffOfst[8] = {0, 1, 2, 3, -4, -3, -2, -1};
/* Include CRS REs while calculating Efficiency */
-CONSTANT PRIVATE U8 rgSchCmnAntIdx[5] = {0,0,1,0,2};
-CONSTANT PRIVATE U8 rgSchCmnNumResForCrs[5] = {0,6,12,0,16};
-U32 cfiSwitchCnt ;
-U32 cfiIncr ;
-U32 cfiDecr ;
+CONSTANT PRIVATE uint8_t rgSchCmnAntIdx[5] = {0,0,1,0,2};
+CONSTANT PRIVATE uint8_t rgSchCmnNumResForCrs[5] = {0,6,12,0,16};
+uint32_t cfiSwitchCnt ;
+uint32_t cfiIncr ;
+uint32_t cfiDecr ;
#ifdef TFU_UPGRADE
{
TfuDciFormat spfcDciFrmt; /* TM(Transmission Mode) specific DCI format.
* Search space : UE Specific by C-RNTI only. */
- U8 spfcDciRAType; /* Resource Alloctn(RA) type for spfcDciFrmt */
+ uint8_t spfcDciRAType; /* Resource Alloctn(RA) type for spfcDciFrmt */
TfuDciFormat prfrdDciFrmt; /* Preferred DCI format among the available
* options for TD (Transmit Diversity) */
- U8 prfrdDciRAType; /* Resource Alloctn(RA) type for prfrdDciFrmt */
+ uint8_t prfrdDciRAType; /* Resource Alloctn(RA) type for prfrdDciFrmt */
}RgSchCmnDlUeDciFrmtOptns;
#ifndef LTE_ADV
typedef struct rgSchCmnDlImcsTbl
{
- U8 modOdr; /* Modulation Order */
- U8 iTbs; /* ITBS */
+ uint8_t modOdr; /* Modulation Order */
+ uint8_t iTbs; /* ITBS */
}RgSchCmnDlImcsTbl[29];
CONSTANT struct rgSchCmnMult235Info
{
- U8 match; /* Closest number satisfying 2^a.3^b.5^c, with a bias
+ uint8_t match; /* Closest number satisfying 2^a.3^b.5^c, with a bias
* towards the smaller number */
- U8 prvMatch; /* Closest number not greater than array index
+ uint8_t prvMatch; /* Closest number not greater than array index
* satisfying 2^a.3^b.5^c */
} rgSchCmnMult235Tbl[110+1] = {
{0, 0}, /* dummy */
/* This table maps a (delta_offset * 2 + 2) to a (beta * 8)
* where beta is 10^-(delta_offset/10) rounded off to nearest 1/8
*/
-PRIVATE U16 rgSchCmnUlBeta8Tbl[29] = {
+PRIVATE uint16_t rgSchCmnUlBeta8Tbl[29] = {
6, RG_SCH_CMN_UL_INVALID_BETA8, 8, 9, 10, 11, 13, 14, 16, 18, 20, 23,
25, 28, 32, RG_SCH_CMN_UL_INVALID_BETA8, 40, RG_SCH_CMN_UL_INVALID_BETA8,
50, RG_SCH_CMN_UL_INVALID_BETA8, 64, RG_SCH_CMN_UL_INVALID_BETA8, 80,
#endif
/* QCI to SVC priority mapping. Index specifies the Qci*/
-PRIVATE U8 rgSchCmnDlQciPrio[RG_SCH_CMN_MAX_QCI] = RG_SCH_CMN_QCI_TO_PRIO;
+PRIVATE uint8_t rgSchCmnDlQciPrio[RG_SCH_CMN_MAX_QCI] = RG_SCH_CMN_QCI_TO_PRIO;
/* The configuration is efficiency measured per 1024 REs. */
/* The first element stands for when CQI is not known */
/* ADD CQI to MCS mapping correction
* single dimensional array is replaced by 2 dimensions for different CFI*/
-PRIVATE U16 rgSchCmnCqiPdschEff[4][16] = {RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI0 ,RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI1,
+PRIVATE uint16_t rgSchCmnCqiPdschEff[4][16] = {RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI0 ,RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI1,
RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI2,RG_SCH_CMN_CQI_TO_PDSCH_EFF_CFI3};
-PRIVATE U16 rgSchCmn2LyrCqiPdschEff[4][16] = {RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI0 ,RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI1,
+PRIVATE uint16_t rgSchCmn2LyrCqiPdschEff[4][16] = {RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI0 ,RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI1,
RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI2, RG_SCH_CMN_2LYR_CQI_TO_PDSCH_EFF_CFI3};
/* This configuration determines the transalation of a UEs CQI to its */
/* PDCCH coding efficiency. This may be edited based on the installation */
-PRIVATE U8 rgSchCmnDlRvTbl[4] = {0, 2, 3, 1}; /* RVIdx sequence is corrected*/
+PRIVATE uint8_t rgSchCmnDlRvTbl[4] = {0, 2, 3, 1}; /* RVIdx sequence is corrected*/
/* Indexed by [DciFrmt].
* Considering the following definition in determining the dciFrmt index.
TFU_DCI_FORMAT_3A
} TfuDciFormat;
*/
-PRIVATE U16 rgSchCmnDciFrmtSizes[10];
+PRIVATE uint16_t rgSchCmnDciFrmtSizes[10];
-PRIVATE U16 rgSchCmnCqiPdcchEff[16] = RG_SCH_CMN_CQI_TO_PDCCH_EFF;
+PRIVATE uint16_t rgSchCmnCqiPdcchEff[16] = RG_SCH_CMN_CQI_TO_PDCCH_EFF;
#ifdef LTE_TDD
/* SPS_INTG_FIX */
#ifdef LTEMAC_SPS
-U8 rgSchTddSpsDlMaxRetxTbl[RGSCH_MAX_TDD_UL_DL_CFG] = {
+uint8_t rgSchTddSpsDlMaxRetxTbl[RGSCH_MAX_TDD_UL_DL_CFG] = {
/* 0 */ 6,
/* 1 */ 7,
/* 2 */ 8,
/* PDSCH to PUCCH Table for DL Harq Feed back. Based on the
Downlink association set index 'K' table */
-U8 rgSchTddPucchTxTbl[7][10] = {
+uint8_t rgSchTddPucchTxTbl[7][10] = {
{4, 6, 0, 0, 0, 4, 6, 0, 0, 0},
{7, 6, 0, 0, 4, 7, 6, 0, 0, 4},
{7, 6, 0, 4, 8, 7, 6, 0, 4, 8},
So at sf4 the new CFI can be applied. To arrive at sf4 from
sf0, the sfIdx has to be increased by 3 */
-U8 rgSchTddPdcchSfIncTbl[7][10] = {
+uint8_t rgSchTddPdcchSfIncTbl[7][10] = {
/* A/N Bundl: 0,1,5,6*/ {2, 1, 0, 0, 0, 2, 1, 0, 0, 0},
/* A/N Bundl: 0,4,5,9*/ {2, 2, 0, 0, 3, 2, 2, 0, 0, 3},
/* A/N Bundl: 4,9*/ {3, 6, 0, 5, 4, 3, 6, 0, 5, 4},
#endif /* (LTEMAC_SPS ) */
/* Number of Uplink subframes Table */
-PRIVATE U8 rgSchTddNumUlSf[] = {6, 4, 2, 3, 2, 1, 5};
+PRIVATE uint8_t rgSchTddNumUlSf[] = {6, 4, 2, 3, 2, 1, 5};
/* Downlink HARQ processes Table */
RgSchTddUlNumHarqProcTbl rgSchTddUlNumHarqProcTbl = { 7, 4, 2, 3, 2, 1, 6};
/* DwPTS Scheduling Changes Start */
/* Provides the number of Cell Reference Signals in DwPTS
* region per RB */
-PRIVATE U8 rgSchCmnDwptsCrs[2][3] = {/* [Spl Sf cfg][Ant Port] */
+PRIVATE uint8_t rgSchCmnDwptsCrs[2][3] = {/* [Spl Sf cfg][Ant Port] */
{4, 8, 16}, /* Spl Sf cfg 1,2,3,6,7,8 */
{6, 12, 20}, /* Spl Sf cfg 4 */
};
#endif
-PRIVATE U32 rgSchCmnBsrTbl[64] = {
+PRIVATE uint32_t rgSchCmnBsrTbl[64] = {
0, 10, 12, 14, 17, 19, 22, 26,
31, 36, 42, 49, 57, 67, 78, 91,
107, 125, 146, 171, 200, 234, 274, 321,
58255, 68201, 79846, 93479, 109439, 128125, 150000, 220000
};
-PRIVATE U32 rgSchCmnExtBsrTbl[64] = {
+PRIVATE uint32_t rgSchCmnExtBsrTbl[64] = {
0, 10, 13, 16, 19, 23, 29, 35,
43, 53, 65, 80, 98, 120, 147, 181,
223, 274, 337, 414, 509, 625, 769, 945,
867737, 1067031, 1312097, 1613447, 1984009, 2439678, 3000000, 3100000
};
-U8 rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_MAX_CP][RG_SCH_CMN_UL_NUM_CQI];
+uint8_t rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_MAX_CP][RG_SCH_CMN_UL_NUM_CQI];
RgSchTbSzTbl rgTbSzTbl = {
{
/* [ccpu00138532]-ADD-The below table stores the min HARQ RTT time
in Downlink for TDD and FDD. Indices 0 to 6 map to tdd UL DL config 0-6.
Index 7 map to FDD */
-U8 rgSchCmnHarqRtt[8] = {4,7,10,9,12,15,6,8};
+uint8_t rgSchCmnHarqRtt[8] = {4,7,10,9,12,15,6,8};
/* Number of CFI Switchover Index is equals to 7 TDD Indexes + 1 FDD index */
-U8 rgSchCfiSwitchOvrWinLen[] = {7, 4, 2, 3, 2, 1, 6, 8};
+uint8_t rgSchCfiSwitchOvrWinLen[] = {7, 4, 2, 3, 2, 1, 6, 8};
/* EffTbl is calculated for single layer and two layers.
* CqiToTbs is calculated for single layer and two layers */
));
RgSchUeCb* rgSCHCmnGetHoUe ARGS((
RgSchCellCb *cell,
-U16 rapId
+uint16_t rapId
));
PRIVATE Void rgSCHCmnDelDedPreamble ARGS((
RgSchCellCb *cell,
-U8 preambleId
+uint8_t preambleId
));
RgSchUeCb* rgSCHCmnGetPoUe ARGS((
RgSchCellCb *cell,
-U16 rapId,
+uint16_t rapId,
CmLteTimingInfo timingInfo
));
PRIVATE Void rgSCHCmnDelRachInfo ARGS((
RgSchCellCb *cell,
RgSchUlSf *sf,
RgSchUeCb *ue,
-U8 maxRb
+uint8_t maxRb
));
PRIVATE Void rgSCHCmnHdlHoPo ARGS((
RgSchCellCb *cell,
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchPdcch *pdcc,
-U8 rapId,
-U8 prachMskIdx
+uint8_t rapId,
+uint8_t prachMskIdx
));
PRIVATE Void rgSCHCmnDlAdd2PdcchOdrQ ARGS((
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchUeCb *ue,
RgSchPdcch **pdcch,
-U8 *rapId,
-U8 *prachMskIdx
+uint8_t *rapId,
+uint8_t *prachMskIdx
));
PRIVATE Void rgSCHCmnGenPdcchOrder ARGS((
RgSchCellCb *cell,
PRIVATE Void rgSCHCmnAddUeToRefreshQ ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 wait
+uint32_t wait
));
PRIVATE Void rgSCHCmnDlCcchRetx ARGS((
RgSchCellCb *cell,
PRIVATE Void rgSCHCmnUlRbAllocForLst ARGS((
RgSchCellCb *cell,
RgSchUlSf *sf,
- U32 count,
+ uint32_t count,
CmLListCp *reqLst,
CmLListCp *schdLst,
CmLListCp *nonSchdLst,
RgSchCellCb *cell,
RgSchUlSf *sf,
RgSchUeCb *ue,
- U8 maxRb,
+ uint8_t maxRb,
RgSchUlHole *hole
));
PRIVATE Void rgSCHCmnMsg3GrntReq ARGS((
Bool preamGrpA,
RgSchUlHqProcCb *hqProc,
RgSchUlAlloc **ulAllocRef,
- U8 *hqProcIdRef
+ uint8_t *hqProcIdRef
));
PRIVATE Void rgSCHCmnDlCcchRarAlloc ARGS((
RgSchCellCb *cell
RgSchCellCb *cell,
RgSchDlSf *sf,
RgSchClcDlLcCb *lch,
-U16 rnti,
+uint16_t rnti,
RgSchCmnDlRbAllocInfo *allocInfo
));
#ifndef LTEMAC_SPS
PRIVATE Void rgSCHCmnClcRbAlloc ARGS((
RgSchCellCb *cell,
-U32 bo,
-U8 cqi,
-U8 *rb,
-U32 *tbs,
-U8 *mcs,
+uint32_t bo,
+uint8_t cqi,
+uint8_t *rb,
+uint32_t *tbs,
+uint8_t *mcs,
RgSchDlSf *sf
));
#endif
PRIVATE S16 rgSCHCmnRaRspAlloc ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
-U16 rntiIdx,
-U16 rarnti,
-U8 noRaRnti,
+uint16_t rntiIdx,
+uint16_t rarnti,
+uint8_t noRaRnti,
RgSchCmnDlRbAllocInfo *allocInfo
));
PRIVATE Void rgSCHCmnUlUeDelAllocs ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeRecfg *ueRecfg,
-U8 numTxPorts
+uint8_t numTxPorts
));
#else
PRIVATE Void rgSCHCmnDlHdlTxModeRecfg ARGS
PRIVATE Void rgSCHCmnNonDlfsPbchRbAllocAdj ARGS((
RgSchCellCb *cell,
RgSchDlRbAlloc *cmnAllocInfo,
-U8 pbchSsRsSym,
+uint8_t pbchSsRsSym,
Bool isBcchPcch
));
/* Added function to adjust TBSize*/
PRIVATE Void rgSCHCmnNonDlfsPbchTbSizeAdj ARGS((
RgSchDlRbAlloc *allocInfo,
-U8 numOvrlapgPbchRb,
-U8 pbchSsRsSym,
-U8 idx,
-U32 bytesReq
+uint8_t numOvrlapgPbchRb,
+uint8_t pbchSsRsSym,
+uint8_t idx,
+uint32_t bytesReq
));
/* Added function to find num of overlapping PBCH rb*/
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchDlRbAlloc *allocInfo,
-U8 *numOvrlapgPbchRb
+uint8_t *numOvrlapgPbchRb
));
-PRIVATE U8 rgSCHCmnFindNumAddtlRbsAvl ARGS((
+PRIVATE uint8_t rgSCHCmnFindNumAddtlRbsAvl ARGS((
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchDlRbAlloc *allocInfo
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchDlRbAlloc *allocInfo,
-U8 idx
+uint8_t idx
));
#endif
#endif
PRIVATE Void rgSCHCmnNonDlfsMsg4Alloc ARGS((
RgSchCellCb *cell,
RgSchCmnMsg4RbAlloc *msg4AllocInfo,
-U8 isRetx
+uint8_t isRetx
));
PRIVATE S16 rgSCHCmnNonDlfsMsg4RbAlloc ARGS((
RgSchCellCb *cell,
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlSf *dlSf,
-U8 *isDlBwAvail
+uint8_t *isDlBwAvail
));
#ifndef LTEMAC_SPS
-PRIVATE U32 rgSCHCmnCalcRiv ARGS(( U8 bw,
- U8 rbStart,
- U8 numRb));
+PRIVATE uint32_t rgSCHCmnCalcRiv ARGS(( uint8_t bw,
+ uint8_t rbStart,
+ uint8_t numRb));
#endif
#ifdef LTE_TDD
RgSchDlHqProcCb *hqP,
RgSchDlSf *subFrm,
RgSchDlHqTbCb *tbCb,
-U8 tbAllocIdx
+uint8_t tbAllocIdx
));
PRIVATE S16 rgSCHCmnUlCalcAvailBw ARGS((
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
-U8 cfi,
-U8 *rbStartRef,
-U8 *bwAvailRef
+uint8_t cfi,
+uint8_t *rbStartRef,
+uint8_t *bwAvailRef
));
PRIVATE S16 rgSCHCmnDlKdashUlAscInit ARGS((
RgSchCellCb *cell
PRIVATE S16 rgSCHCmnDlCpyRachInfo ARGS((
RgSchCellCb *cell,
RgSchTddRachRspLst rachRspLst[][RGSCH_NUM_SUB_FRAMES],
-U8 raArrSz
+uint8_t raArrSz
));
PRIVATE S16 rgSCHCmnDlRachInfoInit ARGS((
RgSchCellCb *cell
((
RgSchCellCb *cell,
RgSchUeCb *ue,
- U8 wideCqi
+ uint8_t wideCqi
));
PRIVATE RgSchCmnRank rgSCHCmnComputeRank ARGS
((
RgrTxMode txMode,
- U32 *pmiBitMap,
- U8 numTxPorts
+ uint32_t *pmiBitMap,
+ uint8_t numTxPorts
));
PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode3 ARGS
((
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
));
PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode3 ARGS
((
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
));
PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode4 ARGS
((
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
));
PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode4 ARGS
((
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
));
- PRIVATE U8 rgSCHCmnCalcWcqiFrmSnr ARGS
+ PRIVATE uint8_t rgSCHCmnCalcWcqiFrmSnr ARGS
((
RgSchCellCb *cell,
TfuSrsRpt *srsRpt
*
* Invoked by: Scheduler
*
- * @param[in] U8 noPdcchSym
- * @param[in] U8 cpType
- * @param[in] U8 txAntIdx
+ * @param[in] uint8_t noPdcchSym
+ * @param[in] uint8_t cpType
+ * @param[in] uint8_t txAntIdx
* @param[in] RgSchCmnTbSzEff* effTbl
* @return Void
*
#ifdef ANSI
PRIVATE Void rgSCHCmnCompEff
(
-U8 noPdcchSym,
-U8 cpType,
-U8 txAntIdx,
+uint8_t noPdcchSym,
+uint8_t cpType,
+uint8_t txAntIdx,
RgSchCmnTbSzEff *effTbl
)
#else
PRIVATE Void rgSCHCmnCompEff(noPdcchSym, cpType, txAntIdx, effTbl)
-U8 noPdcchSym;
-U8 cpType;
-U8 txAntIdx;
+uint8_t noPdcchSym;
+uint8_t cpType;
+uint8_t txAntIdx;
RgSchCmnTbSzEff *effTbl;
#endif
{
- U8 noResPerRb;
- U8 noSymPerRb;
- U8 resOfCrs; /* Effective REs occupied by CRS */
- U8 i, j;
+ uint8_t noResPerRb;
+ uint8_t noSymPerRb;
+ uint8_t resOfCrs; /* Effective REs occupied by CRS */
+ uint8_t i, j;
switch (cpType)
break;
default:
/* Generate a log error. This case should never be executed */
- RETVOID;
+ return;
}
/* Depending on the Tx Antenna Index, deduct the
break;
default:
/* Generate a log error. This case should never be executed */
- RETVOID;
+ return;
}
noResPerRb = ((noSymPerRb - noPdcchSym) * RB_SCH_CMN_NUM_SCS_PER_RB) - resOfCrs;
for (i = 0; i < RG_SCH_CMN_NUM_TBS; i++)
}
(*effTbl)[i] /= RG_SCH_CMN_NUM_RBS;
}
- RETVOID;
+ return;
}
/**
* @brief This function computes efficiency and stores in a table.
*
* Invoked by: Scheduler
*
- * @param[in] U8 noUlRsSym
- * @param[in] U8 cpType
- * @param[in] U8 txAntIdx
+ * @param[in] uint8_t noUlRsSym
+ * @param[in] uint8_t cpType
+ * @param[in] uint8_t txAntIdx
* @param[in] RgSchCmnTbSzEff* effTbl
* @return Void
*
#ifdef ANSI
PRIVATE Void rgSCHCmnCompUlEff
(
-U8 noUlRsSym,
-U8 cpType,
+uint8_t noUlRsSym,
+uint8_t cpType,
RgSchCmnTbSzEff *effTbl
)
#else
PRIVATE Void rgSCHCmnCompUlEff(noUlRsSym, cpType, effTbl)
-U8 noUlRsSym;
-U8 cpType;
+uint8_t noUlRsSym;
+uint8_t cpType;
RgSchCmnTbSzEff *effTbl;
#endif
{
- U8 noResPerRb;
- U8 noSymPerRb;
- U8 i, j;
+ uint8_t noResPerRb;
+ uint8_t noSymPerRb;
+ uint8_t i, j;
switch (cpType)
break;
default:
/* Generate a log error. This case should never be executed */
- RETVOID;
+ return;
}
noResPerRb = ((noSymPerRb - noUlRsSym) * RB_SCH_CMN_NUM_SCS_PER_RB);
}
(*effTbl)[i] /= RG_SCH_CMN_NUM_RBS;
}
- RETVOID;
+ return;
}
/**
*
* Invoked by: Scheduler
*
- * @param[in] U8 noPdcchSym
- * @param[in] U8 cpType
- * @param[in] U8 txAntIdx
+ * @param[in] uint8_t noPdcchSym
+ * @param[in] uint8_t cpType
+ * @param[in] uint8_t txAntIdx
* @param[in] RgSchCmnTbSzEff* effTbl2Lyr
* @return Void
*
#ifdef ANSI
PRIVATE Void rgSCHCmn2LyrCompEff
(
-U8 noPdcchSym,
-U8 cpType,
-U8 txAntIdx,
+uint8_t noPdcchSym,
+uint8_t cpType,
+uint8_t txAntIdx,
RgSchCmnTbSzEff *effTbl2Lyr
)
#else
PRIVATE Void rgSCHCmn2LyrCompEff(noPdcchSym, cpType, txAntIdx, effTbl2Lyr)
-U8 noPdcchSym;
-U8 cpType;
-U8 txAntIdx;
+uint8_t noPdcchSym;
+uint8_t cpType;
+uint8_t txAntIdx;
RgSchCmnTbSzEff *effTbl2Lyr;
#endif
{
- U8 noResPerRb;
- U8 noSymPerRb;
- U8 resOfCrs; /* Effective REs occupied by CRS */
- U8 i, j;
+ uint8_t noResPerRb;
+ uint8_t noSymPerRb;
+ uint8_t resOfCrs; /* Effective REs occupied by CRS */
+ uint8_t i, j;
switch (cpType)
break;
default:
/* Generate a log error. This case should never be executed */
- RETVOID;
+ return;
}
/* Depending on the Tx Antenna Index, deduct the
break;
default:
/* Generate a log error. This case should never be executed */
- RETVOID;
+ return;
}
noResPerRb = ((noSymPerRb - noPdcchSym) * RB_SCH_CMN_NUM_SCS_PER_RB) - resOfCrs;
}
(*effTbl2Lyr)[i] /= RG_SCH_CMN_NUM_RBS;
}
- RETVOID;
+ return;
}
\f
/* DCI Format 3A size determination */
rgSchCmnDciFrmtSizes[9] = rgSchCmnDciFrmtSizes[0];
- RETVOID;
+ return;
}
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 i;
- U8 j;
+ uint8_t i;
+ uint8_t j;
for (i = 0; i < RG_SCH_CMN_MAX_CQI; i++)
{
for (j = 0; j < 10; j++)
{
- U32 pdcchBits; /* Actual number of phy bits needed for a given DCI Format
+ uint32_t pdcchBits; /* Actual number of phy bits needed for a given DCI Format
* for a given CQI Level */
pdcchBits = (rgSchCmnDciFrmtSizes[j] * 1024)/rgSchCmnCqiPdcchEff[i];
/* V5G_211 : 6.6 */
cellSch->dciAggrLvl[i][j] = CM_LTE_AGGR_LVL16;
}
}
- RETVOID;
+ return;
}
\f
/**
PRIVATE Void rgSCHCmnDlInit()
#endif
{
- U8 i;
+ uint8_t i;
S16 j;
S16 k;
- U8 idx;
+ uint8_t idx;
RgSchCmnTbSzEff *effTbl;
RgSchCmnCqiToTbs *tbsTbl;
for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
{
/* EfficiencyTbl calculation incase of 2 layers for normal CP */
- rgSCHCmnCompEff((U8)(i + 1), RG_SCH_CMN_NOR_CP, idx,\
+ rgSCHCmnCompEff((uint8_t)(i + 1), RG_SCH_CMN_NOR_CP, idx,\
rgSchCmnEffTbl[0][RG_SCH_CMN_NOR_CP][idx][i]);
- rgSCHCmn2LyrCompEff((U8)(i + 1), RG_SCH_CMN_NOR_CP, idx, \
+ rgSCHCmn2LyrCompEff((uint8_t)(i + 1), RG_SCH_CMN_NOR_CP, idx, \
rgSchCmnEffTbl[1][RG_SCH_CMN_NOR_CP][idx][i]);
}
}
* single dimensional array is replaced by 2 dimensions for different CFI*/
if ((*effTbl)[j] <= rgSchCmnCqiPdschEff[i][k])
{
- (*tbsTbl)[k--] = (U8)j;
+ (*tbsTbl)[k--] = (uint8_t)j;
}
}
for (; k > 0; --k)
* single dimensional array is replaced by 2 dimensions for different CFI*/
if ((*effTbl)[j] <= rgSchCmn2LyrCqiPdschEff[i][k])
{
- (*tbsTbl)[k--] = (U8)j;
+ (*tbsTbl)[k--] = (uint8_t)j;
}
}
for (; k > 0; --k)
for (i = 0; i < RG_SCH_CMN_MAX_CFI; i++)
{
/* EfficiencyTbl calculation incase of 2 layers for extendedl CP */
- rgSCHCmnCompEff( (U8)(i + 1 ), (U8)RG_SCH_CMN_EXT_CP, idx,\
+ rgSCHCmnCompEff( (uint8_t)(i + 1 ), (uint8_t)RG_SCH_CMN_EXT_CP, idx,\
rgSchCmnEffTbl[0][RG_SCH_CMN_EXT_CP][idx][i]);
- rgSCHCmn2LyrCompEff((U8)(i + 1), (U8) RG_SCH_CMN_EXT_CP,idx, \
+ rgSCHCmn2LyrCompEff((uint8_t)(i + 1), (uint8_t) RG_SCH_CMN_EXT_CP,idx, \
rgSchCmnEffTbl[1][RG_SCH_CMN_EXT_CP][idx][i]);
}
}
* single dimensional array is replaced by 2 dimensions for different CFI*/
if ((*effTbl)[j] <= rgSchCmnCqiPdschEff[i][k])
{
- (*tbsTbl)[k--] = (U8)j;
+ (*tbsTbl)[k--] = (uint8_t)j;
}
}
for (; k > 0; --k)
* single dimensional array is replaced by 2 dimensions for different CFI*/
if ((*effTbl)[j] <= rgSchCmn2LyrCqiPdschEff[i][k])
{
- (*tbsTbl)[k--] = (U8)j;
+ (*tbsTbl)[k--] = (uint8_t)j;
}
}
for (; k > 0; --k)
}
}
}
- RETVOID;
+ return;
}
\f
/**
PRIVATE Void rgSCHCmnUlInit()
#endif
{
- U8 *mapTbl = &rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_NOR_CP][0];
+ uint8_t *mapTbl = &rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_NOR_CP][0];
RgSchCmnTbSzEff *effTbl = &rgSchCmnNorUlEff[0];
CONSTANT RgSchCmnUlCqiInfo *cqiTbl = &rgSchCmnUlCqiTbl[0];
S16 i;
{
if ((*effTbl)[i] <= cqiTbl[j].eff)
{
- mapTbl[j--] = (U8)i;
+ mapTbl[j--] = (uint8_t)i;
}
}
for (; j > 0; --j)
{
if ((*effTbl)[i] <= cqiTbl[j].eff)
{
- mapTbl[j--] = (U8)i;
+ mapTbl[j--] = (uint8_t)i;
}
}
for (; j > 0; --j)
mapTbl[j] = 0;
}
rgSCHPwrInit();
- RETVOID;
+ return;
}
/**
Void rgSCHCmnInit()
#endif
{
- U8 idx;
+ uint8_t idx;
rgSCHCmnDlInit();
rgSCHCmnUlInit();
rgSchCmnApis.rgSCHRgrSCellUeCfg = rgSCHCmnRgrSCellUeCfg;
rgSchCmnApis.rgSCHRgrSCellUeDel = rgSCHCmnRgrSCellUeDel;
#endif
- RETVOID;
+ return;
}
\f
/* Re-initialize DLFS specific information for the sub-frame */
cellSch->apisDlfs->rgSCHDlfsReinitSf(cell, sf);
}
- RETVOID;
+ return;
}
/* LTE_ADV_FLAG_REMOVED_END */
#endif
- RETVOID;
+ return;
}
#ifdef RGR_V1
}
}
}
- RETVOID;
+ return;
}
#endif
\f
}
}
}
- RETVOID;
+ return;
}
#ifdef RGR_V1
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchUeCb *ueCb;
RgSchDlHqProcCb *hqP;
- U8 retxBw = 0;
+ uint8_t retxBw = 0;
RgSchCmnDlUe *ueDl;
RgSchDlSf *dlSf = allocInfo->ccchSduAlloc.ccchSduDlSf;
}
}
dlSf->bwAssigned += retxBw;
- RETVOID;
+ return;
}
#endif
\f
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchRaCb *raCb;
RgSchDlHqProcCb *hqP;
- U8 retxBw = 0;
+ uint8_t retxBw = 0;
RgSchDlSf *dlSf = allocInfo->msg4Alloc.msg4DlSf;
}
}
dlSf->bwAssigned += retxBw;
- RETVOID;
+ return;
}
\f
if (bch == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on BCH is not configured");
- RETVOID;
+ return;
}
#endif
if (bch->boLst.first != NULLP)
if (bcch == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on DLSCH is not configured");
- RETVOID;
+ return;
}
#endif
if (bcch->boLst.first != NULLP)
if (bcch == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"BCCH on DLSCH is not configured");
- RETVOID;
+ return;
}
#endif
lnk = bcch->boLst.first;
if (pcch == NULLP)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"PCCH on DLSCH is not configured");
- RETVOID;
+ return;
}
#endif
if (pcch->boLst.first != NULLP)
rgSCHCmnClcAlloc(cell, sf, pcch, RGSCH_P_RNTI, allocInfo);
}
}
- RETVOID;
+ return;
}
/*
* @param[in] RgSchCellCb *cell,
* @param[in] RgSchDlSf *sf,
* @param[in] RgSchClcDlLcCb *lch,
- * @param[in] U16 rnti,
+ * @param[in] uint16_t rnti,
* @param[out] RgSchCmnDlRbAllocInfo *allocInfo
* @return Void
*
RgSchCellCb *cell,
RgSchDlSf *sf,
RgSchClcDlLcCb *lch,
-U16 rnti,
+uint16_t rnti,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
RgSchCellCb *cell;
RgSchDlSf *sf;
RgSchClcDlLcCb *lch;
-U16 rnti;
+uint16_t rnti;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchClcBoRpt *bo;
- U32 rb=0;
- U8 mcs;
- U32 tbs;
+ uint32_t rb=0;
+ uint8_t mcs;
+ uint32_t tbs;
#ifdef LTE_TDD
- U8 lostRe;
- U8 cfi = cellDl->currCfi;
+ uint8_t lostRe;
+ uint8_t cfi = cellDl->currCfi;
#endif
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"BW allocation "
"failed for CRNTI:%d",rnti);
- RETVOID;
+ return;
}
/* Update the subframe Allocated BW field */
allocInfo->pcchAlloc.tbInfo[0].noLyr = 1;
allocInfo->pcchAlloc.nPrb = bo->nPrb;
}
- RETVOID;
+ return;
}
\f
RgSchPdcchInfo *pdcchInfo;
RgSchPdcch *pdcch;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 numCce; /*store num CCEs based on
+ uint8_t numCce; /*store num CCEs based on
aggregation level */
aggrLvl = cellSch->dl.cmnChAggrLvl;
* Invoked by: Scheduler
*
* @param[in] RgSchCellCb* cell
- * @param[in] U32 bo
- * @param[in] U8 cqi
- * @param[in] U8 *rb
- * @param[in] U32 *tbs
- * @param[in] U8 *mcs
+ * @param[in] uint32_t bo
+ * @param[in] uint8_t cqi
+ * @param[in] uint8_t *rb
+ * @param[in] uint32_t *tbs
+ * @param[in] uint8_t *mcs
* @param[in] RgSchDlSf *sf
* @return Void
*
#ifdef ANSI
Void rgSCHCmnClcRbAlloc
(
-RgSchCellCb *cell,
-U32 bo,
-U8 cqi,
-U8 *rb,
-U32 *tbs,
-U8 *mcs,
-U8 *iTbs,
-Bool isSpsBo,
-RgSchDlSf *sf
+RgSchCellCb *cell,
+uint32_t bo,
+uint8_t cqi,
+uint8_t *rb,
+uint32_t *tbs,
+uint8_t *mcs,
+uint8_t *iTbs,
+Bool isSpsBo,
+RgSchDlSf *sf
)
#else
Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, iTbs, isSpsBo)
-RgSchCellCb *cell;
-U32 bo;
-U8 cqi;
-U8 *rb;
-U32 *tbs;
-U8 *mcs;
-U8 *iTbs;
-Bool isSpsBo;
-RgSchDlSf *sf;
+RgSchCellCb *cell;
+uint32_t bo;
+uint8_t cqi;
+uint8_t *rb;
+uint32_t *tbs;
+uint8_t *mcs;
+uint8_t *iTbs;
+Bool isSpsBo;
+RgSchDlSf *sf;
#endif
#else
#ifdef ANSI
PRIVATE Void rgSCHCmnClcRbAlloc
(
-RgSchCellCb *cell,
-U32 bo,
-U8 cqi,
-U8 *rb,
-U32 *tbs,
-U8 *mcs,
-RgSchDlSf *sf
+RgSchCellCb *cell,
+uint32_t bo,
+uint8_t cqi,
+uint8_t *rb,
+uint32_t *tbs,
+uint8_t *mcs,
+RgSchDlSf *sf
)
#else
PRIVATE Void rgSCHCmnClcRbAlloc(cell, bo, cqi, rb, tbs, mcs, sf)
-RgSchCellCb *cell;
-U32 bo;
-U8 cqi;
-U8 *rb;
-U32 *tbs;
-U8 *mcs;
-RgSchDlSf *sf;
+RgSchCellCb *cell;
+uint32_t bo;
+uint8_t cqi;
+uint8_t *rb;
+uint32_t *tbs;
+uint8_t *mcs;
+RgSchDlSf *sf;
#endif
#endif /* LTEMAC_SPS */
{
- U8 iTbsVal;
- RgSchCmnTbSzEff *effTbl;
- U32 eff;
- U32 noRes;
- RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 cfi = cellSch->dl.currCfi;
- U32 tmpRb=0;
+ uint8_t iTbsVal;
+ RgSchCmnTbSzEff *effTbl;
+ uint32_t eff;
+ uint32_t noRes;
+ RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
+ uint8_t cfi = cellSch->dl.currCfi;
+ uint32_t tmpRb=0;
/* first get the CQI to MCS table and determine the number of RBs */
effTbl = (RgSchCmnTbSzEff *)(cellSch->dl.cqiToEffTbl[0][cfi]);
RGSCH_ARRAY_BOUND_CHECK_WITH_POS_IDX(cell->instIdx, rgTbSzTbl[0][0], (tmpRb-1));
}
*tbs = rgTbSzTbl[0][iTbsVal][tmpRb-1]/8;
- *rb = (U8)tmpRb;
+ *rb = (uint8_t)tmpRb;
RG_SCH_CMN_DL_TBS_TO_MCS(iTbsVal, *mcs);
- RETVOID;
+ return;
}
\f
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlSf *subFrm,
-U8 cqi,
+uint8_t cqi,
TfuDciFormat dciFrmt,
Bool isDtx
)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlSf *subFrm;
-U8 cqi;
+uint8_t cqi;
TfuDciFormat dciFrmt;
Bool isDtx;
#endif
#endif
{
RgSchDlHqEnt *hqE = NULLP;
- U32 effBo;
+ uint32_t effBo;
RgSchDlRbAlloc *rbAllocinfo = NULLP;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U8 iTbs;
- U8 numRb;
+ uint8_t iTbs;
+ uint8_t numRb;
#ifdef LTE_TDD
- U8 cfi = cellDl->currCfi;
+ uint8_t cfi = cellDl->currCfi;
#endif
RgSchRaCb *raCb;
#endif
{
- U32 effBo;
+ uint32_t effBo;
RgSchDlRbAlloc *rbAllocinfo = &raCb->rbAllocInfo;
- U8 iTbs;
- U8 numRb;
+ uint8_t iTbs;
+ uint8_t numRb;
#ifdef LTE_TDD
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U8 cfi = cellDl->currCfi;
+ uint8_t cfi = cellDl->currCfi;
#endif
CmLteTimingInfo frm;
CmLteTimingInfo schFrm;
RgSchDlSf *subFrm;
- U16 rarnti;
- U8 i;
- U8 noRaRnti=0;
- U8 raIdx;
+ uint16_t rarnti;
+ uint8_t i;
+ uint8_t noRaRnti=0;
+ uint8_t raIdx;
RgSchTddRachRspLst *rachRsp;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 sfnIdx;
- U8 subfrmIdx;
- U16 rntiIdx=0;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t sfnIdx;
+ uint8_t subfrmIdx;
+ uint16_t rntiIdx=0;
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
}
}
- RETVOID;
+ return;
}
#else
/**
CmLteTimingInfo frm;
CmLteTimingInfo winStartFrm;
RgSchDlSf *subFrm;
- U8 winStartIdx;
- U8 winGap;
- U8 rarnti;
- U8 raIdx;
+ uint8_t winStartIdx;
+ uint8_t winGap;
+ uint8_t rarnti;
+ uint8_t raIdx;
RgSchCmnCell *sched;
- U8 i,noRaRnti=0;
+ uint8_t i,noRaRnti=0;
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
for response allocation */
}
}
- RETVOID;
+ return;
}
#endif
*
* @param[in] RgSchCellCb *cell,
* @param[in] RgSchDlSf *subFrm,
- * @param[in] U16 rarnti,
- * @param[in] U8 noRaRnti
+ * @param[in] uint16_t rarnti,
+ * @param[in] uint8_t noRaRnti
* @param[out] RgSchCmnDlRbAllocInfo *allocInfo
* @return S16
*
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
-U16 raIndex,
-U16 rarnti,
-U8 noRaRnti,
+uint16_t raIndex,
+uint16_t rarnti,
+uint8_t noRaRnti,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
PRIVATE S16 rgSCHCmnRaRspAlloc(cell,subFrm,raIndex,rarnti,noRaRnti,allocInfo)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
-U16 raIndex;
-U16 rarnti;
-U8 noRaRnti;
+uint16_t raIndex;
+uint16_t rarnti;
+uint8_t noRaRnti;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- U16 noBytes;
- U32 rb = 0;
- U32 tbs;
+ uint16_t noBytes;
+ uint32_t rb = 0;
+ uint32_t tbs;
/*ccpu00116700,ccpu00116708- Corrected the wrong type for mcs*/
- U8 mcs;
+ uint8_t mcs;
CmLListCp *reqLst;
/* RACH handling related changes */
Bool isAlloc = FALSE;
- static U8 schdNumRapid = 0;
- U8 remNumRapid = 0;
- U8 nPrb = 0;
+ static uint8_t schdNumRapid = 0;
+ uint8_t remNumRapid = 0;
+ uint8_t nPrb = 0;
S32 allwdTbSz = 0;
#ifdef LTE_TDD
- U16 lostRe;
- U8 cfi = cellDl->currCfi;
+ uint16_t lostRe;
+ uint8_t cfi = cellDl->currCfi;
#endif
#ifndef RGR_V1
/* rgSCHCmnClcRbAllocForFxdTb(cell, allwdTbSz/8, cellDl->ccchCqi, &rb);*/
if(cellDl->bitsPerRb==0)
{
- while ((rgTbSzTbl[0][0][rb]) <(U32) allwdTbSz)
+ while ((rgTbSzTbl[0][0][rb]) <(uint32_t) allwdTbSz)
{
rb++;
}
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U8 cfi = cellDl->currCfi;
+ uint8_t cfi = cellDl->currCfi;
alloc->grnt.rbStart = (alloc->sbStart * cellUl->sbSize) +
/* Num RBs = numSbAllocated * sbSize - less RBs in the last SB */
alloc->grnt.numRb = (alloc->numSb * cellUl->sbSize);
- RETVOID;
+ return;
}
/**
* @param[in] Bool preamGrpA
* @param[in] RgSchUlHqProcCb *hqProc
* @param[out] RgSchUlAlloc **ulAllocRef
- * @param[out] U8 *hqProcIdRef
+ * @param[out] uint8_t *hqProcIdRef
* @return Void
**/
#ifdef ANSI
Bool preamGrpA,
RgSchUlHqProcCb *hqProc,
RgSchUlAlloc **ulAllocRef,
-U8 *hqProcIdRef
+uint8_t *hqProcIdRef
)
#else
PRIVATE Void rgSCHCmnMsg3GrntReq(cell, rnti, preamGrpA, hqProc,
Bool preamGrpA;
RgSchUlHqProcCb *hqProc;
RgSchUlAlloc **ulAllocRef;
-U8 *hqProcIdRef;
+uint8_t *hqProcIdRef;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchUlSf *sf = &cellUl->ulSfArr[cellUl->msg3SchdIdx];
RgSchUlHole *hole;
RgSchUlAlloc *alloc;
- U8 iMcs;
- U8 numSb;
+ uint8_t iMcs;
+ uint8_t numSb;
*ulAllocRef = NULLP;
/* Fix: ccpu00120610 Use remAllocs from subframe during msg3 allocation */
if (*sf->allocCountRef >= cellUl->maxAllocPerUlSf)
{
- RETVOID;
+ return;
}
if (preamGrpA == FALSE)
{
}
if (numSb <= hole->num)
{
- U8 iTbs;
+ uint8_t iTbs;
alloc = rgSCHUtlUlAllocGetHole(sf, numSb, hole);
rgSCHCmnUlAllocFillRbInfo(cell, sf, alloc);
alloc->grnt.iMcs = iMcs;
alloc->pdcch = FALSE;
alloc->forMsg3 = TRUE;
alloc->hqProc = hqProc;
- rgSCHUhmNewTx(hqProc, (U8)(cell->rachCfg.maxMsg3Tx - 1), alloc);
+ rgSCHUhmNewTx(hqProc, (uint8_t)(cell->rachCfg.maxMsg3Tx - 1), alloc);
//RLOG_ARG4(L_DEBUG,DBG_CELLID,cell->cellId,
printf(
"\nRNTI:%d MSG3 ALLOC proc(%lu)procId(%d)schdIdx(%d)\n",
}
}
- RETVOID;
+ return;
}
\f
Bool isEmtcUe;
#endif
{
- U8 modOrder;
- U32 maxRb;
+ uint8_t modOrder;
+ uint32_t maxRb;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 cfi = cellSch->dl.currCfi;
+ uint8_t cfi = cellSch->dl.currCfi;
#ifdef EMTC_ENABLE
}
}
- RETVOID;
+ return;
}
#ifdef DL_LA
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue ,cell);
- U8 cfi = cellSch->dl.currCfi;
- U8 maxiTbs;
- U8 cqiBasediTbs;
- U8 actualiTbs;
+ uint8_t cfi = cellSch->dl.currCfi;
+ uint8_t maxiTbs;
+ uint8_t cqiBasediTbs;
+ uint8_t actualiTbs;
maxiTbs = (*(RgSchCmnCqiToTbs*)(cellSch->dl.cqiToTbsTbl[0][cfi]))\
RG_SCH_CMN_UNSET_FORCE_TD(ue,cell, RG_SCH_CMN_TD_TXSCHEME_CHNG);
}
- RETVOID;
+ return;
}
/**
RgSchUeCb *ue;
#endif
{
- U8 modOrder;
- U32 maxRb;
- U8 reportediTbs;
+ uint8_t modOrder;
+ uint32_t maxRb;
+ uint8_t reportediTbs;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- U8 cfi = cellSch->dl.currCfi;
- U8 maxiTbs;
- U8 cwIdx = 0;
+ uint8_t cfi = cellSch->dl.currCfi;
+ uint8_t maxiTbs;
+ uint8_t cwIdx = 0;
maxiTbs = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[RG_SCH_CMN_MAX_CQI - 1];
}
- RETVOID;
+ return;
}
#endif
/***********************************************************
hqP->reqLnk.node = (PTR)NULLP;
hqP->schdLstLnk.node = (PTR)NULLP;
- RETVOID;
+ return;
} /* rgSCHCmnDlHqPResetTemp */
/***********************************************************
}
rgSCHCmnDlHqPResetTemp(hqP);
- RETVOID;
+ return;
} /* rgSCHCmnDlUeResetTemp */
/***********************************************************
memset(&cmnUlUe->alloc, 0, sizeof(cmnUlUe->alloc));
- RETVOID;
+ return;
} /* rgSCHCmnUlUeResetTemp */
"dciForamt Fill RNTI:%d",rbAllocInfo->rnti);
break;
}
- RETVOID;
+ return;
}
#ifdef LTE_TDD
*
* Invoked by: Scheduler
*
- * @param[in] U8 splfrmCnt
- * @param[in] U8 curSubfrmIdx
- * @param[in] U8 periodicity
+ * @param[in] uint8_t splfrmCnt
+ * @param[in] uint8_t curSubfrmIdx
+ * @param[in] uint8_t periodicity
* @param[in] RgSchTddSubfrmInfo *subfrmInfo
* @return Bool
*
#ifdef ANSI
PRIVATE Bool rgSCHCmnIsSplSubfrm
(
-U8 splfrmCnt,
-U8 curSubfrmIdx,
-U8 periodicity,
+uint8_t splfrmCnt,
+uint8_t curSubfrmIdx,
+uint8_t periodicity,
RgSchTddSubfrmInfo *subfrmInfo
)
#else
PRIVATE Bool rgSCHCmnIsSplSubfrm(splfrmCnt, curSubfrmIdx, periodicity, subfrmInfo)
-U8 splfrmCnt;
-U8 curSubfrmIdx;
-U8 periodicity;
+uint8_t splfrmCnt;
+uint8_t curSubfrmIdx;
+uint8_t periodicity;
RgSchTddSubfrmInfo *subfrmInfo;
#endif
{
- U8 dlSfCnt = 0;
- U8 splfrmIdx = 0;
+ uint8_t dlSfCnt = 0;
+ uint8_t splfrmIdx = 0;
if(splfrmCnt > 0)
* @param[in] RgDlHqProcCb *hqP
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchDlHqTbCb *tbCb
- * @param[in] U8 tbAllocIdx
+ * @param[in] uint8_t tbAllocIdx
* @return Void
*
**/
RgSchDlHqProcCb *hqP,
RgSchDlSf *subFrm,
RgSchDlHqTbCb *tbCb,
-U8 tbAllocIdx
+uint8_t tbAllocIdx
)
#else
PRIVATE Void rgSCHCmnUpdHqAndDai(hqP, subFrm, tbCb,tbAllocIdx)
RgSchDlHqProcCb *hqP;
RgSchDlSf *subFrm;
RgSchDlHqTbCb *tbCb;
-U8 tbAllocIdx;
+uint8_t tbAllocIdx;
#endif
{
RgSchUeCb *ue = hqP->hqE->ue;
if(ue && !tbAllocIdx)
{
Bool havePdcch = (tbCb->hqP->pdcch ? TRUE : FALSE);
- U8 dlDai;
+ uint8_t dlDai;
dlDai = rgSCHCmnUpdDai(ue, &tbCb->fdbkTime, tbCb->m, havePdcch,tbCb->hqP,
&tbCb->dai);
fdbk reception */
tbCb->pucchFdbkIdx = tbCb->hqP->ulDai;
- RETVOID;
+ return;
}
* @param[in] RgDlHqProcCb *hqP
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchDlHqTbCb *tbCb
- * @return U8 dlDai
+ * @return uint8_t dlDai
*
**/
#ifdef ANSI
-U8 rgSCHCmnUpdDai
+uint8_t rgSCHCmnUpdDai
(
RgSchUeCb *ue,
CmLteTimingInfo *fdbkTime,
-U8 m,
+uint8_t m,
Bool havePdcch,
RgSchDlHqProcCb *hqP,
-U8 *ulDai
+uint8_t *ulDai
)
#else
-U8 rgSCHCmnUpdDai(ue, fdbkTime, m, havePdcch,tbCb,servCellId,hqP,ulDai)
+uint8_t rgSCHCmnUpdDai(ue, fdbkTime, m, havePdcch,tbCb,servCellId,hqP,ulDai)
RgSchUeCb *ue;
CmLteTimingInfo *fdbkTime;
-U8 m;
+uint8_t m;
Bool havePdcch;
RgSchDlHqProcCb *hqP;
-U8 *ulDai;
+uint8_t *ulDai;
#endif
{
RgSchTddANInfo *anInfo;
- U8 servCellIdx;
- U8 ackNackFdbkArrSize;
+ uint8_t servCellIdx;
+ uint8_t ackNackFdbkArrSize;
}
#endif /* ifdef LTE_TDD */
-U32 rgHqRvRetxCnt[4][2];
-U32 rgUlrate_grant;
+uint32_t rgHqRvRetxCnt[4][2];
+uint32_t rgUlrate_grant;
/**
* @brief This function fills the HqP TB with rbAllocInfo.
*
* @param[in] RgSchCellCb* cell
* @param[in] RgSchDlRbAlloc *rbAllocInfo,
- * @param[in] U8 tbAllocIdx
+ * @param[in] uint8_t tbAllocIdx
* @param[in] RgSchPdcch *pdcch
* @return Void
*
(
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
-U8 tbAllocIdx,
+uint8_t tbAllocIdx,
RgSchPdcch *pdcch
)
#else
Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
RgSchCellCb *cell;
RgSchDlRbAlloc *rbAllocInfo;
-U8 tbAllocIdx;
+uint8_t tbAllocIdx;
RgSchPdcch *pdcch;
#endif
#else
(
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
-U8 tbAllocIdx,
+uint8_t tbAllocIdx,
RgSchPdcch *pdcch
)
#else
PRIVATE Void rgSCHCmnFillHqPTb(cell, rbAllocInfo, tbAllocIdx, pdcch)
RgSchCellCb *cell;
RgSchDlRbAlloc *rbAllocInfo;
-U8 tbAllocIdx;
+uint8_t tbAllocIdx;
RgSchPdcch *pdcch;
#endif
#endif /* LTEMAC_SPS */
//tbInfo->dlGrnt.numRb = rbAllocInfo->rbsAlloc;
rgSCHUtlDlHqPTbAddToTx(hqP->subFrm, hqP, tbInfo->tbIdx);
}
- RETVOID;
+ return;
}
/**
* @param[in] RgSchDlRbAlloc* rbAllocInfo
* @param[in] RgDlHqProc* hqP
* @param[out] RgSchPdcch *pdcch
- * @param[in] U8 tpc
+ * @param[in] uint8_t tpc
* @return Void
*
**/
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
)
#else
PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmtB1B2(cell, rbAllocInfo, hqP, pdcch, tpc)
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchPdcch *pdcch;
-U8 tpc;
+uint8_t tpc;
#endif
{
break;
}
- RETVOID;
+ return;
}
-extern U32 totPcellSCell;
-extern U32 addedForScell;
-extern U32 addedForScell1;
-extern U32 addedForScell2;
+extern uint32_t totPcellSCell;
+extern uint32_t addedForScell;
+extern uint32_t addedForScell1;
+extern uint32_t addedForScell2;
/**
* @brief This function fills the PDCCH information from dlProc.
*
{
RgSchCmnDlCell *cmnCell = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchPdcch *pdcch = rbAllocInfo->pdcch;
- U8 tpc = 1;
+ uint8_t tpc = 1;
if (hqP->hqE->ue)
"Allocator's incorrect dciForamt Fill for RNTI:%d",rbAllocInfo->rnti);
break;
}
- RETVOID;
+ return;
}
#ifdef UNUSED_FUNC
/**
* @param[in] RgSchDlRbAlloc* rbAllocInfo
* @param[in] RgDlHqProc* hqP
* @param[out] RgSchPdcch *pdcch
- * @param[in] U8 tpc
+ * @param[in] uint8_t tpc
* @return Void
*
**/
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
)
#else
PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1(cell, rbAllocInfo, hqP, pdcch, tpc)
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchPdcch *pdcch;
-U8 tpc;
+uint8_t tpc;
#endif
{
if(hqP->hqE->ue != NULLP)
{
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
hqP->hqE->cell->cellId,
hqP->hqE->ue);
#endif
- RETVOID;
+ return;
}
/**
* @brief This function fills the PDCCH DCI format 1A information from dlProc.
* @param[in] RgSchDlRbAlloc* rbAllocInfo
* @param[in] RgDlHqProc* hqP
* @param[out] RgSchPdcch *pdcch
- * @param[in] U8 tpc
+ * @param[in] uint8_t tpc
* @return Void
*
**/
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
)
#else
PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1A(cell, rbAllocInfo, hqP, pdcch, tpc)
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchPdcch *pdcch;
-U8 tpc;
+uint8_t tpc;
#endif
{
if(hqP->hqE->ue != NULLP)
{
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
hqP->hqE->cell->cellId,
hqP->hqE->ue);
anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
}
#endif
- RETVOID;
+ return;
}
/**
* @brief This function fills the PDCCH DCI format 1B information from dlProc.
* @param[in] RgSchDlRbAlloc* rbAllocInfo
* @param[in] RgDlHqProc* hqP
* @param[out] RgSchPdcch *pdcch
- * @param[in] U8 tpc
+ * @param[in] uint8_t tpc
* @return Void
*
**/
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
)
#else
PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt1B(cell, rbAllocInfo, hqP, pdcch, tpc)
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchPdcch *pdcch;
-U8 tpc;
+uint8_t tpc;
#endif
{
if(hqP->hqE->ue != NULLP)
{
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
hqP->hqE->cell->cellId,
hqP->hqE->ue);
anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
}
#endif
- RETVOID;
+ return;
}
/**
* @param[in] RgSchDlRbAlloc* rbAllocInfo
* @param[in] RgDlHqProc* hqP
* @param[out] RgSchPdcch *pdcch
- * @param[in] U8 tpc
+ * @param[in] uint8_t tpc
* @return Void
*
**/
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
)
#else
PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2(cell, rbAllocInfo, hqP, pdcch, tpc)
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchPdcch *pdcch;
-U8 tpc;
+uint8_t tpc;
#endif
{
{
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
hqP->hqE->cell->cellId,
hqP->hqE->ue);
anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
}
#endif
- RETVOID;
+ return;
}
/**
* @brief This function fills the PDCCH DCI format 2A information from dlProc.
* @param[in] RgSchDlRbAlloc* rbAllocInfo
* @param[in] RgDlHqProc* hqP
* @param[out] RgSchPdcch *pdcch
- * @param[in] U8 tpc
+ * @param[in] uint8_t tpc
* @return Void
*
**/
RgSchDlRbAlloc *rbAllocInfo,
RgSchDlHqProcCb *hqP,
RgSchPdcch *pdcch,
-U8 tpc
+uint8_t tpc
)
#else
PRIVATE Void rgSCHCmnFillHqPPdcchDciFrmt2A(cell, rbAllocInfo, hqP, pdcch, tpc)
RgSchDlRbAlloc *rbAllocInfo;
RgSchDlHqProcCb *hqP;
RgSchPdcch *pdcch;
-U8 tpc;
+uint8_t tpc;
#endif
{
#ifdef LTE_TDD
if(hqP->hqE->ue != NULLP)
{
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
hqP->hqE->cell->cellId,
hqP->hqE->ue);
anInfo = rgSCHUtlGetUeANFdbkInfo(hqP->hqE->ue,
#endif
- RETVOID;
+ return;
}
#endif
/**
cellUl->reTxIdx[0] = RGSCH_INVALID_INFO;
cellUl->reTxIdx[1] = RGSCH_INVALID_INFO;
/* Stack Crash problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
}
{
CmLteTimingInfo timeInfo;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- U16 idx;
+ uint16_t idx;
idx = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot);
idx = ((cellUl->schdIdx) % (RG_SCH_CMN_UL_NUM_SF));
- cellUl->reTxIdx[0] = (U8) idx;
+ cellUl->reTxIdx[0] = (uint8_t) idx;
#ifdef UL_ADPT_DBG
printf("cellUl->hqFdbkIdx[0] %d cellUl->reTxIdx[0] %d \n",cellUl->hqFdbkIdx[0], cellUl->reTxIdx[0] );
#endif
* mainly the prachMaskIndex */
rgSCHCmnUpdRachParam(cell);
- RETVOID;
+ return;
}
#endif
*
* @param[in] CmLteTimingInfo *timeInfo
* @param[in] RgSchCellCb *cell
- * @return U8
+ * @return uint8_t
*
**/
#ifdef ANSI
-U8 rgSCHCmnGetPhichUlSfIdx
+uint8_t rgSCHCmnGetPhichUlSfIdx
(
CmLteTimingInfo *timeInfo,
RgSchCellCb *cell
)
#else
-U8 rgSCHCmnGetPhichUlSfIdx(timeInfo, cell)
+uint8_t rgSCHCmnGetPhichUlSfIdx(timeInfo, cell)
CmLteTimingInfo *timeInfo;
RgSchCellCb *cell;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchDlSf *dlsf;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 idx;
- U16 numUlSf;
- U16 sfn;
- U8 subframe;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t idx;
+ uint16_t numUlSf;
+ uint16_t sfn;
+ uint8_t subframe;
dlsf = rgSCHUtlSubFrmGet(cell, *timeInfo);
sfn = (RGSCH_MAX_SFN + timeInfo->sfn -
dlsf->phichOffInfo.sfnOffset) % RGSCH_MAX_SFN;
- /* ccpu00130980: numUlSf(U16) parameter added to avoid integer
+ /* ccpu00130980: numUlSf(uint16_t) parameter added to avoid integer
* wrap case such that idx will be proper*/
numUlSf = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
numUlSf = ((numUlSf * sfn) + rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][subframe]) - 1;
* Purpose: Gets uplink subframe index based on SFN and subframe number.
*
* @param[in] CmLteTimingInfo *timeInfo
- * @param[in] U8 ulDlCfgIdx
- * @return U8
+ * @param[in] uint8_t ulDlCfgIdx
+ * @return uint8_t
*
**/
#ifdef ANSI
-U8 rgSCHCmnGetUlSfIdx
+uint8_t rgSCHCmnGetUlSfIdx
(
CmLteTimingInfo *timeInfo,
RgSchCellCb *cell
)
#else
-U8 rgSCHCmnGetUlSfIdx(timeInfo, cell)
+uint8_t rgSCHCmnGetUlSfIdx(timeInfo, cell)
CmLteTimingInfo *timeInfo;
RgSchCellCb *cell;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 idx = 0;
- U16 numUlSf;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t idx = 0;
+ uint16_t numUlSf;
- /* ccpu00130980: numUlSf(U16) parameter added to avoid integer
+ /* ccpu00130980: numUlSf(uint16_t) parameter added to avoid integer
* wrap case such that idx will be proper*/
numUlSf = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
numUlSf = ((numUlSf * timeInfo->sfn) + \
* Purpose: Gets uplink subframe index based on SFN and subframe number.
*
* @param[in] CmLteTimingInfo *timeInfo
- * @param[in] U8 ulDlCfgIdx
- * @return U8
+ * @param[in] uint8_t ulDlCfgIdx
+ * @return uint8_t
*
**/
#ifdef ANSI
-U8 rgSCHCmnGetUlHqProcIdx
+uint8_t rgSCHCmnGetUlHqProcIdx
(
CmLteTimingInfo *timeInfo,
RgSchCellCb *cell
)
#else
-U8 rgSCHCmnGetUlHqProcIdx(timeInfo, cell)
+uint8_t rgSCHCmnGetUlHqProcIdx(timeInfo, cell)
CmLteTimingInfo *timeInfo;
RgSchCellCb *cell;
#endif
{
- U8 procId;
- U32 numUlSf;
+ uint8_t procId;
+ uint32_t numUlSf;
#ifndef LTE_TDD
numUlSf = (timeInfo->sfn * RGSCH_NUM_SUB_FRAMES_5G + timeInfo->slot);
procId = numUlSf % RGSCH_NUM_UL_HQ_PROC;
#else
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
/*ccpu00130639 - MOD - To get correct UL HARQ Proc IDs for all UL/DL Configs*/
- U8 numUlSfInSfn;
+ uint8_t numUlSfInSfn;
S8 sfnCycle = cell->tddHqSfnCycle;
- U8 numUlHarq = rgSchTddUlNumHarqProcTbl[ulDlCfgIdx]
+ uint8_t numUlHarq = rgSchTddUlNumHarqProcTbl[ulDlCfgIdx]
/* TRACE 5 Changes */
rgSCHUhmFreeProc(alloc->hqProc, cell);
rgSCHUtlUlAllocRelease(alloc);
rgSCHRamDelRaCb(cell, raCb, TRUE);
- RETVOID;
+ return;
}
}
hqProc = alloc->hqProc;
rgSCHUtlUlAllocRelease(alloc);
rgSCHUhmFreeProc(hqProc, cell);
- RETVOID;
+ return;
}
rgSCHUhmFreeProc(alloc->hqProc, cell);
rgSCHUtlUlAllocRls(sf, alloc);
rgSCHRamDelRaCb(cell, raCb, TRUE);
- RETVOID;
+ return;
}
}
#endif
rgSCHUtlUlAllocRls(sf, alloc);
- RETVOID;
+ return;
}
/**
#endif
{
alloc->grnt.nDmrs = cellUl->dmrsArr[alloc->sbStart];
- RETVOID;
+ return;
}
/***********************************************************
#endif
rgSCHUhmNewTx(proc, (((RgUeUlHqCb*)proc->hqEnt)->maxHqRetx), alloc);
}
- RETVOID;
+ return;
}
/**
RGSCH_INCR_SUB_FRAME(frm, TFU_ULCNTRL_DLDELTA);
sf = rgSCHUtlSubFrmGet(cell, frm);
rgSCHUtlPdcchPut(cell, &sf->pdcchInfo, pdcch);
- RETVOID;
+ return;
}
/***********************************************************
*
}
- RETVOID;
+ return;
}
/***********************************************************
#endif
{
alloc->grnt.tpc = rgSCHPwrPuschTpcForUe(cell, ue);
- RETVOID;
+ return;
}
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 wait
+uint32_t wait
)
#else
PRIVATE Void rgSCHCmnAddUeToRefreshQ(cell, ue, wait)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U32 wait;
+uint32_t wait;
#endif
{
RgSchCmnCell *sched = RG_SCH_CMN_GET_CELL(cell);
arg.evnt = RG_SCH_CMN_EVNT_UE_REFRESH;
arg.wait = wait;
cmPlcCbTq(&arg);
- RETVOID;
+ return;
}
/**
{
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
- U8 lcgCnt=0;
+ uint8_t lcgCnt=0;
RgSchCmnLcg *lcgCmn;
CmLList *node;
RgSchCmnAllocRecord *allRcd;
cellSchd->apisUl->rgSCHUlUeReset(cell, ue);
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
}
}
#endif
- RETVOID;
+ return;
}
/**
RgSchUeCb *ue;
#endif
{
- U8 idx;
+ uint8_t idx;
Pst pst;
RgInfResetHqEnt hqEntRstInfo;
rgSCHUtlGetPstToLyr(&pst, &rgSchCb[cell->instIdx], cell->macInst);
RgSchMacRstHqEnt(&pst,&hqEntRstInfo);
- RETVOID;
+ return;
}
/**
/* : take care of this in UL retransmission */
cellSchd->apisUl->rgSCHUlActvtUe(cell, ue);
- RETVOID;
+ return;
}
/**
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
cellSchd->apisDl->rgSCHDlActvtUe(cell, ue);
- RETVOID;
+ return;
}
/**
RG_SCH_CMN_DL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
RG_SCH_CMN_UL_UPDT_INACTV_MASK ( cell, ue, RG_PDCCHODR_INACTIVE);
}
- RETVOID;
+ return;
}
#ifdef TFU_UPGRADE
* - return the least possible Rank
*
*
- * @param[in] U32 *pmiBitMap
+ * @param[in] uint32_t *pmiBitMap
* @return RgSchCmnRank
**/
#ifdef ANSI
PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode4
(
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
)
#else
PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode4(pmiBitMap)
- U32 *pmiBitMap;
+ uint32_t *pmiBitMap;
#endif
{
- U32 bitMap0, bitMap1;
+ uint32_t bitMap0, bitMap1;
bitMap0 = pmiBitMap[0];
bitMap1 = pmiBitMap[1];
if((bitMap1) & 0xFFFF)
* - return the least possible Rank
*
*
- * @param[in] U32 *pmiBitMap
+ * @param[in] uint32_t *pmiBitMap
* @return RgSchCmnRank
**/
#ifdef ANSI
PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode4
(
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
)
#else
PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode4(pmiBitMap)
- U32 *pmiBitMap;
+ uint32_t *pmiBitMap;
#endif
{
- U32 bitMap0;
+ uint32_t bitMap0;
bitMap0 = pmiBitMap[0];
if((bitMap0>>26)& 0x0F)
{
* - return the least possible Rank
*
*
- * @param[in] U32 *pmiBitMap
+ * @param[in] uint32_t *pmiBitMap
* @return RgSchCmnRank
**/
#ifdef ANSI
PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode3
(
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
)
#else
PRIVATE RgSchCmnRank rgSCHCmnComp4TxMode3(pmiBitMap)
- U32 *pmiBitMap;
+ uint32_t *pmiBitMap;
#endif
{
- U32 bitMap0;
+ uint32_t bitMap0;
bitMap0 = pmiBitMap[0];
if((bitMap0>>28)& 1)
{
* - return the least possible Rank
*
*
- * @param[in] U32 *pmiBitMap
+ * @param[in] uint32_t *pmiBitMap
* @return RgSchCmnRank
**/
#ifdef ANSI
PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode3
(
- U32 *pmiBitMap
+ uint32_t *pmiBitMap
)
#else
PRIVATE RgSchCmnRank rgSCHCmnComp2TxMode3(pmiBitMap)
- U32 *pmiBitMap;
+ uint32_t *pmiBitMap;
#endif
{
- U32 bitMap0;
+ uint32_t bitMap0;
bitMap0 = pmiBitMap[0];
if((bitMap0>>30)& 1)
{
*
*
* @param[in] RgrTxMode txMode
- * @param[in] U32 *pmiBitMap
- * @param[in] U8 numTxPorts
+ * @param[in] uint32_t *pmiBitMap
+ * @param[in] uint8_t numTxPorts
* @return RgSchCmnRank
**/
#ifdef ANSI
PRIVATE RgSchCmnRank rgSCHCmnComputeRank
(
RgrTxMode txMode,
- U32 *pmiBitMap,
- U8 numTxPorts
+ uint32_t *pmiBitMap,
+ uint8_t numTxPorts
)
#else
PRIVATE RgSchCmnRank rgSCHCmnComputeRank(txMode, pmiBitMap, numTxPorts)
RgrTxMode txMode;
- U32 *pmiBitMap;
- U8 numTxPorts;
+ uint32_t *pmiBitMap;
+ uint8_t numTxPorts;
#endif
{
{
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
RgSchDlHqProcCb *hqP;
- U8 cnt;
+ uint8_t cnt;
S16 ret;
rgSCHLaaDeInitDlHqProcCb (cell, hqE);
#endif
- RETVOID;
+ return;
}
/**
{
RgSchDlHqProcCb *hqP;
- U8 cnt;
+ uint8_t cnt;
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(cell);
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnGetRefreshDist
+PRIVATE uint8_t rgSCHCmnGetRefreshDist
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-PRIVATE U8 rgSCHCmnGetRefreshDist(cell, ue)
+PRIVATE uint8_t rgSCHCmnGetRefreshDist(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
{
- U8 refOffst;
+ uint8_t refOffst;
#ifdef DEBUGP
Inst inst = cell->instIdx;
#endif
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U32 *waitPer
+ * @param[in] uint32_t *waitPer
* @return Void
*
**/
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 *waitPer
+uint32_t *waitPer
)
#else
PRIVATE Void rgSCHCmnGetRefreshPer(cell, ue, waitPer)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U32 *waitPer;
+uint32_t *waitPer;
#endif
{
- U32 refreshPer;
- U32 crntSubFrm;
+ uint32_t refreshPer;
+ uint32_t crntSubFrm;
refreshPer = RG_SCH_CMN_REFRESH_TIME * RG_SCH_CMN_REFRESH_TIMERES;
*waitPer = RGSCH_CEIL(*waitPer, RG_SCH_CMN_REFRESH_TIMERES);
*waitPer = *waitPer + rgSCHCmnGetRefreshDist(cell, ue);
- RETVOID;
+ return;
}
RgSchErrInfo *err;
#endif
{
- U8 i;
+ uint8_t i;
S16 ret;
- U8 cnt;
+ uint8_t cnt;
RgSchCmnAllocRecord *allRcd;
RgSchDlRbAlloc *allocInfo;
RgSchCmnCell *cellSchd = RG_SCH_CMN_GET_CELL(ue->cell);
#ifdef DEBUGP
Inst inst = ue->cell->instIdx;
#endif
- U32 idx = (U8)((sCell->cellId - rgSchCb[sCell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
+ uint32_t idx = (uint8_t)((sCell->cellId - rgSchCb[sCell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
pCellUeSchCmn = RG_SCH_CMN_GET_UE(ue,ue->cell);
pCellUeDl = &pCellUeSchCmn->dl;
RGSCH_ARRAY_BOUND_CHECK(sCell->instIdx, rgUeCatTbl, pCellUeSchCmn->cmn.ueCat);
ueDl->maxTbBits = rgUeCatTbl[pCellUeSchCmn->cmn.ueCat].maxDlTbBits;
/*CA dev-Start*/
- U8 ri = 0;
+ uint8_t ri = 0;
ri = RGSCH_MIN(ri, sCell->numTxAntPorts);
if(((CM_LTE_UE_CAT_6 == pCellUeSchCmn->cmn.ueCat )
||(CM_LTE_UE_CAT_7 == pCellUeSchCmn->cmn.ueCat))
RgSchCmnUe *ueSchCmn;
RgSchCmnUlUe *ueUl;
RgSchCmnDlUe *ueDl;
- U8 cnt;
+ uint8_t cnt;
RgSchCmnAllocRecord *allRcd;
- U32 waitPer;
- U32 idx = (U8)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
+ uint32_t waitPer;
+ uint32_t idx = (uint8_t)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ue);
RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgUeCatTbl, ueSchCmn->cmn.ueCat);
ueDl->maxTbBits = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxDlTbBits;
/*CA dev-Start*/
- U8 ri = 0;
+ uint8_t ri = 0;
ri = RGSCH_MIN(ri, cell->numTxAntPorts);
if(((CM_LTE_UE_CAT_6 == ueSchCmn->cmn.ueCat )
||(CM_LTE_UE_CAT_7 == ueSchCmn->cmn.ueCat))
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrUeRecfg *ueRecfg,
-U8 numTxPorts
+uint8_t numTxPorts
)
#else
PRIVATE Void rgSCHCmnDlHdlTxModeRecfg(cell, ue, ueRecfg, numTxPorts)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrUeRecfg *ueRecfg;
-U8 numTxPorts;
+uint8_t numTxPorts;
#endif
#else
#ifdef ANSI
if (ueRecfg->txMode.pres != PRSNT_NODEF)
{
- RETVOID;
+ return;
}
/* ccpu00140894- Starting Timer for TxMode Transition Completion*/
ue->txModeTransCmplt =FALSE;
RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
}
/* MIMO Fix End: need to set FORCE TD bitmap based on TX mode */
- RETVOID;
+ return;
}
if (ueRecfg->txMode.tmTrnstnState == RGR_TXMODE_RECFG_START)
{
{
RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
}
- RETVOID;
+ return;
}
}
/***********************************************************
ueDl->mimoInfo.cwInfo[0].cqi = cellSchd->dl.ccchCqi;
ueDl->mimoInfo.cwInfo[1].cqi = cellSchd->dl.ccchCqi;
- RETVOID;
+ return;
}
/***********************************************************
*
ueUl->maxUlCqi = RG_SCH_CMN_UL_NUM_CQI - 1;
}
- RETVOID;
+ return;
}
/***********************************************************
*
hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
/*CA dev-Start*/
- U8 ri = 0;
+ uint8_t ri = 0;
ri = RGSCH_MIN(ri, cell->numTxAntPorts);
if(((CM_LTE_UE_CAT_6 == ueSchCmn->cmn.ueCat )
||(CM_LTE_UE_CAT_7 == ueSchCmn->cmn.ueCat))
}
ue->ul.maxBytesPerUePerTti = rgUeCatTbl[ueSchCmn->cmn.ueCat].maxUlBits * \
RG_SCH_CMN_MAX_BITS_RATIO / (RG_SCH_CMN_UL_COM_DENOM*8);
- RETVOID;
+ return;
}
/**
#endif
{
RgSchCmnCell *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
- U32 waitPer;
+ uint32_t waitPer;
/* Basic validations */
if (ueRecfg->ueRecfgTypes & RGR_UE_TXMODE_RECFG)
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
- U8 i;
+ uint8_t i;
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = RG_SCH_CMN_GET_UL_SPS_UE(ue,cell);
#endif
}
}
}
- RETVOID;
+ return;
}
/***********************************************************
arg.evnt = RG_SCH_CMN_EVNT_UE_REFRESH;
cmRmvCbTq(&arg);
- RETVOID;
+ return;
}
/***********************************************************
hqE = RG_SCH_CMN_GET_UE_HQE(ueCb, cell);
if (hqE == NULLP)
{
- RETVOID;
+ return;
}
ccchSduHqP = hqE->ccchSduProc;
if(ueCb->ccchSduLnk.node != NULLP)
rgSCHDhmRlsHqpTb(ccchSduHqP, 0, TRUE);
}
}
- RETVOID;
+ return;
}
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
CmLList *node;
RgSchCmnAllocRecord *allRcd;
- U8 cnt;
+ uint8_t cnt;
RgSchCmnCell *cellSchCmn = RG_SCH_CMN_GET_CELL(cell);
- U32 idx = 0;
+ uint32_t idx = 0;
if (RG_SCH_CMN_GET_UE(ue,cell) == NULLP)
{
/* Common scheduler config has not happened yet */
- RETVOID;
+ return;
}
hqE = RG_SCH_CMN_GET_UE_HQE(ue, cell);
if(hqE)
}
/* Fix : syed Moved hqEnt deinit to rgSCHCmnDlDeInitHqEnt */
- idx = (U8)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId) & (CM_LTE_MAX_CELLS - 1));
+ idx = (uint8_t)((cell->cellId - rgSchCb[cell->instIdx].genCfg.startCellId) & (CM_LTE_MAX_CELLS - 1));
rgSCHUtlFreeSBuf(cell->instIdx,
(Data**)(&(((ue->cellInfo[ue->cellIdToCellIdxMap[idx]])->sch))), (sizeof(RgSchCmnUe)));
- RETVOID;
+ return;
} /* rgSCHCmnUeDel */
\f
#endif
{
RgSchCmnCell *cellDl = RG_SCH_CMN_GET_CELL(cell);
- U32 bitsPerRb;
- U32 bitsPer2Rb;
- U32 bitsPer3Rb;
- U8 i, rbNum;
- U32 pdcchBits;
+ uint32_t bitsPerRb;
+ uint32_t bitsPer2Rb;
+ uint32_t bitsPer3Rb;
+ uint8_t i, rbNum;
+ uint32_t pdcchBits;
/* code rate is bits per 1024 phy bits, since modl'n scheme is 2. it is
#endif
{
RgSchCmnCell *cellSch;
- U8 cp;
- U8 sfCount;
- U8 numPdcchSym;
- U8 noSymPerSlot;
- U8 maxDlSubfrms = cell->numDlSubfrms;
- U8 splSubfrmIdx = cfg->spclSfCfgIdx;
- U8 swPtCnt = 0;
+ uint8_t cp;
+ uint8_t sfCount;
+ uint8_t numPdcchSym;
+ uint8_t noSymPerSlot;
+ uint8_t maxDlSubfrms = cell->numDlSubfrms;
+ uint8_t splSubfrmIdx = cfg->spclSfCfgIdx;
+ uint8_t swPtCnt = 0;
Bool isSplfrm;
RgSchTddSubfrmInfo subfrmInfo = rgSchTddMaxUlSubfrmTbl[cell->ulDlCfgIdx];
S16 ret;
- U8 splSfIdx;
- U8 antPortIdx;
- U8 numCrs;
- U8 cfi;
- U8 cfiIdx;
+ uint8_t splSfIdx;
+ uint8_t antPortIdx;
+ uint8_t numCrs;
+ uint8_t cfi;
+ uint8_t cfiIdx;
RgSchDlSf *sf;
- U8 splSfCfi;
- U8 mPhich;
+ uint8_t splSfCfi;
+ uint8_t mPhich;
{
S16 ret;
RgSchCmnCell *cellSch;
- U8 cp;
- U8 numPdcchSym;
- U8 noSymPerSlot;
- U8 cfi;
- U8 cfiIdx;
+ uint8_t cp;
+ uint8_t numPdcchSym;
+ uint8_t noSymPerSlot;
+ uint8_t cfi;
+ uint8_t cfiIdx;
cellSch = RG_SCH_CMN_GET_CELL(cell);
* is necessarily satisfied (does a 'ceiling'
* computation).
*
- * Ret : Required RBs (U8)
+ * Ret : Required RBs (uint8_t)
*
* Notes:
*
*
**********************************************************/
#ifdef ANSI
-U8 rgSCHCmnUlCalcReqRbCeil
+uint8_t rgSCHCmnUlCalcReqRbCeil
(
-U32 bytes,
-U8 cqi,
+uint32_t bytes,
+uint8_t cqi,
RgSchCmnUlCell *cellUl
)
#else
-U8 rgSCHCmnUlCalcReqRbCeil(bytes, cqi, cellUl)
-U32 bytes;
-U8 cqi;
+uint8_t rgSCHCmnUlCalcReqRbCeil(bytes, cqi, cellUl)
+uint32_t bytes;
+uint8_t cqi;
RgSchCmnUlCell *cellUl;
#endif
{
- U32 numRe = RGSCH_CEIL((bytes * 8) * 1024, rgSchCmnUlCqiTbl[cqi].eff);
- return ((U8)RGSCH_CEIL(numRe, RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl)));
+ uint32_t numRe = RGSCH_CEIL((bytes * 8) * 1024, rgSchCmnUlCqiTbl[cqi].eff);
+ return ((uint8_t)RGSCH_CEIL(numRe, RG_SCH_CMN_UL_NUM_RE_PER_RB(cellUl)));
}
/***********************************************************
PRIVATE S16 rgSCHCmnPrecompMsg3Vars
(
RgSchCmnUlCell *cellUl,
-U8 ccchCqi,
-U16 msgSzA,
-U8 sbSize,
+uint8_t ccchCqi,
+uint16_t msgSzA,
+uint8_t sbSize,
Bool isEcp
)
#else
PRIVATE S16 rgSCHCmnPrecompMsg3Vars(cellUl, ccchCqi, msgSzA, sbSize, isEcp)
RgSchCmnUlCell *cellUl;
-U8 ccchCqi;
-U16 msgSzA;
-U8 sbSize;
+uint8_t ccchCqi;
+uint16_t msgSzA;
+uint8_t sbSize;
Bool isEcp;
#endif
{
- U8 numSb;
- U8 ccchTbs;
- U8 ccchMcs;
- U8 numRb = 0;
- U8 iTbs = 0;
- U16 msg3GrntSz = 0;
+ uint8_t numSb;
+ uint8_t ccchTbs;
+ uint8_t ccchMcs;
+ uint8_t numRb = 0;
+ uint8_t iTbs = 0;
+ uint16_t msg3GrntSz = 0;
if (ccchCqi > cellUl->max16qamCqi)
}
/* #ifndef RG_SCH_CMN_EXP_CP_SUP For ECP Pick the index 1 */
/* Fix */
- ccchTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ccchCqi];
+ ccchTbs = rgSchCmnUlCqiToTbsTbl[(uint8_t)isEcp][ccchCqi];
ccchMcs = rgSCHCmnUlGetIMcsFrmITbs(ccchTbs, CM_LTE_UE_CAT_1);
/* MCS should fit in 4 bits in RAR */
* Since, UE doesn't exist right now, we use CAT_1 for ue
* category*/
while((ccchMcs = (rgSCHCmnUlGetIMcsFrmITbs(
- rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ccchCqi],CM_LTE_UE_CAT_1))
+ rgSchCmnUlCqiToTbsTbl[(uint8_t)isEcp][ccchCqi],CM_LTE_UE_CAT_1))
) >
RG_SCH_CMN_MAX_MSG3_IMCS)
{
ccchCqi--;
}
- iTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ccchCqi];
+ iTbs = rgSchCmnUlCqiToTbsTbl[(uint8_t)isEcp][ccchCqi];
if (msgSzA < RGSCH_MIN_MSG3_GRNT_SZ)
{
return ROK;
}
-U32 gPrntPucchDet=0;
+uint32_t gPrntPucchDet=0;
#ifdef LTE_TDD
/***********************************************************
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
-U8 cfi,
-U8 *rbStartRef,
-U8 *bwAvailRef
+uint8_t cfi,
+uint8_t *rbStartRef,
+uint8_t *bwAvailRef
)
#else
PRIVATE S16 rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, rbStartRef, bwAvailRef)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
-U8 cfi;
-U8 *rbStartRef;
-U8 *bwAvailRef;
-#endif
-{
- U8 c = 3;
- U8 ulBw = cell->bwCfg.ulTotalBw;
- U8 n2Rb = cell->pucchCfg.resourceSize;
- U8 pucchDeltaShft = cell->pucchCfg.deltaShift;
- U16 n1Pucch = cell->pucchCfg.n1PucchAn;
- U8 n1Cs = cell->pucchCfg.cyclicShift;
-
- U8 n1PerRb;
- U8 totalCce;
- U16 n1Max;
- U8 n1Rb;
- U32 mixedRb;
- U8 exclRb; /* RBs to exclude */
- U8 n1RbPart;
- U8 puschRbStart;
+uint8_t cfi;
+uint8_t *rbStartRef;
+uint8_t *bwAvailRef;
+#endif
+{
+ uint8_t c = 3;
+ uint8_t ulBw = cell->bwCfg.ulTotalBw;
+ uint8_t n2Rb = cell->pucchCfg.resourceSize;
+ uint8_t pucchDeltaShft = cell->pucchCfg.deltaShift;
+ uint16_t n1Pucch = cell->pucchCfg.n1PucchAn;
+ uint8_t n1Cs = cell->pucchCfg.cyclicShift;
+
+ uint8_t n1PerRb;
+ uint8_t totalCce;
+ uint16_t n1Max;
+ uint8_t n1Rb;
+ uint32_t mixedRb;
+ uint8_t exclRb; /* RBs to exclude */
+ uint8_t n1RbPart;
+ uint8_t puschRbStart;
/* To avoid PUCCH and PUSCH collision issue */
- U8 P;
- U8 n1PlusOne;
- U8 mi;
+ uint8_t P;
+ uint8_t n1PlusOne;
+ uint8_t mi;
/* Maximum value of M as per Table 10.1-1 */
- U8 M[RGSCH_MAX_TDD_UL_DL_CFG] = {1, 2, 4, 3, 4, 9, 1};
+ uint8_t M[RGSCH_MAX_TDD_UL_DL_CFG] = {1, 2, 4, 3, 4, 9, 1};
if (cell->isCpUlExtend)
(
RgSchCellCb *cell,
RgrCellCfg *cellCfg,
-U8 cfi,
-U8 *rbStartRef,
-U8 *bwAvailRef
+uint8_t cfi,
+uint8_t *rbStartRef,
+uint8_t *bwAvailRef
)
#else
PRIVATE S16 rgSCHCmnUlCalcAvailBw(cell, cellCfg, cfi, rbStartRef, bwAvailRef)
RgSchCellCb *cell;
RgrCellCfg *cellCfg;
-U8 cfi;
-U8 *rbStartRef;
-U8 *bwAvailRef;
-#endif
-{
- U8 c = 3;
- U8 ulBw = cell->bwCfg.ulTotalBw;
- U8 n2Rb = cell->pucchCfg.resourceSize;
- U8 pucchDeltaShft = cell->pucchCfg.deltaShift;
- U16 n1Pucch = cell->pucchCfg.n1PucchAn;
- U8 n1Cs = cell->pucchCfg.cyclicShift;
- U8 n1PerRb;
- U8 totalCce;
- U16 n1Max;
- U8 n1Rb;
- U32 mixedRb;
- U8 exclRb; /* RBs to exclude */
- U8 n1RbPart;
- U8 puschRbStart;
+uint8_t cfi;
+uint8_t *rbStartRef;
+uint8_t *bwAvailRef;
+#endif
+{
+ uint8_t c = 3;
+ uint8_t ulBw = cell->bwCfg.ulTotalBw;
+ uint8_t n2Rb = cell->pucchCfg.resourceSize;
+ uint8_t pucchDeltaShft = cell->pucchCfg.deltaShift;
+ uint16_t n1Pucch = cell->pucchCfg.n1PucchAn;
+ uint8_t n1Cs = cell->pucchCfg.cyclicShift;
+ uint8_t n1PerRb;
+ uint8_t totalCce;
+ uint16_t n1Max;
+ uint8_t n1Rb;
+ uint32_t mixedRb;
+ uint8_t exclRb; /* RBs to exclude */
+ uint8_t n1RbPart;
+ uint8_t puschRbStart;
#ifdef LTE_ADV
- U16 numOfN3PucchRb;
+ uint16_t numOfN3PucchRb;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
#endif
/* ccpu00129978- MOD- excluding RBs based on formula in section 5.4.3 in
* TS 36.211 */
n1RbPart = (c*n1Cs)/pucchDeltaShft;
- n1Rb = (U8)((n1Max - n1RbPart) / n1PerRb);
+ n1Rb = (uint8_t)((n1Max - n1RbPart) / n1PerRb);
mixedRb = RGSCH_CEIL(n1Cs, 8); /* same as 'mixedRb = n1Cs ? 1 : 0' */
/* get the total Number of RB's to be excluded for PUSCH */
{
S16 ret;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- U8 maxUePerUlSf = cellCfg->maxUePerUlSf;
+ uint8_t maxUePerUlSf = cellCfg->maxUePerUlSf;
#ifdef RGR_V1
/* Added configuration for maximum number of MSG3s */
- U8 maxMsg3PerUlSf = cellCfg->maxMsg3PerUlSf;
-#endif
- U8 maxUlBwPerUe = cellCfg->maxUlBwPerUe;
- U8 sbSize = cellCfg->puschSubBand.size;
- U8 i;
- U8 rbStart;
- U8 bwAvail;
- U8 cfi;
- U8 maxSbPerUe;
- U8 numSb;
+ uint8_t maxMsg3PerUlSf = cellCfg->maxMsg3PerUlSf;
+#endif
+ uint8_t maxUlBwPerUe = cellCfg->maxUlBwPerUe;
+ uint8_t sbSize = cellCfg->puschSubBand.size;
+ uint8_t i;
+ uint8_t rbStart;
+ uint8_t bwAvail;
+ uint8_t cfi;
+ uint8_t maxSbPerUe;
+ uint8_t numSb;
#ifdef LTE_TDD
- U16 ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint16_t ulDlCfgIdx = cell->ulDlCfgIdx;
/* [ccpu00127294]-MOD-Change the max Ul subfrms size in TDD */
- U8 maxSubfrms = 2 * rgSchTddNumUlSf[ulDlCfgIdx];
- U8 ulToDlMap[12] = {0}; /* maximum 6 Subframes in UL * 2 */
- U8 maxUlsubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
+ uint8_t maxSubfrms = 2 * rgSchTddNumUlSf[ulDlCfgIdx];
+ uint8_t ulToDlMap[12] = {0}; /* maximum 6 Subframes in UL * 2 */
+ uint8_t maxUlsubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
[RGSCH_NUM_SUB_FRAMES-1];
- U16 subfrm;
+ uint16_t subfrm;
S8 dlIdx;
#else
- U8 maxSubfrms = RG_SCH_CMN_UL_NUM_SF;
+ uint8_t maxSubfrms = RG_SCH_CMN_UL_NUM_SF;
#endif
#ifdef LTE_L2_MEAS
- U8 idx;
+ uint8_t idx;
#endif
- U8 iTbs;
+ uint8_t iTbs;
#if (defined(LTE_L2_MEAS) )
Inst inst = cell->instIdx;
#endif /* #if (defined(LTE_L2_MEAS) || defined(DEBUGP) */
if (recfg->recfgTypes & RGR_CELL_UL_CMNRATE_RECFG)
{
- U8 oldCqi = cellUl->dfltUlCqi;
+ uint8_t oldCqi = cellUl->dfltUlCqi;
if (!RG_SCH_CMN_UL_IS_CQI_VALID(recfg->ulCmnCodeRate.ccchCqi))
{
err->errCause = RGSCHERR_SCH_CFG;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- U8 ulSfIdx;
+ uint8_t ulSfIdx;
#ifdef LTE_TDD
- U8 maxSubfrms = cellUl->numUlSubfrms;
+ uint8_t maxSubfrms = cellUl->numUlSubfrms;
#endif
#ifdef LTE_L2_MEAS
CmLList *lnk = NULLP;
}
#endif
- RETVOID;
+ return;
}
/**
#endif
if (cellSch == NULLP)
{
- RETVOID;
+ return;
}
/* Perform the deinit for the UL scheduler */
rgSCHCmnUlCellDeinit(cell);
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx,
(Data**)(&(cell->sc.sch)), (sizeof(RgSchCmnCell)));
- RETVOID;
+ return;
} /* rgSCHCmnCellDel */
\f
RgrLchQosCfg *dlQos;
#endif
{
- U8 qci = dlQos->qci;
+ uint8_t qci = dlQos->qci;
if ( qci < RG_SCH_CMN_MIN_QCI || qci > RG_SCH_CMN_MAX_QCI )
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteLcId lcId,
-U8 lcgId
+uint8_t lcgId
)
#else
S16 rgSCHCmnRgrLchDel(cell, ue, lcId, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteLcId lcId;
-U8 lcgId;
+uint8_t lcgId;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
if (lcgCmn == NULLP)
{
- RETVOID;
+ return;
}
if (RGSCH_IS_GBR_BEARER(lcgCmn->cfgdGbr))
{
cellSch->apisUl->rgSCHFreeUlLcg(cell, ue, lcg);
}
- RETVOID;
+ return;
}
\f
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
if (svc->sch == NULLP)
{
- RETVOID;
+ return;
}
#ifdef EMTC_ENABLE
if((cell->emtcEnable)&&(TRUE == ue->isEmtcUe))
rgSCHLaaDeInitDlLchCb(cell, svc);
#endif
- RETVOID;
+ return;
}
#ifdef RGR_V1
/* reset the UE allocation Information */
rgSCHCmnDlUeResetTemp(ue, hqP);
}
- RETVOID;
+ return;
}
#endif
/**
memset(&raCb->rbAllocInfo, 0, sizeof(raCb->rbAllocInfo));
rgSCHCmnDlHqPResetTemp(hqP);
}
- RETVOID;
+ return;
}
#ifdef RGR_V1
/* reset the UE allocation Information */
rgSCHCmnDlUeResetTemp(ueCb, hqP);
}
- RETVOID;
+ return;
}
#endif
rgSCHCmnDlHqPResetTemp(hqP);
}
- RETVOID;
+ return;
}
/* R8 Upgrade */
/**
* Invoked by: Common Scheduler
*
* @param[in] RgSchCellCb *cell
- * @param[in] U32 ueCount
- * @return U8
+ * @param[in] uint32_t ueCount
+ * @return uint8_t
*
**/
#ifdef ANSI
-U8 rgSCHCmnGetBiIndex
+uint8_t rgSCHCmnGetBiIndex
(
RgSchCellCb *cell,
-U32 ueCount
+uint32_t ueCount
)
#else
-U8 rgSCHCmnGetBiIndex(cell, ueCount)
+uint8_t rgSCHCmnGetBiIndex(cell, ueCount)
RgSchCellCb *cell;
-U32 ueCount;
+uint32_t ueCount;
#endif
{
S16 prevVal = 0; /* To Store Intermediate Value */
- U16 newBiVal = 0; /* To store Bi Value in millisecond */
- U8 idx = 0;
- U16 timeDiff = 0;
+ uint16_t newBiVal = 0; /* To store Bi Value in millisecond */
+ uint8_t idx = 0;
+ uint16_t timeDiff = 0;
if (cell->biInfo.prevBiTime != 0)
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
- U32 rarCnt = 0;
+ uint32_t rarCnt = 0;
RgSchDlRbAlloc *raRspAlloc;
RgSchDlSf *subFrm = NULLP;
RgSchRaCb *raCb;
Bool preamGrpA;
RgSchUlAlloc *ulAllocRef=NULLP;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U8 allocRapidCnt = 0;
+ uint8_t allocRapidCnt = 0;
#ifdef LTE_TDD
- U32 msg3SchdIdx = 0;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 msg3Subfrm;
+ uint32_t msg3SchdIdx = 0;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t msg3Subfrm;
#endif
subFrm->raRsp[rarCnt].pdcch = NULLP;
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnRaRspAlloc(): "
"Not even one RaReq.");
- RETVOID;
+ return;
}
}
RLOG_ARG3(L_DEBUG,DBG_CELLID,cell->cellId,
cell->crntTime.sfn,
cell->crntTime.slot);
}
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] Bool si
- * @param[in] U16 i
- * @return U8
+ * @param[in] uint16_t i
+ * @return uint8_t
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnDlCalcRvForBcch
+PRIVATE uint8_t rgSCHCmnDlCalcRvForBcch
(
RgSchCellCb *cell,
Bool si,
-U16 i
+uint16_t i
)
#else
-PRIVATE U8 rgSCHCmnDlCalcRvForBcch(cell, si, i)
+PRIVATE uint8_t rgSCHCmnDlCalcRvForBcch(cell, si, i)
RgSchCellCb *cell;
Bool si;
-U16 i;
+uint16_t i;
#endif
{
- U8 k, rv;
+ uint8_t k, rv;
CmLteTimingInfo frm;
frm = cell->crntTime;
RgSchDlSf *subFrm;
#ifdef LTE_TDD
- U8 nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
+ uint8_t nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
#else
#ifdef LTEMAC_HDFDD
- U8 nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
+ uint8_t nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
#else
- U8 nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
+ uint8_t nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
#endif
#endif
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHCmnDlBcchPcchFnlz( ): "
"No Pcch Present");
- RETVOID;
+ return;
}
/* Added Dl TB count for paging message transmission*/
}
else
{
- U16 i;
+ uint16_t i;
#ifdef RGR_SI_SCH
Buffer *pdu;
#endif/*RGR_SI_SCH*/
}
- RETVOID;
+ return;
}
node = allocInfo->ueLst.first;
}
- RETVOID;
+ return;
}
#endif
RgSchCmnUeUlAlloc *ulAllocInfo = &((RG_SCH_CMN_GET_UL_UE(ue,ue->cell))->alloc);
cmLListAdd2Tail(&allocInfo->contResLst, &ulAllocInfo->reqLnk);
ulAllocInfo->reqLnk.node = (PTR)ue;
- RETVOID;
+ return;
}
/**
cmLListAdd2Tail(&allocInfo->ueLst, &ulAllocInfo->reqLnk);
ulAllocInfo->reqLnk.node = (PTR)ue;
}
- RETVOID;
+ return;
}
/**
rgSCHCmnUlRbAllocForLst(cell, sf, allocInfo->ueLst.count,
&allocInfo->ueLst, &allocInfo->schdUeLst,
&allocInfo->nonSchdUeLst, (Bool)TRUE);
- RETVOID;
+ return;
}
/***********************************************************
(
RgSchCellCb *cell,
RgSchUlSf *sf,
-U32 count,
+uint32_t count,
CmLListCp *reqLst,
CmLListCp *schdLst,
CmLListCp *nonSchdLst,
nonSchdLst, isNewTx)
RgSchCellCb *cell;
RgSchUlSf *sf;
-U32 count;
+uint32_t count;
CmLListCp *reqLst;
CmLListCp *schdLst;
CmLListCp *nonSchdLst;
RgSchUlHole *hole;
#ifdef LTE_L2_MEAS
#ifdef LTE_TDD
- U8 k;
+ uint8_t k;
CmLteTimingInfo timeInfo;
#endif
#endif
#ifdef LTE_L2_MEAS
if(isNewTx == TRUE)
{
- cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.numUes = (U8) count;
+ cell->sfAllocArr[cell->crntSfIdx].ulUeInfo.numUes = (uint8_t) count;
#ifdef LTE_TDD
RG_SCH_ADD_TO_CRNT_TIME(cell->crntTime, timeInfo, TFU_ULCNTRL_DLDELTA);
k = rgSchTddPuschTxKTbl[cell->ulDlCfgIdx][timeInfo.subframe];
RgSchUeCb *ue = (RgSchUeCb *)lnk->node;
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
S16 ret;
- U8 maxRb;
+ uint8_t maxRb;
if ((hole = rgSCHUtlUlHoleFirst(sf)) == NULLP)
rgSCHCmnUlRbAllocAddUeToLst(cell, ue, nonSchdLst);
ue->isMsg4PdcchWithCrnti = FALSE;
}
- RETVOID;
+ return;
}
#ifdef UNUSED_FUNC
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 maxRb,
-U32 *numSb,
-U8 *iTbs,
-U32 hqSz,
-U32 stepDownItbs,
-U32 effTgt
+uint32_t maxRb,
+uint32_t *numSb,
+uint8_t *iTbs,
+uint32_t hqSz,
+uint32_t stepDownItbs,
+uint32_t effTgt
)
#else
PRIVATE S16 rgSCHCmnUlMdfyGrntForCqi(cell, ue, maxRb, numSb, iTbs, hqSz, stepDownItbs, effTgt)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U32 maxRb;
-U32 *numSb;
-U8 *iTbs;
-U32 hqSz;
-U32 stepDownItbs;
-U32 effTgt;
+uint32_t maxRb;
+uint32_t *numSb;
+uint8_t *iTbs;
+uint32_t hqSz;
+uint32_t stepDownItbs;
+uint32_t effTgt;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(ue->cell);
- U32 nPrb;
- U32 totREs;
- U32 cqiRiREs;
- U32 hqREs;
- U32 remREsForPusch;
- U32 bitsPerRe;
- U32 tbSz;
- U32 betaOffVal = ue->ul.betaOffstVal;
- U32 cqiRiRptSz = ue->ul.cqiRiSz;
- U32 betaOffHqVal = rgSchCmnBetaHqOffstTbl[ue->ul.betaHqOffst];
- U32 resNumSb = *numSb;
- U32 puschEff = 1000;
- U8 modOdr;
- U8 iMcs;
+ uint32_t nPrb;
+ uint32_t totREs;
+ uint32_t cqiRiREs;
+ uint32_t hqREs;
+ uint32_t remREsForPusch;
+ uint32_t bitsPerRe;
+ uint32_t tbSz;
+ uint32_t betaOffVal = ue->ul.betaOffstVal;
+ uint32_t cqiRiRptSz = ue->ul.cqiRiSz;
+ uint32_t betaOffHqVal = rgSchCmnBetaHqOffstTbl[ue->ul.betaHqOffst];
+ uint32_t resNumSb = *numSb;
+ uint32_t puschEff = 1000;
+ uint8_t modOdr;
+ uint8_t iMcs;
Bool mdfyiTbsFlg = FALSE;
- U8 resiTbs = *iTbs;
+ uint8_t resiTbs = *iTbs;
RgSchCellCb *cell,
RgSchUlSf *sf,
RgSchUeCb *ue,
-U8 maxRb,
+uint8_t maxRb,
RgSchUlHole *hole
)
#else
RgSchCellCb *cell;
RgSchUlSf *sf;
RgSchUeCb *ue;
-U8 maxRb;
+uint8_t maxRb;
RgSchUlHole *hole;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
RgSchUlAlloc *alloc = NULLP;
- U32 nPrb = 0;
- U8 numVrbg;
- U8 iMcs;
- U8 iMcsCrnt;
+ uint32_t nPrb = 0;
+ uint8_t numVrbg;
+ uint8_t iMcs;
+ uint8_t iMcsCrnt;
#ifndef RG_5GTF
RgSchUlHqProcCb *proc = &ueUl->hqEnt.hqProcCb[cellUl->schdHqProcIdx];
#else
RgSchUlHqProcCb *proc = NULLP;
#endif
RgSchPdcch *pdcch;
- U32 reqVrbg;
- U8 numVrbgTemp;
+ uint32_t reqVrbg;
+ uint8_t numVrbgTemp;
#ifdef RG_5GTF
TfuDciFormat dciFrmt;
- U8 numLyr;
+ uint8_t numLyr;
#endif
#ifdef RG_5GTF
/* call scheduler specific Finalization */
cellSch->apisUl->rgSCHUlAllocFnlz(cell, allocInfo);
- RETVOID;
+ return;
}
/**
cellSch->apisDl->rgSCHDlAllocFnlz(cell, allocInfo);
/* Stack Crash problem for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
}
*/
- RETVOID;
+ return;
}
/**
RgSchUlAlloc *alloc;
#endif
{
- U32 bytes;
+ uint32_t bytes;
RgSchCmnUlUe *ueUl;
bytes = \
rgTbSzTbl[0][rgSCHCmnUlGetITbsFrmIMcs(alloc->grnt.iMcs)]\
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,
"rgSCHCmnUlRbAllocForUe():Could not get UlAlloc for msg3Retx RNTI:%d",
alloc->rnti);
- RETVOID;
+ return;
}
retxAlloc->grnt.iMcs = alloc->grnt.iMcs;
retxAlloc->grnt.iMcsCrnt = rgSchCmnUlRvIdxToIMcsTbl\
retxAlloc->hqProc = alloc->hqProc;
rgSCHUhmRetx(retxAlloc->hqProc);
}
- RETVOID;
+ return;
}
#endif
RgSchCmnUlRbAllocInfo allocInfo;
RgSchCmnUlRbAllocInfo *allocInfoRef = &allocInfo;
#ifdef RG_5GTF
- U8 idx;
+ uint8_t idx;
#endif
g5gtfTtiCnt = 0;
}
- RETVOID;
+ return;
}
/**
cell->crntSfIdx = (cell->crntSfIdx + 1) % RGSCH_SF_ALLOC_SIZE;
#endif
- RETVOID;
+ return;
}
/**
* @brief Consolidate Subframe Allocations.
/*re/start DRX inactivity timer for the UEs*/
(Void)rgSCHDrxStrtInActvTmr(cell,&dlDrxInactvTmrLst,RG_SCH_DRX_DL);
- RETVOID;
+ return;
}
/**
{
memset(&allocInfo->pcchAlloc, 0, sizeof(RgSchDlRbAlloc));
memset(&allocInfo->bcchAlloc, 0, sizeof(RgSchDlRbAlloc));
- memset(allocInfo->raRspAlloc, 0,
- RG_SCH_CMN_MAX_CMN_PDCCH*sizeof(RgSchDlRbAlloc));
+ memset(allocInfo->raRspAlloc, 0, RG_SCH_CMN_MAX_CMN_PDCCH*sizeof(RgSchDlRbAlloc));
allocInfo->msg4Alloc.msg4DlSf = NULLP;
cmLListInit(&allocInfo->msg4Alloc.msg4TxLst);
cmLListInit(&allocInfo->dedAlloc.errIndTxHqPLst);
cmLListInit(&allocInfo->dedAlloc.schdErrIndTxHqPLst);
cmLListInit(&allocInfo->dedAlloc.nonSchdErrIndTxHqPLst);
- RETVOID;
+ return;
}
/**
cmLListInit(&allocInfo->schdUeLst);
cmLListInit(&allocInfo->nonSchdUeLst);
- RETVOID;
+ return;
}
/**
rgSCHPwrGrpCntrlPucch(cell, dlSf);
- RETVOID;
+ return;
}
/**
rgSCHPwrGrpCntrlPusch(cell, dlSf, ulSf);
- RETVOID;
+ return;
}
/* Fix: syed align multiple UEs to refresh at same time */
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U32 effGbrBsr = 0;
- U32 effNonGbrBsr = 0;
- U32 lcgId;
+ uint32_t effGbrBsr = 0;
+ uint32_t effNonGbrBsr = 0;
+ uint32_t lcgId;
/* Reset the refresh cycle variableCAP */
PRIVATE Void rgSchCmnUpdCfiVal
(
RgSchCellCb *cell,
-U8 delta
+uint8_t delta
)
#else
PRIVATE Void rgSchCmnUpdCfiVal(cell, delta)
RgSchCellCb *cell;
-U8 delta;
+uint8_t delta;
#endif
{
RgSchDlSf *dlSf;
CmLteTimingInfo pdsch;
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U8 dlIdx;
+ uint8_t dlIdx;
#ifdef LTE_TDD
- U8 mPhich;
+ uint8_t mPhich;
RgSchDlSf *tddSf;
- U8 idx;
- U8 splSfCfi = 0;
+ uint8_t idx;
+ uint8_t splSfCfi = 0;
#endif
}
}
- RETVOID;
+ return;
}
/***********************************************************
PRIVATE Void rgSchCmnUpdtPdcchSfIdx
(
RgSchCellCb *cell,
-U8 dlIdx,
-U8 sfNum
+uint8_t dlIdx,
+uint8_t sfNum
)
#else
PRIVATE Void rgSchCmnUpdtPdcchSfIdx(cell, dlIdx, sfNum)
RgSchCellCb *cell;
-U8 dlIdx;
-U8 sfNum;
+uint8_t dlIdx;
+uint8_t sfNum;
#endif
#else
#ifdef ANSI
PRIVATE Void rgSchCmnUpdtPdcchSfIdx
(
RgSchCellCb *cell,
-U8 dlIdx
+uint8_t dlIdx
)
#else
PRIVATE Void rgSchCmnUpdtPdcchSfIdx(cell, dlIdx)
RgSchCellCb *cell;
-U8 dlIdx;
+uint8_t dlIdx;
#endif
#endif
{
- U8 idx;
+ uint8_t idx;
/* Resetting the parameters on CFI switching */
Void rgSchCmnUpdCfiDb
(
RgSchCellCb *cell,
-U8 delta
+uint8_t delta
)
#else
Void rgSchCmnUpdCfiDb(cell, delta)
RgSchCellCb *cell;
-U8 delta;
+uint8_t delta;
#endif
{
CmLteTimingInfo frm;
RgSchDlSf *dlSf;
#ifdef LTE_TDD
- U8 mPhich;
+ uint8_t mPhich;
Bool isHiDci0;
#endif
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 nCceLowerCfi = 0;
- U8 currCfi;
- U8 cceFailIdx;
- U32 totalCce;
- U8 dlIdx;
- U16 ttiMod;
+ uint8_t nCceLowerCfi = 0;
+ uint8_t currCfi;
+ uint8_t cceFailIdx;
+ uint32_t totalCce;
+ uint8_t dlIdx;
+ uint16_t ttiMod;
/* Get Downlink Subframe */
{
rgSCHCmnDlCcchRarAlloc(cell);
}
- RETVOID;
+ return;
}
/**
/* LAA_SCELL: */
if(TRUE == rgSCHLaaSCellEnabled(cell))
{
- RETVOID;
+ return;
}
#endif
#endif
#endif
- RETVOID;
+ return;
}
\f
{
rgSCHCmnSpsDlDedBoUpd(cell, ue, svc);
/* Note: Retrun from here, no update needed in other schedulers */
- RETVOID;
+ return;
}
#endif
#ifdef EMTC_ENABLE
rgSCHSCellDlDedBoUpd(cell, ue, svc);
}
#endif
- RETVOID;
+ return;
}
\f
cmLListDelFrm(&cellCmnDl->taLst, &ue->dlTaLnk);
ue->dlTaLnk.node = (PTR)NULLP;
}
- RETVOID;
+ return;
}
/* Fix: syed Remove the msg4Proc from cell
}
#endif
}
- RETVOID;
+ return;
}
\f
{
/* Invoke SPS module for SPS HARQ proc re-transmission handling */
rgSCHCmnSpsDlProcAddToRetx(cell, hqP);
- RETVOID;
+ return;
}
#endif /* LTEMAC_SPS */
#ifdef EMTC_ENABLE
cellSch->apisDl->rgSCHDlProcAddToRetx(cell, hqP);
}
}
- RETVOID;
+ return;
}
\f
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 ri
+ * @param[in] uint8_t ri
* @param[in] Bool isPeriodic
* @return Void
*
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 ri,
+uint8_t ri,
Bool isPer
)
#else
PRIVATE Void rgSCHCmnDlSetUeRi(cell, ue, ri, isPer)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 ri;
+uint8_t ri;
Bool isPer;
#endif
{
* specific during which SCH expecting UE can complete TX mode transition*/
if (ue->txModeTransCmplt == FALSE)
{
- RETVOID;
+ return;
}
/* Restrict the Number of TX layers to cell->numTxAntPorts.
RG_SCH_CMN_SET_FORCE_TD(ue, cell, RG_SCH_CMN_TD_RI_1);
}
- RETVOID;
+ return;
}
\f
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 pmi
+ * @param[in] uint8_t pmi
* @return Void
*
**/
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 pmi
+uint8_t pmi
)
#else
PRIVATE S16 rgSCHCmnDlSetUePmi(cell, ue, pmi)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 pmi;
+uint8_t pmi;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
}
else
{
- RETVOID;
+ return;
}
}
else if (pucchCqi->u.mode10Info.type == TFU_RPT_RI)
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode10Info.u.ri,ue->ueId);
- RETVOID;
+ return;
}
}
}
}
else
{
- RETVOID;
+ return;
}
rgSCHCmnDlSetUePmi(cell, ue, \
pucchCqi->u.mode11Info.u.cqi.pmi);
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode11Info.u.ri,ue->ueId);
- RETVOID;
+ return;
}
}
}
}
else
{
- RETVOID;
+ return;
}
}
}
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode20Info.u.ri,ue->ueId);
- RETVOID;
+ return;
}
}
}
}
else
{
- RETVOID;
+ return;
}
rgSCHCmnDlSetUePmi(cell, ue, \
pucchCqi->u.mode21Info.u.cqi.u.wideCqi.pmi);
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId, "Invalid RI value(%x) CRNTI:%d",
pucchCqi->u.mode21Info.u.ri,ue->ueId);
- RETVOID;
+ return;
}
}
}
break;
}
- RETVOID;
+ return;
} /* rgSCHCmnDlCqiOnPucchInd */
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- U32 prevRiVal = 0;
+ uint32_t prevRiVal = 0;
if (puschCqi->ri.pres == PRSNT_NODEF)
{
if (RG_SCH_CMN_IS_RI_VALID(puschCqi->ri.val))
{
RLOG_ARG2(L_ERROR,DBG_CELLID,cell->cellId,"Invalid RI value(%x) CRNTI:%d",
puschCqi->ri.val,ue->ueId);
- RETVOID;
+ return;
}
}
ue->mimoInfo.puschFdbkVld = FALSE;
}
else
{
- RETVOID;
+ return;
}
break;
case TFU_PUSCH_CQI_MODE_30:
#endif
#ifdef CA_DBG
{
- extern U32 gACqiRcvdCount;
+ extern uint32_t gACqiRcvdCount;
gACqiRcvdCount++;
}
}
else
{
- RETVOID;
+ return;
}
break;
case TFU_PUSCH_CQI_MODE_12:
}
else
{
- RETVOID;
+ return;
}
if((puschCqi->u.mode12Info.cqiIdx[1]) &&
(puschCqi->u.mode12Info.cqiIdx[1] < RG_SCH_CMN_MAX_CQI))
}
else
{
- RETVOID;
+ return;
}
ue->mimoInfo.puschFdbkVld = TRUE;
ue->mimoInfo.puschPmiInfo.mode = TFU_PUSCH_CQI_MODE_12;
}
else
{
- RETVOID;
+ return;
}
if((puschCqi->u.mode22Info.wideBandCqi[1]) &&
(puschCqi->u.mode22Info.wideBandCqi[1] < RG_SCH_CMN_MAX_CQI))
}
else
{
- RETVOID;
+ return;
}
rgSCHCmnDlSetUePmi(cell, ue, puschCqi->u.mode22Info.wideBandPmi);
ue->mimoInfo.puschFdbkVld = TRUE;
break;
}
- RETVOID;
+ return;
} /* rgSCHCmnDlCqiOnPuschInd */
\f
}
else
{
- U8 dlCqiDeltaPrev = 0;
+ uint8_t dlCqiDeltaPrev = 0;
dlCqiDeltaPrev = ue->prevCqi - ueDl->mimoInfo.cwInfo[0].cqi;
if (dlCqiDeltaPrev > 3)
dlCqiDeltaPrev = 3;
cell->tenbStats->sch.dlNumCw0Cqi ++;
cell->tenbStats->sch.dlNumCw1Cqi ++;
#endif
- RETVOID;
+ return;
}
#ifdef TFU_UPGRADE
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnCalcWcqiFrmSnr
+PRIVATE uint8_t rgSCHCmnCalcWcqiFrmSnr
(
RgSchCellCb *cell,
TfuSrsRpt *srsRpt
)
#else
-PRIVATE U8 rgSCHCmnCalcWcqiFrmSnr(cell,srsRpt)
+PRIVATE uint8_t rgSCHCmnCalcWcqiFrmSnr(cell,srsRpt)
RgSchCellCb *cell;
TfuSrsRpt *srsRpt;
#endif
{
- U8 wideCqi=1; /*Calculated value from SNR*/
+ uint8_t wideCqi=1; /*Calculated value from SNR*/
/*Need to map a certain SNR with a WideCQI value.
* The CQI calculation is still primitive. Further, need to
* use a improvized method for calculating WideCQI from SNR*/
CmLteTimingInfo timingInfo;
#endif
{
- U8 wideCqi; /*Calculated value from SNR*/
- U32 recReqTime; /*Received Time in TTI*/
+ uint8_t wideCqi; /*Calculated value from SNR*/
+ uint32_t recReqTime; /*Received Time in TTI*/
recReqTime = (timingInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G) + timingInfo.slot;
ue->srsCb.selectedAnt = (recReqTime/ue->srsCb.peri)%2;
wideCqi = rgSCHCmnCalcWcqiFrmSnr(cell, srsRpt);
}
rgSCHCmnFindUlCqiUlTxAnt(cell, ue, wideCqi);
- RETVOID;
+ return;
}/*rgSCHCmnSrsInd*/
#endif
/* Fix : syed Ignore if TaTmr is not configured */
if ((ue->dl.taCb.cfgTaTmr) && (rgSCHCmnUeIdleExdThrsld(cell, ue) == ROK))
{
- U32 prevDlMsk = ue->dl.dlInactvMask;
- U32 prevUlMsk = ue->ul.ulInactvMask;
+ uint32_t prevDlMsk = ue->dl.dlInactvMask;
+ uint32_t prevUlMsk = ue->ul.ulInactvMask;
ue->dl.dlInactvMask |= RG_PDCCHODR_INACTIVE;
ue->ul.ulInactvMask |= RG_PDCCHODR_INACTIVE;
/* Indicate Specific scheduler for this UEs inactivity */
ue->ueId);
}
}
- RETVOID;
+ return;
}
#ifdef TFU_UPGRADE
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 wideCqi
+ * @param[in] uint8_t wideCqi
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 wideCqi
+uint8_t wideCqi
)
#else
PRIVATE Void rgSCHCmnFindUlCqiUlTxAnt(cell, ue, wideCqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 wideCqi;
+uint8_t wideCqi;
#endif
{
ue->validTxAnt = 1;
- RETVOID;
+ return;
} /* rgSCHCmnFindUlCqiUlTxAnt */
#endif
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
#ifdef UL_LA
- U8 iTbsNew;
+ uint8_t iTbsNew;
S32 previTbs;
#endif
#if (defined(SCH_STATS) || defined(TENB_STATS))
}
#endif
- RETVOID;
+ return;
} /* rgSCHCmnUlCqiInd */
/**
#endif
{
#ifndef RG_5GTF
- U8 procId = rgSCHCmnGetUlHqProcIdx(&frm, cell);
+ uint8_t procId = rgSCHCmnGetUlHqProcIdx(&frm, cell);
#endif
#ifndef RG_5GTF
*procRef = rgSCHUhmGetUlHqProc(cell, ue, procId);
#else
*procRef = rgSCHUhmGetUlProcByTime(cell, ue, frm);
#endif
- RETVOID;
+ return;
}
#ifdef RG_UNUSED
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
* @param[in] RgSchLcgCb *ulLcg
- * @param[in] U8 bsr
+ * @param[in] uint8_t bsr
* @param[out] RgSchErrInfo *err
* @return S16
* -# ROK
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *ulLcg,
-U8 bsr,
+uint8_t bsr,
RgSchErrInfo *err
)
#else
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *ulLcg;
-U8 bsr;
+uint8_t bsr;
RgSchErrInfo *err;
#endif
{
- U8 lcgCnt;
+ uint8_t lcgCnt;
#ifdef LTE_L2_MEAS
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
#endif
RgSchCmnLcg *cmnLcg = NULLP;
#ifdef LTE_L2_MEAS
- U8 idx;
+ uint8_t idx;
#endif
if (!RGSCH_LCG_ISCFGD(ulLcg))
#ifdef LTE_ADV
if (ue->ul.isUlCaEnabled && ue->numSCells)
{
- for(U8 sCellIdx = 1; sCellIdx <= RG_SCH_MAX_SCELL ; sCellIdx++)
+ for(uint8_t sCellIdx = 1; sCellIdx <= RG_SCH_MAX_SCELL ; sCellIdx++)
{
#ifndef PAL_ENABLE_UL_CA
if((ue->cellInfo[sCellIdx] != NULLP) &&
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
* @param[in] RgSchLcgCb *ulLcg
- * @param[in] U8 bsr
+ * @param[in] uint8_t bsr
* @param[out] RgSchErrInfo *err
* @return S16
* -# ROK
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *ulLcg,
-U8 bsr,
+uint8_t bsr,
RgSchErrInfo *err
)
#else
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *ulLcg;
-U8 bsr;
+uint8_t bsr;
RgSchErrInfo *err;
#endif
{
RgSchCmnLcg *cmnLcg = NULLP;
S32 cnt;
#ifdef LTE_L2_MEAS
- U8 idx;
+ uint8_t idx;
#endif
#ifdef LTE_ADV
if (ue->ul.isUlCaEnabled && ue->numSCells)
{
- for(U8 sCellIdx = 1; sCellIdx <= RG_SCH_MAX_SCELL ; sCellIdx++)
+ for(uint8_t sCellIdx = 1; sCellIdx <= RG_SCH_MAX_SCELL ; sCellIdx++)
{
#ifndef PAL_ENABLE_UL_CA
if((ue->cellInfo[sCellIdx] != NULLP) &&
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 bsArr[]
+ * @param[in] uint8_t bsArr[]
* @param[out] RgSchErrInfo *err
* @return S16
* -# ROK
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 *bsArr,
+uint8_t *bsArr,
RgSchErrInfo *err
)
#else
S16 rgSCHCmnUpdBsrLong(cell, ue, bsArr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 *bsArr;
+uint8_t *bsArr;
RgSchErrInfo *err;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U32 tmpBsArr[4] = {0, 0, 0, 0};
- U32 nonGbrBs = 0;
+ uint32_t tmpBsArr[4] = {0, 0, 0, 0};
+ uint32_t nonGbrBs = 0;
#ifdef LTE_L2_MEAS
- U8 idx1;
- U8 idx2;
+ uint8_t idx1;
+ uint8_t idx2;
#endif
- U32 lcgId;
+ uint32_t lcgId;
#ifdef LTE_L2_MEAS
#ifdef LTE_ADV
if (ue->ul.isUlCaEnabled && ue->numSCells)
{
- for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
+ for(uint8_t idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
#ifndef PAL_ENABLE_UL_CA
if((ue->cellInfo[idx] != NULLP) &&
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 phr
+ * @param[in] uint8_t phr
* @param[out] RgSchErrInfo *err
* @return S16
* -# ROK
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 phr
+ * @param[in] uint8_t phr
* @param[out] RgSchErrInfo *err
* @return S16
* -# ROK
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 phr,
+uint8_t phr,
RgSchErrInfo *err
)
#else
S16 rgSCHCmnUpdPhr(cell, ue, phr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 phr;
+uint8_t phr;
RgSchErrInfo *err;
#endif
{
(Void)rgSCHDrxStrtInActvTmr(cell,&ulUeLst,RG_SCH_DRX_UL);
- RETVOID;
+ return;
}
* Invoked by: TOM
*
* @param[in] RgSchCellCb *cell
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @return RgSchUlAlloc*
**/
#ifdef ANSI
RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc
(
RgSchCellCb *cell,
-U8 idx
+uint8_t idx
)
#else
RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc(cell, idx)
RgSchCellCb *cell;
-U8 idx;
+uint8_t idx;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
-U8 idx
+uint8_t idx
)
#else
RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc(cell, alloc, idx)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
-U8 idx;
+uint8_t idx;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
*
**********************************************************/
#ifdef ANSI
-U8 rgSCHCmnUlGetITbsFrmIMcs
+uint8_t rgSCHCmnUlGetITbsFrmIMcs
(
-U8 iMcs
+uint8_t iMcs
)
#else
-U8 rgSCHCmnUlGetITbsFrmIMcs(iMcs)
-U8 iMcs;
+uint8_t rgSCHCmnUlGetITbsFrmIMcs(iMcs)
+uint8_t iMcs;
#endif
{
*
**********************************************************/
#ifdef ANSI
-U8 rgSCHCmnUlGetIMcsFrmITbs
+uint8_t rgSCHCmnUlGetIMcsFrmITbs
(
-U8 iTbs,
+uint8_t iTbs,
CmLteUeCategory ueCtg
)
#else
-U8 rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg)
-U8 iTbs;
+uint8_t rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg)
+uint8_t iTbs;
CmLteUeCategory ueCtg;
#endif
{
- U8 iMcs;
+ uint8_t iMcs;
if (iTbs <= 10)
{
*
**********************************************************/
#ifdef ANSI
-U32 rgSCHCmnUlMinTbBitsForITbs
+uint32_t rgSCHCmnUlMinTbBitsForITbs
(
RgSchCmnUlCell *cellUl,
-U8 iTbs
+uint8_t iTbs
)
#else
-U32 rgSCHCmnUlMinTbBitsForITbs(cellUl, iTbs)
+uint32_t rgSCHCmnUlMinTbBitsForITbs(cellUl, iTbs)
RgSchCmnUlCell *cellUl;
-U8 iTbs;
+uint8_t iTbs;
#endif
{
RgSchUlAlloc *rgSCHCmnUlSbAlloc
(
RgSchUlSf *sf,
-U8 numSb,
+uint8_t numSb,
RgSchUlHole *hole
)
#else
RgSchUlAlloc *rgSCHCmnUlSbAlloc(sf, numSb, hole)
RgSchUlSf *sf;
-U8 numSb;
+uint8_t numSb;
RgSchUlHole *hole;
#endif
{
- U8 holeSz; /* valid hole size */
+ uint8_t holeSz; /* valid hole size */
RgSchUlAlloc *alloc;
if ((holeSz = rgSchCmnMult235Tbl[hole->num].prvMatch) == hole->num)
rgSCHCmnUlUpdOutStndAlloc(cell, ue, ulAllocInfo->allocdBytes);
}
- RETVOID;
+ return;
}
/**
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,ue->cell);
CmLList *node = ueUl->ulAllocLst.last;
RgSchCmnAllocRecord *allRcd;
- U32 outStndAlloc=0;
- U32 nonLcg0OutStndAllocBs=0;
- U32 nonLcg0Bsr=0;
- U8 lcgId;
+ uint32_t outStndAlloc=0;
+ uint32_t nonLcg0OutStndAllocBs=0;
+ uint32_t nonLcg0Bsr=0;
+ uint8_t lcgId;
RgSchCmnLcg *cmnLcg = NULLP;
while (node)
/* better be handled in individual scheduler */
ue->ul.effBsr = nonLcg0Bsr +\
((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs;
- RETVOID;
+ return;
}
/**
cell->measurements.ulBytesCnt += ulAllocInfo->allocdBytes;
- RETVOID;
+ return;
}
/** PHR handling for MSG3
rgSCHPwrRecordRbAlloc(cell, ue, allRcd->numRb);
- RETVOID;
+ return;
}
/**
* @brief Keeps track of the most recent RG_SCH_CMN_MAX_ALLOC_TRACK
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U32 alloc
+ * @param[in] uint32_t alloc
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 alloc
+uint32_t alloc
)
#else
Void rgSCHCmnUlUpdOutStndAlloc(cell, ue, alloc)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U32 alloc;
+uint32_t alloc;
#endif
{
- U32 nonLcg0Alloc=0;
+ uint32_t nonLcg0Alloc=0;
/* Update UEs LCG0's bs according to the total outstanding BSR allocation.*/
if (((RgSchCmnLcg *)(ue->ul.lcgArr[0].sch))->bs > alloc)
/* Resetting UEs lower Cap */
ue->ul.minReqBytes = 0;
- RETVOID;
+ return;
}
* Invoked by: Scheduler
*
* @param[in] RgSchUeCb *ue
- * @return U8
+ * @return uint8_t
**/
#ifdef ANSI
-U8 rgSCHCmnUlGetITbs
+uint8_t rgSCHCmnUlGetITbs
(
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool isEcp
)
#else
-U8 rgSCHCmnUlGetITbs(cell, ue, isEcp)
+uint8_t rgSCHCmnUlGetITbs(cell, ue, isEcp)
RgSchCellCb *cell;
RgSchUeCb *ue;
Bool isEcp;
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
/* CQI will be capped to maxUlCqi for 16qam UEs */
CmLteUeCategory ueCtgy = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
- U8 cqi;
+ uint8_t cqi;
#ifdef UL_LA
S32 iTbs;
- U8 maxiTbs = rgSchCmnUlCqiToTbsTbl[(U8)isEcp][ueUl->maxUlCqi];
+ uint8_t maxiTbs = rgSchCmnUlCqiToTbsTbl[(uint8_t)isEcp][ueUl->maxUlCqi];
#endif
cqi = ueUl->crntUlCqi[0];
}
#endif
- return (rgSchCmnUlCqiToTbsTbl[(U8)isEcp][cqi]);
+ return (rgSchCmnUlCqiToTbsTbl[(uint8_t)isEcp][cqi]);
}
/**
hqP->reqLnk.node = (PTR)hqP;
}
}
- RETVOID;
+ return;
}
/**
cmLListAdd2Tail(&allocInfo->dedAlloc.retxHqPLst, &hqP->reqLnk);
hqP->reqLnk.node = (PTR)hqP;
}
- RETVOID;
+ return;
}
/**
cmLListAdd2Tail(&allocInfo->dedAlloc.txRetxHqPLst, &hqP->reqLnk);
hqP->reqLnk.node = (PTR)hqP;
}
- RETVOID;
+ return;
}
/**
if ( (hqP->sch != (RgSchCmnDlHqProc *)NULLP) &&
(RG_SCH_CMN_SPS_DL_IS_SPS_HQP(hqP)))
{
- RETVOID;
+ return;
}
#endif
RG_SCH_CMN_INIT_SCHD_LNK(schdLnkNode, hqP);
cmLListAdd2Tail(&allocInfo->dedAlloc.nonSchdRetxHqPLst, schdLnkNode);
- RETVOID;
+ return;
}
RgSchCellCb *cell;
#endif
{
- U8 sfCount;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 maxDlSubfrms = cell->numDlSubfrms;
- U8 sfNum;
- U8 idx;
- U8 dlIdx;
- U8 calcSfnOffset;
+ uint8_t sfCount;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t maxDlSubfrms = cell->numDlSubfrms;
+ uint8_t sfNum;
+ uint8_t idx;
+ uint8_t dlIdx;
+ uint8_t calcSfnOffset;
S8 calcSfNum;
- U8 ulSfCnt =0;
+ uint8_t ulSfCnt =0;
RgSchTddSubfrmInfo ulSubfrmInfo;
- U8 maxUlSubfrms;
+ uint8_t maxUlSubfrms;
ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
RgSchCellCb *cell;
#endif
{
- U8 sfCount;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 maxDlSubfrms = cell->numDlSubfrms;
- U8 sfNum;
- U8 dlIdx;
+ uint8_t sfCount;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t maxDlSubfrms = cell->numDlSubfrms;
+ uint8_t sfNum;
+ uint8_t dlIdx;
S8 calcSfnOffset;
S8 calcSfNum;
- U8 ulSfCnt =0;
+ uint8_t ulSfCnt =0;
RgSchTddSubfrmInfo ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
- U8 maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
+ uint8_t maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
[RGSCH_NUM_SUB_FRAMES-1];
- U8 dlPres = 0;
+ uint8_t dlPres = 0;
/* Generate ACK/NACK offset information for each DL subframe in a radio frame
RgSchCellCb *cell;
#endif
{
- U8 idx;
- U16 np;
+ uint8_t idx;
+ uint16_t np;
/* Always Np is 0 for p=0 */
cell->rgSchTddNpValTbl[0] = 0;
for(idx=1; idx < RGSCH_TDD_MAX_P_PLUS_ONE_VAL; idx++)
{
np = cell->bwCfg.dlTotalBw * (idx * RG_SCH_CMN_NUM_SUBCAR - 4);
- cell->rgSchTddNpValTbl[idx] = (U8) (np/36);
+ cell->rgSchTddNpValTbl[idx] = (uint8_t) (np/36);
}
return ROK;
RgSchCellCb *cell;
#endif
{
- U8 raArrSz;
+ uint8_t raArrSz;
S16 ret;
- U8 lstSize;
+ uint8_t lstSize;
RG_SCH_CMN_CALC_RARSPLST_SIZE(cell, raArrSz);
RgSchCellCb *cell;
#endif
{
- U8 sfCount;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 sfNum;
- U8 ulSfCnt =0;
- U8 maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
+ uint8_t sfCount;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t sfNum;
+ uint8_t ulSfCnt =0;
+ uint8_t maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
[RGSCH_NUM_SUB_FRAMES-1];
- U8 raArrSz;
- RgSchTddRachRspLst rachRspLst[3][RGSCH_NUM_SUB_FRAMES];
- U8 startWin;
- U8 endWin;
- U8 sfnIdx;
- U8 subfrmIdx;
- U8 endSubfrmIdx;
- U8 startSubfrmIdx;
- S16 ret;
- RgSchTddRachDelInfo *delInfo;
- S8 sfnOffset;
- U8 numSubfrms;
+ uint8_t raArrSz;
+ RgSchTddRachRspLst rachRspLst[3][RGSCH_NUM_SUB_FRAMES];
+ uint8_t startWin;
+ uint8_t endWin;
+ uint8_t sfnIdx;
+ uint8_t subfrmIdx;
+ uint8_t endSubfrmIdx;
+ uint8_t startSubfrmIdx;
+ S16 ret;
+ RgSchTddRachDelInfo *delInfo;
+ S8 sfnOffset;
+ uint8_t numSubfrms;
memset(rachRspLst, 0, sizeof(rachRspLst));
RgSchCellCb *cell;
#endif
{
- U8 sfCount;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 maxDlSubfrms = cell->numDlSubfrms;
- U8 sfNum;
- U8 dlIdx;
- U8 dlPres = 0;
- U8 calcSfnOffset;
- U8 calcSfNum;
- U8 ulSfCnt =0;
+ uint8_t sfCount;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t maxDlSubfrms = cell->numDlSubfrms;
+ uint8_t sfNum;
+ uint8_t dlIdx;
+ uint8_t dlPres = 0;
+ uint8_t calcSfnOffset;
+ uint8_t calcSfNum;
+ uint8_t ulSfCnt =0;
RgSchTddSubfrmInfo ulSubfrmInfo = rgSchTddMaxUlSubfrmTbl[ulDlCfgIdx];
- U8 maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
+ uint8_t maxUlSubfrms = rgSchTddNumUlSubfrmTbl[ulDlCfgIdx]\
[RGSCH_NUM_SUB_FRAMES-1];
RgSchCellCb *cell;
#endif
{
- RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- CmLteTimingInfo timeInfo;
- U8 idx;
- U8 ulSubframe;
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 msg3Subfrm;
- U8 Mval;
+ RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
+ CmLteTimingInfo timeInfo;
+ uint8_t idx;
+ uint8_t ulSubframe;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t msg3Subfrm;
+ uint8_t Mval;
/* ccpu00132654-ADD- Initializing all the indices in every subframe*/
rgSCHCmnInitVars(cell);
else
{
/* introduce some reuse with above code? */
- U8 offst;
+ uint8_t offst;
RGSCHCMNADDTOCRNTTIME(cell->crntTime,timeInfo,RG_SCH_CMN_DL_DELTA)
//offst = rgSchTddMsg3SubfrmTbl[ulDlCfgIdx][timeInfo.subframe];
offst = rgSchTddSpsUlRsrvTbl[ulDlCfgIdx][timeInfo.subframe];
* mainly the prachMaskIndex */
rgSCHCmnUpdRachParam(cell);
- RETVOID;
+ return;
}
/**
* Purpose: Gets 'p' value for HARQ ACK/NACK reception from CCE.
*
* @param[in] RgSchCellCb *cell
- * @param[in] U8 cce
- * @return U8
+ * @param[in] uint8_t cce
+ * @return uint8_t
*
**/
#ifdef ANSI
-U8 rgSCHCmnGetPValFrmCCE
+uint8_t rgSCHCmnGetPValFrmCCE
(
RgSchCellCb *cell,
-U8 cce
+uint8_t cce
)
#else
-U8 rgSCHCmnGetPValFrmCCE(cell, cce)
+uint8_t rgSCHCmnGetPValFrmCCE(cell, cce)
RgSchCellCb *cell;
-U8 cce;
+uint8_t cce;
#endif
{
- U8 i;
+ uint8_t i;
for(i=1; i < RGSCH_TDD_MAX_P_PLUS_ONE_VAL; i++)
{
{
alloc->grnt.iMcsCrnt = alloc->grnt.iMcs;
}
- RETVOID;
+ return;
}
/**
/* take care of this in UL retransmission */
cellSch->apisUl->rgSCHUlInactvtUes(cell, &ulInactvLst);
- RETVOID;
+ return;
}
/**
rgSCHMeasGapANRepGetDlInactvUe (cell, &dlInactvLst);
cellSch->apisDl->rgSCHDlInactvtUes(cell, &dlInactvLst);
- RETVOID;
+ return;
}
/* RACHO: Rach handover functions start here */
#endif
{
/* Time difference in subframes */
- U32 sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime, ue->ul.ulTransTime);
+ uint32_t sfDiff = RGSCH_CALC_SF_DIFF(cell->crntTime, ue->ul.ulTransTime);
- if (sfDiff > (U32)RG_SCH_CMN_UE_IDLE_THRSLD(ue))
+ if (sfDiff > (uint32_t)RG_SCH_CMN_UE_IDLE_THRSLD(ue))
{
return ROK;
}
#endif
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- U32 gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
- U32 sfDiff;
- U8 cnt;
+ uint32_t gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
+ uint32_t sfDiff;
+ uint8_t cnt;
if (cell->macPreambleSet.pres == NOTPRSNT)
{
- RETVOID;
+ return;
}
cellSch->rachCfg.numDedPrm = cell->macPreambleSet.size;
cellSch->rachCfg.dedPrmStart = cell->macPreambleSet.start;
sfDiff = RGSCH_CALC_SF_DIFF(cellSch->rachCfg.applFrm, cell->crntTime);
}
- RETVOID;
+ return;
}
/**
cell->rachCfg.raOccasion.subFrameNum[cellSch->rachCfg.prachMskIndx];
}
}
- RETVOID;
+ return;
}
/**
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
- U32 gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
- U32 sfDiff;
+ uint32_t gap = RG_SCH_CMN_MIN_PRACH_OPPR_GAP;
+ uint32_t sfDiff;
if (cell->macPreambleSet.pres == NOTPRSNT)
{
- RETVOID;
+ return;
}
sfDiff = RGSCH_CALC_SF_DIFF(cellSch->rachCfg.applFrm, \
cell->crntTime);
if (sfDiff > gap)
{
/* applFrm is still a valid next Prach Oppurtunity */
- RETVOID;
+ return;
}
rgSCHCmnUpdNxtPrchMskIdx(cell);
/* Reset remDedPrm as numDedPrm */
cellSch->rachCfg.remDedPrm = cellSch->rachCfg.numDedPrm;
- RETVOID;
+ return;
}
/**
* @param[in] RgSchDlSf *dlSf
* @param[in] RgSchUeCb *ue
* @param[out] RgSchPdcch **pdcch
- * @param[out] U8 *rapId
- * @param[out] U8 *prachMskIdx
+ * @param[out] uint8_t *rapId
+ * @param[out] uint8_t *prachMskIdx
* @return Void
**/
#ifdef ANSI
RgSchDlSf *dlSf,
RgSchUeCb *ue,
RgSchPdcch **pdcch,
-U8 *rapId,
-U8 *prachMskIdx
+uint8_t *rapId,
+uint8_t *prachMskIdx
)
#else
PRIVATE S16 rgSCHCmnAllocPOParam(cell, dlSf, ue, pdcch, rapId, prachMskIdx)
RgSchDlSf *dlSf;
RgSchUeCb *ue;
RgSchPdcch **pdcch;
-U8 *rapId;
-U8 *prachMskIdx;
+uint8_t *rapId;
+uint8_t *prachMskIdx;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
CmLList *node = cellSch->rachCfg.pdcchOdrLst.first;
RgSchUeCb *ue;
- U8 rapId;
- U8 prachMskIdx;
+ uint8_t rapId;
+ uint8_t prachMskIdx;
RgSchPdcch *pdcch = NULLP;
/* Reset UE's power state */
rgSCHPwrUeReset(cell, ue);
}
- RETVOID;
+ return;
}
\f
cmLListAdd2Tail(&cellSch->rachCfg.pdcchOdrLst, &ueDl->rachInfo.poLnk);
ueDl->rachInfo.poLnk.node = (PTR)ue;
}
- RETVOID;
+ return;
}
\f
cmLListDelFrm(&cellSch->rachCfg.pdcchOdrLst, &ueDl->rachInfo.poLnk);
ueDl->rachInfo.poLnk.node = NULLP;
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchUeCb *ue
* @param[in] RgSchPdcch *pdcch
- * @param[in] U8 rapId
- * @param[in] U8 prachMskIdx
+ * @param[in] uint8_t rapId
+ * @param[in] uint8_t prachMskIdx
* @return Void
**/
#ifdef ANSI
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchPdcch *pdcch,
-U8 rapId,
-U8 prachMskIdx
+uint8_t rapId,
+uint8_t prachMskIdx
)
#else
PRIVATE Void rgSCHCmnFillPdcchOdr2Sf(ue, pdcch, rapId, prachMskIdx)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchPdcch *pdcch;
-U8 rapId;
-U8 prachMskIdx;
+uint8_t rapId;
+uint8_t prachMskIdx;
#endif
{
RgSchUeACqiCb *acqiCb = RG_SCH_CMN_GET_ACQICB(ue,cell);
}
#endif
- RETVOID;
+ return;
}
\f
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- U8 rapIdIdx;
+ uint8_t rapIdIdx;
if (ueDl->rachInfo.poLnk.node)
&ueDl->rachInfo.rapIdLnk);
ueDl->rachInfo.rapIdLnk.node = NULLP;
}
- RETVOID;
+ return;
}
/**
rgSCHDrxDedRa(cell,ue);
}
rgSCHCmnAllocPoHoGrnt(cell, raRspLst, ue, raReq);
- RETVOID;
+ return;
}
/**
RgSchUeCb* rgSCHCmnGetHoUe
(
RgSchCellCb *cell,
-U16 rapId
+uint16_t rapId
)
#else
RgSchUeCb* rgSCHCmnGetHoUe(cell, rapId)
RgSchCellCb *cell;
-U16 rapId
+uint16_t rapId
#endif
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
PRIVATE Void rgSCHCmnDelDedPreamble
(
RgSchCellCb *cell,
-U8 preambleId
+uint8_t preambleId
)
#else
PRIVATE rgSCHCmnDelDedPreamble(cell, preambleId)
RgSchCellCb *cell;
-U8 preambleId;
+uint8_t preambleId;
#endif
{
RgSchCmnCell *cellSch = (RgSchCmnCell *)(cell->sc.sch);
RgSchUeCb* rgSCHCmnGetPoUe
(
RgSchCellCb *cell,
-U16 rapId,
+uint16_t rapId,
CmLteTimingInfo timingInfo
)
#else
RgSchUeCb* rgSCHCmnGetPoUe(cell, rapId, timingInfo)
RgSchCellCb *cell;
-U16 rapId;
+uint16_t rapId;
CmLteTimingInfo timingInfo;
#endif
{
CmLListCp *ueLst;
RgSchUeCb *ue;
RgSchCmnDlUe *ueDl;
- U8 rapIdIdx;
+ uint8_t rapIdIdx;
rapIdIdx = rapId -cellSch->rachCfg.dedPrmStart;
ueLst = &cellSch->rachCfg.rapIdMap[rapIdIdx].assgndUes;
* Invoked by: Scheduler
*
* @param[in] RgSchUeCb *ue
- * @param[in] U8 ueCtgy
- * @return U8
+ * @param[in] uint8_t ueCtgy
+ * @return uint8_t
**/
#ifdef ANSI
-U8 rgSCHCmnUlGetCqi
+uint8_t rgSCHCmnUlGetCqi
(
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteUeCategory ueCtgy
)
#else
-U8 rgSCHCmnUlGetCqi(cell, ue, ueCtgy)
+uint8_t rgSCHCmnUlGetCqi(cell, ue, ueCtgy)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteUeCategory ueCtgy;
#endif
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
- U8 cqi;
+ uint8_t cqi;
cqi = ueUl->maxUlCqi;
RgSchCellCb *cell,
RgSchUlSf *sf,
RgSchUeCb *ue,
-U8 maxRb
+uint8_t maxRb
)
#else
PRIVATE S16 rgSCHCmnUlRbAllocForPoHoUe(cell, sf, ue, maxRb)
RgSchCellCb *cell;
RgSchUlSf *sf;
RgSchUeCb *ue;
-U8 maxRb;
+uint8_t maxRb;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue,cell);
- U8 sbSize = cellUl->sbSize;
- U32 maxBits = ue->ul.maxBytesPerUePerTti*8;
- U32 bits;
+ uint8_t sbSize = cellUl->sbSize;
+ uint32_t maxBits = ue->ul.maxBytesPerUePerTti*8;
+ uint32_t bits;
RgSchUlAlloc *alloc;
- U32 nPrb;
- U8 iTbs;
- U32 eff;
- U32 numSb;
- U8 iMcs;
- U8 iMcsCrnt;
- U8 cqi;
- U8 modOdr;
+ uint32_t nPrb;
+ uint8_t iTbs;
+ uint32_t eff;
+ uint32_t numSb;
+ uint8_t iMcs;
+ uint8_t iMcsCrnt;
+ uint8_t cqi;
+ uint8_t modOdr;
RgSchUlHole *hole;
RgSchUlHqProcCb *proc = &ueUl->hqEnt.hqProcCb[cellUl->msg3SchdHqProcIdx];
CmLteUeCategory ueCtg = (CmLteUeCategory)(RG_SCH_CMN_GET_UE_CTGY(ue));
}
/*MS_WORKAROUND for HO ccpu00121116*/
cqi = rgSCHCmnUlGetCqi(cell, ue, ueCtg);
- RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgSchCmnUlCqiToTbsTbl[(U8)cell->isCpUlExtend], cqi);
- iTbs = rgSchCmnUlCqiToTbsTbl[(U8)cell->isCpUlExtend][cqi];
+ RGSCH_ARRAY_BOUND_CHECK(cell->instIdx, rgSchCmnUlCqiToTbsTbl[(uint8_t)cell->isCpUlExtend], cqi);
+ iTbs = rgSchCmnUlCqiToTbsTbl[(uint8_t)cell->isCpUlExtend][cqi];
iMcs = rgSCHCmnUlGetIMcsFrmITbs(iTbs,ueCtg);
while(iMcs > RG_SCH_CMN_MAX_MSG3_IMCS)
{
cqi--;
- iTbs = rgSchCmnUlCqiToTbsTbl[(U8)cell->isCpUlExtend][cqi];
+ iTbs = rgSchCmnUlCqiToTbsTbl[(uint8_t)cell->isCpUlExtend][cqi];
iMcs = rgSCHCmnUlGetIMcsFrmITbs(iTbs, ueCtg);
}
/* Filling the modorder in the grant structure*/
}
iMcsCrnt = iMcs;
- alloc = rgSCHCmnUlSbAlloc(sf, (U8)RGSCH_MIN(numSb, cellUl->maxSbPerUe),\
+ alloc = rgSCHCmnUlSbAlloc(sf, (uint8_t)RGSCH_MIN(numSb, cellUl->maxSbPerUe),\
hole);
if (alloc == NULLP)
{
/* Fix : syed allocs are limited */
if (*sf->allocCountRef >= cellUl->maxAllocPerUlSf)
{
- RETVOID;
+ return;
}
ueUl->alloc.reqBytes = RG_SCH_MIN_GRNT_HOPO;
if (rgSCHCmnUlRbAllocForPoHoUe(cell, sf, ue, RGSCH_MAX_UL_RB) != ROK)
{
- RETVOID;
+ return;
}
/* Fill grant information */
{
RLOG_ARG1(L_ERROR,DBG_INSTID,cell->instIdx, "Failed to get"
"the grant for HO/PDCCH Order. CRNTI:%d",ue->ueId);
- RETVOID;
+ return;
}
ue->ul.rarGrnt.rapId = raReq->raReq.rapId;
ue->ul.rarGrnt.hop = grnt->hop;
if((sf->numACqiCount < RG_SCH_MAX_ACQI_PER_ULSF) && (RG_SCH_APCQI_NO != ue->dl.reqForCqi))
{
#ifdef LTE_ADV
- U8 idx = 0;
+ uint8_t idx = 0;
/* Send two bits cqireq field if more than one cells are configured else one*/
for (idx = 1;idx < CM_LTE_MAX_CELLS;idx++)
{
cmLListAdd2Tail(raRspLst, &ue->ul.rarGrnt.raRspLnk);
ue->ul.rarGrnt.raRspLnk.node = (PTR)ue;
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCmnUlCell *cellUl
* @param[out] RgSchUlAlloc *alloc
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @return Void
*
**/
(
RgSchCmnUlCell *cellUl,
RgSchUlAlloc *alloc,
-U8 idx
+uint8_t idx
)
#else
PRIVATE Void rgSCHCmnUlNonadapRetx(cellUl, alloc, idx)
RgSchCmnUlCell *cellUl;
RgSchUlAlloc *alloc;
-U8 idx;
+uint8_t idx;
#endif
{
rgSCHUhmRetx(alloc->hqProc, alloc);
}
alloc->grnt.isRtx = TRUE;
alloc->pdcch = NULLP;
- RETVOID;
+ return;
}
/**
* @brief Check if 2 allocs overlap
#endif
}
- RETVOID;
+ return;
}
/**
* @brief Update TX and RETX subframe's allocation
/* MS_WORKAROUND ccpu00120827 */
RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
- U8 remAllocs;
+ uint8_t remAllocs;
if ((alloc = rgSCHUtlUlAllocFirst(oldSf)) != NULLP)
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId,"CRNTI:%d "
"rgSCHUtlUlGetSpfcAlloc failed in rgSCHCmnUlInsAllocFrmNewSf2OldSf",
srcAlloc->rnti);
- RETVOID;
+ return;
}
#endif
/* Copy the srcAlloc's state information in to dstAlloc */
/* Set new Tx merged Alloc Flag to TRUE, indicating that this
* alloc shall not be processed for non-adaptive retransmission */
dstAlloc->mrgdNewTxAlloc = TRUE;
- RETVOID;
+ return;
}
/**
* @brief Merge all allocations of newSf to oldSf.
rgSCHUtlUlAllocRls(newSf, alloc);
} while((alloc = nxtAlloc) != NULLP);
}
- RETVOID;
+ return;
}
/**
* @brief Swap Hole/Alloc DB context of newSf and oldSf.
{
RgSchUlAllocDb *tempAllocDb = newSf->allocDb;
RgSchUlHoleDb *tempHoleDb = newSf->holeDb;
- U8 tempAvailSbs = newSf->availSubbands;
+ uint8_t tempAvailSbs = newSf->availSubbands;
UNUSED(cell);
/* Fix ccpu00120610*/
newSf->allocCountRef = &newSf->allocDb->count;
oldSf->allocCountRef = &oldSf->allocDb->count;
- RETVOID;
+ return;
}
/**
* @brief Perform non-adaptive RETX for non-colliding allocs.
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUlSf *newSf
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchUlSf *newSf,
-U8 idx
+uint8_t idx
)
#else
PRIVATE Void rgSCHCmnUlPrcNonAdptRetx(cell, newSf, idx)
RgSchCellCb *cell;
RgSchUlSf *newSf;
-U8 idx;
+uint8_t idx;
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
} while((alloc = nxtAlloc) != NULLP);
}
- RETVOID;
+ return;
}
/**
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUlSf *oldSf
* @param[in] RgSchUlSf *newSf
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @return Void
**/
#ifdef ANSI
RgSchCellCb *cell,
RgSchUlSf *oldSf,
RgSchUlSf *newSf,
-U8 idx
+uint8_t idx
)
#else
PRIVATE Void rgSCHCmnUlPrfmSfMerge(cell, oldSf, newSf, idx)
RgSchCellCb *cell;
RgSchUlSf *oldSf;
RgSchUlSf *newSf;
-U8 idx;
+uint8_t idx;
#endif
{
/* Preassigned resources for msg3 in newSf.
/* Perform non-adaptive RETX for non-colliding allocs */
rgSCHCmnUlPrcNonAdptRetx(cell, newSf, idx);
- RETVOID;
+ return;
}
#endif
/**
if ((alloc = rgSCHUtlUlAllocFirst(sf)) == NULLP)
{
- RETVOID;
+ return;
}
do
{
RgSchUeCb *ueCb = alloc->ue;
RgSchCmnUe *cmnUe = (RgSchCmnUe*)ueCb->sch;
RgSchCmnUlUe *ulUe = &(cmnUe->ul);
- U8 cqi = ulUe->crntUlCqi[0];
- U16 numUlRetx = ueCb->ul.hqEnt.maxHqRetx - alloc->hqProc->remTx;
+ uint8_t cqi = ulUe->crntUlCqi[0];
+ uint16_t numUlRetx = ueCb->ul.hqEnt.maxHqRetx - alloc->hqProc->remTx;
hqRetxStats.ulCqiStat[(cqi - 1)].mcs = alloc->grnt.iMcs;
}
} while ((alloc = nxtAlloc) != NULLP);
- RETVOID;
+ return;
}
/**
* - Perform retransmission
*
* @param[in] RgSchUlSf *sf
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @return Void
**/
#ifdef ANSI
Void rgSCHCmnRlsUlSf
(
RgSchCellCb *cell,
-U8 idx
+uint8_t idx
)
#else
Void rgSCHCmnRlsUlSf(cell, idx)
RgSchCellCb *cell;
-U8 idx;
+uint8_t idx;
#endif
{
/* Initialize the reTxLst of UL HqProcs for RETX subframe */
if (rgSCHUtlUlAllocFirst(oldSf) == NULLP)
{
- RETVOID;
+ return;
}
/* Release all completed TX allocs from sf */
rgSCHCmnUlRmvCmpltdAllocs(cell, oldSf);
oldSf->numACqiCount = 0;
}
- RETVOID;
+ return;
}
/**
#endif
cmLListAdd2Tail(&cmnUlCell->reTxLst, &alloc->hqProc->reTxLnk);
alloc->hqProc->reTxLnk.node = (PTR)alloc->hqProc;
- RETVOID;
+ return;
}
/**
* @param[in] RgSchUlSf *sf
* @param[in] RgSchUlHqProcCb *proc;
* @param[in] RgSchUlHole *hole;
- * @return U8
+ * @return uint8_t
**/
#ifdef ANSI
PRIVATE Bool rgSCHCmnUlAdapRetxAlloc
RgSchUlHole *hole;
#endif
{
- U8 numSb = proc->reTxAlloc.numSb;
- U8 iMcs = proc->reTxAlloc.iMcs;
+ uint8_t numSb = proc->reTxAlloc.numSb;
+ uint8_t iMcs = proc->reTxAlloc.iMcs;
CmLteTimingInfo frm = cell->crntTime;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchDlSf *dlSf;
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUlSf *sf
- * @return U8
+ * @return uint8_t
**/
#ifdef UNUSED_FUNC
#ifdef ANSI
cmLListDelFrm(&cellUl->reTxLst, &proc->reTxLnk);
proc->reTxLnk.node = (PTR)NULLP;
}
- RETVOID;
+ return;
}
#endif
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUlSf *sf
- * @return U8
+ * @return uint8_t
**/
#ifdef ANSI
PRIVATE Void rgSCHCmnUlSfReTxAllocs
/* Fix: syed Adaptive Msg3 Retx crash. */
proc->reTxLnk.node = (PTR)NULLP;
}
- RETVOID;
+ return;
}
/**
{
rgSCHCmnNonDlfsRbAlloc(cell, allocInfo);
}
- RETVOID;
+ return;
}
#ifdef LTEMAC_SPS
* Processing Steps:
* - Fill-up rbgInfo data structure for given DL bandwidth and rbgSize
*
- * @param[in] U8 dlTotalBw
- * @param[in] U8 dlSubsetBw
- * @param[in] U8 maxRaType1SubsetBw
- * @param[in] U8 rbgSize
+ * @param[in] uint8_t dlTotalBw
+ * @param[in] uint8_t dlSubsetBw
+ * @param[in] uint8_t maxRaType1SubsetBw
+ * @param[in] uint8_t rbgSize
* @param[out] RgSchBwRbgInfo *rbgInfo
* @return Void
**/
#ifdef ANSI
Void rgSCHCmnDlGetRbgInfo
(
-U8 dlTotalBw,
-U8 dlSubsetBw,
-U8 maxRaType1SubsetBw,
-U8 rbgSize,
+uint8_t dlTotalBw,
+uint8_t dlSubsetBw,
+uint8_t maxRaType1SubsetBw,
+uint8_t rbgSize,
RgSchBwRbgInfo *rbgInfo
)
#else
Void rgSCHCmnDlGetRbgInfo(dlTotalBw, dlSubsetBw, maxRaType1SubsetBw,
rbgSize, rbgInfo)
-U8 dlTotalBw;
-U8 dlSubsetBw;
-U8 maxRaType1SubsetBw;
-U8 rbgSize;
+uint8_t dlTotalBw;
+uint8_t dlSubsetBw;
+uint8_t maxRaType1SubsetBw;
+uint8_t rbgSize;
RgSchBwRbgInfo *rbgInfo;
#endif
{
#ifdef RGSCH_SPS_UNUSED
- U8 idx = 0;
- U8 lastRbgIdx = ((dlTotalBw + rbgSize - 1)/rbgSize) - 1;
- U8 currRbgSize = rbgSize;
- U8 subsetSizeIdx = 0;
- U8 subsetSize[RG_SCH_NUM_RATYPE1_SUBSETS] = {0};
- U8 lastRbgSize = rbgSize - (dlTotalBw - ((dlTotalBw/rbgSize) * rbgSize));
- U8 numRaType1Rbgs = (maxRaType1SubsetBw + rbgSize - 1)/rbgSize;
+ uint8_t idx = 0;
+ uint8_t lastRbgIdx = ((dlTotalBw + rbgSize - 1)/rbgSize) - 1;
+ uint8_t currRbgSize = rbgSize;
+ uint8_t subsetSizeIdx = 0;
+ uint8_t subsetSize[RG_SCH_NUM_RATYPE1_SUBSETS] = {0};
+ uint8_t lastRbgSize = rbgSize - (dlTotalBw - ((dlTotalBw/rbgSize) * rbgSize));
+ uint8_t numRaType1Rbgs = (maxRaType1SubsetBw + rbgSize - 1)/rbgSize;
#endif
/* Compute maximum number of SPS RBGs for the cell */
rbgInfo->lastRbgSize = rbgSize -
(dlSubsetBw - ((dlSubsetBw/rbgSize) * rbgSize));
#ifdef RGSCH_SPS_UNUSED
- memcpy(rbgInfo->rbgSubsetSize, subsetSize, 4 * sizeof(U8));
+ memcpy(rbgInfo->rbgSubsetSize, subsetSize, 4 * sizeof(uint8_t));
#endif
rbgInfo->numRbs = (rbgInfo->numRbgs * rbgSize > dlTotalBw) ?
dlTotalBw:(rbgInfo->numRbgs * rbgSize);
* - Update RA Type 0, RA Type 1 and RA type 2 masks.
*
* @param[in] RgSchDlSfAllocInfo *allocedInfo
- * @param[in] U8 rbsReq
+ * @param[in] uint8_t rbsReq
* @param[in] RgSchBwRbgInfo *rbgInfo
- * @param[out] U8 *numAllocRbs
+ * @param[out] uint8_t *numAllocRbs
* @param[out] RgSchDlSfAllocInfo *resAllocInfo
* @param[in] Bool isPartialAlloc
*
**/
#ifdef ANSI
-U8 rgSCHCmnDlRaType0Alloc
+uint8_t rgSCHCmnDlRaType0Alloc
(
RgSchDlSfAllocInfo *allocedInfo,
-U8 rbsReq,
+uint8_t rbsReq,
RgSchBwRbgInfo *rbgInfo,
-U8 *numAllocRbs,
+uint8_t *numAllocRbs,
RgSchDlSfAllocInfo *resAllocInfo,
Bool isPartialAlloc
)
#else
-U8 rgSCHCmnDlRaType0Alloc(allocedInfo, rbsReq, rbgInfo,
+uint8_t rgSCHCmnDlRaType0Alloc(allocedInfo, rbsReq, rbgInfo,
numAllocRbs, resAllocInfo, isPartialAlloc)
RgSchDlSfAllocInfo *allocedInfo;
-U8 rbsReq;
+uint8_t rbsReq;
RgSchBwRbgInfo *rbgInfo;
-U8 *numAllocRbs;
+uint8_t *numAllocRbs;
RgSchDlSfAllocInfo *resAllocInfo;
Bool isPartialAlloc;
#endif
{
/* Note: This function atttempts allocation only full allocation */
- U32 remNumRbs, rbgPosInRbgMask, ueRaType2Mask;
- U8 type2MaskIdx, cnt, rbIdx;
- U8 maskSize, rbg;
- U8 bestNumAvailRbs = 0;
- U8 usedRbs = 0;
- U8 numAllocRbgs = 0;
- U8 rbgSize = rbgInfo->rbgSize;
- U32 *rbgMask = &(resAllocInfo->raType0Mask);
+ uint32_t remNumRbs, rbgPosInRbgMask, ueRaType2Mask;
+ uint8_t type2MaskIdx, cnt, rbIdx;
+ uint8_t maskSize, rbg;
+ uint8_t bestNumAvailRbs = 0;
+ uint8_t usedRbs = 0;
+ uint8_t numAllocRbgs = 0;
+ uint8_t rbgSize = rbgInfo->rbgSize;
+ uint32_t *rbgMask = &(resAllocInfo->raType0Mask);
#ifdef RGSCH_SPS_UNUSED
- U8 rbgSubset;
- U32 ueRaType1Mask;
- U32 *raType1Mask = resAllocInfo->raType1Mask;
- U32 *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
+ uint8_t rbgSubset;
+ uint32_t ueRaType1Mask;
+ uint32_t *raType1Mask = resAllocInfo->raType1Mask;
+ uint32_t *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
#endif
- U32 *raType2Mask = resAllocInfo->raType2Mask;
+ uint32_t *raType2Mask = resAllocInfo->raType2Mask;
- U32 allocedMask = allocedInfo->raType0Mask;
+ uint32_t allocedMask = allocedInfo->raType0Mask;
maskSize = rbgInfo->numRbgs;
* - Update RA Type1, RA type 0 and RA type 2 masks.
*
* @param[in] RgSchDlSfAllocInfo *allocedInfo
- * @param[in] U8 rbsReq
+ * @param[in] uint8_t rbsReq
* @param[in] RgSchBwRbgInfo *rbgInfo
- * @param[in] U8 startRbgSubset
- * @param[in] U8 *allocRbgSubset
+ * @param[in] uint8_t startRbgSubset
+ * @param[in] uint8_t *allocRbgSubset
* @param[out] rgSchDlSfAllocInfo *resAllocInfo
* @param[in] Bool isPartialAlloc
*
- * @return U8
+ * @return uint8_t
* Number of allocated RBs
**/
#ifdef ANSI
-U8 rgSCHCmnDlRaType1Alloc
+uint8_t rgSCHCmnDlRaType1Alloc
(
RgSchDlSfAllocInfo *allocedInfo,
-U8 rbsReq,
+uint8_t rbsReq,
RgSchBwRbgInfo *rbgInfo,
-U8 startRbgSubset,
-U8 *allocRbgSubset,
+uint8_t startRbgSubset,
+uint8_t *allocRbgSubset,
RgSchDlSfAllocInfo *resAllocInfo,
Bool isPartialAlloc
)
#else
-U8 rgSCHCmnDlRaType1Alloc(allocedInfo, rbsReq,rbgInfo,startRbgSubset,
+uint8_t rgSCHCmnDlRaType1Alloc(allocedInfo, rbsReq,rbgInfo,startRbgSubset,
allocRbgSubset, resAllocInfo, isPartialAlloc)
RgSchDlSfAllocInfo *allocedInfo;
-U8 rbsReq;
+uint8_t rbsReq;
RgSchBwRbgInfo *rbgInfo;
-U8 startRbgSubset;
-U8 *allocRbgSubset;
+uint8_t startRbgSubset;
+uint8_t *allocRbgSubset;
RgSchDlSfAllocInfo *resAllocInfo;
Bool isPartialAlloc;
#endif
{
/* Note: This function atttempts only full allocation */
- U8 *rbgSubsetSzArr;
- U8 type2MaskIdx, subsetIdx, rbIdx, rbInSubset, rbgInSubset;
- U8 offset, rbg, maskSize, bestSubsetIdx;
- U8 startPos = 0;
- U8 bestNumAvailRbs = 0;
- U8 numAllocRbs = 0;
- U32 ueRaType2Mask, ueRaType0Mask, rbPosInSubset;
- U32 remNumRbs, allocedMask;
- U8 usedRbs = 0;
- U8 rbgSize = rbgInfo->rbgSize;
- U8 rbgSubset = startRbgSubset;
- U32 *rbgMask = &resAllocInfo->raType0Mask;
- U32 *raType1Mask = resAllocInfo->raType1Mask;
- U32 *raType2Mask = resAllocInfo->raType2Mask;
- U32 *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
- U32 *allocMask = allocedInfo->raType1Mask;
+ uint8_t *rbgSubsetSzArr;
+ uint8_t type2MaskIdx, subsetIdx, rbIdx, rbInSubset, rbgInSubset;
+ uint8_t offset, rbg, maskSize, bestSubsetIdx;
+ uint8_t startPos = 0;
+ uint8_t bestNumAvailRbs = 0;
+ uint8_t numAllocRbs = 0;
+ uint32_t ueRaType2Mask, ueRaType0Mask, rbPosInSubset;
+ uint32_t remNumRbs, allocedMask;
+ uint8_t usedRbs = 0;
+ uint8_t rbgSize = rbgInfo->rbgSize;
+ uint8_t rbgSubset = startRbgSubset;
+ uint32_t *rbgMask = &resAllocInfo->raType0Mask;
+ uint32_t *raType1Mask = resAllocInfo->raType1Mask;
+ uint32_t *raType2Mask = resAllocInfo->raType2Mask;
+ uint32_t *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
+ uint32_t *allocMask = allocedInfo->raType1Mask;
/* Initialize the subset size Array */
rbgSubsetSzArr = rbgInfo->rbgSubsetSize;
{
/* Initialize alloced mask and subsetSize depending on the RBG
* subset of allocation */
- U8 startIdx = 0;
+ uint8_t startIdx = 0;
maskSize = rbgSubsetSzArr[bestSubsetIdx];
allocedMask = allocMask[bestSubsetIdx];
RG_SCH_CMN_DL_GET_START_POS(allocedMask, maskSize,
* - Update RA Type2, RA type 1 and RA type 0 masks.
*
* @param[in] RgSchDlSfAllocInfo *allocedInfo
- * @param[in] U8 rbsReq
+ * @param[in] uint8_t rbsReq
* @param[in] RgSchBwRbgInfo *rbgInfo
- * @param[out] U8 *rbStart
+ * @param[out] uint8_t *rbStart
* @param[out] rgSchDlSfAllocInfo *resAllocInfo
* @param[in] Bool isPartialAlloc
*
- * @return U8
+ * @return uint8_t
* Number of allocated RBs
**/
#ifdef ANSI
-U8 rgSCHCmnDlRaType2Alloc
+uint8_t rgSCHCmnDlRaType2Alloc
(
RgSchDlSfAllocInfo *allocedInfo,
-U8 rbsReq,
+uint8_t rbsReq,
RgSchBwRbgInfo *rbgInfo,
-U8 *rbStart,
+uint8_t *rbStart,
RgSchDlSfAllocInfo *resAllocInfo,
Bool isPartialAlloc
)
#else
-U8 rgSCHCmnDlRaType2Alloc(allocedInfo, rbsReq, rbgInfo, rbStart,
+uint8_t rgSCHCmnDlRaType2Alloc(allocedInfo, rbsReq, rbgInfo, rbStart,
resAllocInfo, isPartialAlloc)
RgSchDlSfAllocInfo *allocedInfo;
-U8 rbsReq;
+uint8_t rbsReq;
RgSchBwRbgInfo *rbgInfo;
-U8 *rbStart;
+uint8_t *rbStart;
RgSchDlSfAllocInfo *resAllocInfo;
Bool isPartialAlloc;
#endif
{
- U8 numAllocRbs = 0;
- U8 rbIdx;
- U8 rbgSize = rbgInfo->rbgSize;
- U32 *rbgMask = &resAllocInfo->raType0Mask;
+ uint8_t numAllocRbs = 0;
+ uint8_t rbIdx;
+ uint8_t rbgSize = rbgInfo->rbgSize;
+ uint32_t *rbgMask = &resAllocInfo->raType0Mask;
#ifdef RGSCH_SPS_UNUSED
- U32 *raType1Mask = resAllocInfo->raType1Mask;
+ uint32_t *raType1Mask = resAllocInfo->raType1Mask;
#endif
- U32 *raType2Mask = resAllocInfo->raType2Mask;
+ uint32_t *raType2Mask = resAllocInfo->raType2Mask;
#ifdef RGSCH_SPS_UNUSED
- U32 *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
+ uint32_t *raType1UsedRbs = resAllocInfo->raType1UsedRbs;
#endif
- U32 *allocedMask = allocedInfo->raType2Mask;
+ uint32_t *allocedMask = allocedInfo->raType2Mask;
/* Note: This function atttempts only full allocation */
rgSCHCmnDlGetBestFitHole(allocedMask, rbgInfo->numRbs,
if (numAllocRbs)
{
/* Update the allocation in RA type 0 and RA type 1 masks */
- U8 rbCnt = numAllocRbs;
+ uint8_t rbCnt = numAllocRbs;
#ifdef RGSCH_SPS_UNUSED
- U8 rbgSubset;
- U32 ueRaType1Mask;
+ uint8_t rbgSubset;
+ uint32_t ueRaType1Mask;
#endif
- U32 ueRaType0Mask;
+ uint32_t ueRaType0Mask;
rbIdx = *rbStart;
while(rbCnt)
* Processing Steps:
* - Determine RA Type 0 mask for given rbIdex and rbg size.
*
- * @param[in] U8 rbIdx
- * @param[in] U8 rbgSize
- * @return U32 RA type 0 mask
+ * @param[in] uint8_t rbIdx
+ * @param[in] uint8_t rbgSize
+ * @return uint32_t RA type 0 mask
**/
#ifdef ANSI
-PRIVATE U32 rgSCHCmnGetRaType0Mask
+PRIVATE uint32_t rgSCHCmnGetRaType0Mask
(
-U8 rbIdx,
-U8 rbgSize
+uint8_t rbIdx,
+uint8_t rbgSize
)
#else
-PRIVATE U32 rgSCHCmnGetRaType0Mask(rbIdx, rbgSize)
-U8 rbIdx;
-U8 rbgSize;
+PRIVATE uint32_t rgSCHCmnGetRaType0Mask(rbIdx, rbgSize)
+uint8_t rbIdx;
+uint8_t rbgSize;
#endif
{
- U8 rbg;
- U32 rbgPosInRbgMask = 0;
+ uint8_t rbg;
+ uint32_t rbgPosInRbgMask = 0;
rbg = rbIdx/rbgSize;
rbgPosInRbgMask = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbg);
* Processing Steps:
* - Determine RA Type 1 mask for given rbIdex and rbg size.
*
- * @param[in] U8 rbIdx
- * @param[in] U8 rbgSize
- * @param[out] U8 *type1Subset
- * @return U32 RA type 1 mask
+ * @param[in] uint8_t rbIdx
+ * @param[in] uint8_t rbgSize
+ * @param[out] uint8_t *type1Subset
+ * @return uint32_t RA type 1 mask
**/
#ifdef ANSI
-PRIVATE U32 rgSCHCmnGetRaType1Mask
+PRIVATE uint32_t rgSCHCmnGetRaType1Mask
(
-U8 rbIdx,
-U8 rbgSize,
-U8 *type1Subset
+uint8_t rbIdx,
+uint8_t rbgSize,
+uint8_t *type1Subset
)
#else
-PRIVATE U32 rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, type1Subset)
-U8 rbIdx;
-U8 rbgSize;
-U8 *type1Subset;
+PRIVATE uint32_t rgSCHCmnGetRaType1Mask(rbIdx, rbgSize, type1Subset)
+uint8_t rbIdx;
+uint8_t rbgSize;
+uint8_t *type1Subset;
#endif
{
- U8 rbg, rbgSubset, rbgInSubset, offset, rbInSubset;
- U32 rbPosInSubset;
+ uint8_t rbg, rbgSubset, rbgInSubset, offset, rbInSubset;
+ uint32_t rbPosInSubset;
rbg = rbIdx/rbgSize;
rbgSubset = rbg % rbgSize;
* Processing Steps:
* - Determine RA Type 2 mask for given rbIdx and rbg size.
*
- * @param[in] U8 rbIdx
- * @param[out] U8 *maskIdx
- * @return U32 RA type 2 mask
+ * @param[in] uint8_t rbIdx
+ * @param[out] uint8_t *maskIdx
+ * @return uint32_t RA type 2 mask
**/
#ifdef ANSI
-PRIVATE U32 rgSCHCmnGetRaType2Mask
+PRIVATE uint32_t rgSCHCmnGetRaType2Mask
(
-U8 rbIdx,
-U8 *maskIdx
+uint8_t rbIdx,
+uint8_t *maskIdx
)
#else
-PRIVATE U32 rgSCHCmnGetRaType2Mask(rbIdx, maskIdx)
-U8 rbIdx;
-U8 *maskIdx;
+PRIVATE uint32_t rgSCHCmnGetRaType2Mask(rbIdx, maskIdx)
+uint8_t rbIdx;
+uint8_t *maskIdx;
#endif
{
- U32 rbPosInType2;
+ uint32_t rbPosInType2;
*maskIdx = rbIdx / 32;
rbPosInType2 = 1 << RG_SCH_CMN_DL_GET_POS_FRM_LSB(rbIdx % 32);
Bool isPartialAlloc;
#endif
{
- U8 rbgSize = cell->rbgSize;
- U8 numAllocRbs = 0;
- U8 numAllocRbgs = 0;
- U8 rbStart = 0;
- U8 idx, noLyr, iTbs;
+ uint8_t rbgSize = cell->rbgSize;
+ uint8_t numAllocRbs = 0;
+ uint8_t numAllocRbgs = 0;
+ uint8_t rbStart = 0;
+ uint8_t idx, noLyr, iTbs;
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
RgSchDlSfAllocInfo *dlSfAlloc = &rbAllocInfo->dlSf->dlSfAllocInfo;
RgSchBwRbgInfo *spsRbgInfo = &cell->spsBwRbgInfo;
/* If no RBS could be allocated, attempt RA TYPE 1 */
numAllocRbs = rgSCHCmnDlRaType1Alloc(dlSfAlloc,
- rbAllocInfo->rbsReq, spsRbgInfo, (U8)dlSfAlloc->nxtRbgSubset,
+ rbAllocInfo->rbsReq, spsRbgInfo, (uint8_t)dlSfAlloc->nxtRbgSubset,
&rbAllocInfo->allocInfo.raType1.rbgSubset,
&rbAllocInfo->resAllocInfo, isPartialAlloc);
iTbs = rbAllocInfo->tbInfo[1].iTbs;
noLyr = rbAllocInfo->tbInfo[1].noLyr;
rbAllocInfo->tbInfo[1].bytesAlloc =
- rgTbSzTbl[noLyr - 1][iTbs][numAllocRbs - 1]/8;;
+ rgTbSzTbl[noLyr - 1][iTbs][numAllocRbs - 1]/8;
}
/* Update rbAllocInfo with the allocation information */
#ifdef ANSI
PRIVATE Void rgSCHCmnDlGetBestFitHole
(
-U32 *allocMask,
-U8 numMaskRbs,
-U32 *crntAllocMask,
-U8 rbsReq,
-U8 *allocStart,
-U8 *allocNumRbs,
+uint32_t *allocMask,
+uint8_t numMaskRbs,
+uint32_t *crntAllocMask,
+uint8_t rbsReq,
+uint8_t *allocStart,
+uint8_t *allocNumRbs,
Bool isPartialAlloc
)
#else
PRIVATE Void rgSCHCmnDlGetBestFitHole (allocMask, numMaskRbs,
crntAllocMask, rbsReq, allocStart, allocNumRbs, isPartialAlloc)
-U32 *allocMask;
-U8 numMaskRbs;
-U32 *crntAllocMask;
-U8 rbsReq;
-U8 *allocStart;
-U8 *allocNumRbs;
+uint32_t *allocMask;
+uint8_t numMaskRbs;
+uint32_t *crntAllocMask;
+uint8_t rbsReq;
+uint8_t *allocStart;
+uint8_t *allocNumRbs;
Bool isPartialAlloc;
#endif
{
- U8 maskSz = (numMaskRbs + 31)/32;
- U8 maxMaskPos = (numMaskRbs % 32);
- U8 maskIdx, maskPos;
- U8 numAvailRbs = 0;
- U8 bestAvailNumRbs = 0;
+ uint8_t maskSz = (numMaskRbs + 31)/32;
+ uint8_t maxMaskPos = (numMaskRbs % 32);
+ uint8_t maskIdx, maskPos;
+ uint8_t numAvailRbs = 0;
+ uint8_t bestAvailNumRbs = 0;
S8 bestStartPos = -1;
S8 startPos = -1;
- U32 tmpMask[RG_SCH_NUM_RATYPE2_32BIT_MASK] = {0};
- U32 bestMask[RG_SCH_NUM_RATYPE2_32BIT_MASK] = {0};
+ uint32_t tmpMask[RG_SCH_NUM_RATYPE2_32BIT_MASK] = {0};
+ uint32_t bestMask[RG_SCH_NUM_RATYPE2_32BIT_MASK] = {0};
*allocNumRbs = numAvailRbs;
*allocStart = 0;
++numAvailRbs;
if (numAvailRbs == rbsReq)
{
- *allocStart = (U8)startPos;
+ *allocStart = (uint8_t)startPos;
*allocNumRbs = rbsReq;
break;
}
{
bestAvailNumRbs = numAvailRbs;
bestStartPos = startPos;
- memcpy(bestMask, tmpMask, 4 * sizeof(U32));
+ memcpy(bestMask, tmpMask, 4 * sizeof(uint32_t));
}
numAvailRbs = 0;
startPos = -1;
- memset(tmpMask, 0, 4 * sizeof(U32));
+ memset(tmpMask, 0, 4 * sizeof(uint32_t));
}
}
if (*allocNumRbs == rbsReq)
if (*allocNumRbs == rbsReq)
{
/* Convert the hole into allocation */
- memcpy(crntAllocMask, tmpMask, 4 * sizeof(U32));
- RETVOID;
+ memcpy(crntAllocMask, tmpMask, 4 * sizeof(uint32_t));
+ return;
}
else
{
if (bestAvailNumRbs && isPartialAlloc)
{
/* Partial allocation could have been done */
- *allocStart = (U8)bestStartPos;
+ *allocStart = (uint8_t)bestStartPos;
*allocNumRbs = bestAvailNumRbs;
/* Convert the hole into allocation */
- memcpy(crntAllocMask, bestMask, 4 * sizeof(U32));
+ memcpy(crntAllocMask, bestMask, 4 * sizeof(uint32_t));
}
}
- RETVOID;
+ return;
}
#endif /* LTEMAC_SPS */
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchDlRbAlloc *allocInfo,
-U8 idx
+uint8_t idx
)
#else
PRIVATE Void rgSCHCmnFindCodeRate(cell,dlSf,allocInfo,idx)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
RgSchDlRbAlloc *allocInfo;
-U8 idx;
+uint8_t idx;
#endif
{
- RETVOID;
+ return;
}
#endif
* - Adjust Imcs according to tbSize and ITBS.
*
* @param[in,out] RgSchDlRbAlloc *allocInfo
- * @param[in] U8 *idx
+ * @param[in] uint8_t *idx
* @return void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchDlRbAlloc *allocInfo,
-U8 idx,
-U8 rbsReq
+uint8_t idx,
+uint8_t rbsReq
)
#else
PRIVATE Void rgSCHCmnNonDlfsPbchTbImcsAdj(cell,allocInfo, idx, rbsReq)
RgSchCellCb *cell;
RgSchDlRbAlloc *allocInfo;
-U8 idx;
-U8 rbsReq;
+uint8_t idx;
+uint8_t rbsReq;
#endif
{
- U8 noLyrs = 0;
- U8 tbs = 0;
- U32 origBytesReq;
- U8 noRbgs = 0;
- U8 noRbs = 0;
+ uint8_t noLyrs = 0;
+ uint8_t tbs = 0;
+ uint32_t origBytesReq;
+ uint8_t noRbgs = 0;
+ uint8_t noRbs = 0;
RgSchDlSf *dlSf = allocInfo->dlSf;
RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[idx].imcs, tbs);
/* This line will help in case if tbs is zero and reduction in MCS is not possible */
if (allocInfo->rbsReq == 0 )
{
- RETVOID;
+ return;
}
origBytesReq = rgTbSzTbl[noLyrs - 1][tbs][rbsReq - 1]/8;
RG_SCH_CMN_DL_TBS_TO_MCS(tbs,allocInfo->tbInfo[idx].imcs);
}
- RETVOID;
+ return;
}
/* Added funcion to adjust TBSize*/
/**
* Processing Steps:
*
* @param[in,out] RgSchDlRbAlloc *allocInfo
- * @param[in] U8 numOvrlapgPbchRb
- * @param[in] U8 idx
- * @param[in] U8 pbchSsRsSym
+ * @param[in] uint8_t numOvrlapgPbchRb
+ * @param[in] uint8_t idx
+ * @param[in] uint8_t pbchSsRsSym
* @return void
**/
#ifdef ANSI
PRIVATE Void rgSCHCmnNonDlfsPbchTbSizeAdj
(
RgSchDlRbAlloc *allocInfo,
-U8 numOvrlapgPbchRb,
-U8 pbchSsRsSym,
-U8 idx,
-U32 bytesReq
+uint8_t numOvrlapgPbchRb,
+uint8_t pbchSsRsSym,
+uint8_t idx,
+uint32_t bytesReq
)
#else
PRIVATE Void rgSCHCmnNonDlfsPbchTbSizeAdj(allocInfo,numOvrlapgPbchRb,pbchSsRsSym,idx,bytesReq)
RgSchDlRbAlloc *allocInfo;
-U8 numOvrlapgPbchRb;
-U8 pbchSsRsSym;
-U8 idx;
-U32 bytesReq;
+uint8_t numOvrlapgPbchRb;
+uint8_t pbchSsRsSym;
+uint8_t idx;
+uint32_t bytesReq;
#endif
{
- U32 reducedTbs = 0;
- U8 noLyrs = 0;
- U8 tbs = 0;
+ uint32_t reducedTbs = 0;
+ uint8_t noLyrs = 0;
+ uint8_t tbs = 0;
noLyrs = allocInfo->tbInfo[idx].noLyr;
RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[idx].imcs, tbs);
- reducedTbs = bytesReq - (((U32)numOvrlapgPbchRb * (U32)pbchSsRsSym * 6)/8);
+ reducedTbs = bytesReq - (((uint32_t)numOvrlapgPbchRb * (uint32_t)pbchSsRsSym * 6)/8);
/* find out the ITbs & Imcs by identifying first Highest
number of bits compared with reduced bits considering the bits that are
allocInfo->tbInfo[idx].iTbs = tbs;
RG_SCH_CMN_DL_TBS_TO_MCS(tbs,allocInfo->tbInfo[idx].imcs);
- RETVOID;
+ return;
}
/* Added this function to find num of ovrlapping PBCH rb*/
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *dlSf
* @param[in,out] RgSchDlRbAlloc *allocInfo
- * @param[out] U8 addtlRbsAvl
+ * @param[out] uint8_t addtlRbsAvl
* @return void
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnFindNumAddtlRbsAvl
+PRIVATE uint8_t rgSCHCmnFindNumAddtlRbsAvl
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchDlRbAlloc *allocInfo
)
#else
-PRIVATE U8 rgSCHCmnFindNumAddtlRbsAvl(cell,dlSf,allocInfo)
+PRIVATE uint8_t rgSCHCmnFindNumAddtlRbsAvl(cell,dlSf,allocInfo)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
RgSchDlRbAlloc *allocInfo;
#endif
{
- U8 addtlRbsAvl = 0;
+ uint8_t addtlRbsAvl = 0;
if (allocInfo->raType == RG_SCH_CMN_RA_TYPE0)
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *dlSf
* @param[in,out] RgSchDlRbAlloc *allocInfo
- * @param[out] U8* numOvrlapgPbchRb
+ * @param[out] uint8_t* numOvrlapgPbchRb
* @return void
**/
#ifdef ANSI
RgSchCellCb *cell,
RgSchDlSf *dlSf,
RgSchDlRbAlloc *allocInfo,
-U8 *numOvrlapgPbchRb
+uint8_t *numOvrlapgPbchRb
)
#else
PRIVATE Void rgSCHCmnFindNumPbchOvrlapRbs(cell,dlSf,allocInfo,numOvrlapgPbchRb)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
RgSchDlRbAlloc *allocInfo;
-U8 *numOvrlapgPbchRb;
+uint8_t *numOvrlapgPbchRb;
#endif
{
*numOvrlapgPbchRb = 0;
*numOvrlapgPbchRb = (cell->pbchRbEnd) - dlSf->bwAlloced;
}
}
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in,out] RgSchDlRbAlloc *allocInfo
- * @param[in] U8 pbchSsRsSym
+ * @param[in] uint8_t pbchSsRsSym
* @return void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchDlRbAlloc *allocInfo,
-U8 pbchSsRsSym,
+uint8_t pbchSsRsSym,
Bool isBcchPcch
)
#else
PRIVATE Void rgSCHCmnNonDlfsPbchRbAllocAdj(cell, allocInfo,pbchSsRsSym)
RgSchCellCb *cell;
RgSchDlRbAlloc *allocInfo;
-U8 pbchSsRsSym;
+uint8_t pbchSsRsSym;
Bool isBcchPcch;
#endif
{
RgSchDlSf *dlSf = allocInfo->dlSf;
- U8 numOvrlapgPbchRb = 0;
- U8 numOvrlapgAdtlPbchRb = 0;
- U8 totSym;
- U8 addtlRbsReq = 0;
- U8 moreAddtlRbsReq = 0;
- U8 addtlRbsAdd = 0;
- U8 moreAddtlRbsAdd = 0;
- U8 tbs;
- U8 origRbsReq = 0;
- U32 bytesReq;
- U8 noLyr;
- U8 divResult;
+ uint8_t numOvrlapgPbchRb = 0;
+ uint8_t numOvrlapgAdtlPbchRb = 0;
+ uint8_t totSym;
+ uint8_t addtlRbsReq = 0;
+ uint8_t moreAddtlRbsReq = 0;
+ uint8_t addtlRbsAdd = 0;
+ uint8_t moreAddtlRbsAdd = 0;
+ uint8_t tbs;
+ uint8_t origRbsReq = 0;
+ uint32_t bytesReq;
+ uint8_t noLyr;
+ uint8_t divResult;
}
if (isBcchPcch == TRUE)
{
- RETVOID;
+ return;
}
RG_SCH_CMN_DL_MCS_TO_TBS(allocInfo->tbInfo[0].imcs, tbs);
}
}
- RETVOID;
+ return;
} /* end of rgSCHCmnNonDlfsPbchRbAllocAdj */
#endif
#endif
#ifndef LTE_TDD
#ifdef LTEMAC_SPS
#endif
- U8 pbchSsRsSym = 0;
- U8 pbchFrame = 0;
- U8 tbs = 0;
+ uint8_t pbchSsRsSym = 0;
+ uint8_t pbchFrame = 0;
+ uint8_t tbs = 0;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
#endif
RgSchDlSf *dlSf = allocInfo->dlSf;
#ifdef LTEMAC_SPS
- U8 rbStart = 0;
- U8 spsRbsAlloc = 0;
+ uint8_t rbStart = 0;
+ uint8_t spsRbsAlloc = 0;
RgSchDlSfAllocInfo *dlSfAlloc = &allocInfo->dlSf->dlSfAllocInfo;
#endif
* is initialized to 0 at the beginning of allcoation */
allocInfo->resAllocInfo.raType0Mask = 0;
memset(allocInfo->resAllocInfo.raType1Mask, 0,
- RG_SCH_NUM_RATYPE1_32BIT_MASK * sizeof (U32));
+ RG_SCH_NUM_RATYPE1_32BIT_MASK * sizeof (uint32_t));
memset(allocInfo->resAllocInfo.raType2Mask, 0,
- RG_SCH_NUM_RATYPE2_32BIT_MASK * sizeof (U32));
+ RG_SCH_NUM_RATYPE2_32BIT_MASK * sizeof (uint32_t));
if ((dlSf->spsAllocdBw >= cell->spsBwRbgInfo.numRbs) &&
(dlSf->bwAlloced == dlSf->bw))
allocInfo->allocInfo.raType2.rbStart = rbStart;
#else
/*Fix for ccpu00123918*/
- allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
+ allocInfo->allocInfo.raType2.rbStart = (uint8_t)dlSf->type2Start;
#endif
}
else
{
#endif
/*Fix for ccpu00123918*/
- allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
+ allocInfo->allocInfo.raType2.rbStart = (uint8_t)dlSf->type2Start;
allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
allocInfo->rbsAlloc = allocInfo->rbsReq;
#ifdef LTEMAC_SPS
if (spsRbsAlloc)
{
- U8 idx;
+ uint8_t idx;
/* Update type 0, 1 and 2 masks */
dlSfAlloc->raType0Mask |= allocInfo->resAllocInfo.raType0Mask;
#ifdef RGSCH_SPS_UNUSED
allocInfo->allocInfo.raType2.isLocal = TRUE;
/*Fix for ccpu00123918*/
- allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
+ allocInfo->allocInfo.raType2.rbStart = (uint8_t)dlSf->type2Start;
allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
allocInfo->rbsAlloc = allocInfo->rbsReq;
RgSchSFRPoolInfo *sfrPool;
RgSchSFRPoolInfo *sfrCEPool;
- U8 tbs;
- U8 noLyrs;
+ uint8_t tbs;
+ uint8_t noLyrs;
RgSchSFRPoolInfo *poolWithMaxAvlblBw = NULLP;
- U32 bwAvlbl = 0;
- U32 addtnlPRBs = 0;
+ uint32_t bwAvlbl = 0;
+ uint32_t addtnlPRBs = 0;
if (dlSf->bw <= dlSf->bwAlloced)
{
RgSchDlRbAlloc *allocInfo;
#endif
{
- U8 tbs;
- U8 noLyrs;
- U8 ignoredDfctRbg = FALSE;
+ uint8_t tbs;
+ uint8_t noLyrs;
+ uint8_t ignoredDfctRbg = FALSE;
if (dlSf->bw <= dlSf->bwAlloced)
{
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *dlSf
- * @param[in] U8 rbStrt
- * @param[in] U8 numRb
+ * @param[in] uint8_t rbStrt
+ * @param[in] uint8_t numRb
*
* @return Void
**/
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
-U8 rbStrt,
-U8 numRb
+uint8_t rbStrt,
+uint8_t numRb
)
#else
Void rgSCHCmnNonDlfsSFRCmnChannelUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
-U8 rbStrt;
-U8 numRb;
+uint8_t rbStrt;
+uint8_t numRb;
#endif
{
CmLListCp *l;
n = cmLListFirst(l);
}
else
- RETVOID;
+ return;
}
}
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *dlSf
- * @param[in] U8 rbStrt
- * @param[in] U8 numRb
+ * @param[in] uint8_t rbStrt
+ * @param[in] uint8_t numRb
*
* @return Void
**/
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlSf *dlSf,
-U8 rbStrt,
-U8 numRb
+uint8_t rbStrt,
+uint8_t numRb
)
#else
PRIVATE S16 rgSCHCmnNonDlfsUpdDSFRTyp2Alloc(cell, ue, dlSf, rbStrt, numRb)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlSf *dlSf;
-U8 rbStrt;
-U8 numRb;
+uint8_t rbStrt;
+uint8_t numRb;
#endif
{
CmLListCp *l;
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *dlSf
- * @param[in] U8 rbStrt
- * @param[in] U8 numRb
+ * @param[in] uint8_t rbStrt
+ * @param[in] uint8_t numRb
*
* @return Void
**/
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
-U8 rbStrt,
-U8 numRb
+uint8_t rbStrt,
+uint8_t numRb
)
#else
PRIVATE Void rgSCHCmnNonDlfsUpdTyp2Alloc(cell, dlSf, rbStrt, numRb)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
-U8 rbStrt;
-U8 numRb;
+uint8_t rbStrt;
+uint8_t numRb;
#endif
{
/* Move the type2End pivot forward */
/*Fix for ccpu00123918*/
dlSf->type2Start += numRb;
//#endif
- RETVOID;
+ return;
}
/**
RgSchUeCb *ue;
#endif
{
- U32 dlAllocMsk = 0;
- U8 rbgFiller = dlSf->lstRbgDfct;
- U8 noRbgs = RGSCH_CEIL((allocInfo->rbsReq + rbgFiller), cell->rbgSize);
- //U8 noRbgs = (allocInfo->rbsReq + rbgFiller)/ cell->rbgSize;
- U8 noRbs;
- U8 noLyr;
- U8 iTbs;
- U32 tb1BytesAlloc = 0;
- U32 tb2BytesAlloc = 0;
+ uint32_t dlAllocMsk = 0;
+ uint8_t rbgFiller = dlSf->lstRbgDfct;
+ uint8_t noRbgs = RGSCH_CEIL((allocInfo->rbsReq + rbgFiller), cell->rbgSize);
+ //uint8_t noRbgs = (allocInfo->rbsReq + rbgFiller)/ cell->rbgSize;
+ uint8_t noRbs;
+ uint8_t noLyr;
+ uint8_t iTbs;
+ uint32_t tb1BytesAlloc = 0;
+ uint32_t tb2BytesAlloc = 0;
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ue,cell);
//if(noRbgs == 0) noRbgs = 1; /* Not required as ceilling is used above*/
{
if (--noRbgs == 0)
{
- RETVOID;
+ return;
}
noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
}
{
if (--noRbgs == 0)
{
- RETVOID;
+ return;
}
noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
}
else
{
allocInfo->tbInfo[1].bytesAlloc =
- rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;;
+ rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
/* DwPts Scheduling Changes Start */
#ifdef LTE_TDD
if (dlSf->sfType == RG_SCH_SPL_SF_DATA)
/* The last RBG which can be smaller than the RBG size is consedered
* only for the first time allocation of TYPE0 UE */
dlSf->lstRbgDfct = 0;
- RETVOID;
+ return;
}
#endif
#ifndef LTE_TDD
*
* Processing Steps:
*
- * @param[in] U8 *rntpPtr
- * @param[in] U8 startRb
- * @param[in] U8 numRb
+ * @param[in] uint8_t *rntpPtr
+ * @param[in] uint8_t startRb
+ * @param[in] uint8_t numRb
*
* @return Void
**/
PRIVATE S16 rgSCHCmnBuildRntpInfo
(
RgSchCellCb *cell,
-U8 *rntpPtr,
-U8 startRb,
-U8 nmbRb,
-U16 bw
+uint8_t *rntpPtr,
+uint8_t startRb,
+uint8_t nmbRb,
+uint16_t bw
)
#else
PRIVATE S16 rgSCHCmnBuildRntpInfo(cell, rntpPtr, startRb, nmbRb, bw)
RgSchCellCb *cell;
-U8 *rntpPtr;
-U8 startRb;
-U8 nmbRb;
-U16 bw;
+uint8_t *rntpPtr;
+uint8_t startRb;
+uint8_t nmbRb;
+uint16_t bw;
#endif
{
- U16 rbPtrStartIdx; /* Start Index of Octete Buffer to be filled */
- U16 rbPtrEndIdx; /* End Index of Octete Buffer to be filled */
- U16 rbBitLoc; /* Bit Location to be set as 1 in the current Byte */
- U16 nmbRbPerByte; /* PRB's to be set in the current Byte (in case of multiple Bytes) */
+ uint16_t rbPtrStartIdx; /* Start Index of Octete Buffer to be filled */
+ uint16_t rbPtrEndIdx; /* End Index of Octete Buffer to be filled */
+ uint16_t rbBitLoc; /* Bit Location to be set as 1 in the current Byte */
+ uint16_t nmbRbPerByte; /* PRB's to be set in the current Byte (in case of multiple Bytes) */
rbPtrStartIdx = (startRb)/8;
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *dlSf
- * @param[in] U8 rbStrt
- * @param[in] U8 numRb
+ * @param[in] uint8_t rbStrt
+ * @param[in] uint8_t numRb
*
* @return Void
**/
RgSchUeCb *ue,
RgSchDlSf *dlSf,
RgSchSFRPoolInfo *sfrPool,
-U8 rbStrt,
-U8 numRb
+uint8_t rbStrt,
+uint8_t numRb
)
#else
PRIVATE S16 rgSCHCmnNonDlfsUpdSFRPoolTyp2Alloc(cell, ue, dlSf, sfrPool, rbStrt, numRb)
RgSchUeCb *ue;
RgSchDlSf *dlSf;
RgSchSFRPoolInfo *sfrPool;
-U8 rbStrt;
-U8 numRb;
+uint8_t rbStrt;
+uint8_t numRb;
#endif
{
#ifndef LTEMAC_SPS
RgSchDlRbAlloc *allocInfo;
#endif
{
- U32 dlAllocMsk = 0;
- U8 rbgFiller = 0;
- U8 noRbgs = 0;
- U8 noRbs;
- U8 noLyr;
- U8 iTbs;
+ uint32_t dlAllocMsk = 0;
+ uint8_t rbgFiller = 0;
+ uint8_t noRbgs = 0;
+ uint8_t noRbs;
+ uint8_t noLyr;
+ uint8_t iTbs;
if (poolInfo->poolstartRB + poolInfo->bw == dlSf->bw)
{
if (--noRbgs == 0)
{
- RETVOID;
+ return;
}
noRbs = (noRbgs * cell->rbgSize) - rbgFiller;
}
else
{
allocInfo->tbInfo[1].bytesAlloc =
- rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;;
+ rgTbSzTbl[noLyr - 1][iTbs][noRbs - 1]/8;
}
}
/* The last RBG which can be smaller than the RBG size is consedered
* only for the first time allocation of TYPE0 UE */
dlSf->lstRbgDfct = 0;
- RETVOID;
+ return;
}
#endif
/**
RgSchDlSf *dlSf;
#endif
{
- PRIVATE U16 samples = 0;
- U16 i;
- U16 bwBytes = (dlSf->bw-1)/8;
+ PRIVATE uint16_t samples = 0;
+ uint16_t i;
+ uint16_t bwBytes = (dlSf->bw-1)/8;
RgrLoadInfIndInfo *rgrLoadInf;
- U16 len;
- U16 ret = ROK;
+ uint16_t len;
+ uint16_t ret = ROK;
len = (dlSf->bw % 8 == 0) ? dlSf->bw/8 : dlSf->bw/8 + 1;
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Could not "
"allocate memory for sending LoadInfo");
- RETVOID;
+ return;
}
rgrLoadInf->u.rntpInfo.pres = cell->rntpAggrInfo.pres;
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlSf *dlSf
- * @param[out] U8 *isDlBwAvail
+ * @param[out] uint8_t *isDlBwAvail
*
* @return S16
* -# ROK
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlSf *dlSf,
-U8 *isDlBwAvail
+uint8_t *isDlBwAvail
)
#else
PRIVATE S16 rgSCHCmnSFRNonDlfsUeRbAlloc(cell, ue, dlSf, isDlBwAvail)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlSf *dlSf;
-U8 *isDlBwAvail;
+uint8_t *isDlBwAvail;
#endif
{
RgSchDlRbAlloc *allocInfo;
allocInfo->allocInfo.raType2.isLocal = TRUE;
/* rg004.201 patch - ccpu00109921 fix end */
/* MS_FIX for ccpu00123918*/
- allocInfo->allocInfo.raType2.rbStart = (U8)sfrpoolInfo->type2Start;
+ allocInfo->allocInfo.raType2.rbStart = (uint8_t)sfrpoolInfo->type2Start;
allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
/* rg007.201 - Changes for MIMO feature addition */
/* rg008.201 - Removed dependency on MIMO compile-time flag */
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlSf *dlSf
- * @param[out] U8 *isDlBwAvail
+ * @param[out] uint8_t *isDlBwAvail
*
* @return S16
* -# ROK
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlSf *dlSf,
-U8 *isDlBwAvail
+uint8_t *isDlBwAvail
)
#else
PRIVATE S16 rgSCHCmnNonDlfsUeRbAlloc(cell, ue, dlSf, isDlBwAvail)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlSf *dlSf;
-U8 *isDlBwAvail;
+uint8_t *isDlBwAvail;
#endif
{
RgSchDlRbAlloc *allocInfo;
RgSchCmnDlUe *dlUe;
#ifdef LAA_DBG
- U32 dbgRbsReq = 0;
+ uint32_t dbgRbsReq = 0;
#endif
#ifdef RG_5GTF
*
* @param[in] RgSchCellCb *cell
* @param[in, out] RgSchCmnCcchSduRbAlloc *allocInfo
- * @param[in] U8 isRetx
+ * @param[in] uint8_t isRetx
*
* @return Void
**/
(
RgSchCellCb *cell,
RgSchCmnCcchSduRbAlloc *allocInfo,
-U8 isRetx
+uint8_t isRetx
)
#else
PRIVATE Void rgSCHCmnNonDlfsCcchSduAlloc(cell, allocInfo, isRetx)
RgSchCellCb *cell;
RgSchCmnCcchSduRbAlloc *allocInfo;
-U8 isRetx;
+uint8_t isRetx;
#endif
{
S16 ret;
cmLListAdd2Tail(nonSchdCcchSduLst, schdLnkNode);
toBeSchdLnk = toBeSchdLnk->next;
} while(toBeSchdLnk);
- RETVOID;
+ return;
}
/* Allocation successful: Add UE to the scheduled list */
}
- RETVOID;
+ return;
}
/**
/*Fix for ccpu00123918*/
/* Push this harq process back to the free queue */
- allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
+ allocInfo->allocInfo.raType2.rbStart = (uint8_t)dlSf->type2Start;
allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
allocInfo->rbsAlloc = allocInfo->rbsReq;
allocInfo->tbInfo[0].bytesAlloc = allocInfo->tbInfo[0].bytesReq;
/*Fix for ccpu00123918*/
- allocInfo->allocInfo.raType2.rbStart = (U8)dlSf->type2Start;
+ allocInfo->allocInfo.raType2.rbStart = (uint8_t)dlSf->type2Start;
allocInfo->allocInfo.raType2.numRb = allocInfo->rbsReq;
/* LTE_ADV_FLAG_REMOVED_START */
#ifndef LTE_TDD
*
* @param[in] RgSchCellCb *cell
* @param[in, out] RgSchCmnMsg4RbAlloc *allocInfo
- * @param[in] U8 isRetx
+ * @param[in] uint8_t isRetx
*
* @return Void
**/
(
RgSchCellCb *cell,
RgSchCmnMsg4RbAlloc *allocInfo,
-U8 isRetx
+uint8_t isRetx
)
#else
PRIVATE Void rgSCHCmnNonDlfsMsg4Alloc(cell, allocInfo, isRetx)
RgSchCellCb *cell;
RgSchCmnMsg4RbAlloc *allocInfo;
-U8 isRetx;
+uint8_t isRetx;
#endif
{
S16 ret;
cmLListAdd2Tail(nonSchdMsg4Lst, schdLnkNode);
toBeSchdLnk = toBeSchdLnk->next;
} while(toBeSchdLnk);
- RETVOID;
+ return;
}
/* Allocation successful: Add UE to the scheduled list */
}
- RETVOID;
+ return;
}
/**
RgSchDlSf *dlSf = allocInfo->dedDlSf;
RgSchUeCb *ue = NULLP;
RgSchDlHqProcCb *hqP = NULLP;
- U8 isDlBwAvail;
+ uint8_t isDlBwAvail;
/* Perform allocaations for the list */
}
}
- RETVOID;
+ return;
}
/**
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
- U8 raRspCnt = 0;
+ uint8_t raRspCnt = 0;
RgSchDlRbAlloc *reqAllocInfo;
/* Allocate for MSG4 retransmissions */
}
/* LTE_ADV_FLAG_REMOVED_END */
#endif /* LTE_TDD */
- RETVOID;
+ return;
}
/***********************************************************
**********************************************************/
#ifdef LTEMAC_SPS
#ifdef ANSI
-U32 rgSCHCmnCalcRiv
+uint32_t rgSCHCmnCalcRiv
(
-U8 bw,
-U8 rbStart,
-U8 numRb
+uint8_t bw,
+uint8_t rbStart,
+uint8_t numRb
)
#else
-U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
-U8 bw;
-U8 rbStart;
-U8 numRb;
+uint32_t rgSCHCmnCalcRiv(bw, rbStart, numRb)
+uint8_t bw;
+uint8_t rbStart;
+uint8_t numRb;
#endif
#else
#ifdef ANSI
-U32 rgSCHCmnCalcRiv
+uint32_t rgSCHCmnCalcRiv
(
-U8 bw,
-U8 rbStart,
-U8 numRb
+uint8_t bw,
+uint8_t rbStart,
+uint8_t numRb
)
#else
-U32 rgSCHCmnCalcRiv(bw, rbStart, numRb)
-U8 bw;
-U8 rbStart;
-U8 numRb;
+uint32_t rgSCHCmnCalcRiv(bw, rbStart, numRb)
+uint8_t bw;
+uint8_t rbStart;
+uint8_t numRb;
#endif
#endif
{
- U8 numRbMinus1 = numRb - 1;
- U32 riv;
+ uint8_t numRbMinus1 = numRb - 1;
+ uint32_t riv;
if (numRbMinus1 <= bw/2)
*
* @param[in] RgSchCellCb* cell
* @param[in] RgSchTddRachRspLst rachRspLst[][RGSCH_NUM_SUB_FRAMES]
- * @param[in] U8 raArrSz
+ * @param[in] uint8_t raArrSz
* @return S16
*
**/
(
RgSchCellCb *cell,
RgSchTddRachRspLst rachRspLst[][RGSCH_NUM_SUB_FRAMES],
-U8 raArrSz
+uint8_t raArrSz
)
#else
PRIVATE S16 rgSCHCmnDlCpyRachInfo(cell, rachRspLst, raArrSz)
RgSchCellCb *cell;
RgSchTddRachRspLst rachRspLst[][RGSCH_NUM_SUB_FRAMES];
-U8 raArrSz;
+uint8_t raArrSz;
#endif
{
- U8 ulDlCfgIdx = cell->ulDlCfgIdx;
- U8 sfNum;
+ uint8_t ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t sfNum;
S16 sfnIdx;
- U16 subfrmIdx;
- U8 numRfs;
- U8 numSubfrms;
- U8 sfcount;
+ uint16_t subfrmIdx;
+ uint8_t numRfs;
+ uint8_t numSubfrms;
+ uint8_t sfcount;
S16 ret;
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchCmnDlUe *ueDl
- * @param[in] U8 cqi
+ * @param[in] uint8_t cqi
*
* @return S32 iTbs
*
RgSchCellCb *cell,
RgSchCmnDlUe *ueDl,
RgSchDlSf *subFrm,
-U8 cqi,
-U8 cfi,
-U8 cwIdx,
-U8 noLyr
+uint8_t cqi,
+uint8_t cfi,
+uint8_t cwIdx,
+uint8_t noLyr
)
#else
PRIVATE S32 rgSchCmnFetchItbs (cell, ueDl, subFrm, cqi, cfi, cwIdx, noLyr)
RgSchCellCb *cell;
RgSchCmnDlUe *ueDl;
RgSchDlSf *subFrm;
-U8 cqi;
-U8 cfi;
-U8 cwIdx;
-U8 noLyr;
+uint8_t cqi;
+uint8_t cfi;
+uint8_t cwIdx;
+uint8_t noLyr;
#endif
#else
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchCmnDlUe *ueDl,
-U8 cqi,
-U8 cfi,
-U8 cwIdx,
-U8 noLyr
+uint8_t cqi,
+uint8_t cfi,
+uint8_t cwIdx,
+uint8_t noLyr
)
#else
PRIVATE S32 rgSchCmnFetchItbs (cell, ueDl, cqi, cfi, cwIdx, noLyr)
RgSchCellCb *cell;
RgSchCmnDlUe *ueDl;
-U8 cqi;
-U8 cfi;
-U8 cwIdx;
-U8 noLyr;
+uint8_t cqi;
+uint8_t cfi;
+uint8_t cwIdx;
+uint8_t noLyr;
#endif
#endif
{
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
RgSchDlRbAlloc *allocInfo;
S16 ret;
- U8 numRb;
+ uint8_t numRb;
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
if (ret == RFAILED)
{
/* If allocation couldn't be made then return */
- RETVOID;
+ return;
}
/* Adding UE to RbAllocInfo TX Lst */
rgSCHCmnDlRbInfoAddUeTx(cell, cellWdAllocInfo, ue, proc);
allocInfo->vrbgReq = numRb/MAX_5GTF_VRBG_SIZE;
#endif
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
RgSchDlRbAlloc *allocInfo;
S16 ret;
- U8 numRb;
+ uint8_t numRb;
ret = ROK;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
* to the nonSchdTxRetxUeLst and let spfc scheduler take care of it during
* finalization. */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
/* Fill UE alloc Info */
allocInfo->vrbgReq = numRb/MAX_5GTF_VRBG_SIZE;
#endif
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
rgSCHCmnDlTM3TxTx(cell, subFrm, ue, bo, effBo,\
proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
proc, cellWdAllocInfo);
}
- RETVOID;
+ return;
}
\f
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[out] U8 *raType
+ * @param[out] uint8_t *raType
* @return TfuDciFormat
*
**/
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 *raType
+uint8_t *raType
)
#else
TfuDciFormat rgSCHCmnSlctPdcchFrmt(cell, ue, raType)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 *raType;
+uint8_t *raType;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
S16 ret;
RgSchDlRbAlloc *allocInfo;
- U8 numRb;
+ uint8_t numRb;
Bool swpFlg;
- U8 precInfo;
- U8 noTxLyrs;
- U8 precInfoAntIdx;
+ uint8_t precInfo;
+ uint8_t noTxLyrs;
+ uint8_t precInfoAntIdx;
ret = ROK;
{
/* Allocation couldn't be made for Retx */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
/* Fix for ccpu00123927: Retransmit 2 codewords irrespective of current rank */
noTxLyrs = proc->tbInfo[0].numLyrs + proc->tbInfo[1].numLyrs;
RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
precInfo, noTxLyrs, subFrm);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
S16 ret;
RgSchDlRbAlloc *allocInfo;
- U8 numRb;
+ uint8_t numRb;
Bool swpFlg = FALSE;
- U8 precInfo;
+ uint8_t precInfo;
#ifdef FOUR_TX_ANTENNA
- U8 precInfoAntIdx;
+ uint8_t precInfoAntIdx;
#endif
- U8 noTxLyrs;
+ uint8_t noTxLyrs;
ret = ROK;
{
/* Allocation couldn't be made for Retx */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
noTxLyrs = proc->tbInfo[0].numLyrs + proc->tbInfo[1].numLyrs;
precInfo = 0;
RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
precInfo, noTxLyrs, subFrm);
- RETVOID;
+ return;
}
*frthrScp = allocInfo->mimoAllocInfo.hasNewTxData;
}
}
- RETVOID;
+ return;
}
\f
* Invoked by: rgSCHCmnDlGetAttrForTM3
*
* @param[in] RgSchUeCb *ue
- * @param[in] U8 numTxLyrs
+ * @param[in] uint8_t numTxLyrs
* @param[in] Bool bothCwEnbld
- * @return U8
+ * @return uint8_t
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnDlTM3PrecInf2
+PRIVATE uint8_t rgSCHCmnDlTM3PrecInf2
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
)
#else
-PRIVATE U8 rgSCHCmnDlTM3PrecInf2(ue, numTxLyrs, bothCwEnbld)
+PRIVATE uint8_t rgSCHCmnDlTM3PrecInf2(ue, numTxLyrs, bothCwEnbld)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 numTxLyrs;
+uint8_t numTxLyrs;
Bool bothCwEnbld;
#endif
{
* Invoked by: rgSCHCmnDlGetAttrForTM4
*
* @param[in] RgSchUeCb *ue
- * @param[in] U8 numTxLyrs
+ * @param[in] uint8_t numTxLyrs
* @param[in] Bool bothCwEnbld
- * @return U8
+ * @return uint8_t
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnDlTM4PrecInf2
+PRIVATE uint8_t rgSCHCmnDlTM4PrecInf2
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
)
#else
-PRIVATE U8 rgSCHCmnDlTM4PrecInf2(ue, numTxLyrs, bothCwEnbld)
+PRIVATE uint8_t rgSCHCmnDlTM4PrecInf2(ue, numTxLyrs, bothCwEnbld)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 numTxLyrs;
+uint8_t numTxLyrs;
Bool bothCwEnbld;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- U8 precIdx;
+ uint8_t precIdx;
if (ueDl->mimoInfo.ri == numTxLyrs)
* Invoked by: rgSCHCmnDlGetAttrForTM3
*
* @param[in] RgSchUeCb *ue
- * @param[in] U8 numTxLyrs
+ * @param[in] uint8_t numTxLyrs
* @param[in] Bool bothCwEnbld
- * @return U8
+ * @return uint8_t
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnDlTM3PrecInf4
+PRIVATE uint8_t rgSCHCmnDlTM3PrecInf4
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
)
#else
-PRIVATE U8 rgSCHCmnDlTM3PrecInf4(ue, numTxLyrs, bothCwEnbld)
+PRIVATE uint8_t rgSCHCmnDlTM3PrecInf4(ue, numTxLyrs, bothCwEnbld)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 numTxLyrs;
+uint8_t numTxLyrs;
Bool bothCwEnbld;
#endif
{
- U8 precIdx;
+ uint8_t precIdx;
if (bothCwEnbld)
* Invoked by: rgSCHCmnDlGetAttrForTM4
*
* @param[in] RgSchUeCb *ue
- * @param[in] U8 numTxLyrs
+ * @param[in] uint8_t numTxLyrs
* @param[in] Bool bothCwEnbld
- * @return U8
+ * @return uint8_t
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHCmnDlTM4PrecInf4
+PRIVATE uint8_t rgSCHCmnDlTM4PrecInf4
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numTxLyrs,
+uint8_t numTxLyrs,
Bool bothCwEnbld
)
#else
-PRIVATE U8 rgSCHCmnDlTM4PrecInf4(cell, ue, numTxLyrs, bothCwEnbld)
+PRIVATE uint8_t rgSCHCmnDlTM4PrecInf4(cell, ue, numTxLyrs, bothCwEnbld)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 numTxLyrs;
+uint8_t numTxLyrs;
Bool bothCwEnbld;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- U8 precInfoBaseIdx, precIdx;
+ uint8_t precInfoBaseIdx, precIdx;
precInfoBaseIdx = (ue->mimoInfo.puschFdbkVld)? (16):
*
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlHqProcCb *proc
- * @param[out] U8 *numTxLyrs
+ * @param[out] uint8_t *numTxLyrs
* @param[out] Bool *isTraDiv
- * @param[out] U8 *prcdngInf
- * @param[out] U8 *raType
+ * @param[out] uint8_t *prcdngInf
+ * @param[out] uint8_t *raType
* @return Void
*
**/
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc,
-U8 *numTxLyrs,
+uint8_t *numTxLyrs,
TfuDciFormat *dciFrmt,
-U8 *prcdngInf,
+uint8_t *prcdngInf,
RgSchDlHqTbCb **retxTb,
RgSchDlHqTbCb **txTb,
Bool *frthrScp,
Bool *swpFlg,
-U8 *raType
+uint8_t *raType
)
#else
PRIVATE Void rgSCHCmnDlGetAttrForTM3(cell, ue, proc, numTxLyrs, dciFrmt,\
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqProcCb *proc;
-U8 *numTxLyrs;
+uint8_t *numTxLyrs;
TfuDciFormat *dciFrmt;
-U8 *prcdngInf;
+uint8_t *prcdngInf;
RgSchDlHqTbCb **retxTb;
RgSchDlHqTbCb **txTb;
Bool *frthrScp;
Bool *swpFlg;
-U8 *raType;
+uint8_t *raType;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- U8 precInfoAntIdx;
+ uint8_t precInfoAntIdx;
/* Avoiding Tx-Retx for LAA cell as firstSchedTime is associated with
*numTxLyrs = 1;
*frthrScp = FALSE;
*prcdngInf = 0;
- RETVOID;
+ return;
}
/* Determine the 2 TB transmission attributes */
*raType = RG_SCH_CMN_RA_TYPE0;
}
*prcdngInf = 0;
- RETVOID;
+ return;
}
else /* NumAntPorts == 4 */
{
*raType = RG_SCH_CMN_RA_TYPE0;
precInfoAntIdx = cell->numTxAntPorts/2 - 1;
*prcdngInf = (getPrecInfoFunc[0][precInfoAntIdx])(cell, ue, *numTxLyrs, *frthrScp);
- RETVOID;
+ return;
}
else
{
*raType = RG_SCH_CMN_RA_TYPE0;
}
*prcdngInf = 0;
- RETVOID;
+ return;
}
}
}
- RETVOID;
+ return;
}
*
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlHqProcCb *proc
- * @param[out] U8 *numTxLyrs
+ * @param[out] uint8_t *numTxLyrs
* @param[out] Bool *isTraDiv
- * @param[out] U8 *prcdngInf
- * @param[out] U8 *raType
+ * @param[out] uint8_t *prcdngInf
+ * @param[out] uint8_t *raType
* @return Void
*
**/
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc,
-U8 *numTxLyrs,
+uint8_t *numTxLyrs,
TfuDciFormat *dciFrmt,
-U8 *prcdngInf,
+uint8_t *prcdngInf,
RgSchDlHqTbCb **retxTb,
RgSchDlHqTbCb **txTb,
Bool *frthrScp,
Bool *swpFlg,
-U8 *raType
+uint8_t *raType
)
#else
PRIVATE Void rgSCHCmnDlGetAttrForTM4(cell, ue, proc, numTxLyrs, dciFrmt,\
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqProcCb *proc;
-U8 *numTxLyrs;
+uint8_t *numTxLyrs;
TfuDciFormat *dciFrmt;
-U8 *prcdngInf;
+uint8_t *prcdngInf;
RgSchDlHqTbCb **retxTb;
RgSchDlHqTbCb **txTb;
Bool *frthrScp;
Bool *swpFlg;
-U8 *raType;
+uint8_t *raType;
#endif
{
RgSchCmnDlUe *ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
- U8 precInfoAntIdx;
+ uint8_t precInfoAntIdx;
*frthrScp = FALSE;
*numTxLyrs = 1;
*frthrScp = FALSE;
*prcdngInf = 0;
- RETVOID;
+ return;
}
if (ueDl->mimoInfo.ri == 1)
*raType = RG_SCH_CMN_RA_TYPE0;
*frthrScp = FALSE;
*prcdngInf = 0; /*When RI= 1*/
- RETVOID;
+ return;
}
/* Determine the 2 TB transmission attributes */
*numTxLyrs = 1;
*prcdngInf = (getPrecInfoFunc[1][cell->numTxAntPorts/2 - 1])\
(cell, ue, *numTxLyrs, *frthrScp);
- RETVOID;
+ return;
}
else /* NumAntPorts == 4 */
{
precInfoAntIdx = cell->numTxAntPorts/2 - 1;
*prcdngInf = (getPrecInfoFunc[1][precInfoAntIdx])\
(cell, ue, *numTxLyrs, *frthrScp);
- RETVOID;
+ return;
}
else
{
precInfoAntIdx = cell->numTxAntPorts/2 - 1;
*prcdngInf = (getPrecInfoFunc[1][precInfoAntIdx])\
(cell, ue, *numTxLyrs, *frthrScp);
- RETVOID;
+ return;
}
}
}
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
S16 ret;
RgSchDlRbAlloc *allocInfo;
- U8 numRb;
+ uint8_t numRb;
RgSchDlHqTbCb *retxTb, *txTb;
Bool frthrScp;
Bool swpFlg;
- U8 prcdngInf;
- U8 numTxLyrs;
+ uint8_t prcdngInf;
+ uint8_t numTxLyrs;
frthrScp = FALSE;
{
/* Allocation couldn't be made for Retx */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
/* Adding UE to RbAllocInfo RETX-TX Lst */
rgSCHCmnDlRbInfoAddUeRetxTx(cell, cellWdAllocInfo, ue, proc);
{
/* Allocation couldn't be made for Retx */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
#ifdef LTEMAC_SPS
if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
prcdngInf, numTxLyrs, subFrm);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
S16 ret;
RgSchDlRbAlloc *allocInfo;
- U8 numRb;
+ uint8_t numRb;
RgSchDlHqTbCb *retxTb, *txTb;
Bool frthrScp;
Bool swpFlg;
- U8 prcdngInf;
- U8 numTxLyrs;
+ uint8_t prcdngInf;
+ uint8_t numTxLyrs;
ret = ROK;
* with the proc to the nonSchdTxRetxUeLst and let spfc scheduler
* take care of it during finalization. */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
/* Adding UE to RbAllocInfo RETX-TX Lst */
rgSCHCmnDlRbInfoAddUeRetxTx(cell, cellWdAllocInfo, ue, proc);
{
/* Allocation couldn't be made for Retx */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
#ifdef LTEMAC_SPS
if (!RG_SCH_CMN_SPS_DL_IS_SPS_HQP(proc))
RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, swpFlg, \
prcdngInf, numTxLyrs, subFrm)
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
RgSchCmnDlUe *ueDl;
RgSchDlRbAlloc *allocInfo;
- U8 numRb;
- U8 noTxLyrs;
- U8 precInfo;
+ uint8_t numRb;
+ uint8_t noTxLyrs;
+ uint8_t precInfo;
S16 ret;
- U8 precInfoAntIdx;
+ uint8_t precInfoAntIdx;
ret = ROK;
if (ret == RFAILED)
{
/* If allocation couldn't be made then return */
- RETVOID;
+ return;
}
noTxLyrs = 1;
precInfo = 0; /* TD */
if (ret == RFAILED)
{
/* If allocation couldn't be made then return */
- RETVOID;
+ return;
}
noTxLyrs = ueDl->mimoInfo.ri;
precInfoAntIdx = cell->numTxAntPorts/2 - 1;
RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, FALSE, \
precInfo, noTxLyrs, subFrm);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
RgSchCmnDlUe *ueDl;
RgSchDlRbAlloc *allocInfo;
- U8 numRb;
- U8 precInfo;
- U8 noTxLyrs;
- U8 precInfoAntIdx;
+ uint8_t numRb;
+ uint8_t precInfo;
+ uint8_t noTxLyrs;
+ uint8_t precInfoAntIdx;
S16 ret;
if (ret == RFAILED)
{
/* If allocation couldn't be made then return */
- RETVOID;
+ return;
}
noTxLyrs = 1;
precInfo = 0; /* TD */
if (ret == RFAILED)
{
/* If allocation couldn't be made then return */
- RETVOID;
+ return;
}
noTxLyrs = 1;
precInfo = 0; /* PrecInfo as 0 for RI=1*/
if (ret == RFAILED)
{
/* If allocation couldn't be made then return */
- RETVOID;
+ return;
}
noTxLyrs = ueDl->mimoInfo.ri;
precInfoAntIdx = cell->numTxAntPorts/2 - 1;
RG_SCH_CMN_FILL_DL_TXINFO(allocInfo, numRb, FALSE, \
precInfo, noTxLyrs, subFrm);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
rgSCHCmnDlTM4TxTx(cell, subFrm, ue, bo, effBo,\
proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
proc, cellWdAllocInfo);
}
- RETVOID;
+ return;
}
#ifdef RG_UNUSED
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
#endif
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "Invalid TM 5 for CRNTI:%d",ue->ueId);
#endif
- RETVOID;
+ return;
}
#endif
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
RgSchDlRbAlloc *allocInfo;
RgSchCmnDlUe *ueDl;
S16 ret;
- U8 numRb;
+ uint8_t numRb;
ret = ROK;
if (ret == RFAILED)
{
/* If allocation couldn't be made then return */
- RETVOID;
+ return;
}
#ifdef LTEMAC_SPS
/* Fill UE alloc Info */
allocInfo->rbsReq = numRb;
allocInfo->dlSf = subFrm;
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
RgSchDlRbAlloc *allocInfo;
RgSchCmnDlUe *ueDl;
S16 ret;
- U8 numRb;
+ uint8_t numRb;
ret = ROK;
{
/* Allocation couldn't be made for Retx */
rgSCHCmnDlAdd2NonSchdRetxLst(cellWdAllocInfo, ue, proc);
- RETVOID;
+ return;
}
/* Adding UE to allocInfo RETX Lst */
rgSCHCmnDlRbInfoAddUeRetx(cell, cellWdAllocInfo, ue, proc);
/* Fill UE alloc Info */
allocInfo->rbsReq = numRb;
allocInfo->dlSf = subFrm;
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
rgSCHCmnDlAllocTxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return Void
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
rgSCHCmnDlAllocRetxRb1Tb1Cw(cell, subFrm, ue, bo, effBo, proc, cellWdAllocInfo);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return S16
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- U32 newSchBits = 0;
- U32 prevSchBits = 0;
+ uint32_t newSchBits = 0;
+ uint32_t prevSchBits = 0;
RgSchDlRbAlloc *allocInfo;
RgSchDlHqProcCb *proc;
#endif
{
- U8 reqRbs;
+ uint8_t reqRbs;
if (proc->tbInfo[0].state == HQ_TB_NACKED)
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *effBo
* @param[in] RgSchDlHqProcCb *proc
* @param[out] RgSchCmnDlRbAllocInfo *cellWdAllocInfo
* @return S16
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchUeCb *ue;
-U32 bo;
-U32 *effBo;
+uint32_t bo;
+uint32_t *effBo;
RgSchDlHqProcCb *proc;
RgSchCmnDlRbAllocInfo *cellWdAllocInfo;
#endif
{
- U32 newSchBits = 0;
+ uint32_t newSchBits = 0;
RgSchDlRbAlloc *allocInfo;
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlHqTbCb *tbInfo
- * @param[in] U32 bo
- * @param[out] U8 *numRb
- * @param[out] U32 *effBo
+ * @param[in] uint32_t bo
+ * @param[out] uint8_t *numRb
+ * @param[out] uint32_t *effBo
* @return S16
*
**/
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqTbCb *tbInfo,
-U32 bo,
-U8 *numRb,
-U32 *effBo
+uint32_t bo,
+uint8_t *numRb,
+uint32_t *effBo
)
#else
PRIVATE S16 rgSCHCmnDlAlloc1CwTxRb(cell, subFrm, ue, tbInfo, bo, numRb, effBo)
RgSchDlSf *subFrm;
RgSchUeCb *ue;
RgSchDlHqTbCb *tbInfo;
-U32 bo;
-U8 *numRb;
-U32 *effBo;
+uint32_t bo;
+uint8_t *numRb;
+uint32_t *effBo;
#endif
{
- U32 tbSz;
- U8 imcs;
- U8 iTbs;
+ uint32_t tbSz;
+ uint8_t imcs;
+ uint8_t iTbs;
RgSchCmnDlUe *ueDl;
RgSchDlRbAlloc *allocInfo;
- U32 oldReq;
- U32 reqBytes;
+ uint32_t oldReq;
+ uint32_t reqBytes;
/* Correcting wrap around issue.
* This change has been done at mutliple places in this function.*/
- U32 tempNumRb;
+ uint32_t tempNumRb;
reqBytes = bo;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[0], tbSz, \
iTbs, imcs, tbInfo, ue->ue5gtfCb.rank);
- *numRb = (U8) tempNumRb;
+ *numRb = (uint8_t) tempNumRb;
/* Update the subframe Allocated BW field */
subFrm->bwAssigned = subFrm->bwAssigned + tempNumRb - allocInfo->rbsReq;
* of specific scheduler.
*
* @param[in] RgSchDlRbAlloc *allocInfo
- * @param[in] U8 tbInfoIdx
- * @param[in] U32 cnsmdBytes
+ * @param[in] uint8_t tbInfoIdx
+ * @param[in] uint32_t cnsmdBytes
* @return Void
*
**/
Void rgSCHCmnRdcImcsTxTb
(
RgSchDlRbAlloc *allocInfo,
-U8 tbInfoIdx,
-U32 cnsmdBytes
+uint8_t tbInfoIdx,
+uint32_t cnsmdBytes
)
#else
Void rgSCHCmnRdcImcsTxTb(allocInfo, tbInfoIdx, cnsmdBytes)
RgSchDlRbAlloc *allocInfo;
-U8 tbInfoIdx;
-U32 cnsmdBytes;
+uint8_t tbInfoIdx;
+uint32_t cnsmdBytes;
#endif
{
- RETVOID;
+ return;
/*The below functionality is not needed.*/
- U8 noLyr;
- U8 iTbs;
- U16 numRb;
+ uint8_t noLyr;
+ uint8_t iTbs;
+ uint16_t numRb;
iTbs = allocInfo->tbInfo[tbInfoIdx].iTbs;
{
if ((rgTbSzTbl[noLyr-1][iTbs][numRb-1]/8) == cnsmdBytes)
{
- RETVOID;
+ return;
}
}
/* Get iTbs as suitable for the consumed bytes */
{
RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, allocInfo->tbInfo[tbInfoIdx].\
tbCb->dlGrnt.iMcs);
- RETVOID;
+ return;
}
iTbs--;
}
iTbs++;
RG_SCH_CMN_DL_TBS_TO_MCS(iTbs, allocInfo->tbInfo[tbInfoIdx].tbCb->dlGrnt.iMcs);
- RETVOID;
+ return;
}
\f
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlHqProcCb *proc
* @param[in] RgSchDlHqProcCb bo
- * @param[out] U8 *numRb
- * @param[out] U32 *effBo
+ * @param[out] uint8_t *numRb
+ * @param[out] uint32_t *effBo
* @return Void
*
**/
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc,
-U32 bo,
-U8 *numRbRef,
-U32 *effBo
+uint32_t bo,
+uint8_t *numRbRef,
+uint32_t *effBo
)
#else
PRIVATE S16 rgSCHCmnDlAlloc2CwTxRb(cell, subFrm, ue, proc, bo, numRbRef, effBo)
RgSchDlSf *subFrm;
RgSchUeCb *ue;
RgSchDlHqProcCb *proc;
-U32 bo;
-U8 *numRbRef;
-U32 *effBo;
+uint32_t bo;
+uint8_t *numRbRef;
+uint32_t *effBo;
#endif
{
- U32 noRes;
- U32 eff1, eff2;
- U32 tb1Sz, tb2Sz;
- U8 imcs1, imcs2;
- U8 noLyr1, noLyr2;
- U8 iTbs1, iTbs2;
+ uint32_t noRes;
+ uint32_t eff1, eff2;
+ uint32_t tb1Sz, tb2Sz;
+ uint8_t imcs1, imcs2;
+ uint8_t noLyr1, noLyr2;
+ uint8_t iTbs1, iTbs2;
RgSchCmnDlCell *cellDl;
RgSchCmnDlUe *ueDl;
RgSchDlRbAlloc *allocInfo;
- U32 oldReq;
- U32 reqBytes;
+ uint32_t oldReq;
+ uint32_t reqBytes;
/* Fix: MUE_PERTTI_DL */
- U32 numRb;
+ uint32_t numRb;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 cfi = cellSch->dl.currCfi;
+ uint8_t cfi = cellSch->dl.currCfi;
S16 availBw;
- U32 availBits = 0;
+ uint32_t availBits = 0;
#ifdef LTE_ADV
- U32 boTmp = bo;
+ uint32_t boTmp = bo;
#endif
}
else
{
- U8 cqi = ueDl->mimoInfo.cwInfo[0].cqi;
+ uint8_t cqi = ueDl->mimoInfo.cwInfo[0].cqi;
#ifdef LTE_TDD
- iTbs1 = (U8) rgSchCmnFetchItbs(cell, ueDl, subFrm, cqi, cfi, 0, noLyr1);
+ iTbs1 = (uint8_t) rgSchCmnFetchItbs(cell, ueDl, subFrm, cqi, cfi, 0, noLyr1);
#else
- iTbs1 = (U8) rgSchCmnFetchItbs(cell, ueDl, cqi, cfi, 0, noLyr1);
+ iTbs1 = (uint8_t) rgSchCmnFetchItbs(cell, ueDl, cqi, cfi, 0, noLyr1);
#endif
cqi = ueDl->mimoInfo.cwInfo[1].cqi;
#ifdef LTE_TDD
- iTbs2 = (U8) rgSchCmnFetchItbs(cell, ueDl, subFrm, cqi, cfi, 1, noLyr2);
+ iTbs2 = (uint8_t) rgSchCmnFetchItbs(cell, ueDl, subFrm, cqi, cfi, 1, noLyr2);
#else
- iTbs2 = (U8) rgSchCmnFetchItbs(cell, ueDl, cqi, cfi, 1, noLyr2);
+ iTbs2 = (uint8_t) rgSchCmnFetchItbs(cell, ueDl, cqi, cfi, 1, noLyr2);
#endif
}
if(subFrm->sfType == RG_SCH_SPL_SF_DATA)
{
/* Max Rb for Special Sf is approximated as 4/3 of maxRb */
- rgSCHCmnCalcDwPtsTbSz2Cw(cell, bo, (U8*)&numRb, ueDl->maxRb*4/3,
+ rgSCHCmnCalcDwPtsTbSz2Cw(cell, bo, (uint8_t*)&numRb, ueDl->maxRb*4/3,
&iTbs1, &iTbs2, noLyr1,
noLyr2, &tb1Sz, &tb2Sz, cfi);
/* Check for available Bw */
iTbs1, imcs1, &proc->tbInfo[0], noLyr1);
RG_SCH_CMN_FILL_DL_TBINFO(&allocInfo->tbInfo[1], tb2Sz, \
iTbs2, imcs2, &proc->tbInfo[1], noLyr2);
- *numRbRef = (U8)numRb;
+ *numRbRef = (uint8_t)numRb;
return ROK;
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlHqTbCb *reTxTb
* @param[in] RgSchDlHqTbCb *txTb
- * @param[out] U8 *numRb
- * @param[out] U32 *effBo
+ * @param[out] uint8_t *numRb
+ * @param[out] uint32_t *effBo
* @return Void
*
**/
RgSchUeCb *ue,
RgSchDlHqTbCb *reTxTb,
RgSchDlHqTbCb *txTb,
-U8 *numRb,
-U32 *effBo
+uint8_t *numRb,
+uint32_t *effBo
)
#else
PRIVATE S16 rgSCHCmnDlAlloc2CwTxRetxRb(cell, subFrm, ue, reTxTb, txTb, numRb,\
RgSchUeCb *ue;
RgSchDlHqTbCb *reTxTb;
RgSchDlHqTbCb *txTb;
-U8 *numRb;
-U32 *effBo;
+uint8_t *numRb;
+uint32_t *effBo;
#endif
{
RgSchCmnDlUe *ueDl;
RgSchDlRbAlloc *allocInfo;
- U8 imcs1, imcs2;
- U8 noLyr2;
- U16 tb2Sz;
+ uint8_t imcs1, imcs2;
+ uint8_t noLyr2;
+ uint16_t tb2Sz;
RgSchCmnDlUeCwInfo *otherCw;
S16 availBw;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U8 cfi = cellDl->currCfi;
- U8 iTbs;
+ uint8_t cfi = cellDl->currCfi;
+ uint8_t iTbs;
ueDl = RG_SCH_CMN_GET_DL_UE(ue,cell);
else
{
#ifdef LTE_TDD
- iTbs = (U8) rgSchCmnFetchItbs(cell, ueDl, subFrm, otherCw->cqi, cfi,
+ iTbs = (uint8_t) rgSchCmnFetchItbs(cell, ueDl, subFrm, otherCw->cqi, cfi,
!(ueDl->mimoInfo.btrCwIdx), noLyr2);
#else
- iTbs = (U8) rgSchCmnFetchItbs(cell, ueDl, otherCw->cqi, cfi,
+ iTbs = (uint8_t) rgSchCmnFetchItbs(cell, ueDl, otherCw->cqi, cfi,
!(ueDl->mimoInfo.btrCwIdx), noLyr2);
#endif
}
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlHqProcCb *proc
- * @param[out] U8 *numRb
+ * @param[out] uint8_t *numRb
* @param[out] Bool *swpFlg
- * @param[out] U32 *effBo
+ * @param[out] uint32_t *effBo
* @return Void
*
**/
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc,
-U8 *numRb,
+uint8_t *numRb,
Bool *swpFlg,
-U32 *effBo
+uint32_t *effBo
)
#else
PRIVATE S16 rgSCHCmnDlAlloc2CwRetxRb(cell, subFrm, ue, proc,\
RgSchDlSf *subFrm;
RgSchUeCb *ue;
RgSchDlHqProcCb *proc;
-U8 *numRb;
+uint8_t *numRb;
Bool *swpFlg;
-U32 *effBo;
+uint32_t *effBo;
#endif
{
RgSchDlRbAlloc *allocInfo;
- U8 imcs1;
- U8 imcs2;
+ uint8_t imcs1;
+ uint8_t imcs2;
RgSchDlHqTbCb *lrgTbInfo, *othrTbInfo;
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchUeCb *ue
* @param[in] RgSchDlHqTbCb *tbInfo
- * @param[in] U8 noLyr
- * @param[out] U8 *numRb
- * @param[out] U32 *effBo
+ * @param[in] uint8_t noLyr
+ * @param[out] uint8_t *numRb
+ * @param[out] uint32_t *effBo
* @return S16
*
**/
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqTbCb *tbInfo,
-U8 noLyr,
-U8 *numRb,
-U32 *effBo
+uint8_t noLyr,
+uint8_t *numRb,
+uint32_t *effBo
)
#else
PRIVATE S16 rgSCHCmnDlAlloc1CwRetxRb(cell, subFrm, ue, tbInfo, noLyr,\
RgSchDlSf *subFrm;
RgSchUeCb *ue;
RgSchDlHqTbCb *tbInfo;
-U8 noLyr;
-U8 *numRb;
-U32 *effBo;
+uint8_t noLyr;
+uint8_t *numRb;
+uint32_t *effBo;
#endif
{
RgSchDlRbAlloc *allocInfo;
- U8 imcs;
+ uint8_t imcs;
allocInfo = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue,cell);
{
rgSCHCmnSpsDlRelPdcchFbk(cell, ue, isAck);
- RETVOID;
+ return;
}
/* Invoke SPS module if SPS service was scheduled for this HARQ proc */
rgSCHCmnSpsDlProcAck(cell, hqP);
}
- RETVOID;
+ return;
}
#ifdef RGSCH_SPS_STATS
-extern U32 rgSchStatCrntiCeRcvCnt;
+extern uint32_t rgSchStatCrntiCeRcvCnt;
#endif
/**
* @brief This function is invoked to handle CRNTI CE reception for an UE
rgSCHCmnSpsUlUeReset(cell, ue);
}
- RETVOID;
+ return;
}
{
rgSCHCmnSpsUlProcRelInd(cell, ue, isExplRel);
- RETVOID;
+ return;
} /* end of rgSCHCmnUlSpsRelInd */
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U16 spsSduSize
+uint16_t spsSduSize
)
#else
Void rgSCHCmnUlSpsActInd(cell, ue,spsSduSize)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U16 spsSduSize;
+uint16_t spsSduSize;
#endif
{
{
rgSCHCmnSpsUlProcActInd(cell, ue,spsSduSize);
}
- RETVOID;
+ return;
} /* end of rgSCHCmnUlSpsActInd */
{
rgSCHCmnSpsUlProcCrcInd(cell, ue, crcTime);
}
- RETVOID;
+ return;
} /* end of rgSCHCmnUlCrcFailInd */
{
rgSCHCmnSpsUlProcDtxInd(cell, ue, crcTime);
}
- RETVOID;
+ return;
} /* end of rgSCHCmnUlCrcFailInd */
#endif
{
#ifdef LTE_TDD
- U8 nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
+ uint8_t nextSfIdx = (cell->crntSfIdx) % RGSCH_SF_ALLOC_SIZE;
#else
#ifdef LTEMAC_HDFDD
- U8 nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
+ uint8_t nextSfIdx = (cell->crntSfIdx + RG_SCH_CMN_HARQ_INTERVAL) % RGSCH_NUM_SUB_FRAMES;
#else
- U8 nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
+ uint8_t nextSfIdx = (cell->crntSfIdx) % RGSCH_NUM_SUB_FRAMES;
#endif
#endif
RgInfSfAlloc *nextsfAlloc = &(cell->sfAllocArr[nextSfIdx]);
/* Finalize the Allocations for reqested Against alloced */
rgSCHCmnDlBcchPcchFnlz(cell, allocInfo);
#endif /* DISABLE_MIB_SIB */
- RETVOID;
+ return;
}
/**
rgSCHCmnNonDlfsBcchPcchRbAlloc(cell, allocInfo);
}
- RETVOID;
+ return;
}
/**
{
rgSCHCmnNonDlfsCmnRbAlloc(cell, reqAllocInfo);
}
- RETVOID;
+ return;
}
/*if(!((((pdSchTmInfo.hSfn * 1024) + pdSchTmInfo.sfn) % cell->siCfg.modPrd == 0)
&& (0 == pdSchTmInfo.slot)))*/
{
- RETVOID;
+ return;
}
/*Check whether MIB has been updated*/
/*Check whether SIs have been updated*/
if(cell->siCb.siBitMask & RGSCH_SI_SI_UPD)
{
- U8 idx;
+ uint8_t idx;
/*Check if SI cfg have been modified And Check if numSi have
been changed, if yes then we would need to update the
cell->siCb.siBitMask &= ~RGSCH_SI_SICFG_UPD;
}
- RETVOID;
+ return;
}
#endif
{
CmLteTimingInfo crntTmInfo;
- U8 siWinSize;
- U16 x;
- U16 windowId;
+ uint8_t siWinSize;
+ uint16_t x;
+ uint16_t windowId;
else
{
cell->siCb.inWindow--;
- RETVOID;
+ return;
}
}
else /* New window. Re-init the winSize counter with the window length */
/ siWinSize;
if(windowId >= RGR_MAX_NUM_SI)
- RETVOID;
+ return;
/* Update the siCtx if there is a valid SI and its periodicity
* has occurred */
cell->siCb.siCtx.siId = 0;
}
- RETVOID;
+ return;
}
{
CmLteTimingInfo crntTimInfo;
RgSchDlSf *sf;
- U8 nPrb = 0;
- U8 mcs = 0;
+ uint8_t nPrb = 0;
+ uint8_t mcs = 0;
MsgLen msgLen = 0;
- U32 rb=0;
+ uint32_t rb=0;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
/* DwPTS Scheduling Changes Start */
#ifdef LTE_TDD
- U16 lostRe;
- U8 cfi = cellDl->currCfi;
+ uint16_t lostRe;
+ uint8_t cfi = cellDl->currCfi;
#endif
/* DwPTS Scheduling Changes End */
&& (RGSCH_MIB_TX_SF_NUM == crntTimInfo.slot))
{
MsgLen mibLen = 0;
- U8 sfnOctet, mibOct2 = 0;
- U8 mibOct1 = 0;
+ uint8_t sfnOctet, mibOct2 = 0;
+ uint8_t mibOct1 = 0;
/*If MIB has not been yet setup by Application, return*/
if(NULLP == cell->siCb.crntSiInfo.mib)
- RETVOID;
+ return;
SFndLenMsg(cell->siCb.crntSiInfo.mib, &mibLen);
sf->bch.tbSize = mibLen;
/*Set the bits of MIB to reflect SFN */
/*First get the Most signficant 8 bits of SFN */
- sfnOctet = (U8)(crntTimInfo.sfn >> 2);
+ sfnOctet = (uint8_t)(crntTimInfo.sfn >> 2);
/*Get the first two octets of MIB, and then update them
using the SFN octet value obtained above.*/
if(ROK != SExamMsg((Data *)(&mibOct1),
cell->siCb.crntSiInfo.mib, 0))
- RETVOID;
+ return;
if(ROK != SExamMsg((Data *)(&mibOct2),
cell->siCb.crntSiInfo.mib, 1))
- RETVOID;
+ return;
/* ccpu00114572- Fix for improper way of MIB Octet setting for SFN */
mibOct1 = (mibOct1 & 0xFC) | (sfnOctet >> 6);
/*Now, replace the two octets in MIB */
if(ROK != SRepMsg((Data)(mibOct1),
cell->siCb.crntSiInfo.mib, 0))
- RETVOID;
+ return;
if(ROK != SRepMsg((Data)(mibOct2),
cell->siCb.crntSiInfo.mib, 1))
- RETVOID;
+ return;
/*Copy the MIB msg buff into interface buffer */
SCpyMsgMsg(cell->siCb.crntSiInfo.mib,
/*If SIB1 has not been yet setup by Application, return*/
if(NULLP == (cell->siCb.crntSiInfo.sib1Info.sib1))
{
- RETVOID;
+ return;
}
allocInfo->bcchAlloc.schdFirst = TRUE;
Bool invalid = FALSE;
if(cell->siCb.siCtx.siId == 0)
- RETVOID;
+ return;
/*Check if the Si-Window for the current Si-Context is completed*/
invalid = rgSCHCmnChkPastWin(crntTimInfo, cell->siCb.siCtx.maxTimeToTx);
rgSCHUtlFreeWarningSiPdu(cell);
cell->siCb.siCtx.warningSiFlag = FALSE;
}
- RETVOID;
+ return;
}
/*Check the timinginfo of the current SI-Context to see if its
cell->siCb.siCtx.timeToTx,
cell->siCb.siCtx.maxTimeToTx)))
{
- RETVOID;
+ return;
}
/*Check if retransmission count has become 0*/
if(0 == cell->siCb.siCtx.retxCntRem)
{
- RETVOID;
+ return;
}
/* LTE_ADV_FLAG_REMOVED_START */
[((crntTimInfo.sfn*RGSCH_NUM_SUB_FRAMES) + crntTimInfo.slot) % RGR_ABS_PATTERN_LEN]))
{
/* Skip the SI scheduling to next tti */
- RETVOID;
+ return;
}
}
}
* and Other SI */
if((rgSCHUtlGetMcsAndNPrb(cell, &nPrb, &mcs, &msgLen)) != ROK)
{
- RETVOID;
+ return;
}
cell->siCb.siCtx.i = RGSCH_CALC_SF_DIFF(crntTimInfo,
/*rgSCHCmnClcRbAllocForFxdTb(cell, msgLen, cellDl->ccchCqi, &rb);*/
if(cellDl->bitsPerRb==0)
{
- while ((rgTbSzTbl[0][0][rb]) < (U32) (msgLen*8))
+ while ((rgTbSzTbl[0][0][rb]) < (uint32_t) (msgLen*8))
{
rb++;
}
{
RLOG_ARG1(L_ERROR,DBG_CELLID,cell->cellId, "rgSCHDlSiSched(): "
"BW allocation failed CRNTI:%d",RGSCH_SI_RNTI);
- RETVOID;
+ return;
}
/* Update the subframe Allocated BW field */
allocInfo->bcchAlloc.nPrb = nPrb;
allocInfo->bcchAlloc.tbInfo[0].bytesReq = msgLen;
allocInfo->bcchAlloc.tbInfo[0].noLyr = 1;
- RETVOID;
+ return;
}
#endif /*RGR_SI_SCH*/
RgrUeCqiRept *ueCqiRpt;
#endif
{
- U8 *cqiCount = NULLP;
+ uint8_t *cqiCount = NULLP;
S16 retVal;
RgrStaIndInfo *staInfo = NULLP;
/* Step 4.1: Fill StaInd for sending collated N CQI rpeorts */
#ifdef CA_DBG
{
- extern U32 gCqiReptToAppCount;
+ extern uint32_t gCqiReptToAppCount;
gCqiReptToAppCount++;
}
*reTxAllwd = FALSE;
}
- RETVOID;
+ return;
}
/**
* (0,0) (8,0) (16,0) (SFN, SF)
*
*
- * @param[in] U16 sfn
- * @param[in] U8 sf
- * @return U16 siSetId
+ * @param[in] uint16_t sfn
+ * @param[in] uint8_t sf
+ * @return uint16_t siSetId
**/
#ifdef ANSI
-U16 rgSCHCmnGetSiSetId
+uint16_t rgSCHCmnGetSiSetId
(
-U16 sfn,
-U8 sf,
-U16 minPeriodicity
+uint16_t sfn,
+uint8_t sf,
+uint16_t minPeriodicity
)
#else
-U16 rgSCHCmnGetSiSetId(sfn, sf, minPeriodicity)
-U16 sfn;
-U8 sf
-U16 minPeriodicity;
+uint16_t rgSCHCmnGetSiSetId(sfn, sf, minPeriodicity)
+uint16_t sfn;
+uint8_t sf
+uint16_t minPeriodicity;
#endif
{
/* 80 is the minimum SI periodicity in sf. Also
* Function: rgSCHCmnCalcDwPtsTbSz
*
* @param[in] RgSchCellCb *cell
- * @param[in] U32 bo
- * @param[in/out] U8 *rb
- * @param[in/out] U8 *iTbs
- * @param[in] U8 lyr
- * @param[in] U8 cfi
- * @return U32 tbSz
+ * @param[in] uint32_t bo
+ * @param[in/out] uint8_t *rb
+ * @param[in/out] uint8_t *iTbs
+ * @param[in] uint8_t lyr
+ * @param[in] uint8_t cfi
+ * @return uint32_t tbSz
**/
#ifdef ANSI
-PRIVATE U32 rgSCHCmnCalcDwPtsTbSz
+PRIVATE uint32_t rgSCHCmnCalcDwPtsTbSz
(
RgSchCellCb *cell,
-U32 bo,
-U8 *rb,
-U8 *iTbs,
-U8 lyr,
-U8 cfi
+uint32_t bo,
+uint8_t *rb,
+uint8_t *iTbs,
+uint8_t lyr,
+uint8_t cfi
)
#else
-PRIVATE U32 rgSCHCmnCalcDwPtsTbSz(cell, bo, rb, iTbs, lyr, cfi)
+PRIVATE uint32_t rgSCHCmnCalcDwPtsTbSz(cell, bo, rb, iTbs, lyr, cfi)
RgSchCellCb *cell;
-U32 bo;
-U8 *rb;
-U8 *iTbs;
-U8 lyr;
-U8 cfi;
+uint32_t bo;
+uint8_t *rb;
+uint8_t *iTbs;
+uint8_t lyr;
+uint8_t cfi;
#endif
{
- U32 tbSz;
+ uint32_t tbSz;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U32 numRE = *rb * cellDl->noResPerRb[cfi];
- U32 numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
+ uint32_t numRE = *rb * cellDl->noResPerRb[cfi];
+ uint32_t numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
/* DwPts Rb cannot exceed the cell Bw */
* Function: rgSCHCmnCalcDwPtsTbSz2Cw
*
* @param[in] RgSchCellCb *cell
- * @param[in] U32 bo
- * @param[in/out] U8 *rb
- * @param[in] U8 maxRb
- * @param[in/out] U8 *iTbs1
- * @param[in/out] U8 *iTbs2
- * @param[in] U8 lyr1
- * @param[in] U8 lyr2
- * @return[in/out] U32 *tb1Sz
- * @return[in/out] U32 *tb2Sz
- * @param[in] U8 cfi
+ * @param[in] uint32_t bo
+ * @param[in/out] uint8_t *rb
+ * @param[in] uint8_t maxRb
+ * @param[in/out] uint8_t *iTbs1
+ * @param[in/out] uint8_t *iTbs2
+ * @param[in] uint8_t lyr1
+ * @param[in] uint8_t lyr2
+ * @return[in/out] uint32_t *tb1Sz
+ * @return[in/out] uint32_t *tb2Sz
+ * @param[in] uint8_t cfi
**/
#ifdef ANSI
PRIVATE Void rgSCHCmnCalcDwPtsTbSz2Cw
(
RgSchCellCb *cell,
-U32 bo,
-U8 *rb,
-U8 maxRb,
-U8 *iTbs1,
-U8 *iTbs2,
-U8 lyr1,
-U8 lyr2,
-U32 *tb1Sz,
-U32 *tb2Sz,
-U8 cfi
+uint32_t bo,
+uint8_t *rb,
+uint8_t maxRb,
+uint8_t *iTbs1,
+uint8_t *iTbs2,
+uint8_t lyr1,
+uint8_t lyr2,
+uint32_t *tb1Sz,
+uint32_t *tb2Sz,
+uint8_t cfi
)
#else
PRIVATE Void rgSCHCmnCalcDwPtsTbSz2Cw(cell, bo, rb, maxRb, iTbs1, iTbs2,
lyr1, lyr2, tb1Sz, tb2Sz, cfi)
RgSchCellCb *cell;
-U32 bo;
-U8 *rb;
-U8 maxRb;
-U8 *iTbs1;
-U8 *iTbs2;
-U8 lyr1;
-U8 lyr2;
-U32 *tb1Sz;
-U32 *tb2Sz;
-U8 cfi;
+uint32_t bo;
+uint8_t *rb;
+uint8_t maxRb;
+uint8_t *iTbs1;
+uint8_t *iTbs2;
+uint8_t lyr1;
+uint8_t lyr2;
+uint32_t *tb1Sz;
+uint32_t *tb2Sz;
+uint8_t cfi;
#endif
{
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
- U32 numRE = *rb * cellDl->noResPerRb[cfi];
- U32 numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
+ uint32_t numRE = *rb * cellDl->noResPerRb[cfi];
+ uint32_t numDwPtsRb = RGSCH_CEIL(numRE, cellDl->numReDwPts[cfi]);
/* DwPts Rb cannot exceed the cell Bw */
*rb = numDwPtsRb;
- RETVOID;
+ return;
}
#endif
RgInfUeDatInd *datInd;
#endif
{
- U32 idx = 0;
+ uint32_t idx = 0;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
#ifdef DEBUGP
Inst inst = cell->instIdx;
{
if (datInd->lcgInfo[idx].bytesRcvd != 0)
{
- U8 lcgId = datInd->lcgInfo[idx].lcgId;
- U32 bytesRcvd = datInd->lcgInfo[idx].bytesRcvd;
+ uint8_t lcgId = datInd->lcgInfo[idx].lcgId;
+ uint32_t bytesRcvd = datInd->lcgInfo[idx].bytesRcvd;
if (RGSCH_LCG_ISCFGD(&ue->ul.lcgArr[lcgId]))
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
CmLteTimingInfo frm;
RgSchDlSf *dlSf;
- U8 idx;
+ uint8_t idx;
/* Initializing RgSchCmnUlRbAllocInfo structure.*/
/* Update subframe-wide allocation information with SPS allocation */
rgSCHCmnSpsDlUpdDlSfAllocWithSps(cell, frm, dlSf);
#endif
- RETVOID;
+ return;
}
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 newTxMode
+ * @param[in] uint8_t newTxMode
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 newTxMode
+uint8_t newTxMode
)
#else
PRIVATE Void rgSCHCmnSendTxModeInd(cell, ue, newTxMode)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 newTxMode;
+uint8_t newTxMode;
#endif
{
RgmTransModeInd *txModeChgInd;
cell->rgmSap->sapCfg.sapPst.pool, (Data**)&txModeChgInd,
sizeof(RgmTransModeInd)) != ROK)
{
- RETVOID;
+ return;
}
RG_SCH_FILL_RGM_TRANSMODE_IND(ue->ueId, cell->cellId, newTxMode, txModeChgInd);
RgUiRgmChangeTransModeInd(&(cell->rgmSap->sapCfg.sapPst),
ue->mimoInfo.txModDownChgFactor = 0;
ueDl->laCb[0].deltaiTbs = 0;
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 iTbs
+ * @param[in] uint8_t iTbs
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 reportediTbs,
-U8 previTbs,
-U8 maxiTbs
+uint8_t reportediTbs,
+uint8_t previTbs,
+uint8_t maxiTbs
)
#else
Void rgSchCheckAndTriggerModeChange(cell, ue, reportediTbs, previTbs, maxiTbs)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 reportediTbs;
-U8 previTbs;
-U8 maxiTbs;
+uint8_t reportediTbs;
+uint8_t previTbs;
+uint8_t maxiTbs;
#endif
{
RgrTxMode txMode; /*!< UE's Transmission Mode */
}
}
- RETVOID;
+ return;
}
#endif
Void rgSchCmnPreDlSch
(
RgSchCellCb **cell,
- U8 nCell,
+ uint8_t nCell,
RgSchCellCb **cellLst
)
#else
Void rgSchCmnPreDlSch(cell, nCell, cellLst)
RgSchCellCb **cell;
- U8 nCell;
+ uint8_t nCell;
RgSchCellCb **cellLst;
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell[0]);
RgSchDlSf *sf;
- U8 idx;
+ uint8_t idx;
if(nCell > CM_LTE_MAX_CELLS)
{
- RETVOID;
+ return;
}
if (cell[0]->isDlDataAllwd && (cell[0]->stopDlSch == FALSE))
* in that cell */
for (idx = 0; idx < nCell; idx++)
{
- U8 j;
+ uint8_t j;
cellSch = RG_SCH_CMN_GET_CELL(cell[idx]);
sf = cellSch->allocInfo.dedAlloc.dedDlSf;
if(sf->remUeCnt < subfrm->remUeCnt)
{
- U8 k;
+ uint8_t k;
for(k = idx; k > j; k--)
{
cellLst[k] = cellLst[k-1];
cellLst[idx] = cell[idx];
}
}
- RETVOID;
+ return;
}
/** @brief DL scheduler for SPS, and all other downlink data
}
#ifdef ANSI
-U8 rgSCHCmnCalcPcqiBitSz
+uint8_t rgSCHCmnCalcPcqiBitSz
(
RgSchUeCb *ueCb,
- U8 numTxAnt
+ uint8_t numTxAnt
)
#else
-U8 rgSCHCmnCalcPcqiBitSz(ueCb, numTxAnt)
+uint8_t rgSCHCmnCalcPcqiBitSz(ueCb, numTxAnt)
RgSchUeCb *ueCb;
- U8 numTxAnt;
+ uint8_t numTxAnt;
#endif
{
- U8 confRepMode;
- U8 pcqiSz;
- U8 ri;
+ uint8_t confRepMode;
+ uint8_t pcqiSz;
+ uint8_t ri;
RgSchUePCqiCb *cqiCb = ueCb->nPCqiCb;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
#ifdef RG_5GTF
RgSchDynTddCb *rgSchDynTddInfo = &(rgSchCb[cell->instIdx].rgSchDynTdd);
- U16 dlCntrlSfIdx;
+ uint16_t dlCntrlSfIdx;
#endif
cellSch->dl.time.slot);
*/
}
- RETVOID;
+ return;
}
}
#endif
/* Do group power control for PUCCH */
rgSCHCmnGrpPwrCntrlPucch(cell, dlSf);
- RETVOID;
+ return;
}
/**********************************************************************
} \
else { \
if (tb->dlGrnt.iMcs < 29) {\
- U8 _iTbs;\
+ uint8_t _iTbs;\
RG_SCH_CMN_DL_MCS_TO_TBS(tb->dlGrnt.iMcs, _iTbs);\
RG_SCH_CMN_ITBS_TO_RETX_IMCS(_iTbs, retxMcs); \
} \
#define RGSCHCMNADDTOCRNTTIME(crntTime, toFill, incr) \
{\
- U32 absoluteTime;\
+ uint32_t absoluteTime;\
absoluteTime = crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + crntTime.slot;\
absoluteTime += incr;\
toFill.sfn = (absoluteTime /RGSCH_NUM_SUB_FRAMES_5G)% 1024;\
#define RG_SCH_CMN_DL_COUNT_ONES(_bitMask, _size, _numOnes)\
{\
- U8 _pos = 0;\
+ uint8_t _pos = 0;\
*_numOnes = 0;\
for (_pos = 0; _pos < _size; ++_pos)\
{\
#define RG_SCH_CMN_DL_GET_START_POS(_allocedBitmask, _size, _startPos)\
{\
- U8 _pos = 0;\
+ uint8_t _pos = 0;\
for (_pos = 0; _pos < _size; ++_pos)\
{\
if ((_allocedBitmask & (1 << (31 -_pos))))\
#define RG_SCH_CMN_UPD_RBS_TO_ADD(_CELL,_DLSF,_ALLCINFO,_RBSREQ,_RBSTOADD) \
{\
- U8 addtlRbsAvl;\
+ uint8_t addtlRbsAvl;\
addtlRbsAvl = rgSCHCmnFindNumAddtlRbsAvl(_CELL,_DLSF,_ALLCINFO);\
if(_RBSREQ > addtlRbsAvl)\
{\
/* LTE_ADV_FLAG_REMOVED_START */
#define RG_SCH_CMN_SFR_UPD_RBS_TO_ADD_IN_POOL(_CELL,_DLSF,_POOLINFO,_ALLCINFO,_RBSREQ,_RBSTOADD) \
{\
- U8 addtlRbsAvl;\
+ uint8_t addtlRbsAvl;\
addtlRbsAvl = rgSCHCmnSFRFindNumAddtlRbsAvl(_CELL,_DLSF,_POOLINFO,_ALLCINFO);\
if(_RBSREQ > addtlRbsAvl)\
{\
S16 (*rgSCHRgrUlLcRecfg) ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
RgrLchRecfg *recfg, RgSchErrInfo *errInfo));
Void (*rgSCHFreeUlLcg) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, RgSchLcgCb *lcg));
- S16 (*rgSCHRgrUlLchDel) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, CmLteLcId lcId, U8 lcgId));
+ S16 (*rgSCHRgrUlLchDel) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, CmLteLcId lcId, uint8_t lcgId));
Void (*rgSCHUlActvtUe) ARGS((RgSchCellCb *cell, RgSchUeCb *ue));
- Void (*rgSCHUpdBsrShort) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, RgSchLcgCb *ulLcg, U8 bsr));
- Void (*rgSCHUpdBsrTrunc) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, RgSchLcgCb *ulLcg, U8 bsr));
- Void (*rgSCHUpdBsrLong) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, U8 bsArr[]));
+ Void (*rgSCHUpdBsrShort) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, RgSchLcgCb *ulLcg, uint8_t bsr));
+ Void (*rgSCHUpdBsrTrunc) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, RgSchLcgCb *ulLcg, uint8_t bsr));
+ Void (*rgSCHUpdBsrLong) ARGS((RgSchCellCb *cell, RgSchUeCb *ue, uint8_t bsArr[]));
Void (*rgSCHContResUlGrant) ARGS((RgSchCellCb *cell, RgSchUeCb *ue));
Void (*rgSCHSrRcvd) ARGS((RgSchCellCb *cell, RgSchUeCb *ue));
Void (*rgSCHUlSched) ARGS((RgSchCellCb *cell, RgSchCmnUlRbAllocInfo
typedef struct rgSchCmnUlCqiInfo
{
- U8 qm;
- U16 eff; /* Efficiency in terms of bits/RE */
+ uint8_t qm;
+ uint16_t eff; /* Efficiency in terms of bits/RE */
} RgSchCmnUlCqiInfo;
EXTERN RgSchCmnUlCqiInfo rgSchCmnUlCqiTbl[RG_SCH_CMN_UL_NUM_CQI];
#endif
-EXTERN U8 rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_MAX_CP][RG_SCH_CMN_UL_NUM_CQI];
+EXTERN uint8_t rgSchCmnUlCqiToTbsTbl[RG_SCH_CMN_MAX_CP][RG_SCH_CMN_UL_NUM_CQI];
#if (LTEMAC_SPS & LTE_TDD)
/* subframe offset values to be used when twoIntervalsConfig is enabled in UL
*/
typedef struct rgSchCmnSpsDlUeSchdInfo
{
- U8 scaledCqi; /*!< Assumed value of CQI for transmission */
- U16 actvSfTblIdx; /*!< Index into cell-wide DL SPS sub-frame
+ uint8_t scaledCqi; /*!< Assumed value of CQI for transmission */
+ uint16_t actvSfTblIdx; /*!< Index into cell-wide DL SPS sub-frame
table during activation */
CmLteTimingInfo schdKey; /*!< Key into the list of DL SPS active
UEs: next DL SPS ocassion */
RgSchDlRbAlloc spsAllocInfo; /*!< Allocation information for an SPS active
UE */
- U8 allocN1PucchIdx; /*!< Index value in UE's n1Pucch array
+ uint8_t allocN1PucchIdx; /*!< Index value in UE's n1Pucch array
of the allocated n1Pucch */
//Bool pdcchPndng; /*!< Indicates if the activaton/
// reactivation PDCCH needs to be sent
*/
typedef struct rgSchCmnDlUeSpsStatInfo
{
- U32 numSchedSPSRnti; /*!< Number of SPS occasions sched using SPS RNTI*/
- U32 totalSPSSchedOcc; /*!< Number of SPS occasions sched
+ uint32_t numSchedSPSRnti; /*!< Number of SPS occasions sched using SPS RNTI*/
+ uint32_t totalSPSSchedOcc; /*!< Number of SPS occasions sched
using SPS RNTI + CRNTI*/
- U32 numSpsReactv; /*!< Number of Reactivations */
- U32 numSpsActv; /*!< Number of activations */
- U32 numSpsRel; /*!< Number of Deactivations */
+ uint32_t numSpsReactv; /*!< Number of Reactivations */
+ uint32_t numSpsActv; /*!< Number of activations */
+ uint32_t numSpsRel; /*!< Number of Deactivations */
}RgSchCmnDlUeSpsStatInfo;
/**
UE */
CmLListCp *spsList; /*!< Pointer to the SPS list of which
UE is a part */
- U32 measGapMask[RG_SCH_CMN_SPS_DL_MEASGAP_32BITMASK_SIZE];
+ uint32_t measGapMask[RG_SCH_CMN_SPS_DL_MEASGAP_32BITMASK_SIZE];
/*!< Indicates the DL sub-frames with
ongoing measurement gap */
- U16 n1PucchIdx[RG_SCH_CMN_SPS_DL_MAX_N1PUCCH_IDX_PER_UE];
+ uint16_t n1PucchIdx[RG_SCH_CMN_SPS_DL_MAX_N1PUCCH_IDX_PER_UE];
/*!< N1Pucch indices configured for the UE */
- U8 actionPndng; /*!< Indicates the action pending on the UE
+ uint8_t actionPndng; /*!< Indicates the action pending on the UE
activation/re-activation/release */
- U8 dlSpsStatus; /*!< Indicates the current status of DL SPS */
- U8 prdIdx; /*!< DL SPS periodicity index for the
+ uint8_t dlSpsStatus; /*!< Indicates the current status of DL SPS */
+ uint8_t prdIdx; /*!< DL SPS periodicity index for the
configured peridicity */
RgSchCmnSpsDlUeSchdInfo dlSpsUeSchdInfo; /*!< Scheduled info for DL SPS
active UE */
in DCI formats 0/1/1A/1B/1D/2/2A.
For FDD, used to not repeat relPdcch
till the feddback is recieved */
- U8 numRelPdcchSent; /*!< Number of times RelPdcch has been sent. */
+ uint8_t numRelPdcchSent; /*!< Number of times RelPdcch has been sent. */
RgSchCmnDlUeSpsStatInfo statInfo; /*!< SPS Metric Info */
- U8 dynSchedCount; /*!< To track num of consecutive times SPS BO
+ uint8_t dynSchedCount; /*!< To track num of consecutive times SPS BO
is sched dynamically */
- U8 reducedBoCount; /*!< To track num of consecutive times BO
+ uint8_t reducedBoCount; /*!< To track num of consecutive times BO
is lesser than SPS BO */
- U32 maxChgdBo; /* !< The Maximum of BO which is different from the
+ uint32_t maxChgdBo; /* !< The Maximum of BO which is different from the
BO for which SPS has been activated */
- U32 spsSchedBo; /* !< BO for which SPS is activated */
+ uint32_t spsSchedBo; /* !< BO for which SPS is activated */
Bool isDynSched; /* !< BO is dynamically scheduled */
} RgSchCmnDlUeSpsInfo;
*/
typedef struct rgSchCmnSpsDlSf
{
- U32 rbsAlloc; /*!< Allocated BW for this subframe (in actual number of
+ uint32_t rbsAlloc; /*!< Allocated BW for this subframe (in actual number of
RBs) */
RgSchDlSfAllocInfo spsAllocInfo; /*!< Allocation information for SPS BW */
- U32 n1PucchMask[RG_SCH_CMN_SPS_DL_N1PUCCH_32BITMASK_SIZE];
+ uint32_t n1PucchMask[RG_SCH_CMN_SPS_DL_N1PUCCH_32BITMASK_SIZE];
/*!< N1Pucch allocation mask per Sub-frame */
- U8 numDlSpsActiveUes; /*!< number of DL SPS UEs that
+ uint8_t numDlSpsActiveUes; /*!< number of DL SPS UEs that
have been activated */
} RgSchCmnSpsDlSf;
typedef struct rgSchCmnSpsDlN1Pucch RgSchCmnSpsDlN1Pucch;
struct rgSchCmnSpsDlN1Pucch
{
- U16 idx; /*!< Index in the n1PucchLst */
- U16 n1PucchVal; /*!< Pucch Value corresponding to the index */
- U32 numUes; /*!< Count of UEs with this N1Pucch value configured */
- U16 next; /*!< Next available index */
+ uint16_t idx; /*!< Index in the n1PucchLst */
+ uint16_t n1PucchVal; /*!< Pucch Value corresponding to the index */
+ uint32_t numUes; /*!< Count of UEs with this N1Pucch value configured */
+ uint16_t next; /*!< Next available index */
};
/**
*/
typedef struct rgSchCmnSpsDlN1PucchDb
{
- U16 numFreeN1Pucch; /*!< Number of free n1Pucch values */
- U16 numInUseN1Pucch; /*!< Number of inUse n1Pucch values
+ uint16_t numFreeN1Pucch; /*!< Number of free n1Pucch values */
+ uint16_t numInUseN1Pucch; /*!< Number of inUse n1Pucch values
*/
RgSchCmnSpsDlN1Pucch *freeN1PucchStart; /*!< Start for free n1Pucch list */
RgSchCmnSpsDlN1Pucch *inUseN1PucchStart;/*!< Start for in-use n1Pucch list
for feedback for
Release PDCCH sent
*/
- U16 spsPrdLcmVal; /*!< LCM value for all configured
+ uint16_t spsPrdLcmVal; /*!< LCM value for all configured
SPS periodicities: maxVal = 640 for FDD
and (640 * 3) for TDD */
- U8 lcmIdx; /*!< Index value for computed LCM */
+ uint8_t lcmIdx; /*!< Index value for computed LCM */
RgSchCmnSpsDlSf *spsSfTbl; /*!< DL sub-frame information for the cell*/
RgSchCmnSpsDlN1PucchDb n1PucchDb; /*!< Database of configured n1Pucch values
*/
*/
typedef struct rgSchCmnSpsUlAlloc
{
- U8 sbStart; /*!< Starting subband of the alloc */
- U8 numSb; /*!< Num of subbands in the alloc */
+ uint8_t sbStart; /*!< Starting subband of the alloc */
+ uint8_t numSb; /*!< Num of subbands in the alloc */
} RgSchCmnSpsUlAlloc;
/**
*/
typedef struct rgSchCmnSpsUlSf
{
- U32 ulBwBitMask[RGSCH_SPS_ULBW_MASK_LEN]; /*!< Bitmask indicating the alloc/hole info
+ uint32_t ulBwBitMask[RGSCH_SPS_ULBW_MASK_LEN]; /*!< Bitmask indicating the alloc/hole info
for SPS BW. Bit set at position 'x'
indicates subband 'x' is occupied */
- U8 maskLen; /*!< Length of ulBwBitMask based on numSb */
- U8 numUlSpsActiveUes; /*!< Number of UL SPS Active UEs in this Subframe */
+ uint8_t maskLen; /*!< Length of ulBwBitMask based on numSb */
+ uint8_t numUlSpsActiveUes; /*!< Number of UL SPS Active UEs in this Subframe */
RgSchCmnSpsUlAlloc allocInfo; /*!< Info per SPS Allocation - Used to mark
previous allocations in a subframe */
} RgSchCmnSpsUlSf;
*/
typedef struct rgSchCmnUlCellSpsInfo
{
- U8 spsSbStart; /*!< Starting subband of SPS BW */
- U8 numSpsSb; /*!< number of subbands for SPS */
- U16 spsPrdLcmVal; /*!< LCM value for all configured UL
+ uint8_t spsSbStart; /*!< Starting subband of SPS BW */
+ uint8_t numSpsSb; /*!< number of subbands for SPS */
+ uint16_t spsPrdLcmVal; /*!< LCM value for all configured UL
SPS periodicities:maxVal = 640 for FDD
and (640 * 3) for TDD */
RgSchCmnSpsUlSf *spsSfLst; /*!< UL subframe information for the cell*/
*/
typedef struct rgSchCmnUlCellRa
{
- U8 prmblANumSb; /*!< Number of msg3 RBs to allocate for preamble A */
- U8 prmblAIMcs; /*!< Imcs for msg3 when preamble A was used */
- U8 prmblBNumSb; /*!< Number of msg3 RBs to allocate for preamble B */
- U8 prmblBIMcs; /*!< Imcs for msg3 when preamble B was used */
+ uint8_t prmblANumSb; /*!< Number of msg3 RBs to allocate for preamble A */
+ uint8_t prmblAIMcs; /*!< Imcs for msg3 when preamble A was used */
+ uint8_t prmblBNumSb; /*!< Number of msg3 RBs to allocate for preamble B */
+ uint8_t prmblBIMcs; /*!< Imcs for msg3 when preamble B was used */
} RgSchCmnUlCellRa;
typedef struct rgSchCmnCellClcITbs
{
- U8 iTbs2Rbs; /*!< iTbs value for 2 Rbs precomputed at cell cfg */
- U8 iTbs3Rbs; /*!< iTbs value for 3 Rbs precomputed at cell cfg */
+ uint8_t iTbs2Rbs; /*!< iTbs value for 2 Rbs precomputed at cell cfg */
+ uint8_t iTbs3Rbs; /*!< iTbs value for 3 Rbs precomputed at cell cfg */
}RgSchCmnCellClcITbs;
typedef struct rgSchCmnDlCell
{
Bool isDlFreqSel; /*!< Bool indicating if cell is frequency
selective or not */
- U8 maxUeNewTxPerTti; /*!< Max UEs to be considered for New Tx Alloc in DL */
- U8 numRaSubFrms; /*!< Number of frames of RA transmission */
- U8 iTbsCap; /*!< Max value DL iTbs capped to */
- U16 nCce; /*!< Number of CCEs computed based on CFI */
- U8 maxDlBwPerUe; /*!< Max DL B/W per UE */
- U8 maxDlRetxBw; /*!< Max DL retx B/W, as part of 256 */
- U8 maxUePerDlSf; /*!< Max UE to be considered for DL scheduling
+ uint8_t maxUeNewTxPerTti; /*!< Max UEs to be considered for New Tx Alloc in DL */
+ uint8_t numRaSubFrms; /*!< Number of frames of RA transmission */
+ uint8_t iTbsCap; /*!< Max value DL iTbs capped to */
+ uint16_t nCce; /*!< Number of CCEs computed based on CFI */
+ uint8_t maxDlBwPerUe; /*!< Max DL B/W per UE */
+ uint8_t maxDlRetxBw; /*!< Max DL retx B/W, as part of 256 */
+ uint8_t maxUePerDlSf; /*!< Max UE to be considered for DL scheduling
* in a TTI */
/*[ccpu00138609]-ADD- max Msg4/ DL CCCH UE configuration */
- U8 maxCcchPerDlSf; /*!< Max Msg4/DL CCCH UE sched in Dlsf */
- U8 msg4TxDelay; /*!< Max estimated time for HARQ tx
+ uint8_t maxCcchPerDlSf; /*!< Max Msg4/DL CCCH UE sched in Dlsf */
+ uint8_t msg4TxDelay; /*!< Max estimated time for HARQ tx
of msg4 based on the Harq RTT and
max Harq retries for msg4 */
RgSchCmnCellClcITbs cmnChITbs; /*!< iTbs value for 2 Rbs precomputed at cell cfg */
CmLteAggrLvl cmnChAggrLvl; /*!< Precomputed aggregation level for common channel */
- U8 ccchCqi; /*!< Default Cqi to be used for Msg4 and UE */
+ uint8_t ccchCqi; /*!< Default Cqi to be used for Msg4 and UE */
CmLListCp msg4RetxLst; /*!< Queue to hold Msg4 procs for retransmission */
/* Changes for CR timer */
#ifdef RGR_V1
/* cqi to Tbs tables for each 1 and 2 layer TbSz table */
/*!< CQI to efficiency translation */
Void *cqiToEffTbl[RGSCH_MAX_NUM_LYR_PERCW][RG_SCH_CMN_MAX_CFI];
- U8 newCfi; /*!< New CFI value */
- U8 currCfi; /*!< Current CFI value */
+ uint8_t newCfi; /*!< New CFI value */
+ uint8_t currCfi; /*!< Current CFI value */
- U16 noResPerRb[RG_SCH_CMN_MAX_CFI]; /*!< Num REs per RB */
+ uint16_t noResPerRb[RG_SCH_CMN_MAX_CFI]; /*!< Num REs per RB */
CmLteTimingInfo time; /*!< Timing info for current allocation */
Void *schSpfc; /*!< Scheduler Specific Cell DL dereferencing */
Void *dlfsCell; /*!< DLFS specific information per cell */
RgSchCmnDlCellSpsInfo dlSpsInfo; /*!< DL SPS info for the cell */
#endif
/* Member to store no. of Bits per RB */
- U32 bitsPerRb; /*!< Bits per RB calculated from
+ uint32_t bitsPerRb; /*!< Bits per RB calculated from
BcchPcchRaRsp Code rate configured through
RGR */
#ifdef LTE_TDD
- U16 numReDwPts[RG_SCH_CMN_MAX_CFI-1]; /*!< Num of RE in DwPTS RB */
- U8 splSfCfg; /*!<Stores the special subframe cfg */
+ uint16_t numReDwPts[RG_SCH_CMN_MAX_CFI-1]; /*!< Num of RE in DwPTS RB */
+ uint8_t splSfCfg; /*!<Stores the special subframe cfg */
#endif
/* ccpu00132314-ADD-Tx power offsets for Common PDSCH transmissions */
- U16 bcchTxPwrOffset; /*!< Tx Pwr Offset for BCCH tx on PDSCH.
+ uint16_t bcchTxPwrOffset; /*!< Tx Pwr Offset for BCCH tx on PDSCH.
Offset to the reference signal
power. Value: 0 -> 10000,
representing -6 dB to 4 dB in 0.001
dB steps */
- U16 pcchTxPwrOffset; /*!< Tx Pwr Offset for PCCH tx.
+ uint16_t pcchTxPwrOffset; /*!< Tx Pwr Offset for PCCH tx.
Offset to the reference signal
power. Value: 0 -> 10000,
representing -6 dB to 4 dB in 0.001
dB steps */
- U16 rarTxPwrOffset; /*!< Tx Pwr Offset for RAR tx.
+ uint16_t rarTxPwrOffset; /*!< Tx Pwr Offset for RAR tx.
Offset to the reference signal
power. Value: 0 -> 10000,
representing -6 dB to 4 dB in 0.001
dB steps */
/* ccpu00138898 - Added Tx pwr offset for PHICH Tx*/
- U16 phichTxPwrOffset; /*!< Tx Pwr Offset for PHICH tx.
+ uint16_t phichTxPwrOffset; /*!< Tx Pwr Offset for PHICH tx.
Offset to the reference signal
power. Value: 0 -> 10000,
representing -6 dB to 4 dB in 0.001
dB steps */
- U32 ncsgPrbCnt; /*!< Cumulative sum of PDSCH PRBs assigned to non-Csg UEs */
- U32 totPrbCnt; /*!< Cumulative sum of PDSCH PRBs assigned to all UEs */
+ uint32_t ncsgPrbCnt; /*!< Cumulative sum of PDSCH PRBs assigned to non-Csg UEs */
+ uint32_t totPrbCnt; /*!< Cumulative sum of PDSCH PRBs assigned to all UEs */
RgrUeDlPwrCntrlPaCfg msg4pAVal; /*!< Default value (Enum) of PA that is
used by Scheduler for msg4 */
#ifdef LTE_ADV
@brief Uplink Power control related information per cell. */
typedef struct rgSchCmnUlPwrCb
{
- U8 tpcPucchRntiCnt;/*!< Count of TPC-PUCCH-RNTIs for the cell */
+ uint8_t tpcPucchRntiCnt;/*!< Count of TPC-PUCCH-RNTIs for the cell */
RgSchCmnTpcRntiCb tpcPucchRntiLst[RG_SCH_CMN_MAX_NUM_TPC_PUCCH_RNTI];
/*!< List of TPC-PUCCH-RNTIs */
- U8 tpcPuschRntiCnt;/*!< Count of TPC-PUSCH-RNTIs for the cell */
+ uint8_t tpcPuschRntiCnt;/*!< Count of TPC-PUSCH-RNTIs for the cell */
RgSchCmnTpcRntiCb tpcPuschRntiLst[RG_SCH_CMN_MAX_NUM_TPC_PUSCH_RNTI];
/*!< List of TPC-PUSCH-RNTIs */
CmLListCp pucchGrpPwr; /*!< List of TPC-PUCCH-RNTIs for PUCCH group
CmLListCp puschGrpPwr; /*!< List of TPC-PUSCH-RNTIs for PUSCH group
power control: 'RgSchCmnTpcRntiCb' */
S8 pMax; /*!< Max allowed uplink power in cell */
- U8 trgUlCqi; /*!< Default target CQI */
+ uint8_t trgUlCqi; /*!< Default target CQI */
} RgSchCmnUlPwrCb;
/**
*/
typedef struct rgSchCmnUlCell
{
- U8 maxUeNewTxPerTti; /*!< Max UEs to be considered for New Tx Alloc in UL */
+ uint8_t maxUeNewTxPerTti; /*!< Max UEs to be considered for New Tx Alloc in UL */
/* Added new variable maxUlBwPerUe */
- U8 maxUlBwPerUe; /*!< Max UL BW per UE */
- U8 maxSbPerUe; /*!< Max subbands per UE */
- U8 dfltUlCqi; /*!< Default uplink CQI assumed intitially */
- U8 max16qamCqi; /*!< Highest CQI supporting 16 QAM */
- U8 maxUlSpsCqi; /*!< Highest CQI supporting 16 QAM */
- U8 iTbsCap; /*!< Max value UL iTbs capped to */
- U8 sbSize; /*!< Subband size */
- U8 dmrsArrSize; /*!< DMRS array size */
- U8 *dmrsArr; /*!< DMRS array */
+ uint8_t maxUlBwPerUe; /*!< Max UL BW per UE */
+ uint8_t maxSbPerUe; /*!< Max subbands per UE */
+ uint8_t dfltUlCqi; /*!< Default uplink CQI assumed intitially */
+ uint8_t max16qamCqi; /*!< Highest CQI supporting 16 QAM */
+ uint8_t maxUlSpsCqi; /*!< Highest CQI supporting 16 QAM */
+ uint8_t iTbsCap; /*!< Max value UL iTbs capped to */
+ uint8_t sbSize; /*!< Subband size */
+ uint8_t dmrsArrSize; /*!< DMRS array size */
+ uint8_t *dmrsArr; /*!< DMRS array */
RgSchCmnUlCellRa ra; /*!< RA related info */
- U8 idx; /*!< Current subframe - maps to HARQ process ID */
- U8 schdIdx; /*!< Subframe to schedule for */
- U8 schdHqProcIdx; /*!< Proc to schedule for */
- U8 msg3SchdIdx; /*!< Subframe to schedule for msg3 */
+ uint8_t idx; /*!< Current subframe - maps to HARQ process ID */
+ uint8_t schdIdx; /*!< Subframe to schedule for */
+ uint8_t schdHqProcIdx; /*!< Proc to schedule for */
+ uint8_t msg3SchdIdx; /*!< Subframe to schedule for msg3 */
#ifdef EMTC_ENABLE
RgSchCmnUlCellRa emtcRa; /*!< RA related info */
- U8 emtcMsg3SchdIdx;
+ uint8_t emtcMsg3SchdIdx;
Void *schSpfcEmtc; /*!< Scheduler Specific Cell UL dereferencing */
#endif
- U8 msg3SchdHqProcIdx;/*!< Proc to schedule for */
- U8 rcpReqIdx; /*!< Subframe to send reception req for */
+ uint8_t msg3SchdHqProcIdx;/*!< Proc to schedule for */
+ uint8_t rcpReqIdx; /*!< Subframe to send reception req for */
/* ccpu00130688 -MOD- for config-0 changes */
- U8 hqFdbkIdx[2]; /*!< In FDD only Idx 0 is used.
+ uint8_t hqFdbkIdx[2]; /*!< In FDD only Idx 0 is used.
In TDD n+k value is updated at idx 0.
For TDD Cfg 0 both indices are used */
- U8 reTxIdx[2]; /*!< Retransmission Index corresponding to
+ uint8_t reTxIdx[2]; /*!< Retransmission Index corresponding to
the hqFdbkIdx */
#ifdef LTEMAC_SPS
- U8 spsUlRsrvIdx; /*!< Subframe to reserve UL SPS cfgd grant */
- U8 spsUlRsrvHqProcIdx;/*!< Proc for the cfgd UL SPS grant */
+ uint8_t spsUlRsrvIdx; /*!< Subframe to reserve UL SPS cfgd grant */
+ uint8_t spsUlRsrvHqProcIdx;/*!< Proc for the cfgd UL SPS grant */
#endif
CmLteTimingInfo schdTime;
#ifdef LTE_TDD
- U8 numUlSubfrms; /*!< Number of UL subframes */
+ uint8_t numUlSubfrms; /*!< Number of UL subframes */
RgSchUlSf *ulSfArr; /*!< no msg3 alloc info here */
#else
RgSchUlSf ulSfArr[RG_SCH_CMN_UL_NUM_SF]; /*!< no msg3 alloc info here */
#endif
Void *schSpfc; /*!< Scheduler Specific Cell UL dereferencing */
RgSchCmnUlPwrCb ulPwrCb; /*!< Uplink power control block */
- U8 ulNumRePerRb; /*!< Number of REs per RB in UL */
+ uint8_t ulNumRePerRb; /*!< Number of REs per RB in UL */
/* Added support for non-adaptive retransmission in uplink */
- U8 maxAllocPerUlSf; /*!< Max Allocations in a given SF */
+ uint8_t maxAllocPerUlSf; /*!< Max Allocations in a given SF */
#ifdef RGR_V1
/* Added a param to limit msg3 allocations */
- U8 maxMsg3PerUlSf; /*!< Max msg3 alocs in a given SF */
+ uint8_t maxMsg3PerUlSf; /*!< Max msg3 alocs in a given SF */
#endif
#ifdef LTEMAC_SPS
RgSchCmnUlCellSpsInfo ulSpsInfo; /*!< UL SPS info for the cell */
- U16 schdTti; /*< 0..1023, corresponding to scheduling time,
+ uint16_t schdTti; /*< 0..1023, corresponding to scheduling time,
* can theoretically used for non-SPS
* purposes as well */
#endif
- U32 ncsgPrbCnt; /*!< Cumulative sum of PDSCH PRBs assigned to non-Csg UEs */
- U32 totPrbCnt; /*!< Cumulative sum of PDSCH PRBs assigned to all UEs */
+ uint32_t ncsgPrbCnt; /*!< Cumulative sum of PDSCH PRBs assigned to non-Csg UEs */
+ uint32_t totPrbCnt; /*!< Cumulative sum of PDSCH PRBs assigned to all UEs */
CmLListCp reTxLst; /*!< Retransmission List*/
} RgSchCmnUlCell;
* common scheduler specific information for rapId to UE mapping. */
typedef struct rgSchCmnRapIdMap
{
- U8 rapId;
+ uint8_t rapId;
CmLListCp assgndUes; /*!< List of UEs for which this rapId is
assigned. */
} RgSchCmnRapIdMap;
* common scheduler specific information for RACH Dedicated Preambles. */
typedef struct rgSchCmnRachCfg
{
- U8 numDedPrm; /*!< number of configured dedicated prmbls */
- U8 dedPrmStart; /*!< starting rapId Number */
- U8 remDedPrm; /*!< remaining number of ded Prm available
+ uint8_t numDedPrm; /*!< number of configured dedicated prmbls */
+ uint8_t dedPrmStart; /*!< starting rapId Number */
+ uint8_t remDedPrm; /*!< remaining number of ded Prm available
for the "applFrm" */
CmLteTimingInfo applFrm; /*!< Frame under consideration for dedPrm
distribution */
- U8 prachMskIndx;/*!< Prach Mask Idx corresponding to
+ uint8_t prachMskIndx;/*!< Prach Mask Idx corresponding to
applFrm*/
RgSchCmnRapIdMap rapIdMap[RG_SCH_MAX_DED_PRMBLS]; /*!< mapping of RapId
* to assigned UEs */
Bool isAccumulated; /*!< Indicates if power is accumulative or not */
Bool deltaMcsEnbld; /*!< Indicates if coding effeciency is
* considered or not for PUSCH power computation */
- U8 pucchIdx; /*!< Index for TPC-PUCCH-RNTI */
- U8 puschIdx; /*!< Index for TPC-PUSCH-RNTI */
- U8 isPhrAvail; /*!< Indicates if PHR is recieved */
+ uint8_t pucchIdx; /*!< Index for TPC-PUCCH-RNTI */
+ uint8_t puschIdx; /*!< Index for TPC-PUSCH-RNTI */
+ uint8_t isPhrAvail; /*!< Indicates if PHR is recieved */
S8 phVal; /*!< Power headroom value in dB */
S8 pwrPerRb; /*!< UL power computed per RB */
S8 maxUePwr; /*!< Maximum power with which UE can transmit */
- U8 maxUlRbs; /*!< Maximum number of UL Rbs for UL scheduling */
+ uint8_t maxUlRbs; /*!< Maximum number of UL Rbs for UL scheduling */
S8 delta; /*!< Delta corresponding to TPC, for PUSCH */
- U8 numRb; /*!< Number of RBs used in last allocation */
+ uint8_t numRb; /*!< Number of RBs used in last allocation */
S8 remPuschPwr; /*!< PUSCH power remaining to be adjusted
(in db) */ /* chk if needed */
S8 remPucchPwr; /*!< PUCCH Power remaining to be adjusted (in db) */
- U8 pucchTpc; /*!< TPC to be used for PUCCH power control */
- U8 puschTpc; /*!< TPC to be used for PUSCH power control */
- U8 trgCqi; /*!< Target CQI */
+ uint8_t pucchTpc; /*!< TPC to be used for PUCCH power control */
+ uint8_t puschTpc; /*!< TPC to be used for PUSCH power control */
+ uint8_t trgCqi; /*!< Target CQI */
RgSchCmnTpcRntiCb *tpcPucchRntiCb; /*!< Pointer to tpcPucchRntiCb for the UE */
CmLList pucchGrpLnk; /*!< To link together UEs in
* RgSchCmnTpcRntiCb */
struct rgSchCmnUeUlAlloc
{
/* Request */
- U32 reqBytes; /*!< Requested bytes */
+ uint32_t reqBytes; /*!< Requested bytes */
/* Allocation to be filled by UL RB allocator module */
- U32 allocdBytes; /*!< Allocated bytes */
+ uint32_t allocdBytes; /*!< Allocated bytes */
RgSchUlAlloc *alloc; /*!< Alloc assgnd by Allocator */
CmLList reqLnk; /*!< To link UL Tx UEs */
CmLList schdLstLnk; /*!< To link scheduled/non-scheduled UL UEs */
typedef struct rgSchCmnAllocRecord
{
- U32 alloc; /* allocation amount */
+ uint32_t alloc; /* allocation amount */
CmLteTimingInfo allocTime; /* Time at which allocation made */
CmLList lnk; /* To link in ulAllocLst */
- U8 numRb; /* Number of RBs */
- U8 cqi; /* CQI assumed for allocation */
- U8 tpc; /* TPC */
+ uint8_t numRb; /* Number of RBs */
+ uint8_t cqi; /* CQI assumed for allocation */
+ uint8_t tpc; /* TPC */
}RgSchCmnAllocRecord;
typedef struct ueUlLaCb
{
S32 deltaiTbs;
- U32 iTbsUpperCap;
+ uint32_t iTbsUpperCap;
S32 cqiBasediTbs;
Bool lastiTbsIgnored;
} UeUlLaCb;
*/
typedef struct rgSchCmnUlUe
{
- U8 maxUlCqi; /*!< CQI for which no better Imcs can be granted */
- U8 crntUlCqi[RG_SCH_MAX_UL_TX_ANT]; /*!< Current CQI */
+ uint8_t maxUlCqi; /*!< CQI for which no better Imcs can be granted */
+ uint8_t crntUlCqi[RG_SCH_MAX_UL_TX_ANT]; /*!< Current CQI */
/* Added changes of TFU_UPGRADE */
#ifdef TFU_UPGRADE
- U8 validUlCqi;
+ uint8_t validUlCqi;
#endif
- U8 lastCfi; /* last CFI, updated in case of SPS */
+ uint8_t lastCfi; /* last CFI, updated in case of SPS */
CmLListCp ulAllocLst; /*!< To track the outstanding Allocations
* node type RgSchCmnAllocRecord */
RgSchCmnUeUlPwrCb ulPwrCb; /*!< Uplink power control block */
RgSchCmnUeUlAlloc alloc; /*!< Allocation info */
#ifdef SCH_STATS
- U32 schedOccns; /*!< Number of scheduling occassions in a refresh period */
- U32 schedRetxOccns;
- U32 avgCqi; /*!< AvgCqi in a refresh period */
- U32 numCqiOccns;
- U32 prbAlloc;
+ uint32_t schedOccns; /*!< Number of scheduling occassions in a refresh period */
+ uint32_t schedRetxOccns;
+ uint32_t avgCqi; /*!< AvgCqi in a refresh period */
+ uint32_t numCqiOccns;
+ uint32_t prbAlloc;
#endif
#ifdef UL_LA
UeUlLaCb ulLaCb; /*!< Uplink LA structure */
#endif
RgUeUlHqCb hqEnt; /*!< Uplink HARQ information for the UE */
- U8 subbandShare; /*!< New variable added to store the number
+ uint8_t subbandShare; /*!< New variable added to store the number
* of subbands alowed for this UE */
- U32 subbandRequired; /*!< Number of subbands required to
+ uint32_t subbandRequired; /*!< Number of subbands required to
* serve the total BO */
CmLList ulSchedLnk; /*!< To link UE UL Cb to toBeSchedList */
#ifdef EMTC_ENABLE
RgSchUlHqProcCb *tempProc; /*!< To identify UE is serverd for Retx */
#endif
#ifdef RG_5GTF
- U8 vrbgRequired;
- U8 vrbgAllocated;
+ uint8_t vrbgRequired;
+ uint8_t vrbgAllocated;
#endif
} RgSchCmnUlUe;
CmLList hoLnk; /*!< To link UE to HandOver UE lst */
CmLList rapIdLnk; /*!< Link to the list assgndUes */
CmLteTimingInfo asgnOppr; /*!< PRACH oppurtunity time assgined to UE */
- U8 hoRapId; /*!< RAPID assigned to UE for HandOver */
- U8 poRapId; /*!< RAPID assigned to UE for PdcchOrder */
+ uint8_t hoRapId; /*!< RAPID assigned to UE for HandOver */
+ uint8_t poRapId; /*!< RAPID assigned to UE for PdcchOrder */
}RgSchCmnDlUeRachInfo;
*/
typedef struct rgSchCmnDlUeCwInfo
{
- U8 cqi; /*!< CQI reported for this CW */
- U8 iTbs[2]; /*!< [0]ITBS for CW for 1 Layer,
+ uint8_t cqi; /*!< CQI reported for this CW */
+ uint8_t iTbs[2]; /*!< [0]ITBS for CW for 1 Layer,
corresponding to this CW's cqi. */
/*!< [1]ITBS for CW for 2 Layer,
corresponding to this CW's cqi. */
- U32 eff[2]; /*!< [0]eff for CW for 1 Layer,
+ uint32_t eff[2]; /*!< [0]eff for CW for 1 Layer,
corresponding to this CW's cqi. */
/*!< [1]eff for CW for 2 Layer,
corresponding to this CW's cqi. */
- U8 noLyr; /*!< No. of layers this CW shall be using
+ uint8_t noLyr; /*!< No. of layers this CW shall be using
* for transmission */
- U16 dtxCnt;
- U16 ackCnt;
- U16 nackCnt;
+ uint16_t dtxCnt;
+ uint16_t ackCnt;
+ uint16_t nackCnt;
}RgSchCmnDlUeCwInfo;
/**
* @brief UE cmn scheduler specific MIMO Info.
typedef struct rgSchCmnUeMimoInfo
{
RgSchCmnDlUeCwInfo cwInfo[RG_SCH_CMN_MAX_CW_PER_UE];/*!< Codeword related feddback Information */
- U8 ri; /*!< Maximum allowable number of TX layers for SM */
- U8 pmi; /*!< Precoding matrix indicator(if any) */
- U8 btrCwIdx; /*!< Index of a better(efficient) CW (0 or 1) */
- U8 forceTD; /*!< Flag to indicate transmission scheme as TD
+ uint8_t ri; /*!< Maximum allowable number of TX layers for SM */
+ uint8_t pmi; /*!< Precoding matrix indicator(if any) */
+ uint8_t btrCwIdx; /*!< Index of a better(efficient) CW (0 or 1) */
+ uint8_t forceTD; /*!< Flag to indicate transmission scheme as TD
* beyond any other consideration */
}RgSchCmnUeMimoInfo;
typedef struct ueLaCb {
S32 deltaiTbs;
- U32 iTbsUpperCap;
+ uint32_t iTbsUpperCap;
S32 cqiBasediTbs;
Bool lastiTbsIgnored;
- U8 notFirstCqi;
- U8 numLastiTbsIgnored;
+ uint8_t notFirstCqi;
+ uint8_t numLastiTbsIgnored;
} UeLaCb;
/**
*/
typedef struct rgSchCmnDlUe
{
- U32 maxSbSz; /*!< Max soft channel bits per Hq proc per TTI */
- U32 maxTbSz; /*!< Max DLSCH TB bits per TB per TTI */
- U8 maxRb; /*!< updated based on SoftBuffer Limitation and MaxDlBwPerUE */
- U32 maxTbBits;/*!< Max Transport Block Bits this UE can receive per TTI*/
+ uint32_t maxSbSz; /*!< Max soft channel bits per Hq proc per TTI */
+ uint32_t maxTbSz; /*!< Max DLSCH TB bits per TB per TTI */
+ uint8_t maxRb; /*!< updated based on SoftBuffer Limitation and MaxDlBwPerUE */
+ uint32_t maxTbBits;/*!< Max Transport Block Bits this UE can receive per TTI*/
RgSchCmnUeMimoInfo mimoInfo; /*!< UE cmn scheduler specific MIMO Info */
RgSchDlHqProcCb *proc; /*!< Proc which is picked for Trans for this Subfrm,"dlSf" */
Void *schSpfc; /*!< scheduler specific UE DL Info */
Void *dlfsUe; /*!< DLFS Specific information */
- U32 outStndAlloc; /*!< UEs outstanding allocation, for a given TTI.
+ uint32_t outStndAlloc; /*!< UEs outstanding allocation, for a given TTI.
* valid for a single scheduling index */
RgSchCmnDlUeRachInfo rachInfo; /*!< Ue specific RACH HO Info */
#ifdef LTEMAC_SPS
RgSchCmnDlUeSpsInfo dlSpsInfo;/*!< DL SPS information for the UE */
#endif
#if defined(SCH_STATS) || defined(TENB_STATS)
- U32 schedOccns;
- U32 currPdbLvl;
- U32 prevOccnLvlUpd;
- /* U32 schedRetxOccns;
- U32 prbAlloc;*/
+ uint32_t schedOccns;
+ uint32_t currPdbLvl;
+ uint32_t prevOccnLvlUpd;
+ /* uint32_t schedRetxOccns;
+ uint32_t prbAlloc;*/
#endif
#ifdef SCH_STATS
- U32 schedRetxOccns;
- U32 avgCqi;
- U32 numCqiOccns;
- U32 numRi1;
- U32 numRi2;
- U32 boReported;
- U32 prbAlloc;
- U32 remAmbrForStats;
+ uint32_t schedRetxOccns;
+ uint32_t avgCqi;
+ uint32_t numCqiOccns;
+ uint32_t numRi1;
+ uint32_t numRi2;
+ uint32_t boReported;
+ uint32_t prbAlloc;
+ uint32_t remAmbrForStats;
#endif
UeLaCb laCb[RG_SCH_CMN_MAX_CW_PER_UE];
- U8 cqiFlag;
- U8 lastCfi;
+ uint8_t cqiFlag;
+ uint8_t lastCfi;
#ifdef RG_5GTF
- U8 vrbgRequired;
- U8 vrbgAllocated;
+ uint8_t vrbgRequired;
+ uint8_t vrbgAllocated;
#endif
} RgSchCmnDlUe;
*/
typedef struct rgSchCmnUeInfo
{
- U8 ueCat; /*!< UE category */
+ uint8_t ueCat; /*!< UE category */
CmTimer tmr;
} RgSchCmnUeInfo;
/**
typedef struct rgSchCmnLcg
{
- U32 bs; /*!< Effective Buffer Status */
- U32 cfgdGbr; /*!< Configured GBR */
- U32 effGbr; /*!< Effective GBR */
- U32 deltaMbr; /*!< Configured MBR in excess of configured GBR */
- U32 effDeltaMbr; /*!< Effective MBR */
- U32 reportedBs; /*!< Latest Buffer Status */
+ uint32_t bs; /*!< Effective Buffer Status */
+ uint32_t cfgdGbr; /*!< Configured GBR */
+ uint32_t effGbr; /*!< Effective GBR */
+ uint32_t deltaMbr; /*!< Configured MBR in excess of configured GBR */
+ uint32_t effDeltaMbr; /*!< Effective MBR */
+ uint32_t reportedBs; /*!< Latest Buffer Status */
Void *schSpfc;
}RgSchCmnLcg;
typedef struct rgSchCmnDlSvcSpsInfo
{
CmLList toBeSchdSvcEnt; /*!< Linked list entity for toBeSchdSvcs lst */
- U16 zeroBoOcassionCnt; /*!< Number of contiguous SPS ocassions for
+ uint16_t zeroBoOcassionCnt; /*!< Number of contiguous SPS ocassions for
which BO=0 */
- U32 effSpsBo; /*!< Effective BO of the SPS service */
- U32 bytesReq; /*!< Bytes Requested for this SPS service */
- U8 hdrEst; /*!< Header estimate for SPS service */
+ uint32_t effSpsBo; /*!< Effective BO of the SPS service */
+ uint32_t bytesReq; /*!< Bytes Requested for this SPS service */
+ uint8_t hdrEst; /*!< Header estimate for SPS service */
} RgSchCmnDlSvcSpsInfo;
#endif
typedef struct rgSchCmnDlSvc {
- U8 qci; /*!< Prio computed against Qci */
- U8 prio; /*!< Prio computed against Qci */
- U32 gbr; /*!< scaled GBR as per Refresh time resolution */
- U32 mbr; /*!< scaled MBR as per Refresh time resolution */
+ uint8_t qci; /*!< Prio computed against Qci */
+ uint8_t prio; /*!< Prio computed against Qci */
+ uint32_t gbr; /*!< scaled GBR as per Refresh time resolution */
+ uint32_t mbr; /*!< scaled MBR as per Refresh time resolution */
Void *schSpfc[CM_LTE_MAX_CELLS];/*!< Scheduler specific Info */
#ifdef LTEMAC_SPS
RgSchCmnDlSvcSpsInfo dlSvcSpsInfo; /*!< SPS related information for DL
typedef struct rgSchCmnDlHqProc {
CmLList retxLnk; /*!< To link retransmitting HARQ processes in cell */
- U32 totBytes;/*!< This maintains total allocation */
+ uint32_t totBytes;/*!< This maintains total allocation */
#ifdef LTEMAC_SPS
Bool isSpsSvcSchd;/*!< Indicates if this HARQ process is having SPS
service scheduled: TRUE for SPS and non-SPS
Bool isSpsActv; /*!< Indicates if this HARQ proc
is in-use for SPS transmission: TRUE only for
SPS ocassions */
- U8 spsAction; /*!< SPS action associated with this HARQ proc:
+ uint8_t spsAction; /*!< SPS action associated with this HARQ proc:
activation/reactivation */
CmLteTimingInfo maxRetxTime; /*!< Maximum retransmission time for SPS HARQ
proc */
*---------------------------*/
/* Inappropriate name of CQI to ITbs table for DL. */
-typedef U8 RgSchCmnCqiToTbs[16];
+typedef uint8_t RgSchCmnCqiToTbs[16];
/* The following data type is used to store computed efficiency */
/* for each MCS and consequently, will be used to derive MCS */
/* for a CQI. The last row is used for storing the average */
-typedef U32 RgSchCmnTbSzEff[RG_SCH_CMN_NUM_TBS];
+typedef uint32_t RgSchCmnTbSzEff[RG_SCH_CMN_NUM_TBS];
/* Inappropriate name of CQI to ITbs table for DL. */
/* Changes for MIMO feature addition */
EXTERN Bool rgSchIsN1PucchResAvail ARGS((
CmLListCp *lst,
RgSchUeCb *ue,
- U8 n1Idx,
- U8 resCount
+ uint8_t n1Idx,
+ uint8_t resCount
));
EXTERN Bool rgSchIsN3PucchResAvail ARGS((
CmLListCp *lst,
RgSchUeCb *ue,
- U8 n1Idx
+ uint8_t n1Idx
));
EXTERN S16 rgSchGetAvlTpcIdx ARGS((
RgSchUeCb *ue,
- U8 *tpcIdx,
+ uint8_t *tpcIdx,
RgSchDlSf *dlsf,
RgSchCellCb *cell
));
EXTERN Void rgSCHSCellDelUeSCell ARGS((
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
- U8 sCellIdx
+ uint8_t sCellIdx
));
EXTERN S16 rgSCHCmnRgrSCellUeDel ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteLcId lcId,
-U8 lcgId
+uint8_t lcgId
));
EXTERN S16 rgSCHCmnRgrLchRecfg ARGS((
RgSchCellCb *cell,
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *ulLcg,
-U8 bsr,
+uint8_t bsr,
RgSchErrInfo *err
));
EXTERN S16 rgSCHCmnUpdBsrTrunc ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *ulLcg,
-U8 bsr,
+uint8_t bsr,
RgSchErrInfo *err
));
EXTERN S16 rgSCHCmnUpdBsrLong ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 bsArr[],
+uint8_t bsArr[],
RgSchErrInfo *err
));
EXTERN S16 rgSCHCmnDataRcvd ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numLc,
+uint8_t numLc,
RgSchUlLcCb *lcArr[],
-U16 bytesArr[],
+uint16_t bytesArr[],
RgSchErrInfo *err
));
EXTERN Void rgSCHCmnUlCqiInd ARGS((
EXTERN S16 rgSCHCmnUpdPhr ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 phr,
+uint8_t phr,
RgSchErrInfo *err
));
EXTERN S16 rgSCHCmnUpdUlHqProc ARGS((
));
EXTERN RgSchUlAlloc *rgSCHCmnFirstHqFdbkAlloc ARGS((
RgSchCellCb *cell,
-U8 idx
+uint8_t idx
));
EXTERN RgSchUlAlloc *rgSCHCmnNextHqFdbkAlloc ARGS((
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
-U8 idx
+uint8_t idx
));
EXTERN Void rgSCHCmnDlDedBoUpd ARGS((
RgSchCellCb *cell,
));
EXTERN RgSchUlAlloc *rgSCHCmnUlSbAlloc ARGS((
RgSchUlSf *sf,
-U8 numSb,
+uint8_t numSb,
RgSchUlHole *hole
));
EXTERN Void rgSCHCmnRlsUlSf ARGS((
RgSchCellCb *cell,
-U8 idx
+uint8_t idx
));
/* PHR handling for MSG3 */
EXTERN Void rgSCHCmnFillHqPTb ARGS((
RgSchCellCb *cell,
RgSchDlRbAlloc *rbAllocInfo,
-U8 tbAllocIdx,
+uint8_t tbAllocIdx,
RgSchPdcch *pdcch
));
Bool isAck
));
EXTERN Void rgSCHCmnDlGetRbgInfo ARGS((
-U8 dlTotalBw,
-U8 dlSubsetBw,
-U8 maxRaType1SubsetBw,
-U8 rbgSize,
+uint8_t dlTotalBw,
+uint8_t dlSubsetBw,
+uint8_t maxRaType1SubsetBw,
+uint8_t rbgSize,
RgSchBwRbgInfo *rbgInfo
));
-EXTERN U8 rgSCHCmnDlRaType0Alloc ARGS((
+EXTERN uint8_t rgSCHCmnDlRaType0Alloc ARGS((
RgSchDlSfAllocInfo *allocedInfo,
-U8 rbsReq,
+uint8_t rbsReq,
RgSchBwRbgInfo *rbgInfo,
-U8 *numAllocRbs,
+uint8_t *numAllocRbs,
RgSchDlSfAllocInfo *resAllocInfo,
Bool isPartialAlloc
));
#ifdef RGSCH_SPS_UNUSED
-EXTERN U8 rgSCHCmnDlRaType1Alloc ARGS((
+EXTERN uint8_t rgSCHCmnDlRaType1Alloc ARGS((
RgSchDlSfAllocInfo *allocedInfo,
-U8 rbsReq,
+uint8_t rbsReq,
RgSchBwRbgInfo *rbgInfo,
-U8 startRbgSubset,
-U8 *allocRbgSubset,
+uint8_t startRbgSubset,
+uint8_t *allocRbgSubset,
RgSchDlSfAllocInfo *resAllocInfo,
Bool isPartialAlloc
));
#endif
-EXTERN U8 rgSCHCmnDlRaType2Alloc ARGS((
+EXTERN uint8_t rgSCHCmnDlRaType2Alloc ARGS((
RgSchDlSfAllocInfo *allocedInfo,
-U8 rbsReq,
+uint8_t rbsReq,
RgSchBwRbgInfo *rbgInfo,
-U8 *rbStart,
+uint8_t *rbStart,
RgSchDlSfAllocInfo *resAllocInfo,
Bool isPartialAlloc
));
EXTERN Void rgSCHCmnDrxStrtInActvTmrInUl ARGS((RgSchCellCb *cell));
EXTERN Void rgSCHCmnUpdUeDataIndLcg ARGS((RgSchCellCb *cell, RgSchUeCb *ue, RgInfUeDatInd *datInd));
#ifdef LTE_TDD
-EXTERN U8 rgSCHCmnGetPhichUlSfIdx ARGS((CmLteTimingInfo *timeInfo, RgSchCellCb *cell));
-EXTERN U8 rgSCHCmnGetUlSfIdx ARGS((CmLteTimingInfo *timeInfo, RgSchCellCb *cell));
-EXTERN U8 rgSCHCmnGetPValFrmCCE ARGS((RgSchCellCb *cell, U8 cce));
+EXTERN uint8_t rgSCHCmnGetPhichUlSfIdx ARGS((CmLteTimingInfo *timeInfo, RgSchCellCb *cell));
+EXTERN uint8_t rgSCHCmnGetUlSfIdx ARGS((CmLteTimingInfo *timeInfo, RgSchCellCb *cell));
+EXTERN uint8_t rgSCHCmnGetPValFrmCCE ARGS((RgSchCellCb *cell, uint8_t cce));
#endif
-EXTERN U8 rgSCHCmnGetUlHqProcIdx ARGS((CmLteTimingInfo *timeInfo, RgSchCellCb *cell));
+EXTERN uint8_t rgSCHCmnGetUlHqProcIdx ARGS((CmLteTimingInfo *timeInfo, RgSchCellCb *cell));
EXTERN Void rgSchCmnSetCqiReqField ARGS((
RgSchUeCellInfo *cellInfo,
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlSf *subFrm,
-U8 cqi,
+uint8_t cqi,
TfuDciFormat dciFrmt,
Bool isDtx
));
EXTERN Void rgSCHCmnRdcImcsTxTb ARGS((
RgSchDlRbAlloc *allocInfo,
-U8 tbInfoIdx,
-U32 cnsmdBytes
+uint8_t tbInfoIdx,
+uint32_t cnsmdBytes
));
EXTERN Void rgSCHCmnFillPdcch ARGS((
RgSchCellCb *cell,
RgSchPdcch *pdcch,
RgSchDlRbAlloc *rbAllocInfo
));
-EXTERN U8 rgSCHCmnUpdDai ARGS((
+EXTERN uint8_t rgSCHCmnUpdDai ARGS((
RgSchUeCb *ue,
CmLteTimingInfo *fdbkTime,
-U8 m,
+uint8_t m,
Bool havePdcch,
RgSchDlHqProcCb *hqP,
-U8 *ulDai
+uint8_t *ulDai
));
EXTERN Void rgSCHCmnFillHqPPdcch ARGS((
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc,
-U32 *bo,
-U8 *iTbs,
-U32 *maxRb
+uint32_t *bo,
+uint8_t *iTbs,
+uint32_t *maxRb
));
EXTERN S16 rgSCHCmnDlDedAlloc ARGS((
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
RgSchDlHqProcCb *proc,
-U32 bo,
-U8 iTbs,
-U32 maxRb,
-U32 *bytes
+uint32_t bo,
+uint8_t iTbs,
+uint32_t maxRb,
+uint32_t *bytes
));
EXTERN Void rgSCHCmnUlUeFillAllocInfo ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue
));
/* Fixing incorrect Imcs derivation */
-EXTERN U8 rgSCHCmnUlGetITbsFrmIMcs ARGS((
-U8 iMcs
+EXTERN uint8_t rgSCHCmnUlGetITbsFrmIMcs ARGS((
+uint8_t iMcs
));
/* Adding ueCtg to argument list */
-EXTERN U8 rgSCHCmnUlGetIMcsFrmITbs ARGS((
-U8 iTbs,
+EXTERN uint8_t rgSCHCmnUlGetIMcsFrmITbs ARGS((
+uint8_t iTbs,
CmLteUeCategory ueCtg
));
-EXTERN U32 rgSCHCmnUlMinTbBitsForITbs ARGS((
+EXTERN uint32_t rgSCHCmnUlMinTbBitsForITbs ARGS((
RgSchCmnUlCell *cellUl,
-U8 iTbs
+uint8_t iTbs
));
-EXTERN U8 rgSCHCmnUlGetITbs ARGS((
+EXTERN uint8_t rgSCHCmnUlGetITbs ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
Bool isEcp
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchUeCb *ue,
-U32 bo,
-U32 *effBo,
+uint32_t bo,
+uint32_t *effBo,
RgSchDlHqProcCb *proc,
RgSchCmnDlRbAllocInfo *cellWdAllocInfo
));
#ifdef LTEMAC_SPS
EXTERN Void rgSCHCmnClcRbAlloc ARGS((
RgSchCellCb *cell,
-U32 bo,
-U8 cqi,
-U8 *rb,
-U32 *tbs,
-U8 *mcs,
-U8 *iTbs,
+uint32_t bo,
+uint8_t cqi,
+uint8_t *rb,
+uint32_t *tbs,
+uint8_t *mcs,
+uint8_t *iTbs,
Bool isSpsBo,
RgSchDlSf *sf
));
-U32 rgSCHCmnCalcRiv ARGS((
-U8 bw,
-U8 rbStart,
-U8 numRb
+uint32_t rgSCHCmnCalcRiv ARGS((
+uint8_t bw,
+uint8_t rbStart,
+uint8_t numRb
));
#endif /* LTEMAC_SPS */
EXTERN Void rgSCHCmnUlUpdOutStndAlloc ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 alloc
+uint32_t alloc
));
EXTERN Void rgSCHCmnUlRecordUeAlloc ARGS((
/* APIs exposed by common power module */
EXTERN Void rgSCHPwrInit ARGS((
Void));
-EXTERN U8 rgSCHPwrPuschTpcForUe ARGS((
+EXTERN uint8_t rgSCHPwrPuschTpcForUe ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue));
-EXTERN U8 rgSCHPwrGetMaxUlRb ARGS((
+EXTERN uint8_t rgSCHPwrGetMaxUlRb ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue));
-EXTERN U8 rgSCHPwrPucchTpcForUe ARGS((
+EXTERN uint8_t rgSCHPwrPucchTpcForUe ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue));
EXTERN Void rgSCHPwrGrpCntrlPucch ARGS((
EXTERN Void rgSCHPwrUpdPhr ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
- U8 phr,
+ uint8_t phr,
RgSchCmnAllocRecord *allocInfo,
S8 maxUePwr));
EXTERN Void rgSCHPwrUlCqiInd ARGS((
EXTERN Void rgSCHPwrRecordRbAlloc ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
- U8 numRb
+ uint8_t numRb
));
EXTERN S16 rgSCHPwrCellCfg ARGS((
RgSchCellCb *cell,
EXTERN Void rgSCHCmnSpsUlProcActInd ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U16 spsSduSize
+uint16_t spsSduSize
));
EXTERN Void rgSCHCmnSpsPhrInd ARGS((
RgSchCellCb *cell,
EXTERN Void rgSCHCmnUlSpsActInd ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U16 spsSduSize
+uint16_t spsSduSize
));
EXTERN Void rgSCHCmnUlCrcFailInd ARGS((
Bool *reTxAllwd
));
-EXTERN S16 PtUiRgmBndCfm ARGS((Pst* pst, SuId suId, U8 status));
+EXTERN S16 PtUiRgmBndCfm ARGS((Pst* pst, SuId suId, uint8_t status));
EXTERN S16 rgSCHCmnDlInitHqEnt
ARGS((
RgSchCellCb *cell,
RgSchDlHqEnt *hqE
));
-EXTERN U8 rgSCHCmnUlGetCqi
+EXTERN uint8_t rgSCHCmnUlGetCqi
ARGS ((
RgSchCellCb *cell,
RgSchUeCb *ue,
EXTERN S16 rgSCHDhmUpdBlerBasediTbsEff ARGS((
RgSchCellCb *cell,
RgSchUeCb *ueCb,
- U8 tbCnt
+ uint8_t tbCnt
));
#endif
EXTERN Void rgSchCmnUpdCfiDb ARGS((
RgSchCellCb *cell,
- U8 delta
+ uint8_t delta
));
EXTERN S16 RgUiRgmChangeTransModeInd ARGS((
Pst *pst,
EXTERN Void rgSchCheckAndTriggerModeChange ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 reportediTbs,
-U8 previTbs,
-U8 maxiTbs
+uint8_t reportediTbs,
+uint8_t previTbs,
+uint8_t maxiTbs
));
EXTERN Void rgSCHRrDlProcRmvFrmRetx ARGS((
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP
));
-EXTERN U8 rgSchUtlGetServCellIdx ARGS((
+EXTERN uint8_t rgSchUtlGetServCellIdx ARGS((
Inst inst,
- U16 cellId,
+ uint16_t cellId,
RgSchUeCb *ue
));
EXTERN S16 rgSchUtlVldtCellId ARGS ((
Inst inst,
- U16 cellId
+ uint16_t cellId
));
EXTERN Void rgSCHCmnInitUlRbAllocInfo ARGS((
RgSchCmnUlRbAllocInfo *allocInfo
EXTERN TfuDciFormat rgSCHCmnSlctPdcchFrmt ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 *raType
+uint8_t *raType
));
EXTERN Void rgSCHCmnNonDlfsDedRbAlloc ARGS((
/* local defines */
-PRIVATE S16 rgSCHDbmInitUeCbLst ARGS(( RgSchCellCb *cellCb, U16 numBins));
+PRIVATE S16 rgSCHDbmInitUeCbLst ARGS(( RgSchCellCb *cellCb, uint16_t numBins));
#ifdef LTE_TDD
-PRIVATE S16 rgSCHDbmInitUeTfuPendLst ARGS(( RgSchCellCb *cellCb, U16 numBins));
+PRIVATE S16 rgSCHDbmInitUeTfuPendLst ARGS(( RgSchCellCb *cellCb, uint16_t numBins));
#endif
PRIVATE Void rgSCHDbmInitDedLcLst ARGS((RgSchUeCb *ueCb));
PRIVATE Void rgSCHDbmInitCmnLcLst ARGS((RgSchCellCb *cellCb));
#ifdef LTEMAC_SPS
PRIVATE S16 rgSCHDbmInitSpsUeCbLst ARGS((RgSchCellCb *cellCb,
- U16 numBins));
+ uint16_t numBins));
#endif
PRIVATE Void rgSCHDbmInitRaCbLst ARGS(( RgSchCellCb *cellCb));
#ifndef LTE_TDD
PRIVATE S16 rgSCHDbmInitUeCbLst
(
RgSchCellCb *cellCb,
-U16 numBins
+uint16_t numBins
)
#else
PRIVATE S16 rgSCHDbmInitUeCbLst(cellCb, numBins)
RgSchCellCb *cellCb;
-U16 numBins;
+uint16_t numBins;
#endif
{
RgSchUeCellInfo ueCellInfo;
/* Fix: syed It is better to compute offset dynamically
* rather than hardcoding it as 0 */
- return (cmHashListInit(&cellCb->ueLst, numBins, (U16)((PTR)&(ueCellInfo.ueLstEnt) - (PTR)&ueCellInfo), FALSE,
+ return (cmHashListInit(&cellCb->ueLst, numBins, (uint16_t)((PTR)&(ueCellInfo.ueLstEnt) - (PTR)&ueCellInfo), FALSE,
CM_HASH_KEYTYPE_CONID,
rgSchCb[cellCb->instIdx].rgSchInit.region,
rgSchCb[cellCb->instIdx].rgSchInit.pool));
PRIVATE S16 rgSCHDbmInitSpsUeCbLst
(
RgSchCellCb *cellCb,
-U16 numBins
+uint16_t numBins
)
#else
PRIVATE S16 rgSCHDbmInitSpsUeCbLst(cellCb, numBins)
RgSchCellCb *cellCb;
-U16 numBins;
+uint16_t numBins;
#endif
{
RgSchUeCb ue;
- return (cmHashListInit(&cellCb->spsUeLst, numBins, (U16) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
+ return (cmHashListInit(&cellCb->spsUeLst, numBins, (uint16_t) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
CM_HASH_KEYTYPE_CONID,
rgSchCb[cellCb->instIdx].rgSchInit.region,
rgSchCb[cellCb->instIdx].rgSchInit.pool));
ueCellInfo = ueCb->cellInfo[ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cellCb)]];
return (cmHashListInsert(&cellCb->ueLst, (PTR)ueCellInfo,
- (U8 *)&ueCb->ueId, (U16)sizeof(ueCb->ueId)));
+ (uint8_t *)&ueCb->ueId, (uint16_t)sizeof(ueCb->ueId)));
} /* rgSCHDbmInsUeCb */
#endif
{
return (cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
- (U8 *)&ueCb->spsRnti, (U16)sizeof(ueCb->spsRnti)));
+ (uint8_t *)&ueCb->spsRnti, (uint16_t)sizeof(ueCb->spsRnti)));
} /* end of rgSCHDbmInsSpsUeCb */
{
RgSchUeCellInfo *ueCellInfo = NULLP;
- cmHashListFind(&cellCb->ueLst, (U8 *)&ueId,
+ cmHashListFind(&cellCb->ueLst, (uint8_t *)&ueId,
sizeof(ueId), 0, (PTR *)&ueCellInfo);
return (!ueCellInfo?NULLP:ueCellInfo->ue);
{
RgSchUeCb *ueCb = NULLP;
- cmHashListFind(&cellCb->spsUeLst, (U8 *)&spsRnti,
+ cmHashListFind(&cellCb->spsUeLst, (uint8_t *)&spsRnti,
sizeof(spsRnti), 0, (PTR *)&ueCb);
return (ueCb);
} /* rgSCHDbmGetSpsUeCb */
RgSchUeCb *ueCb;
#endif
{
- U8 lcCnt = 0;
+ uint8_t lcCnt = 0;
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
ueUl->hqEnt.numBusyHqProcs = 0;
RgSchUeCb *ueCb;
#endif
{
- U8 idx;
+ uint8_t idx;
for (idx = 0; idx < RGSCH_MAX_LC_PER_UE; ++idx)
{
}
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmInitDedLcLst */
RgSchCellCb *cellCb;
#endif
{
- U8 idx;
+ uint8_t idx;
for (idx = 0; idx < RGSCH_MAX_CMN_LC_CB; idx++)
{
}
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmInitCmnLcLst */
ueCb->dl.lcCb[dlLcCb->lcId - 1] = NULLP;
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmDelDlDedLcCb */
RgSchUeCb *ueCb;
#endif
{
- U8 idx;
+ uint8_t idx;
for(idx = 0; idx < RGSCH_DEDLC_MAX_LCID; idx++)
{
RgSchDlLcCb *lcCb;
#endif
{
- U8 idx;
+ uint8_t idx;
if (!lcCb)
{
CmLteLcId lcId;
#endif
{
- U8 idx;
+ uint8_t idx;
for(idx = 0; idx < RGSCH_MAX_CMN_LC_CB; idx++)
{
cellCb->cmnLcCb[RGSCH_BCCH_BCH_IDX].boLst = cmnDlLcCb->boLst;
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmInsBcchOnBch */
}
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmInsBcchOnDlsch */
cellCb->cmnLcCb[RGSCH_PCCH_IDX].boLst = cmnDlLcCb->boLst;
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmInsPcch */
{
cmLListInit(&cmnDlLcCb->boLst);
- RETVOID;
+ return;
} /* rgSCHDbmInitCmnLcBoLst */
/**
cmnBoRpt->boLstEnt.prev = NULLP;
cmnBoRpt->boLstEnt.node = (PTR)cmnBoRpt;
cmLListAdd2Tail(&cmnDlLcCb->boLst, &cmnBoRpt->boLstEnt);
- RETVOID;
+ return;
} /* rgSCHDbmInsCmnLcBoRpt */
{
cmLListInit(&cellCb->raInfo.raCbLst);
- RETVOID;
+ return;
} /* rgSCHDbmInitRaCbLst */
RgSchCellCb *cellCb;
#endif
{
- U8 idx;
+ uint8_t idx;
/* ccpu00133557- Memory Leak Fix- initializing for the all nodes
* in RAREQ list*/
{
cmLListInit(&cellCb->raInfo.raReqLst[idx]);
}
- RETVOID;
+ return;
} /* rgSCHDbmInitRaReqLst */
#endif
{
cmLListInit(&cellCb->rgCfgInfo.crntRgrCfgLst);
- RETVOID;
+ return;
} /* rgSCHDbmInitCrntRgrCfgLst */
/**
{
cmLListInit(&cellCb->rgCfgInfo.pndngRgrCfgLst);
- RETVOID;
+ return;
} /* rgSCHDbmInitPndngRgrCfgLst */
/**
cfgElem->cfgReqLstEnt.next = NULLP;
cfgElem->cfgReqLstEnt.prev = NULLP;
cmLListAdd2Tail(&cellCb->rgCfgInfo.crntRgrCfgLst, &cfgElem->cfgReqLstEnt);
- RETVOID;
+ return;
} /* rgSCHDbmInsCrntRgrCfgElem */
/**
cfgElem->cfgReqLstEnt.prev = NULLP;
cfgElem->cfgReqLstEnt.node = (PTR)cfgElem;
cmLListAdd2Tail(&cellCb->rgCfgInfo.pndngRgrCfgLst, &cfgElem->cfgReqLstEnt);
- RETVOID;
+ return;
} /* rgSCHDbmInsPndngRgrCfgElem */
/**
S16 rgSCHDbmRntiDbInit
(
RgSchCellCb *cellCb,
-U16 rntiStart,
-U16 maxRntis
+uint16_t rntiStart,
+uint16_t maxRntis
)
#else
S16 rgSCHDbmRntiDbInit(cellCb, rntiStart, maxRntis)
RgSchCellCb *cellCb;
-U16 rntiStart;
-U16 maxRntis;
+uint16_t rntiStart;
+uint16_t maxRntis;
#endif
{
- U16 rnti;
+ uint16_t rnti;
RgSchRntiLnk *rntiPool;
/* Fix for Change Request ccpu00099150 */
}
else
{
- U16 idx;
+ uint16_t idx;
rntiPool[0].rnti = rnti++;
rntiPool[0].prv = NULLP;
rntiPool[0].nxt = &rntiPool[1];
cmLListInit(&cellCb->rntiDb.rntiGuardPool);
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmRntiDbDeInit */
#ifdef EMTC_ENABLE
if(ROK==rgSCHDbmPutEmtcRnti(cellCb,rntiLnk))
{
-RETVOID;
+return;
}
#endif
rntiLnk->nxt = NULLP;
cellCb->rntiDb.count++;
/* Stack Crash problems for TRACE5 Changes. Added the return below */
- RETVOID;
+ return;
} /* rgSCHDbmRlsRnti */
PRIVATE S16 rgSCHDbmInitUeTfuPendLst
(
RgSchCellCb *cellCb,
-U16 numBins
+uint16_t numBins
)
#else
PRIVATE S16 rgSCHDbmInitUeTfuPendLst(cellCb, numBins)
RgSchCellCb *cellCb;
-U16 numBins;
+uint16_t numBins;
#endif
{
RgSchUePucchRecpInfo pucchInfo;
/* Fix: syed It is better to compute offset dynamically
* rather than hardcoding it as 0 */
- if(cmHashListInit(&cellCb->ueTfuPendLst, numBins, (U16)((PTR)&(pucchInfo.hashLstEnt) - (PTR)&pucchInfo), FALSE,
+ if(cmHashListInit(&cellCb->ueTfuPendLst, numBins, (uint16_t)((PTR)&(pucchInfo.hashLstEnt) - (PTR)&pucchInfo), FALSE,
CM_HASH_KEYTYPE_CONID,
rgSchCb[cellCb->instIdx].rgSchInit.region,
rgSchCb[cellCb->instIdx].rgSchInit.pool) != ROK)
#include "rg_sch_cmn.x"
#ifdef RGSCH_SPS_STATS
-extern U32 rgNumSPSSchedDropMaxRetx;
-extern U32 rgNumActDtx;
+extern uint32_t rgNumSPSSchedDropMaxRetx;
+extern uint32_t rgNumActDtx;
#endif
-U32 nackSf[10];
+uint32_t nackSf[10];
#endif /* MAC_SCH_STATS */
//Chandan Stats Collection
#ifdef DLHQ_STATS
-U32 statsCnt;
+uint32_t statsCnt;
RgSchDlHqStats dlHqStats[10000] = {{0,0,0}};
#endif
* The below table is based on Table 7.3-X from 36.213 and
* table 79 from FAPIv1.1 doc
*/
-U8 rgSchNumOfAcksToAckNack[RG_SCH_MAX_NUM_EXPECTED_ACKS][RG_SCH_NUM_FDBK_VALUE] = {
+uint8_t rgSchNumOfAcksToAckNack[RG_SCH_MAX_NUM_EXPECTED_ACKS][RG_SCH_NUM_FDBK_VALUE] = {
{TFU_HQFDB_ACK, TFU_HQFDB_NACK, TFU_HQFDB_NACK},
{TFU_HQFDB_NACK, TFU_HQFDB_ACK, TFU_HQFDB_NACK},
{TFU_HQFDB_NACK, TFU_HQFDB_NACK, TFU_HQFDB_ACK},
/* local externs */
-PRIVATE Void rgSCHDhmFdbkIndHndlTa ARGS((RgSchDlHqProcCb *hqP, U8 tbIdx, U8 fdbk,
+PRIVATE Void rgSCHDhmFdbkIndHndlTa ARGS((RgSchDlHqProcCb *hqP, uint8_t tbIdx, uint8_t fdbk,
Bool maxHqRetxReached));
void rgEmtcsetNullSubFrm ARGS((RgSchDlHqProcCb *hqP));
#ifndef LTE_TDD
PRIVATE S16 rgSCHDhmProcHqFdbkAckNackRep ARGS((
RgSchDlHqProcCb *hqP,
RgSchDlSf *sf,
-U8 tbCnt,
-U8 *isAck
+uint8_t tbCnt,
+uint8_t *isAck
));
#endif
#ifdef DL_LA
PRIVATE S16 rgSCHDhmUpdateAckNackHistory ARGS((
RgSchCellCb *cell,
RgSchUeCb *ueCb,
- U8 hqfdbk,
- U8 tbCnt
+ uint8_t hqfdbk,
+ uint8_t tbCnt
));
#endif
#ifdef LTE_TDD
PRIVATE Void rgSCHDhmPrcSplBundlFdbk ARGS((
RgSchCellCb *cell,
TfuHqInfo *fdbk,
- U8 hqCnt
+ uint8_t hqCnt
));
#ifdef LTE_ADV
PRIVATE Void rgSchGetHqFdbkPosForM1 ARGS((
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP,
- U8 *isAck,
+ uint8_t *isAck,
RgTfuHqInfo *fdbk,
- U8 tbIdx,
+ uint8_t tbIdx,
RgSchTddANInfo *anInfo
));
PRIVATE Void rgSchGetHqFdbkPosForM234 ARGS((
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP,
- U8 *isAck,
+ uint8_t *isAck,
RgTfuHqInfo *fdbk,
- U8 tbIdx,
+ uint8_t tbIdx,
RgSchTddANInfo *anInfo,
- U8 M,
+ uint8_t M,
CmLteTimingInfo timeInfo
));
#endif/*LTE_ADV*/
#endif
#ifdef CA_DBG
-extern U32 gPCellTb1AckCount,gPCellTb2AckCount,gPCellTb1NackCount,gPCellTb2NackCount;
-extern U32 gSCellSchedCount,gPrimarySchedCount;
-extern U32 gSCellTb1AckCount,gSCellTb2AckCount,gSCellTb1NackCount,gSCellTb2NackCount;
-extern U32 gPCellTb1DtxCount, gPCellTb2DtxCount, gSCellTb1DtxCount, gSCellTb2DtxCount;
-extern U32 gHqFdbkCount;
+extern uint32_t gPCellTb1AckCount,gPCellTb2AckCount,gPCellTb1NackCount,gPCellTb2NackCount;
+extern uint32_t gSCellSchedCount,gPrimarySchedCount;
+extern uint32_t gSCellTb1AckCount,gSCellTb2AckCount,gSCellTb1NackCount,gSCellTb2NackCount;
+extern uint32_t gPCellTb1DtxCount, gPCellTb2DtxCount, gSCellTb1DtxCount, gSCellTb2DtxCount;
+extern uint32_t gHqFdbkCount;
#endif
#ifdef EMTC_ENABLE
(
RgSchEmtcDlSf *subFrm,
RgSchDlHqProcCb *hqP,
-U8 tbIdx,
+uint8_t tbIdx,
Bool isRepeting
);
EXTERN RgSchEmtcDlSf* rgSCHEmtcUtlSubFrmGet
#endif
{
RgSchDlHqProcCb *hqP;
- U8 i;
+ uint8_t i;
cmLListInit(&hqE->inUse);
cmLListInit(&hqE->free);
for (i=0; i < hqE->numHqPrcs; i++)
rgSCHLaaResetDlHqProcCb(hqP);
#endif
}
- RETVOID;
+ return;
} /* rgSCHDhmHqEntReset */
/**
ue->ul.ulInactvMask &= ~(RG_HQENT_INACTIVE);
rgSCHCmnDlInitHqEnt(ue->cell, ue->cellInfo[0]->hqEnt);
- RETVOID;
+ return;
}
/**
if (!(*hqE))
{
- RETVOID;
+ return;
}
rgSCHCmnDlDeInitHqEnt(cell, *hqE);
rgSCHUtlFreeSBuf(cell->instIdx, (Data **)hqE,
sizeof(RgSchDlHqEnt));
- RETVOID;
+ return;
}
#ifdef ANSI
* @param[in] RgSchDlHqEnt *hqE
* @param[in] CmLteTimingInfo timingInfo
* @param[out] RgDlHqProc *hqP
- * @param[in] U8 tbIdx
+ * @param[in] uint8_t tbIdx
* @return Void
*
**/
RgSchDlHqEnt *hqE,
CmLteTimingInfo timingInfo,
RgSchDlHqProcCb *hqP,
-U8 tbIdx
+uint8_t tbIdx
)
#else
Void rgSCHDhmHqTbRetx(hqE, timingInfo, hqP, tbIdx)
RgSchDlHqEnt *hqE;
CmLteTimingInfo timingInfo;
RgSchDlHqProcCb *hqP;
-U8 tbIdx;
+uint8_t tbIdx;
#endif
{
- U8 othrTbIdx = tbIdx ^ 1;
+ uint8_t othrTbIdx = tbIdx ^ 1;
hqP->tbInfo[tbIdx].timingInfo = timingInfo;
if (hqE->msg4Proc == hqP)
{
- RETVOID;
+ return;
}
/* fix for ccpu00118633 No Hq proc Avl end*/
hqP->tbInfo[tbIdx].cntrRetxAllocFail = 0;
- RETVOID;
+ return;
} /* rgSCHDhmHqTbRetx */
/**
* Invoked by: scheduler and HARQ processing
*
* @param[in] RgDlHqProc *hqP
- * @param[in] U8 tbIdx
+ * @param[in] uint8_t tbIdx
* @param[in] Bool togNdi
* @return Void
*
Void rgSCHDhmRlsHqpTb
(
RgSchDlHqProcCb *hqP,
-U8 tbIdx,
+uint8_t tbIdx,
Bool togNdi
)
#else
Void rgSCHDhmRlsHqpTb(hqP, tbIdx, togNdi)
RgSchDlHqProcCb *hqP;
-U8 tbIdx;
+uint8_t tbIdx;
Bool togNdi;
#endif
{
RgSchDlHqEnt *hqE;
- U8 othrTbIdx = tbIdx ^ 1;
+ uint8_t othrTbIdx = tbIdx ^ 1;
#ifdef LTEMAC_SPS
RgSchCmnDlHqProc *cmnHqDl;
#endif
/* L2_COUNTERS */
#ifdef LTE_L2_MEAS
RgSchDlLcCb* lcCb = NULLP;
- U8 numLch = 0;
+ uint8_t numLch = 0;
#endif
/* Reset all tbInfo values */
RgSchUeCb *ueCb = hqP->hqE->ue;
RgSchCmnUe *cmnUe = (RgSchCmnUe*)ueCb->sch;
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ueCb,hqE->cell);/*CA dev*/
- U8 cqi = dlUe->mimoInfo.cwInfo[0].cqi;
+ uint8_t cqi = dlUe->mimoInfo.cwInfo[0].cqi;
/* to get retransmission, decreasing transmission counter */
- U16 numDlRetx = hqP->tbInfo[0].txCntr-1;
- U8 tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
- static U32 retxCnt1 = 0;
+ uint16_t numDlRetx = hqP->tbInfo[0].txCntr-1;
+ uint8_t tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
+ static uint32_t retxCnt1 = 0;
RG_SCH_CMN_DL_TBS_TO_MCS(tbs, \
hqRetxStats.dlCqiStat[(cqi - 1)].mcs);
/* Add the proc to the free list */
//cmLListAdd2Tail(&hqE->free, &hqP->lnk);
rgSCHDhmHqPAdd2FreeLst(hqP);
- RETVOID;
+ return;
}
#ifdef RGR_V1
/* MS_WORKAROUND : syed The check (hqE->ccchSduProc != NULLP)
/* Add the proc to the free list */
//cmLListAdd2Tail(&hqE->free, &hqP->lnk);
rgSCHDhmHqPAdd2FreeLst(hqP);
- RETVOID;
+ return;
}
#endif
hqP->tbInfo[tbIdx].cntrRetxAllocFail = 0;
- RETVOID;
+ return;
} /* rgSCHDhmRlsHqpTb */
/**
RgSchUeCb *ueCb = hqP->hqE->ue;
RgSchCmnUe *cmnUe = (RgSchCmnUe*)ueCb->sch;
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ueCb,hqE->cell);/*CA dev*/
- U8 cqi = dlUe->mimoInfo.cwInfo[0].cqi;
+ uint8_t cqi = dlUe->mimoInfo.cwInfo[0].cqi;
/* to get retransmission, decreasing transmission counter */
- U16 numDlRetx = hqP->tbInfo[0].txCntr-1;
- U8 tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
+ uint16_t numDlRetx = hqP->tbInfo[0].txCntr-1;
+ uint8_t tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
RG_SCH_CMN_DL_TBS_TO_MCS(tbs, hqRetxStats.dlCqiStat[(cqi - 1)].mcs);
hqP->tbCnt = 0;
#endif
- RETVOID;
+ return;
} /* rgSCHDhmRlsHqProc */
#ifdef LTEMAC_SPS
* Invoked by: ROM
*
* @param[in] RgSchUeCb *ue
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @param[in] RgDlHqProc **hqP
* @return S16
* -# ROK if successful
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 idx,
+uint8_t idx,
RgSchDlHqProcCb **hqP
)
#else
S16 rgSCHDhmGetHqProcFrmId(cell, ue, idx, hqP)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 idx;
+uint8_t idx;
RgSchDlHqProcCb **hqP;
#endif
{
#endif
{
RgSchDlHqEnt *hqE;
- U8 idx;
+ uint8_t idx;
RgSchDlHqProcCb *hqProc = NULLP;
CmLList *tmp = NULLP;
* feedback indication received.
*
* @param[in] RgSchDlHqProcCb *hqP
- * @param[in] U8 tbIdx
- * @param[in] U8 fdbk
+ * @param[in] uint8_t tbIdx
+ * @param[in] uint8_t fdbk
* @return Void
* -# None.
**/
PRIVATE Void rgSCHDhmFdbkIndHndlTa
(
RgSchDlHqProcCb *hqP,
-U8 tbIdx,
-U8 fdbk,
+uint8_t tbIdx,
+uint8_t fdbk,
Bool maxHqRetxReached
)
#else
PRIVATE Void rgSCHDhmFdbkIndHndlTa(hqP, tbIdx, fdbk,maxHqRetxReached)
RgSchDlHqProcCb *hqP;
-U8 tbIdx;
-U8 fdbk;
+uint8_t tbIdx;
+uint8_t fdbk;
Bool maxHqRetxReached;
#endif
{
break;
}
- RETVOID;
+ return;
} /* rgSCHDhmFdbkIndHndlTa */
/* 3.1 MIMO: TA cmd details at TB level rather than Hq Level */
tbInfo->schdTa.pres = PRSNT_NODEF;
tbInfo->schdTa.val = ueCb->dl.taCb.ta;
- RETVOID;
+ return;
} /* rgSCHDhmSchdTa */
#ifdef LTE_TDD
* @param[in] CmLteTimingInfo timeInfo
* @param[in] Bool *isMsg4
* @param[out] RgSchDlHqProcCb **hqPrcs
- * @param[out] U8 *numTbs
+ * @param[out] uint8_t *numTbs
* @param[out] S8 *tbStrtIdx
- * @param[out] U8 *cntHqPrcs
+ * @param[out] uint8_t *cntHqPrcs
* @return S16
**/
#ifdef ANSI
CmLteTimingInfo timeInfo,
Bool *isMsg4,
RgSchDlHqProcCb **hqPrcs,
-U8 *numTbs,
+uint8_t *numTbs,
S8 *tbStrtIdx,
-U8 *cntHqPrcs,
+uint8_t *cntHqPrcs,
RgSchCellCb *cell
)
#else
CmLteTimingInfo timeInfo;
Bool *isMsg4;
RgSchDlHqProcCb **hqPrcs;
-U8 *numTbs;
+uint8_t *numTbs;
S8 *tbStrtIdx;
-U8 *cntHqPrcs;
+uint8_t *cntHqPrcs;
RgSchCellCb *cell;
#endif
{
RgSchDlHqProcCb *hqP;
CmLteTimingInfo schdSfTime;
RgSchTddDlAscSetIdxK ascIdx;
- U8 noFdbks;
- U8 i;
- U8 idx;
- U8 dlIdx;
+ uint8_t noFdbks;
+ uint8_t i;
+ uint8_t idx;
+ uint8_t dlIdx;
CmLListCp *lnk;
CmLList *node;
* @param[in] RgSchDlHqEnt *hqE
* @param[in] CmLteTimingInfo timeInfo
* @param[in] Bool *isMsg4
- * @param[out] U8 *numTbs
+ * @param[out] uint8_t *numTbs
* @param[out] S8 *tbStrtIdx
* @return RgSchDlHqProcCb*
* -# RgSchDlHqProcCb*
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlHqProcCb *hqP
- * @param[in] U8 tbCnt
+ * @param[in] uint8_t tbCnt
* @param[out] Bool *isMaxRetx
* @return Void
* -#None.
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP,
-U8 tbCnt,
+uint8_t tbCnt,
Bool *isMaxRetx
)
#else
Void rgSCHDhmHqTbTrnsFail(cell, hqP, tbCnt, isMaxRetx)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
-U8 tbCnt;
+uint8_t tbCnt;
Bool *isMaxRetx;
#endif
{
RgSchDlHqEnt *hqE;
- U8 maxHqTx;
+ uint8_t maxHqTx;
hqE = hqP->hqE;
"rgSCHDhmHqTbTrnsFail contRes exp(): tmpCRNTI = %u",
hqP->hqE->raCb->tmpCrnti);
rgSCHRamMsg4Done(cell, (RgSchRaCb *)hqP->hqE->raCb);
- RETVOID;
+ return;
}
#endif
maxHqTx = cell->dlHqCfg.maxMsg4HqTx;
RgSchUeCb *ueCb = hqE->ue;
RgSchCmnUe *cmnUe = (RgSchCmnUe*)ueCb->sch;
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ueCb,hqE->cell);/*CA dev*/
- U8 tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
- static U32 retxCnt = 0;
+ uint8_t tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
+ static uint32_t retxCnt = 0;
{
++retxCnt;
/* CA Dev End*/
break;
}
- RETVOID;
+ return;
}
/* extra:check if already removed as part of other TB processing
* then donot remove from InUse Q */
*isMaxRetx = TRUE;
}
- RETVOID;
+ return;
} /* rgSCHDhmHqTbTrnsFail */
-U32 rgHqRvStats[2][4][2] = {{{0, 0}, {0, 0}, {0, 0}, {0, 0}},
+uint32_t rgHqRvStats[2][4][2] = {{{0, 0}, {0, 0}, {0, 0}, {0, 0}},
{{0, 0}, {0, 0}, {0, 0}, {0, 0}}};
#ifdef LTE_TDD
#ifdef LTE_ADV
*
* @param[in] RgSchUeCb *ue,
* @param[in] RgSchDlHqProcCb *hqP,
- * @param[in] U8 *isAck,
+ * @param[in] uint8_t *isAck,
* @param[in] RgTfuHqInfo *fdbk,
- * @param[in] U8 tbIdx,
+ * @param[in] uint8_t tbIdx,
* @param[in] RgSchTddANInfo *anInfo;
- * @return RETVOID
+ * @return void
**/
#ifdef ANSI
PRIVATE Void rgSchGetHqFdbkPosForM1
(
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP,
- U8 *isAck,
+ uint8_t *isAck,
RgTfuHqInfo *fdbk,
- U8 tbIdx,
+ uint8_t tbIdx,
RgSchTddANInfo *anInfo
)
#else
PRIVATE Void rgSchGetHqFdbkPosForM1(ue,hqP,isAck,fdbk,tbIdx,anInfo)
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
- U8 *isAck;
+ uint8_t *isAck;
RgTfuHqInfo *fdbk;
- U8 tbIdx;
+ uint8_t tbIdx;
RgSchTddANInfo *anInfo;
#endif
{
{
if(RG_SCH_IS_CELL_SEC(ue,hqP->hqE->cell))
{
- U8 cellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
+ uint8_t cellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
hqP->hqE->cell->cellId,
hqP->hqE->ue);
break;
}
}
- RETVOID;
+ return;
}/* End of rgSchGetHqFdbkPosForM1 */
/** * @brief Function to decode the position of HarqFb for M>=2 cases.
*
* @param[in] RgSchUeCb *ue,
* @param[in] RgSchDlHqProcCb *hqP,
- * @param[in] U8 *isAck,
+ * @param[in] uint8_t *isAck,
* @param[in] RgTfuHqInfo *fdbk,
- * @param[in] U8 tbIdx,
+ * @param[in] uint8_t tbIdx,
* @param[in] RgSchTddANInfo *anInfo;
* @param[in] CmLteTimingInfo timeInfo;
- * @return RETVOID
+ * @return void
**/
#ifdef ANSI
PRIVATE Void rgSchGetHqFdbkPosForM234
(
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP,
- U8 *isAck,
+ uint8_t *isAck,
RgTfuHqInfo *fdbk,
- U8 tbIdx,
+ uint8_t tbIdx,
RgSchTddANInfo *anInfo,
- U8 M,
+ uint8_t M,
CmLteTimingInfo timeInfo
)
#else
PRIVATE Void rgSchGetHqFdbkPosForM234(ue,hqP,isAck,fdbk,tbIdx,anInfo,M,timeInfo)
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
- U8 *isAck;
+ uint8_t *isAck;
RgTfuHqInfo *fdbk;
- U8 tbIdx;
+ uint8_t tbIdx;
RgSchTddANInfo *anInfo;
- U8 M;
+ uint8_t M;
CmLteTimingInfo timeInfo;
#endif
{
- U8 fdbkIdx;
+ uint8_t fdbkIdx;
Bool isSCell;
RgSchTddANInfo *pCellAnInfo;
- U8 incr = 0;
+ uint8_t incr = 0;
if(NULLP != ue)
{
dlHqStats[statsCnt].sf = hqP->tbInfo[tbIdx].timingInfo.slot;
dlHqStats[statsCnt].ack = *isAck;
dlHqStats[statsCnt].fdbkIdx = fdbkIdx;
- dlHqStats[statsCnt].ue = hqP->hqE->ue->ueId;;
+ dlHqStats[statsCnt].ue = hqP->hqE->ue->ueId;
if (anInfo)
dlHqStats[statsCnt].ulDai = incr;
if(TRUE == fdbk->isPusch)
}
#endif
}/*ue*/
- RETVOID;
+ return;
}/*rgSchGetHqFdbkPosForM234*/
#endif/*LTE_ADV*/
*
*
* @param[in] Void *cb
- * @param[in] U8 cbType
+ * @param[in] uint8_t cbType
* @param[in] RgSchCellCb cellCb
* @param[in] CmLteTimingInfo timeInfo
* @param[in] TfuHqInfo *fdbk
S16 rgSCHDhmHqFdbkInd
(
Void *cb,
-U8 cbType,
+uint8_t cbType,
RgSchCellCb *cellCb,
CmLteTimingInfo timeInfo,
TfuHqInfo *fdbk,
#else
S16 rgSCHDhmHqFdbkInd(cb, cbType, cellCb, timeInfo, fdbk, rlsHqBufs, err)
Void *cb;
-U8 cbType;
+uint8_t cbType;
RgSchCellCb *cellCb;
CmLteTimingInfo timeInfo;
TfuHqInfo *fdbk;
RgSchDlSf *sf;
Bool isMsg4 = FALSE;
RgSchRaCb *raCb = NULLP;
- U16 rnti=0;
+ uint16_t rnti=0;
/* Maximum possible HARQ processes in UL-DL configuration 5 that is
* given feedback at a time */
RgSchDlHqProcCb *hqPrcs[(RGSCH_NUM_SUB_FRAMES-1)*5]; /*MAX 5 Cells*/
- U8 numTb[(RGSCH_NUM_SUB_FRAMES-1)*5];
+ uint8_t numTb[(RGSCH_NUM_SUB_FRAMES-1)*5];
S8 tbStrtIdx[(RGSCH_NUM_SUB_FRAMES-1)*5];
- U8 hqCnt;
- U8 idx;
+ uint8_t hqCnt;
+ uint8_t idx;
RgSchTddANInfo *anInfo = NULLP;
- U8 isAck = 0;
- U8 tbCnt;
+ uint8_t isAck = 0;
+ uint8_t tbCnt;
RgrTddAckNackMode ackNackMode;
Bool hqRls = FALSE;
RgSchDlSf *nxtDlsf = NULLP;
- /* U8 rcvCnt = 0; */
+ /* uint8_t rcvCnt = 0; */
CmLteTimingInfo nxtfrm = {0,0};
Bool anUpd = FALSE;
Bool maxHqRetxReached;
#if ((defined LTEMAC_SPS_AN_MUX) || (defined LTE_ADV))
RgSchTddDlAscSetIdxK ascIdx;
- U8 noFdbks;
+ uint8_t noFdbks;
#endif
#ifdef LTEMAC_SPS_AN_MUX
Bool isPusch = FALSE;
- U8 tmpIdx;
- U8 hIdx;
+ uint8_t tmpIdx;
+ uint8_t hIdx;
/* Subframes in which transmissions are scheduled and whose feedback can come
* in this subframe. Used only for Multiplexing mode */
CmLteTimingInfo schdSfTime[RGSCH_TDD_MAX_FDBK];
#endif
#endif
#ifdef LTE_ADV
- U8 sCellActCePres = 0;
+ uint8_t sCellActCePres = 0;
#endif
/* LTEMAC_SPS_AN_MUX*/
RgrSchFrmt1b3TypEnum uciFrmtTyp = RG_SCH_UCI_FORMAT1A_1B;
if(ue)
{
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqPrcs[idx]->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqPrcs[idx]->hqE->cell->instIdx,
hqPrcs[idx]->hqE->cell->cellId,ue);
if(ue->cellInfo[servCellIdx]->sCellState != RG_SCH_SCELL_ACTIVE)
if(ackNackMode == RGR_TDD_ACKNACK_MODE_MULT)
{
CmLteTimingInfo txTime;
- U8 ulDlCfgIdx = 0;
- U8 maxFdbks = 0;
- U8 itr = 0;
+ uint8_t ulDlCfgIdx = 0;
+ uint8_t maxFdbks = 0;
+ uint8_t itr = 0;
ulDlCfgIdx = cellCb->ulDlCfgIdx;
RgSchDlHqProcCb *hqP,
RgSchDlSf *sf,
Bool isMsg4,
-U16 rnti,
-U8 tbCnt,
+uint16_t rnti,
+uint8_t tbCnt,
CmLteTimingInfo timingInfo,
-U8 isAck,
+uint8_t isAck,
RgInfRlsHqInfo *rlsHqBufs,
RgSchErrInfo *err
)
RgSchDlHqProcCb *hqP;
RgSchDlSf *sf;
Bool isMsg4;
-U16 rnti;
-U8 tbCnt;
+uint16_t rnti;
+uint8_t tbCnt;
CmLteTimingInfo timingInfo;
-U8 isAck;
+uint8_t isAck;
RgInfRlsHqInfo *rlsHqBufs;
RgSchErrInfo *err;
#endif
* @param[in] RgrSchFrmt1b3TypEnum uciFrmtTyp,
* @param[in] Bool *isAck,
* @param[in] RgTfuHqInfo *fdbk,
- * @return RETVOID
+ * @return void
**/
#ifdef ANSI
Void rgSchGetHqFdbkPos
RgSchUeCb *ue,
RgSchDlHqProcCb *hqP,
RgrSchFrmt1b3TypEnum uciFrmtTyp,
- U8 *isAck,
+ uint8_t *isAck,
RgTfuHqInfo *fdbk
)
#else
RgSchUeCb *ue;
RgSchDlHqProcCb *hqP;
RgrSchFrmt1b3TypEnum uciFrmtTyp;
- U8 *isAck;
+ uint8_t *isAck;
RgTfuHqInfo *fdbk;
#endif
{
{
isAck[0] = fdbk->isAck[0];
isAck[1] = fdbk->isAck[1];
- RETVOID;
+ return;
}
#ifdef LTE_ADV
/* LAA Making all ack for LAA CELL */
{
isAck[0] = TRUE;
isAck[1] = TRUE;
- RETVOID;
+ return;
}
if((ue != NULLP))
if(RG_SCH_IS_CELL_SEC(ue,hqP->hqE->cell))
{
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqP->hqE->cell->instIdx,
hqP->hqE->cell->cellId,
ue);
}
}
#endif
- RETVOID;
+ return;
}/* End of rgSchGetHqFdbkPos */
#ifdef LTE_ADV
#ifdef ANSI
Void rgSchGetHqFdbkPosFormat3
(
RgSchDlHqProcCb *hqP,
- U8 *isAck,
+ uint8_t *isAck,
TfuHqFdbk *fdbk
)
#else
Void rgSchGetHqFdbkPosFormat3(hqP,isAck,fdbk)
RgSchDlHqProcCb *hqP;
- U8 *isAck;
+ uint8_t *isAck;
TfuHqFdbk *fdbk;
#endif
{
- U8 cellIdx = RG_SCH_CMN_GET_CELL_IDX_FROM_HQP(hqP);
- isAck[0] = (U8)fdbk[cellIdx];
- isAck[1] = (U8)fdbk[cellIdx + 1];
+ uint8_t cellIdx = RG_SCH_CMN_GET_CELL_IDX_FROM_HQP(hqP);
+ isAck[0] = (uint8_t)fdbk[cellIdx];
+ isAck[1] = (uint8_t)fdbk[cellIdx + 1];
}
#endif
/** * @brief Handler for HARQ feedback received for DL transmission.
*
*
* @param[in] Void *cb
- * @param[in] U8 cbType
+ * @param[in] uint8_t cbType
* @param[in] RgSchCellCb *cell
* @param[in] RgTfuHarqAckIndInfo *fdbk
* @param[in] RgInfRlsHqInfo *rlsHqBufs
S16 ret = ROK;
RgSchDlSf *sf;
Bool isMsg4 = FALSE;
- U16 rnti=0;
- U16 procId=0;
- U8 hqPCount = 0;
+ uint16_t rnti=0;
+ uint16_t procId=0;
+ uint8_t hqPCount = 0;
RgInfRlsHqInfo *rlsHqBufs = NULLP;
RGSCHDECRFRMCRNTTIME(timingInfo, timingInfo, 4);
{
rlsHqBufs->ueHqInfo[rlsHqBufs->numUes].rnti = rnti;
rlsHqBufs->ueHqInfo[rlsHqBufs->numUes].hqProcId =
- (U8)procId;
+ (uint8_t)procId;
rlsHqBufs->numUes++;
}
hqPCount--;
*
*
* @param[in] Void *cb
- * @param[in] U8 cbType
+ * @param[in] uint8_t cbType
* @param[in] RgSchCellCb *cell
* @param[in] RgTfuHarqAckIndInfo *fdbk
* @param[in] RgInfRlsHqInfo *rlsHqBufs
S16 rgSCHDhmHqFdbkInd
(
Void *cb,
-U8 cbType,
+uint8_t cbType,
RgSchCellCb *cell,
CmLteTimingInfo timingInfo,
RgTfuHqInfo *fdbk,
#else
S16 rgSCHDhmHqFdbkInd(cb, cbType, cell, timingInfo, fdbk, rlsHqBufs, err)
Void *cb;
-U8 cbType;
+uint8_t cbType;
RgSchCellCb *cell;
CmLteTimingInfo timingInfo;
RgTfuHqInfo *fdbk;
RgSchDlSf *sf;
Bool isMsg4 = FALSE;
RgSchRaCb *raCb = NULLP;
- U16 rnti=0;
+ uint16_t rnti=0;
/* Added Insure Fixes Of UR.Initialized procId */
- U16 procId=0;
- /* DTX Change: Bool is converted into U8*/
- U8 isAck[2]={0}; /*Changed to Array of 2*/
- U8 tbCnt;
- U8 hqPCount = 0;
+ uint16_t procId=0;
+ /* DTX Change: Bool is converted into uint8_t*/
+ uint8_t isAck[2]={0}; /*Changed to Array of 2*/
+ uint8_t tbCnt;
+ uint8_t hqPCount = 0;
#ifdef LTEMAC_SPS
CmLteTimingInfo fdbkRcptTime = timingInfo;
RgSchUeCb *ueCb = hqE->ue;
RgSchCmnUe *cmnUe = (RgSchCmnUe*)ueCb->sch;
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ueCb,hqE->cell);/*CA dev*/
- U8 tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
- static U32 retxCnt = 0;
+ uint8_t tbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
+ static uint32_t retxCnt = 0;
if (fdbk->isAck[0] == TFU_HQFDB_ACK)
{
{
rlsHqBufs->ueHqInfo[rlsHqBufs->numUes].rnti = rnti;
rlsHqBufs->ueHqInfo[rlsHqBufs->numUes].hqProcId =
- (U8)procId;
+ (uint8_t)procId;
rlsHqBufs->numUes++;
}
hqPCount--;
{
rlsHqBufs->ueHqInfo[rlsHqBufs->numUes].rnti = rnti;
rlsHqBufs->ueHqInfo[rlsHqBufs->numUes].hqProcId =
- (U8)procId;
+ (uint8_t)procId;
rlsHqBufs->numUes++;
}
hqPCount--;
}
rgSCHTmrStartTmr (cell, ueCb, RG_SCH_TMR_TA, ueCb->dl.taCb.cfgTaTmr);
}
- RETVOID;
+ return;
} /* rgSCHDhmRgrUeCfg */
PTR pUeCb;/* previous UE Control block */
PTR nUeCb;/* next UE control block */
S16 ret;
- U8 idx;
+ uint8_t idx;
UNUSED(err);
cell->tq[idx].first = NULLP;
cell->tq[idx].tail = NULLP;
}
- RETVOID;
+ return;
} /* rgSCHDhmRgrCellCfg */
/**
}
}
}
- RETVOID;
+ return;
} /* rgSCHDhmRgrCellRecfg */
/**
rgSCHCmnRmvFrmTaLst(ueCb->cell, ueCb);
}
- RETVOID;
+ return;
} /* rgSCHDhmFreeUe */
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ueCb
- * @param[in] U8 ta
+ * @param[in] uint8_t ta
*
* @return None.
*
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
-U8 ta
+uint8_t ta
)
#else
Void rgSCHDhmUpdTa(cell, ueCb, ta)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
-U8 ta;
+uint8_t ta;
#endif
{
ueCb->dl.taCb.outStndngTaval = ta;
}
- RETVOID;
+ return;
} /* rgSCHDhmUpdTa */
/** @brief This function handles the TA timer expiry.
/* Ask scheduler to schedule this UE */
ueCb->dl.taCb.state = RGSCH_TA_TOBE_SCHEDULED;
rgSCHUtlDlTARpt(ueCb->cell, ueCb);
- RETVOID;
+ return;
} /* end of rgSCHDhmProcTAExp */
/* 3.1 MIMO: LC details at TB level rather than Hq Level */
{
CmLteTimingInfo dlSfTime;
RgSchTddDlAscSetIdxK ascIdx;
- U8 noFdbks;
- U8 i;
+ uint8_t noFdbks;
+ uint8_t i;
ascIdx =
rgSchTddDlAscSetIdxKTbl[cellCb->ulDlCfgIdx][uciTimingInfo.slot];
}/* rgSCHDhmTddRlsSubFrm */
#ifdef TFU_TDD
-U32 macDtx = 0;
+uint32_t macDtx = 0;
#endif
/**
* @brief Handler for Removing the HARQ process from a dlsf.
CmLteTimingInfo nxtfrm = {0,0};
RgSchDlHqProcCb *tmpHqProc;
RgSchTddDlAscSetIdxK ascIdx;
- U8 noFdbks;
+ uint8_t noFdbks;
S16 i;
RgSchDlSf *nxtDlsf = NULLP;
CmLList *node;
CmLList *hqPNode;
- U8 idx;
+ uint8_t idx;
/*ccpu00130018 -MOD -Initiatizing with FALSE*/
- U8 maxRetx=FALSE;
+ uint8_t maxRetx=FALSE;
RgSchTddANInfo *anInfo = NULLP;
RgSchDlHqTbCb *tbCb;
RgSchUeCb *ue = NULLP;
/* Update feedback time for this process so that
* next subframe its picked up */
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(
tmpHqProc->hqE->cell->instIdx,
tmpHqProc->hqE->cell->cellId,
ue);
/* Update feedback time for this process so that
* next subframe its picked up */
#ifdef LTE_ADV
- U8 servCellIdx = rgSchUtlGetServCellIdx(
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(
tmpHqProc->hqE->cell->instIdx,
tmpHqProc->hqE->cell->cellId,
ue);
Bool maxRetx;
CmLList *node;
CmLList *hqPNode;
- U8 idx;
+ uint8_t idx;
RgSchDlHqTbCb *tbCb;
RgSchUeCb *ue;
* - Set isSpsHqProc = TRUE
*
* @param[in] RgSchUeCb *ue
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @return S16
* -# ROK if successful
* -# RFAILED otherwise
S16 rgSCHDhmMarkSpsHqProc
(
RgSchUeCb *ue,
-U8 idx
+uint8_t idx
)
#else
S16 rgSCHDhmMarkSpsHqProc(ue, idx)
RgSchUeCb *ue;
-U8 idx;
+uint8_t idx;
#endif
{
RgSchDlHqProcCb *hqP;
*
* @param[in] RgSchDlHqProcCb *hqP
* @param[in] RgSchDlSf *sf
- * @param[in] U8 tbCnt
- * @param[in] U8 *isAck
+ * @param[in] uint8_t tbCnt
+ * @param[in] uint8_t *isAck
* @return S16
* -# ROK
* -# RFAILED
(
RgSchDlHqProcCb *hqP,
RgSchDlSf *sf,
-U8 tbCnt,
-U8 *isAck
+uint8_t tbCnt,
+uint8_t *isAck
)
#else
PRIVATE S16 rgSCHDhmProcHqFdbkAckNackRep(hqP,sf,tbCnt,isAck)
RgSchDlHqProcCb *hqP;
RgSchDlSf *sf;
-U8 tbCnt;
-U8 *isAck;
+uint8_t tbCnt;
+uint8_t *isAck;
#endif
{
/* Check if this is repeating UE */
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
-U8 hqfdbk,
-U8 tbCnt
+uint8_t hqfdbk,
+uint8_t tbCnt
)
#else
PRIVATE S16 rgSCHDhmUpdateAckNackHistory(cell, ueCb, hqfdbk, tbCnt)
(
RgSchCellCb *cell;
RgSchUeCb *ueCb;
-U8 hqfdbk;
-U8 tbCnt;
+uint8_t hqfdbk;
+uint8_t tbCnt;
)
#endif
{
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
-U8 tbCnt
+uint8_t tbCnt
)
#else
S16 rgSCHDhmUpdBlerBasediTbsEff(cell, ueCb, tbCnt)
(
RgSchCellCb *cell;
RgSchUeCb *ueCb;
-U8 tbCnt;
+uint8_t tbCnt;
)
#endif
{
S32 iTbs;
RgSchCmnDlUe *ueDl;
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 cfi = cellSch->dl.currCfi;
- U8 maxiTbs = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[RG_SCH_CMN_MAX_CQI - 1];
+ uint8_t cfi = cellSch->dl.currCfi;
+ uint8_t maxiTbs = (*(RgSchCmnCqiToTbs *)(cellSch->dl.cqiToTbsTbl[0][cfi]))[RG_SCH_CMN_MAX_CQI - 1];
maxiTbs = RG_SCH_DL_MAX_ITBS;
ueDl = RG_SCH_CMN_GET_DL_UE(ueCb,cell);
* 4 = DTX (UE did not transmit anything)
*
* @param[in] TfuHqInfo *fdbk
- * @param[in] U8 hqCnt
+ * @param[in] uint8_t hqCnt
* @return Void
*
**/
(
RgSchCellCb *cell,
TfuHqInfo *fdbk,
-U8 hqCnt
+uint8_t hqCnt
)
#else
PRIVATE Void rgSCHDhmPrcSplBundlFdbk(cell, fdbk, hqCnt)
(
RgSchCellCb *cell;
TfuHqInfo *fdbk;
-U8 hqCnt;
+uint8_t hqCnt;
)
#endif
{
- U8 numOfAcks;
+ uint8_t numOfAcks;
/* Num of ACKs reported by UE */
numOfAcks = fdbk->isAck[0];
the PDSCH trasnmission (spatial bundling). So we have
to assume same feedback for both codewords */
#ifdef LTE_ADV
- for(U8 idx = 1 ; idx < TFU_MAX_HARQ_FDBKS; idx++)
+ for(uint8_t idx = 1 ; idx < TFU_MAX_HARQ_FDBKS; idx++)
{
fdbk->isAck[idx] = fdbk->isAck[0];
}
fdbk->isAck[1] = fdbk->isAck[0];
#endif
- RETVOID;
+ return;
}
#endif
rgSCHLaaHndlHqProcFree(hqP);
#endif
- RETVOID;
+ return;
} /* rgSCHDhmHqPAdd2FreeLst */
}
#endif
- RETVOID;
+ return;
} /* rgSCHDhmHqPAdd2InUseLst */
/**
}
#endif
- RETVOID;
+ return;
} /* rgSCHDhmHqPDelFrmFreeLst */
}
#endif
- RETVOID;
+ return;
} /* rgSCHDhmHqPDelFrmInUseLst */
\f
* in TDD config 2 where no DwPTS exits.
*/
-PRIVATE U8 rgSchDrxDlSfTddCfg[RGSCH_MAX_SFCFG][RGSCH_MAX_TDD_CFG] =
+PRIVATE uint8_t rgSchDrxDlSfTddCfg[RGSCH_MAX_SFCFG][RGSCH_MAX_TDD_CFG] =
{
{2,4,6,6,7,8,3},
{4,6,8,7,8,9,5}
*
*/
-PRIVATE U8 rgSchDrxDLSfTillNxtSFN[RGSCH_MAX_SFCFG][RGSCH_MAX_TDD_CFG]
+PRIVATE uint8_t rgSchDrxDLSfTillNxtSFN[RGSCH_MAX_SFCFG][RGSCH_MAX_TDD_CFG]
[RGSCH_NUM_SUB_FRAMES]=
{
{
*
*/
-PRIVATE U8 rgSchDrxDLSftoDLSfIdx[RGSCH_MAX_SFCFG][RGSCH_MAX_TDD_CFG]
+PRIVATE uint8_t rgSchDrxDLSftoDLSfIdx[RGSCH_MAX_SFCFG][RGSCH_MAX_TDD_CFG]
[RGSCH_NUM_SUB_FRAMES]=
{
{
/* The k+4 th subframe in TDD at which HARQ RTT expires may be an Uplink SF.
In such case, the drx retx timer may start at the next pdcch sf instead
of at k+4 itself */
-U8 rgSchDrxHarqRetxFirstPsf[RGSCH_MAX_TDD_CFG][RGSCH_NUM_SUB_FRAMES] = {
+uint8_t rgSchDrxHarqRetxFirstPsf[RGSCH_MAX_TDD_CFG][RGSCH_NUM_SUB_FRAMES] = {
{0, 0, 4, 0, 6, 0, 0, 4, 0, 6},
{0, 0, 4, 6, 0, 0, 0, 4, 6, 0},
{0, 0, 4, 0, 0, 0, 0, 4, 0, 0},
******************************************************************************/
PRIVATE Void rgSCHDrxTtiHdlOnDurUl ARGS((
RgSchCellCb *cell,
-U16 ulIndex
+uint16_t ulIndex
));
PRIVATE Void rgSCHDrxTtiHdlOnDurDl ARGS((
RgSchCellCb *cell,
-U16 dlIndex
+uint16_t dlIndex
));
PRIVATE Void rgSCHDrxTtiHdlDlHarqRTT ARGS((
RgSchCellCb *cell,
-U16 dlIndex
+uint16_t dlIndex
));
PRIVATE Void rgSCHDrxTtiHdlUlHarqRTT ARGS((
RgSchCellCb *cell,
-U16 ulIndex
+uint16_t ulIndex
));
- PRIVATE S16 rgSCHDrxTtiHdlOnDur ARGS((RgSchCellCb *cellCb, U16 dlIndex,
- U16 ulIndex));
- PRIVATE S16 rgSCHDrxTtiHdlInActv ARGS((RgSchCellCb *cellCb, U16 dlIndex,
- U16 ulIndex));
- PRIVATE S16 rgSCHDrxTtiHdlShortCycle ARGS((RgSchCellCb *cell, U16 dlIndex,
- U16 ulIndex));
- PRIVATE S16 rgSCHDrxTtiHdlDlHarq ARGS((RgSchCellCb *cellCb, U16 dlIndex,
- U16 ulIndex));
+ PRIVATE S16 rgSCHDrxTtiHdlOnDur ARGS((RgSchCellCb *cellCb, uint16_t dlIndex,
+ uint16_t ulIndex));
+ PRIVATE S16 rgSCHDrxTtiHdlInActv ARGS((RgSchCellCb *cellCb, uint16_t dlIndex,
+ uint16_t ulIndex));
+ PRIVATE S16 rgSCHDrxTtiHdlShortCycle ARGS((RgSchCellCb *cell, uint16_t dlIndex,
+ uint16_t ulIndex));
+ PRIVATE S16 rgSCHDrxTtiHdlDlHarq ARGS((RgSchCellCb *cellCb, uint16_t dlIndex,
+ uint16_t ulIndex));
PRIVATE S16 rgSCHDrxCpyUeCfg ARGS((RgSchDrxUeCb *drxCb,
RgrUeDrxCfg* ueDrxCfg));
PRIVATE S16 rgSCHDrxGetNxtOnDur ARGS((RgSchCellCb* cell,RgSchDrxUeCb* drxCb,
CmLteTimingInfo* nxtOnDur,
- U8 delta));
+ uint8_t delta));
PRIVATE Void rgSCHDrxMvToNxtOnDurOcc ARGS((RgSchCellCb* cell,
RgSchUeCb* ue,
- U16 idx,
+ uint16_t idx,
Bool calcFrmOffst));
#ifdef LTE_TDD
PRIVATE Void rgSCHDrxCalcNxtTmrExpry ARGS((RgSchCellCb *cell,
RgSchUeCb *ue,
- U16 delta,
- U32 tmrLen,
+ uint16_t delta,
+ uint32_t tmrLen,
S16 *distance,
- U16 *idx
+ uint16_t *idx
));
-PRIVATE S16 rgSCHDrxGetNxtTmrExpry ARGS((RgSchCellCb *cell,U16 curTime,
- U32 duration,
+PRIVATE S16 rgSCHDrxGetNxtTmrExpry ARGS((RgSchCellCb *cell,uint16_t curTime,
+ uint32_t duration,
CmLteTimingInfo* tmrExpryIdx));
#endif /* LTE_TDD */
#ifdef EMTC_ENABLE
EXTERN S16 rgSCHDrxTtiHdlUlHarq
(
RgSchCellCb *cell,
-U16 dlIndex,
-U16 ulIndex
+uint16_t dlIndex,
+uint16_t ulIndex
);
EXTERN Void rgSCHDrxUeUlHqReset
(
RgSchCellCb *cell;
#endif
{
- U16 dlIndex;
- U16 ulIndex;
+ uint16_t dlIndex;
+ uint16_t ulIndex;
dlIndex = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot +
RG_SCH_DRX_DL_DELTA) % RG_SCH_MAX_DRXQ_SIZE;
#endif /*LTEMAC_R9*/
- RETVOID;
+ return;
}/*rgSCHDrxTtiInd*/
*
*
* @param RgSchCellCb *cellCb
- * @param U16 dlIndex
- * @param U16 ulIndex
+ * @param uint16_t dlIndex
+ * @param uint16_t ulIndex
* @return ROK/RFAILED
*/
PRIVATE S16 rgSCHDrxTtiHdlOnDur
(
RgSchCellCb* cell,
-U16 dlIndex,
-U16 ulIndex
+uint16_t dlIndex,
+uint16_t ulIndex
)
#else
PRIVATE S16 rgSCHDrxTtiHdlOnDur(cell, dlIndex, ulIndex)
RgSchCellCb* cell;
-U16 dlIndex;
-U16 ulIndex;
+uint16_t dlIndex;
+uint16_t ulIndex;
#endif
{
*
*
* @param RgSchCellCb *cellCb
- * @param U16 dlIndex
- * @param U16 ulIndex
+ * @param uint16_t dlIndex
+ * @param uint16_t ulIndex
* @return ROK/RFAILED
*/
S16 rgSCHDrxTtiHdlInActv
(
RgSchCellCb *cell,
-U16 dlIndex,
-U16 ulIndex
+uint16_t dlIndex,
+uint16_t ulIndex
)
#else
S16 rgSCHDrxTtiHdlInActv(cell, dlIndex, ulIndex)
RgSchCellCb *cell;
-U16 dlIndex;
-U16 ulIndex;
+uint16_t dlIndex;
+uint16_t ulIndex;
#endif
{
CmLList *node;
RgSchDRXCellCb *drxCell=NULLP;
RgSchUeCb *ue=NULLP;
RgSchDrxUeCb *drxUe=NULLP;
- U16 shrtCycleExpIndx;
+ uint16_t shrtCycleExpIndx;
CmLListCp dlInactvLst; /* list of UE's becoming DL-inactive */
CmLListCp ulInactvLst; /* list of UE's becoming UL-inactive */
RgSchCmnCell *cellSch = NULLP;
*
*
* @param RgSchCellCb *cell
- * @param U16 dlIndex
- * @param U16 ulIndex
+ * @param uint16_t dlIndex
+ * @param uint16_t ulIndex
* @return ROK/RFAILED
*/
S16 rgSCHDrxTtiHdlShortCycle
(
RgSchCellCb *cell,
-U16 dlIndex,
-U16 ulIndex
+uint16_t dlIndex,
+uint16_t ulIndex
)
#else
S16 rgSCHDrxTtiHdlShortCycle (cell, dlIndex, ulIndex)
RgSchCellCb *cell;
-U16 dlIndex;
-U16 ulIndex;
+uint16_t dlIndex;
+uint16_t ulIndex;
#endif
{
CmLList *node;
*
*
* @param RgSchCellCb *cellCb
- * @param U16 dlIndex
- * @param U16 ulIndex
+ * @param uint16_t dlIndex
+ * @param uint16_t ulIndex
* @return ROK/RFAILED
*/
PRIVATE S16 rgSCHDrxTtiHdlDlHarq
(
RgSchCellCb *cell,
-U16 dlIndex,
-U16 ulIndex
+uint16_t dlIndex,
+uint16_t ulIndex
)
#else /* ANSI */
PRIVATE S16 rgSCHDrxTtiHdlDlHarq (cell, dlIndex, ulIndex)
RgSchCellCb *cell;
-U16 dlIndex;
-U16 ulIndex;
+uint16_t dlIndex;
+uint16_t ulIndex;
#endif /* ANSI */
{
*
* @param RgSchCellCb *cell
* @param CmLListCp *ueUlLst
- * @param U8 direction
+ * @param uint8_t direction
* @return Void
*/
(
RgSchCellCb *cell,
CmLListCp *ueLst,
-U8 direction
+uint8_t direction
)
#else
Void rgSCHDrxStrtInActvTmr(cell, ueLst, direction)
RgSchCellCb *cell;
CmLListCp *ueLst;
-U8 direction;
+uint8_t direction;
#endif
{
CmLList *node;
RgSchUeCb *ueCb;
RgSchDrxUeCb *ueDrxCb;
#ifndef LTE_TDD
- U16 index1;
+ uint16_t index1;
#endif
- U16 inActvTmrExpIndx;
+ uint16_t inActvTmrExpIndx;
#ifndef LTE_TDD
- U16 curTimeInSf; /* current time in number of subframes */
+ uint16_t curTimeInSf; /* current time in number of subframes */
#endif
#ifdef LTE_TDD
- U16 delta;
+ uint16_t delta;
#endif /*LTE_TDD*/
CmLListCp dlInactvLst; /* list of UE's becoming DL-inactive */
CmLListCp ulInactvLst; /* list of UE's becoming UL-inactive */
cellSch = RG_SCH_CMN_GET_CELL(cell);
cellSch->apisDl->rgSCHDlInactvtUes(cell,&dlInactvLst);
- RETVOID;
+ return;
}/*rgSCHDrxStrtInActvTmr*/
/** @brief This function is called by the downlink HARQ module on receiving a
*
* @param RgSchCellCb *cell
* @param RgSchDlHqProcCb *dlHq
- * @param U8 tbCnt
+ * @param uint8_t tbCnt
* @return Void
*/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqP,
-U8 tbCnt
+uint8_t tbCnt
)
#else
Void rgSCHDrxStartHarqRTTTmr(cell, hqP, tbCnt)
RgSchCellCb *cell;
RgSchDlHqProcCb *hqP;
-U8 tbCnt;
+uint8_t tbCnt;
#endif
{
RgSchDRXCellCb *drxCell =NULLP;
RgSchDrxDlHqProcCb *drxHq =NULLP;
- U16 harqRTTExpIndx;
- U8 fdbkDelta;
+ uint16_t harqRTTExpIndx;
+ uint8_t fdbkDelta;
#ifdef LTE_TDD
- U8 firstDlTxOcassion;
- U8 drxRetxTmrStartSf;
+ uint8_t firstDlTxOcassion;
+ uint8_t drxRetxTmrStartSf;
#endif
drxCell = RG_SCH_DRX_GET_CELL(cell);
may not be possible */
drxRetxTmrStartSf = (hqP->tbInfo[tbCnt].fdbkTime.subframe +
firstDlTxOcassion) % RGSCH_NUM_SUB_FRAMES;
- U8 i;
+ uint8_t i;
/* We are here because the Retx Timer start is moved by atleast one
position. Hence the timer will be reduced by minimum one */
drxHq->retxTmrReduction = 1;
drxHq->harqRTTEnt.node = (PTR)hqP;
drxHq->rttIndx = harqRTTExpIndx;
- RETVOID;
+ return;
}/*rgSCHDrxStartHarqRTTTmr*/
S16 ret = ROK;
RgSchDrxUeCb *ueDrxCb;
CmLteTimingInfo nxtOnDur;
- U16 onDurIndx;
- U16 nxtOnDurTime;
- U16 curTime;
- U8 cellIdx;
+ uint16_t onDurIndx;
+ uint16_t nxtOnDurTime;
+ uint16_t curTime;
+ uint8_t cellIdx;
#if ( ERRCLASS & ERRCLS_INT_PAR )
* @param RgSchCellCb *cell
* @param RgSchDrxUeCb *drxCb
* @param CmLteTimingInfo *nxtOnDur
- * @param U8 delta
+ * @param uint8_t delta
* @return ROK/RFAILED
*/
#ifdef ANSI
RgSchCellCb *cell,
RgSchDrxUeCb *drxCb,
CmLteTimingInfo *nxtOnDur,
- U8 delta
+ uint8_t delta
)
#else
PRIVATE S16 rgSCHDrxGetNxtOnDur (cell, drxCb, nxtOnDur, delta)
RgSchCellCb *cell;
RgSchDrxUeCb *drxCb;
CmLteTimingInfo *nxtOnDur;
- U8 delta;
+ uint8_t delta;
#endif
{
- U16 curTime;
- U16 curDist;
- U16 cycleLen;
- U32 numOfCycles;
- U32 nxtDist;
+ uint16_t curTime;
+ uint16_t curDist;
+ uint16_t cycleLen;
+ uint32_t numOfCycles;
+ uint32_t nxtDist;
#if ( ERRCLASS & ERRCLS_INT_PAR )
{
/* offset is the nextOnDur */
nxtOnDur->sfn = drxCb->drxStartOffset / RGSCH_NUM_SUB_FRAMES_5G;
- nxtOnDur->slot = (U8)(drxCb->drxStartOffset % RGSCH_NUM_SUB_FRAMES_5G);
+ nxtOnDur->slot = (uint8_t)(drxCb->drxStartOffset % RGSCH_NUM_SUB_FRAMES_5G);
nxtDist = ((nxtOnDur->sfn * RGSCH_NUM_SUB_FRAMES_5G) + nxtOnDur->slot);
}
else
{
/* Perfect match pick up the current time */
/*nxtOnDur should be set to equal to currentTime + DELTA */
- nxtOnDur->sfn = (U16)curTime / RGSCH_NUM_SUB_FRAMES_5G;
- nxtOnDur->slot = (U16)curTime % RGSCH_NUM_SUB_FRAMES_5G;
+ nxtOnDur->sfn = (uint16_t)curTime / RGSCH_NUM_SUB_FRAMES_5G;
+ nxtOnDur->slot = (uint16_t)curTime % RGSCH_NUM_SUB_FRAMES_5G;
nxtDist = ((nxtOnDur->sfn * RGSCH_NUM_SUB_FRAMES_5G) + nxtOnDur->slot);
}
{
nxtDist = drxCb->drxStartOffset + (numOfCycles + 1) *
cycleLen;
- nxtOnDur->sfn = (U16)nxtDist / RGSCH_NUM_SUB_FRAMES_5G;
- nxtOnDur->slot = (U16)nxtDist % RGSCH_NUM_SUB_FRAMES_5G;
+ nxtOnDur->sfn = (uint16_t)nxtDist / RGSCH_NUM_SUB_FRAMES_5G;
+ nxtOnDur->slot = (uint16_t)nxtDist % RGSCH_NUM_SUB_FRAMES_5G;
}
}
if((nxtDist - (curTime - delta)) <= RG_SCH_DRX_MAX_DELTA)
{
nxtDist = nxtDist + cycleLen;
- nxtOnDur->sfn = (U16)nxtDist / RGSCH_NUM_SUB_FRAMES_5G;
- nxtOnDur->slot = (U16)nxtDist % RGSCH_NUM_SUB_FRAMES_5G;
+ nxtOnDur->sfn = (uint16_t)nxtDist / RGSCH_NUM_SUB_FRAMES_5G;
+ nxtOnDur->slot = (uint16_t)nxtDist % RGSCH_NUM_SUB_FRAMES_5G;
}
return ROK;
} /* end of rgSCHDrxGetNxtOnDur */
Inst instIdx = cell->instIdx;
RgSchDrxUeCb *ueDrxCb;
CmLteTimingInfo nxtOnDur;
- U16 nxtOnDurTime;
- U16 onDurIndx;
- U16 curTime;
- U16 shrtCycleExpIndx;
- U16 onDurExpTime;
- U16 cycleLen;
- U16 curIndx;
- U8 cellIdx;
+ uint16_t nxtOnDurTime;
+ uint16_t onDurIndx;
+ uint16_t curTime;
+ uint16_t shrtCycleExpIndx;
+ uint16_t onDurExpTime;
+ uint16_t cycleLen;
+ uint16_t curIndx;
+ uint8_t cellIdx;
/* drx was disabled but now enabled for this ue */
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqEnt *hqE,
- U8 cellIdx
+ uint8_t cellIdx
)
#else
Void rgSCHDrxUeHqReset(cell, ue, hqE, cellIdx)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqEnt *hqE;
- U8 cellIdx;
+ uint8_t cellIdx;
#endif
{
RgSchDlHqProcCb *hqP;
RgSchDrxDlHqProcCb *drxHq =NULLP;
- U8 i;
+ uint8_t i;
for(i=0; i < hqE->numHqPrcs; i++)
{
{
RgSchDrxUeCb *ueDrxCb;
RgSchDlHqEnt *hqE = NULLP;
- U8 cellIdx;
+ uint8_t cellIdx;
RgSchUeCellInfo *cellInfo = NULLP;
#ifdef EMTC_ENABLE
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
rgSCHUtlFreeSBuf(instIdx, (Data **)(&(cell->drxCb)),
sizeof(RgSchDRXCellCb));
}
- RETVOID;
+ return;
} /* end of rgSchDrxCellDel */
/** @brief This function is called when an SR is received from the UE. In this
drxCb->raRcvd = TRUE;
- RETVOID;
+ return;
} /* end of rgSCHDrxDedRa */
*
* @param RgSchCellCb *cell
* @param RgSchUeCb *ueCb
- * @param U16 idx - if calcFrmOffst is TRUE,
+ * @param uint16_t idx - if calcFrmOffst is TRUE,
* idx is delta to be added
* @param Bool calcFrmOffst
* @return Void
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
-U16 idx,
+uint16_t idx,
Bool calcFrmOffst
)
#else
PRIVATE Void rgSCHDrxMvToNxtOnDurOcc (cell, ueCb, idx, calcFrmOffst)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
-U16 idx;
+uint16_t idx;
Bool calcFrmOffst;
#endif
{
- U16 nxtOnDurIndex;
- U16 curTime;
+ uint16_t nxtOnDurIndex;
+ uint16_t curTime;
RgSchDrxUeCb *drxUe;
RgSchDRXCellCb *drxCell;
CmLteTimingInfo nxtOnDur; /* to be used when calcFrmOffset is set */
- U16 nxtOnDurInSf; /* next On Duration in no of subframes */
+ uint16_t nxtOnDurInSf; /* next On Duration in no of subframes */
drxCell = cell->drxCb;
drxUe = ueCb->drxCb;
}
else
{
- rgSCHDrxGetNxtOnDur(cell,drxUe,&nxtOnDur,(U8)idx);
+ rgSCHDrxGetNxtOnDur(cell,drxUe,&nxtOnDur,(uint8_t)idx);
nxtOnDurInSf = ((nxtOnDur.sfn * RGSCH_NUM_SUB_FRAMES_5G) +
nxtOnDur.slot);
drxUe->onDurationEnt.node = (PTR)ueCb;
drxUe->onDurIndx = nxtOnDurIndex;
- RETVOID;
+ return;
}/*rgSCHDrxMvToNxtOnDurOcc*/
#ifdef LTE_TDD
* and will expire on (15,1)
*
* @param RgSchUeCb *ue Ue control block.
- * @param U16 curTime current Time
- * @param U32 duration Timer duration
+ * @param uint16_t curTime current Time
+ * @param uint32_t duration Timer duration
* @param CmLteTimingInfo *tmrExpryIdx Timer expry (SFN,sf)
* @return ROK/RFAILED
*/
PRIVATE S16 rgSCHDrxGetNxtTmrExpry
(
RgSchCellCb *cell,
- U16 curTime,
- U32 duration,
+ uint16_t curTime,
+ uint32_t duration,
CmLteTimingInfo *tmrExpryIdx
)
#else
PRIVATE S16 rgSCHDrxGetNxtTmrExpry (cell,curTime,duration,tmrExpryIdx)
RgSchCellCb *cell;
- U16 curTime;
- U32 duration;
+ uint16_t curTime;
+ uint32_t duration;
CmLteTimingInfo *tmrExpryIdx;
#endif
{
- U32 dlSfTillNxtSFN; /*!< DL subframes till next SFN */
- U8 tddCfgMode; /*!< tdd config mode */
+ uint32_t dlSfTillNxtSFN; /*!< DL subframes till next SFN */
+ uint8_t tddCfgMode; /*!< tdd config mode */
Bool isDwPtsCnted; /*!< is DwPts counted as PDCCH sf */
CmLteTimingInfo crntTime; /*!< current SFN & sf */
if ( dlSfTillNxtSFN >= duration )
{
/* the timer would expire on the same RF */
- U32 diff = dlSfTillNxtSFN - duration;
+ uint32_t diff = dlSfTillNxtSFN - duration;
tmrExpryIdx->sfn = crntTime.sfn;
}
else
{
- U8 arrayIdx;
+ uint8_t arrayIdx;
/* to know the DL sf index based on diff */
arrayIdx = rgSchDrxDlSfTddCfg[isDwPtsCnted][tddCfgMode];
}/* if ( dlSfTillNxtSFN >= duration...*/
else
{
- U32 remSf; /*!< remaining subframes */
- U32 numRf; /*!< num of complete radio frames */
- U32 numRemSfs; /*!< num of remaining subframes */
+ uint32_t remSf; /*!< remaining subframes */
+ uint32_t numRf; /*!< num of complete radio frames */
+ uint32_t numRemSfs; /*!< num of remaining subframes */
remSf = duration - dlSfTillNxtSFN;
/* move to (currSFN,9) having consued dlSfTillNxtSFN DL subframes */
tmrExpryIdx->sfn = crntTime.sfn;
- tmrExpryIdx->subframe = (U8)9;
+ tmrExpryIdx->subframe = (uint8_t)9;
numRf = (1 * remSf)/rgSchDrxDlSfTddCfg[isDwPtsCnted][tddCfgMode];
numRemSfs = (1 * remSf)%rgSchDrxDlSfTddCfg[isDwPtsCnted][tddCfgMode];
*
* @param RgSchCellCb *cell
* @param RgSchUeCb *ue
- * @param U16 delta
- * @param U32 tmrLen
- * @param U16 *distance
+ * @param uint16_t delta
+ * @param uint32_t tmrLen
+ * @param uint16_t *distance
* @param S16 *idx
* @return ROK/RFAILED
*/
(
RgSchCellCb *cell,
RgSchUeCb *ue,
- U16 delta,
- U32 tmrLen,
+ uint16_t delta,
+ uint32_t tmrLen,
S16 *distance,
- U16 *idx
+ uint16_t *idx
)
#else
PRIVATE Void rgSCHDrxCalcNxtTmrExpry (cell,ue,delta,tmrLen,distance,idx)
RgSchCellCb *cell;
RgSchUeCb *ue;
- U16 delta;
- U32 tmrLen;
+ uint16_t delta;
+ uint32_t tmrLen;
S16 *distance;
- U16 *idx;
+ uint16_t *idx;
#endif
{
- U16 curTimeInSf; /*current time in no of subframes*/
+ uint16_t curTimeInSf; /*current time in no of subframes*/
CmLteTimingInfo tmrExpry;
- U16 tmrExpryInSf; /*timer expry in no of subframes*/
+ uint16_t tmrExpryInSf; /*timer expry in no of subframes*/
curTimeInSf = cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G +
cell->crntTime.slot;
}
}
- RETVOID;
+ return;
}/*rgSCHDrxCalcNxtTmrExpry*/
/* ccpu00134670- Validating onduration timer versus DRX cycle*/
S16 rgSCHCfgVldtTddDrxCycCfg
(
RgSchCellCb *cell,
-U16 drxCycle,
-U8 onDurTmr,
-U16 offSet
+uint16_t drxCycle,
+uint8_t onDurTmr,
+uint16_t offSet
)
#else
S16 rgSCHCfgVldtTddDrxCycCfg(cell, drxCycle, onDurTmr, offSet)
RgSchCellCb *cell;
-U16 drxCycle;
-U8 onDurTmr;
-U16 offSet;
+uint16_t drxCycle;
+uint8_t onDurTmr;
+uint16_t offSet;
#endif
{
- U16 startTime;
- U16 endTimeInSf;
+ uint16_t startTime;
+ uint16_t endTimeInSf;
CmLteTimingInfo endTime;
startTime = offSet;
*
*
* @param RgSchCellCb *cellCb
- * @param U16 ulIndex
+ * @param uint16_t ulIndex
* @return Void
*/
PRIVATE Void rgSCHDrxTtiHdlOnDurUl
(
RgSchCellCb *cell,
-U16 ulIndex
+uint16_t ulIndex
)
#else
PRIVATE Void rgSCHDrxTtiHdlOnDurUl(cell, ulIndex)
RgSchCellCb *cell;
-U16 ulIndex;
+uint16_t ulIndex;
#endif
{
CmLList *node;
cellSch = RG_SCH_CMN_GET_CELL(cell);
cellSch->apisUl->rgSCHUlInactvtUes(cell, &ulInactvLst);
- RETVOID;
+ return;
}
/** @brief This function is called to handle onDurationTimer per TTI processing.
*
*
* @param RgSchCellCb *cellCb
- * @param U16 dlIndex
+ * @param uint16_t dlIndex
* @return Void
*/
PRIVATE Void rgSCHDrxTtiHdlOnDurDl
(
RgSchCellCb *cell,
-U16 dlIndex
+uint16_t dlIndex
)
#else
PRIVATE Void rgSCHDrxTtiHdlOnDurDl(cell, dlIndex)
RgSchCellCb *cell;
-U16 dlIndex;
+uint16_t dlIndex;
#endif
{
CmLList *node;
RgSchUeCb *ue = NULLP;
RgSchDrxUeCb *drxUe = NULLP;
RgSchCmnCell *cellSch = NULLP;
- U16 expiryIndex;
+ uint16_t expiryIndex;
CmLListCp dlInactvLst; /* list of UE's becoming DL-inactive */
Bool delInUlScan = FALSE;
cellSch = RG_SCH_CMN_GET_CELL(cell);
cellSch->apisDl->rgSCHDlInactvtUes(cell, &dlInactvLst);
- RETVOID;
+ return;
}/*rgSCHDrxTtiHdlOnDurDl*/
/** @brief This function handles the Dl HARQ timer's processing per TTI.
* process accordingly.
*
* @param RgSchCellCb *cellCb
- * @param U16 dlIndex
+ * @param uint16_t dlIndex
* @return Void
*/
PRIVATE Void rgSCHDrxTtiHdlDlHarqRTT
(
RgSchCellCb *cell,
-U16 dlIndex
+uint16_t dlIndex
)
#else /* ANSI */
PRIVATE Void rgSCHDrxTtiHdlDlHarqRTT(cell, dlIndex)
RgSchCellCb *cell;
-U16 dlIndex;
+uint16_t dlIndex;
#endif /* ANSI */
{
CmLList *node;
RgSchDlHqProcCb *dlHq;
RgSchDRXCellCb *drxCell;
RgSchDrxUeCb *drxUe;
- U16 reTxExpIndx;
+ uint16_t reTxExpIndx;
Bool delInUlScan;
RgSchUeCb *ue;
CmLListCp dlInactvLst; /* list of UE's becoming DL-inactive */
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 cellIdx;
- U32 dlInactvMask;
+ uint8_t cellIdx;
+ uint32_t dlInactvMask;
drxCell = cell->drxCb;
delInUlScan = drxCell->delInUlScan;
/*Call schedulers to inactivate ue*/
cellSch->apisDl->rgSCHDlInactvtUes(cell, &dlInactvLst);
- RETVOID;
+ return;
}
/** @brief This function handles the Ul HARQ timer's processing per TTI.
*
*
* @param RgSchCellCb *cellCb
- * @param U16 ulIndex
+ * @param uint16_t ulIndex
* @return Void
*/
PRIVATE Void rgSCHDrxTtiHdlUlHarqRTT
(
RgSchCellCb *cell,
-U16 ulIndex
+uint16_t ulIndex
)
#else /* ANSI */
PRIVATE Void rgSCHDrxTtiHdlUlHarqRTT(cell, ulIndex)
RgSchCellCb *cell;
-U16 ulIndex;
+uint16_t ulIndex;
#endif /* ANSI */
{
CmLList *node;
RgSchUeCb *ue;
CmLListCp ulInactvLst; /* list of UE's becoming DL-inactive */
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- U8 cellIdx;
- U32 ulInactvMask;
+ uint8_t cellIdx;
+ uint32_t ulInactvMask;
drxCell = cell->drxCb;
}
cellSch->apisUl->rgSCHUlInactvtUes(cell, &ulInactvLst);
- RETVOID;
+ return;
}
Void rgSCHCmnSpsInit ()
#endif /* ANSI */
{
- RETVOID;
+
+ return;
}
/**
#endif /* ANSI */
{
- RETVOID;
+ return;
}
/**
#endif /* ANSI */
{
- RETVOID;
+ return;
}
/**
RgSchCellCb *cell
))
{
- RETVOID;
+ return;
}
S16 rgSCHCmnSpsDlLcRecfg ARGS((
RgSchLcgCb *lcg
))
{
- RETVOID;
+ return;
}
Void rgSCHCmnSpsDlLcDel ARGS((
RgSchDlLcCb *dlLc
))
{
- RETVOID;
+ return;
}
S16 rgSCHCmnSpsUlTti ARGS((
))
{
- RETVOID;
+ return;
}
Void rgSCHCmnSpsDlProcAddToRetx ARGS((
))
{
- RETVOID;
+ return;
}
Void rgSCHCmnSpsDlCqiIndHndlr ARGS((
))
{
- RETVOID;
+ return;
}
S16 rgSCHCmnSpsUlCqiInd ARGS((
))
{
- RETVOID;
+ return;
}
Void rgSCHCmnSpsDlRelPdcchFbk ARGS((
))
{
- RETVOID;
+ return;
}
Void rgSCHCmnSpsDlProcAck ARGS((
))
{
- RETVOID;
+ return;
}
Void rgSCHCmnSpsDlUeReset ARGS((
))
{
- RETVOID;
+ return;
}
Void rgSCHCmnSpsUlUeReset ARGS((
))
{
- RETVOID;
+ return;
}
Void rgSCHCmnSpsUlProcRelInd ARGS((
))
{
- RETVOID;
+ return;
}
Void rgSCHCmnSpsUlProcActInd ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U16 spsSduSize
+uint16_t spsSduSize
))
{
- RETVOID;
+ return;
}
S16 rgSCHCmnSpsUlProcCrcInd ARGS((
))
{
- RETVOID;
+ return;
}
RgrDel *del,RgSchErrInfo *errInfo));
#ifdef LTE_ADV
PRIVATE S16 rgSCHGomHndlSCellActDeactReq ARGS((RgSchCb *instCb, SpId spId,
- RgrSCellActDeactEvnt *sCellActDeactEvnt, RgSchErrInfo *errInfo, U8 action));
+ RgrSCellActDeactEvnt *sCellActDeactEvnt, RgSchErrInfo *errInfo, uint8_t action));
#endif /* LTE_ADV */
#ifdef EMTC_ENABLE
EXTERN S16 rgSchEmtcGetSiWinPerd ARGS((
RgSchCellCb *cell,
-U16 *siWinSize,
-U16 *minPeriod
+uint16_t *siWinSize,
+uint16_t *minPeriod
));
extern S16 rgSCHEmtcUtlCalMcsAndNPrb
(
RgSchCellCb *cell,
- U8 cfgType,
+ uint8_t cfgType,
MsgLen msgLen,
- U8 siId
+ uint8_t siId
);
EXTERN S32 rgSCHEmtcUtlGetAllwdCchTbSzForSI ARGS(
(
-U32 bo
+uint32_t bo
));
EXTERN Void rgSCHEmtcWarningSiCfg ARGS(
(
RgSchCellCb *cell,
RgrWarningSiCfgReqInfo *warningSiCfgReqInfo,
-U16 idx
+uint16_t idx
));
#endif
SpId spId = 0;
CmLteCellId cellId;
RgSchCellCb *cell = NULLP;
- U8 cfmStatus = RGR_CFG_CFM_NOK;
+ uint8_t cfmStatus = RGR_CFG_CFM_NOK;
#ifdef DEBUGP
Inst inst = (instCb->rgSchInit.inst );
#endif
#endif
{
SpId spId = 0;
- U8 cfmStatus = RGR_CFG_CFM_OK;
+ uint8_t cfmStatus = RGR_CFG_CFM_OK;
S16 ret;
RgSchErrInfo errInfo;
#ifdef DEBUGP
#endif
{
S16 ret;
- U32 sfDiff;
+ uint32_t sfDiff;
RgSchCfgElem *rgrCfgElem = NULLP;
CmLteTimingInfo actvTime;
Inst inst = cell->instIdx;
/* Allocate memory for config Element */
ret = rgSCHUtlAllocSBuf(inst, (Data **)&rgrCfgElem, sizeof(RgSchCfgElem));
- if ((ret != ROK) || ((U8 *)rgrCfgElem == NULLP))
+ if ((ret != ROK) || ((uint8_t *)rgrCfgElem == NULLP))
{
return RFAILED;
}
* @param[in] RgSchCb *instCb
* @param[in] SpId spId
* @param[in] RgrSCellActDeactEvnt *sCellActDeactEvnt
- * @param[in] U8 action
+ * @param[in] uint8_t action
* @param[out] RgSchErrInfo *errInfo
* @return S16
* -# ROK
SpId spId,
RgrSCellActDeactEvnt *sCellActDeactEvnt,
RgSchErrInfo *errInfo,
-U8 action
+uint8_t action
)
#else
PRIVATE S16 rgSCHGomHndlSCellActDeactReq(instCb, spId, sCellActDeactEvnt, errInfo, action)
SpId spId;
RgrSCellActDeactEvnt *sCellActDeactEvnt;
RgSchErrInfo *errInfo;
-U8 action;
+uint8_t action;
#endif
{
RgSchUeCb *ue = NULLP;
- U16 idx = 0;
- U16 sCellIdx = 0;
+ uint16_t idx = 0;
+ uint16_t sCellIdx = 0;
RgSchCellCb *cell = instCb->rgrSap[spId].cell;
Inst inst = (instCb->rgSchInit.inst);
#ifdef DEBUGP
Inst inst = (instCb->rgSchInit.inst);
#endif
- VOLATILE U32 startTime=0;
+ VOLATILE uint32_t startTime=0;
errInfo->errType = RGSCHERR_GOM_DEL_REQ;
if(ret == ROK)
{
/* TODO::Needs to be revisited after tti flow CaDev Start */
- U8 idx = (U8)((instCb->rgrSap[spId].cell->cellId - instCb->genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
+ uint8_t idx = (uint8_t)((instCb->rgrSap[spId].cell->cellId - instCb->genCfg.startCellId)&(CM_LTE_MAX_CELLS-1));
instCb->cells[idx] = NULLP;
/* CaDev End */
instCb->rgrSap[spId].cell = NULLP;
RgSchCellCb *cell = instCb->rgrSap[spId].cell;
Inst inst = (instCb->rgSchInit.inst );
RgSchErrInfo errInfo;
- U8 cfmStatus = RGR_CFG_CFM_NOK;
+ uint8_t cfmStatus = RGR_CFG_CFM_NOK;
MsgLen msgLen = 0, pduLen;
S32 tbSz = 0;
- U8 nPrb = 0;
- U8 mcs = 0;
+ uint8_t nPrb = 0;
+ uint8_t mcs = 0;
/* check if cell does not exists */
- if (((U8 *)cell == NULLP) || (cell->cellId != cfgReqInfo->cellId))
+ if (((uint8_t *)cell == NULLP) || (cell->cellId != cfgReqInfo->cellId))
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cfgReqInfo->cellId,"Cell Control block does not exist"
);
}
else /* Initial Si cfg or si recfg where numSi did not change */
{
- U8 bitMask;
+ uint8_t bitMask;
/* Initial Si cfg */
if (cell->siCb.crntSiInfo.siInfo[cfgReqInfo->siId-1].si == NULLP)
{
#endif
{
RgSchCellCb *cell = instCb->rgrSap[spId].cell;
- U8 cfmStatus = RGR_CFG_CFM_NOK;
- U16 idx;
- U8 siId = warningSiCfgReqInfo->siId;
- U8 j, mcs=0, nPrb=0;
+ uint8_t cfmStatus = RGR_CFG_CFM_NOK;
+ uint16_t idx;
+ uint8_t siId = warningSiCfgReqInfo->siId;
+ uint8_t j, mcs=0, nPrb=0;
RgSchWarningSiSeg *warningSiMsg;
RgSchWarningSiPdu *pduNode;
CmLList *node;
MsgLen msgLen = 0;
Bool freeNodeFound = FALSE;
- U16 siWinSize = 0;
- U16 minPeriod = 0;
+ uint16_t siWinSize = 0;
+ uint16_t minPeriod = 0;
#ifdef EMTC_ENABLE
- U8 isEmtc = warningSiCfgReqInfo->emtcEnable;
+ uint8_t isEmtc = warningSiCfgReqInfo->emtcEnable;
#endif
#ifdef EMTC_ENABLE
minPeriod = cell->siCfg.minPeriodicity;
}
/* check if cell does not exists */
- if (((U8 *)cell == NULLP) ||
+ if (((uint8_t *)cell == NULLP) ||
(cell->cellId != warningSiCfgReqInfo->cellId) ||
(warningSiCfgReqInfo->siId >
((minPeriod * 10)/siWinSize)))
Region reg,
Pool pool,
RgSchCb *instCb,
-U8 siId,
+uint8_t siId,
RgrCfgTransId transId,
SpId spId
)
Region reg;
Pool pool;
RgSchCb *instCb;
-U8 siId;
+uint8_t siId;
RgrCfgTransId transId;
SpId spId;
#endif
{
RgSchCellCb *cell = instCb->rgrSap[spId].cell;
- U16 idx;
+ uint16_t idx;
CmLList *node;
RgSchWarningSiPdu *warningSiPdu;
Buffer *pdu;
{
if(cell->siCb.warningSi[idx].siId == siId)
{
- if ((cmMemcmp ((U8 *)&cell->siCb.warningSi[idx].warningSiMsg.transId,
- (U8 *)&transId, sizeof(RgrCfgTransId))) == 0)
+ if ((cmMemcmp ((uint8_t *)&cell->siCb.warningSi[idx].warningSiMsg.transId,
+ (uint8_t *)&transId, sizeof(RgrCfgTransId))) == 0)
{
/* ccpu00136659: CMAS ETWS design changes */
CM_LLIST_FIRST_NODE(&cell->siCb.warningSi[idx].warningSiMsg.segLstCp, node);
}
}
}
- RETVOID;
+ return;
}
#endif/*RGR_SI_SCH */
RgSchCellCb *cell = instCb->rgrSap[spId].cell;
Inst inst = (instCb->rgSchInit.inst );
RgSchErrInfo errInfo;
- U16 i;
+ uint16_t i;
/* check if cell does not exists */
- if (((U8 *)cell == NULLP) || (cell->cellId != loadInfReq->cellId))
+ if (((uint8_t *)cell == NULLP) || (cell->cellId != loadInfReq->cellId))
{
RLOG_ARG1(L_ERROR,DBG_CELLID,loadInfReq->cellId,"Cell Control block does not exist"
"for load cellId:%d",loadInfReq->cellId);
Bool hdFddEnbl;
#endif /* ANSI */
{
- U8 sfi;
+ uint8_t sfi;
RLOG_ARG2(L_DEBUG,DBG_CELLID,cellCb->cellId,
"rgSCHHdFddUeCfg(): UeId =%d hdFddEnbl=%d",
RgSchCellCb *cellCb;
#endif /* ANSI */
{
- U16 sfn; /* System Frame Number */
- U32 pti; /* Index into Periodic table */
- U16 sfi; /* Index into HDFDD state table */
+ uint16_t sfn; /* System Frame Number */
+ uint32_t pti; /* Index into Periodic table */
+ uint16_t sfi; /* Index into HDFDD state table */
CmLListCp *cqiLst;
CmLListCp *srsLst;
CmLListCp *srLst;
CM_LLIST_NEXT_NODE(riLst, riNode);
}
- RETVOID;
+ return;
} /* rgSCHCmnHdFddPtUlMrk */
#endif /* ifdef TFU_UPGRADE */
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
- U8 *allow
+ uint8_t *allow
)
#else /* ANSI */
Void rgSCHCmnHdFddChkUlAllow ( cellCb, ueCb, allow)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
-U8 *allow;
+uint8_t *allow;
#endif /* ANSI */
{
- U16 sfn;
- U16 sfi;
+ uint16_t sfn;
+ uint16_t sfi;
CmLteTimingInfo timeInfo;
RgSchDlSf *sf = NULLP; /* Dl subframe info */
- U8 ulOffset
+ uint8_t ulOffset
RLOG_ARG1(L_DEBUG,DBG_CELLID,cellCb->cellId,
" rgSCHCmnHdFddChkUlAllow: ueId=%d ", ueCb->ueId);
RLOG_ARG1(L_DEBUG,DBG_CELLID,cellCb->cellId,
"rgSCHCmnHdFddChkUlAllow: Already marked for DL, ueId = %d ",
ueCb->ueId);
- RETVOID;
+ return;
}
/* Validate condition 3 */
RLOG_ARG1(L_DEBUG,DBG_CELLID,cellCb->cellId,
"rgSCHCmnHdFddChkUlAllow: No Place for HARQ, ueId = %d ",
ueCb->ueId);
- RETVOID;
+ return;
}
/* Validate condition 4 */
RLOG_ARG1(L_DEBUG,DBG_CELLID,cellCb->cellId,
" rgSCHCmnHdFddChkUlAllow: No Place for UL grant, ueId = %d ",
ueCb->ueId);
- RETVOID;
+ return;
}
/* Validate condition 5 */
RLOG_ARG1(L_DEBUG,DBG_CELLID,cellCb->cellId,
" rgSCHCmnHdFddChkUlAllow: No Place for Guard time, ueId = %d ",
ueCb->ueId);
- RETVOID;
+ return;
}
/* Adition guard time rule check: Above check is only for PDSCH, lets check
RLOG_ARG1(L_DEBUG,DBG_CELLID,cellCb->cellId,
"rgSCHCmnHdFddChkUlAllow: Already marked for Cmn DL, ueId = %d ",
ueCb->ueId);
- RETVOID;
+ return;
}
/* All validation done. Safe to for UL */
*allow = TRUE;
- RETVOID;
+ return;
} /* rgSCHCmnHdFddChkUlAllow */
* @param[in] RgSchCellCb *cellCb
* @param[in] RgSchUeCb *ueCb
* @param[in] CmLteTimingInfo *timeInfo
- * @param[out] U8 *allow -- TRUE is allowed or FALSE if no allowedi.
+ * @param[out] uint8_t *allow -- TRUE is allowed or FALSE if no allowedi.
* Valdity of this pointer is not done in this function
*
*/
Bool *allow; /* Valdity of this pointer is not done in this function */
#endif /* ANSI */
{
- U16 sfn;
- U16 sfi;
+ uint16_t sfn;
+ uint16_t sfi;
RgSchDlSf *sf = NULLP; /* Dl subframe info */
CmLteTimingInfo timeInfo;
CmLteTimingInfo tempTimeInfo;
RLOG_ARG1(L_DEBUG,DBG_CELLID,cellCb->cellId,
"rgSCHCmnHdFddChkDlAllow: sf is UL, ueId=%d ", ueCb->ueId);
*allow = FALSE;
- RETVOID;
+ return;
}
/* It is not validation, but BCCH/PCCH marking is done here */
" rgSCHCmnHdFddChkDlAllow: Guard time rule not met, ueId=%d ",
ueCb->ueId);
*allow = FALSE;
- RETVOID;
+ return;
}
/* Validate condition 3 */
/* Mark this sf as DLCNTRL */
ueCb->hdFddCb->subfrm[sfi].subFrmDir =RG_SCH_HDFDD_DLCNTRL;
- RETVOID;
+ return;
}
"ueId=%d ",ueCb->ueId);
*allow = FALSE;
- RETVOID;
+ return;
}
/* First check for any Common channel info is scheduled */
*allow = TRUE;
/* All validation done. Safe to for DL */
- RETVOID;
+ return;
} /* rgSCHCmnHdFddChkDlAllow */
*sndNACK = TRUE;
}
- RETVOID;
+ return;
} /* rgSCHCmnHdFddChkNackAllow */
* @param[in] RgSchCellCb *cellCb
* @param[in] RgSchUeCb *ueCb
* @param[in] CmLteTimingInfo *timeInfo
- * @param[out] U8 *allow -- TRUE is allowed or FALSE if no allowedi.
+ * @param[out] uint8_t *allow -- TRUE is allowed or FALSE if no allowedi.
* Valdity of this pointer is not done in this function.
*
* @return None
#endif /* ANSI */
{
- U16 sfn;
- U16 sfi;
+ uint16_t sfn;
+ uint16_t sfi;
CmLteTimingInfo timeInfo;
- U8 ulOffset;
+ uint8_t ulOffset;
ulOffset = RGSCH_PDCCH_PUSCH_DELTA -
TFU_CRCIND_ULDELTA + RGSCH_PDCCH_PUSCH_DELTA;
RG_SCH_HDFDD_GETSFI(sfi, timeInfo, (ulOffset * -1));
RG_SCH_HDFDD_MARKSTATE(ueCb, RG_SCH_HDFDD_NOSCHD, RG_SCH_HDFDD_INVSFN, sfi);
- RETVOID;
+ return;
} /* rgSCHCmnHdFddUpdULMark */
* @param[in] RgSchCellCb *cellCb
* @param[in] RgSchUeCb *ueCb
* @param[in] CmLteTimingInfo *timeInfo
- * @param[out] U8 *allow -- TRUE is allowed or FALSE if no allowed.
+ * @param[out] uint8_t *allow -- TRUE is allowed or FALSE if no allowed.
* Valdity of this pointer is not done in this function
*
* @return None
#endif /* ANSI */
{
- U16 sfn;
- U16 sfi;
+ uint16_t sfn;
+ uint16_t sfi;
CmLteTimingInfo timeInfo;
timeInfo = cellCb->crntTime;
RG_SCH_HDFDD_MARKSTATE(ueCb, RG_SCH_HDFDD_DLCNTRL, sfn, sfi);
}
- RETVOID;
+ return;
} /* rgSCHCmnHdFddUpdDLMark */
*
* Processing Steps:
*
- * @param[out] *sfn U32
+ * @param[out] *sfn uint32_t
* @param[in] timeInfo timing information subframe of interest
* @param[in] offsest Offest with w.r.t which SFN has to be determined
*
#ifdef ANSI
Void rgSCHHdFddGetSfn
(
- U16 *sfn,
+ uint16_t *sfn,
CmLteTimingInfo timeInfo,
S16 offset
)
#else /* ANSI */
Void rgSCHHdFddGetSfn (sfn, timeInfo, offset)
- U16 *sfn;
+ uint16_t *sfn;
CmLteTimingInfo timeInfo;
S16 offset;
#endif /* ANSI */
{
- U16 tempSfn;
+ uint16_t tempSfn;
S16 tempSfCount;
if(((S16)(timeInfo.subframe) + offset) >= RGSCH_NUM_SUB_FRAMES)
}
*sfn = tempSfn;
- RETVOID;
+ return;
} /* End of rgSCHHdFddGetSfn */
typedef struct rgSchUeHdFddSfInfo
{
- U16 sfn; /*!< Store the sfn for updated state
+ uint16_t sfn; /*!< Store the sfn for updated state
Default Value= 0xffff
*/
- U8 state;
+ uint8_t state;
/*!< 0x00= DFLT
0x01= DL DATA +(OPT:CNTRL INFO)
0x02= DL CNTRL
*/
typedef struct rgInfEmtcCEmodeARarUlGrt
{
- U8 msg3PUSCHNbIdx; /*!< Indicates the Msg3 PUSCH narrowband index. */
- U8 rbStart; /*!< Start Resource block of allocation. */
- U8 numRb; /*!< Number of resource blocks allocated. */
- U8 msg3PUSCHNumRep; /*!< Number of repetitions for Msg3 PUSCH. */
- U8 iMcsCrnt; /*!< Current MCS index of the grant. */
- U8 tpc; /*!< TPC command for the uplink grant. */
- U8 cqiBit; /*!< Indicates the CQI is enabled or not. */
- U8 delayBit; /*!< Indicates the Delay bit. */
- U8 msg34MPDCCHNbIdx; /*!< Indicates Msg3/4 MPDCCH narrowband index. */
+ uint8_t msg3PUSCHNbIdx; /*!< Indicates the Msg3 PUSCH narrowband index. */
+ uint8_t rbStart; /*!< Start Resource block of allocation. */
+ uint8_t numRb; /*!< Number of resource blocks allocated. */
+ uint8_t msg3PUSCHNumRep; /*!< Number of repetitions for Msg3 PUSCH. */
+ uint8_t iMcsCrnt; /*!< Current MCS index of the grant. */
+ uint8_t tpc; /*!< TPC command for the uplink grant. */
+ uint8_t cqiBit; /*!< Indicates the CQI is enabled or not. */
+ uint8_t delayBit; /*!< Indicates the Delay bit. */
+ uint8_t msg34MPDCCHNbIdx; /*!< Indicates Msg3/4 MPDCCH narrowband index. */
} RgInfEmtcCEmodeARarUlGrnt;
/**
*/
typedef struct rgInfEmtcCEmodeBRarUlGrnt
{
- U8 msg3PUSCHNbIdx; /*!< Indicates the Msg3 PUSCH narrowband index. */
- U8 rbStart; /*!< Start Resource block of allocation. */
- U8 numRb; /*!< Number of resource blocks allocated. */
- U8 msg3PUSCHNumRep; /*!< Number of repetitions for Msg3 PUSCH. */
- U8 iTbsCrnt; /*!< Current TBS index of the grant. */
- U8 msg34MPDCCHNbIdx; /*!< Indicates Msg3/4 MPDCCH narrowband index. */
+ uint8_t msg3PUSCHNbIdx; /*!< Indicates the Msg3 PUSCH narrowband index. */
+ uint8_t rbStart; /*!< Start Resource block of allocation. */
+ uint8_t numRb; /*!< Number of resource blocks allocated. */
+ uint8_t msg3PUSCHNumRep; /*!< Number of repetitions for Msg3 PUSCH. */
+ uint8_t iTbsCrnt; /*!< Current TBS index of the grant. */
+ uint8_t msg34MPDCCHNbIdx; /*!< Indicates Msg3/4 MPDCCH narrowband index. */
}RgInfEmtcCEmodeBRarUlGrnt;
typedef enum rgEmtcCEmodeType
*/
typedef struct rgInfEmtcRarUlGrnt
{
- U8 rgEmtcCEmodeType;
+ uint8_t rgEmtcCEmodeType;
union
{
RgInfEmtcCEmodeARarUlGrnt emtcCEmodeARarUlGrnt;
CM_LTE_LCH_DTCH */
S32 bo; /*!< Buffer occupancy reported by RLC in bytes. */
#ifdef EMTC_ENABLE
- U8 emtcDIReason; /*!< Reason for DI message to send. */
- U8 pnb; /*!< Pagging narrowBand on which Ue perfom paging reception*/
+ uint8_t emtcDIReason; /*!< Reason for DI message to send. */
+ uint8_t pnb; /*!< Pagging narrowBand on which Ue perfom paging reception*/
#endif
union /*!< lcType in the primitive is the union selector. */
{
S32 bo; /*!< Number of bytes reported as Buffer occupancy by RLC. */
#ifdef CCPU_OPT
Bool staPduPrsnt; /*!< Is status PDU present reported by RLC. */
- U16 estRlcHdrSz;/*!< Estimated hader size reported by RLC */
+ uint16_t estRlcHdrSz;/*!< Estimated hader size reported by RLC */
#endif
- U32 staPduBo; /*!< Number of bytes reported as Buffer occupancy for status PDU by RLC.
+ uint32_t staPduBo; /*!< Number of bytes reported as Buffer occupancy for status PDU by RLC.
This is already included in BO.*/
- U32 oldestSduArrTime; /*!< Oldest SDU Arrival Time from Upper Layer */
+ uint32_t oldestSduArrTime; /*!< Oldest SDU Arrival Time from Upper Layer */
Bool setMaxUlPrio; /*!< set when Pollbit is set from RLC in PDU */
Bool setMaxDlPrio; /*!< Set when there is a status PDU in the DL*/
} RgInfDedBoRpt;
typedef struct rgInfRarUlGrnt
{
#ifndef MAC_5GTF_UPDATE
- U8 hop; /*!< Indicates the hopping flag. */
+ uint8_t hop; /*!< Indicates the hopping flag. */
#else
- U8 xPuschRange; /*!< xPUSCH range */
+ uint8_t xPuschRange; /*!< xPUSCH range */
#endif
- U8 rbStart; /*!< Start Resource block of allocation. */
- U8 numRb; /*!< Number of resource blocks allocated. */
- U8 tpc; /*!< TPC command for the uplink grant. */
- U8 iMcsCrnt; /*!< Current MCS index of the grant. */
- U8 delayBit; /*!< Indicates the Delay bit. */
+ uint8_t rbStart; /*!< Start Resource block of allocation. */
+ uint8_t numRb; /*!< Number of resource blocks allocated. */
+ uint8_t tpc; /*!< TPC command for the uplink grant. */
+ uint8_t iMcsCrnt; /*!< Current MCS index of the grant. */
+ uint8_t delayBit; /*!< Indicates the Delay bit. */
#ifndef MAC_5GTF_UPDATE
- U8 cqiBit; /*!< Indicates the CQI is enabled or not. */
+ uint8_t cqiBit; /*!< Indicates the CQI is enabled or not. */
#else
- U8 numBsiRep; /*!< Number of BSI reports. */
- U8 bsiBetaOffIdx; /*!< Index of BSI beta offset used in Msg3 */
- U8 pcrs; /*!< UL dual PCRS */
+ uint8_t numBsiRep; /*!< Number of BSI reports. */
+ uint8_t bsiBetaOffIdx; /*!< Index of BSI beta offset used in Msg3 */
+ uint8_t pcrs; /*!< UL dual PCRS */
#endif
} RgInfRarUlGrnt;
typedef struct rgInfCrntiInfo
{
CmLteRnti tmpCrnti; /*!< Temporary C-RNTI. RNTI range is specified in Section 7.1 in 36.321 specification. */
- U8 rapId; /*!< rapId identifies the index of the Random Access Preamble. rapId ranges from 0 to 63.*/
- TknU16 ta; /*!< Timing Adjustment. Timing Adjustment Value range is defined in Section 6.1.3.5 in 36.321 specification. */
+ uint8_t rapId; /*!< rapId identifies the index of the Random Access Preamble. rapId ranges from 0 to 63.*/
+ TknUInt16 ta; /*!< Timing Adjustment. Timing Adjustment Value range is defined in Section 6.1.3.5 in 36.321 specification. */
RgInfRarUlGrnt grnt; /*!< Uplink Grant to go in RAR. */
Bool isContFree; /*!< Indicates whether the procedure is contention-free or not. */
#ifdef EMTC_ENABLE
*/
typedef struct rgInfRaRntiInfo
{
- U16 raRnti; /*!< RA-RNTI. RNTI range is specified in Section 7.1 in 36.321 specification. */
+ uint16_t raRnti; /*!< RA-RNTI. RNTI range is specified in Section 7.1 in 36.321 specification. */
TfuPdschDciInfo dciInfo; /*!< PDCCH allocated for RA-RNTI. For more information
refer to <i>TFU Interface Service Definition</i> (p/n 1100091). */
- U32 schdTbSz; /*!< Scheduled TB size. schdTbSz value range is defined in Section 7.1.7.2.1 in 36.213
+ uint32_t schdTbSz; /*!< Scheduled TB size. schdTbSz value range is defined in Section 7.1.7.2.1 in 36.213
specification. */
- TknU8 backOffInd; /*!< Indicates the Backoff Indicator value. backOffInd value range
+ TknUInt8 backOffInd; /*!< Indicates the Backoff Indicator value. backOffInd value range
is defined in Section 7.2 in 36.321 specification. */
- U8 numCrnti; /*!< Number of valid RARs in the array. */
+ uint8_t numCrnti; /*!< Number of valid RARs in the array. */
RgInfCrntiInfo *crntiInfo; /*!< RAR information. */
}RgInfRaRntiInfo;
*/
typedef struct rgInfRarInfo
{
- U8 numRaRntis; /*!< Indicates the number of valid RA-RNTIs present. */
+ uint8_t numRaRntis; /*!< Indicates the number of valid RA-RNTIs present. */
RgInfRaRntiInfo *raRntiInfo; /*!< Contains allocation information per RA-RNTI. */
- U16 txPwrOffset; /*!< PDSCH tx power offset for RAR transmission */
+ uint16_t txPwrOffset; /*!< PDSCH tx power offset for RAR transmission */
}RgInfRarInfo;
/**
typedef struct rgInfLcDatInfo
{
CmLList lchLstEnt; /*!< Is not used when part of resource allocation. */
- U8 lcId; /*!< Identifies the logical channel. lcId value range is defined
+ uint8_t lcId; /*!< Identifies the logical channel. lcId value range is defined
in Section 6.2.1 in 36.321 specification. */
- U32 numBytes; /*!< Number of bytes allocated/received to logical channel. */
+ uint32_t numBytes; /*!< Number of bytes allocated/received to logical channel. */
} RgInfLcDatInfo;
/**
*/
typedef struct rgInfExtPhrSCellInfo
{
- U8 sCellIdx; /*!< SCELL index for which PHR is reported */
- U8 phr; /*!< PHR value. PHR value is defined in Section 6.1.3.6a in 36.321 specification. */
- U8 pCmax; /*!< PCMAX value. PCMAX value is defined in Table 6.1.3.6a-1 in 36.321 specification. */
- U8 pBackOff; /*!< If UE applied back off due to P-MPRc in 36.321 specification. */
+ uint8_t sCellIdx; /*!< SCELL index for which PHR is reported */
+ uint8_t phr; /*!< PHR value. PHR value is defined in Section 6.1.3.6a in 36.321 specification. */
+ uint8_t pCmax; /*!< PCMAX value. PCMAX value is defined in Table 6.1.3.6a-1 in 36.321 specification. */
+ uint8_t pBackOff; /*!< If UE applied back off due to P-MPRc in 36.321 specification. */
}RgInfExtPhrSCellInfo;
typedef struct rgInfExtPhrCEInfo
{
- U8 type2Phr; /*!< PHR value. PHR value is defined in Section 6.1.3.6a in 36.321 specification. */
- U8 type2PCMax; /*!< PCMAX value. PCMAX value is defined in Table 6.1.3.6a-1 in 36.321 specification. */
- U8 numServCells; /*!< Number of serving cells for which PHR is reported */
+ uint8_t type2Phr; /*!< PHR value. PHR value is defined in Section 6.1.3.6a in 36.321 specification. */
+ uint8_t type2PCMax; /*!< PCMAX value. PCMAX value is defined in Table 6.1.3.6a-1 in 36.321 specification. */
+ uint8_t numServCells; /*!< Number of serving cells for which PHR is reported */
RgInfExtPhrSCellInfo servCellPhr[CM_LTE_MAX_CELLS];
}RgInfExtPhrCEInfo; /*!< EXT PHR value. EXT PHR value is defined in Section 6.1.3.6a in 36.321 R10 specification. */
*/
typedef struct rgInfCeInfo
{
- U16 bitMask; /*!< Bitmask for the MAC Control elements present. */
+ uint16_t bitMask; /*!< Bitmask for the MAC Control elements present. */
struct
{
- U16 cRnti; /*!< C-RNTI value. RNTI range is specified in Section 7.1 in 36.321 specification. */
- U8 phr; /*!< PHR value. PHR value is defined in Section 6.1.3.6 in 36.321 specification. */
+ uint16_t cRnti; /*!< C-RNTI value. RNTI range is specified in Section 7.1 in 36.321 specification. */
+ uint8_t phr; /*!< PHR value. PHR value is defined in Section 6.1.3.6 in 36.321 specification. */
union
{
- U8 truncBsr; /*!< Truncated BSR value. BSR value is defined in
+ uint8_t truncBsr; /*!< Truncated BSR value. BSR value is defined in
Section 6.1.3.1 in 36.321 specification. */
- U8 shortBsr; /*!< Short BSR value.BSR value is defined in
+ uint8_t shortBsr; /*!< Short BSR value.BSR value is defined in
Section 6.1.3.1 in 36.321 specification. */
struct
{
- U8 bs1; /*!< Buffer size 1 of long BSR. */
- U8 bs2; /*!< Buffer size 2 of long BSR. */
- U8 bs3; /*!< Buffer size 3 of long BSR. */
- U8 bs4; /*!< Buffer size 4 of long BSR. */
+ uint8_t bs1; /*!< Buffer size 1 of long BSR. */
+ uint8_t bs2; /*!< Buffer size 2 of long BSR. */
+ uint8_t bs3; /*!< Buffer size 3 of long BSR. */
+ uint8_t bs4; /*!< Buffer size 4 of long BSR. */
}longBsr; /*!< BSR value is defined in Section 6.1.3.1 in 36.321 specification. */
}bsr;
RgInfExtPhrCEInfo extPhr; /*!< EXT PHR value. EXT PHR value is defined in Section 6.1.3.6a in 36.321 R10 specification. */
#ifdef MAC_5GTF_UPDATE
struct
{
- U8 bar; /*!< Beam Adjusment Request */
- U8 numBsiFields; /*!< Number of BSI fields UE sent in BSI Feedback */
+ uint8_t bar; /*!< Beam Adjusment Request */
+ uint8_t numBsiFields; /*!< Number of BSI fields UE sent in BSI Feedback */
struct
{
- U16 bi; /*!< BSI Feedback : 9 bits Beam Index */
- U8 brsrp; /*!< BSI Feedback :7 bits BRSRP */
+ uint16_t bi; /*!< BSI Feedback : 9 bits Beam Index */
+ uint8_t brsrp; /*!< BSI Feedback :7 bits BRSRP */
}bsiFdbk[4];
}beam;
#endif
} ces;
/* L2_COUNTERS */
#ifdef LTE_L2_MEAS
- U8 ulActLCs[RGINF_MAX_NUM_DED_LC];
+ uint8_t ulActLCs[RGINF_MAX_NUM_DED_LC];
/*!< List of LCs for which Data is received in UL */
#endif
#ifdef LTEMAC_SPS
- U16 spsSduSize;
+ uint16_t spsSduSize;
#endif
} RgInfCeInfo;
typedef struct rgInfLcgInfo
{
- U8 lcgId; /*!< LCGID. GBR DRB LCG */
- U32 bytesRcvd; /*!< Contains bytes received for LCG */
+ uint8_t lcgId; /*!< LCGID. GBR DRB LCG */
+ uint32_t bytesRcvd; /*!< Contains bytes received for LCG */
}RgInfLcgInfo;
/**
CmMemListCp memCp; /*!< Memory control point. */
CmLListCp ueLst; /*!< Pointer to the UE linked list. */
/* RRM_SP1_START */
- U32 qcisUlPrbCnt[RGINF_MAX_GBR_QCI_REPORTS];/*!< UL gbr LC's PRB count*/
+ uint32_t qcisUlPrbCnt[RGINF_MAX_GBR_QCI_REPORTS];/*!< UL gbr LC's PRB count*/
/* RRM_SP1_END */
S16 cellSapId; /*!< Cell SAP Identifier. CellSAP ID value must be within the set of configured cell SAP IDs. */
CmLteCellId cellId; /*!< Identifies the cell. CellId must be within the set of configured cell IDs. */
Bool disTb; /*!< Currently, not used, but is
applicable in MIMO case. */
Bool isReTx; /*!< Indicates the TB transmission type. */
- TknU8 ta; /*!< Timing Adjustment. */
+ TknUInt8 ta; /*!< Timing Adjustment. */
#ifdef LTE_ADV
- TknU8 sCellActCe; /* !< SCell Act values and whether
+ TknUInt8 sCellActCe; /* !< SCell Act values and whether
scheduled or not */
#endif
/* Changed as a result of CR timer implementation*/
- U8 contResCe; /*!< Indicating presence of Contention Resolution CE across MAC-SCH
+ uint8_t contResCe; /*!< Indicating presence of Contention Resolution CE across MAC-SCH
interface to
* identify CCCH SDU transmissions which need to
* be done without the
* contention resolution CE.*/
- U8 numSchLch; /*!< Indicates the number of logical
+ uint8_t numSchLch; /*!< Indicates the number of logical
channels scheduled. */
- U32 schdTbSz;
+ uint32_t schdTbSz;
RgInfLcDatInfo schdDat[RGINF_MAX_NUM_DED_LC]; /*!< Contains
information about scheduled logical
channel. */
*/
typedef struct rgLaaTbReqInfo
{
- U8 sMacInstId;
- U8 sCellHqPId;
- U8 tbId;
- U16 hqPStamp;
+ uint8_t sMacInstId;
+ uint8_t sCellHqPId;
+ uint8_t tbId;
+ uint16_t hqPStamp;
}RgLaaTbReqInfo;
/**
TfuPdschDciInfo dciInfo; /*!< Contains Downlink Control Information. For more information,
refer to <i>TFU Interface Service Definition</i> (p/n 1100091). */
- U8 hqProcId; /*!< HARQ process Identifier. hqProcId ranges between 1 and 8 for FDD mode and 1 and 15 for TDD mode */
+ uint8_t hqProcId; /*!< HARQ process Identifier. hqProcId ranges between 1 and 8 for FDD mode and 1 and 15 for TDD mode */
S8 tbStrtIdx;
- TknU32 doa;
+ TknUInt32 doa;
TfuTxMode txMode;
Bool puschRptUsd;/*!< True, if Precoding Information in PDCCH has to be
in-accordance with the latest PUSCH report */
* information to PHY during a PDSCH */
- U8 nmbOfTBs; /*!< Indicates the number of TBs. Currently this is set to 1. */
+ uint8_t nmbOfTBs; /*!< Indicates the number of TBs. Currently this is set to 1. */
RgInfUeTbInfo tbInfo[RGINF_MAX_TB_PER_UE]; /*!< Contains TB identifier. */
/* LTE_ADV_FLAG_REMOVED_START */
#ifdef TFU_UPGRADE
- U8 pa; /*!< DL Power control paramter P_A
+ uint8_t pa; /*!< DL Power control paramter P_A
configured by higher layers
Ref: RRC 36.331, 6.3.2, PDSCH-Config */
#endif
- U8 isEnbSFR; /*To check if SFR is enabled*/
+ uint8_t isEnbSFR; /*To check if SFR is enabled*/
/* LTE_ADV_FLAG_REMOVED_END */
#ifdef LTE_ADV
Bool fillCtrlPdu; /*!< Based upon this flag RLC will fill RLC Control PDU
*/
typedef struct rgInfUeInfo
{
- U8 numUes; /*!< Number of UEs allocated. */
+ uint8_t numUes; /*!< Number of UEs allocated. */
RgInfUeAlloc *allocInfo; /*!< Allocation information per UE. */
}RgInfUeInfo;
#else
Buffer *pdu; /*!< PDU being specified for BCCH. */
#endif
- U16 txPwrOffset; /*!< PDSCH tx power offset for BCCH
+ uint16_t txPwrOffset; /*!< PDSCH tx power offset for BCCH
transmission */
}RgInfBcchInfo;
CmLteLcId lcId; /*!< Logical Channel Identifier. lcId value range is defined in
Section 6.2.1 in 36.321 specification. */
- U16 txPwrOffset; /*!< PDSCH tx power offset for PCCH
+ uint16_t txPwrOffset; /*!< PDSCH tx power offset for PCCH
transmission */
}RgInfPcchInfo;
*/
typedef struct rgInfCmnLcInfo
{
- U16 bitMask; /*!< Bitmask representing all the common channels present. */
+ uint16_t bitMask; /*!< Bitmask representing all the common channels present. */
RgInfBchInfo bchInfo; /*!< BCH channel Information. */
RgInfPcchInfo pcchInfo; /*!< Paging Logical Channel Information. */
RgInfBcchInfo bcchInfo; /*!< Broadcast Logical Channel Information. */
*/
typedef struct rgInfEmtcCmnLcInfo
{
- U16 bitMask; /*!< Bitmask representing all the common channels present. */
+ uint16_t bitMask; /*!< Bitmask representing all the common channels present. */
RgInfBchInfo bchInfo; /*!< BCH channel Information. */
RgInfPcchInfo pcchInfo; /*!< Paging Logical Channel Information. */
RgInfEmtcBcchInfo emtcBcchInfo; /*!< Broadcast Logical Channel Information. */
typedef struct rgInfUeUlAlloc
{
CmLteRnti rnti; /*!< UE ID */
- U8 numPrb; /*!< Number of total PRB's allocated for this UE */
+ uint8_t numPrb; /*!< Number of total PRB's allocated for this UE */
} RgInfUeUlAlloc;
/**
* */
typedef struct rgInfUlUeInfo
{
- U8 numUes; /*!< Number of UE's*/
+ uint8_t numUes; /*!< Number of UE's*/
CmLteTimingInfo timingInfo; /*!< Uplink timing information */
RgInfUeUlAlloc *ulAllocInfo;/*!< Uplink Allocations information */
}RgInfUlUeInfo;
typedef struct rgInfLcInfo
{
CmLteLcId lcId; /*!< lcId for flow control*/
-
U32 pktAdmitCnt; /*!<Pkts allowed for the LC */
- U32 maxBo4FlowCtrl; /*!< MAX BO of Queued SDUs at RLC beyond which Flow is Controlled */
+
uint32_t pktAdmitCnt; /*!<Pkts allowed for the LC */
+ uint32_t maxBo4FlowCtrl; /*!< MAX BO of Queued SDUs at RLC beyond which Flow is Controlled */
}RgInfLcFlowCntrlInfo;
typedef struct rgInfUeFlowCntrlInfo
{
CmLteRnti ueId; /*!<ueId for flow control*/
- U32 numLcs;/*!<numLcs in the UE*/
+ uint32_t numLcs;/*!<numLcs in the UE*/
RgInfLcFlowCntrlInfo lcInfo[RGINF_MAX_NUM_DED_LC]; /*!<LC list*/
}RgInfUeFlowCntrlInfo;
/**
* @brief This structure contains the flow control information to be sent to MAC */
typedef struct rgInfFlowCntrlInfo
{
- U32 numUes;/*!<Num UEs for flow control */
+ uint32_t numUes;/*!<Num UEs for flow control */
RgInfUeFlowCntrlInfo ueFlowCntrlInfo[RGINF_MAX_NUM_UE_PER_TTI]; /*!<Ue Info for flow control */
}RgInfFlowCntrlInfo;
#ifdef EMTC_ENABLE
{
CmLteRnti rnti; /*!< RNTI which uniquely identifies the UE. RNTI value range is
specified in Section 7.1 in 25.321 */
- U8 hqProcId; /*!< HARQ Process Identifier.
+ uint8_t hqProcId; /*!< HARQ Process Identifier.
hqProcId ranges between 1 and 8 for FDD mode and 1 and 15 for TDD mode. */
- U8 numOfTBs; /*!< Identifies the number of TBs. Currently this is set to 1. */
- U8 tbId[RGINF_MAX_TB_PER_UE]; /*!< Indicates the TB Identifier. */
+ uint8_t numOfTBs; /*!< Identifies the number of TBs. Currently this is set to 1. */
+ uint8_t tbId[RGINF_MAX_TB_PER_UE]; /*!< Indicates the TB Identifier. */
/* MS_WORKAROUND: to increase Harq Fail Counter .
The status field is required for tracking the number of harq faliures at MAC.
As this is already present under L2_MEAS flag, we have replaced it with platform flag */
- U8 status[RGINF_MAX_TB_PER_UE]; /*!< Indicates HARQ ACK or NACK */
- U8 rlsOperationType; /*!< Decides action to be taken in MAC
+ uint8_t status[RGINF_MAX_TB_PER_UE]; /*!< Indicates HARQ ACK or NACK */
+ uint8_t rlsOperationType; /*!< Decides action to be taken in MAC
0x00 RGINF_RLS_HQ_NO_ACTION - Free Hq Procs and TBs
0x01 RGINF_RLS_HQ_SAVE_TB - Free Hq Proc but save the TBs
0x02 RGINF_RLS_HQ_DEL_TB - Del already saved TBs */
- U16 saveId; /*!< Uniquely identify an particular HqP save */
+ uint16_t saveId; /*!< Uniquely identify an particular HqP save */
} RgInfUeHqInfo;
/**
{
CmLteCellId cellId; /*!< Identifies Cell. CellId should be within
the set of configured cell IDs. */
- U8 numUes; /*!< Indicates number of UEs present. */
+ uint8_t numUes; /*!< Indicates number of UEs present. */
RgInfUeHqInfo *ueHqInfo; /*!< Contains UE specific HARQ information. */
}RgInfRlsHqInfo;
{
CmLteCellId cellId; /*!< Identifies the cell. cellId value should be within the set of configured cell IDs. */
S16 cellSapId; /*!< Identifies the cell SAP. cellSapId value should be within the set of configured cell SAP IDs. */
- U8 maxDlHqProcPerUe; /*!< Indicates Maximum number of downlink HARQ processes per UE. */
+ uint8_t maxDlHqProcPerUe; /*!< Indicates Maximum number of downlink HARQ processes per UE. */
}RgInfCellReg;
#ifdef LTE_L2_MEAS
* */
typedef struct rgInfPrbReq
{
- U8 numQci; /*!< Number fo QCI's in Request */
- U8 qci[LRG_MAX_QCI_PER_REQ]; /*!< QCI for which PRB has
+ uint8_t numQci; /*!< Number fo QCI's in Request */
+ uint8_t qci[LRG_MAX_QCI_PER_REQ]; /*!< QCI for which PRB has
to be measured */
} RgInfPrbReq;
typedef struct prbUsage
{
- U8 qciValue; /*!< Qci Value */
-
U32 prbUsage; /*!<Prb Usage for this Qci */
+ uint8_t qciValue; /*!< Qci Value */
+
uint32_t prbUsage; /*!<Prb Usage for this Qci */
}PrbUsage;
/**
* @brief struture to hold measurement confirm for Uplink Average PRB usage per
* */
typedef struct rgInfPrbCfm
{
- U8 numQci; /*!< Number fo QCI's in Request */
+ uint8_t numQci; /*!< Number fo QCI's in Request */
PrbUsage prbUsage[LRG_MAX_QCI_PER_REQ]; /*!< Average PRB usage
per QCI */
} RgInfPrbCfm;
* */
typedef struct RgInfL2MeasReq
{
- U32 transId; /*!< TransId to uniquely identify request */
- U16 measType; /*!< For action type Avegare PRB usage
+ uint32_t transId; /*!< TransId to uniquely identify request */
+ uint16_t measType; /*!< For action type Avegare PRB usage
in Uplink */
- U16 timePrd; /*!< Time Period for which measurement
+ uint16_t timePrd; /*!< Time Period for which measurement
is done */
CmLteCellId cellId; /*!< CellId for which measurement done*/
union {
* */
typedef struct RgInfL2MeasStopReq
{
- U32 transId; /*!< TransId to uniquely identify request */
- U8 measType; /*!< For action type Avegare PRB usage
+ uint32_t transId; /*!< TransId to uniquely identify request */
+ uint8_t measType; /*!< For action type Avegare PRB usage
in Uplink */
CmLteCellId cellId; /*!< CellId for which measurement done*/
} RgInfL2MeasStopReq;
* */
typedef struct RgInfL2MeasSndReq
{
- U32 transId; /*!< TransId to uniquely identify request */
- U8 measType; /*!< For action type Avegare PRB usage
+ uint32_t transId; /*!< TransId to uniquely identify request */
+ uint8_t measType; /*!< For action type Avegare PRB usage
in Uplink */
- U16 timePrd; /*!< Time Period for which measurement
+ uint16_t timePrd; /*!< Time Period for which measurement
is done */
CmLteCellId cellId; /*!< CellId for which measurement done*/
} RgInfL2MeasSndReq;
* */
typedef struct rgInfL2MeasCfm
{
- U16 transId; /*!< transId to map to request */
- U8 measType; /*!< Action for which measurement done */
+ uint16_t transId; /*!< transId to map to request */
+ uint8_t measType; /*!< Action for which measurement done */
CmLteCellId cellId; /*!< CellId for which measurement done*/
CmStatus cfm; /*!< Confirmation possible Values when measType
is invalid status -> NOK and reason -> INVALID */
CmLteRnti crnti; /*!< RNTI which uniquely identifies the UE
RNTI range is specified in Section
7.1 in 25.321 Specification. */
- U8 lcgId;
+ uint8_t lcgId;
Bool isGbr; /* Indicate if the LCG is Gbr */
} RgInfLcgRegReq;
7.1 in 25.321 Specification. */
CmLteRnti spsRnti; /*!< SPS RNTI. RNTI range is specified in
Section 7.1 in 25.321 Specification. */
- U8 spsLcCnt; /*!< identifies the number of SPS
+ uint8_t spsLcCnt; /*!< identifies the number of SPS
configured logical channels */
- U8 spsLcId[RGINF_MAX_NUM_DED_LC]; /*!< Logical Channel
+ uint8_t spsLcId[RGINF_MAX_NUM_DED_LC]; /*!< Logical Channel
Identifier. lcId value range is
defined in Section 6.2.1
in 36.321 Specification. */
- U8 implRelCnt; /*!< "implicitRelAfter" vallue */
- U16 spsPrd; /*!< SPS periodicity of the UE */
+ uint8_t implRelCnt; /*!< "implicitRelAfter" vallue */
+ uint16_t spsPrd; /*!< SPS periodicity of the UE */
} RgInfSpsLcInfo;
/**
#include "rg_sch.x" /* typedefs for Scheduler */
#include "rg_sch_cmn.x" /* typedefs for Scheduler */
/* local defines */
-U32 dlPrbCnt;
+uint32_t dlPrbCnt;
#ifdef LTE_L2_MEAS
static const char* RLOG_MODULE_NAME="MAC";
RgSchCellCb *cell,
RgSchL2MeasCb *measCb,
LrgSchMeasCfmInfo *cfm,
-U32 measTime
+uint32_t measTime
)
#else
S16 rgSchFillL2MeasCfm(cell, measCb, cfm, measTime)
RgSchCellCb *cell;
RgSchL2MeasCb *measCb;
LrgSchMeasCfmInfo *cfm;
-U32 measTime;
+uint32_t measTime;
#endif
{
- U8 idx;
+ uint8_t idx;
LrgSchMeasReqInfo *measInfo;
- U8 qciVal = 0;
- U32 sampOc = 0;
+ uint8_t qciVal = 0;
+ uint32_t sampOc = 0;
measInfo = &measCb->measReq;
cfmPst->region = measInfo->hdr.response.mem.region;
cfmPst->pool = measInfo->hdr.response.mem.pool;
- RETVOID;
+ return;
} /* rgSchL2mFillCfmPst */
/** @brief This function inserts the MeasCb in to data base
{
CmLList *lnk, *node;
RgSchL2MeasCb *oldMeasCb;
- U32 diffTime;
+ uint32_t diffTime;
/*
* 1. Check if l2mList has any entries.
CmLteTimingInfo frm;
RgSchDlSf *sf = NULLP;
#ifdef LTE_TDD
- U8 idx;
+ uint8_t idx;
#endif
frm = cell->crntTime;
#else
cell->avgPrbDl.prbCount += sf->bwAssigned;
#endif
- RETVOID;
+ return;
}
/** @brief This function calculates the up link prb count
RgSchUlSf *sf = NULLP;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
#ifdef LTE_TDD
- U8 idx;
+ uint8_t idx;
#endif
#ifdef LTE_TDD
sf = &cellUl->ulSfArr[cellUl->schdIdx];
cell->avgPrbUl.prbCount += sf->totPrb;
#endif
- RETVOID;
+ return;
}
/** @brief This function allocates memory from the heap
*
#endif
{
RgSchL2MeasCb *measCb;
- U8 idx;
- U8 qciVal;
+ uint8_t idx;
+ uint8_t qciVal;
qciVal = 0;
S16 rgSCHL2Meas
(
RgSchCellCb *cell,
-U8 isCalrCrcInd
+uint8_t isCalrCrcInd
)
#else
S16 rgschL2Meas(cell,isCalrCrcInd)
RgSchCellCb *cell;
-U8 isCalrCrcInd
+uint8_t isCalrCrcInd
#endif
{
CmLList *node = NULLP;
RgSchL2MeasCb *measCb = NULLP;
- U8 idx;
+ uint8_t idx;
LrgSchMeasCfmInfo measCfm;
- U8 qciVal = 0;
- U32 sfDiff;
- U32 meas;
+ uint8_t qciVal = 0;
+ uint32_t sfDiff;
+ uint32_t meas;
#ifdef LTE_TDD
- U8 sfIdx;
+ uint8_t sfIdx;
Bool isDlDataAllowed;
- U8 rem;
- U32 numDlSf;
- U32 numUlSf;
+ uint8_t rem;
+ uint32_t numDlSf;
+ uint32_t numUlSf;
#endif
node = cell->l2mList.first;
/* forward references */
extern int schActvInit(Ent entity, Inst instId, Region region, Reason reason);
#ifdef UNUSE_FUN
-PRIVATE U16 rgSCHLmmSapCfg ARGS((
+PRIVATE uint16_t rgSCHLmmSapCfg ARGS((
Inst inst,
RgCfg *cfg,
- U8 sapIdx,
+ uint8_t sapIdx,
Elmnt sapType
));
#endif
void printSchCellInfo(void)
{
- U8 idx=0;
- U8 inst=0;
+ uint8_t idx=0;
+ uint8_t inst=0;
for (idx = 0; idx < rgSchCb[inst].numSaps; idx++)
{
/* Unbind all the TFU SAP */
* reason for success/failure of this function.
*
* @param[in] RgCfg *cfg, the Configuaration information
- * @return U16
+ * @return uint16_t
* -# LCM_REASON_GENCFG_NOT_DONE
* -# LCM_REASON_INVALID_SAP
* -# LCM_REASON_NOT_APPL
**/
#ifdef UNUSE_FUN
#ifdef ANSI
-PRIVATE U16 rgSCHLmmSapCfg
+PRIVATE uint16_t rgSCHLmmSapCfg
(
Inst dInst,
RgCfg *cfg, /* Configuaration information */
-U8 sapIdx, /* SAP index */
+uint8_t sapIdx, /* SAP index */
Elmnt sapType /* SAP Type */
)
#else
-PRIVATE U16 rgSCHLmmSapCfg(dInst, cfg, sapIdx, sapType)
+PRIVATE uint16_t rgSCHLmmSapCfg(dInst, cfg, sapIdx, sapType)
Inst dInst;
RgCfg *cfg; /* Configuaration information */
-U8 sapIdx; /* SAP index */
+uint8_t sapIdx; /* SAP index */
Elmnt sapType; /* SAP Type */
#endif
{
- U16 ret = LCM_REASON_NOT_APPL;
+ uint16_t ret = LCM_REASON_NOT_APPL;
RgSchLowSapCfgInfo *lowSapCfg = NULLP;
RgSchUpSapCfgInfo *upSapCfg = NULLP;
Inst inst = (dInst - SCH_INST_START);
#endif
{
Inst dInst = inst + SCH_INST_START;
- U8 idx;
+ uint8_t idx;
#ifdef LTE_L2_MEAS
CmLList *lnk = NULLP;
RgSchCb *instCb = &rgSchCb[inst];
RgSchCellCb *cell = NULLP;
RgSchL2MeasCb *measCb;
- U8 ulAllocIdx;
+ uint8_t ulAllocIdx;
RgSchCmnUlCell *cellUl;
RgSchClcBoRpt *bo = NULL;
#endif
/* Set Config done in TskInit */
rgSchCb[inst].rgSchInit.cfgDone = FALSE;
- RETVOID;
+ return;
}
\f
break;
}
RgMiLrgSchCntrlCfm(cfmPst, cfm);
- RETVOID;
+ return;
}
\f
Pst *cfmPst;
#endif
{
- U8 idx;
+ uint8_t idx;
/* TODO Pass InstId instead of using InstId from cfmPst */
Inst inst = (cfmPst->srcInst - SCH_INST_START); /* Scheduler instance Id */
switch(cntrl->hdr.elmId.elmnt)
{
case STTFUSAP:
- idx = (U8)cntrl->t.cntrl.s.rgSapCntrl.suId;
+ idx = (uint8_t)cntrl->t.cntrl.s.rgSapCntrl.suId;
if (idx > LRG_MAX_SAPS_PER_INST)
{
cfm->cfm.status = LCM_PRIM_NOK;
rgSCHUtlTfuBndReq(inst, rgSchCb[inst].tfuSap[idx].sapCfg.suId,
rgSchCb[inst].tfuSap[idx].sapCfg.spId);
- RETVOID;
+ return;
}
break;
case AUBND:
}
break;
case STRGRSAP:
- idx = (U8)cntrl->t.cntrl.s.rgSapCntrl.spId;
+ idx = (uint8_t)cntrl->t.cntrl.s.rgSapCntrl.spId;
if (idx > LRG_MAX_SAPS_PER_INST)
{
cfm->cfm.status = LCM_PRIM_NOK;
}
break;
case STRGMSAP:
- idx = (U8)cntrl->t.cntrl.s.rgSapCntrl.spId;
+ idx = (uint8_t)cntrl->t.cntrl.s.rgSapCntrl.spId;
if (idx > LRG_MAX_SAPS_PER_INST)
{
cfm->cfm.status = LCM_PRIM_NOK;
default:
/* Would never come here. */
- RETVOID;
+ return;
}
RgMiLrgSchCntrlCfm(cfmPst, cfm);
- RETVOID;
+ return;
}
\f
cfmPst->region = cfm->hdr.response.mem.region;
cfmPst->pool = cfm->hdr.response.mem.pool;
- RETVOID;
+ return;
}
\f
* code based on "tmrEvnt".
*
* @param[in] S16 tmrEvnt, the Timer Event
- * @param[in] U32 tmrVal, the Wait Time
+ * @param[in] uint32_t tmrVal, the Wait Time
* @param[in] PTR cb, Entry for which Timer expired
* @return S16
* -# ROK
(
Inst inst,
S16 tmrEvnt, /* Timer Event */
-U32 tmrVal, /* Wait Time */
+uint32_t tmrVal, /* Wait Time */
PTR cb /* Entry for which Timer Expired */
)
#else
S16 rgSCHLmmStartTmr(inst, tmrEvnt, tmrVal, cb)
Inst inst; /* scheduler instance ID */
S16 tmrEvnt; /* Timer Event */
-U32 tmrVal; /* Wait Time */
+uint32_t tmrVal; /* Wait Time */
PTR cb; /* Entry for which Timer Expired */
#endif
{
#endif
{
CmTmrArg arg;
- U8 i;
+ uint8_t i;
S16 ret;
ret = RFAILED;
tfuSap->numBndRetries++;
if(tfuSap->numBndRetries > RGSCH_MAX_BNDRETRY)
{
- rgSCHLmmStaInd((U8)(tfuSap->sapCfg.sapPst.srcInst - SCH_INST_START),
- (U16)LCM_CATEGORY_INTERFACE, (U16)LCM_EVENT_BND_FAIL,
- (U16)LCM_CAUSE_TMR_EXPIRED, (RgUstaDgn *)NULLP);
+ rgSCHLmmStaInd((uint8_t)(tfuSap->sapCfg.sapPst.srcInst - SCH_INST_START),
+ (uint16_t)LCM_CATEGORY_INTERFACE, (uint16_t)LCM_EVENT_BND_FAIL,
+ (uint16_t)LCM_CAUSE_TMR_EXPIRED, (RgUstaDgn *)NULLP);
}
else
{
/* Restart the bind timer */
if (tfuSap->sapCfg.bndTmr.enb == TRUE)
{
- ret = rgSCHLmmStartTmr((U8)(tfuSap->sapCfg.sapPst.srcInst - SCH_INST_START),
+ ret = rgSCHLmmStartTmr((uint8_t)(tfuSap->sapCfg.sapPst.srcInst - SCH_INST_START),
RGSCH_BNDREQ_TMR,
- (U32)tfuSap->sapCfg.bndTmr.val, cb);
+ (uint32_t)tfuSap->sapCfg.bndTmr.val, cb);
}
/* Send bind request */
- rgSCHUtlTfuBndReq((U8)(tfuSap->sapCfg.sapPst.srcInst - SCH_INST_START),
+ rgSCHUtlTfuBndReq((uint8_t)(tfuSap->sapCfg.sapPst.srcInst - SCH_INST_START),
tfuSap->sapCfg.suId, tfuSap->sapCfg.spId);
}
break;
*
* @param[in] Pst *pst, Post Structure
* @param[in] SuId suId, Service user ID
- * @param[in] U8 status, Status
+ * @param[in] uint8_t status, Status
* @return S16
* -# ROK
**/
(
Pst *pst, /* Post Structure */
SuId suId, /* Service user ID */
-U8 status /* Status */
+uint8_t status /* Status */
)
#else
S16 rgSCHLmmBndCfm(pst,suId,status)
Pst *pst; /* Post Structure */
SuId suId; /* Service user Id */
-U8 status; /* Status */
+uint8_t status; /* Status */
#endif
{
S16 ret = ROK;
cntrlCfm.cfm.status = LCM_PRIM_OK;
cntrlCfm.cfm.reason = LCM_REASON_NOT_APPL;
/* Sending Status Indication to Layer Manager */
- rgSCHLmmStaInd((U8)(rgSchCb[inst].tfuSap->sapCfg.sapPst.srcInst - SCH_INST_START),
+ rgSCHLmmStaInd((uint8_t)(rgSchCb[inst].tfuSap->sapCfg.sapPst.srcInst - SCH_INST_START),
LCM_CATEGORY_INTERFACE, LCM_EVENT_BND_OK,
LCM_CAUSE_LYR_SPECIFIC, (RgUstaDgn *)NULLP);
break;
* This API is used by the other modules of MAC to send a unsolicited
* status indication to the Layer Manager.
*
- * @param[in] U16 category, the Alarm category
- * @param[in] U16 event, the Alarm event
- * @param[in] U16 cause, the cause of the Alarm
+ * @param[in] uint16_t category, the Alarm category
+ * @param[in] uint16_t event, the Alarm event
+ * @param[in] uint16_t cause, the cause of the Alarm
* @param[in] RgUstaDgn *dgn, Alarm Diagonostics
* @return S16
* -# ROK
S16 rgSCHLmmStaInd
(
Inst inst,
-U16 category,
-U16 event,
-U16 cause,
+uint16_t category,
+uint16_t event,
+uint16_t cause,
RgUstaDgn *dgn
)
#else
S16 rgSCHLmmStaInd(inst, category, event, cause, dgn)
Inst inst;
-U16 category;
-U16 event;
-U16 cause;
+uint16_t category;
+uint16_t event;
+uint16_t cause;
RgUstaDgn *dgn;
#endif
{
{
return ROK;
}
-
memset(&usta, 0, sizeof(RgMngmt));
SGetDateTime(&usta.t.usta.cmAlarm.dt);
RgSchCellCb *cell,
CmLListCp *measGapQ));
#ifdef LTE_TDD
-PRIVATE U8 rgSCHAckNakRepFindUlDuration ARGS((
+PRIVATE uint8_t rgSCHAckNakRepFindUlDuration ARGS((
RgSchCellCb *cell,
RgSchDlSf *dlSf,
CmLteTimingInfo repTime,
-U8 repCnt));
+uint8_t repCnt));
PRIVATE Void rgSCHAckNakRepGetUlOffsetFrmDl ARGS((
RgSchDlSf *dlSf,
CmLteTimingInfo crntDlTime,
-U8 *noSubfrms));
+uint8_t *noSubfrms));
#endif
/**
rgSCHTmrStopTmr (cell, RG_SCH_TMR_ACKNACK_REP, ue);
rgSchAckNackRepUtlRmvUe (cell, ue);
}
- RETVOID;
+ return;
}
/** @brief This function deletes the UEs information related to ACK NACK
{
- U8 hqIdx;
- U8 repIdx;
+ uint8_t hqIdx;
+ uint8_t repIdx;
RgSchDlHqProcCb *hqP;
- U8 tbCnt;
+ uint8_t tbCnt;
RgSchDlHqEnt *hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
RgSchCellCb *cell;
#endif
{
- U8 offset;
+ uint8_t offset;
CmLListCp *queue;
RgSchDlSf *dlSf;
CmLteTimingInfo repTime;
}
node = node->next;
} /* end of while */
- RETVOID;
+ return;
} /* end of */
rgSCHTmrStartTmr (cell, ue, RG_SCH_TMR_MEASGAP, RG_SCH_MEAS_GAP_LEN);
node = node->next;
} /* end of while */
- RETVOID;
+ return;
} /* end of */
CmLListCp *dlInactvUeLst;
#endif
{
- U8 offset;
+ uint8_t offset;
CmLList *node;
CmLList *hqNode;
CmLListCp *queue;
RgSchUeCb *ue;
RgSchDlSf *dlSf;
CmLteTimingInfo ackNakTime;
- U16 schedTime;
- U8 harqFdbkOffset;
+ uint16_t schedTime;
+ uint8_t harqFdbkOffset;
#ifdef LTE_TDD
- U8 repCntr;
+ uint8_t repCntr;
#endif
RgSchDlHqProcCb *hqP;
RgSchDlHqTbCb *tbCb;
- U32 i;
+ uint32_t i;
schedTime = cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot + RG_DL_DELTA;
/* Start timer */
#ifdef LTE_TDD
repCntr = rgSCHAckNakRepFindUlDuration(cell, dlSf, ackNakTime,
- (U8)(ue->ackNakRepCb.repCntr - 1));
+ (uint8_t)(ue->ackNakRepCb.repCntr - 1));
rgSCHTmrStartTmr (cell, ue, RG_SCH_TMR_DL_ACKNACK, repCntr);
#else
rgSCHTmrStartTmr (cell, ue, RG_SCH_TMR_DL_ACKNACK,
#endif
{
- U8 offset;
+ uint8_t offset;
CmLList *node;
CmLList *hqNode;
CmLListCp *queue;
RgSchUeCb *ue;
CmLteTimingInfo ackNakTime;
RgSchDlSf *dlSf;
- U16 schedTime;
- U8 pdcchToPuschGap;
- U8 idx=0;
+ uint16_t schedTime;
+ uint8_t pdcchToPuschGap;
+ uint8_t idx=0;
#ifdef LTE_TDD
- U8 repCntr;
+ uint8_t repCntr;
#endif
RgSchDlHqProcCb *hqP;
RgSchDlHqTbCb *tbCb;
- U32 i;
+ uint32_t i;
/*ccpu00139481- Meas Gap should be monitored in UL with TFU_ULCNTRL_DLDELTA*/
schedTime = cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G + cell->crntTime.slot + \
Void rgSCHMeasGapANRepDlInactvTmrExpry
(
RgSchUeCb *ue,
-U8 tmrEvnt
+uint8_t tmrEvnt
)
#else
Void rgSCHMeasGapANRepDlInactvTmrExpry(ue, tmrEvnt)
RgSchUeCb *ue;
-U8 tmrEvnt;
+uint8_t tmrEvnt;
#endif
{
cmInitTimers (&ue->measGapCb.measGapDlInactvTmr, 1);
cmInitTimers (&ue->ackNakRepCb.ackNakRepDlInactvTmr, 1);
}
- RETVOID;
+ return;
}
/**
Void rgSCHMeasGapANRepUlInactvTmrExpry
(
RgSchUeCb *ue,
-U8 tmrEvnt
+uint8_t tmrEvnt
)
#else
Void rgSCHMeasGapANRepUlInactvTmrExpry(ue, tmrEvnt)
RgSchUeCb *ue;
-U8 tmrEvnt;
+uint8_t tmrEvnt;
#endif
{
RgSchCellCb *cell = ue->cell;
cmInitTimers (&ue->measGapCb.measGapUlInactvTmr, 1);
cmInitTimers (&ue->ackNakRepCb.ackNakRepUlInactvTmr, 1);
}
- RETVOID;
+ return;
}
/**
ue->measGapCb.isMeasuring = FALSE;
cmInitTimers (&ue->measGapCb.measGapTmr, 1);
- RETVOID;
+ return;
}
/**
ue->ackNakRepCb.isAckNakRep = FALSE;
cmInitTimers (&ue->ackNakRepCb.ackNakRepTmr, 1);
- RETVOID;
+ return;
}
CmLList *hqNode;
RgSchDlHqProcCb *hqP;
RgSchDlHqTbCb *tbCb;
- U32 i;
+ uint32_t i;
node = crntDlSf->ueLst.first;
while (node)
}
}
}
- RETVOID;
+ return;
}
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *dlSf
* @param[in] CmLteTimingInfo repTime
- * @param[in] U8 repCnt
+ * @param[in] uint8_t repCnt
*
- * @return U8
+ * @return uint8_t
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHAckNakRepFindUlDuration
+PRIVATE uint8_t rgSCHAckNakRepFindUlDuration
(
RgSchCellCb *cell,
RgSchDlSf *dlSf,
CmLteTimingInfo repTime,
-U8 repCnt
+uint8_t repCnt
)
#else
-PRIVATE U8 rgSCHAckNakRepFindUlDuration(cell, dlSf, repTime, repCnt)
+PRIVATE uint8_t rgSCHAckNakRepFindUlDuration(cell, dlSf, repTime, repCnt)
RgSchCellCb *cell;
RgSchDlSf *dlSf;
CmLteTimingInfo repTime;
-U8 repCnt;
+uint8_t repCnt;
#endif
{
CmLteTimingInfo ulfrm;
- U8 noSubfrms = 0;
- U16 ulDlCfgIdx = cell->ulDlCfgIdx;
+ uint8_t noSubfrms = 0;
+ uint16_t ulDlCfgIdx = cell->ulDlCfgIdx;
S16 rem = 0;
S16 idx;
S8 diff;
*
* @param[in] RgSchDlSf *dlSf
* @param[in] CmLteTimingInfo crntDlTime
- * @param[in] U8 *noSubfrms
+ * @param[in] uint8_t *noSubfrms
*
- * @return U8
+ * @return uint8_t
*
**/
(
RgSchDlSf *dlSf,
CmLteTimingInfo crntDlTime,
-U8 *noSubfrms
+uint8_t *noSubfrms
)
#else
PRIVATE Void rgSCHAckNakRepGetUlOffsetFrmDl(dlSf, crntDlTime, noSubfrms)
RgSchDlSf *dlSf;
CmLteTimingInfo crntDlTime;
-U8 *noSubfrms;
+uint8_t *noSubfrms;
#endif
{
{
*noSubfrms = dlSf->dlFdbkInfo.subframe - crntDlTime.subframe;
}
- RETVOID;
+ return;
}
#endif
\f
/* This table maps a given number of RBs (given by array index)
* to the power in dB that these many RBs map to. */
-CONSTANT U8 rgSchPwrRbToPwrTbl[111] = { 0, /* First entry is dummy */
+CONSTANT uint8_t rgSchPwrRbToPwrTbl[111] = { 0, /* First entry is dummy */
0, 3, 4, 6, 7, 7, 8, 9, 9, 10,
10, 10, 11, 11, 11, 12, 12, 12, 12, 13,
13, 13, 13, 13, 14, 14, 14, 14, 14, 14,
/* This table maps power (in dB) to number of RBs */
/* The array size comes from max power in rgSchPwrRbToPwrTbl */
-CONSTANT U8 rgSchPwrToRbTbl[20+1] = {
+CONSTANT uint8_t rgSchPwrToRbTbl[20+1] = {
1, 1, 2, 2, 3, 4, 5, 6, 7, 9, 11,
13, 17, 21, 26, 33, 41, 52, 65, 82, 103
};
PRIVATE S8 rgSCHPwrGetCqiPwr ARGS((
- U8 cqi
+ uint8_t cqi
));
PRIVATE S8 rgSCHPwrGetCqiPwrForUe ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
- U8 cqi
+ uint8_t cqi
));
PRIVATE S8 rgSCHPwrCalcEfficncyPwr ARGS((
- U32 eff
+ uint32_t eff
));
PRIVATE S8 rgSCHPwrGetDelta2FrmCqi ARGS((
- U8 crntCqi,
- U8 trgCqi,
+ uint8_t crntCqi,
+ uint8_t trgCqi,
RgSchUeCb *ue,
RgSchCellCb *cell
));
PRIVATE Void rgSCHPwrGetPuschTpc ARGS((
- U8 isAcc,
+ uint8_t isAcc,
S8 delta,
S8 availPwr,
- U8 *tpc,
+ uint8_t *tpc,
S8 *tpcDelta
));
-PRIVATE U8 rgSCHPwrGetMaxRb ARGS((
+PRIVATE uint8_t rgSCHPwrGetMaxRb ARGS((
RgSchCellCb *cell,
S8 pwr
));
-PRIVATE U8 rgSCHPwrRbToPwr ARGS((
+PRIVATE uint8_t rgSCHPwrRbToPwr ARGS((
RgSchCellCb *cell,
- U8 numRb
+ uint8_t numRb
));
PRIVATE Void rgSCHPwrSchedPucchRnti ARGS((
RgSchCellCb *cell,
));
PRIVATE Void rgSCHPwrGetPucchFmt3TpcForUe ARGS((
RgSchUeCb *ue,
- U8 *tpc,
+ uint8_t *tpc,
S8 *delta
));
PRIVATE Void rgSCHPwrGetPucchFmt3aTpcForUe ARGS((
RgSchUeCb *ue,
- U8 *tpc,
+ uint8_t *tpc,
S8 *delta
));
PRIVATE Void rgSCHPwrGetPuschFmt3TpcForUe ARGS((
RgSchUeCb *ue,
- U8 *tpc,
+ uint8_t *tpc,
S8 *delta
));
PRIVATE Void rgSCHPwrGetPuschFmt3aTpcForUe ARGS((
RgSchUeCb *ue,
- U8 *tpc,
+ uint8_t *tpc,
S8 *delta
));
PRIVATE Void rgSCHPwrGetAcc1bitTpc ARGS((
S8 remPwr,
- U8 *tpc,
+ uint8_t *tpc,
S8 *delta
));
PRIVATE Void rgSCHPwrGetAcc2bitTpc ARGS((
S8 remPwr,
- U8 *tpc,
+ uint8_t *tpc,
S8 *delta
));
PRIVATE Void rgSCHPwrGetAbsTpc ARGS((
S8 remPwr,
- U8 *tpc,
+ uint8_t *tpc,
S8 *delta
));
PRIVATE Void rgSCHPwrOnPucchGrpPwrForUe ARGS((
));
PRIVATE S16 rgSCHPwrChkPucchTpcRntiIdx ARGS((
RgSchCmnTpcRntiCb *cb,
- U8 idx
+ uint8_t idx
));
PRIVATE S16 rgSCHPwrChkPuschTpcRntiIdx ARGS((
RgSchCmnTpcRntiCb *cb,
- U8 idx
+ uint8_t idx
));
PRIVATE S16 rgSCHPwrChkUniqPucchTpcRntiIdx ARGS((
RgSchCmnTpcRntiCb *cb,
- U8 idx
+ uint8_t idx
));
PRIVATE S16 rgSCHPwrChkUniqPuschTpcRntiIdx ARGS((
RgSchCmnTpcRntiCb *cb,
- U8 idx
+ uint8_t idx
));
PRIVATE S16 rgSCHPwrChkTpcRntiIdx ARGS((
RgSchCmnTpcRntiCb *cb,
- U8 idx
+ uint8_t idx
));
PRIVATE S8 rgSCHPwrGetPhValFromPhr ARGS((
- U8 phr
+ uint8_t phr
));
PRIVATE S8 rgSCHPwrGetPCMaxValFromPCMax ARGS((
- U8 pCMax
+ uint8_t pCMax
));
/* local defines */
Void rgSCHPwrInit()
#endif
{
- U8 idx;
+ uint8_t idx;
rgSchPwrCqiToPwrTbl[0] = 0; /* This should never be used anyway */
for (idx = 1; idx < RG_SCH_CMN_UL_NUM_CQI; ++idx)
{
rgSchPwrCqiToPwrTbl[idx] = rgSCHPwrCalcEfficncyPwr(rgSchCmnUlCqiTbl[idx].eff);
}
- RETVOID;
+ return;
}
/***********************************************************
* Desc : Returns power corresponding to coding efficiency
* when beta pusch is assumed 1.
*
- * Ret : U8
+ * Ret : uint8_t
*
* Notes:
*
#ifdef ANSI
PRIVATE S8 rgSCHPwrGetCqiPwr
(
-U8 cqi
+uint8_t cqi
)
#else
PRIVATE S8 rgSCHPwrGetCqiPwr(cqi)
-U8 cqi;
+uint8_t cqi;
#endif
{
* Desc : If MCS control is enabled for UE, returns
* power corresponding to CQI, else 0.
*
- * Ret : U8
+ * Ret : uint8_t
*
* Notes:
*
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 cqi
+uint8_t cqi
)
#else
PRIVATE S8 rgSCHPwrGetCqiPwrForUe(cell, ue, cqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 cqi;
+uint8_t cqi;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
* Desc : Computes power corresponding to a coding
* efficiency.
*
- * Ret : U8
+ * Ret : uint8_t
*
* Notes: Assumes beta pusch to be 1
*
#ifdef ANSI
PRIVATE S8 rgSCHPwrCalcEfficncyPwr
(
-U32 eff
+uint32_t eff
)
#else
PRIVATE S8 rgSCHPwrCalcEfficncyPwr(eff)
-U32 eff;
+uint32_t eff;
#endif
{
F64 ks = 1.25; /* or F64 */
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @return U8
+ * @return uint8_t
**/
#ifdef ANSI
-U8 rgSCHPwrPuschTpcForUe
+uint8_t rgSCHPwrPuschTpcForUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-U8 rgSCHPwrPuschTpcForUe(cell, ue)
+uint8_t rgSCHPwrPuschTpcForUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
* @return Void
**/
#ifdef ANSI
-U8 rgSCHPwrGetMaxUlRb
+uint8_t rgSCHPwrGetMaxUlRb
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-U8 rgSCHPwrGetMaxUlRb(cell, ue)
+uint8_t rgSCHPwrGetMaxUlRb(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
S8 delta;
#ifdef TFU_UPGRADE
- U8 cqi = ueUl->validUlCqi;
+ uint8_t cqi = ueUl->validUlCqi;
S32 tmp;
#else
- U8 cqi = ueUl->crntUlCqi[0];
+ uint8_t cqi = ueUl->crntUlCqi[0];
#endif
Bool isAcc = uePwr->isAccumulated;
- U8 tpc;
+ uint8_t tpc;
S8 availPwr;
- U8 maxRb;
+ uint8_t maxRb;
UNUSED(cell);
uePwr->delta = delta;
uePwr->maxUlRbs = maxRb;
uePwr->puschTpc = tpc;
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @return U8
+ * @return uint8_t
**/
#ifdef ANSI
-U8 rgSCHPwrPucchTpcForUe
+uint8_t rgSCHPwrPucchTpcForUe
(
RgSchCellCb *cell,
RgSchUeCb *ue
)
#else
-U8 rgSCHPwrPucchTpcForUe(cell, ue)
+uint8_t rgSCHPwrPucchTpcForUe(cell, ue)
RgSchCellCb *cell;
RgSchUeCb *ue;
#endif
#ifdef ANSI
PRIVATE S8 rgSCHPwrGetDelta2FrmCqi
(
-U8 crntCqi,
-U8 trgCqi,
+uint8_t crntCqi,
+uint8_t trgCqi,
RgSchUeCb *ue,
RgSchCellCb *cell
)
#else
PRIVATE S8 rgSCHPwrGetDelta2FrmCqi(crntCqi, trgCqi)
-U8 crntCqi;
-U8 trgCqi;
+uint8_t crntCqi;
+uint8_t trgCqi;
RgSchUeCb *ue;
RgSchCellCb *cell;
#endif
#ifdef ANSI
PRIVATE Void rgSCHPwrGetPuschTpc
(
-U8 isAcc,
+uint8_t isAcc,
S8 delta,
S8 availPwr,
-U8 *tpc,
+uint8_t *tpc,
S8 *tpcDelta
)
#else
PRIVATE Void rgSCHPwrGetPuschTpc(isAcc, delta, availPwr, tpc, tpcDelta)
-U8 isAcc;
+uint8_t isAcc;
S8 delta;
S8 availPwr;
-U8 *tpc;
+uint8_t *tpc;
S8 *tpcDelta;
#endif
{
{
rgSCHPwrGetAbsTpc(delta, tpc, tpcDelta);
}
- RETVOID;
+ return;
} /* rgSCHPwrGetPuschTpc */
/***********************************************************
* expected to be supported by the passed
* power headroom.
*
- * Ret : U8
+ * Ret : uint8_t
*
* Notes:
*
*
**********************************************************/
#ifdef ANSI
-PRIVATE U8 rgSCHPwrGetMaxRb
+PRIVATE uint8_t rgSCHPwrGetMaxRb
(
RgSchCellCb *cell,
S8 pwr
)
#else
-PRIVATE U8 rgSCHPwrGetMaxRb(cell, pwr)
+PRIVATE uint8_t rgSCHPwrGetMaxRb(cell, pwr)
RgSchCellCb *cell;
S8 pwr;
#endif
{
return (cellUl->maxUlBwPerUe);
}
- return (RGSCH_MIN(cellUl->maxUlBwPerUe,rgSchPwrToRbTbl[(U8)pwr]));
+ return (RGSCH_MIN(cellUl->maxUlBwPerUe,rgSchPwrToRbTbl[(uint8_t)pwr]));
} /* rgSCHPwrGetMaxRb */
/***********************************************************
*
* Desc : Get the power corresponding to number of RBs
*
- * Ret : U8
+ * Ret : uint8_t
*
* Notes:
*
*
**********************************************************/
#ifdef ANSI
-PRIVATE U8 rgSCHPwrRbToPwr
+PRIVATE uint8_t rgSCHPwrRbToPwr
(
RgSchCellCb *cell,
-U8 numRb
+uint8_t numRb
)
#else
-PRIVATE U8 rgSCHPwrRbToPwr(cell,numRb)
+PRIVATE uint8_t rgSCHPwrRbToPwr(cell,numRb)
RgSchCellCb *cell;
-U8 numRb;
+uint8_t numRb;
#endif
{
#ifndef NO_ERRCLS
rgSCHPwrGetAcc2bitTpc(uePwr->remPucchPwr, &uePwr->pucchTpc, &delta);
rgSCHPwrOnSchedPucchTpc(cell, ue, delta);
- RETVOID;
+ return;
}
/**
* be scheduled again */
}
- RETVOID;
+ return;
}
/**
* be scheduled again */
}
- RETVOID;
+ return;
}
/***********************************************************
{
CmLListCp *lst;
CmLList *lnk;
- U8 *tpcCmds;
- U8 tpc;
+ uint8_t *tpcCmds;
+ uint8_t tpc;
S8 delta;
Bool atleastOne;
rgSCHPwrRmvSchdPucchTpcRntiCb(cell, cb);
}
- RETVOID;
+ return;
} /* rgSCHPwrSchedPucchRnti */
/***********************************************************
{
CmLListCp *lst;
CmLList *lnk;
- U8 *tpcCmds;
- U8 tpc;
+ uint8_t *tpcCmds;
+ uint8_t tpc;
S8 delta;
Bool atleastOne;
rgSCHPwrRmvSchdPuschTpcRntiCb(cell, cb);
}
- RETVOID;
+ return;
} /* rgSCHPwrSchedPuschRnti */
/***********************************************************
PRIVATE Void rgSCHPwrGetPucchFmt3TpcForUe
(
RgSchUeCb *ue,
-U8 *tpc,
+uint8_t *tpc,
S8 *delta
)
#else
PRIVATE Void rgSCHPwrGetPucchFmt3TpcForUe(ue, tpc, delta)
RgSchUeCb *ue;
-U8 *tpc;
+uint8_t *tpc;
S8 *delta;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
rgSCHPwrGetAcc2bitTpc(uePwr->remPucchPwr, tpc, delta);
- RETVOID;
+ return;
} /* rgSCHPwrGetPucchFmt3TpcForUe */
/***********************************************************
PRIVATE Void rgSCHPwrGetPucchFmt3aTpcForUe
(
RgSchUeCb *ue,
-U8 *tpc,
+uint8_t *tpc,
S8 *delta
)
#else
PRIVATE Void rgSCHPwrGetPucchFmt3aTpcForUe(ue, tpc, delta)
RgSchUeCb *ue;
-U8 *tpc;
+uint8_t *tpc;
S8 *delta;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, ue->cell);
rgSCHPwrGetAcc1bitTpc(uePwr->remPucchPwr, tpc, delta);
- RETVOID;
+ return;
} /* rgSCHPwrGetPucchFmt3aTpcForUe */
/***********************************************************
PRIVATE Void rgSCHPwrGetPuschFmt3TpcForUe
(
RgSchUeCb *ue,
-U8 *tpc,
+uint8_t *tpc,
S8 *delta
)
#else
PRIVATE Void rgSCHPwrGetPuschFmt3TpcForUe(ue, tpc, delta)
RgSchUeCb *ue;
-U8 *tpc;
+uint8_t *tpc;
S8 *delta;
#endif
{
S8 adj = RGSCH_MIN(uePwr->remPuschPwr, uePwr->phVal);
rgSCHPwrGetAcc2bitTpc(adj, tpc, delta);
- RETVOID;
+ return;
} /* rgSCHPwrGetPuschFmt3TpcForUe */
/***********************************************************
PRIVATE Void rgSCHPwrGetPuschFmt3aTpcForUe
(
RgSchUeCb *ue,
-U8 *tpc,
+uint8_t *tpc,
S8 *delta
)
#else
PRIVATE Void rgSCHPwrGetPuschFmt3aTpcForUe(ue, tpc, delta)
RgSchUeCb *ue;
-U8 *tpc;
+uint8_t *tpc;
S8 *delta;
#endif
{
/* Don't attempt to look at headroom now, power
* adjustment is small anyway */
rgSCHPwrGetAcc1bitTpc(uePwr->remPuschPwr, tpc, delta);
- RETVOID;
+ return;
} /* rgSCHPwrGetPuschFmt3aTpcForUe */
/***********************************************************
PRIVATE Void rgSCHPwrGetAcc1bitTpc
(
S8 remPwr,
-U8 *tpc,
+uint8_t *tpc,
S8 *delta
)
#else
PRIVATE Void rgSCHPwrGetAcc1bitTpc(remPwr, tpc, delta)
S8 remPwr;
-U8 *tpc;
+uint8_t *tpc;
S8 *delta;
#endif
{
*delta = 1;
*tpc = 1;
}
- RETVOID;
+ return;
} /* rgSCHPwrGetAcc1bitTpc */
/***********************************************************
PRIVATE Void rgSCHPwrGetAcc2bitTpc
(
S8 remPwr,
-U8 *tpc,
+uint8_t *tpc,
S8 *delta
)
#else
PRIVATE Void rgSCHPwrGetAcc2bitTpc(remPwr, tpc, delta)
S8 remPwr;
-U8 *tpc;
+uint8_t *tpc;
S8 *delta;
#endif
{
* 2 1
* 3 3
*/
- U8 tpcs[3] = {1, 2, 2};
- U8 deltas[3] = {0, 1, 1};
+ uint8_t tpcs[3] = {1, 2, 2};
+ uint8_t deltas[3] = {0, 1, 1};
if (remPwr <= -1)
{
*tpc = 0;
}
else
{
- *tpc = tpcs[(U8)remPwr];
- *delta = deltas[(U8)remPwr];
+ *tpc = tpcs[(uint8_t)remPwr];
+ *delta = deltas[(uint8_t)remPwr];
}
- RETVOID;
+ return;
} /* rgSCHPwrGetAcc2bitTpc */
/***********************************************************
PRIVATE Void rgSCHPwrGetAbsTpc
(
S8 remPwr,
-U8 *tpc,
+uint8_t *tpc,
S8 *delta
)
#else
PRIVATE Void rgSCHPwrGetAbsTpc(remPwr, tpc, delta)
S8 remPwr;
-U8 *tpc;
+uint8_t *tpc;
S8 *delta;
#endif
{
*tpc = 3;
*delta = 4;
}
- RETVOID;
+ return;
} /* rgSCHPwrGetAbsTpc */
/***********************************************************
* this will happen in the caller once this
* function is called for every UE scheduled. */
}
- RETVOID;
+ return;
}
/***********************************************************
* this will happen in the caller once this
* function is called for every UE scheduled. */
}
- RETVOID;
+ return;
}
/***********************************************************
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 pwrDelta
+ * @param[in] uint8_t pwrDelta
* @return Void
**/
#ifdef ANSI
if ((cb = uePwr->tpcPucchRntiCb) == NULLP)
{
- RETVOID;
+ return;
}
toAdd = FALSE;
rgSCHPwrRmvSchdUeFrmPucchTpcRntiCb(cell, cb, ue);
}
- RETVOID;
+ return;
}
/**
if (uePwr->schdPucchGrpLnk.node == NULLP)
{
- RETVOID;
+ return;
}
/* UE was scheduled for TPC, sent TPC may
rgSCHPwrRmvSchdPucchTpcRntiCb(cell, uePwr->tpcPucchRntiCb);
}
}
- RETVOID;
+ return;
}
/* Don't do anything for the case of absolute TPC commands */
if (!uePwr->isAccumulated)
{
- RETVOID;
+ return;
}
uePwr->remPuschPwr -= uePwr->delta;
if (uePwr->schdPuschGrpLnk.node == NULLP)
{
- RETVOID;
+ return;
}
/* UE was scheduled for pusch TPC, sent TPC may
rgSCHPwrRmvSchdUeFrmPuschTpcRntiCb(cell, uePwr->tpcPuschRntiCb, ue);
}
- RETVOID;
+ return;
}
/**
RgSchCmnAllocRecord *allocInfo;
#endif
{
- U8 idx;
+ uint8_t idx;
RgInfExtPhrSCellInfo *servCellPhr;
S8 pCMax;
rgSCHPwrUpdPhr(ue->cellInfo[servCellPhr->sCellIdx]->cell,
ue, servCellPhr->phr, allocInfo, pCMax);
}
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 phr
+ * @param[in] uint8_t phr
* @param[in] RgSchCmnAllocRecord allocInfo
- * @param[in] U8 maxUePwr
+ * @param[in] uint8_t maxUePwr
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 phr,
+uint8_t phr,
RgSchCmnAllocRecord *allocInfo,
S8 maxUePwr
)
Void rgSCHPwrUpdPhr(cell, ue, phr, allocInfo, maxUePwr)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 phr;
+uint8_t phr;
RgSchCmnAllocRecord *allocInfo;
S8 maxUePwr;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
- U8 rbPwr;
- U8 effPwr;
+ uint8_t rbPwr;
+ uint8_t effPwr;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
uePwr->phVal = rgSCHPwrGetPhValFromPhr(phr);
allocInfo->cqi,
allocInfo->numRb,
uePwr->pwrPerRb);
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 numRb
+ * @param[in] uint8_t numRb
* @return Void
**/
#ifdef ANSI
}
#endif
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 numRb
+ * @param[in] uint8_t numRb
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 numRb
+uint8_t numRb
)
#else
Void rgSCHPwrRecordRbAlloc(cell, ue, numRb)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 numRb;
+uint8_t numRb;
#endif
{
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
UNUSED(cell);
- RETVOID;
+ return;
if (uePwr->isPhrAvail)
{
uePwr->phVal = RGSCH_MIN(40, uePwr->phVal);
}
uePwr->numRb = numRb;
- RETVOID;
+ return;
}
/**
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
CmLteRnti rnti;
CmLteRnti startRnti;
- U16 size;
+ uint16_t size;
Bool isFmt3a;
/* Right now, all UEs have fixed maximum power capability. So
UNUSED(cell);
/* There is no allocated memory, so do nothing */
- RETVOID;
+ return;
}
RgSchCmnUeUlPwrCb *uePwr = RG_SCH_PWR_GETUEPWR(ue, cell);
RgSchCmnTpcRntiCb *pucchRntiCb = NULLP;
RgSchCmnTpcRntiCb *puschRntiCb = NULLP;
- U8 pucchIdx = 0;
- U8 puschIdx = 0;
+ uint8_t pucchIdx = 0;
+ uint8_t puschIdx = 0;
/* Validate Pucch group power control config */
if (pwrCfg->uePucchPwr.pres)
#ifndef ALIGN_64BIT
RLOG_ARG4(L_UNUSED,DBG_CELLID,cell->cellId,
"<GRP_PWR>PucchRntiCb cfgdUes(%ld %lu %lu) UEID:%d",
- pucchRntiCb->cfgdUes.count,((U32)pucchRntiCb->cfgdUes.first),
- ((U32)pucchRntiCb->cfgdUes.last),ue->ueId);
+ pucchRntiCb->cfgdUes.count,((uint32_t)pucchRntiCb->cfgdUes.first),
+ ((uint32_t)pucchRntiCb->cfgdUes.last),ue->ueId);
RLOG_ARG3(L_UNUSED,DBG_CELLID,cell->cellId,
"UEID:%d isFmt3a(%u) ueNode(%ld)",
ue->ueId,pucchRntiCb->isFmt3a,
RLOG_ARG4(L_UNUSED,DBG_CELLID,cell->cellId,
"toBeSchdUes(%ld %lu %lu) tpcRnti(%u)",
pucchRntiCb->toBeSchdUes.count,
- ((U32)pucchRntiCb->toBeSchdUes.first),
- ((U32)pucchRntiCb->toBeSchdUes.last),
+ ((uint32_t)pucchRntiCb->toBeSchdUes.first),
+ ((uint32_t)pucchRntiCb->toBeSchdUes.last),
pucchRntiCb->tpcRnti);
#else
RLOG_ARG4(L_UNUSED,DBG_CELLID,cell->cellId,
"<GRP_PWR>PucchRntiCb cfgdUes(%ld %lu %lu) UEID:%d",
- pucchRntiCb->cfgdUes.count,((U64)pucchRntiCb->cfgdUes.first),
- ((U64)pucchRntiCb->cfgdUes.last),ue->ueId);
+ pucchRntiCb->cfgdUes.count,((uint64_t)pucchRntiCb->cfgdUes.first),
+ ((uint64_t)pucchRntiCb->cfgdUes.last),ue->ueId);
RLOG_ARG3(L_UNUSED,DBG_CELLID,cell->cellId,
"UEID:%d isFmt3a(%u) ueNode(%ld)",
ue->ueId,pucchRntiCb->isFmt3a,
RLOG_ARG4(L_UNUSED,DBG_CELLID,cell->cellId,
"toBeSchdUes(%ld %lu %lu) tpcRnti(%u)",
pucchRntiCb->toBeSchdUes.count,
- ((U64)pucchRntiCb->toBeSchdUes.first),
- ((U64)pucchRntiCb->toBeSchdUes.last),
+ ((uint64_t)pucchRntiCb->toBeSchdUes.first),
+ ((uint64_t)pucchRntiCb->toBeSchdUes.last),
pucchRntiCb->tpcRnti);
#endif
rgSCHPwrDelUeFrmPuschTpcRntiCb(cell, uePwr->tpcPuschRntiCb, ue);
uePwr->tpcPuschRntiCb = NULLP;
}
- RETVOID;
+ return;
}
/**
rgSCHPwrUeResetPucch(cell, ue);
rgSCHPwrUeResetPusch(cell, ue);
- RETVOID;
+ return;
}
/***********************************************************
}
/* Stack Crash problem for TRACE5 changes. Added the line below */
- RETVOID;
+ return;
}
{
rgSCHPwrRmvSchdUeFrmPuschTpcRntiCb(cell, uePwr->tpcPuschRntiCb, ue);
}
- RETVOID;
+ return;
}
/***********************************************************
if ((cb = uePwr->tpcPuschRntiCb) == NULLP)
{
- RETVOID;
+ return;
}
/* Not checking for uwPwr->isPhrAvail as uePwr->phVal
rgSCHPwrRmvSchdUeFrmPuschTpcRntiCb(cell, cb, ue);
}
- RETVOID;
+ return;
}
rgSCHPwrInitTpcRntiCb(&cellPwr->tpcPucchRntiLst[cellPwr->tpcPucchRntiCnt++],
rnti, isFmt3a);
- RETVOID;
+ return;
}
/***********************************************************
rgSCHPwrInitTpcRntiCb(&cellPwr->tpcPuschRntiLst[cellPwr->tpcPuschRntiCnt++],
rnti, isFmt3a);
- RETVOID;
+ return;
}
/***********************************************************
cb->isFmt3a = isFmt3a;
/* Not initialising lists as memset 0 takes care of it */
/* cb->schdLnk.node is set when this rnti is to be scheduled */
- RETVOID;
+ return;
}
/***********************************************************
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- U16 idx;
+ uint16_t idx;
if (!cellPwr->tpcPucchRntiCnt)
{
#endif
{
RgSchCmnUlPwrCb *cellPwr = RG_SCH_PWR_GETCELLPWR(cell);
- U16 idx;
+ uint16_t idx;
if (!cellPwr->tpcPuschRntiCnt)
{
cmLListAdd2Tail(&cb->cfgdUes, &uePwr->pucchGrpLnk);
uePwr->pucchGrpLnk.node = (PTR)ue;
- RETVOID;
+ return;
}
/***********************************************************
rgSCHPwrRmvSchdUeFrmPucchTpcRntiCb(cell, cb, ue);
cmLListDelFrm(&cb->cfgdUes, &uePwr->pucchGrpLnk);
uePwr->pucchGrpLnk.node = NULLP;
- RETVOID;
+ return;
}
/***********************************************************
if (uePwr->schdPucchGrpLnk.node == NULLP)
{
- RETVOID;
+ return;
}
rgSCHPwrRmvSchdUeOnlyFrmPucchTpcRntiCb(cell, cb, ue);
if (!cb->toBeSchdUes.count)
{
rgSCHPwrRmvSchdPucchTpcRntiCb(cell, cb);
}
- RETVOID;
+ return;
}
/***********************************************************
cmLListDelFrm(&cb->toBeSchdUes, &uePwr->schdPucchGrpLnk);
uePwr->schdPucchGrpLnk.node = NULLP;
}
- RETVOID;
+ return;
}
/***********************************************************
if (cb->schdLnk.node == NULLP)
{
- RETVOID;
+ return;
}
cmLListDelFrm(&cellPwr->pucchGrpPwr, &cb->schdLnk);
cb->schdLnk.node = NULLP;
- RETVOID;
+ return;
}
/***********************************************************
if (uePwr->schdPucchGrpLnk.node != NULLP)
{
/* UE is already in the list */
- RETVOID;
+ return;
}
cmLListAdd2Tail(&cb->toBeSchdUes, &uePwr->schdPucchGrpLnk);
uePwr->schdPucchGrpLnk.node = (PTR)ue;
* for scheduling */
rgSCHPwrAddSchdPucchTpcRntiCb(cell, cb);
}
- RETVOID;
+ return;
}
/***********************************************************
cmLListAdd2Tail(&cellPwr->pucchGrpPwr, &cb->schdLnk);
cb->schdLnk.node = (PTR)cb;
- RETVOID;
+ return;
}
cmLListAdd2Tail(&cb->cfgdUes, &uePwr->puschGrpLnk);
uePwr->puschGrpLnk.node = (PTR)ue;
- RETVOID;
+ return;
}
/***********************************************************
if (uePwr->schdPuschGrpLnk.node != NULLP)
{
/* UE is already in the list */
- RETVOID;
+ return;
}
cmLListAdd2Tail(&cb->toBeSchdUes, &uePwr->schdPuschGrpLnk);
uePwr->schdPuschGrpLnk.node = (PTR)ue;
* for scheduling */
rgSCHPwrAddSchdPuschTpcRntiCb(cell, cb);
}
- RETVOID;
+ return;
}
/***********************************************************
rgSCHPwrRmvSchdUeFrmPuschTpcRntiCb(cell, cb, ue);
cmLListDelFrm(&cb->cfgdUes, &uePwr->puschGrpLnk);
uePwr->puschGrpLnk.node = NULLP;
- RETVOID;
+ return;
}
/***********************************************************
if (uePwr->schdPuschGrpLnk.node == NULLP)
{
- RETVOID;
+ return;
}
rgSCHPwrRmvSchdUeOnlyFrmPuschTpcRntiCb(cell, cb, ue);
if (!cb->toBeSchdUes.count)
{
rgSCHPwrRmvSchdPuschTpcRntiCb(cell, cb);
}
- RETVOID;
+ return;
}
/***********************************************************
cmLListDelFrm(&cb->toBeSchdUes, &uePwr->schdPuschGrpLnk);
uePwr->schdPuschGrpLnk.node = NULLP;
}
- RETVOID;
+ return;
}
/***********************************************************
cmLListAdd2Tail(&cellPwr->puschGrpPwr, &cb->schdLnk);
cb->schdLnk.node = (PTR)cb;
- RETVOID;
+ return;
}
/***********************************************************
if (cb->schdLnk.node == NULLP)
{
- RETVOID;
+ return;
}
cmLListDelFrm(&cellPwr->puschGrpPwr, &cb->schdLnk);
cb->schdLnk.node = NULLP;
- RETVOID;
+ return;
}
/***********************************************************
PRIVATE S16 rgSCHPwrChkPucchTpcRntiIdx
(
RgSchCmnTpcRntiCb *cb,
-U8 idx
+uint8_t idx
)
#else
PRIVATE S16 rgSCHPwrChkPucchTpcRntiIdx(cb, idx)
RgSchCmnTpcRntiCb *cb;
-U8 idx;
+uint8_t idx;
#endif
{
PRIVATE S16 rgSCHPwrChkPuschTpcRntiIdx
(
RgSchCmnTpcRntiCb *cb,
-U8 idx
+uint8_t idx
)
#else
PRIVATE S16 rgSCHPwrChkPuschTpcRntiIdx(cb, idx)
RgSchCmnTpcRntiCb *cb;
-U8 idx;
+uint8_t idx;
#endif
{
PRIVATE S16 rgSCHPwrChkUniqPucchTpcRntiIdx
(
RgSchCmnTpcRntiCb *cb,
-U8 idx
+uint8_t idx
)
#else
PRIVATE S16 rgSCHPwrChkUniqPucchTpcRntiIdx(cb, idx)
RgSchCmnTpcRntiCb *cb;
-U8 idx;
+uint8_t idx;
#endif
{
CmLList *lnk;
PRIVATE S16 rgSCHPwrChkUniqPuschTpcRntiIdx
(
RgSchCmnTpcRntiCb *cb,
-U8 idx
+uint8_t idx
)
#else
PRIVATE S16 rgSCHPwrChkUniqPuschTpcRntiIdx(cb, idx)
RgSchCmnTpcRntiCb *cb;
-U8 idx;
+uint8_t idx;
#endif
{
CmLList *lnk;
PRIVATE S16 rgSCHPwrChkTpcRntiIdx
(
RgSchCmnTpcRntiCb *cb,
-U8 idx
+uint8_t idx
)
#else
PRIVATE S16 rgSCHPwrChkTpcRntiIdx(cb, idx)
RgSchCmnTpcRntiCb *cb;
-U8 idx;
+uint8_t idx;
#endif
{
if (cb->isFmt3a)
#ifdef ANSI
PRIVATE S8 rgSCHPwrGetPCMaxValFromPCMax
(
-U8 pCMax
+uint8_t pCMax
)
#else
PRIVATE S8 rgSCHPwrGetPCMaxValFromPCMax(pCMax)
-U8 pCMax;
+uint8_t pCMax;
#endif
{
return ((pCMax & 63) - 30);
#ifdef ANSI
PRIVATE S8 rgSCHPwrGetPhValFromPhr
(
-U8 phr
+uint8_t phr
)
#else
PRIVATE S8 rgSCHPwrGetPhValFromPhr(phr)
-U8 phr;
+uint8_t phr;
#endif
{
return ((phr & 63) - 23);
#ifdef ANSI
S16 rgSCHRamProcRaReq
(
-U8 raReqCnt,
+uint8_t raReqCnt,
RgSchCellCb *cell,
CmLteRnti raRnti,
TfuRachInfo *raReqInd,
)
#else
S16 rgSCHRamProcRaReq(raReqCnt, cell, raRnti, raReqInd, timingInfo, ue, err)
-U8 raReqCnt;
+uint8_t raReqCnt;
RgSchCellCb *cell;
CmLteRnti raRnti;
TfuRachInfo *raReqInd;
#endif
{
RgSchRaReqInfo *raReqInfo;
- U16 raIndex;
+ uint16_t raIndex;
#ifdef LTE_TDD
- U8 fid;
- U8 tid;
+ uint8_t fid;
+ uint8_t tid;
#endif
{
/* Releasing HARQ processes of old UE when ue
* reconfig with new crnti */
- /* U32 cnt; */
+ /* uint32_t cnt; */
RgSchDlHqEnt **hqEnt = &(RG_SCH_CMN_GET_UE_HQE(ue, cell));
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
{
/* Update Bo in RaCb */
- raCb->dlCcchInfo.bo = (U32)(staRsp->bo);
+ raCb->dlCcchInfo.bo = (uint32_t)(staRsp->bo);
/* SR_RACH_STATS : MSG4 WITH CCCH SDU */
rgNumMsg4WithCCCHSdu++;
#endif
{
RgSchRaCb *raCb;
- U16 raSfn;
- U16 crntSfn;
- U16 dist; /* Number of frames between raCb's creation and crnt
+ uint16_t raSfn;
+ uint16_t crntSfn;
+ uint16_t dist; /* Number of frames between raCb's creation and crnt
frame */
- U8 idx;
- U32 maxCnt;
+ uint8_t idx;
+ uint32_t maxCnt;
#ifndef LTE_TDD
- U8 winGap;
- U8 raIdx;
+ uint8_t winGap;
+ uint8_t raIdx;
RgSchRaReqInfo *raReqInfo;
#else
CmLteTimingInfo frm;
- U8 raIdx;
+ uint8_t raIdx;
#endif
{
RgSchRaReqInfo *raReqInfo;
RgSchRaCb *raCb;
- U8 idx;
- U8 raCbCnt;
+ uint8_t idx;
+ uint8_t raCbCnt;
Inst inst = cell->instIdx;
- U8 lstSz;
+ uint8_t lstSz;
#ifdef LTE_TDD
- U8 maxUlSubframes;
- U8 maxDlSubframes;
+ uint8_t maxUlSubframes;
+ uint8_t maxDlSubframes;
#endif
/* Delete RACB and release RNTI */
rgSCHRamDelRaCb(cell, raCb, TRUE);
}
- RETVOID;
+ return;
}
#ifdef ANSI
raCb->rntiLnk->rnti);
rgSCHRamAddToRaInfoSchdLst(cell, raCb);
/* MSG4 Fix End */
- RETVOID;
+ return;
}
/**
*
* @param[in,out] RgSchCellCb *cell
* @param[in] CmLteTimingInfo timingInfo
- * @param[in] U8 raIdx
+ * @param[in] uint8_t raIdx
* @return S16
* -# ROK
**/
(
RgSchCellCb *cell,
CmLteTimingInfo timingInfo,
-U8 raIdx
+uint8_t raIdx
)
#else
S16 rgSCHRamDelRaReq(cell, timingInfo, raIdx)
RgSchCellCb *cell;
CmLteTimingInfo timingInfo;
-U8 raIdx;
+uint8_t raIdx;
#endif
{
- U8 subfrmIdx;
+ uint8_t subfrmIdx;
RgSchTddRachRspLst *rachRsp;
- U16 sfnIdx;
+ uint16_t sfnIdx;
S16 calcSfn;
- U8 subfrm;
+ uint8_t subfrm;
RgSchRaReqInfo *raReqInfo;
- U8 idx;
- U8 i;
- U8 raRntiIdx;
+ uint8_t idx;
+ uint8_t i;
+ uint8_t raRntiIdx;
CmLteRnti raRnti;
{
rgSCHUtlUlAllocRls(sf, alloc);
}
- RETVOID;
+ return;
}
/**********************************************************************
RgSchCellCb *cell,
CmLListCp *ueTxLst,
RgSchCmnUlRbAllocInfo *allocInfo,
-U8 *remUe
+uint8_t *remUe
));
PRIVATE Void rgSCHSc1DlProcRmvFrmRetx ARGS((
RgSchCellCb *cell,
rgSCHSc1DlSuspendUe(cell, ue);
- RETVOID;
+ return;
}
\f
CmLList *node;
RgSchDlHqProcCb *hqP;
RgSchDlLcCb *svc;
- U8 idx;
+ uint8_t idx;
/* Add UE's HqProcs From UERetxLst to CellRetxLst */
lst = &ueDl->retxHqProcs;
rgSCHSc1DlUeAddToSchd(cell, ue);
}
- RETVOID;
+ return;
}
\f
/* Update the SVC's positioning in the Queue */
rgSCHSc1DlMngGbrSvcPosn(cell, ue, svc);
}
- RETVOID;
+ return;
}
\f
(hqProcDl->schSpfc))->prio], &(hqProcDl->retxLnk));
hqProcDl->retxLnk.node = NULLP;
}
- RETVOID;
+ return;
}
\f
&(hqProcDl->retxLnkUe));
hqProcDl->retxLnkUe.node = NULLP;
}
- RETVOID;
+ return;
}
\f
cmLListAdd2Tail(&sc1Ue->retxHqProcs,
&(cmnHqDl->retxLnkUe));
cmnHqDl->retxLnkUe.node = (PTR)hqP;
- RETVOID;
+ return;
}
\f
if (!RG_SCH_CMN_DL_IS_UE_ACTIVE(hqP->hqE->ue))
{
rgSCHSc1DlProcAddToUeRetx(cell, hqP->hqE->ue, hqP);
- RETVOID;
+ return;
}
cmLListAdd2Tail(&sc1CellDl->retxLst[((RgSchSc1DlHqProc *)\
(cmnHqDl->schSpfc))->prio], &(cmnHqDl->retxLnk));
cmnHqDl->retxLnk.node = (PTR)hqP;
- RETVOID;
+ return;
}
\f
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
- U8 i;
+ uint8_t i;
CmLListCp *retxLst;
CmLList *node;
RgSchDlHqProcCb *hqP;
#if (defined(LTEMAC_SPS) || (!defined(LTE_TDD)))
CmLteTimingInfo schdTime;
#endif
- U32 effBo;
+ uint32_t effBo;
RgSchUeCb *ue = NULLP;
#ifdef LTEMAC_HDFDD
Bool dlAllowed = FALSE;
ROK)
{
/* SF/RETX Bandwidth expired */
- RETVOID;
+ return;
}
if (effBo == 0)
{
&& (hqP->tbInfo[1].state == HQ_TB_ACKED))
{
rgSCHSc1DlProcRmvFrmCellRetx(cell, hqP);
- RETVOID;
+ return;
}
cmnUeDl->proc = hqP;
/*rgSCHCmnDlRbInfoAddUeRetx(allocInfo, ue);*/
}
}
- RETVOID;
+ return;
}
/***********************************************************
#endif
{
rgSCHDhmRlsHqProc(hqProc);
- RETVOID;
+ return;
}
\f
/**
* @param[in] RgSchCellCb *cell
* @param[in] RgSchDlSf *subFrm
* @param[in] RgSchDlLcCb *svc
- * @param[in] U32 bo
+ * @param[in] uint32_t bo
* @param[in] RgSchCmnDlRbAllocInfo *allocInfo
* @return S16
*
RgSchCellCb *cell,
RgSchDlSf *subFrm,
RgSchDlLcCb *svc,
-U32 bo,
+uint32_t bo,
RgSchCmnDlRbAllocInfo *allocInfo
)
#else
RgSchCellCb *cell;
RgSchDlSf *subFrm;
RgSchDlLcCb *svc;
-U32 bo;
+uint32_t bo;
RgSchCmnDlRbAllocInfo *allocInfo;
#endif
{
RgSchUeCb *ue;
RgSchDlHqProcCb *proc;
- U16 rlcHdrEstmt;
- U32 effBo;
+ uint16_t rlcHdrEstmt;
+ uint32_t effBo;
RgSchCmnDlCell *cmnCellDl = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchCmnDlSvc *svcCmn = RG_SCH_CMN_GET_DL_SVC(svc);
RgSchSc1DlSvc *svcSc1;
/* checking SVC's presence in this lst is unnecessary */
cmLListAdd2Tail(&ueSc1->schdSvcs, &svcSc1->schdSvcLnk);
svcSc1->schdSvcLnk.node = (PTR)svc;
- RETVOID;
+ return;
}
\f
CmLList *node;
RgSchUeCb *ue = NULLP;
RgSchDlLcCb *svc;
- U8 i;
+ uint8_t i;
RgSchSc1DlSvc *svcSc1;
RgSchSc1DlUe *ueDl;
RgSchSc1DlCell *sc1CellDl = RG_GET_SC1_CELL_DL(cell);
if (rgSCHSc1DlDedSvcAlloc(cell, subFrm, svc, svcSc1->bo, allocInfo) != ROK)
{
/* sf bw expired */
- RETVOID;
+ return;
}
}
if (rgSCHSc1DlDedSvcAlloc(cell, subFrm, svc, svcSc1->effMbr, allocInfo) != ROK)
{
/* sf bw expired */
- RETVOID;
+ return;
}
}
}
if (rgSCHSc1DlDedSvcAlloc(cell, subFrm, svc, ueDl->effAmbr, allocInfo) != ROK)
{
/* sf bw expired */
- RETVOID;
+ return;
}
}
}
- RETVOID;
+ return;
}
/**
#endif
{
- RETVOID;
+ return;
}
/**
* @brief scheduling for a cell
#endif
{
- RETVOID;
+ return;
}
\f
rgSCHSc1DlDedTx(cell, subFrm, allocInfo);
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
}
/**
rgSCHSc1DlRetxAlloc(cell, subFrm, allocInfo);
- RETVOID;
+ return;
}
/* The service is already in the scheduler */
if (svcSc1->prioLnk.node != NULLP)
{
- RETVOID;
+ return;
}
/* If the priority = 0, it is the highest priority with infinite */
/* If a svc is put in to cell wide priority Qs
* then add the same to UE's lcsWithData List */
rgSCHSc1DlAdd2UeLcsWithData(cell, svc->ue, svc);
- RETVOID;
+ return;
}
/* Handle GBR services. We have them of next importance */
if (svcCmn->prio <= RG_SCH_SC1_DL_GBR_PRIO_END)
{
if (!RG_SC1_SVC_HAS_DATA(svc,cell))
- RETVOID;
+ return;
lst = &(sc1CellDl->prioLst[svcCmn->prio]);
node = lst->first;
while(node)
* then add the same to UE's lcsWithData List */
rgSCHSc1DlAdd2UeLcsWithData(cell, svc->ue, svc);
}
- RETVOID;
+ return;
}
* then remove the same from UE's lcsWithData List */
rgSCHSc1DlRmFrmUeLcsWithData(cell, ue, ueDl->ambrSvc);
}
- RETVOID;
+ return;
}
\f
cmLListDelFrm(lst, &svcSc1->prioLnk);
svcSc1->prioLnk.node = (PTR)NULLP;
}
- RETVOID;
+ return;
}
\f
/* If svc already present in AMBR List return */
if (svcSc1->prioLnk.node != NULLP)
- RETVOID;
+ return;
node = ueDl->ambrLst.first;
while(node)
svcSc1->prioLnk.node = (PTR)svc;
}
- RETVOID;
+ return;
}
\f
* then remove the same from UE's lcsWithData List */
rgSCHSc1DlRmFrmUeLcsWithData(cell, svc->ue, svc);
}
- RETVOID;
+ return;
}
\f
cmLListAdd2Tail(&ueDl->gbrSvcs, &svcSc1->gbrLnk);
svcSc1->gbrLnk.node = (PTR)svc;
}
- RETVOID;
+ return;
}
\f
if (svcSc1 == NULLP)
{
- RETVOID;
+ return;
}
ueDl = RG_GET_SC1_UE_DL(ue, cell);
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx,
(Data**)(&(RG_SCH_CMN_GET_LC_SCH_SPFC(ue,svc,cell))), (sizeof(RgSchSc1DlSvc)));
- RETVOID;
+ return;
}
/**
svcSc1->gbr = svcCmn->gbr;
svcSc1->mbr = svcCmn->mbr;
}
- RETVOID;
+ return;
}
/**
/* If a svc is put in to cell wide priority Qs
* then add the same to UE's lcsWithData List */
rgSCHSc1DlAdd2UeLcsWithData(cell, ue, ueDl->ambrSvc);
- RETVOID;
+ return;
}
\f
rgSCHSc1DlUeRmvFrmSchd(cell, ue);
}
}
- RETVOID;
+ return;
}
rgSCHSc1DlSvcAddToUeAmbrLst(cell, ue, svc);
/* Current ambr svc is always the first node of ambrLst.*/
}
}
}
- RETVOID;
+ return;
}
\f
if (svcSc1->bo == svc->bo)
{
- RETVOID;
+ return;
}
svcSc1->bo = svc->bo;
if (!RG_SCH_CMN_DL_IS_UE_ACTIVE(ue))
{
- RETVOID;
+ return;
}
rgSCHSc1DlMngSvcPosn(cell, ue, svc);
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
}
{
rgSCHSc1DlSvcRmvFrmSchd(cell, svc);
}
- RETVOID;
+ return;
}
\f
/* Adjust the SVC priority within the queue */
rgSCHSc1DlSvcRmvFrmSchd(cell, svc);
rgSCHSc1DlSvcAddToSchd(cell, svc);
- RETVOID;
+ return;
}
\f
RgSchSc1DlCell *cellDl = RG_GET_SC1_CELL_DL(cell);
(cellDl->svcMngFunc[svcCmn->prio])(cell, ue, svc);
- RETVOID;
+ return;
}
/*--------------------------*
RgSchSc1DlCell *cellDl;
#endif
{
- U8 i;
+ uint8_t i;
for (i = 0; i < RG_SC1_DL_NUM_Q; ++i)
{
cmLListInit(&cellDl->prioLst[i]);
cmLListInit(&cellDl->retxLst[i]);
}
- RETVOID;
+ return;
}
if (((RgSchSc1DlCell *)((RgSchCmnCell*)((cell)->sc.sch))->dl.schSpfc) \
== NULLP)
{
- RETVOID;
+ return;
}
/* Perform the deinit for the DL scheduler */
rgSCHUtlFreeSBuf(cell->instIdx,
(Data**)(&(((RgSchCmnCell*)((cell)->sc.sch))->dl.schSpfc)),
(sizeof(RgSchSc1DlCell)));
- RETVOID;
+ return;
} /* rgSCHSc1DlCellDel */
/**
{
RgSchSc1DlHqProc *hqSpcSch;
RgSchDlHqProcCb *hqP;
- U8 cnt;
+ uint8_t cnt;
/* making use of hqE->sch for one shot allocation
* of RgSchSc1DlHqProc structures */
if (rgSCHUtlAllocSBuf(cell->instIdx,
RgSchDlHqProcCb *hqP;
Pst pst;
RgInfRlsHqInfo *rlsHqBufs = &(cell->rlsHqArr[cell->crntHqIdx]);
- U8 i;
+ uint8_t i;
/* Prepare TB2 release information to be sent to MAC */
rlsHqBufs->numUes = 0;
{
RgSchSc1DlUe *sc1Ue;
RgSchDlLcCb *svc;
- U32 idx;
+ uint32_t idx;
sc1Ue = RG_GET_SC1_UE_DL(ue, cell);
rgSCHSc1DlSvcRmvFrmSchd(cell, svc);
}
- RETVOID;
+ return;
} /* rgSCHSc1DlRmvUeFrmPrioQs */
/**
RgSchSc1DlCell *cellDl = RG_GET_SC1_CELL_DL(cell);
RgSchDlHqProcCb *hqP;
RgSchCmnDlHqProc *hqProcDl;
- U8 i;
+ uint8_t i;
RgSchDlHqEnt *hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
rgSCHSc1DlRmvUeFrmPrioQs(cell, ue);
- RETVOID;
+ return;
} /* rgSCHSc1DlInactvtUe */
#endif
{
RgSchDlHqProcCb *hqP;
- U8 i;
- U8 j;
+ uint8_t i;
+ uint8_t j;
RgSchDlHqEnt *hqEnt = RG_SCH_CMN_GET_UE_HQE(ue, cell);
}
rgSCHSc1DlRmvUeFrmPrioQs(cell, ue);
- RETVOID;
+ return;
} /* rgSCHSc1DlSuspendUe */
/***********************************************************
#endif
{
- RETVOID;
+ return;
}
/**
if (sc1DlUe == NULLP)
{
- RETVOID;
+ return;
}
if( hqEnt)
{
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx, (Data**)(&sc1DlUe), (sizeof(RgSchSc1DlUe)));
- RETVOID;
+ return;
} /* rgSCHSc1DlUeDel */
/**
CmLList *node;
RgSchDlHqProcCb *proc;
RgSchUeCb *ue;
- U32 effBo;
+ uint32_t effBo;
RgSchCmnDlCell *cellCmnDl = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchCmnDlUe *cmnUeDl;
RgSchSc1DlUe *ueDl;
/* 3.1 MIMO moving this call to cmn scheduler */
/*rgSCHCmnDlRbInfoAddUeTx(allocInfo, ue);*/
}
- RETVOID;
+ return;
}
/**
* till it is activated again. */
rgSCHSc1DlInactvtUe(cell, ue);
}
- RETVOID;
+ return;
}
\f
/**
rgSchDlApis->rgSCHDlTickForPdbTrkng = rgSCHSc1DlScanUpdPdbPrio;
rgSchDlApis->rgSCHDlFillFlwCtrlInfo = rgSCHSc1DlFillFlowCntrlInfo;
- RETVOID;
+ return;
}
RgSchSc1DlCell *cellDl;
#endif
{
- U8 i;
+ uint8_t i;
for (i = 0; i < RG_SC1_DL_NUM_Q; ++i)
{
{
cellDl->svcMngFunc[i] = rgSCHSc1DlMngAmbrSvcPosn;
}
- RETVOID;
+ return;
}
/* reset the UE allocation Information */
rgSCHCmnDlUeResetTemp(ue, hqP);
}
- RETVOID;
+ return;
}
/* 3.1 MIMO Alloc distribution functions being performed
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqTbCb *tbInfo,
-U32 *effAlloc,
+uint32_t *effAlloc,
CmLList **node
)
#else
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqTbCb *tbInfo;
-U32 *effAlloc;
+uint32_t *effAlloc;
CmLList **node;
#endif
{
RgSchDlLcCb *svc;
RgSchSc1DlSvc *svcSc1;
RgSchSc1DlUe *ueDl = RG_GET_SC1_UE_DL(ue, cell);
- U32 bytes;
+ uint32_t bytes;
RgSchLchAllocInfo lchSchdData;
- U32 effBo;
- U32 rlcHdrEstmt;
+ uint32_t effBo;
+ uint32_t rlcHdrEstmt;
while((*node) && (*effAlloc > 0))
lchSchdData.schdData = bytes;
rgSCHDhmAddLcData(cell->instIdx, &lchSchdData, tbInfo);
}
- RETVOID;
+ return;
}
\f
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchDlHqTbCb *tbInfo,
-U32 *effAlloc,
+uint32_t *effAlloc,
CmLList **node
)
#else
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchDlHqTbCb *tbInfo;
-U32 *effAlloc;
+uint32_t *effAlloc;
CmLList **node;
#endif
{
RgSchDlLcCb *svc;
RgSchSc1DlSvc *svcSc1 = NULLP;
RgSchSc1DlUe *ueDl = RG_GET_SC1_UE_DL(ue, cell);
- U32 bytes;
+ uint32_t bytes;
RgSchLchAllocInfo lchSchdData;
CmLList *prev = NULLP;
rgSCHSc1DlSprTxTbDstn(cell, ue, tbInfo, effAlloc,
&ueDl->lcsWithData.first);
*node = NULLP;
- RETVOID;
+ return;
}
/* make sure node points to the svc not completely
* satisfied.
* make sure if not served completely then
* the other TB allocation accomodates the same */
*node = prev;
- RETVOID;
+ return;
}
/*cell added as part of CA dev*/
/* 3.1 MIMO Distribute data of each TB across services */
RgSchDlRbAlloc *dlAllocCb = RG_SCH_CMN_GET_ALLOCCB_FRM_UE(ue, cell);
- U32 remTb1Bytes = dlAllocCb->tbInfo[0].bytesAlloc;
- U32 remTb2Bytes = dlAllocCb->tbInfo[1].bytesAlloc;
- U32 effAlloc = 0;
+ uint32_t remTb1Bytes = dlAllocCb->tbInfo[0].bytesAlloc;
+ uint32_t remTb2Bytes = dlAllocCb->tbInfo[1].bytesAlloc;
+ uint32_t effAlloc = 0;
/*ccpu00120365-ADD-added to code to check if second TB is utilized */
- U32 tb2Bytes = 0;
+ uint32_t tb2Bytes = 0;
rgSCHUtlPdcchPut(cell, &dlAllocCb->dlSf->pdcchInfo,
dlAllocCb->pdcch);
rgSCHSc1RlsHqProc(cmnUeDl->proc);
- RETVOID;
+ return;
}
/* Fill PDCCH and assign it to HqP */
rgSCHCmnFillHqPPdcch(cell, dlAllocCb, cmnUeDl->proc);
- RETVOID;
+ return;
}
\f
cmLListInit(&((RgSchSc1DlUe *)(cmnUeDl->schSpfc))->schdSvcs);
rgSCHCmnDlUeResetTemp(ue, hqP);
}
- RETVOID;
+ return;
}
/* 3.1 Added new function to handle TX+RETX alloc fnlz'n */
RgSchSc1DlUe *sc1DlUe;
RgSchDlHqProcCb *hqP;
RgSchDlHqTbCb *newTxTbInfo;
- U32 effAlloc;
- U32 remTbBytes;
+ uint32_t effAlloc;
+ uint32_t remTbBytes;
RgSchDlRbAlloc *ueAllocInfo;
RgSchDlRbAlloc *dlAllocCb;
/*3.1 MIMO new Function added to handle TX+RETX
* harq process scheduling finalization */
rgSCHSc1DlRetxNewTxAllocFnlz(cell, allocInfo);
- RETVOID;
+ return;
}
Void *dlCqi;
#endif
{
- RETVOID;
+ return;
}
\f
cmLListInsCrnt(lst, &sc1DlSvc->lcWithDataLnk);
sc1DlSvc->lcWithDataLnk.node = (PTR)svc;
}
- RETVOID;
+ return;
}
\f
cmLListDelFrm(&(sc1DlUe->lcsWithData), &sc1DlSvc->lcWithDataLnk);
sc1DlSvc->lcWithDataLnk.node = NULLP;
- RETVOID;
+ return;
}
/***************** SC1 DL SCHEDULER FUNCTION DEFNs END HERE ****************/
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteLcId lcId,
-U8 lcgId
+uint8_t lcgId
)
#else
S16 rgSCHRrUlLchDel(cell, ue, lcId, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteLcId lcId;
-U8 lcgId;
+uint8_t lcgId;
#endif
{
return (ROK);
rgSchUlApis->rgSCHUlActvtUe = rgSCHSc1UlActvtUe;
rgSchUlApis->rgSCHUlUeReset = rgSCHSc1UlUeReset;
rgSchUlApis->rgSCHRgrUlLcgUpd = rgSCHSc1UlLcgUpd;
- RETVOID;
+ return;
}
/**
if (ueUl == NULLP)
{
- RETVOID;
+ return;
}
if(ueUl->txLnk.node)
{
rgSCHUtlFreeSBuf(cell->instIdx,
(Data**)(&(ueUl)), (sizeof(RgSchSc1UlUe)));
- RETVOID;
+ return;
} /* rgSCHSc1UlUeDel */
/**
cmLListDelFrm(&(cellUl->contResLst), &(ueUl->contResLnk));
ueUl->contResLnk.node = NULLP;
}
- RETVOID;
+ return;
} /* rgSCHSc1UlUeReset */
\f
if (cellUl == NULLP)
{
- RETVOID;
+ return;
}
/* ccpu00117052 - MOD - Passing double pointer
for proper NULLP assignment*/
rgSCHUtlFreeSBuf(cell->instIdx,
(Data**)(&(cellUl)), (sizeof(RgSchSc1UlCell)));
- RETVOID;
+ return;
} /* rgSCHSc1UlCellDel */
/**
#endif
{
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
}
/**
{
cmnUlUe->alloc.reqBytes = RGSCH_MAX(RG_SCH_CMN_UL_SR_BYTES, \
ue->ul.effBsr);
- RETVOID;
+ return;
}
cmnUlUe->alloc.reqBytes = ue->ul.effBsr;
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[out] RgSchCmnUlRbAllocInfo *allocInfo
- * @param[in] U8 remUe
+ * @param[in] uint8_t remUe
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo,
-U8 remUe
+uint8_t remUe
)
#else
PRIVATE Void rgSCHSc1UlSchdForDataTrans(cell, allocInfo, remUe)
RgSchCellCb *cell;
RgSchCmnUlRbAllocInfo *allocInfo;
-U8 remUe;
+uint8_t remUe;
#endif
{
RgSchSc1UlCell *sc1UlCell = RG_GET_SC1_CELL_UL(cell);
if (remUe == 0)
{
- RETVOID;
+ return;
}
/* Allocate UEs with LCG0 data pending */
rgSCHSc1UlSchdUeTxLst(cell, &sc1UlCell->ueTxLst[0], allocInfo, &remUe);
if (remUe == 0)
{
- RETVOID;
+ return;
}
/* Allocate UEs with other LCGs data pending */
rgSCHSc1UlSchdUeTxLst(cell, &sc1UlCell->ueTxLst[1], allocInfo, &remUe);
- RETVOID;
+ return;
}
/**
*
* @param[in] CmLListCp *ueTxLst
* @param[out] RgSchCmnUlRbAllocInfo *allocInfo
- * @param[in] U8 *remUe
+ * @param[in] uint8_t *remUe
* @return Void
**/
#ifdef ANSI
RgSchCellCb *cell,
CmLListCp *ueTxLst,
RgSchCmnUlRbAllocInfo *allocInfo,
-U8 *remUe
+uint8_t *remUe
)
#else
PRIVATE Void rgSCHSc1UlSchdUeTxLst(cell, ueTxLst, allocInfo, remUe)
RgSchCellCb *cell;
CmLListCp *ueTxLst;
RgSchCmnUlRbAllocInfo *allocInfo;
-U8 *remUe;
+uint8_t *remUe;
#endif
{
RgSchUeCb *ue;
--(*remUe);
}
- RETVOID;
+ return;
}
/**
*
* @param[in] RgSchCellCb *cell
* @param[out] RgSchCmnUlRbAllocInfo *allocInfo
- * @param[out] U8 *remUe
+ * @param[out] uint8_t *remUe
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchCmnUlRbAllocInfo *allocInfo,
-U8 *remUe
+uint8_t *remUe
)
#else
PRIVATE Void rgSCHSc1UlSchdForContRes(cell, allocInfo, remUe)
RgSchCellCb *cell;
RgSchCmnUlRbAllocInfo *allocInfo;
-U8 *remUe;
+uint8_t *remUe;
#endif
{
RgSchSc1UlCell *sc1UlCell = RG_GET_SC1_CELL_UL(cell);
/* Node removal deferred to ULAllocFinalization */
}
- RETVOID;
+ return;
}
/**
#endif
{
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
- U8 remUe = cellUl->maxUeNewTxPerTti;
+ uint8_t remUe = cellUl->maxUeNewTxPerTti;
rgSCHSc1UlSchdForContRes(cell, allocInfo, &remUe);
rgSCHSc1UlSchdForDataTrans(cell, allocInfo, remUe);
- RETVOID;
+ return;
}
/**
#endif
{
rgSCHSc1UlNewTx(cell, allocInfo);
- RETVOID;
+ return;
}
/**
ueUl->txLnk.node = (PTR)ue;
}
- RETVOID;
+ return;
}
/**
* @brief UEs Buffer Status Has changed so reposition it.
if (!RG_SCH_CMN_UL_IS_UE_ACTIVE(ue))
{
- RETVOID;
+ return;
}
/* Remove the UE from its existing position */
}
#endif
- RETVOID;
+ return;
}
/**
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
* @param[in] RgSchLcgCb *lcg
- * @param[in] U8 bsr
+ * @param[in] uint8_t bsr
* @return Void
**/
#ifdef ANSI
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *lcg,
-U8 bsr
+uint8_t bsr
)
#else
Void rgSCHSc1UpdBsrShort(cell, ue, lcg, bsr)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
-U8 bsr;
+uint8_t bsr;
#endif
{
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
} /* rgSCHSc1UpdBsrShort */
/**
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
* @param[in] RgSchLcgCb *lcg
- * @param[in] U8 bsr
+ * @param[in] uint8_t bsr
* @return Void
**/
#ifdef ANSI
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *lcg,
-U8 bsr
+uint8_t bsr
)
#else
Void rgSCHSc1UpdBsrTrunc(cell, ue, lcg, bsr)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgSchLcgCb *lcg;
-U8 bsr;
+uint8_t bsr;
#endif
{
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
} /* rgSCHSc1UpdBsrTrunc */
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 bsArr[]
+ * @param[in] uint8_t bsArr[]
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 *bsArr
+uint8_t *bsArr
)
#else
Void rgSCHSc1UpdBsrLong(cell, ue, bsArr)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 *bsArr;
+uint8_t *bsArr;
#endif
{
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
} /* rgSCHSc1UpdBsrLong */
/**
if (ueUl->contResLnk.node)
{
- RETVOID;
+ return;
}
/* Remove the UE from other Qs */
cmLListAdd2Tail(&cellUl->contResLst, &ueUl->contResLnk);
ueUl->contResLnk.node = (PTR)ue;
- RETVOID;
+ return;
} /* rgSCHSc1ContResUlGrant */
/**
if (ulUe->qId == 0)
{
/* Already present in lcg0 Q */
- RETVOID;
+ return;
}
cmLListDelFrm(&(ulCell->ueTxLst[ulUe->qId]), &(ulUe->txLnk));
}
ulUe->txLnk.node = (PTR)ue;
ulUe->qId = 0;
- RETVOID;
+ return;
} /* rgSCHSc1SrRcvd */
/**
{
/* Stack Crash problem for TRACE5 changes. Added the return below */
- RETVOID;
+ return;
}
#endif
{
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
}
/**
rgSCHCmnUlUeResetTemp(cell, ue);
}
- RETVOID;
+ return;
}
/**
rgSCHCmnUlUeResetTemp(cell, ue);
}
- RETVOID;
+ return;
}
/**
rgSCHSc1UlContResAllocFnlz(cell, allocInfo);
rgSCHSc1UlDatTransAllocFnlz(cell, allocInfo);
- RETVOID;
+ return;
}
\f
{
rgSCHSc1UlPosnUeInQ(cell, ue);
- RETVOID;
+ return;
}
/**
}
/* Do not remove UE from contResLst */
}
- RETVOID;
+ return;
}
/**
* @brief Scheduler invocation
Release HqP.*/
rgSCHSc1DlProcRmvFrmCellRetx(cell, hqP);
rgSCHSc1DlProcRmvFrmUeRetx(cell, ue, hqP);
- RETVOID;
+ return;
}
CmLList txLnk; /* Lnk to one of Transmission Queues */
CmLList contResLnk; /* Lnk to one of Cont Res Queue */
Bool srRcvd; /* TRUE if SR reported is yet to be satisfied */
- U8 qId; /* Id of the Tx Q to which this UE belongs */
+ uint8_t qId; /* Id of the Tx Q to which this UE belongs */
} RgSchSc1UlUe;
/**
{
CmLList prioLnk; /*!< To link UE into priority queues */
CmLListCp gbrSvcs; /*!< List of GBR services */
- U8 prio; /*!< Current priority of UE for DL */
+ uint8_t prio; /*!< Current priority of UE for DL */
CmLListCp ambrLst; /*!< To maintain services per priority for a UE */
RgSchDlLcCb *ambrSvc;/*!< Points to the current AMBR service */
- U32 ambr; /*!< UE's Remaining AMBR */
- U32 effAmbr; /*!< min(svc->bo, ambr)*/
+ uint32_t ambr; /*!< UE's Remaining AMBR */
+ uint32_t effAmbr; /*!< min(svc->bo, ambr)*/
CmLListCp schdSvcs; /*!< List of services for which
allocation requested */
- U8 taReqBytes;/*!< Set to the Number of bytes Requested for TA
+ uint8_t taReqBytes;/*!< Set to the Number of bytes Requested for TA
allocation */
CmLListCp retxHqProcs; /*!< List of RETX Hq Procs in suspension */
CmLListCp lcsWithData; /*!< List of services with non-zero effBo */
*/
typedef struct rgSc1DlHqProc {
CmLList retxLnkUe; /*!< To link retransmitting HARQ processes in ue */
- U8 cqi; /*!< CQI at which the allocation was made */
- U8 prio; /*!< Priority of the allocation */
+ uint8_t cqi; /*!< CQI at which the allocation was made */
+ uint8_t prio; /*!< Priority of the allocation */
}RgSchSc1DlHqProc;
/**
* Downlink service information for SC1 scheduler per UE.
*/
typedef struct rgSc1DlSvc {
- U32 gbr; /*!< Pending GBR to be satisfied */
- U32 mbr; /*!< Pending MBR to be satisfied */
- U32 bo; /*!< BO yet to be satisfied */
- U32 effGbr; /*!< GBR/BO, lower of the two */
- U32 effMbr; /*!< MBR/BO, lower of the two */
+ uint32_t gbr; /*!< Pending GBR to be satisfied */
+ uint32_t mbr; /*!< Pending MBR to be satisfied */
+ uint32_t bo; /*!< BO yet to be satisfied */
+ uint32_t effGbr; /*!< GBR/BO, lower of the two */
+ uint32_t effMbr; /*!< MBR/BO, lower of the two */
CmLList gbrLnk; /*!< used to maintain svcs to be refreshed */
CmLList prioLnk; /*!< Used to queue up services on UE */
CmLList schdSvcLnk; /*!< Used to queue up services on UE
* scheduled svcs list */
- U32 reqBytes; /*!< Set to number of bytes Req for Allocation */
- U16 hdrEstimate; /*!< RLC Hdr est computed during SVC allocn */
+ uint32_t reqBytes; /*!< Set to number of bytes Req for Allocation */
+ uint16_t hdrEstimate; /*!< RLC Hdr est computed during SVC allocn */
CmLList lcWithDataLnk;/*!< Used to maintain svc in ue's
* lcsWithData List */
} RgSchSc1DlSvc;
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *lcg,
-U8 bsr
+uint8_t bsr
));
EXTERN Void rgSCHSc1UpdBsrTrunc ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
RgSchLcgCb *lcg,
-U8 bsr
+uint8_t bsr
));
EXTERN Void rgSCHSc1UpdBsrLong ARGS((
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 bsArr[]
+uint8_t bsArr[]
));
EXTERN Void rgSCHSc1ContResUlGrant ARGS((
RgSchCellCb *cell,
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteLcId lcId,
-U8 lcgId
+uint8_t lcgId
));
#ifdef __cplusplus
}
Void rgSCHSCellHndlFdbkInd ARGS((
RgSchDlHqProcCb *hqP,
-U8 tbIdx,
-U8 fdbk,
+uint8_t tbIdx,
+uint8_t fdbk,
Bool maxHqRetxReached
));
Void rgSCHSCellDelUeSCell ARGS((
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
-U8 sCellIdx
+uint8_t sCellIdx
));
S16 rgSCHSCellDelUe ARGS((
RgSchUeCb *ueCb,
RgrUePrdDlCqiCfg *cqiCfg,
CmLteUeCategory ueCat,
-U8 sCellIdx
+uint8_t sCellIdx
));
#endif
PRIVATE S16 rgSCHSCellTrgMacHqEReset ARGS((
Inst inst,
-U16 secCellId,
-U16 rnti
+uint16_t secCellId,
+uint16_t rnti
));
#endif
{
- U8 bitVal = 0;
- U8 sCellActDeactBitMask = 0;
+ uint8_t bitVal = 0;
+ uint8_t sCellActDeactBitMask = 0;
/* Change the state of all Scells waiting for
* activation */
* 0 for deactivation
* */
- for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
+ for(uint8_t idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
if(ueCb->cellInfo[idx] != NULLP)
{
tbInfo->schdSCellActCe.pres = PRSNT_NODEF;
tbInfo->schdSCellActCe.val = sCellActDeactBitMask;
- RETVOID;
+ return;
} /* rgSCHSCellSchdActDeactCe */
\f
"SCell is already added in the Act List: ueId(%u)\n", ue->ueId));
}
- RETVOID;
+ return;
}
\f
}
ue->sCellActLnk.node = (PTR)NULLP;
- RETVOID;
+ return;
}
\f
/**
#ifdef DEBUGP
Inst inst = ueCb->cell->instIdx;
#endif
- U16 tempIdx;
+ uint16_t tempIdx;
RgrUePrdDlCqiCfg *cqiCfg;
- U8 j; /*Bandwidth Parts*/
- U16 riTrInsTime;
- U16 periodicity;
- U16 cqiTrInstTime;
+ uint8_t j; /*Bandwidth Parts*/
+ uint16_t riTrInsTime;
+ uint16_t periodicity;
+ uint16_t cqiTrInstTime;
RgSchUePCqiCb *cqiCb = NULLP;
CmLteTimingInfo timingInfo;
- U16 crntTime;
+ uint16_t crntTime;
#endif
% RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
if(periodicity >= RG_SCH_PCQI_SRS_SR_TRINS_SIZE)
{
- cqiCb->riDist = rgSCHUtlFindDist((U16)(crntTime + TFU_RECPREQ_DLDELTA),
- (U16) tempIdx);
+ cqiCb->riDist = rgSCHUtlFindDist((uint16_t)(crntTime + TFU_RECPREQ_DLDELTA),
+ (uint16_t) tempIdx);
}
else
{
cellSch = RG_SCH_CMN_GET_CELL(sCellInfo->cell);
cellSch->apisDl->rgSCHDlSCellActv(sCellInfo->cell, sCellInfo->ue);
- RETVOID;
+ return;
}
#ifdef TFU_UPGRADE
}
}
- RETVOID;
+ return;
}
#endif/*TFU_UPGRADE*/
\f
*
* Invoked by: CommonScheduler
*
- * @param[in] U16 sCellId
- * @param[in] U16 rnti
+ * @param[in] uint16_t sCellId
+ * @param[in] uint16_t rnti
* @return Void
*
**/
PRIVATE S16 rgSCHSCellTrgMacHqEReset
(
Inst inst,
-U16 secCellId,
-U16 rnti
+uint16_t secCellId,
+uint16_t rnti
)
#else
PRIVATE S16 rgSCHSCellTrgMacHqEReset(inst,secCellId,rnti)
Inst inst;
-U16 secCellId;
-U16 rnti;
+uint16_t secCellId;
+uint16_t rnti;
#endif
{
Pst pst;
Void rgSCHSCellHndlFdbkInd
(
RgSchDlHqProcCb *hqP,
-U8 tbIdx,
-U8 fdbk,
+uint8_t tbIdx,
+uint8_t fdbk,
Bool maxHqRetxReached
)
#else
Void rgSCHSCellHndlFdbkInd(hqP, tbIdx, fdbk,maxHqRetxReached)
RgSchDlHqProcCb *hqP;
-U8 tbIdx;
-U8 fdbk;
+uint8_t tbIdx;
+uint8_t fdbk;
Bool maxHqRetxReached;
#endif
{
{
hqP->tbInfo[tbIdx].schdSCellActCe.pres = FALSE;
- for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
+ for(uint8_t idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
if(ueCb->cellInfo[idx] != NULLP)
{
if(TRUE == maxHqRetxReached)
{
hqP->tbInfo[tbIdx].schdSCellActCe.pres = FALSE;
- for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
+ for(uint8_t idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
if(ueCb->cellInfo[idx] != NULLP)
{
default:
break;
}
- RETVOID;
+ return;
}
#ifdef LTE_ADV
/* Deactivation Timer is configured, thus assume that UE has deactivated */
rgSCHSCellDeActivation(sCellInfo);
}
- RETVOID;
+ return;
}
#endif
\f
*
* @param[in] RgSchCellCb *cellCb
* @param[in] RgSchUeCb *ueCb
- * @param[in] U8 sCellIdx
- * @param[in] U8 action
+ * @param[in] uint8_t sCellIdx
+ * @param[in] uint8_t action
*
* @return ROK/RFAILED
*
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
-U8 sCellIdx,
-U8 action
+uint8_t sCellIdx,
+uint8_t action
)
#else
S16 rgSCHSCellTrigActDeact(cell,ueCb,sCellIdx,action)
RgSchCellCb *cell,
RgSchUeCb *ueCb;
-U8 sCellIdx;
-U8 action;
+uint8_t sCellIdx;
+uint8_t action;
#endif
{
Inst inst = cell->instIdx;
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
-U8 *sCellIdx
+uint8_t *sCellIdx
)
#else
PRIVATE S16 rgSCHSCellSelectForAct(cell, ueCb)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
-U8 *sCellIdx;
+uint8_t *sCellIdx;
#endif
{
*
* @param[in] RgSchCellCb *cellCb
* @param[in] RgSchUeCb *ueCb
- * @param[in] U8 action
+ * @param[in] uint8_t action
*
* @return Void
*
(
RgSchCellCb *pCell,
RgSchUeCb *ueCb,
-U8 action
+uint8_t action
)
#else
Void rgSCHSCellSelectAndActDeAct(pCell, ueCb, action)
RgSchCellCb *pCell;
RgSchUeCb *ueCb;
-U8 action;
+uint8_t action;
#endif
{
- U8 sCellIdx = 0;
+ uint8_t sCellIdx = 0;
S16 ret = ROK;
switch (action)
if(((ret = rgSCHSCellSelectForAct(pCell, ueCb, &sCellIdx)) == ROK)
&& (sCellIdx == 0))
- RETVOID;
+ return;
break;
}
default:
- RETVOID;
+ return;
}
if ((ret != ROK) ||
(ROK != (rgSCHSCellTrigActDeact(pCell, ueCb, sCellIdx, action))))
RGSCHDBGERR(pCell->instIdx,(rgSchPBuf(pCell->instIdx), "SCell Actication failed"
"for UE [%d] with SCellIdx [%d]\n", ueCb->ueId, sCellIdx));
}
- RETVOID;
+ return;
}
\f
*
* @param[in] RgSchCellCb *cellCb
* @param[in] RgSchUeCb *ueCb
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @return ROK/RFAILED
*
**/
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
-U8 sCellIdx
+uint8_t sCellIdx
)
#else
Void rgSCHSCellDelUeSCell(cellCb,ueCb,sCellIdx)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
-U8 sCellIdx;
+uint8_t sCellIdx;
#endif
{
RgUeUlHqCb *ulHqEnt;
RGSCHDBGERRNEW(inst, (rgSchPBuf(inst),"Serv Cell not added to this Ue Scell Idx %d\
ueId %d\n",
sCellIdx,ueCb->ueId));
- RETVOID;
+ return;
}
rgSCHDbmDelUeCb(sCellInfo->cell, ueCb);
ueCb->cellInfo[sCellIdx] = NULLP;
- RETVOID;
+ return;
}
\f
/**
#endif
{
- for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
+
+ for(uint8_t idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
rgSCHSCellDelUeSCell(cellCb,ueCb,idx);
}
RgSchUeCb *ueCb,
RgrUePrdDlCqiCfg *cqiCfg,
CmLteUeCategory ueCat,
-U8 sCellIdx
+uint8_t sCellIdx
)
#else
S16 rgSCHSCellPCqiCfg(priCellCb,secCellCb,ueCb,cqiCfg,ueCat,sCellIdx)
RgSchUeCb *ueCb;
RgrUePrdDlCqiCfg *cqiCfg;
CmLteUeCategory ueCat;
-U8 sCellIdx;
+uint8_t sCellIdx;
#endif
{
- U8 j; /*Bandwidth Parts*/
- U8 temp;
+ uint8_t j; /*Bandwidth Parts*/
+ uint8_t temp;
#ifdef DEBUGP
Inst inst = priCellCb->instIdx;
#endif
if(RGR_UE_PCQI_SB_REP == cqiCfg->cqiSetup.cqiRepType)
{
- U8 k; /*SubBand Size (RB) */
+ uint8_t k; /*SubBand Size (RB) */
RG_SCH_GET_CQI_J_VAL(secCellCb->bwCfg.dlTotalBw, j);
RG_SCH_GET_CQI_K_VAL(secCellCb->bwCfg.dlTotalBw, k);
cqiCb->J = j; /*Number of Bandwidth Parts*/
{
RgSchCmnCell *cellSch;
- for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
+ for(uint8_t idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
if(ue->cellInfo[idx] != NULLP)
{
ue->cellInfo[idx]->sCellState = RG_SCH_SCELL_INACTIVE;
}
}
- RETVOID;
+ return;
}
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
+ for(uint8_t idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
if(ue->cellInfo[idx] != NULLP)
{
cellSch->apisDl->rgSCHRgrDlLcCfg(ue->cellInfo[idx]->cell, ue, svc,NULLP,NULLP);
}
}
- RETVOID;
+ return;
}
/**
#endif
{
RgSchCmnCell *cellSch = RG_SCH_CMN_GET_CELL(cell);
- for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
+ for(uint8_t idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
if(ue->cellInfo[idx] != NULLP)
{
cellSch->apisDl->rgSCHFreeDlLc(ue->cellInfo[idx]->cell, ue, svc);
}
}
- RETVOID;
+ return;
}
/**
{
cellSch->apisDl->rgSCHDlDedBoUpd(ue->cell, ue, svc);
}
- for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
+ for(uint8_t idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
if((ue->cellInfo[idx] != NULLP) &&
(ue->cellInfo[idx]->sCellState == RG_SCH_SCELL_ACTIVE) &&
cellSch->apisDl->rgSCHDlDedBoUpd(ue->cellInfo[idx]->cell, ue, svc);
}
}
- RETVOID;
+ return;
}
#ifdef TFU_UPGRADE
/**
*
* @param[in] RgSchUePCqiCb *cqiCb1
* @param[in] RgSchUePCqiCb *cqiCb2
- * @return U8 cqiCb cell idx which has the higher priority
+ * @return uint8_t cqiCb cell idx which has the higher priority
*
**/
#ifdef ANSI
-PRIVATE U8 rgSCHUtlSCellCmpCqiCfg
+PRIVATE uint8_t rgSCHUtlSCellCmpCqiCfg
(
RgSchUePCqiCb *cqiCb1,
RgSchUePCqiCb *cqiCb2
)
#else
-PRIVATE U8 rgSCHUtlSCellCmpCqiCfg(cqiCb1, cqiCb2)
+PRIVATE uint8_t rgSCHUtlSCellCmpCqiCfg(cqiCb1, cqiCb2)
RgSchUePCqiCb *cqiCb1;
RgSchUePCqiCb *cqiCb2;
#endif
RgSchUePCqiCb *cqiCb;
#endif
{
- U32 nPCqiServCellIdx;
- U32 minPCqiTrIdx;
- U32 scellPCqiTrIdx;
- U32 pCqiTrIdx;
+ uint32_t nPCqiServCellIdx;
+ uint32_t minPCqiTrIdx;
+ uint32_t scellPCqiTrIdx;
+ uint32_t pCqiTrIdx;
RgSchCellCb *priCellCb = cqiCb->servCellInfo->ue->cell;
RgSchUeCb *ueCb = cqiCb->servCellInfo->ue;
- U16 crntSfIdx;
- U32 cellIdx;
- U32 sCellCnt = 0;
+ uint16_t crntSfIdx;
+ uint32_t cellIdx;
+ uint32_t sCellCnt = 0;
CmLteTimingInfo timingInfo;
- U8 idx = 0;
+ uint8_t idx = 0;
#ifdef xLTE_TDD
RG_SCH_ADD_TO_CRNT_TIME(priCellCb->crntTime, timingInfo, TFU_DELTA);
RgSchUePCqiCb *cqiCb;
#endif
{
- U32 nPRiServCellIdx;
- U32 minPRiTrIdx;
- U32 scellPRiTrIdx;
- U32 pRiTrIdx;
+ uint32_t nPRiServCellIdx;
+ uint32_t minPRiTrIdx;
+ uint32_t scellPRiTrIdx;
+ uint32_t pRiTrIdx;
RgSchCellCb *priCellCb = cqiCb->servCellInfo->ue->cell;
RgSchUeCb *ueCb = cqiCb->servCellInfo->ue;
- U16 crntSfIdx;
- U32 cellIdx;
- U32 sCellCnt = 0;
+ uint16_t crntSfIdx;
+ uint32_t cellIdx;
+ uint32_t sCellCnt = 0;
CmLteTimingInfo timingInfo;
#ifdef xLTE_TDD
{
S16 retVal = RFAILED;
- for(U8 idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
+ for(uint8_t idx = 1; idx <= RG_SCH_MAX_SCELL ; idx++)
{
if((ue->cellInfo[idx] != NULLP) &&
(ue->cellInfo[idx]->cell->cellId == cell->cellId)&&
* @param[in] RgSchCellCb *cell
* @param[in] Ptr cb
* @param[in] S16 tmrEvnt
- * @param[in] U32 tmrVal
+ * @param[in] uint32_t tmrVal
* @return Void
*/
#ifdef ANSI
RgSchCellCb *cell,
Ptr cb,
S16 tmrEvnt,
-U32 tmrVal
+uint32_t tmrVal
)
#else
Void rgSCHTmrStartTmr (cell, cb, tmrEvnt, tmrVal)
RgSchCellCb *cell;
Ptr cb;
S16 tmrEvnt;
-U32 tmrVal;
+uint32_t tmrVal;
#endif
{
CmTmrArg arg;
case RG_SCH_TMR_BSR:
{
#ifdef NO_BSR_SR_5GTF
- RETVOID;
+ return;
#endif
arg.timers = &(ue->bsrTmr);
break;
default:
RLOG_ARG0(L_ERROR,DBG_INSTID,cell->instIdx,
"rgSCHTmrStartTmr() Incorrect Timer event");
- RETVOID;
+ return;
}
arg.tqCp = &(cell->tqCp);
arg.max = 1;
arg.tNum = NOTUSED;
cmPlcCbTq(&arg);
- RETVOID;
+ return;
} /* end of */
case RG_SCH_TMR_BSR:
{
#ifdef NO_BSR_SR_5GTF
- RETVOID;
+ return;
#endif
arg.timers = &(ue->bsrTmr);
break;
default:
RLOG_ARG0(L_ERROR,DBG_INSTID,cell->instIdx,
"rgSCHTmrStopTmr() Incorrect Timer event");
- RETVOID;
+ return;
}
arg.tqCp = &(cell->tqCp);
arg.max = 0;
arg.tNum = NOTUSED;
cmRmvCbTq(&arg);
- RETVOID;
+ return;
} /* end of */
/** @brief This function handles timer expiry.
break;
case RG_SCH_TMR_UL_MEASGAP:
case RG_SCH_TMR_UL_ACKNACK:
- rgSCHMeasGapANRepUlInactvTmrExpry (ue, (U8)tmrEvnt);
+ rgSCHMeasGapANRepUlInactvTmrExpry (ue, (uint8_t)tmrEvnt);
break;
case RG_SCH_TMR_DL_ACKNACK:
case RG_SCH_TMR_DL_MEASGAP:
- rgSCHMeasGapANRepDlInactvTmrExpry (ue, (U8)tmrEvnt);
+ rgSCHMeasGapANRepDlInactvTmrExpry (ue, (uint8_t)tmrEvnt);
break;
case RG_SCH_TMR_TA:
#ifdef EMTC_ENABLE
RLOG_ARG0(L_ERROR,DBG_INSTID,ue->cell->instIdx,
"rgSCHTmrProcTmr() Incorrect Timer event");
}
- RETVOID;
+ return;
}
- RETVOID;
+ return;
} /* end of */
\f
#ifdef EMTC_ENABLE
#include "rg_sch_emtc_ext.x"
#endif
-U8 rgSCHCmnCalcPcqiBitSz(RgSchUeCb *ueCb,U8 numTxAnt);
+uint8_t rgSCHCmnCalcPcqiBitSz(RgSchUeCb *ueCb,uint8_t numTxAnt);
S16 rgSCHDhm5gtfHqFdbkInd(RgSchUeCb *ue,RgSchCellCb *cell,CmLteTimingInfo timingInfo,TfuHqFdbk fdbk,RgSchErrInfo *err);
/* local defines */
#ifdef EMTC_ENABLE
EXTERN Bool rgSCHEmtcChkEmtcUe ARGS(
(
RgSchCellCb *cell,
-U16 rapId
+uint16_t rapId
));
EXTERN Void rgSchTomTtiEmtcSched ARGS(
(
EXTERN S16 rgSCHEmtcRamVldtProcRaReq
(
-U8 raRntiCnt,
-U8 raReqCnt,
+uint8_t raRntiCnt,
+uint8_t raReqCnt,
RgSchCellCb *cell,
TfuRaReqIndInfo *raReqInd,
RgSchUeCb *ue,
(
RgSchUeCb *ue,
RgSchUePCqiCb *cqiCb,
-U16 *cqiIdx
+uint16_t *cqiIdx
);
EXTERN Void rgSCHEmtcUpdSRInfo
(
RgSchUeCb *ue,
-U16 *srIdx
+uint16_t *srIdx
);
EXTERN Void rgSCHCmnEmtcHdlCrcFailInd
(
(
RgSchCellCb *cell,
RgSchDlHqProcCb *hqCb,
-U16 *hqRes
+uint16_t *hqRes
);
EXTERN Bool rgSCHEmtcAddRecpInfoToLst
(
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchErrInfo *err
);
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchErrInfo *err
);
);
#endif
-EXTERN U32 gDlMpdcchBlank;
-EXTERN U32 gUlMpdcchBlank;
+EXTERN uint32_t gDlMpdcchBlank;
+EXTERN uint32_t gUlMpdcchBlank;
EXTERN S16 rgSCHUtlIotResPrcTti
(
RgSchCellCb *cell
EXTERN RgSchUeCb* rgSCHCmnGetHoUe
(
RgSchCellCb *cell,
-U16 rapId
+uint16_t rapId
);
EXTERN RgSchUeCb* rgSCHCmnGetPoUe
(
RgSchCellCb *cell,
-U16 rapId,
+uint16_t rapId,
CmLteTimingInfo timingInfo
);
S16 rgSCHTomUtlFillDatAperRecpReq ARGS(
(
RgSchCellCb *cell,
- U8 cqiReq,
+ uint8_t cqiReq,
RgSchUlAlloc *alloc,
TfuUeRecpReqInfo *datRecpInfo,
CmLteTimingInfo *timeInfo,
Bool hqPres,
- U16 validIdx
+ uint16_t validIdx
));
S16 rgSCHTomUtlFillDatPriRecpReq ARGS(
TfuUeRecpReqInfo *datRecpInfo,
CmLteTimingInfo *timeInfo,
Bool hqPres,
- U16 validIdx
+ uint16_t validIdx
));
S16 rgSCHTomUtlFillDatPCqiRecpReq ARGS(
TfuUeRecpReqInfo *datRecpInfo,
CmLteTimingInfo *timeInfo,
Bool hqPres,
- U16 validIdx
+ uint16_t validIdx
));
S16 rgSCHTomUtlFillDatSrsRecpReq ARGS(
Inst schInst);
#ifdef CA_DBG
-EXTERN U32 delayedApiCnt;
-U32 gPCellTb1AckCount=0,gPCellTb2AckCount=0,gPCellTb1NackCount=0,gPCellTb2NackCount=0;
-U32 gSCellSchedCount=0,gPrimarySchedCount=0;
-U32 gSCellTb1AckCount=0,gSCellTb2AckCount=0,gSCellTb1NackCount=0,gSCellTb2NackCount=0;
-U32 gPCellTb1DtxCount = 0, gPCellTb2DtxCount = 0, gSCellTb1DtxCount = 0, gSCellTb2DtxCount = 0;
-U32 gHqFdbkCount = 0;
+EXTERN uint32_t delayedApiCnt;
+uint32_t gPCellTb1AckCount=0,gPCellTb2AckCount=0,gPCellTb1NackCount=0,gPCellTb2NackCount=0;
+uint32_t gSCellSchedCount=0,gPrimarySchedCount=0;
+uint32_t gSCellTb1AckCount=0,gSCellTb2AckCount=0,gSCellTb1NackCount=0,gSCellTb2NackCount=0;
+uint32_t gPCellTb1DtxCount = 0, gPCellTb2DtxCount = 0, gSCellTb1DtxCount = 0, gSCellTb2DtxCount = 0;
+uint32_t gHqFdbkCount = 0;
-U32 gCqiRecpCount = 0;
-U32 gCqiRecpPuschCount = 0;
-U32 gCqiRcvdCount = 0;
+uint32_t gCqiRecpCount = 0;
+uint32_t gCqiRecpPuschCount = 0;
+uint32_t gCqiRcvdCount = 0;
Bool gF1bCsPres = FALSE;
-U32 gRiReqCount = 0;
-U32 gCqiReqCount = 0;
-U32 gF1bCsCount = 0;
-U32 gACqiRcvdCount = 0;
-U32 gCqiReptToAppCount = 0;
-U32 gRawACqiCount= 0;
-U32 gCqiDropCount,gPucchDropCount;
-U32 gCqiPucchLowSnrDropCount,gCqiPucchConfMaskDropCount,gCqiPuschConfMaskDropCount;
-U32 gDci0Count = 0;
-U32 gUlCrcFailCount = 0;
-U32 gUlCrcPassCount = 0;
-U32 gPuschCqiDropCount = 0;
-U32 gCaDbgCaFrmt = 0;
-U32 gCaDbgNonCaFrmt = 0;
-U32 gPcellZeroBoOcc=0,gScellZeroBoOcc=0, dbgDelayedDatReqInMac=0,gDropDatReqCnt=0, gIccPktRcvrMemDropCnt=0;
+uint32_t gRiReqCount = 0;
+uint32_t gCqiReqCount = 0;
+uint32_t gF1bCsCount = 0;
+uint32_t gACqiRcvdCount = 0;
+uint32_t gCqiReptToAppCount = 0;
+uint32_t gRawACqiCount= 0;
+uint32_t gCqiDropCount,gPucchDropCount;
+uint32_t gCqiPucchLowSnrDropCount,gCqiPucchConfMaskDropCount,gCqiPuschConfMaskDropCount;
+uint32_t gDci0Count = 0;
+uint32_t gUlCrcFailCount = 0;
+uint32_t gUlCrcPassCount = 0;
+uint32_t gPuschCqiDropCount = 0;
+uint32_t gCaDbgCaFrmt = 0;
+uint32_t gCaDbgNonCaFrmt = 0;
+uint32_t gPcellZeroBoOcc=0,gScellZeroBoOcc=0, dbgDelayedDatReqInMac=0,gDropDatReqCnt=0, gIccPktRcvrMemDropCnt=0;
#endif
#ifdef EMTC_ENABLE
-U32 gUlCrcFailCounter = 0;
-U32 gUlCrcPassCounter = 0;
+uint32_t gUlCrcFailCounter = 0;
+uint32_t gUlCrcPassCounter = 0;
#endif
#ifdef RG_5GTF
-EXTERN U32 gUl5gtfPdcchSend;
+EXTERN uint32_t gUl5gtfPdcchSend;
#endif
#ifdef UNUSED_FUNC
RgSchUeCb *ue,
TfuRecpReqInfo *recpReqInfo,
TfuUeRecpReqInfo *pucchRecpInfo,
-U16 validIdx
+uint16_t validIdx
));
PRIVATE Bool rgSCHTomUtlFillDatHarqRecpReq ARGS
((
PRIVATE S16 rgSCHTomUtlFillSrRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
-U16 validIdx,
+uint16_t validIdx,
RgSchErrInfo *err));
PRIVATE S16 rgSCHTomUtlFillRiRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
-U16 validIdx,
+uint16_t validIdx,
RgSchErrInfo *err));
PRIVATE S16 rgSCHTomUtlFillPcqiRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
-U16 validIdx,
+uint16_t validIdx,
RgSchErrInfo *err));
PRIVATE S16 rgSCHTomUtlFillSrsRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
-U16 validIdx,
+uint16_t validIdx,
RgSchErrInfo *err));
PRIVATE S16 rgSCHTomUtlGenIndices ARGS((
-U32 label,
-U8 posM,
-U8 valN,
-U8 valK,
+uint32_t label,
+uint8_t posM,
+uint8_t valN,
+uint8_t valK,
TfuSubbandInfo* sbInfo));
#endif
PRIVATE S16 rgSCHTomUtlFillCqiRiRecpReq ARGS(
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchErrInfo *err
));
PRIVATE Void rgSchTomFillCellTtiInfo ARGS
((
TfuTtiIndInfo *ttiInd,
Inst schInst,
-U8 *nCell,
+uint8_t *nCell,
RgSchCellCb *cells[]
));
#endif
/* local typedefs */
-U32 rgBwAlloInfo[RGSCH_NUM_SUB_FRAMES]; /* Num of Rbs Allocated in each SF */
-U32 rgBwAlcnt[RGSCH_NUM_SUB_FRAMES]; /*Num of times Allocation done in each Subframe */
+uint32_t rgBwAlloInfo[RGSCH_NUM_SUB_FRAMES]; /* Num of Rbs Allocated in each SF */
+uint32_t rgBwAlcnt[RGSCH_NUM_SUB_FRAMES]; /*Num of times Allocation done in each Subframe */
/* local externs */
/* rg006.201: [ccpu000111706, ccpu00112394]: Separated UL and DL TTI
* processing */
#ifdef LTE_L2_MEAS
- U64 glblTtiCnt = 0;
+ uint64_t glblTtiCnt = 0;
#endif
-U32 ri1Cnt ;
-U32 ri2Cnt ;
-U32 gDlNumUePerTti[20] = {0};
-U32 gUlNumUePerTti[20] = {0};
+uint32_t ri1Cnt ;
+uint32_t ri2Cnt ;
+uint32_t gDlNumUePerTti[20] = {0};
+uint32_t gUlNumUePerTti[20] = {0};
PRIVATE S16 rgSCHTomUtlProcDlSf ARGS((
RgSchDlSf *dlSf,
RgSchDlSf *ulSf,
PRIVATE S16 rgSCHTomUtlFillHqFdbkRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchErrInfo *err));
#else
PRIVATE S16 rgSCHTomUtlFillHqFdbkRecpReq ARGS((
TfuRecpReqInfo *recpReqInfo,
RgSchUeCb *ue,
TfuUeRecpReqInfo *pucchRecpInfo,
- U16 validIdx,
+ uint16_t validIdx,
Bool isDatPresOnSecCell
));
RgSchUeCb *ueCb
));
-U8 rgSCHTomUtlFetchPcqiBitSz ARGS
+uint8_t rgSCHTomUtlFetchPcqiBitSz ARGS
((
RgSchUeCb *ueCb,
-U8 numTxAnt,
-U8 *ri
+uint8_t numTxAnt,
+uint8_t *ri
));
-U8 rgSCHTomUtlFetchPcqiBitSzPucchMode21 ARGS
+uint8_t rgSCHTomUtlFetchPcqiBitSzPucchMode21 ARGS
((
RgSchUeCb *ueCb,
TfuCqiPucchMode21 *mode21Info,
-U8 numTxAnt,
-U8 *ri
+uint8_t numTxAnt,
+uint8_t *ri
));
S16 rgSCHTomUtlMoveNxtOccasion ARGS
((
RgSchCellCb *cell,
RgSchUeCb *ueCb,
-U16 validIdx
+uint16_t validIdx
));
PRIVATE S16 rgSCHTomUtlMovePcqiNxtOccasion ARGS
PRIVATE S16 rgSCHTomUtlFillDatRecpReq ARGS((
TfuRecpReqInfo *recpReq,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchErrInfo *err));
#else
PRIVATE S16 rgSCHTomUtlFillDatRecpReq ARGS((
RgSchCellCb *cell,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
- U8 noFdbks,
+ uint8_t noFdbks,
CmMemListCp *memCp,
- U8 elemIdx,
+ uint8_t elemIdx,
RgSchDlSf *nxtDlsf,
- U16 validIdx
+ uint16_t validIdx
));
#else
PRIVATE S16 rgSCHTomUtlFillSfRepHqFdbk ARGS((
RgSchCellCb *cell,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
- U8 noFdbks,
+ uint8_t noFdbks,
CmMemListCp *memCp,
- U8 elemIdx,
+ uint8_t elemIdx,
RgSchDlSf *nxtDlsf
));
#endif
RgSchCellCb *cell,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
- U8 noFdbks,
+ uint8_t noFdbks,
CmMemListCp *memCp,
- U8 elemIdx,
+ uint8_t elemIdx,
RgSchDlSf *nxtDlsf,
- U16 validIdx
+ uint16_t validIdx
));
#else
PRIVATE S16 rgSCHTomUtlFillSfHqFdbk ARGS((
RgSchCellCb *cell,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
- U8 noFdbks,
+ uint8_t noFdbks,
CmMemListCp *memCp,
- U8 elemIdx,
+ uint8_t elemIdx,
RgSchDlSf *nxtDlsf
));
#endif
RgSchCellCb *cellCb,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
- U8 noFdbks,
+ uint8_t noFdbks,
CmMemListCp *memCp,
- U8 elemIdx,
+ uint8_t elemIdx,
RgSchDlSf *nxtDlsf,
CmLteRnti rnti,
RgrTddAckNackMode ackNackMode,
RgSchUePucchRecpInfo **pucchInfoRef,
RgSchPdcch *pdcch,
- TknU16 n1PucchTkn,
+ TknUInt16 n1PucchTkn,
Bool *allocRef,
- U8 hqSz
+ uint8_t hqSz
));
#endif
#ifdef LTEMAC_SPS
RgSchCellCb *cell,
RgSchDlSf *dlSf,
TfuRecpReqInfo *recpReqInfo,
- U16 validIdx,
+ uint16_t validIdx,
RgSchErrInfo *err
));
#else
#ifdef LTE_ADV
PRIVATE Void rgSCHTomUtlGethqRes ARGS
((
-U8 noFdbks,
+uint8_t noFdbks,
RgSchDlSf *dlSf,
RgSchPdcch *pdcch,
RgSchCellCb *cellCb,
-U16 *hqRes
+uint16_t *hqRes
));
PRIVATE Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM1 ARGS
((
RgSchDlHqProcCb *hqCb,
TfuUePucchRecpReq *hqRecpReq,
- U8 noFdbks,
+ uint8_t noFdbks,
RgSchDlSf *dlSf,
RgSchPdcch *pdcch,
RgSchCellCb *cellCb
((
RgSchDlHqProcCb *hqCb,
TfuUePucchRecpReq *hqRecpReq,
- U8 noFdbks,
+ uint8_t noFdbks,
RgSchDlSf *dlSf,
RgSchPdcch *pdcch,
RgSchCellCb *cellCb,
- U8 elemIdx
+ uint8_t elemIdx
));
#endif/*LTE_ADV*/
#endif/*LTE_TDD*/
-U32 rgDlCqiRptCnt[16], rgTotDlCqiRpt;
+uint32_t rgDlCqiRptCnt[16], rgTotDlCqiRpt;
#ifdef RG_5GTF
-U32 rgSch5gtfCqi2Mcs[15] =
+uint32_t rgSch5gtfCqi2Mcs[15] =
{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14};
#endif
/* forward references */
/*HARQ Feedback interpretation in accordance with Femto Forum.
Note: There is no value as '0' in Femto Forum Spec but in order to retain
the existing usage in MAC (and its Acceptance), its being considered*/
-//CONSTANT PRIVATE U8 rgSchTomHqFbkMap[8] = {0,1,0,0,4,4,4,4};
+//CONSTANT PRIVATE uint8_t rgSchTomHqFbkMap[8] = {0,1,0,0,4,4,4,4};
/*added #defines instead of magic numbers*/
-/*CONSTANT PRIVATE U32 rgSCHTomBinCoe[RG_SCH_MAX_NUM_UE_SEL_SUBBANDS][RG_SCH_MAX_TOT_NUM_SUBBANDS]={
+/*CONSTANT PRIVATE uint32_t rgSCHTomBinCoe[RG_SCH_MAX_NUM_UE_SEL_SUBBANDS][RG_SCH_MAX_TOT_NUM_SUBBANDS]={
{1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28},
{0,1,3,6,10,15,21,28,36,45,55,66,78,91,105,120,136,153,171,190,210,231,253,276,300,325,351,378},
{0,0,1,4,10,20,35,56,84,120,165,220,286,364,455,560,680,816,969,1140,1330,1540,1771,2024,2300,2600,2925,3276},
S16 rgSCHGetDedPrmUe
(
RgSchCellCb *cell,
-U16 rapId,
+uint16_t rapId,
CmLteTimingInfo timingInfo,
RgSchUeCb **ue
)
#else
S16 rgSCHGetDedPrmUe(cell, rapId, timingInfo, ue)
RgSchCellCb *cell;
-U16 rapId;
+uint16_t rapId;
CmLteTimingInfo timingInfo;
RgSchUeCb **ue;
#endif
#endif
{
S16 ret;
- U8 raRntiCnt;
- U8 raReqCnt;
+ uint8_t raRntiCnt;
+ uint8_t raReqCnt;
RgSchErrInfo err;
Bool isEmtcUe = FALSE;
- U16 rapId;
+ uint16_t rapId;
RgSchUeCb *ue = NULLP;
if(cell->cellId != raReqInd->cellId)
CmLList *node;
TfuHqInfo *hqInfo;
Pst pst;
- // U8 tbCnt;
+ // uint8_t tbCnt;
RgInfRlsHqInfo *rlsHqBufs = &(cell->rlsHqArr[cell->crntHqIdx]);
- U32 cellIdx;
+ uint32_t cellIdx;
RgSchCellCb *iterCellP;
if(cell->cellId != harqAckInd->cellId)
RgSchUePCqiCb *cqiCb;
#endif
{
- U16 cqiIdx = 0;
+ uint16_t cqiIdx = 0;
CmLteTimingInfo timingInfo;
RgSchUePCqiCb *riCb;
#endif
{
- U16 riIdx;
- U16 riDist=0;
- U16 effPeriodicity;
- U16 riTrInsTime;
- U16 crntTime;
- U16 tempIdx;
+ uint16_t riIdx;
+ uint16_t riDist=0;
+ uint16_t effPeriodicity;
+ uint16_t riTrInsTime;
+ uint16_t crntTime;
+ uint16_t tempIdx;
crntTime = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
+(cell->crntTime.slot);
riIdx = tempIdx % RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
if (effPeriodicity >= RG_SCH_PCQI_SRS_SR_TRINS_SIZE)
{
- riDist = rgSCHUtlFindDist((U16)(crntTime + TFU_RECPREQ_DLDELTA),
- (U16)(crntTime + TFU_RECPREQ_DLDELTA + effPeriodicity));
+ riDist = rgSCHUtlFindDist((uint16_t)(crntTime + TFU_RECPREQ_DLDELTA),
+ (uint16_t)(crntTime + TFU_RECPREQ_DLDELTA + effPeriodicity));
}
else
{
RgSchUeCb *ue;
#endif
{
- U16 srIdx = 0;
+ uint16_t srIdx = 0;
/* Compute Next Transmission Instance */
srIdx = ue->srCb.peri + ue->srCb.nSrTrIdx;
RgSchUeCb *ue;
#endif
{
- U16 srsIdx;
- U16 srsDist;
- U16 tempIdx;
- U16 crntTime;
+ uint16_t srsIdx;
+ uint16_t srsDist;
+ uint16_t tempIdx;
+ uint16_t crntTime;
crntTime = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G)
srsIdx = tempIdx %RG_SCH_PCQI_SRS_SR_TRINS_SIZE;
if (ue->srsCb.peri > RG_SCH_PCQI_SRS_SR_TRINS_SIZE)
{
- srsDist = rgSCHUtlFindDist((U16)(crntTime + TFU_RECPREQ_DLDELTA),
- (U16)(crntTime + TFU_RECPREQ_DLDELTA + ue->srsCb.peri));
+ srsDist = rgSCHUtlFindDist((uint16_t)(crntTime + TFU_RECPREQ_DLDELTA),
+ (uint16_t)(crntTime + TFU_RECPREQ_DLDELTA + ue->srsCb.peri));
}
else
{
TfuRawCqiRpt* rawCqiInfo;
RgSchErrInfo err;
- U32 cellIdx;
+ uint32_t cellIdx;
RgInfRlsHqInfo *rlsHqBufs = &(cell->rlsHqArr[cell->crntHqIdx]);
RgSchCellCb *iterCellP;
#if DL_LA
RgSchCmnDlUe *ueDl;
#endif
- U8 cqi;
- U8 ri;
- U8 hqAck;
+ uint8_t cqi;
+ uint8_t ri;
+ uint8_t hqAck;
Pst pst;
RgSchRaCb *raCb;
TfuHqInfo hqInfo;
if (rawCqiInfo->numBits == 1)
{
rlsHqBufs = &(cell->rlsHqArr[cell->crntHqIdx]);
- U8 fdbk = TFU_HQFDB_NACK;
+ uint8_t fdbk = TFU_HQFDB_NACK;
/* Process HARQ FdbkInd */
hqAck = (rawCqiInfo->uciPayload >> 31) & 0x1;
if (hqAck)
#ifdef ANSI
PRIVATE S16 rgSCHTomUtlGenIndices
(
- U32 label,
- U8 posM,
- U8 valN,
- U8 valK,
+ uint32_t label,
+ uint8_t posM,
+ uint8_t valN,
+ uint8_t valK,
TfuSubbandInfo* sbInfo
)
#else
PRIVATE S16 rgSCHTomUtlGenIndices(label, posM, valN, valK, sbInfo)
- U32 label;
- U8 posM;
- U8 valN;
- U8 valK;
+ uint32_t label;
+ uint8_t posM;
+ uint8_t valN;
+ uint8_t valK;
TfuSubbandInfo* sbInfo;
#endif
{
- U8 idx, kval, xval, xmin;
- U32 binCoe;
+ uint8_t idx, kval, xval, xmin;
+ uint32_t binCoe;
xmin =1;
for(kval=0; kval<posM;kval++)
{
//RgSchCmnUlCell *cellUl;
Inst inst = cell->instIdx;
TfuCntrlReqInfo *cntrlInfo;
- U32 ret;
+ uint32_t ret;
#ifdef LTE_TDD
- U8 Mval;
- U8 idx;
+ uint8_t Mval;
+ uint8_t idx;
#endif
#endif
#ifdef LTE_TDD
RgInfSfAlloc *subfrmAlloc;
RgTfuCntrlReqInfo *cntrlInfo = NULLP;
S16 ret = ROK;
- U8 i;
- U8 nCell = 0;
+ uint8_t i;
+ uint8_t nCell = 0;
RgSchCellCb *cell[CM_LTE_MAX_CELLS];
RgSchCellCb *cellLst[CM_LTE_MAX_CELLS];
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell[i]->cellId,"Unable to Allocate TfuCntrlReqInfo"
" for cell");
- RETVOID;
+ return;
}
#ifdef EMTC_ENABLE
#ifdef CA_DBG
{
- U32 dbgUeIdChngAndDatReqInClCnt = 0;
- static U32 gTtiCount = 0;
+ uint32_t dbgUeIdChngAndDatReqInClCnt = 0;
+ static uint32_t gTtiCount = 0;
gTtiCount++;
if(gTtiCount == 3000)
}
#endif
- RETVOID;
+ return;
} /* rgSCHTomTtiInd */
/** @brief This function does the TTI processin for the uplink subframe,
S16 ret;
TfuRecpReqInfo *recpReqInfo;
#ifdef TFU_UPGRADE
- U16 validIdx = 0; /* Index computed from recreq's timing info*/
+ uint16_t validIdx = 0; /* Index computed from recreq's timing info*/
#endif
Inst inst = cell->instIdx;
{
S16 ret;
TfuRecpReqInfo *recpReqInfo;
- U16 validIdx; /* Index computed from recreq's timing info*/
+ uint16_t validIdx; /* Index computed from recreq's timing info*/
Inst inst = cell->instIdx;
if ((ret = rgSCHUtlAllocEventMem(inst, (Ptr *)&recpReqInfo,
if (ret != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"rgSCHTomUtlPrcUlTddSpclSf() Unable to fill"
- " SRS recption requests for cell");;
+ " SRS recption requests for cell");
RGSCH_FREE_MEM(recpReqInfo);
return ret;
}
{
Inst inst = cell->instIdx;
S16 ret;
- U8 sfTyp = 1; /* Dl Subframe */
+ uint8_t sfTyp = 1; /* Dl Subframe */
cmLListInit(&cntrlInfo->phichLst);
cmLListInit(&cntrlInfo->dlPdcchLst);
*/
cntrlInfo->cfi = dlSf->pdcchInfo.currCfi;
#ifndef RG_ULSCHED_AT_CRC
- U8 Mval = 1;
+ uint8_t Mval = 1;
#ifdef LTE_TDD
Mval = rgSchTddPhichMValTbl[cell->ulDlCfgIdx]
[cell->hiDci0Time.subframe];
* -# ROK
* -# RFAILED
*/
-EXTERN U32 numdlSpsRelSentToTf;
+EXTERN uint32_t numdlSpsRelSentToTf;
#ifdef ANSI
PRIVATE S16 rgSCHTomUtlFillDlPdcch
(
CmLList *node;
RgSchPdcch *pdcch;
TfuPdcchInfo *tfuPdcch;
- U8 isDcivld = FALSE;
- U8 numUePerTti = 0;
+ uint8_t isDcivld = FALSE;
+ uint8_t numUePerTti = 0;
ret = ROK;
/* Traversing the scheduled Harq processes */
} /* end of rgSCHTomUtlFillDlPdcch*/
#ifdef RGSCH_SPS_STATS
-extern U32 rgSchSpsRelSentToTf;
-extern U32 rgSchSpsRelPdcchAllocd;
+extern uint32_t rgSchSpsRelSentToTf;
+extern uint32_t rgSchSpsRelPdcchAllocd;
#endif
/** @brief This function will send all the UL PDCCH's for the given
* subframe.
CmLList *node;
RgSchPdcch *pdcch;
TfuPdcchInfo *tfuPdcch;
- U8 isDcivld = FALSE;
+ uint8_t isDcivld = FALSE;
ret = ROK;
/* Traversing the scheduled Harq processes */
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchDlHqProcCb *hqCb,
RgSchDlSf *nxtDlsf,
TfuUeRecpReqInfo *pucchRecpInfo,
S16 rgSCHTomUtlFillHqFdbkInfo (recpReqInfo, cell, validIdx, hqCb, nxtDlsf, pucchRecpInfo, prvHqCb, err)
TfuRecpReqInfo *recpReqInfo;
RgSchCellCb *cell;
- U16 validIdx;
+ uint16_t validIdx;
RgSchDlHqProcCb *hqCb;
RgSchDlSf *nxtDlsf;
TfuUeRecpReqInfo *pucchRecpInfo;
{
S16 ret;
RgSchDlHqTbCb *tbCb;
- U32 idx;
+ uint32_t idx;
Bool isAddToLst = FALSE;
for (idx = 0 ;idx < 2; idx++)
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx,
+ * @param [in] uint16_t validIdx,
* @param [in] RgSchDlHqInfo *dlSfHqInfo,
* @param [in] RgSchDlSf *dlSf,
* @param [in] TfuUeRecpReqInfo *pucchRecpInfo,
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchDlHqInfo *dlSfHqInfo,
RgSchDlSf *dlSf,
TfuUeRecpReqInfo *pucchRecpInfo,
PRIVATE S16 rgSCHTomUtlFillHqFdbkFor5gtf (recpReqInfo, cell, validIdx, hqCb, dlSf, pucchRecpInfo, err)
TfuRecpReqInfo *recpReqInfo;
RgSchCellCb *cell;
- U16 validIdx;
+ uint16_t validIdx;
RgSchDlHqInfo *dlSfHqInfo;
RgSchDlSf *dlSf;
TfuUeRecpReqInfo *pucchRecpInfo;
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx,
+ * @param [in] uint16_t validIdx,
* @param [in] RgSchDlHqInfo *dlSfHqInfo,
* @param [in] RgSchDlSf *dlSf,
* @param [in] TfuUeRecpReqInfo *pucchRecpInfo,
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchDlHqInfo *dlSfHqInfo,
RgSchDlSf *dlSf,
TfuUeRecpReqInfo *pucchRecpInfo,
PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt1B (recpReqInfo, cell, validIdx, hqCb, dlSf, pucchRecpInfo, err)
TfuRecpReqInfo *recpReqInfo;
RgSchCellCb *cell;
- U16 validIdx;
+ uint16_t validIdx;
RgSchDlHqInfo *dlSfHqInfo;
RgSchDlSf *dlSf;
TfuUeRecpReqInfo *pucchRecpInfo;
RgSchUeCb *ue;
TfuUePucchRecpReq *pucchReqInfo = NULLP;
Bool isDatPresOnSecCell = FALSE;
- U8 primCellTbCount = 0;
+ uint8_t primCellTbCount = 0;
hqPNode = dlSfHqInfo->hqPLst.first;
ue = (RgSchUeCb*)dlSfHqInfo->dlSfUeLnk.node;
pucchReqInfo->hqInfo.hqSz = ue->f1bCsAVal;
pucchReqInfo->hqInfo.pucchResCnt = ue->f1bCsAVal;
- memset(pucchReqInfo->hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
+ memset(pucchReqInfo->hqInfo.hqRes,0xff,sizeof(uint16_t)*TFU_MAX_HQ_RES);
#ifdef LTEMAC_SPS
/* Two Resources needs to be configured if the
* serving cell is in mimo mode else single
* mode should be in 2 indices */
if(RG_SCH_IS_CELL_SEC(ue,hqCb->hqE->cell))
{
- U8 cellIdx = ue->cellIdToCellIdxMap[RG_SCH_CELLINDEX(hqCb->hqE->cell)];
+ uint8_t cellIdx = ue->cellIdToCellIdxMap[RG_SCH_CELLINDEX(hqCb->hqE->cell)];
if(rgSCHUtlGetMaxTbSupp(ue->cellInfo[cellIdx]->txMode.txModeEnum) > 1)
{/* Sec cell is in mimo mode, use 0 and 1 */
pucchReqInfo->hqInfo.hqRes[0] =
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx,
+ * @param [in] uint16_t validIdx,
* @param [in] RgSchDlHqInfo *dlSfHqInfo,
* @param [in] RgSchDlSf *dlSf,
* @param [in] TfuUeRecpReqInfo *pucchRecpInfo,
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchDlHqInfo *dlSfHqInfo,
RgSchDlSf *dlSf,
TfuUeRecpReqInfo *pucchRecpInfo,
PRIVATE S16 rgSCHTomUtlFillHqFdbkForFrmt3 (recpReqInfo, cell, validIdx, hqCb, dlSf, pucchRecpInfo, err)
TfuRecpReqInfo *recpReqInfo;
RgSchCellCb *cell;
- U16 validIdx;
+ uint16_t validIdx;
RgSchDlHqInfo *dlSfHqInfo;
RgSchDlSf *dlSf;
TfuUeRecpReqInfo *pucchRecpInfo;
pucchReqInfo->hqInfo.hqSz = ue->f1bCsAVal;
pucchReqInfo->hqInfo.pucchResCnt = 1;
- memset(pucchReqInfo->hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
+ memset(pucchReqInfo->hqInfo.hqRes,0xff,sizeof(uint16_t)*TFU_MAX_HQ_RES);
#endif/*TFU_UPGRADE*/
pucchReqInfo->hqInfo.hqRes[0] = dlSfHqInfo->n3ScellPucch.n3PucchIdx;
#ifdef TFU_UPGRADE
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchErrInfo *err
)
#else
PRIVATE S16 rgSCHTomUtlFillHqFdbkRecpReq (recpReqInfo, cell, validIdx, err)
TfuRecpReqInfo *recpReqInfo;
RgSchCellCb *cell;
- U16 validIdx;
+ uint16_t validIdx;
RgSchErrInfo *err;
#endif
#else
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchErrInfo *err
)
#else
PRIVATE S16 rgSCHTomUtlFillSrRecpReq (recpReqInfo, cell, validIdx, err)
TfuRecpReqInfo *recpReqInfo;
RgSchCellCb *cell;
- U16 validIdx;
+ uint16_t validIdx;
RgSchErrInfo *err;
#endif
{
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx
+ * @param [in] uint16_t validIdx
* @param [out] RgSchErrInfo *err
* @return S16
* -# ROK
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchErrInfo *err
)
#else
PRIVATE S16 rgSCHTomUtlFillRiRecpReq (recpReqInfo, cell, validIdx, err)
TfuRecpReqInfo *recpReqInfo;
RgSchCellCb *cell;
- U16 validIdx;
+ uint16_t validIdx;
RgSchErrInfo *err;
#endif
{
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx
+ * @param [in] uint16_t validIdx
* @param [out] RgSchErrInfo *err
* @return S16
* -# ROK
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchErrInfo *err
)
#else
PRIVATE S16 rgSCHTomUtlFillCqiRiRecpReq (recpReqInfo, cell, validIdx, err)
TfuRecpReqInfo *recpReqInfo;
RgSchCellCb *cell;
- U16 validIdx;
+ uint16_t validIdx;
RgSchErrInfo *err;
#endif
{
TfuUeRecpReqInfo *pucchRecpInfo;
RgSchUeCb *ue = NULLP;
- U16 ret;
+ uint16_t ret;
while ((ue = rgSCHDbmGetNextUeCb(cell, ue)) != NULLP)
{
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx
+ * @param [in] uint16_t validIdx
* @param [out] RgSchErrInfo *err
* @return S16
* -# ROK
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchErrInfo *err
)
#else
PRIVATE S16 rgSCHTomUtlFillPcqiRecpReq (recpReqInfo, cell, validIdx, err)
TfuRecpReqInfo *recpReqInfo;
RgSchCellCb *cell;
- U16 validIdx;
+ uint16_t validIdx;
RgSchErrInfo *err;
#endif
{
S16 ret;
RgSchUeCb *ue;
- U8 ri; /*RI value*/
+ uint8_t ri; /*RI value*/
Bool willUeRprtCqi; /* Flag set due to CQI Mask
and UE Inactive state (DRX)*/
- U8 cqiPmiSz;
+ uint8_t cqiPmiSz;
RgSchUePCqiCb *cqiCb = NULLP;
Bool isAddToLst = FALSE;
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx
+ * @param [in] uint16_t validIdx
* @param [out] RgSchErrInfo *err
* @return S16
* -# ROK
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchErrInfo *err
)
#else
PRIVATE S16 rgSCHTomUtlFillSrsRecpReq (recpReqInfo, cell, validIdx, err)
TfuRecpReqInfo *recpReqInfo;
RgSchCellCb *cell;
- U16 validIdx;
+ uint16_t validIdx;
RgSchErrInfo *err;
#endif
{
*
* @param [out] TfuRecpReqInfo *recpReqInfo
* @param [in] RgSchCellCb *cell
- * @param [in] U16 validIdx
+ * @param [in] uint16_t validIdx
* @param [out] RgSchErrInfo *err
* @return S16
* -# ROK
(
TfuRecpReqInfo *recpReqInfo,
RgSchCellCb *cell,
- U16 validIdx,
+ uint16_t validIdx,
RgSchErrInfo *err
)
#else
PRIVATE S16 rgSCHTomUtlFillDatRecpReq (recpReqInfo, cell, validIdx, err)
TfuRecpReqInfo *recpReqInfo;
RgSchCellCb *cell;
- U16 validIdx;
+ uint16_t validIdx;
RgSchErrInfo *err;
#endif
{
CmLteTimingInfo dci0Time;
- U8 idx;
+ uint8_t idx;
S16 ret;
RgSchUlAlloc *alloc;
TfuUeRecpReqInfo *datRecpInfo;
Bool isAperiodic = FALSE; /*Set when Aperiodic CQI is expected */
- U8 numUePerTti = 0;
+ uint8_t numUePerTti = 0;
if((0 == (recpReqInfo->timingInfo.sfn % 30)) && (0 == recpReqInfo->timingInfo.slot))
{
*
* Desc : Fetch the CQI/PMI bits for a UE based on the mode, periodicity.
*
- * Ret : U8
+ * Ret : uint8_t
* ROK - Success
*
* Notes:
*
**********************************************************/
#ifdef ANSI
-U8 rgSCHTomUtlFetchPcqiBitSz
+uint8_t rgSCHTomUtlFetchPcqiBitSz
(
RgSchUeCb *ueCb,
- U8 numTxAnt,
- U8 *ri
+ uint8_t numTxAnt,
+ uint8_t *ri
)
#else
-U8 rgSCHTomUtlFetchPcqiBitSz(ueCb, numTxAnt, ri)
+uint8_t rgSCHTomUtlFetchPcqiBitSz(ueCb, numTxAnt, ri)
RgSchUeCb *ueCb;
- U8 numTxAnt;
- U8 *ri;
+ uint8_t numTxAnt;
+ uint8_t *ri;
#endif
{
- U8 confRepMode;
- U8 pcqiSz;
+ uint8_t confRepMode;
+ uint8_t pcqiSz;
TfuCqiPucchMode10 *mode10Info;
TfuCqiPucchMode11 *mode11Info;
TfuCqiPucchMode20 *mode20Info;
RgSchUePCqiCb *cqiCb;
#endif
{
- U16 tti = (crntTimInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G + crntTimInfo.slot);
- U16 prdNum = tti/cqiCb->cqiPeri;
+ uint16_t tti = (crntTimInfo.sfn * RGSCH_NUM_SUB_FRAMES_5G + crntTimInfo.slot);
+ uint16_t prdNum = tti/cqiCb->cqiPeri;
if((prdNum % cqiCb->h) == 0)
{
*
* @param[in] RgSchCellCb *cell,
* RgSchUeCb *ue,
- * U16 validIdx
+ * uint16_t validIdx
* @return S16
* -# ROK
* -# RFAILED
(
RgSchCellCb *cell,
RgSchUeCb *ue,
- U16 validIdx
+ uint16_t validIdx
)
#else
S16 rgSCHTomUtlMoveNxtOccasion(cell, ue, validIdx)
RgSchCellCb *cell;
RgSchUeCb *ue;
- U16 validIdx;
+ uint16_t validIdx;
#endif
{
RgSchUePCqiCb *cqiCb = ue->nPCqiCb;
* to aid decoding of Aperiodic CQI.
*
* Ret : Void
- * ROK - RETVOID
+ * ROK - void
*
* Notes:
*
RgSchUeCb *ueCb,
RgSchCellCb *cell,
TfuUePuschCqiRecpInfo *cqiRecpReqInfo,
- U8 ccIdx
+ uint8_t ccIdx
)
#else
Void rgSCHTomPrepareAcqiRecp(ueCb, cell, cqiRecpReqInfo, ccIdx)
RgSchUeCb *ueCb;
RgSchCellCb *cell;
TfuUePuschCqiRecpInfo *cqiRecpReqInfo;
- U8 ccIdx;
+ uint8_t ccIdx;
#endif
{
- U8 confRepMode;
+ uint8_t confRepMode;
RgSchCqiRawPuschMode12 *mode12Info;
RgSchCqiRawPuschMode20 *mode20Info;
RgSchCqiRawPuschMode22 *mode22Info;
RgSchCqiRawPuschMode30 *mode30Info;
RgSchCqiRawPuschMode31 *mode31Info;
- U8 numTxAnt = cell->numTxAntPorts;
- U8 sCellIdx = ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cell)];
- U8 numOfCells = 0;
+ uint8_t numTxAnt = cell->numTxAntPorts;
+ uint8_t sCellIdx = ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cell)];
+ uint8_t numOfCells = 0;
RgSchUeACqiCb *acqiCb = &ueCb->cellInfo[sCellIdx]->acqiCb;
/* Fill TFU Recp */
default:
break;
}
- RETVOID;
+ return;
}
/**
S16 rgSCHTomUtlFillDatAperRecpReq
(
RgSchCellCb *cell,
- U8 cqiReq,
+ uint8_t cqiReq,
RgSchUlAlloc *alloc,
TfuUeRecpReqInfo *datRecpInfo,
CmLteTimingInfo *timeInfo,
Bool hqPres,
- U16 validIdx
+ uint16_t validIdx
)
#else
S16 rgSCHTomUtlFillDatAperRecpReq(cell, cqiReq, alloc, datRecpInfo, timeInfo, hqPres, validIdx)
RgSchCellCb *cell;
- U8 cqiReq;
+ uint8_t cqiReq;
RgSchUlAlloc *alloc;
TfuUeRecpReqInfo *datRecpInfo;
CmLteTimingInfo *timeInfo;
Bool hqPres;
- U16 validIdx;
+ uint16_t validIdx;
#endif
{
TfuUePuschCqiRecpInfo *cqiRecpReqInfo;
RgSchUeCb *ueCb = alloc->ue;
#ifdef LTE_ADV
- U8 triggerSet = 0;
- U8 sIdx = 0;
+ uint8_t triggerSet = 0;
+ uint8_t sIdx = 0;
#endif
/*Fill RI Reception Params*/
TfuUeRecpReqInfo *datRecpInfo,
CmLteTimingInfo *timeInfo,
Bool hqPres,
- U16 validIdx
+ uint16_t validIdx
)
#else
S16 rgSCHTomUtlFillDatPriRecpReq(cell, alloc, datRecpInfo, timeInfo,
TfuUeRecpReqInfo *datRecpInfo;
CmLteTimingInfo *timeInfo;
Bool hqPres;
- U16 validIdx;
+ uint16_t validIdx;
#endif
{
TfuUePuschCqiRecpInfo *cqiRecpReqInfo;
TfuUeRecpReqInfo *datRecpInfo,
CmLteTimingInfo *timeInfo,
Bool hqPres,
- U16 validIdx
+ uint16_t validIdx
)
#else
S16 rgSCHTomUtlFillDatPCqiRecpReq(cell, alloc, datRecpInfo,
TfuUeRecpReqInfo *datRecpInfo;
CmLteTimingInfo *timeInfo;
Bool hqPres;
- U16 validIdx;
+ uint16_t validIdx;
#endif
{
TfuUePuschCqiRecpInfo *cqiRecpReqInfo;
- U8 cqiPmiSz; /*Raw CQI/PMI Size*/
- U8 ri;
+ uint8_t cqiPmiSz; /*Raw CQI/PMI Size*/
+ uint8_t ri;
/*Fill CQI Reception Params*/
cqiRecpReqInfo = &datRecpInfo->t.puschRecpReq.cqiRiInfo;
* TfuRecpReqInfo *recpReqInfo,
* RgSchDlHqProcCb *hqCb,
* @param[out] TfuUeRecpReqInfo *pucchRecpInfo
- * @param[in] U16 validIdx
+ * @param[in] uint16_t validIdx
* @return S16
* -# ROK
* -# RFAILED
TfuRecpReqInfo *recpReqInfo,
RgSchUeCb *ue,
TfuUeRecpReqInfo *pucchRecpInfo,
- U16 validIdx,
+ uint16_t validIdx,
Bool isDatPresOnSecCell
)
#else
TfuRecpReqInfo *recpReqInfo;
RgSchUeCb *ue;
TfuUeRecpReqInfo *pucchRecpInfo;
-U16 validIdx;
+uint16_t validIdx;
Bool isDatPresOnSecCell;
#endif
{
RgSchUePCqiCb *cqiCb;
RgSchUePCqiCb *riCb;
- U8 ri; /*To fetch RI value*/
+ uint8_t ri; /*To fetch RI value*/
Bool willUeRprtCqi; /* Flag set due to CQI Mask and
UE Inactive state (DRX)*/
Bool willUeRprtSr = TRUE;
TfuAckNackMode hqFdbkMode;
- U8 numCqiBit;
- U8 totalPucchBits;
+ uint8_t numCqiBit;
+ uint8_t totalPucchBits;
Bool dropCqi = FALSE;
#ifdef LTEMAC_SPS
RgSchCmnUlUeSpsInfo *ulSpsUe = NULL;
* RgSchUeCb *ue
* TfuRecpReqInfo *recpReqInfo,
* @param[out] TfuUeRecpReqInfo *pucchRecpInfo
- * @param[in] U16 validIdx
+ * @param[in] uint16_t validIdx
* @return S16
* -# ROK
* -# RFAILED
RgSchUeCb *ue,
TfuRecpReqInfo *recpReqInfo,
TfuUeRecpReqInfo *pucchRecpInfo,
- U16 validIdx
+ uint16_t validIdx
)
#else
PRIVATE S16 rgSCHTomUtlFillCqiSrsWithSr(cell, ue, recpReqInfo,
RgSchUeCb *ue;
TfuRecpReqInfo *recpReqInfo;
TfuUeRecpReqInfo *pucchRecpInfo;
-U16 validIdx;
+uint16_t validIdx;
#endif
{
RgSchUePCqiCb *cqiCb;
RgSchUePCqiCb *riCb;
- U8 ri; /*To fetch RI value*/
+ uint8_t ri; /*To fetch RI value*/
Bool willUeRprtCqi; /* Flag set due to CQI Mask and
UE Inactive state (DRX)*/
riCb = ue->nPRiCb;
* @param [in] RgSchCellCb *cell
* @param [out] RgSchErrInfo *err
* @param [in] RgSchDlSf *dlSf
- * @param [in] U8 noFdbks
+ * @param [in] uint8_t noFdbks
* @param [in] CmMemListCp *memCp
- * @param [in] U8 elemIdx
+ * @param [in] uint8_t elemIdx
* @param [in] RgSchDlSf *nxtDlsf
* @return S16
* -# ROK
RgSchCellCb *cellCb,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
- U8 noFdbks,
+ uint8_t noFdbks,
CmMemListCp *memCp,
- U8 elemIdx,
+ uint8_t elemIdx,
RgSchDlSf *nxtDlsf,
- U16 validIdx
+ uint16_t validIdx
)
#else
PRIVATE S16 rgSCHTomUtlFillSfRepHqFdbk (recpReqInfo, cellCb, err, dlSf,
RgSchCellCb *cellCb;
RgSchErrInfo *err;
RgSchDlSf *dlSf;
- U8 noFdbks;
+ uint8_t noFdbks;
CmMemListCp *memCp;
- U8 elemIdx;
+ uint8_t elemIdx;
RgSchDlSf *nxtDlsf;
- U16 validIdx;
+ uint16_t validIdx;
#endif
#else
#ifdef ANSI
RgSchCellCb *cellCb,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
-U8 noFdbks,
+uint8_t noFdbks,
CmMemListCp *memCp,
-U8 elemIdx,
+uint8_t elemIdx,
RgSchDlSf *nxtDlsf
)
#else
RgSchCellCb *cellCb;
RgSchErrInfo *err;
RgSchDlSf *dlSf;
- U8 noFdbks;
+ uint8_t noFdbks;
CmMemListCp *memCp;
- U8 elemIdx;
+ uint8_t elemIdx;
RgSchDlSf *nxtDlsf;
#endif
#endif
* @param [in] RgSchCellCb *cell
* @param [out] RgSchErrInfo *err
* @param [in] RgSchDlSf *dlSf
- * @param [in] U8 noFdbks
+ * @param [in] uint8_t noFdbks
* @param [in] CmMemListCp *memCp
- * @param [in] U8 elemIdx
+ * @param [in] uint8_t elemIdx
* @param [in] RgSchDlSf *nxtDlsf
-* @param [in] U16 validIdx;
+* @param [in] uint16_t validIdx;
* @return S16
* -# ROK
* -# RFAILED
RgSchCellCb *cellCb,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
- U8 noFdbks,
+ uint8_t noFdbks,
CmMemListCp *memCp,
- U8 elemIdx,
+ uint8_t elemIdx,
RgSchDlSf *nxtDlsf,
- U16 validIdx,
+ uint16_t validIdx,
RgSchDlHqProcCb *hqCb,
RgSchUePucchRecpInfo *pucchInfo,
Bool alloc,
RgSchCellCb *cellCb;
RgSchErrInfo *err;
RgSchDlSf *dlSf;
-U8 noFdbks;
+uint8_t noFdbks;
CmMemListCp *memCp;
-U8 elemIdx;
+uint8_t elemIdx;
RgSchDlSf *nxtDlsf;
-U16 validIdx;
+uint16_t validIdx;
RgSchDlHqProcCb *hqCb;
RgSchUePucchRecpInfo *pucchInfo;
Bool alloc;
RgSchCellCb *cellCb,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
- U8 noFdbks,
+ uint8_t noFdbks,
CmMemListCp *memCp,
- U8 elemIdx,
+ uint8_t elemIdx,
RgSchDlSf *nxtDlsf,
RgSchDlHqProcCb *hqCb,
RgSchUePucchRecpInfo *pucchInfo,
RgSchCellCb *cellCb;
RgSchErrInfo *err;
RgSchDlSf *dlSf;
-U8 noFdbks;
+uint8_t noFdbks;
CmMemListCp *memCp;
-U8 elemIdx;
+uint8_t elemIdx;
RgSchDlSf *nxtDlsf;
RgSchDlHqProcCb *hqCb;
RgSchUePucchRecpInfo *pucchInfo;
RgrTddAckNackMode ackNackMode;
RgSchDlHqTbCb *tbCb;
CmLteRnti rnti;
- U8 hqSz = 0;
- U32 idx = 0;
+ uint8_t hqSz = 0;
+ uint32_t idx = 0;
#ifndef TFU_UPGRADE
RG_SCH_ADD_TO_CRNT_TIME(cellCb->crntTime, futTime, TFU_RECPREQ_DLDELTA);
else
{
/* Get the TFU reception request pointer, if present */
- cmHashListFind(&cellCb->ueTfuPendLst, (U8*) &ueCb->ueId,
+ cmHashListFind(&cellCb->ueTfuPendLst, (uint8_t*) &ueCb->ueId,
sizeof(ueCb->ueId), 0, (PTR *) &pucchInfo);
}
#else
/* For upgrade we shall use the existing logic of pending list. */
- cmHashListFind(&cellCb->ueTfuPendLst, (U8*) &ueCb->ueId,
+ cmHashListFind(&cellCb->ueTfuPendLst, (uint8_t*) &ueCb->ueId,
sizeof(ueCb->ueId), 0, (PTR *) &pucchInfo);
#endif
}
&&(hqCb != prvHqCb)
)
{
- TknU16 n1PucchTkn = {FALSE, 0};
+ TknUInt16 n1PucchTkn = {FALSE, 0};
RgSchPdcch *pdcch;
- U8 tbIndx;
+ uint8_t tbIndx;
pdcch = tbCb->hqP->pdcch;
#ifdef LTEMAC_SPS
n1PucchTkn = hqCb->spsN1PucchRes;
//if((elemIdx != (noFdbks - 1)))
{
cmHashListInsert(&cellCb->ueTfuPendLst, (PTR) pucchInfo,
- (U8 *)&rnti ,(U16) sizeof(CmLteRnti));
+ (uint8_t *)&rnti ,(uint16_t) sizeof(CmLteRnti));
alloc = FALSE;
}
* Harq Reception Request for Format 1B with
* Channel Selection
*
- * @param [in] U8 noFdbks
+ * @param [in] uint8_t noFdbks
* @param [in] RgSchDlSf *dlSf
* @param [in] RgSchPdcch *pdcch
* @param [in] RgSchCellCb *cellCb
- * @param [out]U16 *hqRes
+ * @param [out]uint16_t *hqRes
* @return void
*/
#ifdef ANSI
PRIVATE Void rgSCHTomUtlGethqRes
(
-U8 noFdbks,
+uint8_t noFdbks,
RgSchDlSf *dlSf,
RgSchPdcch *pdcch,
RgSchCellCb *cellCb,
-U16 *hqRes
+uint16_t *hqRes
)
#else
PRIVATE Void rgSCHTomUtlGethqRes(noFdbks,dlSf,pdcch,cellCb,hqRes)
-U8 noFdbks;
+uint8_t noFdbks;
RgSchDlSf *dlSf;
RgSchPdcch *pdcch;
RgSchCellCb *cellCb;
-U16 *hqRes;
+uint16_t *hqRes;
#endif
{
- U8 M;
- U8 P;
- U8 m;
- U8 nP;
- U8 nPlusOne;
- U8 nCce;
+ uint8_t M;
+ uint8_t P;
+ uint8_t m;
+ uint8_t nP;
+ uint8_t nPlusOne;
+ uint8_t nCce;
M = noFdbks;
m = dlSf->dlFdbkInfo.m;
*hqRes = (M - m - 1)* nP + (m * nPlusOne) + pdcch->nCce +
cellCb->pucchCfg.n1PucchAn;
- RETVOID;
+ return;
}
/** @brief This function fills the harq reception request for
*
* @param [in] RgSchDlHqProcCb *hqCb
* @param [in] TfuUePucchRecpReq *hqRecpReq
- * @param [in] U8 noFdbks
+ * @param [in] uint8_t noFdbks
* @param [in] RgSchDlSf *dlSf
* @param [in] RgSchPdcch *pdcch
* @param [in] RgSchCellCb *cellCb
(
RgSchDlHqProcCb *hqCb,
TfuUePucchRecpReq *hqRecpReq,
- U8 noFdbks,
+ uint8_t noFdbks,
RgSchDlSf *dlSf,
RgSchPdcch *pdcch,
RgSchCellCb *cellCb
noFdbks,dlSf,pdcch,cellCb)
RgSchDlHqProcCb *hqCb;
TfuUePucchRecpReq *hqRecpReq;
- U8 noFdbks;
+ uint8_t noFdbks;
RgSchDlSf *dlSf;
RgSchPdcch *pdcch;
RgSchCellCb *cellCb;
{
RgSchUeCb *ue = NULLP;
Bool isCellSec = FALSE;
- U16 hqRes;
+ uint16_t hqRes;
/*ccpu00147920: UeCb is NULL for SPS activation*/
if(pdcch && pdcch->ue)
* Error case. hqCB has to be ter
* when pdcch is present . Adding
* if check bcs of kwork*/
- RETVOID;
+ return;
}
#endif
ue = hqCb->hqE->ue;
* Error case. hqCB has to be ter
* when pdcch is present . Adding
* if check bcs of kwork*/
- RETVOID;
+ return;
}
#endif
* mode should be in 2 indices */
if(isCellSec)
{
- U8 servCellIdx = rgSchUtlGetServCellIdx(hqCb->hqE->cell->instIdx,
+ uint8_t servCellIdx = rgSchUtlGetServCellIdx(hqCb->hqE->cell->instIdx,
hqCb->hqE->cell->cellId,
hqCb->hqE->ue);
* Error case. hqCB has to be ter
* when pdcch is present . Adding
* if check bcs of kwork*/
- RETVOID;
+ return;
}
#endif
* Error case. hqCB has to be ter
* when pdcch is present . Adding
* if check bcs of kwork*/
- RETVOID;
+ return;
}
#endif
* Error case. hqCB has to be ter
* when pdcch is present . Adding
* if check bcs of kwork*/
- RETVOID;
+ return;
}
#endif
default:
break;
}
- RETVOID;
+ return;
}
/** @brief This function fills the harq reception request for
*
* @param [in] RgSchDlHqProcCb *hqCb
* @param [in] TfuUePucchRecpReq *hqRecpReq
- * @param [in] U8 noFdbks
+ * @param [in] uint8_t noFdbks
* @param [in] RgSchDlSf *dlSf
* @param [in] RgSchPdcch *pdcch
* @param [in] RgSchCellCb *cellCb
- * @param [in] U8 elemIdx
+ * @param [in] uint8_t elemIdx
* @return void
*/
#ifdef ANSI
(
RgSchDlHqProcCb *hqCb,
TfuUePucchRecpReq *hqRecpReq,
- U8 noFdbks,
+ uint8_t noFdbks,
RgSchDlSf *dlSf,
RgSchPdcch *pdcch,
RgSchCellCb *cellCb,
- U8 elemIdx
+ uint8_t elemIdx
)
#else
PRIVATE Void rgSCHTomUtlFillSfHqFdbkForFrmt1BCSForM234(
hqCb,hqRecpReq,noFdbks,dlSf,pdcch,cellCb,elemIdx)
RgSchDlHqProcCb *hqCb;
TfuUePucchRecpReq *hqRecpReq;
- U8 noFdbks;
+ uint8_t noFdbks;
RgSchDlSf *dlSf;
RgSchPdcch *pdcch;
RgSchCellCb *cellCb;
- U8 elemIdx;
+ uint8_t elemIdx;
#endif
{
RgSchUeCb *ue;
Bool isCellSec = FALSE;
- U16 hqRes = 0;
- U8 servCellIdx;
+ uint16_t hqRes = 0;
+ uint8_t servCellIdx;
if(pdcch)
{/* SPS Release pdcch or dynamic data */
* Error case. hqCB has to be ter
* when pdcch is present . Adding
* if check bcs of kwork*/
- RETVOID;
+ return;
}
#endif
ue = hqCb->hqE->ue;
}
}
}
- RETVOID;
+ return;
}
/** @brief This function fills the harq reception request for
(
RgSchDlHqProcCb *hqCb,
TfuUePucchRecpReq *hqRecpReq,
- U8 noFdbks,
+ uint8_t noFdbks,
RgSchDlSf *dlSf,
RgSchPdcch *pdcch,
- U8 elemIdx,
+ uint8_t elemIdx,
RgSchCellCb *cellCb
)
#else
n1PucchTkn,elemIdx,cellCb)
RgSchDlHqProcCb *hqCb;
TfuUePucchRecpReq *hqRecpReq;
- U8 noFdbks;
+ uint8_t noFdbks;
RgSchDlSf *dlSf;
RgSchPdcch *pdcch;
- U8 elemIdx;
+ uint8_t elemIdx;
RgSchCellCb *cellCb;
#endif
{
RgSchCellCb *cellCb,
RgSchErrInfo *err,
RgSchDlSf *dlSf,
-U8 noFdbks,
+uint8_t noFdbks,
CmMemListCp *memCp,
-U8 elemIdx,
+uint8_t elemIdx,
RgSchDlSf *nxtDlsf,
CmLteRnti rnti,
RgrTddAckNackMode ackNackMode,
RgSchUePucchRecpInfo **pucchInfoRef,
RgSchPdcch *pdcch,
-TknU16 n1PucchTkn,
+TknUInt16 n1PucchTkn,
Bool *allocRef,
-U8 hqSz
+uint8_t hqSz
)
#else
PRIVATE S16 rgSCHTomUtlFillSfHqFdbkForOneUe(hqCb,recpReqInfo, cellCb, err, dlSf,
RgSchCellCb *cellCb;
RgSchErrInfo *err;
RgSchDlSf *dlSf;
-U8 noFdbks;
+uint8_t noFdbks;
CmMemListCp *memCp;
-U8 elemIdx;
+uint8_t elemIdx;
RgSchDlSf *nxtDlsf;
CmLteRnti rnti;
RgrTddAckNackMode ackNackMode;
RgSchUePucchRecpInfo **pucchInfoRef;
RgSchPdcch *pdcch;
-TknU16 n1PucchTkn;
+TknUInt16 n1PucchTkn;
Bool *allocRef;
-U8 hqSz;
+uint8_t hqSz;
#endif
{
RgSchUePucchRecpInfo *pucchInfo = *pucchInfoRef;
S16 ret;
TfuUePucchRecpReq *hqRecpReq;
#ifdef TFU_UPGRADE
- U8 M;
- U8 P;
- U8 m;
- U8 nP;
- U8 nPlusOne;
- U16 pucchRes;
- U8 resIdx;
- U8 nCce;
- U8 prevHqSize;
+ uint8_t M;
+ uint8_t P;
+ uint8_t m;
+ uint8_t nP;
+ uint8_t nPlusOne;
+ uint16_t pucchRes;
+ uint8_t resIdx;
+ uint8_t nCce;
+ uint8_t prevHqSize;
#else
- U8 multCnt;
+ uint8_t multCnt;
#endif
#ifdef LTEMAC_SPS
Bool isFirstFdbk = FALSE;
err->errCause = RGSCHERR_TOM_MEM_EXHAUST;
return ret;
}
- memset(pucchInfo->pucchRecpInfo->t.pucchRecpReq.hqInfo.hqRes,0xff,sizeof(U16)*TFU_MAX_HQ_RES);
+ memset(pucchInfo->pucchRecpInfo->t.pucchRecpReq.hqInfo.hqRes,0xff,sizeof(uint16_t)*TFU_MAX_HQ_RES);
#ifdef TFU_ALLOC_EVENT_NO_INIT
memset(&pucchInfo->pucchRecpInfo->t.pucchRecpReq, 0, sizeof(TfuUePucchRecpReq));
#endif
if((elemIdx != noFdbks) && alloc)
{
cmHashListInsert(&cellCb->ueTfuPendLst, (PTR) pucchInfo,
- (U8 *)&rnti, (U16) sizeof(rnti));
+ (uint8_t *)&rnti, (uint16_t) sizeof(rnti));
alloc = FALSE;
}
else
RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),
"Mem alloc failed for RGR TTI ind, cellId (%d))\n",
cell->cellId));
- RETVOID;
+ return;
}
rgrTtiInd->cellId = cell->cellId;
//rgrTtiInd->hSfn = cell->crntTime.hSfn;
cell->cellId));
rgSCHUtlFreeSBuf(cell->instIdx, (Data**)&rgrTtiInd,
sizeof(RgrTtiIndInfo));
- RETVOID;
+ return;
}
}
- RETVOID;
+ return;
}
#endif
//printf("Initializing Index %d \n", rgSchDynTddInfo->crntDTddSfIdx);
- RETVOID;
+ return;
}
#endif
#endif
*
* @param [in] TfuTtiIndInfo *ttiInd
* @param [in] Inst schInst
- * @param [out] U8 *nCell
+ * @param [out] uint8_t *nCell
* @param [out] RgSchCellCb *cell[]
*
* Returns: Void
(
TfuTtiIndInfo *ttiInd,
Inst schInst,
-U8 *nCell,
+uint8_t *nCell,
RgSchCellCb *cells[]
)
#else
PRIVATE Void rgSchTomFillCellTtiInfo (ttiInd, schInst, nCell, cells)
TfuTtiIndInfo *ttiInd;
Inst schInst;
-U8 *nCell;
+uint8_t *nCell;
RgSchCellCb *cells[];
#endif
{
- U8 i = 0;
- U8 strtCellId;
+ uint8_t i = 0;
+ uint8_t strtCellId;
TfuTtiCellInfo *cellInfo;
RgSchCellCb *cell;
- U32 Idx1;
+ uint32_t Idx1;
CmLteTimingInfo frm;
if (CM_LTE_MAX_CELLS < ttiInd->numCells)
{
- RETVOID;
+ return;
}
#ifdef RG_5GTF
{
cellInfo = &ttiInd->cells[i];
strtCellId = rgSchCb[schInst].genCfg.startCellId;
- Idx1 = (U8)((cellInfo->cellId - strtCellId)&(CM_LTE_MAX_CELLS-1));
+ Idx1 = (uint8_t)((cellInfo->cellId - strtCellId)&(CM_LTE_MAX_CELLS-1));
cell = rgSchCb[schInst].cells[Idx1];
/* Validate the cell */
if (cell == NULLP)
cell->totalTime++;
#endif
#ifdef LTE_TDD
- U8 idx = (cell->crntTime.slot + RG_SCH_CMN_DL_DELTA) %
+ uint8_t idx = (cell->crntTime.slot + RG_SCH_CMN_DL_DELTA) %
RGSCH_NUM_SUB_FRAMES_5G;
cell->isDlDataAllwd = RG_SCH_CMN_CHK_DL_DATA_ALLOWED(cell, idx);
SlotIndInfo slotInd,
Inst schInst)
{
- U8 cellCount = 0;
+ uint8_t cellCount = 0;
for(cellCount = 0; cellCount < CM_LTE_MAX_CELLS; cellCount++)
{
RgSchCellCb *cell;
*/
#ifndef RG_ULSCHED_AT_CRC
{
- U8 Mval = 1;
- U8 idx; /* Index into Uplink Sf array */
+ uint8_t Mval = 1;
+ uint8_t idx; /* Index into Uplink Sf array */
#ifdef LTE_TDD
Mval = rgSchTddPhichMValTbl[cell->ulDlCfgIdx]
[cell->hiDci0Time.subframe];
/* Perform DL scheduling for Common channels */
rgSCHCmnDlCommonChSch(cell);
- RETVOID;
+ return;
}
/** @brief This function invokes the Non critical procedures like measurements,
RgSchCellCb *cell;
#endif
{
- U8 suId = cell->tfuSap->sapCfg.suId;
+ uint8_t suId = cell->tfuSap->sapCfg.suId;
/* Invoke RAM Tti Handler */
rgSCHRamTtiHndlr(cell);
(cell->lteAdvCb.absCfg.absLoadPeriodicity))
{
RgrLoadInfIndInfo *rgrLoadInf;
- U8 idx;
+ uint8_t idx;
cell->lteAdvCb.absLoadTtiCnt++;
if(cell->lteAdvCb.absLoadTtiCnt >= cell->lteAdvCb.absCfg.absLoadPeriodicity)
{
RGSCHDBGERRNEW(cell->instIdx,(rgSchPBuf(cell->instIdx),"Could not "
"allocate memory for sending LoadInfo\n"));
- RETVOID;
+ return;
}
cell->lteAdvCb.absLoadTtiCnt = 0;
rgrLoadInf->cellId = cell->cellId;
#endif
/* LTE_ADV_FLAG_REMOVED_END */
- RETVOID;
+ return;
}
rgSCHCmnDlSch(cell);
}
- RETVOID;
+ return;
}
/** @brief This function invokes Consolidates the allocations
rgSCHTomUtlProcTA(cell);
- RETVOID;
+ return;
}
/** @brief This function prepares the DL and UL Config requests
rgSCHTomUtlProcUlSf (cell, &err);
#endif
- RETVOID;
+ return;
}
#ifdef LTE_TDD
/** @brief This function prepares does the Downlink subframe re-init and
rgSCHDhmTddRlsSubFrm(cell, cell->hqRlsTime);
rgSCHDhmRlsDlsfHqProc(cell, cell->hqRlsTime);
}
- RETVOID;
+ return;
}
/** @brief This function processes the UL subframe and fills TFU reception
}
}
- RETVOID;
+ return;
}
#endif
/* forward references */
#ifdef EMTC_ENABLE
- U32 gUlRetxPassCntr = 0;
- /*EXTERN U32 gUlRetxFailCntr;
- EXTERN U32 gUlCrcPassCounter;
- EXTERN U32 gUlCrcFailCounter;*/
+ uint32_t gUlRetxPassCntr = 0;
+ /*EXTERN uint32_t gUlRetxFailCntr;
+ EXTERN uint32_t gUlCrcPassCounter;
+ EXTERN uint32_t gUlCrcFailCounter;*/
#endif
-U8 rgRvIdxTable[] = {0, 3, 1, 2}; /* This gives rvIdx for a given rv */
-U8 rgRvTable[] = {0, 2, 3 ,1}; /* This gives rv for a given rvIdx */
+uint8_t rgRvIdxTable[] = {0, 3, 1, 2}; /* This gives rvIdx for a given rv */
+uint8_t rgRvTable[] = {0, 2, 3 ,1}; /* This gives rv for a given rvIdx */
#ifdef EMTC_ENABLE
Void rgSCHCmnEmtcHdlHarqProcFail
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo frm,
-U8 cqi
+uint8_t cqi
)
#else
Void rgSCHUhmProcDatInd(cell, ue, frm, cqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo frm;
-U8 cqi;
+uint8_t cqi;
#endif
#endif /* MAC_SCH_STATS */
{
#ifdef UL_LA
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
S32 iTbs;
- U8 maxiTbs = rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend]
+ uint8_t maxiTbs = rgSchCmnUlCqiToTbsTbl[cell->isCpUlExtend]
[ueUl->maxUlCqi];
#endif
{
printf("UE[%d] failed to find UL HqProc for [%d:%d]\n",
ue->ueId, frm.sfn, frm.slot);
- RETVOID;
+ return;
}
hqProc->rcvdCrcInd = TRUE;
}
#endif
- RETVOID;
+ return;
} /* rgSCHUhmProcDatInd */
/**
hqProc->rcvdCrcInd = TRUE;
hqProc->remTx = 0; /*Reseting the value of rem Tx*/
printf("\nrgSCHUhmProcMsg3DatInd,id:%u\n",hqProc->procId);
- RETVOID;
+ return;
} /* rgSCHUhmProcMsg3DatInd */
/**
hqProc->rcvdCrcInd = FALSE;
}
- RETVOID;
+ return;
} /* rgSCHUhmProcMsg3Failure */
/**
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo frm,
-TknU8 rv
+TknUInt8 rv
)
#else
Void rgSCHUhmProcHqFailure(cell, ue, frm, rv)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo frm;
-TknU8 rv;
+TknUInt8 rv;
#endif
#else /* MAC_SCH_STATS */
#ifdef ANSI
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteTimingInfo frm,
-TknU8 rv,
-U8 cqi
+TknUInt8 rv,
+uint8_t cqi
)
#else
Void rgSCHUhmProcHqFailure(cell, ue, frm, rv, cqi)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteTimingInfo frm;
-TknU8 rv;
-U8 cqi;
+TknUInt8 rv;
+uint8_t cqi;
#endif
#endif /* MAC_SCH_STATS */
{
{
printf("UE[%d] failed to find UL HqProc for [%d:%d]\n",
ue->ueId, frm.sfn, frm.slot);
- RETVOID;
+ return;
}
#ifdef UL_LA
{
#ifdef MAC_SCH_STATS
/** Stats update over here */
{
- static U32 retxCnt = 0;
+ static uint32_t retxCnt = 0;
++retxCnt;
hqFailStats.ulCqiStat[cqi - 1].numOfNacks++;
}
{
hqProc->rvIdxPhy.val = rgRvIdxTable[rv.val];
}
- RETVOID;
+ return;
} /* rgSCHUhmProcHqFailure */
/**
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 idx
+uint8_t idx
)
#else
RgSchUlHqProcCb* rgSCHUhmGetUlHqProc(cell, ue, idx)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 idx;
+uint8_t idx;
#endif
{
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ue, cell);
Void rgSCHUhmNewTx
(
RgSchUlHqProcCb *hqProc,
-U8 maxHqRetx,
+uint8_t maxHqRetx,
RgSchUlAlloc *alloc
)
#else
Void rgSCHUhmNewTx(hqProc, maxHqRetx, alloc)
RgSchUlHqProcCb *hqProc;
-U8 maxHqRetx;
+uint8_t maxHqRetx;
RgSchUlAlloc *alloc;
#endif
{
((RgUeUlHqCb*)hqProc->hqEnt)->numBusyHqProcs++;
}
#endif
- RETVOID;
+ return;
} /* rgSCHUhmNewTx */
/**
{
#ifdef LTE_L2_MEAS
RgSchUeCb *ueCb;
- U8 qci = 1;
+ uint8_t qci = 1;
#endif
#ifdef LTE_L2_MEAS
ueCb = hqProc->alloc->ue;
if (ueCb && cell)
{
- U32 nonLcg0ReportedBs = ((RgSchCmnLcg *)(ueCb->ul.lcgArr[1].sch))->reportedBs + \
+ uint32_t nonLcg0ReportedBs = ((RgSchCmnLcg *)(ueCb->ul.lcgArr[1].sch))->reportedBs + \
((RgSchCmnLcg *)(ueCb->ul.lcgArr[2].sch))->reportedBs + \
((RgSchCmnLcg *)(ueCb->ul.lcgArr[3].sch))->reportedBs;
((RgUeUlHqCb*)hqProc->hqEnt)->numBusyHqProcs--;
{
printf("\nhqEnt is NULL\n");
}
- RETVOID;
+ return;
} /* rgSCHUhmFreeProc */
/**
--hqProc->remTx;
hqProc->rvIdx = (hqProc->rvIdx + 1) % 4;
hqProc->rvIdxPhy.pres = FALSE;
- RETVOID;
+ return;
} /* rgSCHUhmRetx */
RgrUeCfg *ueCfg;
#endif
{
- U8 i;
+ uint8_t i;
RgSchCmnUlUe *ueUl = RG_SCH_CMN_GET_UL_UE(ueCb, cellCb);
ueUl->hqEnt.maxHqRetx = ((ueCfg->ueUlHqCfg.maxUlHqTx) - 1);
#ifdef EMTC_ENABLE
rgSCHEmtcInitUlUeHqEnt(cellCb, ueCfg, ueCb);
#endif
- RETVOID;
+ return;
} /* rgSCHUhmRgrUeCfg */
/**
ueUl->hqEnt.maxHqRetx = (ueRecfg->ueUlHqRecfg.maxUlHqTx - 1);
}
- RETVOID;
+ return;
} /* rgSCHUhmRgrUeRecfg */
/**
hqEnt->numHqPrcs * sizeof(RgSchUlHqProcCb));
#endif
- RETVOID;
+ return;
} /* rgSCHUhmFreeUe */
(
RgSchCellCb *cellCb,
CmLteTimingInfo frm,
-U8 idx
+uint8_t idx
)
#else
S16 rgSCHUhmAppendPhich (cellCb, frm, idx)
RgSchCellCb *cellCb;
CmLteTimingInfo frm;
-U8 idx;
+uint8_t idx;
#endif
{
- U8 nDmrs;
- U8 rbStart;
+ uint8_t nDmrs;
+ uint8_t rbStart;
#ifdef LTE_TDD
- U8 iPhich;
+ uint8_t iPhich;
#endif
RgSchUlAlloc *ulAlloc;
#ifdef LTEMAC_HDFDD
/* SR_RACH_STATS */
-U32 rgNumPrachRecvd =0; /* Num of Rach Req received including dedicated preambles */
-U32 rgNumRarSched =0; /* Num of RARs sent */
-U32 rgNumBI =0; /* Num of BackOff Ind sent */
-U32 rgNumMsg3CrcPassed =0; /* Num of CRC success for Msg3 */
-U32 rgNumMsg3CrcFailed =0; /* Num of CRC fail for Msg 3 */
-U32 rgNumMsg3FailMaxRetx =0; /* Num of Msg3 fail after Max Retx attempts */
-U32 rgNumMsg4Ack =0; /* Num of Acks for Msg4 Tx */
-U32 rgNumMsg4Nack =0;
+uint32_t rgNumPrachRecvd =0; /* Num of Rach Req received including dedicated preambles */
+uint32_t rgNumRarSched =0; /* Num of RARs sent */
+uint32_t rgNumBI =0; /* Num of BackOff Ind sent */
+uint32_t rgNumMsg3CrcPassed =0; /* Num of CRC success for Msg3 */
+uint32_t rgNumMsg3CrcFailed =0; /* Num of CRC fail for Msg 3 */
+uint32_t rgNumMsg3FailMaxRetx =0; /* Num of Msg3 fail after Max Retx attempts */
+uint32_t rgNumMsg4Ack =0; /* Num of Acks for Msg4 Tx */
+uint32_t rgNumMsg4Nack =0;
/* Num of Nacks for Msg4 Tx */
-U32 rgNumMsg4FailMaxRetx =0; /* Num of Msg4 Tx failed after Max Retx attempts */
-U32 rgNumSrRecvd =0; /* Num of Sched Req received */
-U32 rgNumSrGrant =0; /* Num of Sched Req Grants sent */
-U32 rgNumMsg3CrntiCE =0; /* Num of Msg 3 CRNTI CE received */
-U32 rgNumDedPream =0; /* Num of Dedicated Preambles recvd */
-U32 rgNumMsg3CCCHSdu =0; /* Num of Msg 3 CCCH Sdus recvd */
-U32 rgNumCCCHSduCrntiNotFound =0; /*UE Ctx not found for CCCH SDU Msg 3 */
-U32 rgNumCrntiCeCrntiNotFound =0; /*UE Ctx not found for CRNTI CE Msg 3 */
-U32 rgNumMsg4WithCCCHSdu =0; /* Num of Msg4 with CCCH Sdu */
-U32 rgNumMsg4WoCCCHSdu =0; /* Num of Msg4 without CCCH Sdu */
-U32 rgNumMsg4Dtx =0; /* Num of DTX received for Msg 4 */
-U32 rgNumMsg3AckSent =0; /* Num of PHICH Ack sent for Msg 3 */
-U32 rgNumMsg3NackSent =0; /* Num of PHICH Nack sent for Msg 3 */
-U32 rgNumMsg4PdcchWithCrnti =0; /* Num of PDCCH for CRNTI based contention resolution */
-U32 rgNumRarFailDuetoRntiExhaustion =0; /* Num of RACH Failures due to RNTI pool exhaution */
-U32 rgNumTAModified =0; /* Num of times TA received is different from prev value */
-U32 rgNumTASent =0; /* Num of TA Command sent */
-U32 rgNumMsg4ToBeTx =0; /* Num of times MSG4 that should be sent */
-U32 rgNumMsg4Txed =0; /* Num of MSG4 actually sent *//* ysNumMsg4ToBeTx -ysNumMsg4Txed == Failed MSG4 TX */
-U32 rgNumMsg3DtxRcvd =0; /* CRC Fail with SINR < 0 */
-
-U32 rgNumDedPreamUECtxtFound =0; /* Num of Dedicated Preambles recvd */
-
-PRIVATE U8 rgSchDciAmbigSizeTbl[61] = {0,0,0,0,0,0,0,0,0,0,0,
+uint32_t rgNumMsg4FailMaxRetx =0; /* Num of Msg4 Tx failed after Max Retx attempts */
+uint32_t rgNumSrRecvd =0; /* Num of Sched Req received */
+uint32_t rgNumSrGrant =0; /* Num of Sched Req Grants sent */
+uint32_t rgNumMsg3CrntiCE =0; /* Num of Msg 3 CRNTI CE received */
+uint32_t rgNumDedPream =0; /* Num of Dedicated Preambles recvd */
+uint32_t rgNumMsg3CCCHSdu =0; /* Num of Msg 3 CCCH Sdus recvd */
+uint32_t rgNumCCCHSduCrntiNotFound =0; /*UE Ctx not found for CCCH SDU Msg 3 */
+uint32_t rgNumCrntiCeCrntiNotFound =0; /*UE Ctx not found for CRNTI CE Msg 3 */
+uint32_t rgNumMsg4WithCCCHSdu =0; /* Num of Msg4 with CCCH Sdu */
+uint32_t rgNumMsg4WoCCCHSdu =0; /* Num of Msg4 without CCCH Sdu */
+uint32_t rgNumMsg4Dtx =0; /* Num of DTX received for Msg 4 */
+uint32_t rgNumMsg3AckSent =0; /* Num of PHICH Ack sent for Msg 3 */
+uint32_t rgNumMsg3NackSent =0; /* Num of PHICH Nack sent for Msg 3 */
+uint32_t rgNumMsg4PdcchWithCrnti =0; /* Num of PDCCH for CRNTI based contention resolution */
+uint32_t rgNumRarFailDuetoRntiExhaustion =0; /* Num of RACH Failures due to RNTI pool exhaution */
+uint32_t rgNumTAModified =0; /* Num of times TA received is different from prev value */
+uint32_t rgNumTASent =0; /* Num of TA Command sent */
+uint32_t rgNumMsg4ToBeTx =0; /* Num of times MSG4 that should be sent */
+uint32_t rgNumMsg4Txed =0; /* Num of MSG4 actually sent *//* ysNumMsg4ToBeTx -ysNumMsg4Txed == Failed MSG4 TX */
+uint32_t rgNumMsg3DtxRcvd =0; /* CRC Fail with SINR < 0 */
+
+uint32_t rgNumDedPreamUECtxtFound =0; /* Num of Dedicated Preambles recvd */
+
+PRIVATE uint8_t rgSchDciAmbigSizeTbl[61] = {0,0,0,0,0,0,0,0,0,0,0,
0,1,0,1,0,1,0,0,0,1,
0,0,0,1,0,1,0,0,0,0,
0,1,0,0,0,0,0,0,0,1,
/* local defines */
-EXTERN U32 rgSchCmnBetaCqiOffstTbl[16];
-EXTERN U32 rgSchCmnBetaRiOffstTbl[16];
+EXTERN uint32_t rgSchCmnBetaCqiOffstTbl[16];
+EXTERN uint32_t rgSchCmnBetaRiOffstTbl[16];
EXTERN RgSchdApis rgSchCmnApis;
EXTERN S16 RgUiRgmSendPrbRprtInd ARGS((
Pst* pst,
EXTERN Void rgSCHEmtcUtlRlsRnti ARGS((
RgSchCellCb *cell,
RgSchRntiLnk *rntiLnk,
-U8 *isLegacy
+uint8_t *isLegacy
));
EXTERN S16 rgSCHEmtcPdcchAlloc ARGS((
RgSchCellCb *cell,
/* Functions specific to TM1/TM2/TM6/TM7 for PRB calculation*/
Void rgSchUtlDlCalc1CwPrb ARGS(( RgSchCellCb *cell,
RgSchUeCb *ue,
- U32 bo,
- U32 *prbReqrd));
+ uint32_t bo,
+ uint32_t *prbReqrd));
/* Functions specific to TM3/TM4 for PRB calculation*/
Void rgSchUtlDlCalc2CwPrb ARGS(( RgSchCellCb *cell,
RgSchUeCb *ue,
- U32 bo,
- U32 *prbReqrd));
+ uint32_t bo,
+ uint32_t *prbReqrd));
#ifdef LTE_ADV
RgSchCellCb* rgSchUtlGetCellCb ARGS(( Inst inst,
- U16 cellId
+ uint16_t cellId
));
#endif
typedef Void (*RgSchUtlDlCalcPrbFunc) ARGS((RgSchCellCb *cell, RgSchUeCb *ue,
- U32 bo, U32 *prbRequrd));
+ uint32_t bo, uint32_t *prbRequrd));
#ifndef LTE_ADV
/* Functions specific to each transmission mode for PRB calculation*/
RgSchUtlDlCalcPrbFunc dlCalcPrbFunc[7] = {rgSchUtlDlCalc1CwPrb,
#ifdef LTE_TDD
/* The below table will be used to map the UL SF number in a TDD Cfg 0
frame to the ul Sf array maintained in cellCb */
-PRIVATE U8 rgSchTddCfg0UlSfTbl[] = {2, 3, 4, 7, 8, 9};
+PRIVATE uint8_t rgSchTddCfg0UlSfTbl[] = {2, 3, 4, 7, 8, 9};
#endif
PRIVATE S16 rgSCHUtlUlAllocDbInit ARGS((
RgSchCellCb *cell,
RgSchUlAllocDb *db,
- U8 maxAllocs
+ uint8_t maxAllocs
));
PRIVATE Void rgSCHUtlUlAllocDbDeinit ARGS((
RgSchCellCb *cell,
PRIVATE S16 rgSCHUtlUlHoleDbInit ARGS((
RgSchCellCb *cell,
RgSchUlHoleDb *db,
- U8 maxHoles,
- U8 start,
- U8 num
+ uint8_t maxHoles,
+ uint8_t start,
+ uint8_t num
));
PRIVATE Void rgSCHUtlUlHoleDbDeinit ARGS((
RgSchCellCb *cell,
));
#ifdef UNUSE_FUN
#ifdef TFU_UPGRADE
-PRIVATE U8 rgSCHUtlFetchPcqiBitSz ARGS((
+PRIVATE uint8_t rgSCHUtlFetchPcqiBitSz ARGS((
RgSchCellCb *cell,
- RgSchUeCb *ueCb,
- U8 numTxAnt
+ RgSchUeCb *ueCb,
+ uint8_t numTxAnt
));
#endif
#endif
/* sorted in ascending order of tbSz */
CONSTANT struct rgSchUtlBcchPcchTbSz
{
- U8 rbIndex; /* RB index {2,3} */
- U16 tbSz; /* one of the Transport block size in bits of
+ uint8_t rbIndex; /* RB index {2,3} */
+ uint16_t tbSz; /* one of the Transport block size in bits of
* rbIndex 2 or 3 */
/* Corrected allocation for common channels */
- U8 mcs; /* imcs */
+ uint8_t mcs; /* imcs */
} rgSchUtlBcchPcchTbSzTbl[44] = {
{ 2, 32, 0 }, { 2, 56, 1 }, { 2, 72, 2 }, { 3, 88, 1 },
{ 2, 104, 3 }, { 2, 120, 4 }, { 2, 144, 5 }, { 2, 176, 6 },
}
#ifdef TFU_UPGRADE
-#define RGSCH_GETBIT(a, b) ((((U8*)a)[(b)>>3] >> ((7-((b)&7)))) & 1)
+#define RGSCH_GETBIT(a, b) ((((uint8_t*)a)[(b)>>3] >> ((7-((b)&7)))) & 1)
/*
*
*
*/
#ifdef ANSI
-U32 rgSCHUtlParse
+uint32_t rgSCHUtlParse
(
-U8 *buff,
-U8 startPos,
-U8 endPos,
-U8 buffSize
+uint8_t *buff,
+uint8_t startPos,
+uint8_t endPos,
+uint8_t buffSize
)
#else
-U32 rgSCHUtlParse(buff, startPos, endPos, buffSize)
-U8 *buff;
-U8 startPos;
-U8 endPos;
-U8 buffSize;
+uint32_t rgSCHUtlParse(buff, startPos, endPos, buffSize)
+uint8_t *buff;
+uint8_t startPos;
+uint8_t endPos;
+uint8_t buffSize;
#endif
{
- U8 pointToChar,pointToEnd, loop;
- U8 size = endPos - startPos;
+ uint8_t pointToChar,pointToEnd, loop;
+ uint8_t size = endPos - startPos;
F64 result = 0;
pointToEnd = (startPos)%8;
for ( loop=0; loop<size; loop++)
}
pointToEnd++;
}
- return ((U32)result);
+ return ((uint32_t)result);
} /* end of rgSCHUtlParse*/
/*
*
*/
#ifdef ANSI
-U8 rgSCHUtlFindDist
+uint8_t rgSCHUtlFindDist
(
-U16 crntTime,
-U16 tempIdx
+uint16_t crntTime,
+uint16_t tempIdx
)
#else
-U8 rgSCHUtlFindDist(crntTime, tempIdx)
-U16 crntTime;
-U16 tempIdx;
+uint8_t rgSCHUtlFindDist(crntTime, tempIdx)
+uint16_t crntTime;
+uint16_t tempIdx;
#endif
{
- U8 dist =0;
+ uint8_t dist =0;
/* ccpu00137113- Distance is not estimated properly if the periodicity is
* equal to RG_SCH_PCQI_SRS_SR_TRINS_SIZE.
*/
*
* @param[in] RgSchCellCb* cell
* @param[in] RgSchPdcchInfo* pdcchInfo
- * @param[in] U8 loc
- * @param[in] U8 aggrLvl
+ * @param[in] uint8_t loc
+ * @param[in] uint8_t aggrLvl
* @param[out] RgSchPdcch** pdcch
* @return Boolean
* -# TRUE if available
RgSchPdcch **pdcch;
#endif
{
- U8 *byte;
- U16 offset;
- U16 initMask;
- U16 currMask;
+ uint8_t *byte;
+ uint16_t offset;
+ uint16_t initMask;
+ uint16_t currMask;
Inst inst = cell->instIdx;
S16 ret;
- U16 offsetStepMask;
+ uint16_t offsetStepMask;
/* V5G_213 : 10.1 */
offset = 0;
* Invoked by: scheduler
*
* @param[in] RgSchPdcchInfo* pdcchInfo
- * @param[in] U8 loc
- * @param[in] U8 aggrLvl
+ * @param[in] uint8_t loc
+ * @param[in] uint8_t aggrLvl
* @return Void
*
**/
RgSchPdcch *pdcch;
#endif
{
- U8 *byte;
- U8 offset;
+ uint8_t *byte;
+ uint8_t offset;
uint16_t mask;
switch(pdcch->aggrLvl)
mask = 0xffff;
break;
default:
- RETVOID;
+ return;
}
/* Placing common computation of byte from all the cases above here
for optimization */
pdcch->ue = NULLP;
(*byte) &= ~mask;
- RETVOID;
+ return;
}
\f
(
RgSchCellCb *cell,
RgSchDlSf *subFrm,
-U16 nCce
+uint16_t nCce
)
#else
Void rgSCHUtlPdcchInit(cell, subFrm, nCce)
RgSchCellCb *cell;
RgSchDlSf *subFrm;
-U16 nCce;
+uint16_t nCce;
#endif
{
RgSchPdcchInfo *pdcchInfo;
RgSchPdcch *pdcch;
Inst inst = cell->instIdx;
- U8 extraBits;
- U32 cceMapSz;
+ uint8_t extraBits;
+ uint32_t cceMapSz;
pdcchInfo = &subFrm->pdcchInfo;
while(pdcchInfo->pdcchs.first != NULLP)
if (pdcchInfo->map == NULLP)
{
/* Generate log error here */
- RETVOID;
+ return;
}
}
extraBits = (cceMapSz)*8 - pdcchInfo->nCce;
subFrm->pdcchInfo.map[cceMapSz - 1] |=
((1 << extraBits) - 1) << (8 - extraBits);
- RETVOID;
+ return;
}
/* LTE_ADV_FLAG_REMOVED_START */
(
TknStrOSXL *rntpPtr,
RgSchCellCb *cell,
- U16 bw
+ uint16_t bw
)
#else
PRIVATE Void rgSchDSFRRntpInfoInit(rntpPtr, cell, bw)
TknStrOSXL *rntpPtr;
RgSchCellCb *cell;
- U16 bw;
+ uint16_t bw;
#endif
{
Inst inst = cell->instIdx;
- U16 len;
+ uint16_t len;
rntpPtr->pres = PRSNT_NODEF;
/* Allocate memory for "scheduled UE" Info */
if((rgSCHUtlAllocSBuf(inst, (Data**)&(rntpPtr->val),
- (len * sizeof(U8)))) != ROK)
+ (len * sizeof(uint8_t)))) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED for RNTP Alloc");
return RFAILED;
(
TknStrOSXL *rntpPtr,
RgSchCellCb *cell,
- U16 bw
+ uint16_t bw
)
#else
PRIVATE Void rgSchDSFRRntpInfoFree(rntpPtr, cell, bw)
TknStrOSXL *rntpPtr;
RgSchCellCb *cell;
- U16 bw;
+ uint16_t bw;
#endif
{
Inst inst = cell->instIdx;
- U16 len;
+ uint16_t len;
len = (bw % 8 == 0) ? (bw/8) : (bw/8 + 1);
if(rntpPtr->pres == PRSNT_NODEF)
{
- rgSCHUtlFreeSBuf(inst, (Data **)(&(rntpPtr->val)),(len * sizeof(U8)));
+ rgSCHUtlFreeSBuf(inst, (Data **)(&(rntpPtr->val)),(len * sizeof(uint8_t)));
rntpPtr->pres = NOTPRSNT;
rntpPtr->len = 0;
}
pool->type2Start = pool->poolstartRB;
pool->bw = pool->poolendRB - pool->poolstartRB + 1;
- RETVOID;
+ return;
}
/**
* @brief This function resets SFR Pool information for frame
totalPoolInfo->CEPoolBwAvlbl = tempPool->bw;
}
- RETVOID;
+ return;
}
/* LTE_ADV_FLAG_REMOVED_END */
/**
*
* @param[in] RgSchCellCb* cell
* @param[in] RgSubFrm* subFrm
- * @param[in] U8 hqFeedBack
- * @param[in] U8 nDmrs
- * @param[in] U8 rbStart
+ * @param[in] uint8_t hqFeedBack
+ * @param[in] uint8_t nDmrs
+ * @param[in] uint8_t rbStart
* @return S16
* -# ROK
* -# RFAILED
(
RgSchCellCb *cell,
CmLteTimingInfo frm,
-U8 hqFeedBack,
-U8 nDmrs,
-U8 rbStart,
-U8 iPhich
+uint8_t hqFeedBack,
+uint8_t nDmrs,
+uint8_t rbStart,
+uint8_t iPhich
)
#else
S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, iPhich)
RgSchCellCb *cell;
CmLteTimingInfo frm;
-U8 hqFeedBack;
-U8 nDmrs;
-U8 rbStart;
-U8 iPhich;
+uint8_t hqFeedBack;
+uint8_t nDmrs;
+uint8_t rbStart;
+uint8_t iPhich;
#endif
#else
#ifdef ANSI
(
RgSchCellCb *cell,
CmLteTimingInfo frm,
-U8 hqFeedBack,
-U8 nDmrs,
-U8 rbStart,
+uint8_t hqFeedBack,
+uint8_t nDmrs,
+uint8_t rbStart,
Bool isForMsg3
)
#else
S16 rgSCHUtlAddPhich(cell, frm, hqFeedBack, nDmrs, rbStart, isForMsg3)
RgSchCellCb *cell;
CmLteTimingInfo frm;
-U8 hqFeedBack;
-U8 nDmrs;
-U8 rbStart;
+uint8_t hqFeedBack;
+uint8_t nDmrs;
+uint8_t rbStart;
Bool isForMsg3;
#endif
#endif
RGSCH_PHICH_FREE(cell->instIdx, phich, sizeof(RgSchPhich));
}
cmLListInit(&phichInfo->phichs);
- RETVOID;
+ return;
} /* rgSCHUtlPhichReset */
\f
#endif
{
RgSchDlSf *sf;
- U8 dlIdx;
+ uint8_t dlIdx;
#ifdef LTE_TDD
dlIdx = rgSCHUtlGetDlSfIdx(cell, &frm);
RgSchDlSf *sf;
#endif
{
- U8 i;
- U8 noRaRsps;
+ uint8_t i;
+ uint8_t noRaRsps;
#ifdef LTE_TDD
/* Release all the held PDCCH information */
sf->cceCnt = 0;
sf->isCceFailure = FALSE;
sf->dlUlBothCmplt = 0;
- RETVOID;
+ return;
}
\f
*
* Invoked by: Scheduler
*
- * @param[in] U32 n
- * @return U8
+ * @param[in] uint32_t n
+ * @return uint8_t
*
**/
#ifdef ANSI
-U8 rgSCHUtlLog32bitNbase2
+uint8_t rgSCHUtlLog32bitNbase2
(
-U32 n
+uint32_t n
)
#else
-U8 rgSCHUtlLog32bitNbase2(n)
-U32 n;
+uint8_t rgSCHUtlLog32bitNbase2(n)
+uint32_t n;
#endif
{
- U32 b[] = {0x2, 0xc, 0xf0, 0xff00, 0xffff0000};
- U32 s[] = {1, 2, 4, 8, 16};
- S16 i;
- U8 ret = 0;
+ uint32_t b[] = {0x2, 0xc, 0xf0, 0xff00, 0xffff0000};
+ uint32_t s[] = {1, 2, 4, 8, 16};
+ S16 i;
+ uint8_t ret = 0;
for (i=4; i >= 0; i--)
{
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 isAck
+ * @param[in] uint8_t isAck
* @return Void
*
**/
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 isAck
+uint8_t isAck
)
#else
Void rgSCHUtlDlRelPdcchFbk(cell, ue, isAck)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 isAck;
+uint8_t isAck;
#endif
{
cell->sc.apis->rgSCHDlRelPdcchFbk(cell, ue, isAck);
- RETVOID;
+ return;
}
#endif
{
cell->sc.apis->rgSCHDlProcAck(cell, hqP);
- RETVOID;
+ return;
}
/**
{
cell->sc.apis->rgSCHHdlCrntiCE(cell, ue);
- RETVOID;
+ return;
} /* rgSCHUtlHdlCrntiCE */
#endif /* LTEMAC_SPS */
* Desc : Calculate total REGs, given a bandwidth, CFI
* and number of antennas.
*
- * Ret : Total REGs (U16)
+ * Ret : Total REGs (uint16_t)
*
* Notes: Could optimise if bw values are limited
* (taken from RRC spec) by indexing values from
*
**********************************************************/
#ifdef ANSI
-PRIVATE U16 rgSCHUtlCalcTotalRegs
+PRIVATE uint16_t rgSCHUtlCalcTotalRegs
(
-U8 bw,
-U8 cfi,
-U8 numAntna,
+uint8_t bw,
+uint8_t cfi,
+uint8_t numAntna,
Bool isEcp
)
#else
-PRIVATE U16 rgSCHUtlCalcTotalRegs(bw, cfi, numAntna, isEcp)
-U8 bw;
-U8 cfi;
-U8 numAntna;
+PRIVATE uint16_t rgSCHUtlCalcTotalRegs(bw, cfi, numAntna, isEcp)
+uint8_t bw;
+uint8_t cfi;
+uint8_t numAntna;
Bool isEcp;
#endif
{
- U16 regs = 0;
+ uint16_t regs = 0;
/*ccpu00116757- removed check for (ERRCLASS & ERRCLS_DEBUG)*/
*
* Desc : Calculates number of PHICH REGs
*
- * Ret : Number of PHICH REGs (U8)
+ * Ret : Number of PHICH REGs (uint8_t)
*
* Notes: ng6 is Ng multiplied by 6
*
*
**********************************************************/
#ifdef ANSI
-PRIVATE U16 rgSCHUtlCalcPhichRegs
+PRIVATE uint16_t rgSCHUtlCalcPhichRegs
(
-U8 bw,
-U8 ng6
+uint8_t bw,
+uint8_t ng6
)
#else
-PRIVATE U16 rgSCHUtlCalcPhichRegs(bw, ng6)
-U8 bw;
-U8 ng6;
+PRIVATE uint16_t rgSCHUtlCalcPhichRegs(bw, ng6)
+uint8_t bw;
+uint8_t ng6;
#endif
{
/* ccpu00115330: Corrected the calculation for number of PHICH groups*/
*
* Invoked by: Scheduler
*
- * @param[in] U8 bw
- * @param[in] U8 ng6
- * @param[in] U8 cfi
- * @param[in] U8 mPhich
- * @param[in] U8 numAntna
+ * @param[in] uint8_t bw
+ * @param[in] uint8_t ng6
+ * @param[in] uint8_t cfi
+ * @param[in] uint8_t mPhich
+ * @param[in] uint8_t numAntna
* @param[in] Bool isEcp
- * @return N_cce (U8)
+ * @return N_cce (uint8_t)
*
**/
#ifdef ANSI
-U8 rgSCHUtlCalcNCce
+uint8_t rgSCHUtlCalcNCce
(
-U8 bw,
+uint8_t bw,
RgrPhichNg ng,
-U8 cfi,
-U8 mPhich,
-U8 numAntna,
+uint8_t cfi,
+uint8_t mPhich,
+uint8_t numAntna,
Bool isEcp
)
#else
-U8 rgSCHUtlCalcNCce(bw, ng, cfi, mPhich, numAntna, isEcp)
-U8 bw;
+uint8_t rgSCHUtlCalcNCce(bw, ng, cfi, mPhich, numAntna, isEcp)
+uint8_t bw;
RgrPhichNg ng;
-U8 cfi;
-U8 mPhich;
-U8 numAntna;
+uint8_t cfi;
+uint8_t mPhich;
+uint8_t numAntna;
Bool isEcp;
#endif
{
- U16 totalRegs;
- U16 phichRegs;
- U16 cceRegs;
- U8 ng6;
+ uint16_t totalRegs;
+ uint16_t phichRegs;
+ uint16_t cceRegs;
+ uint8_t ng6;
/*ccpu00116757- removed check for (ERRCLASS & ERRCLS_DEBUG)*/
phichRegs = rgSCHUtlCalcPhichRegs(bw, ng6);
cceRegs = totalRegs - mPhich*phichRegs - RGSCH_NUM_PCFICH_REG;
- return ((U8)(cceRegs/RGSCH_NUM_REG_PER_CCE));
+ return ((uint8_t)(cceRegs/RGSCH_NUM_REG_PER_CCE));
}
#else
*
* Invoked by: Scheduler
*
- * @param[in] U8 bw
- * @param[in] U8 ng6
- * @param[in] U8 cfi
- * @param[in] U8 numAntna
- * @return N_cce (U8)
+ * @param[in] uint8_t bw
+ * @param[in] uint8_t ng6
+ * @param[in] uint8_t cfi
+ * @param[in] uint8_t numAntna
+ * @return N_cce (uint8_t)
*
**/
#ifdef ANSI
-U8 rgSCHUtlCalcNCce
+uint8_t rgSCHUtlCalcNCce
(
-U8 bw,
+uint8_t bw,
RgrPhichNg ng,
-U8 cfi,
-U8 numAntna,
+uint8_t cfi,
+uint8_t numAntna,
Bool isEcp
)
#else
-U8 rgSCHUtlCalcNCce(bw, ng, cfi, numAntna, isEcp)
-U8 bw;
+uint8_t rgSCHUtlCalcNCce(bw, ng, cfi, numAntna, isEcp)
+uint8_t bw;
RgrPhichNg ng;
-U8 cfi;
-U8 numAntna;
+uint8_t cfi;
+uint8_t numAntna;
Bool isEcp;
#endif
{
- U16 totalRegs;
- U16 phichRegs;
- U16 cceRegs;
- U8 ng6;
+ uint16_t totalRegs;
+ uint16_t phichRegs;
+ uint16_t cceRegs;
+ uint8_t ng6;
/*ccpu00116757- removed check for (ERRCLASS & ERRCLS_DEBUG)*/
phichRegs = rgSCHUtlCalcPhichRegs(bw, ng6);
cceRegs = totalRegs - phichRegs - RGSCH_NUM_PCFICH_REG;
- return ((U8)(cceRegs/RGSCH_NUM_REG_PER_CCE));
+ return ((uint8_t)(cceRegs/RGSCH_NUM_REG_PER_CCE));
}
#endif
* comprises RB start and N_dmrs.
*
* @param[in] RgSchUlHqProcCb *hqProc
- * @param[out] U8 *rbStartRef
- * @param[out] U8 *nDmrsRef
+ * @param[out] uint8_t *rbStartRef
+ * @param[out] uint8_t *nDmrsRef
* @return S16
**/
#ifdef LTE_TDD
S16 rgSCHUtlGetPhichInfo
(
RgSchUlHqProcCb *hqProc,
-U8 *rbStartRef,
-U8 *nDmrsRef,
-U8 *iPhich
+uint8_t *rbStartRef,
+uint8_t *nDmrsRef,
+uint8_t *iPhich
)
#else
S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef, iPhich)
RgSchUlHqProcCb *hqProc;
-U8 *rbStartRef;
-U8 *nDmrsRef;
-U8 *iPhich;
+uint8_t *rbStartRef;
+uint8_t *nDmrsRef;
+uint8_t *iPhich;
#endif
#else
#ifdef ANSI
S16 rgSCHUtlGetPhichInfo
(
RgSchUlHqProcCb *hqProc,
-U8 *rbStartRef,
-U8 *nDmrsRef
+uint8_t *rbStartRef,
+uint8_t *nDmrsRef
)
#else
S16 rgSCHUtlGetPhichInfo(hqProc, rbStartRef, nDmrsRef)
RgSchUlHqProcCb *hqProc;
-U8 *rbStartRef;
-U8 *nDmrsRef;
+uint8_t *rbStartRef;
+uint8_t *nDmrsRef;
#endif
#endif
{
* - RV
*
* @param[in] RgSchUlAlloc *alloc
- * @param[out] U8 *rbStartRef
- * @param[out] U8 *numRbRef
- * @param[out] U8 *rvRef
- * @param[out] U16 *size
+ * @param[out] uint8_t *rbStartRef
+ * @param[out] uint8_t *numRbRef
+ * @param[out] uint8_t *rvRef
+ * @param[out] uint16_t *size
* @param[out] TfuModScheme *modType
* @param[out] Bool *isRtx
- * @param[out] U8 *nDmrs
+ * @param[out] uint8_t *nDmrs
* @param[out] Bool *ndi
- * @param[out] U8 *hqPId
+ * @param[out] uint8_t *hqPId
* @return S16
**/
#ifdef ANSI
(
RgSchUlAlloc *alloc,
CmLteRnti *rnti,
-U8 *iMcsRef,
-U8 *rbStartRef,
-U8 *numRbRef,
-U8 *rvRef,
-U16 *size,
+uint8_t *iMcsRef,
+uint8_t *rbStartRef,
+uint8_t *numRbRef,
+uint8_t *rvRef,
+uint16_t *size,
TfuModScheme *modType,
Bool *isRtx,
-U8 *nDmrs,
+uint8_t *nDmrs,
Bool *ndi,
-U8 *hqPId
+uint8_t *hqPId
)
#else
S16 rgSCHUtlAllocRcptInfo(alloc, rnti, iMcsRef, rbStartRef, numRbRef,
hqPId)
RgSchUlAlloc *alloc;
CmLteRnti *rnti;
-U8 *iMcsRef;
-U8 *rbStartRef;
-U8 *numRbRef;
-U8 *rvRef;
-U16 *size;
+uint8_t *iMcsRef;
+uint8_t *rbStartRef;
+uint8_t *numRbRef;
+uint8_t *rvRef;
+uint16_t *size;
TfuModScheme *modType;
Bool *isRtx;
-U8 *nDmrs;
+uint8_t *nDmrs;
Bool *ndi;
-U8 *hqPId;
+uint8_t *hqPId;
#endif
{
/* Modulation order for 16qam UEs would be
* - RV
*
* @param[in] RgSchUlAlloc *alloc
- * @param[out] U8 *rbStartRef
- * @param[out] U8 *numRbRef
- * @param[out] U8 *rvRef
- * @param[out] U16 *size
+ * @param[out] uint8_t *rbStartRef
+ * @param[out] uint8_t *numRbRef
+ * @param[out] uint8_t *rvRef
+ * @param[out] uint16_t *size
* @param[out] TfuModScheme *modType
* @return S16
**/
RgrTddPrachInfo *cellCfg;
#endif
{
- U8 idx;
- U8 count = 0;
- U8 size;
- U8 startIdx;
- U8 endIdx;
+ uint8_t idx;
+ uint8_t count = 0;
+ uint8_t size;
+ uint8_t startIdx;
+ uint8_t endIdx;
/* In the 1st half frame */
if(cellCfg->halfFrm == 0)
count ++;
}
}
- RETVOID;
+ return;
}
/**
RgrCellCfg *cellCfg;
#endif
{
- U8 idx;
- U8 subfrmIdx;
- U8 splFrm;
+ uint8_t idx;
+ uint8_t subfrmIdx;
+ uint8_t splFrm;
if(cellCfg->prachRscInfo.numRsc <= 0)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "Invalid"
"PRACH resources Configuration ");
- RETVOID;
+ return;
}
/* Update SFN occasions */
}
}
}
- RETVOID;
+ return;
}
/**
RgSchErrInfo *errInfo;
#endif
{
- U8 i;
- U8 sfn=0;
- U8 sfNum = 0;
+ uint8_t i;
+ uint8_t sfn=0;
+ uint8_t sfNum = 0;
RgSchDlSf *sf;
CmLteTimingInfo frm;
- U8 ulDlCfgIdx = cellCfg->ulDlCfgIdx;
- U8 maxslots ;
- U8 maxDlslots;
+ uint8_t ulDlCfgIdx = cellCfg->ulDlCfgIdx;
+ uint8_t maxslots ;
+ uint8_t maxDlslots;
S16 ret = ROK;
- U16 bw; /*!< Number of RBs in the cell */
+ uint16_t bw; /*!< Number of RBs in the cell */
memset(&frm,0,sizeof(CmLteTimingInfo));
RgSchErrInfo *errInfo;
#endif
{
- U8 i;
+ uint8_t i;
RgSchDlSf *sf;
CmLteTimingInfo frm;
S16 ret;
Inst inst = cell->instIdx;
/* LTE_ADV_FLAG_REMOVED_START */
- U16 len;
- len = (U16)((cell->bwCfg.dlTotalBw % 8 == 0) ? (cell->bwCfg.dlTotalBw/8) : (cell->bwCfg.dlTotalBw/8 + 1)); /*KW fix for LTE_ADV */
+ uint16_t len;
+ len = (uint16_t)((cell->bwCfg.dlTotalBw % 8 == 0) ? (cell->bwCfg.dlTotalBw/8) : (cell->bwCfg.dlTotalBw/8 + 1)); /*KW fix for LTE_ADV */
/* LTE_ADV_FLAG_REMOVED_END */
memset(&frm,0,sizeof(CmLteTimingInfo));
if (cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE)
{
if((rgSCHUtlAllocSBuf(inst, (Data**)&(cell->rntpAggrInfo.val),
- (len * sizeof(U8)))) != ROK)
+ (len * sizeof(uint8_t)))) != ROK)
{
RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"Memory allocation FAILED for RNTP Alloc");
return RFAILED;
RgSchCellCb *cell;
#endif
{
- U8 i;
+ uint8_t i;
CmLListCp *lst;
RgSchPdcch *pdcch;
RgSchPdcchInfo *pdcchInfo;
RgSchPhichInfo *phichInfo;
RgSchPhich *phich;
Inst inst = cell->instIdx;
- U8 maxslots;
+ uint8_t maxslots;
#ifdef LTE_TDD
RgSchRaReqInfo *raReqInfo;
- U8 idx;
+ uint8_t idx;
#endif
#ifdef LTE_TDD
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
* @param[in] CmLteLcId lcId
- * @param[in] U8 lcgId
+ * @param[in] uint8_t lcgId
* @return S16
*
**/
RgSchCellCb *cell,
RgSchUeCb *ue,
CmLteLcId lcId,
-U8 lcgId
+uint8_t lcgId
)
#else
S16 rgSCHUtlRgrLcDel(cell, ue, lcId, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
CmLteLcId lcId;
-U8 lcgId;
+uint8_t lcgId;
#endif
{
cell->sc.apis->rgSCHRgrLchDel(cell, ue, lcId, lcgId);
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 lcgId
+uint8_t lcgId
)
#else
Void rgSCHUtlRgrLcgDel(cell, ue, lcgId)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 lcgId;
+uint8_t lcgId;
#endif
{
cell->sc.apis->rgSCHFreeLcg(cell, ue, &ue->ul.lcgArr[lcgId]);
/* Stack Crash problem for TRACE5 changes. added the return below . */
- RETVOID;
+ return;
} /* rgSCHUtlRgrLcgDel */
{
ue->mimoInfo.doa.pres = PRSNT_NODEF;
ue->mimoInfo.doa.val = doaRpt->doa;
- RETVOID;
+ return;
}
\f
/**
}
else
{
- U32 idx;
+ uint32_t idx;
for (idx = 0; idx < dlCqiRpt->dlCqiInfo.pusch.numOfCells; idx++)
{
sCellCb = ue->cellInfo[dlCqiRpt->dlCqiInfo.pusch.puschCqi[idx].cellIdx]->cell;
(Void *)&dlCqiRpt->dlCqiInfo.pusch.puschCqi[idx], timingInfo);
}
}
- RETVOID;
+ return;
}
\f
#endif
{
cell->sc.apis->rgSCHSrsInd(cell, ue, srsRpt, timingInfo);
- RETVOID;
+ return;
}
#endif
#endif
{
cell->sc.apis->rgSCHDlTARpt(cell, ue);
- RETVOID;
+ return;
}
\f
#endif
{
cell->sc.apis->rgSCHDlRlsSubFrm(cell, subFrm);
- RETVOID;
+ return;
}
#ifdef TFU_UPGRADE
* grant req for APERCQI to SCH.
*
* @param[in] RgSchUeCb *ue
- * @param[in] U8 isAck
+ * @param[in] uint8_t isAck
*
* @return Void
**/
(
RgSchUeCb *ue,
RgSchUeCellInfo *cellInfo,
-U8 isAck
+uint8_t isAck
)
#else
Void rgSCHUtlUpdACqiTrigWt(ue,cellInfo, isAck)
RgSchUeCb *ue;
RgSchUeCellInfo *cellInfo;
-U8 isAck;
+uint8_t isAck;
#endif
{
#ifdef LTE_ADV
- U8 triggerSet = 0;
- U8 sIdx = 0;
+ uint8_t triggerSet = 0;
+ uint8_t sIdx = 0;
#endif
if (isAck == TFU_HQFDB_ACK)
/* Already one ACQI trigger procedure is going on
* which is not yet satisfied. Delaying this request till
* the previous is getting satisfied*/
- RETVOID;
+ return;
}
ue->dl.reqForCqi = TRUE;
rgSCHUtlSrRcvd(cell, ue, cell->crntTime, &unUsed);
}
- RETVOID;
+ return;
}
#endif
#endif
{
cell->sc.apis->rgSCHHdlUlTransInd(cell, ue, timingInfo);
- RETVOID;
+ return;
}
#ifdef LTEMAC_SPS
/**
#endif
{
cell->sc.apis->rgSCHUlCrcInd(cell, ue, timingInfo);
- RETVOID;
+ return;
} /* end of rgSCHUtlHdlCrcFailInd */
/**
#endif
{
cell->sc.apis->rgSCHUlCrcFailInd(cell, ue, timingInfo);
- RETVOID;
+ return;
} /* end of rgSCHUtlHdlCrcFailInd */
#endif /* LTEMAC_SPS */
#endif
{
cell->sc.apis->rgSCHDlProcAddToRetx(cell, hqP);
- RETVOID;
+ return;
}
\f
*
* @param[in] RgSubFrm* subFrm
* @param[in] RgDlHqProc* hqP
- * @param[in] U8 tbIdx
+ * @param[in] uint8_t tbIdx
* @return Void
*
**/
(
RgSchDlSf *subFrm,
RgSchDlHqProcCb *hqP,
-U8 tbIdx
+uint8_t tbIdx
)
#else
Void rgSCHUtlDlHqPTbAddToTx(subFrm, hqP, tbIdx)
RgSchDlSf *subFrm;
RgSchDlHqProcCb *hqP;
-U8 tbIdx;
+uint8_t tbIdx;
#endif
{
RgSchUeCb *ue = NULLP;
cmLListAdd2Tail(&ue->dl.dlSfHqInfo[cell->cellId][subFrm->dlIdx].hqPLst,&hqP->hqPSfLnk);
#ifdef CA_DBG
{
- extern U32 gSCellSchedCount,gPrimarySchedCount;
+ extern uint32_t gSCellSchedCount,gPrimarySchedCount;
if(RG_SCH_IS_CELL_SEC(hqP->hqE->ue,hqP->hqE->cell))
{
gSCellSchedCount++;
hqP->subFrm = subFrm;
/* CA Dev End */
- RETVOID;
+ return;
}
*
* @param[in] RgSubFrm* subFrm
* @param[in] RgDlHqProc* hqP
- * @param[in] U8 tbIdx
+ * @param[in] uint8_t tbIdx
* @param[in] Bool isRepeting
* @return Void
*
(
RgSchDlSf *subFrm,
RgSchDlHqProcCb *hqP,
-U8 tbIdx,
+uint8_t tbIdx,
Bool isRepeting
)
#else
Void rgSCHUtlDlHqPTbRmvFrmTx(subFrm, hqP, tbIdx, isRepeting)
RgSchDlSf *subFrm;
RgSchDlHqProcCb *hqP;
-U8 tbIdx;
+uint8_t tbIdx;
Bool isRepeting;
#endif
{
}
hqP->subFrm = NULLP;
}
- RETVOID;
+ return;
}
#ifdef LTE_ADV
RgSchCellCb* rgSchUtlGetCellCb
(
Inst inst,
- U16 cellId
+ uint16_t cellId
)
#else
RgSchCellCb* rgSchUtlGetCellCb(inst, cellId)
Inst inst;
- U16 cellId;
+ uint16_t cellId;
#endif
{
RgSchCellCb *cellCb = NULLP;
- U8 strtCellId;
+ uint8_t strtCellId;
strtCellId = rgSchCb[inst].genCfg.startCellId;
cellCb = rgSchCb[inst].cells[cellId - strtCellId];
*
* @param[in] *cellId
* @param[in] RgSchUeCb *ue
- * @return U8 servCellIdx
+ * @return uint8_t servCellIdx
**/
#ifdef ANSI
-U8 rgSchUtlGetServCellIdx
+uint8_t rgSchUtlGetServCellIdx
(
Inst inst,
- U16 cellId,
+ uint16_t cellId,
RgSchUeCb *ue
)
#else
-U8 rgSchUtlGetServCellIdx(inst,cellId,ue)
+uint8_t rgSchUtlGetServCellIdx(inst,cellId,ue)
Inst inst;
- U16 cellId;
+ uint16_t cellId;
RgSchUeCb *ue;
#endif
{
- U8 servCellIdx;
- U16 strtCellId;
+ uint8_t servCellIdx;
+ uint16_t strtCellId;
strtCellId = rgSchCb[inst].genCfg.startCellId;
S16 rgSchUtlVldtCellId
(
Inst inst,
- U16 cellId
+ uint16_t cellId
)
#else
S16 rgSchUtlVldtCellId(inst, cellId)
Inst inst;
- U16 cellId;
+ uint16_t cellId;
#endif
{
- U8 strtCellId;
+ uint8_t strtCellId;
strtCellId = rgSchCb[inst].genCfg.startCellId;
if((cellId >= strtCellId) && ((cellId - strtCellId) < CM_LTE_MAX_CELLS))
cell->sc.apis->rgSCHFreeDlLc(cell, ue, svc);
/* Stack Crash problem for TRACE5 changes. added the return below . */
- RETVOID;
+ return;
}
cell->sc.apis->rgSCHFreeUe(cell, ue);
/* Stack Crash problem for TRACE5 changes. added the return below . */
- RETVOID;
+ return;
} /* rgSCHUtlFreeUe */
#endif
{
cell->sc.apis->rgSCHDlDedBoUpd(cell, ue, lc);
- RETVOID;
+ return;
}
/**
* @brief Record MSG3 allocation into the UE
#endif
{
cell->sc.apis->rgSCHUlRecMsg3Alloc(cell, ue, raCb);
- RETVOID;
+ return;
} /* rgSCHRecMsg3Alloc */
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 lcgId
- * @param[in] U8 bsr
+ * @param[in] uint8_t lcgId
+ * @param[in] uint8_t bsr
* @param[out] RgSchErrInfo *err
* @return Void
* -# ROK
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 lcgId,
-U8 bsr,
+uint8_t lcgId,
+uint8_t bsr,
RgSchErrInfo *err
)
#else
Void rgSCHUtlUpdBsrShort(cell, ue, lcgId, bsr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 lcgId;
-U8 bsr;
+uint8_t lcgId;
+uint8_t bsr;
RgSchErrInfo *err;
#endif
{
cell->sc.apis->rgSCHUpdBsrShort(cell, ue, &ue->ul.lcgArr[lcgId], bsr, err);
- RETVOID;
+ return;
} /* rgSCHUtlUpdBsrShort */
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 lcgId
- * @param[in] U8 bsr
+ * @param[in] uint8_t lcgId
+ * @param[in] uint8_t bsr
* @param[out] RgSchErrInfo *err
* @return Void
* -# ROK
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 lcgId,
-U8 bsr,
+uint8_t lcgId,
+uint8_t bsr,
RgSchErrInfo *err
)
#else
Void rgSCHUtlUpdBsrTrunc(cell, ue, lcgId, bsr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 lcgId;
-U8 bsr;
+uint8_t lcgId;
+uint8_t bsr;
RgSchErrInfo *err;
#endif
{
cell->sc.apis->rgSCHUpdBsrTrunc(cell, ue, &ue->ul.lcgArr[lcgId], bsr, err);
- RETVOID;
+ return;
} /* rgSCHUtlUpdBsrTrunc */
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 bsr0
- * @param[in] U8 bsr1
- * @param[in] U8 bsr2
- * @param[in] U8 bsr3
+ * @param[in] uint8_t bsr0
+ * @param[in] uint8_t bsr1
+ * @param[in] uint8_t bsr2
+ * @param[in] uint8_t bsr3
* @param[out] RgSchErrInfo *err
* @return Void
* -# ROK
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 bsr0,
-U8 bsr1,
-U8 bsr2,
-U8 bsr3,
+uint8_t bsr0,
+uint8_t bsr1,
+uint8_t bsr2,
+uint8_t bsr3,
RgSchErrInfo *err
)
#else
Void rgSCHUtlUpdBsrLong(cell, ue, bsr0, bsr1, bsr2, bsr3, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 bsr0;
-U8 bsr1;
-U8 bsr2;
-U8 bsr3;
+uint8_t bsr0;
+uint8_t bsr1;
+uint8_t bsr2;
+uint8_t bsr3;
RgSchErrInfo *err;
#endif
{
- U8 bsArr[4];
+ uint8_t bsArr[4];
bsArr[0] = bsr0;
bsArr[1] = bsr1;
bsArr[2] = bsr2;
bsArr[3] = bsr3;
cell->sc.apis->rgSCHUpdBsrLong(cell, ue, bsArr, err);
- RETVOID;
+ return;
} /* rgSCHUtlUpdBsrLong */
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 phr
+ * @param[in] uint8_t phr
* @param[out] RgSchErrInfo *err
* @return S16
* -# ROK
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 phr
+ * @param[in] uint8_t phr
* @param[out] RgSchErrInfo *err
* @return S16
* -# ROK
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U8 phr,
+uint8_t phr,
RgSchErrInfo *err
)
#else
S16 rgSCHUtlUpdPhr(cell, ue, phr, err)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U8 phr;
+uint8_t phr;
RgSchErrInfo *err;
#endif
{
#endif
{
cell->sc.apis->rgSCHUlCqiInd(cell, ue, ulCqiInfo);
- RETVOID;
+ return;
} /* rgSCHUtlUlCqiInd */
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U8 delta
+ * @param[in] uint8_t delta
* @return Void
**/
#ifdef ANSI
#endif
{
cell->sc.apis->rgSCHPucchDeltaPwrInd(cell, ue, delta);
- RETVOID;
+ return;
} /* rgSCHUtlPucchDeltaPwrInd */
/* Start: LTEMAC_2.1_DEV_CFG */
{
ue->remBoCnt = 0;
cell->sc.apis->rgSCHUeReset(cell, ue);
- RETVOID;
+ return;
} /* rgSCHUtlUeReset */
/* End: LTEMAC_2.1_DEV_CFG */
cell->sc.apis->rgSCHUlHqProcForUe(cell, frm, ue, procRef);
/* Stack Crash problems for TRACE5 changes. added the return below */
- RETVOID;
+ return;
}
* Invoked by: TOM
*
* @param[in] RgSchCellCb *cell
- * @param[in] U8 idx
+ * @param[in] uint8_t idx
* @return RgSchUlAlloc*
**/
#ifdef ANSI
RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc
(
RgSchCellCb *cell,
-U8 idx
+uint8_t idx
)
#else
RgSchUlAlloc *rgSCHUtlFirstHqFdbkAlloc(cell, idx)
RgSchCellCb *cell;
-U8 idx;
+uint8_t idx;
#endif
{
return (cell->sc.apis->rgSCHFirstHqFdbkAlloc(cell, idx));
(
RgSchCellCb *cell,
RgSchUlAlloc *alloc,
-U8 idx
+uint8_t idx
)
#else
RgSchUlAlloc *rgSCHUtlNextHqFdbkAlloc(cell, alloc, idx)
RgSchCellCb *cell;
RgSchUlAlloc *alloc;
-U8 idx;
+uint8_t idx;
#endif
{
return (cell->sc.apis->rgSCHNextHqFdbkAlloc(cell, alloc, idx));
RgSchCellCb *cell;
#endif
{
- U8 idx = 0;
+ uint8_t idx = 0;
Inst inst = cell->instIdx;
for(idx=0; idx < RGSCH_NUM_SUB_FRAMES; idx++)
{
RgSchCellCb *cell;
#endif
{
- U8 idx = 0;
+ uint8_t idx = 0;
Inst inst = cell->instIdx;
for(idx=0; idx < RGSCH_NUM_SUB_FRAMES; idx++)
RgSchCellCb *cell;
#endif
{
- U8 idx;
- U8 indx;
+ uint8_t idx;
+ uint8_t indx;
Inst inst = cell->instIdx;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchCellCb *cell;
#endif
{
- U8 idx;
- U8 indx;
+ uint8_t idx;
+ uint8_t indx;
Inst inst = cell->instIdx;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
* previously allocated by rgSCHUtlAllocSBuf() and size. It
* deallocates the memory.
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: None
* File: rg_utl.c
if ((data == NULLP) || (*data == NULLP) || (size == 0))
{
- RETVOID;
+ return;
}
RGSCHLOGERROR(inst, ERRCLS_DEBUG, ERG016, (ErrVal) 0,
"rgSCHUtlFreeSBuf failed.\n");
RLOG_ARG0(L_ERROR,DBG_INSTID,inst, "rgSCHUtlFreeSBuf failed");
- RETVOID;
+ return;
}
/* ccpu00117052 - ADD - Assigning the pointer to NULLP */
*data = NULLP;
- RETVOID;
+ return;
} /* end of rgSCHUtlFreeSBuf */
\f
*
* Desc: This is used to deallocate Warning SI Seg.
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: None
*
node = NULLP;
}
- RETVOID;
+ return;
} /* end of rgSCHUtlFreeWarningSiSeg */
\f
*
* Desc: This is used to deallocate Warning SI PDU.
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: None
*
CM_LLIST_FIRST_NODE(&warningSi->warningSiMsg.segLstCp, node);
if (node == NULLP)
{
- RETVOID;
+ return;
}
warningSiPdu = (RgSchWarningSiPdu *)node->node;
warningSi->warningSiMsg.transId, RGR_CFG_CFM_TX_COMPLETE);
}
- RETVOID;
+ return;
} /* end of rgSCHUtlFreeWarningSiPdu */
S16 rgSCHUtlGetMcsAndNPrb
(
RgSchCellCb *cell,
-U8 *nPrb,
-U8 *mcs,
+uint8_t *nPrb,
+uint8_t *mcs,
MsgLen *msgLen
)
#else
S16 rgSCHUtlGetMcsAndNPrb(cell, nPrb, mcs, msgLen)
RgSchCellCb *cell;
-U8 *nPrb;
-U8 *mcs;
+uint8_t *nPrb;
+uint8_t *mcs;
MsgLen *msgLen;
#endif
{
S16 rgSCHUtlCalMcsAndNPrb
(
RgSchCellCb *cell,
-U8 cfgType,
+uint8_t cfgType,
MsgLen msgLen,
-U8 siId
+uint8_t siId
)
#else
S16 rgSCHUtlCalMcsAndNPrb(cell, nPrb, mcs, msgLen)
RgSchCellCb *cell;
-U8 cfgType;
+uint8_t cfgType;
MsgLen msgLen;
-U8 siId;
+uint8_t siId;
#endif
{
- U8 mcs = 0;
- U8 nPrb = 0;
+ uint8_t mcs = 0;
+ uint8_t nPrb = 0;
/*Get the nPrb and mcs parametr values */
if (rgSCHUtlGetAllwdCchTbSz(msgLen*8, &nPrb, &mcs) != (msgLen*8))
(
Inst inst,
RgUstaDgn *dgn,
-U8 dgnType
+uint8_t dgnType
)
#else
Void rgSCHUtlFillDgnParams(inst, dgn, dgnType)
Inst inst;
RgUstaDgn *dgn;
-U8 dgnType;
+uint8_t dgnType;
#endif
{
switch(dgnType)
{
case LRG_USTA_DGNVAL_MEM:
- dgn->type = (U8) LRG_USTA_DGNVAL_MEM;
+ dgn->type = (uint8_t) LRG_USTA_DGNVAL_MEM;
dgn->u.mem.region = rgSchCb[inst].rgSchInit.region;
dgn->u.mem.pool = rgSchCb[inst].rgSchInit.pool;
break;
break;
}
- RETVOID;
+ return;
} /* end of rgSCHUtlFillDgnParams */
/***********************************************************
pst->intfVer = 0;
pst->route = RTESPEC;
- RETVOID;
+ return;
} /* end of rgSCHUtlGetPstToLyr */
/** @brief This function fills in the common lc information to be sent to MAC
RgSchCellCb *cell;
#endif
{
- U8 idx;
+ uint8_t idx;
CmLListCp *lnkLst;
CmLList *tmp;
RgSchRaCb *raCb;
RgSchUeCb *ue;
RgInfRaRntiInfo *raRntiAlloc;
- U8 noRaRsps;
+ uint8_t noRaRsps;
RgSchCmnDlCell *cellDl = RG_SCH_CMN_GET_DL_CELL(cell);
#ifdef LTE_TDD
* Desc : Utility Function to fill the allocation info of each Tb
*
*
- * Ret : RETVOID
+ * Ret : void
*
*
* Notes: This function should be called while sending a msg from
#endif
{
RgSchDlSf *sf;
- U8 idx;
+ uint8_t idx;
RgInfUeTbInfo *tbInfo;
- U8 tbCnt;
+ uint8_t tbCnt;
/* LTE_ADV_FLAG_REMOVED_START */
#ifdef TFU_UPGRADE
- PRIVATE U32 tmpCnt = 0;
+ PRIVATE uint32_t tmpCnt = 0;
Bool isAllUePwrHigh = FALSE;
#endif
/* LTE_ADV_FLAG_REMOVED_END */
RgSchDlLcCb *dlLcCb = NULLP;
- U16 rlcHdrEstmt;
- U8 lcId;
+ uint16_t rlcHdrEstmt;
+ uint8_t lcId;
/* RRM_RBC_X */
#ifdef LTE_L2_MEAS
- U8 prbUsed = 0;
+ uint8_t prbUsed = 0;
#endif
/* RRM_RBC_Y */
#ifdef TFU_UPGRADE
/*if SFR is enabled*/
- allocInfo->isEnbSFR = (U8)RG_SCH_CMN_IS_SFR_ENB(ue->cell); /* KW fix for LTE_ADV */
+ allocInfo->isEnbSFR = (uint8_t)RG_SCH_CMN_IS_SFR_ENB(ue->cell); /* KW fix for LTE_ADV */
if((ue->cell->lteAdvCb.dsfrCfg.status == RGR_ENABLE) &&
(ue->lteAdvUeCb.rgrLteAdvUeCfg.isUeCellEdge == FALSE))
{
}
if(isAllUePwrHigh)
{
- allocInfo->pa = (U8)ue->cell->lteAdvCb.sfrCfg.pwrThreshold.pHigh; /* KW fix for LTE_ADV */
+ allocInfo->pa = (uint8_t)ue->cell->lteAdvCb.sfrCfg.pwrThreshold.pHigh; /* KW fix for LTE_ADV */
if(tmpCnt++ == 100000)
{
RLOG_ARG2(L_DEBUG,DBG_CELLID,ue->cell->cellId,
//if(!(hqP->hqE->ue->pfsStats.lcStats[lcId-1].isLcCntSet))
if(tbCnt == 0)
{
- U8 idx = 0;
+ uint8_t idx = 0;
if (hqP->hqE->ue->cell == hqP->hqE->cell)
{
idx = RGSCH_PCELL_INDEX;
rgSCHLaaResetDlHqProcCb(hqP);
#endif
- RETVOID;
+ return;
}
/***********************************************************
*
#endif
}
- RETVOID;
+ return;
} /* end of rgSCHUtlFillRgInfUeInfo */
/* CA dev End */
/*ccpu00129922 - MOD - Deleted return value
* checking since it returns void*/
rgSCHUtlUpdBsrTrunc (cellCb, ueCb,
- (U8)(pdu->ceInfo.ces.bsr.truncBsr >> 6),
- (U8)(pdu->ceInfo.ces.bsr.truncBsr & 0x3F), err);
+ (uint8_t)(pdu->ceInfo.ces.bsr.truncBsr >> 6),
+ (uint8_t)(pdu->ceInfo.ces.bsr.truncBsr & 0x3F), err);
}
else
{
/*ccpu00129922 - MOD - Deleted return value
checking since it returns void*/
rgSCHUtlUpdBsrShort (cellCb, ueCb,
- (U8)(pdu->ceInfo.ces.bsr.shortBsr >> 6),
- (U8)(pdu->ceInfo.ces.bsr.shortBsr & 0x3F), err);
+ (uint8_t)(pdu->ceInfo.ces.bsr.shortBsr >> 6),
+ (uint8_t)(pdu->ceInfo.ces.bsr.shortBsr & 0x3F), err);
}
else
{
return RFAILED;
}
/* Update Bo in ueCb */
- ueCb->dlCcchInfo.bo = (U32)(staRsp->bo);
+ ueCb->dlCcchInfo.bo = (uint32_t)(staRsp->bo);
#ifdef EMTC_ENABLE
if(ueCb->isEmtcUe)
{
return RFAILED;
}
/* Update Bo in ueCb */
- ueCb->dlCcchInfo.bo = (U32)(boRpt->bo);
+ ueCb->dlCcchInfo.bo = (uint32_t)(boRpt->bo);
}
#else
* accordingly set.
*
*
- * @param[in] U32 bo
- * @param[out] U8 *nPrb
+ * @param[in] uint32_t bo
+ * @param[out] uint8_t *nPrb
* @return S32
* -# ROK
* -# RFAILED
#ifdef ANSI
S32 rgSCHUtlGetAllwdCchTbSz
(
-U32 bo,
-U8 *nPrb,
-U8 *mcs
+uint32_t bo,
+uint8_t *nPrb,
+uint8_t *mcs
)
#else
S32 rgSCHUtlGetAllwdCchTbSz(bo, nPrb, mcs)
-U32 bo;
-U8 *nPrb;
-U8 *mcs;
+uint32_t bo;
+uint8_t *nPrb;
+uint8_t *mcs;
#endif
{
S32 lt;
RgSchClcDlLcCb *dlLc;
RgSchClcBoRpt *boRpt;
Inst inst = cell->instIdx;
- U8 nPrb=0;
- U8 mcs=0;
+ uint8_t nPrb=0;
+ uint8_t mcs=0;
dlLc = rgSCHDbmGetBcchOnBch(cell);
if (dlLc == NULLP)
* bind confirm API towards RRM.
*
* @param[in] SuId suId
- * @param[in] U8 status
+ * @param[in] uint8_t status
* @return S16
* -# ROK
* -# RFAILED
(
Inst instId,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 rgSCHUtlRgrBndCfm(instId, suId, status)
Inst instId;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
S16 ret = ROK;
* This API fills in Pst structure and SAP Ids and invokes
*
* @param[in] SuId suId
- * @param[in] U8 status
+ * @param[in] uint8_t status
* @return S16
* -# ROK
* -# RFAILED
(
Inst instId,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 rgSCHUtlRgmBndCfm(instId, suId, status)
Inst instId;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
S16 ret = ROK;
*
* @param[in] Pst pst
* @param[in] RgrCfgTransId transId
- * @param[in] U8 status
+ * @param[in] uint8_t status
* @return S16
* -# ROK
* -# RFAILED
Region reg,
Pool pool,
RgrCfgTransId transId,
-U8 status
+uint8_t status
)
#else
S16 schSendCfgCfm(reg, pool, transId, status)
Region reg;
Pool pool;
RgrCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
Pst cfmPst;
*
* @param [in] RgSchCellCb *cellCb
* @param [in] RgSchUeCb *ueCb
- * @param [in] U16 spsSduSize
+ * @param [in] uint16_t spsSduSize
* @param
* @return S16
* -# ROK
(
RgSchCellCb *cellCb,
RgSchUeCb *ueCb,
-U16 spsSduSize
+uint16_t spsSduSize
)
#else
S16 rgSCHUtlSpsActInd (cellCb, ueCb, spsSduSize)
RgSchCellCb *cellCb;
RgSchUeCb *ueCb;
-U16 spsSduSize;
+uint16_t spsSduSize;
#endif
{
cellCb->sc.apis->rgSCHUlSpsActInd(cellCb, ueCb, spsSduSize);
#endif
{
Mem sMem;
- VOLATILE U32 startTime=0;
+ VOLATILE uint32_t startTime=0;
sMem.region = rgSchCb[inst].rgSchInit.region;
sMem.pool = rgSchCb[inst].rgSchInit.pool;
S16 rgSCHUtlAllocUeANFdbkInfo
(
RgSchUeCb *ue,
-U8 servCellIdx
+uint8_t servCellIdx
)
#else
S16 rgSCHUtlAllocUeANFdbkInfo(ue,servCellIdx)
RgSchUeCb *ue;
-U8 servCellIdx;
+uint8_t servCellIdx;
#endif
{
- U8 idx;
+ uint8_t idx;
if (rgSCHUtlAllocSBuf(ue->cell->instIdx,
(Data **) &(ue->cellInfo[servCellIdx]->anInfo), sizeof(RgSchTddANInfo) * \
Void rgSCHUtlDelUeANFdbkInfo
(
RgSchUeCb *ue,
-U8 servCellIdx
+uint8_t servCellIdx
)
#else
Void rgSCHUtlDelUeANFdbkInfo(ue,servCellIdx)
RgSchUeCb *ue;
-U8 servCellIdx;
+uint8_t servCellIdx;
#endif
{
(Data **)(&( ue->cellInfo[servCellIdx]->anInfo)), sizeof(RgSchTddANInfo) * \
ue->cell->ackNackFdbkArrSize);
- RETVOID;
+ return;
} /* rgSCHUtlDelUeANFdbkInfo */
/**
(
RgSchUeCb *ueCb,
CmLteTimingInfo *timeInfo,
-U8 servCellIdx
+uint8_t servCellIdx
)
#else
RgSchTddANInfo* rgSCHUtlGetUeANFdbkInfo(ueCb, timeInfo,servCellIdx)
RgSchUeCb *ueCb;
CmLteTimingInfo *timeInfo;
-U8 servCellIdx;
+uint8_t servCellIdx;
#endif
{
- U8 idx;
+ uint8_t idx;
for (idx = 0; idx < ueCb->cell->ackNackFdbkArrSize; ++idx)
{
*
* @param[in] CmLteTimingInfo *timeInfo
* @param[in] RgSchCellCb *cell
- * @return U8
+ * @return uint8_t
*
**/
#ifdef ANSI
-U8 rgSCHUtlGetDlSfIdx
+uint8_t rgSCHUtlGetDlSfIdx
(
RgSchCellCb *cell,
CmLteTimingInfo *timeInfo
)
#else
-U8 rgSCHUtlGetDlSfIdx(cell, timeInfo)
+uint8_t rgSCHUtlGetDlSfIdx(cell, timeInfo)
RgSchCellCb *cell;
CmLteTimingInfo *timeInfo;
#endif
{
- U16 idx = 0;
+ uint16_t idx = 0;
idx = RGSCH_NUM_SUB_FRAMES - \
rgSchTddNumUlSubfrmTbl[cell->ulDlCfgIdx][RGSCH_NUM_SUB_FRAMES-1];
rgSchTddNumDlSubfrmTbl[cell->ulDlCfgIdx][timeInfo->slot]) - 1;
idx = idx % cell->numDlSubfrms;
- return ((U8)idx);
+ return ((uint8_t)idx);
}
/**
* @param[in] RgSchDlSf *dlSf
* @param[in] RgSchDlSf **nxtDlsf
* @param[in] CmLteTimingInfo *nxtDlTime
- * @return U8
+ * @return uint8_t
*
**/
#ifdef ANSI
CmLteTimingInfo *nxtDlTime;
#endif
{
- U16 idx = curDlTime.slot;
- U8 count = 0;
+ uint16_t idx = curDlTime.slot;
+ uint8_t count = 0;
while(TRUE)
{
break;
}
}
- RETVOID;
+ return;
}
/**
* @param[in] RgSchCellCb *cell
* @param[in] CmLteTimingInfo curDlTime
* @param[in] CmLteTimingInfo *prevDlTime
- * @param[in] U8 *numSubfrm
- * @return U8
+ * @param[in] uint8_t *numSubfrm
+ * @return uint8_t
*
**/
#ifdef ANSI
RgSchCellCb *cell,
CmLteTimingInfo curDlTime,
CmLteTimingInfo *prevDlTime,
-U8 *numSubfrm
+uint8_t *numSubfrm
)
#else
Void rgSCHUtlGetPrevDlSfInfo(cell, curDlTime, prevDlTime, numSubfrm)
RgSchCellCb *cell;
CmLteTimingInfo curDlTime;
CmLteTimingInfo *prevDlTime;
-U8 *numSubfrm;
+uint8_t *numSubfrm;
#endif
{
S16 idx = curDlTime.slot;
- U8 count = 0;
+ uint8_t count = 0;
do
{
!= RG_SCH_TDD_DL_slot);
*numSubfrm = count;
RGSCHDECRFRMCRNTTIME(curDlTime, (*prevDlTime), count);
- RETVOID;
+ return;
}
#endif
(
RgSchCellCb *cell,
RgSchUlSf *sf,
-U8 idx,
-U8 maxUePerSf
+uint8_t idx,
+uint8_t maxUePerSf
)
#else
S16 rgSCHUtlUlSfInit(cell, sf, idx, maxUePerSf)
RgSchCellCb *cell;
RgSchUlSf *sf;
-U8 idx;
-U8 maxUePerSf;
+uint8_t idx;
+uint8_t maxUePerSf;
#endif
{
S16 ret=ROK;
sf->idx = idx;
#ifdef RG_5GTF
- U8 index;
+ uint8_t index;
#endif
#ifdef LTE_TDD
return (ret);
}
/* Initialize the hole with CFI 1 Pusch Bw Info */
- ret = rgSCHUtlUlHoleDbInit(cell, sf->holeDb, (U8)(maxUePerSf + 2), \
+ ret = rgSCHUtlUlHoleDbInit(cell, sf->holeDb, (uint8_t)(maxUePerSf + 2), \
0, cell->dynCfiCb.bwInfo[1].numSb);
if (ret != ROK)
rgSCHUtlFreeSBuf(cell->instIdx, (Data **)(&(sf->holeDb)),
sizeof(RgSchUlHoleDb));
}
- RETVOID;
+ return;
}
/***********************************************************
(
RgSchCellCb *cell,
RgSchUlAllocDb *allocDb,
-U8 maxAllocs
+uint8_t maxAllocs
)
#else
PRIVATE S16 rgSCHUtlUlAllocDbInit(cell, allocDb, maxAllocs)
RgSchCellCb *cell;
RgSchUlAllocDb *allocDb;
-U8 maxAllocs;
+uint8_t maxAllocs;
#endif
{
S16 ret = rgSCHUtlUlAllocMemInit(cell, &allocDb->mem, maxAllocs);
rgSCHUtlUlAllocMemDeinit(cell, &allocDb->mem);
allocDb->count = 0;
allocDb->first = NULLP;
- RETVOID;
+ return;
}
/***********************************************************
(
RgSchCellCb *cell,
RgSchUlHoleDb *holeDb,
-U8 maxHoles,
-U8 start,
-U8 num
+uint8_t maxHoles,
+uint8_t start,
+uint8_t num
)
#else
PRIVATE S16 rgSCHUtlUlHoleDbInit(cell, holeDb, maxHoles, start, num)
RgSchCellCb *cell;
RgSchUlHoleDb *holeDb;
-U8 maxHoles;
-U8 start;
-U8 num;
+uint8_t maxHoles;
+uint8_t start;
+uint8_t num;
#endif
{
S16 ret;
rgSCHUtlUlHoleMemDeinit(cell, &holeDb->mem);
holeDb->count = 0;
holeDb->first = NULLP;
- RETVOID;
+ return;
}
RgSchUlAlloc *rgSCHUtlUlAllocGetHole
(
RgSchUlSf *sf,
-U8 numSb,
+uint8_t numSb,
RgSchUlHole *hole
)
#else
RgSchUlAlloc *rgSCHUtlUlAllocGetHole(sf, numSb, hole)
RgSchUlSf *sf;
-U8 numSb;
+uint8_t numSb;
RgSchUlHole *hole;
#endif
{
RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole
(
RgSchUlSf *sf,
-U8 numSb,
+uint8_t numSb,
RgSchUlHole *hole
)
#else
RgSchUlAlloc *rgSCHUtlUlAllocGetPartHole(sf, numSb, hole)
RgSchUlSf *sf;
-U8 numSb;
+uint8_t numSb;
RgSchUlHole *hole;
#endif
{
else
rgSCHUtlUlHoleNew(db, alloc);
}
- RETVOID;
+ return;
}
rgSCHUtlUlHoleAddAllocation(alloc);
rgSCHUtlUlAllocMemRls(&allocDb->mem, alloc);
- RETVOID;
+ return;
}
//printf("\nallocDb->count:%u\n",allocDb->count);
- RETVOID;
+ return;
}
/***********************************************************
/* increment the number of subbands getting freed to total available list */
sf->availSubbands += alloc->numSb;
- RETVOID;
+ return;
}
/***********************************************************
rgSCHUtlUlHoleIncr(db, prv);
rgSCHUtlUlHoleUpdAllocLnks(prv, alloc->prv, alloc->nxt);
- RETVOID;
+ return;
}
/***********************************************************
prv->num += alloc->numSb;
rgSCHUtlUlHoleIncr(db, prv);
rgSCHUtlUlHoleUpdAllocLnks(prv, alloc->prv, alloc->nxt);
- RETVOID;
+ return;
}
/***********************************************************
nxt->start = alloc->sbStart;
rgSCHUtlUlHoleIncr(db, nxt);
rgSCHUtlUlHoleUpdAllocLnks(nxt, alloc->prv, alloc->nxt);
- RETVOID;
+ return;
}
/***********************************************************
#if (ERRCLASS & ERRCLS_DEBUG)
if ( hole == NULLP )
{
- RETVOID;
+ return;
}
#endif
hole->start = alloc->sbStart;
++db->count;
rgSCHUtlUlHoleIns(db, hole);
rgSCHUtlUlHoleUpdAllocLnks(hole, alloc->prv, alloc->nxt);
- RETVOID;
+ return;
}
/***********************************************************
}
hole->prvAlloc = prvAlloc;
hole->nxtAlloc = nxtAlloc;
- RETVOID;
+ return;
}
cur->prv = hole;
db->first = hole;
hole->prv = NULLP;
- RETVOID;
+ return;
}
for (nxt = cur->nxt; nxt; cur = nxt, nxt = nxt->nxt)
hole->prv = cur;
hole->nxt = nxt;
nxt->prv = hole;
- RETVOID;
+ return;
}
}
cur->nxt = hole;
hole->prv = cur;
hole->nxt = NULLP;
- RETVOID;
+ return;
}
/* This is the first hole */
db->first = hole;
hole->prv = NULLP; /* may not be needed */
hole->nxt = NULLP;
- RETVOID;
+ return;
}
if (cur->num > hole->num)
{
- RETVOID;
+ return;
}
/* Remove hole from current position */
hole->prv = prv;
hole->nxt = cur;
cur->prv = hole;
- RETVOID;
+ return;
}
}
cur->prv = hole;
db->first = hole;
hole->prv = NULLP;
- RETVOID;
+ return;
}
- RETVOID;
+ return;
}
/***********************************************************
if (cur->num < hole->num)
{
- RETVOID;
+ return;
}
/* Remove hole from current position */
hole->prv = cur;
hole->nxt = nxt;
nxt->prv = hole;
- RETVOID;
+ return;
}
}
cur->nxt = hole;
hole->prv = cur;
hole->nxt = NULLP;
- RETVOID;
+ return;
}
- RETVOID;
+ return;
}
/***********************************************************
}
rgSCHUtlUlHoleMemRls(&db->mem, hole);
- RETVOID;
+ return;
}
(
RgSchCellCb *cell,
RgSchUlAllocMem *mem,
-U8 maxAllocs
+uint8_t maxAllocs
)
#else
S16 rgSCHUtlUlAllocMemInit(cell, mem, maxAllocs)
RgSchCellCb *cell;
RgSchUlAllocMem *mem;
-U8 maxAllocs;
+uint8_t maxAllocs;
#endif
{
S16 ret;
}
else
{
- U8 i;
+ uint8_t i;
allocs[0].prv = NULLP;
allocs[0].nxt = &allocs[1];
for (i = 1; i < mem->maxAllocs - 1; ++i)
mem->maxAllocs * sizeof(*mem->allocs));
mem->maxAllocs = 0;
mem->firstFree = NULLP;
- RETVOID;
+ return;
}
/***********************************************************
(
RgSchCellCb *cell,
RgSchUlHoleMem *mem,
-U8 maxHoles,
+uint8_t maxHoles,
RgSchUlHole **holeRef
)
#else
S16 rgSCHUtlUlHoleMemInit(cell, mem, maxHoles, holeRef)
RgSchCellCb *cell;
RgSchUlHoleMem *mem;
-U8 maxHoles;
+uint8_t maxHoles;
RgSchUlHole **holeRef;
#endif
{
}
else
{
- U8 i;
+ uint8_t i;
holes[1].prv = NULLP;
holes[0].nxt = &holes[1];
for (i = 1; i < mem->maxHoles - 1; ++i)
mem->maxHoles * sizeof(*mem->holes));
mem->maxHoles = 0;
mem->firstFree = NULLP;
- RETVOID;
+ return;
}
/***********************************************************
mem->firstFree->prv = alloc;
}
mem->firstFree = alloc;
- RETVOID;
+ return;
}
/***********************************************************
mem->firstFree->prv = hole;
}
mem->firstFree = hole;
- RETVOID;
+ return;
}
/**
* will always be such hole. And also for efficiency.
*
* @param[in] RgSchUlSf *sf
- * @param[in] U8 startSb
- * @param[in] U8 numSb
+ * @param[in] uint8_t startSb
+ * @param[in] uint8_t numSb
* @return RgSchUlAlloc*
**/
#ifdef ANSI
RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc
(
RgSchUlSf *sf,
-U8 startSb,
-U8 numSb
+uint8_t startSb,
+uint8_t numSb
)
#else
RgSchUlAlloc *rgSCHUtlUlGetSpfcAlloc(sf, startSb, numSb)
RgSchUlSf *sf;
-U8 startSb;
-U8 numSb;
+uint8_t startSb;
+uint8_t numSb;
#endif
{
RgSchUlHole *hole, *nxtHole;
* Function :rgSCHUtlValidateQci
*
* @param[in] RgSchCellCb *cellCb
- * @param[in] U8 numQci
- * @param[out] U8 *qci
+ * @param[in] uint8_t numQci
+ * @param[out] uint8_t *qci
* @return S16
* ROK
* RFAILED
PRIVATE S16 rgSCHUtlValidateQci
(
RgSchCellCb *cellCb,
-U8 numQci,
-U8 *qci
+uint8_t numQci,
+uint8_t *qci
)
#else
PRIVATE S16 rgSCHUtlValidateQci(cellCb, numQci, qci)
RgSchCellCb *cellCb;
-U8 numQci;
-U8 *qci;
+uint8_t numQci;
+uint8_t *qci;
#endif
{
- U8 qciIdx;
- U8 qciVal;
+ uint8_t qciIdx;
+ uint8_t qciVal;
for(qciIdx = 0; qciIdx < numQci; qciIdx++)
RgSchErrInfo *err;
#endif
{
- U16 measType;
+ uint16_t measType;
S16 ret;
* config confirm API towards RRM.
*
* @param[in] RgrCfgTransId transId
- * @param[in] U8 status
+ * @param[in] uint8_t status
* @return S16
* -# ROK
* -# RFAILED
Inst instId,
SpId spId,
RgrCfgTransId transId,
-U8 status
+uint8_t status
)
#else
S16 rgSCHUtlRgrSiCfgCfm(instId, spId, transId, status)
Inst instId;
SpId spId;
RgrCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
- U8 prntTrans[RGR_CFG_TRANSID_SIZE+1];
+ uint8_t prntTrans[RGR_CFG_TRANSID_SIZE+1];
memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
* config confirm API towards RRM.
*
* @param[in] RgrCfgTransId transId
- * @param[in] U8 status
+ * @param[in] uint8_t status
* @return S16
* -# ROK
* -# RFAILED
(
Inst instId,
SpId spId,
-U8 siId,
+uint8_t siId,
RgrCfgTransId transId,
-U8 status
+uint8_t status
)
#else
S16 rgSCHUtlRgrWarningSiCfgCfm(instId, spId, siId, transId, status)
Inst instId;
SpId spId;
-U8 siId;
+uint8_t siId;
RgrCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
- U8 prntTrans[RGR_CFG_TRANSID_SIZE+1];
+ uint8_t prntTrans[RGR_CFG_TRANSID_SIZE+1];
memcpy(prntTrans, transId.trans, RGR_CFG_TRANSID_SIZE);
RgSchCellCb *cell;
#endif
{
- U8 idx = 0;
- U32 sizeOfSiInfo = 0;
+ uint8_t idx = 0;
+ uint32_t sizeOfSiInfo = 0;
/*Free the buffers in crntSiInfo*/
RGSCH_FREE_MSG(cell->siCb.crntSiInfo.mib)
RGSCH_FREE_MSG(cell->siCb.crntSiInfo.sib1Info.sib1)
RGSCH_FREE_MSG(cell->siCb.newSiInfo.siInfo[idx].si)
}
- RETVOID;
+ return;
}
#endif /*RGR_SI_SCH */
#endif
{
Bool isNewTx = FALSE;
- U8 idx;
+ uint8_t idx;
RgSchDrxDlHqProcCb *drxHq;
RgSchDRXCellCb *drxCell = cellCb->drxCb;
RgSchDrxUeCb *drxUe;
#ifdef DEBUGP
Inst inst = cellCb->instIdx;
#endif
- U8 cellIdx = ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(dlHq->hqE->cell)];
- U32 dlInactvMask;
- U32 ulInactvMask;
+ uint8_t cellIdx = ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(dlHq->hqE->cell)];
+ uint32_t dlInactvMask;
+ uint32_t ulInactvMask;
for(idx = 0; idx < allocInfo->nmbOfTBs; idx++)
{
* @param[in] RgSchCellCb *cell pointer to Cell Control block
* @param[in] RgSchUeCb *ue pointer to Ue Control block
* @param[in] RgrStaIndInfo *staInfo Sta Ind struct to be filled
- * @param[in] U8 numCqiRept NUmber of reports to be filled
+ * @param[in] uint8_t numCqiRept NUmber of reports to be filled
* @return Void
*
**/
RgSchCellCb *cell,
RgSchUeCb *ue,
RgrStaIndInfo *staInfo,
-U8 numCqiRept
+uint8_t numCqiRept
)
#else
S16 rgSCHUtlFillSndStaInd(cell, ue, staInfo, numCqiRept)
RgSchCellCb *cell;
RgSchUeCb *ue;
RgrStaIndInfo *staInfo;
-U8 numCqiRept;
+uint8_t numCqiRept;
#endif
{
- U8 idxStart;
+ uint8_t idxStart;
/* Fill StaInd for sending collated Latest N CQI rpeorts */
/* Find index in the array from where Latest N
/* Invoke MAC to release the rnti */
rgSCHUtlGetPstToLyr(&pst, &rgSchCb[inst], cell->macInst);
RgSchMacRlsRnti(&pst, &rntiInfo);
- RETVOID;
+ return;
}
/* LTE_ADV_FLAG_REMOVED_START */
#endif
{
- U8 isLegacy = 0;
+ uint8_t isLegacy = 0;
#ifdef EMTC_ENABLE
if(cell->emtcEnable)
{
/* Fix: syed Explicitly Inidcate MAC to release RNTI */
rgSCHUtlIndRntiRls2Mac(cell, rntiLnk->rnti, ueIdChngd, newRnti);
- RETVOID;
+ return;
}
*
* @param[in] RgSchCellCb *cell pointer to Cell Control block
* @param[in] RgSchUeCb *ue pointer to Ue Control block
- * @param[in] U8 numCqiRept NUmber of reports to be filled
+ * @param[in] uint8_t numCqiRept NUmber of reports to be filled
* @return Void
*
**/
CmLteTimingInfo frm;
RgmPrbRprtInd *prbRprtInd;
S16 ret = ROK;
- U32 idx;
+ uint32_t idx;
#ifdef DBG_MAC_RRM_PRB_PRINT
- static U32 count = 0;
- const U32 reprotForEvery20Sec = 20000/cell->prbUsage.rprtPeriod;
+ static uint32_t count = 0;
+ const uint32_t reprotForEvery20Sec = 20000/cell->prbUsage.rprtPeriod;
count++;
#endif
frm = cell->crntTime;
RGSCH_INCR_SUB_FRAME(frm, RG_SCH_CMN_DL_DELTA);
- U16 numDlSf;
- U16 numUlSf;
+ uint16_t numDlSf;
+ uint16_t numUlSf;
#ifdef LTE_TDD
if(cell->prbUsage.rprtPeriod >= RGSCH_NUM_SUB_FRAMES)
ueCb->dl.taCb.state = RGSCH_TA_TOBE_SCHEDULED;
rgSCHUtlDlTARpt(cellCb, ueCb);
- RETVOID;
+ return;
}
/* Added function for dropping Paging Message*/
#endif
{
- U32 crntTimeInSubFrms = 0;
- U32 boUpdTimeInSubFrms = 0;
- U32 distance = 0;
+ uint32_t crntTimeInSubFrms = 0;
+ uint32_t boUpdTimeInSubFrms = 0;
+ uint32_t distance = 0;
crntTimeInSubFrms = (cell->crntTime.sfn * RGSCH_NUM_SUB_FRAMES_5G) + cell->crntTime.slot +
RG_SCH_CMN_DL_DELTA + 2; /* As bo received will scheduled in next TTI
*
* @param[in] RgSchCellCb *cell
* @param[in] CmLteTimingInfo phichTime
- * @param[in] U8 hqFdbkIdx
- * @return U8
+ * @param[in] uint8_t hqFdbkIdx
+ * @return uint8_t
**/
#ifdef ANSI
-U8 rgSchUtlCfg0ReTxIdx
+uint8_t rgSchUtlCfg0ReTxIdx
(
RgSchCellCb *cell,
CmLteTimingInfo phichTime,
-U8 hqFdbkIdx
+uint8_t hqFdbkIdx
)
#else
-U8 rgSchUtlCfg0ReTxIdx (cell, phichTime, hqFdbkIdx)
+uint8_t rgSchUtlCfg0ReTxIdx (cell, phichTime, hqFdbkIdx)
RgSchCellCb *cell;
CmLteTimingInfo phichTime;
-U8 hqFdbkIdx;
+uint8_t hqFdbkIdx;
#endif
{
- U8 reTxIdx = RGSCH_INVALID_INFO;
- U8 iPhich = 0;
+ uint8_t reTxIdx = RGSCH_INVALID_INFO;
+ uint8_t iPhich = 0;
RgSchCmnUlCell *cellUl = RG_SCH_CMN_GET_UL_CELL(cell);
RgSchUlSf *ulSf;
- U8 ulSF; /* UL SF in the TDD frame */
+ uint8_t ulSF; /* UL SF in the TDD frame */
ulSf = &cellUl->ulSfArr[hqFdbkIdx];
ulSF = ulSf->ulSfIdx;
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *prbReqrd
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *prbReqrd
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 bo,
-U32 *prbReqrd
+uint32_t bo,
+uint32_t *prbReqrd
)
#else
Void rgSchUtlDlCalc1CwPrb(cell, ue, bo, prbReqrd)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U32 bo;
-U32 *prbReqrd;
+uint32_t bo;
+uint32_t *prbReqrd;
#endif
{
RgSchCmnDlCell *dlCell = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ue, cell);
- U32 eff;
- U32 noRes;
- U8 iTbs;
- U8 cfi = dlCell->currCfi;
+ uint32_t eff;
+ uint32_t noRes;
+ uint8_t iTbs;
+ uint8_t cfi = dlCell->currCfi;
iTbs = dlUe->mimoInfo.cwInfo[0].iTbs[0];
eff = (*(RgSchCmnTbSzEff *)(dlCell->cqiToEffTbl[0][cfi]))[iTbs];
/* Optimization to convert totalBo (which is in-terms of bytes) to bits
* i.e, << 3 and multiply with 1024 i.e, << 10 */
- noRes = ((U64)((bo << 3) << 10)) / (eff);
+ noRes = ((uint64_t)((bo << 3) << 10)) / (eff);
/* Get the number of RBs needed for this transmission */
/* Number of RBs = No of REs / No of REs per RB */
*prbReqrd = RGSCH_CEIL(noRes, dlCell->noResPerRb[cfi]);
- RETVOID;
+ return;
} /* rgSchUtlDlCalc1CwPrb*/
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *prbReqrd
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *prbReqrd
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 bo,
-U32 *prbReqrd
+uint32_t bo,
+uint32_t *prbReqrd
)
#else
Void rgSchUtlDlCalc2CwPrb(cell, ue, bo, prbReqrd)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U32 bo;
-U32 *prbReqrd;
+uint32_t bo;
+uint32_t *prbReqrd;
#endif
{
RgSchCmnDlCell *dlCell = RG_SCH_CMN_GET_DL_CELL(cell);
RgSchCmnDlUe *dlUe = RG_SCH_CMN_GET_DL_UE(ue, cell);
- U32 eff1, eff2;
- U32 noRes;
- U8 noLyr1, noLyr2;
- U8 iTbs1, iTbs2;
- U8 cfi = dlCell->currCfi;
+ uint32_t eff1, eff2;
+ uint32_t noRes;
+ uint8_t noLyr1, noLyr2;
+ uint8_t iTbs1, iTbs2;
+ uint8_t cfi = dlCell->currCfi;
if ((dlUe->mimoInfo.forceTD) ||/* Transmit Diversity (TD) */
(dlUe->mimoInfo.ri < 2))/* 1 layer precoding */
/* Optimization to convert totalBo (which is in-terms of bytes) to bits
* i.e, << 3 and multiply with 1024 i.e, << 10 */
- noRes = ((U64)((bo << 3) << 10)) / (eff1);
+ noRes = ((uint64_t)((bo << 3) << 10)) / (eff1);
/* Get the number of RBs needed for this transmission */
/* Number of RBs = No of REs / No of REs per RB */
*prbReqrd = RGSCH_CEIL(noRes, dlCell->noResPerRb[cfi]);
/* Optimization to convert totalBo (which is in-terms of bytes) to bits
* i.e, << 3 and multiply with 1024 i.e, << 10 */
- noRes = ((U64)((bo << 3) << 10)) / (eff1 + eff2);
+ noRes = ((uint64_t)((bo << 3) << 10)) / (eff1 + eff2);
/* Get the number of RBs needed for this transmission */
/* Number of RBs = No of REs / No of REs per RB */
*prbReqrd = RGSCH_CEIL(noRes, dlCell->noResPerRb[cfi]);
}
- RETVOID;
+ return;
} /* rgSchUtlDlCalc2CwPrb */
/**
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U32 bo
- * @param[out] U32 *prbReqrd
+ * @param[in] uint32_t bo
+ * @param[out] uint32_t *prbReqrd
* @return Void
**/
#ifdef ANSI
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 bo,
-U32 *prbReqrd
+uint32_t bo,
+uint32_t *prbReqrd
)
#else
Void rgSchUtlCalcTotalPrbReq(cell, ue, bo, prbReqrd)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U32 bo;
-U32 *prbReqrd;
+uint32_t bo;
+uint32_t *prbReqrd;
#endif
{
/* Call TM specific Prb calculation routine */
(dlCalcPrbFunc[ue->mimoInfo.txMode - 1])(cell, ue, bo, prbReqrd);
- RETVOID;
+ return;
} /* rgSchUtlCalcTotalPrbReq */
#ifdef UNUSE_FUN
#ifdef TFU_UPGRADE
*
* Desc : Fetch the CQI/PMI bits for a UE based on the mode, periodicity.
*
- * Ret : U8
+ * Ret : uint8_t
* ROK - Success
*
* Notes:
*
**********************************************************/
#ifdef ANSI
-PRIVATE U8 rgSCHUtlFetchPcqiBitSz
+PRIVATE uint8_t rgSCHUtlFetchPcqiBitSz
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
- U8 numTxAnt
+ uint8_t numTxAnt
)
#else
-PRIVATE U8 rgSCHUtlFetchPcqiBitSz (cell, ueCb, numTxAnt)
+PRIVATE uint8_t rgSCHUtlFetchPcqiBitSz (cell, ueCb, numTxAnt)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
-U8 numTxAnt;
+uint8_t numTxAnt;
#endif
{
- U8 confRepMode;
- U8 pcqiSz;
- U8 ri;
+ uint8_t confRepMode;
+ uint8_t pcqiSz;
+ uint8_t ri;
RgSchUePCqiCb *cqiCb = RG_SCH_GET_UE_CELL_CQI_CB(ueCb,cell);
confRepMode = cqiCb->cqiCfg.cqiSetup.prdModeEnum;
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @param[in] U32 *numSbs
- * @return U8
+ * @param[in] uint32_t *numSbs
+ * @return uint8_t
**/
#ifdef ANSI
-U8 rgSchUtlGetNumSbs
+uint8_t rgSchUtlGetNumSbs
(
RgSchCellCb *cell,
RgSchUeCb *ue,
-U32 *numSbs
+uint32_t *numSbs
)
#else
-U8 rgSchUtlGetNumSbs (cell, ue, numSbs)
+uint8_t rgSchUtlGetNumSbs (cell, ue, numSbs)
RgSchCellCb *cell;
RgSchUeCb *ue;
-U32 *numSbs;
+uint32_t *numSbs;
#endif
{
- U32 nPrb;
+ uint32_t nPrb;
//Currently hardcoding MAX prb for each UE
nPrb = ue->ue5gtfCb.maxPrb;
(*numSbs) = RGSCH_CEIL(nPrb, MAX_5GTF_VRBG_SIZE);
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb *ue
- * @return U8
+ * @return uint8_t
**/
#ifdef ANSI
-U8 rgSchUtlSortInsUeLst
+uint8_t rgSchUtlSortInsUeLst
(
RgSchCellCb *cell,
CmLListCp *ueLst,
CmLList *node,
-U8 vrbgRequired
+uint8_t vrbgRequired
)
#else
-U8 rgSchUtlSortInsUeLst (cell, ueLst, node, vrbgRequired)
+uint8_t rgSchUtlSortInsUeLst (cell, ueLst, node, vrbgRequired)
RgSchCellCb *cell;
CmLListCp *ueLst;
CmLList *node;
-U8 vrbgRequired;
+uint8_t vrbgRequired;
#endif
{
CmLList *ueInLst;
*
* @param[in] RgSchCellCb *cell
* @param[in] CmLteRnti crnti
- * @param[in] U8 lcgId
+ * @param[in] uint8_t lcgId
* @param[in] Bool isGbr
* @return S16
* -# ROK
(
RgSchCellCb *cell,
CmLteRnti crnti,
-U8 lcgId,
+uint8_t lcgId,
Bool isGbr
)
#else
S16 rgSCHUtlBuildNSendLcgReg(cell, crnti, lcgId, isGbr)
RgSchCellCb *cell;
CmLteRnti crnti;
-U8 lcgId;
+uint8_t lcgId;
Bool isGbr;
#endif
{
/* Invoke MAC to release the rnti */
rgSCHUtlGetPstToLyr(&pst, &rgSchCb[inst], cell->macInst);
RgSchMacRlsRnti(&pst, &rntiInfo);
- RETVOID;
+ return;
}
/**
*
*
* @param[in] RgrTxMode txMode
- * @return U8 maxTbCount;
+ * @return uint8_t maxTbCount;
* -# ROK
**/
#ifdef ANSI
-U8 rgSCHUtlGetMaxTbSupp
+uint8_t rgSCHUtlGetMaxTbSupp
(
RgrTxMode txMode
)
#else
-U8 rgSCHUtlGetMaxTbSupp(txMode)
+uint8_t rgSCHUtlGetMaxTbSupp(txMode)
RgrTxMode txMode
#endif
{
- U8 maxTbCount;
+ uint8_t maxTbCount;
/* Primary Cell */
*
* @param[in] RgSchCellCb *cell
* @param[in] RgSchUeCb ueCb
- * @param[in] U8 cqiReq,
- * @param[out] U8 *triggerSet
+ * @param[in] uint8_t cqiReq,
+ * @param[out] uint8_t *triggerSet
*
* @return Void
* -# ROK
(
RgSchCellCb *cell,
RgSchUeCb *ueCb,
- U8 cqiReq,
- U8 *triggerSet
+ uint8_t cqiReq,
+ uint8_t *triggerSet
)
#else
PRIVATE S16 rgSCHTomUtlGetTrigSet(cell, ueCb, cqiReq, triggerSet)
RgSchCellCb *cell;
RgSchUeCb *ueCb;
- U8 cqiReq;
- U8 *triggerSet;
+ uint8_t cqiReq;
+ uint8_t *triggerSet;
#endif
{
RgSchUeCellInfo *pCellInfo = RG_SCH_CMN_GET_PCELL_INFO(ueCb);
case RG_SCH_APCQI_SERVING_CC:
{
/* APeriodic CQI request for Current Carrier.*/
- U8 sCellIdx = ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cell)];
+ uint8_t sCellIdx = ueCb->cellIdToCellIdxMap[RG_SCH_CELLINDEX(cell)];
*triggerSet = 1 << (7 - sCellIdx);
break;
}
break;
}
}
- RETVOID;
+ return;
}
#endif
/**
Bool isCsi2Bit;
#endif
{
- U8 dci01aCmnSize = cell->dciSize.baseSize[TFU_DCI_FORMAT_0];
- U8 dci01aDedSize = cell->dciSize.baseSize[TFU_DCI_FORMAT_0];
+ uint8_t dci01aCmnSize = cell->dciSize.baseSize[TFU_DCI_FORMAT_0];
+ uint8_t dci01aDedSize = cell->dciSize.baseSize[TFU_DCI_FORMAT_0];
if ((ueCb->accessStratumRls >= RGR_REL_10) && (cell->bwCfg.dlTotalBw >= cell->bwCfg.ulTotalBw))
{
dci01aCmnSize += 1; /* Resource Allocation Type DCI 0 */
RgSchCellCb *cell;
#endif
{
- U8 dciSize = 0;
- U8 dci01aSize = 0;
- U32 bits = 0, idx = 0;
+ uint8_t dciSize = 0;
+ uint8_t dci01aSize = 0;
+ uint32_t bits = 0, idx = 0;
switch(TFU_DCI_FORMAT_0) /* Switch case for the purpose of readability */
{
dciSize = 1 /* DCI 0 bit indicator */ + \
1 /* Frequency hoping enable bit field */ + \
- (U8)bits /* For frequency Hopping */ + \
+ (uint8_t)bits /* For frequency Hopping */ + \
5 /* MCS */ + \
1 /* NDI */ + \
2 /* TPC */ + \
dciSize += 1 /* Format 1A */ + \
1 /* Local or Distributed */ + \
- (U8)bits /* Resource block Assignment */ + \
+ (uint8_t)bits /* Resource block Assignment */ + \
5 /* MCS */ +
#ifdef TFU_TDD
4 /* HARQ Proc Id */ +
bits++;
}
- dciSize += (U8)bits /* Resource Allocation bits */ + \
+ dciSize += (uint8_t)bits /* Resource Allocation bits */ + \
5 /* MCS */ +
#ifdef TFU_TDD
4 /* HARQ TDD */ +
dciSize = 1; /* Resource Allocation bit */
}
- dciSize += (U8)bits /* Resource Allocation bits */ + \
+ dciSize += (uint8_t)bits /* Resource Allocation bits */ + \
2 /* TPC */ +
#ifdef TFU_TDD
2 /* DAI */ + \
dciSize = 1; /* Resource Allocation bit */
}
- dciSize += (U8)bits /* Resource Allocation bits */ + \
+ dciSize += (uint8_t)bits /* Resource Allocation bits */ + \
2 /* TPC */ +
#ifdef TFU_TDD
2 /* DAI */ + \
RgSchCellCb *cell
#endif
{
- U32 tptDelta;
+ uint32_t tptDelta;
if ((cell->cpuOvrLdCntrl.cpuOvrLdIns) & (RGR_CPU_OVRLD_DL_TPT_UP |
RGR_CPU_OVRLD_DL_TPT_DOWN))
#endif
}
- RETVOID;
+ return;
}
/**
* @brief Handler for the num UE per TTI based CPU OvrLd instr updating
* - If successful, return ROK else RFAILED.
*
* @param[in] RgSchCellCb *cell
- * @param[in] U8 cnrtCpuOvrLdIns
+ * @param[in] uint8_t cnrtCpuOvrLdIns
* @return Void
**/
#ifdef ANSI
PRIVATE Void rgSCHUtlChkAndUpdNumUePerTtiCpuOvInstr
(
RgSchCellCb *cell,
- U8 crntCpuOvrLdIns
+ uint8_t crntCpuOvrLdIns
)
#else
PRIVATE S16 rgSCHUtlChkAndUpdNumUePerTtiCpuOvInstr(cell, crntCpuOvrLdIns)
RgSchCellCb *cell;
- U8 crntCpuOvrLdIns;
+ uint8_t crntCpuOvrLdIns;
#endif
{
RgSchCpuOvrLdCntrlCb *cpuInstr = &(cell->cpuOvrLdCntrl);
RgSchCmnCell *cellSch;
- U8 maxUeNewDlTxPerTti;
- U8 maxUeNewUlTxPerTti;
- U8 tmpslot = 0;
+ uint8_t maxUeNewDlTxPerTti;
+ uint8_t maxUeNewUlTxPerTti;
+ uint8_t tmpslot = 0;
#ifdef CPU_OL_DBG_PRINTS
- U8 idx = 0;
+ uint8_t idx = 0;
#endif
- U8 maxDlDecCnt;
- U8 maxUlDecCnt;
+ uint8_t maxDlDecCnt;
+ uint8_t maxUlDecCnt;
cellSch = RG_SCH_CMN_GET_CELL(cell);
printf("\n");
#endif
- RETVOID;
+ return;
} /* rgSCHUtlChkAndUpdNumUePerTtiCpuOvInstr */
/**
* - If successful, return ROK else RFAILED.
*
* @param[in] RgSchCellCb *cell
- * @param[in] U8 cnrtCpuOvrLdIns
+ * @param[in] uint8_t cnrtCpuOvrLdIns
* @return S16
* -# ROK
* -# RFAILED
S16 rgSCHUtlResetCpuOvrLdState
(
RgSchCellCb *cell,
- U8 crntCpuOvrLdIns
+ uint8_t crntCpuOvrLdIns
)
#else
S16 rgSCHUtlResetCpuOvrLdState(cell, crntCpuOvrLdIns)
RgSchCellCb *cell;
- U8 crntCpuOvrLdIns;
+ uint8_t crntCpuOvrLdIns;
#endif
{
- U8 crntDlCpuOL=0;
- U8 crntUlCpuOL=0;
+ uint8_t crntDlCpuOL=0;
+ uint8_t crntUlCpuOL=0;
RgSchCmnCell *schCmnCell = (RgSchCmnCell *)(cell->sc.sch);
- U8 idx;
+ uint8_t idx;
#ifdef CPU_OL_DBG_PRINTS
printf("\n CPU OVR LD Ins Rcvd = %d\n", (int)crntCpuOvrLdIns);
lCp->crnt = (RgSchRrCList *)NULLP;
lCp->count = 0;
- RETVOID;
+ return;
} /* end of rgSCHRrCListInit */
/* LTE_ADV_FLAG_REMOVED_START */
{
#ifdef ERRCHK
if (lCp == (RgSchRrCListCp *)NULLP)
- RETVOID;
+ return;
#endif
lCp->count++;
lCp->crnt = lCp->first;
- RETVOID;
+ return;
}
node->next = lCp->crnt;
lCp->crnt->prev->next = node;
lCp->crnt->prev = node;
- RETVOID;
+ return;
}
/* LTE_ADV_FLAG_REMOVED_END */
#ifdef ERRCHK
if (lCp == (RgSchRrCListCp *)NULLP)
- RETVOID;
+ return;
#endif
lCp->count++;
lCp->crnt = lCp->first;
- RETVOID;
+ return;
}
node->next = lCp->first;
lCp->first->prev->next = node;
lCp->first->prev = node;
- RETVOID;
+ return;
} /* end of rgSCHRrCListAdd2Tail */
/*
#ifdef ERRCHK
if (lCp == (RgSchRrCListCp *)NULLP)
- RETVOID;
+ return;
#endif
crnt = lCp->crnt;
lCp->count++;
- RETVOID;
+ return;
}
/********************************************************************30**
* reason for success/failure of this function.
*
* @param[in] RgCfg *cfg, the Configuaration information
- * @return U16
+ * @return uint16_t
* -# LCM_REASON_NOT_APPL
* -# LCM_REASON_INVALID_MSGTYPE
* -# LCM_REASON_MEM_NOAVAIL
**/
uint8_t SchProcGenCfgReq(Pst *pst, RgMngmt *cfg)
{
- uint8_t ret = LCM_PRIM_OK;
- uint16_t reason = LCM_REASON_NOT_APPL;
+ uint8_t ret = LCM_PRIM_OK;
+ uint16_t reason = LCM_REASON_NOT_APPL;
RgMngmt cfm;
Pst cfmPst;
/* allocate and zero out a static buffer */
#define SCH_ALLOC(_datPtr, _size) \
{ \
- int _ret; \
+ uint8_t _ret; \
_ret = SGetSBuf(SCH_MEM_REGION, SCH_POOL, \
(Data **)&_datPtr, _size); \
if(_ret == ROK) \
(
Pst *pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 cmPkCkwBndCfm(pst, suId, status)
Pst *pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
S16 ret1;
for (idx = param->numEnt-1; idx >= 0; idx--)
{
- CMCHKPK(cmPkRlcEntCfgCfmInfo, &(param->entCfgCfm[(U8)idx]), mBuf);
+ CMCHKPK(cmPkRlcEntCfgCfmInfo, &(param->entCfgCfm[(uint8_t)idx]), mBuf);
}
CMCHKPK(oduUnpackUInt8, param->numEnt, mBuf);
(
Pst *pst,
SpId spId,
-U32 transId,
+uint32_t transId,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo
)
S16 cmPkCkwUeIdChgReq(pst, spId, transId, ueInfo, newUeInfo)
Pst *pst;
SpId spId;
-U32 transId;
+uint32_t transId;
CkwUeInfo *ueInfo;
CkwUeInfo *newUeInfo;
#endif
(
Pst *pst,
SuId suId,
-U32 transId,
+uint32_t transId,
CkwUeInfo *ueInfo,
CmStatus status
)
S16 cmPkCkwUeIdChgCfm(pst, suId, transId, ueInfo, status)
Pst *pst;
SuId suId;
-U32 transId;
+uint32_t transId;
CkwUeInfo *ueInfo;
CmStatus status;
#endif
#endif
{
SuId suId = 0;
- U8 status = 0;
+ uint8_t status = 0;
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, ECKW028, pst);
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPKLOG(oduPackUInt32, &(param->transId), mBuf, ECKW030, pst);
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPKLOG(oduPackUInt32, &(param->transId), mBuf, ECKW031, pst);
{
S16 ret1;
SpId spId = 0;
- U32 transId = 0;
+ uint32_t transId = 0;
CkwUeInfo *ueInfo = NULLP;
CkwUeInfo *newUeInfo = NULLP;
{
S16 ret1;
SuId suId = 0;
- U32 transId = 0;
+ uint32_t transId = 0;
CkwUeInfo *ueInfo = NULLP;
CmStatus status;
Logical Channel Information */
typedef struct ckwLChInfo
{
- U8 lChId; /*!< Logical Channel ID.
+ uint8_t lChId; /*!< Logical Channel ID.
The allowed values are [1..10] */
- U8 type; /*!< Logical Channel Type -
+ uint8_t type; /*!< Logical Channel Type -
BCCH/PCCH/CCCH/DTCH/DCCH */
}CkwLChInfo;
{
struct _umDl
{
- U8 snLen; /*!< Sequence Number length in bits. Allowed values are 6 and 12*/
+ uint8_t snLen; /*!< Sequence Number length in bits. Allowed values are 6 and 12*/
}dl; /*!< Downlink */
struct _umUl
{
- U8 snLen; /*!< Sequence Number length in bits.*/
+ uint8_t snLen; /*!< Sequence Number length in bits.*/
/*!< Allowed values are 6 and 12*/
- U8 reOrdTmr; /*!< T_reordering Timer in msec */
+ uint8_t reOrdTmr; /*!< T_reordering Timer in msec */
}ul; /*!< Uplink */
}RlcUmInfo;
{
struct _amDl
{
- U8 snLen; /*!< Sequence Number length in
+ uint8_t snLen; /*!< Sequence Number length in
bits. Allowed values are 12 and 18 */
- U16 pollRetxTmr; /*!< T_poll_retransmit Timer in msec */
+ uint16_t pollRetxTmr; /*!< T_poll_retransmit Timer in msec */
S16 pollPdu; /*!< Used to trigger a poll for every pollPdu.*/
/*!< This field indicates the number of PDUs */
/* Patch ckw_x_001.main_5 */
/* !<For Infinite, RLC expects value 0xFFFF */
S32 pollByte; /*!< Poll_Byte in bytes. */
/*!<For Infinite RLC expects value 0xFFFFFFFF */
- U8 maxRetx; /*!< Max_Retx_Threshold */
+ uint8_t maxRetx; /*!< Max_Retx_Threshold */
}dl; /*!< Down link */
struct _amUl
{
- U8 snLen; /*!< Sequence Number length in
+ uint8_t snLen; /*!< Sequence Number length in
bits. Allowed values are 12 and 18 */
- U16 staProhTmr; /*!< T_status_prohibit Timer in msec*/
- U8 reOrdTmr; /*!< T_reordering Timer in msec*/
+ uint16_t staProhTmr; /*!< T_status_prohibit Timer in msec*/
+ uint8_t reOrdTmr; /*!< T_reordering Timer in msec*/
}ul; /*!< Up link */
}RlcAmInfo;
{
struct _tmDl
{
- U32 buffSize; /*!< Buffer Size in bytes */
+ uint32_t buffSize; /*!< Buffer Size in bytes */
}dl; /*!< Down link */
}RlcTmInfo;
Entity Configuration Information */
typedef struct rlcEntCfgInfo
{
- U8 cfgType; /*!< Type of Configuration -
+ uint8_t cfgType; /*!< Type of Configuration -
ADD/MODIFY/DELETE/RE-ESTABLISH/
DELTEUE */
- U8 rbId; /* RB ID. The allowed
+ uint8_t rbId; /* RB ID. The allowed
Values are [0..255] */
- U8 rbType; /* Type of the RB - can be SRB or DRB */
- U8 qci; /*!< qCI value Associated with that RB */
+ uint8_t rbType; /* Type of the RB - can be SRB or DRB */
+ uint8_t qci; /*!< qCI value Associated with that RB */
CkwLChInfo lCh[CM_LTE_MAX_LOGCH_PER_RB]; /*!< Logical channel
information
In case of AM mode:
In case of TM/UM idx 0 is only
applicable */
CmLteRlcMode entMode; /*!< Entity mode: AM, UM or TM */
- U8 dir; /*!< Direction: It can be either
+ uint8_t dir; /*!< Direction: It can be either
UL / DL for TM mode
UL / DL or BOTH for UM mode
and for AM its always for both UL
Configuration Information from RRC to RLC */
typedef struct rlcCfgInfo
{
- U32 transId; /*!< Transaction Id */
+ uint32_t transId; /*!< Transaction Id */
CmLteRnti ueId; /*!< UE ID */
CmLteCellId cellId; /*!< Cell ID */
- U8 numEnt; /*!< Number of entities to
+ uint8_t numEnt; /*!< Number of entities to
configure */
RlcEntCfgInfo entCfg[CKW_MAX_ENT_CFG]; /*!< Array of Entities to be
configure */
Entity Configuration Confirmation Information */
typedef struct rlcEntCfgCfmInfo
{
- U8 rbId; /*!< rb ID */
- U8 rbType; /*!< RB type - can be SRB or DRB */
+ uint8_t rbId; /*!< rb ID */
+ uint8_t rbType; /*!< RB type - can be SRB or DRB */
CmStatus status; /*!< Status of the confirmation */
}RlcEntCfgCfmInfo;
Configuration Confirmation Informatin RLC to RRC */
typedef struct rlcCfgCfmInfo
{
- U32 transId; /*!< Transaction Id */
+ uint32_t transId; /*!< Transaction Id */
CmLteRnti ueId; /*!< UE ID */
CmLteCellId cellId; /*!< Cell ID */
- U8 numEnt; /*!< Number of entities configured */
+ uint8_t numEnt; /*!< Number of entities configured */
RlcEntCfgCfmInfo entCfgCfm[CKW_MAX_ENT_CFG]; /*!< Array of Entity cfg
confiramations */
}RlcCfgCfmInfo;
typedef S16 (*RlcCfgReq) ARGS((Pst *pst, RlcCfgInfo *cfgInfo));
typedef S16 (*RlcCfgCfm) ARGS((Pst *pst, SuId suId, RlcCfgCfmInfo *cfmInfo));
-typedef S16 (*CkwUeIdChgReq) ARGS((Pst *pst, SpId spId, U32 transId,
+typedef S16 (*CkwUeIdChgReq) ARGS((Pst *pst, SpId spId, uint32_t transId,
CkwUeInfo *ueInfo, CkwUeInfo *newUeInfo));
-typedef S16 (*CkwUeIdChgCfm) ARGS((Pst *pst, SuId suId, U32 transId,
+typedef S16 (*CkwUeIdChgCfm) ARGS((Pst *pst, SuId suId, uint32_t transId,
CkwUeInfo *ueInfo, CmStatus status));
typedef S16 (*CkwBndReq) ARGS((Pst *pst, SuId suId, SpId spId));
-typedef S16 (*CkwBndCfm) ARGS((Pst *pst, SuId suId, U8 status));
+typedef S16 (*CkwBndCfm) ARGS((Pst *pst, SuId suId, uint8_t status));
typedef S16 (*CkwUbndReq) ARGS((Pst *pst, SpId spId, Reason reason));
/**
CM_BND_NOK: Error encountered during the processing of the bind request.
* @return ROK
*/
-EXTERN S16 RlcUiCkwBndCfm ARGS((Pst *pst, SuId suId, U8 status));
+EXTERN S16 RlcUiCkwBndCfm ARGS((Pst *pst, SuId suId, uint8_t status));
/**
* @details The RLC service user initiates this primitive for performing
* @param[in] newUeInfo - New UE Id Info for existing UE context.
* @return ROK
*/
-EXTERN S16 RlcUiCkwUeIdChgReq ARGS((Pst *pst, SpId spId, U32 transId,
+EXTERN S16 RlcUiCkwUeIdChgReq ARGS((Pst *pst, SpId spId, uint32_t transId,
CkwUeInfo *ueInfo, CkwUeInfo *newUeInfo));
/**
* information.
* @return ROK
*/
-EXTERN S16 RlcUiCkwUeIdChgCfm ARGS((Pst *pst, SuId suId, U32 transId,
+EXTERN S16 RlcUiCkwUeIdChgCfm ARGS((Pst *pst, SuId suId, uint32_t transId,
CkwUeInfo *ueInfo, CmStatus status));
/* RRC Extern declarations */
EXTERN S16 NhLiCkwBndCfm ARGS((Pst *pst,
SuId suId,
- U8 status));
+ uint8_t status));
EXTERN S16 NhLiRlcCfgReq ARGS((
Pst *pst,
RlcCfgCfmInfo* cfmInfo));
EXTERN S16 NhLiCkwUeIdChgReq ARGS((Pst *pst,
- SpId spId, U32 transId,
+ SpId spId, uint32_t transId,
CkwUeInfo *ueInfo, CkwUeInfo *newUeInfo));
EXTERN S16 NhLiCkwUeIdChgCfm ARGS((Pst *pst,
- SuId suId, U32 transId,
+ SuId suId, uint32_t transId,
CkwUeInfo *ueInfo, CmStatus status));
#endif /* NH */
EXTERN S16 DmUiCkwBndCfm ARGS((Pst *pst,
SuId suId,
- U8 status));
+ uint8_t status));
EXTERN S16 DmUiRlcCfgReq ARGS((
Pst *pst,
RlcCfgCfmInfo* cfmInfo));
EXTERN S16 DmUiCkwUeIdChgReq ARGS((Pst *pst,
- SpId spId, U32 transId,
+ SpId spId, uint32_t transId,
CkwUeInfo *ueInfo, CkwUeInfo *newUeInfo));
EXTERN S16 DmUiCkwUeIdChgCfm ARGS((Pst *pst,
- SuId suId, U32 transId,
+ SuId suId, uint32_t transId,
CkwUeInfo *ueInfo, CmStatus status));
#endif /* DM */
EXTERN S16 cmPkCkwBndCfm ARGS ((
Pst *pst,
SuId suId,
-U8 status
+uint8_t status
));
EXTERN S16 packUeCreateReq ARGS ((
EXTERN S16 cmPkCkwUeIdChgReq ARGS ((
Pst *pst,
SpId spId,
-U32 transId,
+uint32_t transId,
CkwUeInfo *ueInfo,
CkwUeInfo *newUeInfo
));
EXTERN S16 cmPkCkwUeIdChgCfm ARGS ((
Pst *pst,
SuId suId,
-U32 transId,
+uint32_t transId,
CkwUeInfo *ueInfo,
CmStatus status
));
typedef struct cmTimer /* timer structure */
{
S16 tmrEvnt; /* Timer Event */
- U32 tqExpire; /* Timing Queue Expiry */
+ uint32_t tqExpire; /* Timing Queue Expiry */
PTR cb; /* Pointer to start of control block list */
struct cmTimer *next; /* Next item in the timing queue */
struct cmTimer *prev; /* Previous item in the timing queue */
- U8 ent2bUpd; /* TRUE, if the timer block is not in the
+ uint8_t ent2bUpd; /* TRUE, if the timer block is not in the
proper bin */
- U16 entIdx; /* Current entry index */
+ uint16_t entIdx; /* Current entry index */
} CmTimer;
typedef struct cmTqCp /* timing queue control point */
{
- U32 nxtEnt; /* next Entry */
- U32 tmrLen; /* length of timer (MODULO is -1) */
+ uint32_t nxtEnt; /* next Entry */
+ uint32_t tmrLen; /* length of timer (MODULO is -1) */
CmTimer *tmp; /* Temporary variable used in cmPrcTmr */
} CmTqCp;
CmTimer *timers; /* timers array */
PTR cb; /* control block pointer */
S16 evnt; /* event */
- U32 wait; /* wait */
- U8 tNum; /* timer number */
- U8 max; /* max timers */
+ uint32_t wait; /* wait */
+ uint8_t tNum; /* timer number */
+ uint8_t max; /* max timers */
} CmTmrArg;
\f
typedef Void (*PFV) ARGS((PTR, S16));
-extern Void cmInitTimers ARGS((CmTimer* timers, U8 max));
+extern Void cmInitTimers ARGS((CmTimer* timers, uint8_t max));
extern Void cmPlcCbTq ARGS((CmTmrArg* arg));
extern Void cmRmvCbTq ARGS((CmTmrArg* arg));
extern Void cmPrcTmr ARGS((CmTqCp* tqCp, CmTqType* tq, PFV func));
*
* Desc: Handle a timer entry
*
-* Ret: RETVOID
+* Ret: void
*
* Notes:
*
#endif
{
/**/
- U32 expire;
- U32 entry;
+ uint32_t expire;
+ uint32_t entry;
S16 event;
PTR cb;
CmTimer *tmp1;
++tqCp->nxtEnt;
expire = tqCp->nxtEnt;
/* cm_bdy5_c_002.113 - Modification for SRegCfgTmr support */
- entry = (U32) (expire % (U32)(tqCp->tmrLen));
+ entry = (uint32_t) (expire % (uint32_t)(tqCp->tmrLen));
tmp2 = &tq[entry].first;
while ((tmp1 = *tmp2) != NULLP)
else
tmp2 = &tmp1->next;
}
- RETVOID;
+ return;
} /* end of cmPrcTmr */
#else /* not defined SS_FAP */
#endif
{
/**/
- U32 expire;
- U32 entry, entry1;
+ uint32_t expire;
+ uint32_t entry, entry1;
S16 event;
CmTqType *tqEnt, *tqEnt1;
PTR cb;
CmTimer *tmp1;
- VOLATILE U32 startTime = 0;
+ VOLATILE uint32_t startTime = 0;
/*starting Task*/
++tqCp->nxtEnt;
expire = tqCp->nxtEnt;
tqCp->tmrLen = 1;
- entry = (U32) (expire % (U32)(tqCp->tmrLen));
+ entry = (uint32_t) (expire % (uint32_t)(tqCp->tmrLen));
tqCp->tmp = (tqEnt = &tq[entry])->first;
while ((tmp1 = tqCp->tmp) != NULLP)
}
else
{
- entry1 = (U32) (tmp1->tqExpire % (U32)(tqCp->tmrLen));
+ entry1 = (uint32_t) (tmp1->tqExpire % (uint32_t)(tqCp->tmrLen));
tqEnt1 = &tq[entry1];
CM_RMV_TQCP(tqEnt, tmp1);
tmp1->entIdx = entry1;
/*stoping Task*/
SStopTask(startTime, PID_CM_PRC_TMR);
- RETVOID;
+ return;
} /* end of cmPrcTmr */
#endif /* SS_FAP */
*
* Desc: initialize timers
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: Connection Oriented Control
*
Void cmInitTimers
(
CmTimer *timers, /* timer list */
-U8 max /* maximum tmrs */
+uint8_t max /* maximum tmrs */
)
#else
Void cmInitTimers(timers, max)
CmTimer *timers; /* timer list */
-U8 max; /* maximum tmrs */
+uint8_t max; /* maximum tmrs */
#endif
{
CmTimer *tPtr;
- REG1 U8 i;
+ REG1 uint8_t i;
for (i = 0, tPtr = timers; i < max; i++, tPtr++)
tPtr->prev = (struct cmTimer *)NULLP;
tPtr->ent2bUpd = FALSE;
}
- RETVOID;
+ return;
} /* end of cmInitTimers */
/*
*
* Desc: Places Control Block on Timing Queue
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: None
*
{
/*added FAP modifications*/
#ifdef SS_FAP
- REG1 U8 tmrNum;
+ REG1 uint8_t tmrNum;
/* cm_bdy5_c_001.main_20 - Modification for SRegCfgTmr support */
- U32 ent;
- U32 expire;
+ uint32_t ent;
+ uint32_t expire;
CmTimer **tmp;
expire = (arg->tqCp->nxtEnt + arg->wait);
/* cm_bdy5_c_002.113 - Modification for SRegCfgTmr support */
- ent = (U32)(expire % (U32)(arg->tqCp->tmrLen));
+ ent = (uint32_t)(expire % (uint32_t)(arg->tqCp->tmrLen));
for (tmrNum = 0; tmrNum < arg->max; tmrNum++)
{
tmp = &((*tmp)->next);
*tmp = &arg->timers[tmrNum];
- RETVOID;
+ return;
}
}
- RETVOID;
+ return;
#else
- REG1 U8 tmrNum;
- U32 ent;
+ REG1 uint8_t tmrNum;
+ uint32_t ent;
CmTqType *tq;
CmTimer *target;
- U32 expire;
+ uint32_t expire;
expire = (arg->tqCp->nxtEnt + arg->wait);
- ent = (U32)(expire % (U32)(arg->tqCp->tmrLen));
+ ent = (uint32_t)(expire % (uint32_t)(arg->tqCp->tmrLen));
for (tmrNum = 0; tmrNum < arg->max; tmrNum++)
{
/* Place the timer block in the timer list */
CM_PLC_TQCP(tq, target);
- RETVOID;
+ return;
}
}
- RETVOID;
+ return;
#endif
} /* end of cmPlcCbTq */
*
* Desc: Places Control Block on Timing Queue
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: None
*
arg->timers[arg->tNum].tqExpire = arg->tqCp->nxtEnt + arg->wait;
arg->timers[arg->tNum].ent2bUpd = TRUE;
- RETVOID;
+ return;
} /* end of cmRstCbTq */
/*
*
* Desc: Removes control block from Timing Queue
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: None
*
/*Added FAP modifications*/
#ifdef SS_FAP
/* cm_bdy5_c_002.113 - Modification for SRegCfgTmr support */
- U32 ent;
+ uint32_t ent;
CmTimer *target;
CmTimer *tmp1;
CmTimer **tmp2;
if (target->tmrEvnt != TMR_NONE)
{
/* cm_bdy5_c_002.113 - Modification for SRegCfgTmr support */
- ent = (U32) (target->tqExpire % (U32)(arg->tqCp->tmrLen));
+ ent = (uint32_t) (target->tqExpire % (uint32_t)(arg->tqCp->tmrLen));
tmp2 = &arg->tq[ent].first;
while ((tmp1 = *tmp2) != NULLP)
tmp2 = &tmp1->next;
}
}
- RETVOID;
+ return;
#else
- U32 ent;
+ uint32_t ent;
CmTimer *target;
CmTqType *tq;
target = &arg->timers[arg->tNum];
if (target->tmrEvnt != TMR_NONE)
{
- ent = (U32) (target->entIdx);
+ ent = (uint32_t) (target->entIdx);
tq = &arg->tq[ent];
/*
target->cb = NULLP;
}
- RETVOID;
+ return;
#endif
} /* end of cmRmvCbTq */
/* functions in other modules */
/* public variable declarations */
-U16 gTransId = 0;
+uint16_t gTransId = 0;
/* private variable declarations */
{
Data pkArray[PTRSIZE]; /* array for packing */
S16 ret; /* return code */
- U16 tmp; /* temporary value */
+ uint16_t tmp; /* temporary value */
#if (defined(ALPHA) || defined(BIT_64))
- U32 tmp32;
+ uint32_t tmp32;
#endif
case 4:
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp = (U16) GetHiWord(ptr);
+ tmp = (uint16_t) GetHiWord(ptr);
pkArray[0] = (Data) GetHiByte(tmp);
pkArray[1] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(ptr);
+ tmp = (uint16_t) GetLoWord(ptr);
pkArray[2] = (Data) GetHiByte(tmp);
pkArray[3] = (Data) GetLoByte(tmp);
#else /* forward compatibility, packing order */
- tmp = (U16) GetHiWord(ptr);
+ tmp = (uint16_t) GetHiWord(ptr);
pkArray[3] = (Data) GetHiByte(tmp);
pkArray[2] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(ptr);
+ tmp = (uint16_t) GetLoWord(ptr);
pkArray[1] = (Data) GetHiByte(tmp);
pkArray[0] = (Data) GetLoByte(tmp);
#endif
case 8:
#if (defined(ALPHA) || defined(BIT_64))
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp32 = (U32) GetHi32Bit(ptr);
- tmp = (U16) GetHiWord(tmp32);
+ tmp32 = (uint32_t) GetHi32Bit(ptr);
+ tmp = (uint16_t) GetHiWord(tmp32);
pkArray[0] = (Data) GetHiByte(tmp);
pkArray[1] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(tmp32);
+ tmp = (uint16_t) GetLoWord(tmp32);
pkArray[2] = (Data) GetHiByte(tmp);
pkArray[3] = (Data) GetLoByte(tmp);
- tmp32 = (U32) GetLo32Bit(ptr);
- tmp = (U16) GetHiWord(tmp32);
+ tmp32 = (uint32_t) GetLo32Bit(ptr);
+ tmp = (uint16_t) GetHiWord(tmp32);
pkArray[4] = (Data) GetHiByte(tmp);
pkArray[5] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(tmp32);
+ tmp = (uint16_t) GetLoWord(tmp32);
pkArray[6] = (Data) GetHiByte(tmp);
pkArray[7] = (Data) GetLoByte(tmp);
#else /* forward compatibility, packing order */
- tmp32 = (U32) GetHi32Bit(ptr);
- tmp = (U16) GetHiWord(tmp32);
+ tmp32 = (uint32_t) GetHi32Bit(ptr);
+ tmp = (uint16_t) GetHiWord(tmp32);
pkArray[7] = (Data) GetHiByte(tmp);
pkArray[6] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(tmp32);
+ tmp = (uint16_t) GetLoWord(tmp32);
pkArray[5] = (Data) GetHiByte(tmp);
pkArray[4] = (Data) GetLoByte(tmp);
- tmp32 = (U32) GetLo32Bit(ptr);
- tmp = (U16) GetHiWord(tmp32);
+ tmp32 = (uint32_t) GetLo32Bit(ptr);
+ tmp = (uint16_t) GetHiWord(tmp32);
pkArray[3] = (Data) GetHiByte(tmp);
pkArray[2] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(tmp32);
+ tmp = (uint16_t) GetLoWord(tmp32);
pkArray[1] = (Data) GetHiByte(tmp);
pkArray[0] = (Data) GetLoByte(tmp);
#endif
break;
#endif
default:
- /* no support for U64 */
+ /* no support for uint64_t */
ret = RFAILED;
}
Buffer *mBuf; /* buffer */
#endif
{
- U8 j; /* Index */
+ uint8_t j; /* Index */
#ifdef CM_ARI2
Buffer *mBuf; /* buffer */
#endif
{
- U8 i; /* index */
- U8 j; /* Index */
+ uint8_t i; /* index */
+ uint8_t j; /* Index */
ProtAddr *pAddr; /* protocol Address */
Buffer *mBuf; /* message buffer */
#endif
{
- U8 i; /* loop counter */
+ uint8_t i; /* loop counter */
if (addrs->length > ADRLEN)
Buffer *mBuf; /* message buffer */
#endif
{
- U8 i; /* loop counter */
+ uint8_t i; /* loop counter */
if (addrs->length > SHRTADRLEN)
#ifdef ANSI
S16 cmPkAddrMask
(
-U8 *mask, /* pointer to address mask array */
+uint8_t *mask, /* pointer to address mask array */
Buffer *mBuf /* message buffer */
)
#else
S16 cmPkAddrMask(mask, mBuf)
-U8 *mask; /* pointer to address mask array */
+uint8_t *mask; /* pointer to address mask array */
Buffer *mBuf; /* message buffer */
#endif
{
\f
/*
*
- * Fun: cmPkTknU8
+ * Fun: cmPkTknUInt8
*
- * Desc: This function packs a token U8
+ * Desc: This function packs a token uint8_t
*
* Ret: ROK - ok
*
*/
#ifdef ANSI
-S16 cmPkTknU8
+S16 cmPkTknUInt8
(
-TknU8 *tknU8, /* token U8 */
+TknUInt8 *tknUInt8, /* token uint8_t */
Buffer *mBuf /* message buffer */
)
#else
-S16 cmPkTknU8(tknU8, mBuf)
-TknU8 *tknU8; /* token U8 */
+S16 cmPkTknUInt8(tknUInt8, mBuf)
+TknUInt8 *tknUInt8; /* token uint8_t */
Buffer *mBuf; /* message buffer */
#endif
{
- if (tknU8->pres)
+ if (tknUInt8->pres)
{
/* Value */
- CMCHKPK(oduUnpackUInt8, tknU8->val, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknUInt8->val, mBuf);
}
/* Token Header */
- CMCHKPK(oduUnpackUInt8, tknU8->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknUInt8->pres, mBuf);
return ROK;
-} /* end of cmPkTknU8 */
+} /* end of cmPkTknUInt8 */
\f
/*
\f
/*
*
- * Fun: cmPkTknU16
+ * Fun: cmPkTknUInt16
*
- * Desc: This function packs a token U16
+ * Desc: This function packs a token uint16_t
*
* Ret: ROK - ok
*
*/
#ifdef ANSI
-S16 cmPkTknU16
+S16 cmPkTknUInt16
(
-TknU16 *tknU16, /* token U16 */
+TknUInt16 *tknUInt16, /* token uint16_t */
Buffer *mBuf /* message buffer */
)
#else
-S16 cmPkTknU16(tknU16, mBuf)
-TknU16 *tknU16; /* token U16 */
+S16 cmPkTknUInt16(tknUInt16, mBuf)
+TknUInt16 *tknUInt16; /* token uint16_t */
Buffer *mBuf; /* message buffer */
#endif
{
- if (tknU16->pres)
+ if (tknUInt16->pres)
{
/* Value */
- CMCHKPK(oduUnpackUInt16, tknU16->val, mBuf);
+ CMCHKPK(oduUnpackUInt16, tknUInt16->val, mBuf);
}
/* Token Header */
- CMCHKPK(oduUnpackUInt8, tknU16->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknUInt16->pres, mBuf);
return ROK;
-} /* end of cmPkTknU16 */
+} /* end of cmPkTknUInt16 */
\f
/*
*
- * Fun: cmPkTknU32
+ * Fun: cmPkTknUInt32
*
- * Desc: This function packs a token U32
+ * Desc: This function packs a token uint32_t
*
* Ret: ROK - ok
*
*/
#ifdef ANSI
-S16 cmPkTknU32
+S16 cmPkTknUInt32
(
-TknU32 *tknU32, /* token U32 */
+TknUInt32 *tknUInt32, /* token uint32_t */
Buffer *mBuf /* message buffer */
)
#else
-S16 cmPkTknU32(tknU32, mBuf)
-TknU32 *tknU32; /* token U32 */
+S16 cmPkTknUInt32(tknUInt32, mBuf)
+TknUInt32 *tknUInt32; /* token uint32_t */
Buffer *mBuf; /* message buffer */
#endif
{
- if (tknU32->pres)
+ if (tknUInt32->pres)
{
/* Value */
- CMCHKPK(oduUnpackUInt32, tknU32->val, mBuf);
+ CMCHKPK(oduUnpackUInt32, tknUInt32->val, mBuf);
}
/* Token Header */
- CMCHKPK(oduUnpackUInt8, tknU32->pres, mBuf);
+ CMCHKPK(oduUnpackUInt8, tknUInt32->pres, mBuf);
return ROK;
-} /* end of cmPkTknU32 */
+} /* end of cmPkTknUInt32 */
\f
/*
Buffer *mBuf; /* message buffer */
#endif
{
- U16 i;
+ uint16_t i;
if (tknOid->pres == TRUE)
{
/* Pack the value */
- for (i = 0; i < (U16)tknOid->len; i++)
+ for (i = 0; i < (uint16_t)tknOid->len; i++)
{
- /* cm_gen_c_001.main_33: changes for TknOid value from U16 to U32
- * with compilation flag TKNOID_U16 */
-#ifndef TKNOID_U16
+ /* cm_gen_c_001.main_33: changes for TknOid value from uint16_t to uint32_t
+ * with compilation flag TKNOID_UINT16 */
+#ifndef TKNOID_UINT16
CMCHKPK(oduUnpackUInt32, tknOid->val[i], mBuf);
#else
CMCHKPK(oduUnpackUInt16, tknOid->val[i], mBuf);
-#endif /* !TKNOID_U16 */
+#endif /* !TKNOID_UINT16 */
}
/* Pack the length */
CMCHKPK(oduUnpackUInt8, tknOid->len, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- U16 tmp16; /* temporary value */
- U32 tmp32; /* temporary value */
+ uint16_t tmp16; /* temporary value */
+ uint32_t tmp32; /* temporary value */
Data unpkArray[PTRSIZE]; /* unpacking array */
S16 ret; /* return code */
#if (defined(ALPHA) || defined(BIT_64))
- U64 tmp64;
+ uint64_t tmp64;
#endif
tmp16 = 0;
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
#else /* forward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
#endif
*ptr = tmp16;
break;
tmp16 = 0;
tmp32 = 0;
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[3]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[2]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[3]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[2]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
#else /* forward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[2]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[3]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[2]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[3]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
#endif
*ptr = tmp32;
break;
tmp32 = 0;
tmp64 = 0;
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[7]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[6]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[5]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[4]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
- tmp64 = (U64) PutHi32Bit(tmp64, tmp32);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[3]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[2]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
- tmp64 = (U64) PutLo32Bit(tmp64, tmp32);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[7]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[6]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[5]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[4]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
+ tmp64 = (uint64_t) PutHi32Bit(tmp64, tmp32);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[3]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[2]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
+ tmp64 = (uint64_t) PutLo32Bit(tmp64, tmp32);
#else /* forward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[2]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[3]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
- tmp64 = (U64) PutHi32Bit(tmp64, tmp32);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[4]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[5]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[6]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[7]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
- tmp64 = (U64) PutLo32Bit(tmp64, tmp32);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[2]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[3]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
+ tmp64 = (uint64_t) PutHi32Bit(tmp64, tmp32);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[4]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[5]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[6]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[7]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
+ tmp64 = (uint64_t) PutLo32Bit(tmp64, tmp32);
#endif
*ptr = tmp64;
break;
#endif
default:
- /* no support for U64 */
+ /* no support for uint64_t */
ret = RFAILED;
}
Buffer *mBuf; /* buffer */
#endif
{
- U8 j; /* Index */
+ uint8_t j; /* Index */
CMCHKUNPK(oduPackUInt16, &(pAddr->protType), mBuf);
Buffer *mBuf; /* buffer */
#endif
{
- U8 i; /* index */
- U8 j; /* Index */
+ uint8_t i; /* index */
+ uint8_t j; /* Index */
ProtAddr *pAddr; /* Protocol Address */
Buffer *mBuf; /* message buffer */
#endif
{
- U8 i; /* loop counter */
+ uint8_t i; /* loop counter */
CMCHKUNPK(oduPackUInt8, &addrs->length, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- U8 i; /* loop counter */
+ uint8_t i; /* loop counter */
CMCHKUNPK(oduPackUInt8, &addrs->length, mBuf);
#ifdef ANSI
S16 cmUnpkAddrMask
(
-U8 *mask, /* pointer to address mask */
+uint8_t *mask, /* pointer to address mask */
Buffer *mBuf /* message buffer */
)
#else
S16 cmUnpkAddrMask(mask, mBuf)
-U8 *mask; /* pointer to address mask */
+uint8_t *mask; /* pointer to address mask */
Buffer *mBuf; /* message buffer */
#endif
{
\f
/*
*
-* Fun: cmUnpkTknU8
+* Fun: cmUnpkTknUInt8
*
-* Desc: This function unpacks a token U8
+* Desc: This function unpacks a token uint8_t
*
* Ret: ROK - ok
*
*/
#ifdef ANSI
-S16 cmUnpkTknU8
+S16 cmUnpkTknUInt8
(
-TknU8 *tknU8, /* token U8 */
+TknUInt8 *tknUInt8, /* token uint8_t */
Buffer *mBuf /* message buffer */
)
#else
-S16 cmUnpkTknU8(tknU8, mBuf)
-TknU8 *tknU8; /* token U8 */
+S16 cmUnpkTknUInt8(tknUInt8, mBuf)
+TknUInt8 *tknUInt8; /* token uint8_t */
Buffer *mBuf; /* message buffer */
#endif
{
/* Token Header */
- CMCHKUNPK(oduPackUInt8, &tknU8->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknUInt8->pres, mBuf);
- if (tknU8->pres)
+ if (tknUInt8->pres)
{
/* Value */
- CMCHKUNPK(oduPackUInt8, &tknU8->val, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknUInt8->val, mBuf);
}
return ROK;
-} /* end of cmUnpkTknU8 */
+} /* end of cmUnpkTknUInt8 */
\f
/*
\f
/*
*
-* Fun: cmUnpkTknU16
+* Fun: cmUnpkTknUInt16
*
-* Desc: This function unpacks a token U16
+* Desc: This function unpacks a token uint16_t
*
* Ret: ROK - ok
*
*/
#ifdef ANSI
-S16 cmUnpkTknU16
+S16 cmUnpkTknUInt16
(
-TknU16 *tknU16, /* token U16 */
+TknUInt16 *tknUInt16, /* token uint16_t */
Buffer *mBuf /* message buffer */
)
#else
-S16 cmUnpkTknU16(tknU16, mBuf)
-TknU16 *tknU16; /* token U16 */
+S16 cmUnpkTknUInt16(tknUInt16, mBuf)
+TknUInt16 *tknUInt16; /* token uint16_t */
Buffer *mBuf; /* message buffer */
#endif
{
/* Token Header */
- CMCHKUNPK(oduPackUInt8, &tknU16->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknUInt16->pres, mBuf);
- if (tknU16->pres)
+ if (tknUInt16->pres)
{
/* Value */
- CMCHKUNPK(oduPackUInt16, &tknU16->val, mBuf);
+ CMCHKUNPK(oduPackUInt16, &tknUInt16->val, mBuf);
}
return ROK;
-} /* end of cmUnpkTknU16 */
+} /* end of cmUnpkTknUInt16 */
\f
/*
*
-* Fun: cmUnpkTknU32
+* Fun: cmUnpkTknUInt32
*
-* Desc: This function unpacks a token U32
+* Desc: This function unpacks a token uint32_t
*
* Ret: ROK - ok
*
*/
#ifdef ANSI
-S16 cmUnpkTknU32
+S16 cmUnpkTknUInt32
(
-TknU32 *tknU32, /* token U32 */
+TknUInt32 *tknUInt32, /* token uint32_t */
Buffer *mBuf /* message buffer */
)
#else
-S16 cmUnpkTknU32(tknU32, mBuf)
-TknU32 *tknU32; /* token U32 */
+S16 cmUnpkTknUInt32(tknUInt32, mBuf)
+TknUInt32 *tknUInt32; /* token uint32_t */
Buffer *mBuf; /* message buffer */
#endif
{
/* Token Header */
- CMCHKUNPK(oduPackUInt8, &tknU32->pres, mBuf);
+ CMCHKUNPK(oduPackUInt8, &tknUInt32->pres, mBuf);
- if (tknU32->pres)
+ if (tknUInt32->pres)
{
/* Value */
- CMCHKUNPK(oduPackUInt32, &tknU32->val, mBuf);
+ CMCHKUNPK(oduPackUInt32, &tknUInt32->val, mBuf);
}
return ROK;
-} /* end of cmUnpkTknU32 */
+} /* end of cmUnpkTknUInt32 */
/*
*
Buffer *mBuf; /* message buffer */
#endif
{
- U16 i;
+ uint16_t i;
/* Unpack the token header */
CMCHKUNPK(oduPackUInt8, &tknOid->len, mBuf);
/* Pack the value */
- for (i = 1; i <= (U16)tknOid->len; i++)
+ for (i = 1; i <= (uint16_t)tknOid->len; i++)
{
- /* cm_gen_c_001.main_33: changes for TknOid value from U16 to U32
- * with compilation flag TKNOID_U16 */
-#ifndef TKNOID_U16
+ /* cm_gen_c_001.main_33: changes for TknOid value from uint16_t to uint32_t
+ * with compilation flag TKNOID_UINT16 */
+#ifndef TKNOID_UINT16
CMCHKUNPK(oduPackUInt32, &tknOid->val[tknOid->len - i], mBuf);
#else
CMCHKUNPK(oduPackUInt16, &tknOid->val[tknOid->len - i], mBuf);
-#endif /* !TKNOID_U16 */
+#endif /* !TKNOID_UINT16 */
}
}
* File: cm_gen.c
*
*/
-U16 getTransId()
+uint16_t getTransId()
{
gTransId = (gTransId%65535) + 1;
return gTransId;
#define cmPkDgn(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Dgn */
#define cmPkAction(x, mBuf) SPkS16(x, mBuf) /* pack Action */
#define cmPkSeqS16(x, mBuf) SPkS16(x, mBuf) /* pack SeqS16 */
-#define cmPkSeqU16(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack SeqU16 */
+#define cmPkSeqUInt16(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack SeqUInt16 */
#define cmPkSeqS24(x, mBuf) SPkS32(x, mBuf) /* pack SeqS24 */
-#define cmPkSeqU24(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack SeqU24 */
+#define cmPkSeqUInt24(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack SeqUInt24 */
#define cmPkSetUpArb(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack SetUpArb */
#define cmPkEvntType(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack EvntType */
#define cmPkState(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack State */
#define cmPkTpInstId(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack TpInstId */
/* PNNI specific typedefs */
-#define cmPkPnPortId(x, mBuf) oduUnpackUInt32(x, mBuf)
+#define cmPkPnPortId(x, mBuf) oduUnpackUInt32(x, mBuf)
\f
/* unpacking macros */
/* system services typedefs */
-#define oduUnpackBool(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Bool */
+#define oduUnpackBool(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Bool */
#define cmUnpkStatus(x, mBuf) SUnpkS16(x, mBuf) /* unpack Status */
#define cmUnpkTicks(x, mBuf) oduPackUInt32(x, mBuf) /* unpack Ticks */
#define cmUnpkQLen(x, mBuf) SUnpkS16(x, mBuf) /* unpack QLen */
#define cmUnpkDgn(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Dgn */
#define cmUnpkAction(x, mBuf) SUnpkS16(x, mBuf) /* unpack Action */
#define cmUnpkSeqS16(x, mBuf) SUnpkS16(x, mBuf) /* unpack SeqS16 */
-#define cmUnpkSeqU16(x, mBuf) oduPackUInt16(x, mBuf) /* unpack SeqU16 */
+#define cmUnpkSeqUInt16(x, mBuf) oduPackUInt16(x, mBuf) /* unpack SeqUInt16 */
#define cmUnpkSeqS24(x, mBuf) SUnpkS32(x, mBuf) /* unpack SeqS24 */
-#define cmUnpkSeqU24(x, mBuf) oduPackUInt32(x, mBuf) /* unpack SeqU24 */
+#define cmUnpkSeqUInt24(x, mBuf) oduPackUInt32(x, mBuf) /* unpack SeqUInt24 */
#define cmUnpkSetUpArb(x, mBuf) oduPackUInt8(x, mBuf) /* unpack SetUpArb */
#define cmUnpkEvntType(x, mBuf) oduPackUInt8(x, mBuf) /* unpack EvntType */
#define cmUnpkState(x, mBuf) oduPackUInt8(x, mBuf) /* unpack State */
extern "C" {
#endif
-PRIVATE S16 cmHashFuncBCD8 ARGS((CmHashListCp *hashListCp, U8 *key,
- U16 keyLen, U16 *idx));
+PRIVATE S16 cmHashFuncBCD8 ARGS((CmHashListCp *hashListCp, uint8_t *key,
+ uint16_t keyLen, uint16_t *idx));
-PRIVATE S16 cmHashFuncConId ARGS((CmHashListCp *hashListCp, U8 *key,
- U16 keyLen, U16 *idx));
+PRIVATE S16 cmHashFuncConId ARGS((CmHashListCp *hashListCp, uint8_t *key,
+ uint16_t keyLen, uint16_t *idx));
-PRIVATE S16 cmHashFuncU32Mod ARGS((CmHashListCp *hashListCp, U8 *key,
- U16 keyLen, U16 *idx));
+PRIVATE S16 cmHashFuncUInt32Mod ARGS((CmHashListCp *hashListCp, uint8_t *key,
+ uint16_t keyLen, uint16_t *idx));
-PRIVATE S16 cmHashFuncString ARGS((CmHashListCp *hashListCp, U8 *key,
- U16 keyLen, U16 *idx));
+PRIVATE S16 cmHashFuncString ARGS((CmHashListCp *hashListCp, uint8_t *key,
+ uint16_t keyLen, uint16_t *idx));
-PRIVATE S16 cmHashFuncDefault ARGS((CmHashListCp *hashListCp, U8 *key,
- U16 keyLen, U16 *idx));
+PRIVATE S16 cmHashFuncDefault ARGS((CmHashListCp *hashListCp, uint8_t *key,
+ uint16_t keyLen, uint16_t *idx));
-PRIVATE S16 cmHashFuncAnyKey ARGS((CmHashListCp *hashListCp, U8 *key,
- U16 keyLen, U16 *idx));
+PRIVATE S16 cmHashFuncAnyKey ARGS((CmHashListCp *hashListCp, uint8_t *key,
+ uint16_t keyLen, uint16_t *idx));
-PRIVATE S16 cmHashMatchKey ARGS((U8 *key1, U16 keyLen1, U8 *key2, U16 keyLen2));
+PRIVATE S16 cmHashMatchKey ARGS((uint8_t *key1, uint16_t keyLen1, uint8_t *key2, uint16_t keyLen2));
PRIVATE S16 cmListInsert ARGS((CmListEnt *oldEntry, CmListEnt *newEntry));
PRIVATE S16 cmListDelete ARGS((CmListEnt *entry));
/* cm_hash_c_001.main_22: Fixing warnings on GCC compiler */
-PRIVATE S16 cmHashFuncMult24 ARGS((CmHashListCp *hashListCp, U8 *key, U16 keyLen, U16 *idx));
+PRIVATE S16 cmHashFuncMult24 ARGS((CmHashListCp *hashListCp, uint8_t *key, uint16_t keyLen, uint16_t *idx));
-PRIVATE S16 cmHashFuncDirIdx ARGS((CmHashListCp *hashListCp, U8 *key, U16 keyLen, U16 *idx));
+PRIVATE S16 cmHashFuncDirIdx ARGS((CmHashListCp *hashListCp, uint8_t *key, uint16_t keyLen, uint16_t *idx));
#ifdef __cplusplus
}
PRIVATE S16 cmHashFuncAnyKey
(
CmHashListCp *hashListCp, /* hash list control point */
-U8 *key, /* key string */
-U16 keyLen, /* length of key string */
-U16 *idx /* idx to return */
+uint8_t *key, /* key string */
+uint16_t keyLen, /* length of key string */
+uint16_t *idx /* idx to return */
)
#else
PRIVATE S16 cmHashFuncAnyKey (hashListCp, key, keyLen, idx)
CmHashListCp *hashListCp; /* hash list control point */
-U8 *key; /* key string */
-U16 keyLen; /* length of key string */
-U16 *idx; /* idx to return */
+uint8_t *key; /* key string */
+uint16_t keyLen; /* length of key string */
+uint16_t *idx; /* idx to return */
#endif
{
- U32 a; /* hash variables */
- U32 b; /* hash variables */
- U32 c; /* hash variables */
- U32 len; /* length */
+ uint32_t a; /* hash variables */
+ uint32_t b; /* hash variables */
+ uint32_t c; /* hash variables */
+ uint32_t len; /* length */
/*cm_hash_c_001.main_23 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
/* Set up the internal state */
/*---------------------------------------- handle most of the key */
while (len >= 12)
{
- a += (key[0] +((U32)key[1]<<8) +((U32)key[2]<<16) +((U32)key[3]<<24));
- b += (key[4] +((U32)key[5]<<8) +((U32)key[6]<<16) +((U32)key[7]<<24));
- c += (key[8] +((U32)key[9]<<8) +((U32)key[10]<<16)+((U32)key[11]<<24));
+ a += (key[0] +((uint32_t)key[1]<<8) +((uint32_t)key[2]<<16) +((uint32_t)key[3]<<24));
+ b += (key[4] +((uint32_t)key[5]<<8) +((uint32_t)key[6]<<16) +((uint32_t)key[7]<<24));
+ c += (key[8] +((uint32_t)key[9]<<8) +((uint32_t)key[10]<<16)+((uint32_t)key[11]<<24));
CM_HASH_MIX(a, b, c);
key += 12; len -= 12;
}
c += keyLen;
switch(len) /* all the case statements fall through */
{
- case 11: c+=((U32)key[10]<<24);
- case 10: c+=((U32)key[9]<<16);
- case 9 : c+=((U32)key[8]<<8);
+ case 11: c+=((uint32_t)key[10]<<24);
+ case 10: c+=((uint32_t)key[9]<<16);
+ case 9 : c+=((uint32_t)key[8]<<8);
/* the first byte of c is reserved for the keyLen */
- case 8 : b+=((U32)key[7]<<24);
- case 7 : b+=((U32)key[6]<<16);
- case 6 : b+=((U32)key[5]<<8);
+ case 8 : b+=((uint32_t)key[7]<<24);
+ case 7 : b+=((uint32_t)key[6]<<16);
+ case 6 : b+=((uint32_t)key[5]<<8);
case 5 : b+=key[4];
- case 4 : a+=((U32)key[3]<<24);
- case 3 : a+=((U32)key[2]<<16);
- case 2 : a+=((U32)key[1]<<8);
+ case 4 : a+=((uint32_t)key[3]<<24);
+ case 3 : a+=((uint32_t)key[2]<<16);
+ case 2 : a+=((uint32_t)key[1]<<8);
case 1 : a+=key[0];
/* case 0: nothing left to add */
}
/* if nmbBins is a power of 2, use shift, else use division */
if (hashListCp->binBitMask != CM_HASH_NOBITMASK)
- *idx = (U16) (c & hashListCp->binBitMask);
+ *idx = (uint16_t) (c & hashListCp->binBitMask);
else
- *idx = (U16) (c % hashListCp->nmbBins);
+ *idx = (uint16_t) (c % hashListCp->nmbBins);
return ROK;
} /* end of cmHashFuncAnyKey */
/*
*
-* Fun: cmHashFuncU32Mod
+* Fun: cmHashFuncUInt32Mod
*
* Desc: Computes the hash list index (bin number) for a specified
* key of type CM_HASH_KEYTYPE_MOD.
*/
#ifdef ANSI
-PRIVATE S16 cmHashFuncU32Mod
+PRIVATE S16 cmHashFuncUInt32Mod
(
CmHashListCp *hashListCp, /* hash list control point */
-U8 *key, /* key string */
-U16 keyLen, /* length of key string */
-U16 *idx /* idx to return */
+uint8_t *key, /* key string */
+uint16_t keyLen, /* length of key string */
+uint16_t *idx /* idx to return */
)
#else
-PRIVATE S16 cmHashFuncU32Mod (hashListCp, key, keyLen, idx)
+PRIVATE S16 cmHashFuncUInt32Mod (hashListCp, key, keyLen, idx)
CmHashListCp *hashListCp; /* hash list control point */
-U8 *key; /* key string */
-U16 keyLen; /* length of key string */
-U16 *idx; /* idx to return */
+uint8_t *key; /* key string */
+uint16_t keyLen; /* length of key string */
+uint16_t *idx; /* idx to return */
#endif
{
- U32 sum; /* Sum of octets for hash function */
+ uint32_t sum; /* Sum of octets for hash function */
/* keyLen is marked Unused to remove compilation
* warnings. */
UNUSED(keyLen);
- sum = *((U32 *)key);
+ sum = *((uint32_t *)key);
/* if nmbBins is a power of 2, use shift, else use division */
if (hashListCp->binBitMask != CM_HASH_NOBITMASK)
- *idx = (U16) (sum & hashListCp->binBitMask);
+ *idx = (uint16_t) (sum & hashListCp->binBitMask);
else
- *idx = (U16) (sum % hashListCp->nmbBins);
+ *idx = (uint16_t) (sum % hashListCp->nmbBins);
return ROK;
-} /* end of cmHashFuncU32Mod () */
+} /* end of cmHashFuncUInt32Mod () */
/*
*
* key of type CM_HASH_KEYTYPE_BCD8.
*
* Steps:
-* 1. Converts the 8 BCD coded octets into 2 U32s
-* 2. Adds 2 U32s to get one U32.
-* 3. Apply U32Mod technique to get the index
+* 1. Converts the 8 BCD coded octets into 2 uint32_ts
+* 2. Adds 2 uint32_ts to get one uint32_t.
+* 3. Apply uint32_tMod technique to get the index
* 4. Return the index
*
* Note:
PRIVATE S16 cmHashFuncBCD8
(
CmHashListCp *hashListCp, /* hash list control point */
-U8 *key, /* key string */
-U16 keyLen, /* length of key string */
-U16 *idx /* idx to return */
+uint8_t *key, /* key string */
+uint16_t keyLen, /* length of key string */
+uint16_t *idx /* idx to return */
)
#else
PRIVATE S16 cmHashFuncBCD8 (hashListCp, key, keyLen, idx)
CmHashListCp *hashListCp; /* hash list control point */
-U8 *key; /* key string */
-U16 keyLen; /* length of key string */
-U16 *idx; /* idx to return */
+uint8_t *key; /* key string */
+uint16_t keyLen; /* length of key string */
+uint16_t *idx; /* idx to return */
#endif
{
- U16 tmp16 = 0;
- U32 firstU32 = 0; /* First U32 prepared for lower 4 octets */
- U32 secondU32 = 0; /* Second U32 prepared for higher 4 octets */
- U32 sum; /* Sum of the above 2 octets to get the index */
+ uint16_t tmp16 = 0;
+ uint32_t firstUInt32 = 0; /* First uint32_t prepared for lower 4 octets */
+ uint32_t secondUInt32 = 0; /* Second uint32_t prepared for higher 4 octets */
+ uint32_t sum; /* Sum of the above 2 octets to get the index */
/* keyLen is marked Unused to remove compilation
* warnings. */
UNUSED(keyLen);
- /* Compute second U32 */
- tmp16 = (U16) PutHiByte(tmp16, (U8) key[0]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) key[1]);
- secondU32 = (U32) PutHiWord(secondU32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) key[2]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) key[3]);
- secondU32 = (U32) PutLoWord(secondU32, (U16) tmp16);
+ /* Compute second uint32_t */
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) key[0]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) key[1]);
+ secondUInt32 = (uint32_t) PutHiWord(secondUInt32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) key[2]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) key[3]);
+ secondUInt32 = (uint32_t) PutLoWord(secondUInt32, (uint16_t) tmp16);
- /* Compute first U32 */
- tmp16 = (U16) PutHiByte(tmp16, (U8) key[4]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) key[5]);
- firstU32 = (U32) PutHiWord(firstU32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) key[6]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) key[7]);
- firstU32 = (U32) PutLoWord(firstU32, (U16) tmp16);
+ /* Compute first uint32_t */
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) key[4]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) key[5]);
+ firstUInt32 = (uint32_t) PutHiWord(firstUInt32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) key[6]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) key[7]);
+ firstUInt32 = (uint32_t) PutLoWord(firstUInt32, (uint16_t) tmp16);
- sum = firstU32 + secondU32;
+ sum = firstUInt32 + secondUInt32;
/* if nmbBins is a power of 2, use shift, else use division */
if (hashListCp->binBitMask != CM_HASH_NOBITMASK)
- *idx = (U16) (sum & hashListCp->binBitMask);
+ *idx = (uint16_t) (sum & hashListCp->binBitMask);
else
- *idx = (U16) (sum % hashListCp->nmbBins);
+ *idx = (uint16_t) (sum % hashListCp->nmbBins);
return ROK;
} /* end of cmHashFuncBCD8 () */
PRIVATE S16 cmHashFuncString
(
CmHashListCp *hashListCp, /* hash list control point */
-U8 *key, /* key string */
-U16 keyLen, /* length of key string */
-U16 *idx /* idx to return */
+uint8_t *key, /* key string */
+uint16_t keyLen, /* length of key string */
+uint16_t *idx /* idx to return */
)
#else
PRIVATE S16 cmHashFuncString (hashListCp, key, keyLen, idx)
CmHashListCp *hashListCp; /* hash list control point */
-U8 *key; /* key string */
-U16 keyLen; /* length of key string */
-U16 *idx; /* idx to return */
+uint8_t *key; /* key string */
+uint16_t keyLen; /* length of key string */
+uint16_t *idx; /* idx to return */
#endif
{
- U16 cntr; /* Index */
- U32 sum; /* Sum of octets for hash function */
+ uint16_t cntr; /* Index */
+ uint32_t sum; /* Sum of octets for hash function */
sum = 0;
/* if nmbBins is a power of 2, use shift, else use division */
if (hashListCp->binBitMask != CM_HASH_NOBITMASK)
- *idx = (U16) (sum & hashListCp->binBitMask);
+ *idx = (uint16_t) (sum & hashListCp->binBitMask);
else
- *idx = (U16) (sum % hashListCp->nmbBins);
+ *idx = (uint16_t) (sum % hashListCp->nmbBins);
return ROK;
PRIVATE S16 cmHashFuncDefault
(
CmHashListCp *hashListCp, /* hash list control point */
-U8 *key, /* key string */
-U16 keyLen, /* length of key string */
-U16 *idx /* index to return */
+uint8_t *key, /* key string */
+uint16_t keyLen, /* length of key string */
+uint16_t *idx /* index to return */
)
#else
PRIVATE S16 cmHashFuncDefault(hashListCp, key, keyLen, idx)
CmHashListCp *hashListCp; /* hash list control point */
-U8 *key; /* key string */
-U16 keyLen; /* length of key string */
-U16 *idx; /* index to return */
+uint8_t *key; /* key string */
+uint16_t keyLen; /* length of key string */
+uint16_t *idx; /* index to return */
#endif
{
- U32 sum; /* sum of key string octets */
+ uint32_t sum; /* sum of key string octets */
/* add all bytes of the key */
sum = 0;
while (keyLen--)
- sum += (U32) (*key++);
+ sum += (uint32_t) (*key++);
/* compute index by dividing the range into the sum */
/* if nmbBins is a power of 2, use shift, else use division */
if (hashListCp->binBitMask != CM_HASH_NOBITMASK)
- *idx = (U16) (sum & hashListCp->binBitMask);
+ *idx = (uint16_t) (sum & hashListCp->binBitMask);
else
- *idx = (U16) (sum % hashListCp->nmbBins);
+ *idx = (uint16_t) (sum % hashListCp->nmbBins);
return ROK;
PRIVATE S16 cmHashFuncMult24
(
CmHashListCp *hashListCp, /* hash list control point */
-U8 *key, /* key string */
-U16 keyLen, /* length of key string */
-U16 *idx /* index to return */
+uint8_t *key, /* key string */
+uint16_t keyLen, /* length of key string */
+uint16_t *idx /* index to return */
)
#else
PRIVATE S16 cmHashFuncMult24(hashListCp, key, keyLen, idx)
CmHashListCp *hashListCp; /* hash list control point */
-U8 *key; /* key string */
-U16 keyLen; /* length of key string */
-U16 *idx; /* index to return */
+uint8_t *key; /* key string */
+uint16_t keyLen; /* length of key string */
+uint16_t *idx; /* index to return */
#endif
{
- U32 prod; /* (constant multiplier * key) */
- U8 shift; /* Bits to be shifted to get index */
+ uint32_t prod; /* (constant multiplier * key) */
+ uint8_t shift; /* Bits to be shifted to get index */
UNUSED(keyLen);
return RFAILED;
#endif
- prod = CM_HASH_MULT24_CONST * *((U32 *)key);
+ prod = CM_HASH_MULT24_CONST * *((uint32_t *)key);
shift = CM_HASH_MULT24_BITPOS - hashListCp->nmbBinBits;
- *idx = ((U16) (prod & (hashListCp->binBitMask << shift))) >> shift;
+ *idx = ((uint16_t) (prod & (hashListCp->binBitMask << shift))) >> shift;
return ROK;
} /* end of cmHashFuncMult24 */
* key of type CM_HASH_KEYTYPE_CONID.
*
* This function can be used for keys that are an integer whose
-* size is U8, U16 or U32. Instead of adding all octets of the key,
+* size is uint8_t, uint16_t or uint32_t. Instead of adding all octets of the key,
* this fn computes the "index" of the bin in which the entry
* needs to be inserted by taking a modulo of the integer with the
* total number of bins.
PRIVATE S16 cmHashFuncConId
(
CmHashListCp *hashListCp, /* hash list control point */
-U8 *key, /* key string */
-U16 keyLen, /* length of key string */
-U16 *idx /* index to return */
+uint8_t *key, /* key string */
+uint16_t keyLen, /* length of key string */
+uint16_t *idx /* index to return */
)
#else
PRIVATE S16 cmHashFuncConId(hashListCp, key, keyLen, idx)
CmHashListCp *hashListCp; /* hash list control point */
-U8 *key; /* key string */
-U16 keyLen; /* length of key string */
-U16 *idx; /* index to return */
+uint8_t *key; /* key string */
+uint16_t keyLen; /* length of key string */
+uint16_t *idx; /* index to return */
#endif
{
/* switch based on the length of the key */
switch (keyLen)
{
- case CM_HASHKEYLEN_U32:
+ case CM_HASHKEYLEN_UINT32:
if (hashListCp->binBitMask != CM_HASH_NOBITMASK)
- *idx = (U16) (((U32) *((U32 *)key)) & hashListCp->binBitMask);
+ *idx = (uint16_t) (((uint32_t) *((uint32_t *)key)) & hashListCp->binBitMask);
else
- *idx = (U16) (((U32) *((U32 *)key)) % hashListCp->nmbBins);
+ *idx = (uint16_t) (((uint32_t) *((uint32_t *)key)) % hashListCp->nmbBins);
break;
- case CM_HASHKEYLEN_U16:
+ case CM_HASHKEYLEN_UINT16:
if (hashListCp->binBitMask != CM_HASH_NOBITMASK)
- *idx = (U16) (((U16)*((U16 *)key)) & hashListCp->binBitMask);
+ *idx = (uint16_t) (((uint16_t)*((uint16_t *)key)) & hashListCp->binBitMask);
else
- *idx = (U16) (((U16)*((U16 *)key)) % hashListCp->nmbBins);
+ *idx = (uint16_t) (((uint16_t)*((uint16_t *)key)) % hashListCp->nmbBins);
break;
- case CM_HASHKEYLEN_U8:
+ case CM_HASHKEYLEN_UINT8:
if (hashListCp->binBitMask != CM_HASH_NOBITMASK)
- *idx = (U16) (((U8)*((U8 *)key)) & hashListCp->binBitMask);
+ *idx = (uint16_t) (((uint8_t)*((uint8_t *)key)) & hashListCp->binBitMask);
else
- *idx = (U16) (((U8)*((U8 *)key)) % hashListCp->nmbBins);
+ *idx = (uint16_t) (((uint8_t)*((uint8_t *)key)) % hashListCp->nmbBins);
break;
default:
PRIVATE S16 cmHashFuncDirIdx
(
CmHashListCp *hashListCp, /* hash list control point */
-U8 *key, /* key string */
-U16 keyLen, /* length of key string */
-U16 *idx /* index to return */
+uint8_t *key, /* key string */
+uint16_t keyLen, /* length of key string */
+uint16_t *idx /* index to return */
)
#else
PRIVATE S16 cmHashFuncDirIdx(hashListCp, key, keyLen, idx)
CmHashListCp *hashListCp; /* hash list control point */
-U8 *key; /* key string */
-U16 keyLen; /* length of key string */
-U16 *idx; /* index to return */
+uint8_t *key; /* key string */
+uint16_t keyLen; /* length of key string */
+uint16_t *idx; /* index to return */
#endif
{
UNUSED(hashListCp);
UNUSED(keyLen);
- *idx = *((U16 *) key);
+ *idx = *((uint16_t *) key);
return ROK;
} /* end of cmHashFuncDirIdx */
#ifdef ANSI
PRIVATE S16 cmHashMatchKey
(
-U8 *key1, /* first key string */
-U16 keyLen1, /* length of first key string */
-U8 *key2, /* second key string */
-U16 keyLen2 /* length of second key string */
+uint8_t *key1, /* first key string */
+uint16_t keyLen1, /* length of first key string */
+uint8_t *key2, /* second key string */
+uint16_t keyLen2 /* length of second key string */
)
#else
PRIVATE S16 cmHashMatchKey(key1, keyLen1, key2, keyLen2)
-U8 *key1; /* first key string */
-U16 keyLen1; /* length of first key string */
-U8 *key2; /* second key string */
-U16 keyLen2; /* length of second key string */
+uint8_t *key1; /* first key string */
+uint16_t keyLen1; /* length of first key string */
+uint8_t *key2; /* second key string */
+uint16_t keyLen2; /* length of second key string */
#endif
{
S16 cmHashListInit
(
CmHashListCp *hashListCp, /* hash list to initialize */
-U16 nmbBins, /* number of hash list bins */
-U16 offset, /* offset of CmHashListEnt in entries */
+uint16_t nmbBins, /* number of hash list bins */
+uint16_t offset, /* offset of CmHashListEnt in entries */
Bool dupFlg, /* allow duplicate keys */
-U16 keyType, /* key type for selecting hash fn */
+uint16_t keyType, /* key type for selecting hash fn */
Region region, /* memory region to allocate bins */
Pool pool /* memory pool to allocate bins */
)
#else
S16 cmHashListInit(hashListCp, nmbBins, offset, dupFlg, keyType, region, pool)
CmHashListCp *hashListCp; /* hash list to initialize */
-U16 nmbBins; /* number of hash list bins */
-U16 offset; /* offset of CmHashListEnt in entries */
+uint16_t nmbBins; /* number of hash list bins */
+uint16_t offset; /* offset of CmHashListEnt in entries */
Bool dupFlg; /* allow duplicate keys */
-U16 keyType; /* key type for selecting hash fn */
+uint16_t keyType; /* key type for selecting hash fn */
Region region; /* memory region to allocate bins */
Pool pool; /* memory pool to allocate bins */
#endif
{
- U16 i;
+ uint16_t i;
#ifndef CM_MT_HASH_BIN
CmListEnt *hl;
#else
hashListCp->hashFunc = cmHashFuncString;
break;
- case CM_HASH_KEYTYPE_U32MOD:
- hashListCp->hashFunc = cmHashFuncU32Mod;
+ case CM_HASH_KEYTYPE_UINT32_MOD:
+ hashListCp->hashFunc = cmHashFuncUInt32Mod;
break;
case CM_HASH_KEYTYPE_BCD8:
/* initialize bin bit mask */
if (((nmbBins) & (nmbBins - 1)) == 0)
{
- U16 binBitMask;
+ uint16_t binBitMask;
/* number of bins is a power of 2 */
hashListCp->binBitMask = nmbBins - 1;
(
CmHashListCp *hashListCp, /* hash list to add to */
PTR entry, /* entry to add */
-U8 *key, /* pointer to key */
-U16 keyLen /* length of key */
+uint8_t *key, /* pointer to key */
+uint16_t keyLen /* length of key */
)
#else
S16 cmHashListInsert(hashListCp, entry, key, keyLen)
CmHashListCp *hashListCp; /* hash list to add to */
PTR entry; /* entry to add */
-U8 *key; /* pointer to key */
-U16 keyLen; /* length of key */
+uint8_t *key; /* pointer to key */
+uint16_t keyLen; /* length of key */
#endif
{
CmHashListEnt *hashListEnt; /* pointer to hash list entry header */
PTR dupEntry; /* pointer to entry with duplicate key */
- U16 idx; /* index for insertion into hash list */
+ uint16_t idx; /* index for insertion into hash list */
#if (ERRCLASS & ERRCLS_DEBUG)
}
/* get pointer to hash list entry header */
- hashListEnt = (CmHashListEnt *) (((U8 *) entry) + hashListCp->offset);
+ hashListEnt = (CmHashListEnt *) (((uint8_t *) entry) + hashListCp->offset);
/* initialize hash list entry header */
hashListEnt->list.next = NULLP;
{
CmHashListEnt *hashListEnt; /* pointer to hash list entry header */
#ifdef CM_MT_HASH_BIN
- U16 idx; /* index for selecting the right hash list bin */
+ uint16_t idx; /* index for selecting the right hash list bin */
#endif
#endif
/* get pointer to hash list entry header */
- hashListEnt = (CmHashListEnt *) (((U8 *) entry) + hashListCp->offset);
+ hashListEnt = (CmHashListEnt *) (((uint8_t *) entry) + hashListCp->offset);
/* check if entry is already deleted if yes then return OK */
if((hashListEnt->list.next == NULLP) ||
S16 cmHashListFind
(
CmHashListCp *hashListCp, /* hash list to search */
-U8 *key, /* pointer to key */
-U16 keyLen, /* length of key */
-U16 seqNmb, /* used in case of duplicate keys */
+uint8_t *key, /* pointer to key */
+uint16_t keyLen, /* length of key */
+uint16_t seqNmb, /* used in case of duplicate keys */
PTR *entry /* entry to be returned */
)
#else
S16 cmHashListFind(hashListCp, key, keyLen, seqNmb, entry)
CmHashListCp *hashListCp; /* hash list to search */
-U8 *key; /* pointer to key */
-U16 keyLen; /* length of key */
-U16 seqNmb; /* used in case of duplicate keys */
+uint8_t *key; /* pointer to key */
+uint16_t keyLen; /* length of key */
+uint16_t seqNmb; /* used in case of duplicate keys */
PTR *entry; /* entry to be returned */
#endif
{
CmListEnt *hashListBin; /* pointer to hash list bin */
#else
CmListBinEnt *hashListBin; /* pointer to hash list bin */
- U16 entCnt=0; /* counter for number of entries */
+ uint16_t entCnt=0; /* counter for number of entries */
#endif
- U16 i; /* counter for sequence number */
- U16 idx; /* index for insertion into hash list */
+ uint16_t i; /* counter for sequence number */
+ uint16_t idx; /* index for insertion into hash list */
#if (ERRCLASS & ERRCLS_DEBUG)
== ROK)
{
/* matching key */
- *entry = (PTR) (((U8 *) hashListEnt) - hashListCp->offset);
+ *entry = (PTR) (((uint8_t *) hashListEnt) - hashListCp->offset);
/* check for duplicates */
if (!hashListCp->dupFlg)
#endif
CmHashListEnt *hashListEnt; /* temporary hash list entry pointer */
CmHashListEnt *prevListEnt; /* previous hash list entry pointer */
- U16 i; /* hash list counter */
+ uint16_t i; /* hash list counter */
#if (ERRCLASS & ERRCLS_DEBUG)
hashListEnt = (CmHashListEnt *) hashListCp->hl[i].next;
/* requested entry is in nxtEnt */
- *entry = (PTR) (((U8 *) hashListEnt) - hashListCp->offset);
+ *entry = (PTR) (((uint8_t *) hashListEnt) - hashListCp->offset);
return ROK;
}
/* use previous entry to find next entry */
/* get pointer to previous hash list entry header */
- prevListEnt = (CmHashListEnt *) (((U8 *) prevEnt) + hashListCp->offset);
+ prevListEnt = (CmHashListEnt *) (((uint8_t *) prevEnt) + hashListCp->offset);
/* get index of previous entry */
i = prevListEnt->hashVal;
if (prevListEnt != (CmHashListEnt *) hashListBin)
{
/* found next entry */
- *entry = (PTR) (((U8 *) prevListEnt) - hashListCp->offset);
+ *entry = (PTR) (((uint8_t *) prevListEnt) - hashListCp->offset);
return ROK;
}
S16 cmHashListBinGetNextEntry
(
CmHashListCp *hashListCp, /* hash list to get from */
-U16 binIdx, /* Bin Index to retreive the entry */
+uint16_t binIdx, /* Bin Index to retreive the entry */
PTR prevEnt, /* previous entry */
PTR *entry /* entry to be returned */
)
#else
S16 cmHashListBinGetNextEntry(hashListCp, binIdx, prevEnt, entry)
CmHashListCp *hashListCp; /* hash list to get from */
-U16 binIdx; /* Bin Index to retreive the entry */
+uint16_t binIdx; /* Bin Index to retreive the entry */
PTR prevEnt; /* previous entry */
PTR *entry; /* entry to be returned */
#endif
hashListEnt = (CmHashListEnt *) hashListCp->hl[binIdx].next;
/* requested entry is in nxtEnt */
- *entry = (PTR) (((U8 *) hashListEnt) - hashListCp->offset);
+ *entry = (PTR) (((uint8_t *) hashListEnt) - hashListCp->offset);
return ROK;
}
/* use previous entry to find next entry */
/* get pointer to previous hash list entry header */
- prevListEnt = (CmHashListEnt *) (((U8 *) prevEnt) + hashListCp->offset);
+ prevListEnt = (CmHashListEnt *) (((uint8_t *) prevEnt) + hashListCp->offset);
/* set pointers to get next entry */
hashListBin = &hashListCp->hl[binIdx];
if (prevListEnt != (CmHashListEnt *) hashListBin)
{
/* found next entry */
- *entry = (PTR) (((U8 *) prevListEnt) - hashListCp->offset);
+ *entry = (PTR) (((uint8_t *) prevListEnt) - hashListCp->offset);
return ROK;
}
S16 cmHashListQuery
(
CmHashListCp *hashListCp, /* hash list to query */
-U8 queryType, /* type of query */
-U16 *result /* result of query */
+uint8_t queryType, /* type of query */
+uint16_t *result /* result of query */
)
#else
S16 cmHashListQuery(hashListCp, queryType, result)
CmHashListCp *hashListCp; /* hash list to query */
-U8 queryType; /* type of query */
-U16 *result; /* result of query */
+uint8_t queryType; /* type of query */
+uint16_t *result; /* result of query */
#endif
{
#ifdef CM_MT_HASH_BIN
- U8 i;
+ uint8_t i;
#endif
{
/* storage for each bin */
#ifndef CM_MT_HASH_BIN
- *result = (U16) sizeof(CmListEnt);
+ *result = (uint16_t) sizeof(CmListEnt);
#else
- *result = (U16) sizeof(CmListBinEnt);
+ *result = (uint16_t) sizeof(CmListBinEnt);
#endif
return ROK;
}
{
case CM_HASH_QUERYTYPE_ENTRIES: /* current number of entries */
#ifndef CM_MT_HASH_BIN
- *result = (U16) hashListCp->nmbEnt;
+ *result = (uint16_t) hashListCp->nmbEnt;
#else
*result = 0;
for (i=0; i < hashListCp->nmbBins; i++)
return ROK;
case CM_HASH_QUERYTYPE_BINS: /* number of bins */
- *result = (U16) hashListCp->nmbBins;
+ *result = (uint16_t) hashListCp->nmbBins;
return ROK;
case CM_HASH_QUERYTYPE_OFFSET: /* offset of CmHashListEnt in entries */
- *result = (U16) hashListCp->offset;
+ *result = (uint16_t) hashListCp->offset;
return ROK;
case CM_HASH_QUERYTYPE_DUPFLG: /* allow duplicate keys */
- *result = (U16) hashListCp->dupFlg;
+ *result = (uint16_t) hashListCp->dupFlg;
return ROK;
case CM_HASH_QUERYTYPE_KEYTYPE: /* key type for selecting hash functions */
- *result = (U16) hashListCp->keyType;
+ *result = (uint16_t) hashListCp->keyType;
return ROK;
default: /* process other query types */
(
CmHashListCp *hashListCp, /* hash table to add to */
PTR entry, /* entry to add */
-U8 *key, /* pointer to key */
-U16 keyLen /* length of key */
+uint8_t *key, /* pointer to key */
+uint16_t keyLen /* length of key */
)
#else
S16 cmHashListOAInsert(hashListCp, entry, key, keyLen)
CmHashListCp *hashListCp; /* hash table to add to */
PTR entry; /* entry to add */
-U8 *key; /* pointer to key */
-U16 keyLen; /* length of key */
+uint8_t *key; /* pointer to key */
+uint16_t keyLen; /* length of key */
#endif
{
/* cm_hash_c_001.main_21. Modify. Compilation Issue resolved. */
CmListBinEnt *hashBin; /* temporary hash list bin pointer */
#endif
CmHashListEnt *hashListEnt; /* pointer to hash list entry header */
- U16 idx; /* index for insertion into hash list */
- U16 hashSize; /* hash size */
- U16 i;
+ uint16_t idx; /* index for insertion into hash list */
+ uint16_t hashSize; /* hash size */
+ uint16_t i;
/* cm_hash_c_001.main_21. Modify. Compilation Issue resolved. */
- U16 nmbEnt;
+ uint16_t nmbEnt;
#if (ERRCLASS & ERRCLS_DEBUG)
return (ROUTRES);
/* get pointer to hash list entry header */
- hashListEnt = (CmHashListEnt *) (((U8 *) entry) + hashListCp->offset);
+ hashListEnt = (CmHashListEnt *) (((uint8_t *) entry) + hashListCp->offset);
/* initialize hash list entry header */
hashListEnt->list.next = NULLP;
#define CM_HASH_KEYTYPE_STR 3 /* Hash Function for Strings */
-#define CM_HASH_KEYTYPE_U32MOD 4 /* Mods the key with number of bins
- * useful if key is U32 numeric */
+#define CM_HASH_KEYTYPE_UINT32_MOD 4 /* Mods the key with number of bins
+ * useful if key is uint32_t numeric */
#define CM_HASH_KEYTYPE_CONID 5 /* Uses diff computation for keylen
- < U32. Ideal fo conId type params */
+ < uint32_t. Ideal fo conId type params */
#define CM_HASH_KEYTYPE_BCD8 6 /* Converts the 8 BCD coded octets
- * into 2 U32s and then adds 2
- * U32s to get one U32. Then applies the
- * U32Mod technique to get the index */
+ * into 2 uint32_ts and then adds 2
+ * uint32_ts to get one uint32_t. Then applies the
+ * uint32_tMod technique to get the index */
#define CM_HASH_KEYTYPE_ANY 7 /* Converts a variable length key into
- * a U32 which is then mapped to number
+ * a uint32_t which is then mapped to number
* of hash bins
*/
/* CONSTANTS for CmHashFuncConId */
/* cm_hash_h_001.main_13 : Fixed for 64 Bit */
-#define CM_HASHKEYLEN_U32 sizeof(U32) /* size of U32 */
-#define CM_HASHKEYLEN_U16 sizeof(U16) /* size of U16 */
-#define CM_HASHKEYLEN_U8 sizeof(U8) /* size of U8 */
+#define CM_HASHKEYLEN_UINT32 sizeof(uint32_t) /* size of uint32_t */
+#define CM_HASHKEYLEN_UINT16 sizeof(uint16_t) /* size of uint16_t */
+#define CM_HASHKEYLEN_UINT8 sizeof(uint8_t) /* size of uint8_t */
/* query types */
/* hash function */
-typedef S16 (* CmHashFunc) ARGS((CmHashListCp *hashListCp, U8 *key,
- U16 keyLen, U16 *idx));
+typedef S16 (* CmHashFunc) ARGS((CmHashListCp *hashListCp, uint8_t *key,
+ uint16_t keyLen, uint16_t *idx));
/* list entry */
typedef struct cmListEnt CmListEnt; /* list entry */
{
CmListEnt *next; /* next entry in list */
CmListEnt *prev; /* prev entry in list */
- U16 nmbEnt; /* current number of entries */
+ uint16_t nmbEnt; /* current number of entries */
};
#endif
typedef struct cmHashListEnt /* hash list entry */
{
CmListEnt list; /* list pointers */
- U8 *key; /* pointer to key */
- U16 keyLen; /* length of key */
- U16 hashVal; /* computed hash value */
+ uint8_t *key; /* pointer to key */
+ uint16_t keyLen; /* length of key */
+ uint16_t hashVal; /* computed hash value */
} CmHashListEnt;
/* hash list control point */
#endif
Region region; /* memory region to allocate bins */
Pool pool; /* memory pool to allocate bins */
- U16 nmbBins; /* number of hash list bins */
- U16 binBitMask; /* number of bits if nmbBins is power of 2 */
- U8 nmbBinBits; /* number of bits to represent nmbBins */
+ uint16_t nmbBins; /* number of hash list bins */
+ uint16_t binBitMask; /* number of bits if nmbBins is power of 2 */
+ uint8_t nmbBinBits; /* number of bits to represent nmbBins */
#ifndef CM_MT_HASH_BIN
- U16 nmbEnt; /* current number of entries */
+ uint16_t nmbEnt; /* current number of entries */
#endif
- U16 offset; /* offset of CmHashListEnt in entries */
+ uint16_t offset; /* offset of CmHashListEnt in entries */
Bool dupFlg; /* allow duplicate keys */
- U16 keyType; /* key type for selecting hash functions */
+ uint16_t keyType; /* key type for selecting hash functions */
CmHashFunc hashFunc; /* hash function for this key type */
};
EXTERN S16 cmHashListInit ARGS((
CmHashListCp *hashListCp, /* hash list to initialize */
- U16 nmbBins, /* number of hash list bins */
- U16 offset, /* offset of CmHashListEnt in entries */
+ uint16_t nmbBins, /* number of hash list bins */
+ uint16_t offset, /* offset of CmHashListEnt in entries */
Bool dupFlg, /* allow duplicate keys */
- U16 keyType, /* key type for selecting hash fn */
+ uint16_t keyType, /* key type for selecting hash fn */
Region region, /* memory region to allocate bins */
Pool pool)); /* memory pool to allocate bins */
EXTERN S16 cmHashListInsert ARGS((
CmHashListCp *hashListCp, /* hash list to add to */
PTR entry, /* entry to add */
- U8 *key, /* pointer to key */
- U16 keyLen)); /* length of key */
+ uint8_t *key, /* pointer to key */
+ uint16_t keyLen)); /* length of key */
EXTERN S16 cmHashListDelete ARGS((
CmHashListCp *hashListCp, /* hash list to delete from */
EXTERN S16 cmHashListFind ARGS((
CmHashListCp *hashListCp, /* hash list to search */
- U8 *key, /* pointer to key */
- U16 keyLen, /* length of key */
- U16 seqNmb, /* used in case of duplicate keys */
+ uint8_t *key, /* pointer to key */
+ uint16_t keyLen, /* length of key */
+ uint16_t seqNmb, /* used in case of duplicate keys */
PTR *entry)); /* entry to be returned */
EXTERN S16 cmHashListGetNext ARGS((
#ifdef CM_MT_HASH_BIN
EXTERN S16 cmHashListBinGetNextEntry ARGS((
CmHashListCp *hashListCp, /* hash list to get from */
- U16 binIdx, /* Index of the bin */
+ uint16_t binIdx, /* Index of the bin */
PTR prevEnt, /* previous entry */
PTR *entry)); /* entry to be returned */
#endif
*/
EXTERN S16 cmHashListQuery ARGS((
CmHashListCp *hashListCp, /* hash list to query */
- U8 queryType, /* type of query */
- U16 *result)); /* result of query */
+ uint8_t queryType, /* type of query */
+ uint16_t *result)); /* result of query */
/* Hash list with open addressing
*/
EXTERN S16 cmHashListOAInsert ARGS((
CmHashListCp *hashListCp, /* hash list to add to */
PTR entry, /* entry to add */
- U8 *key, /* pointer to key */
- U16 keyLen)); /* length of key */
+ uint8_t *key, /* pointer to key */
+ uint16_t keyLen)); /* length of key */
#ifdef __cplusplus
}
#if (!(defined(WIN32)) && !(defined(CMINETFLATBUF)))
/* Added another function parameter */
PRIVATE S16 buildRecvBuf ARGS((CmInetMemInfo *info, MsgLen len,
- CmInetIovec rxArr[], Buffer *dBuf[], U16 maxSize,
+ CmInetIovec rxArr[], Buffer *dBuf[], uint16_t maxSize,
struct msghdr *msg, Bool isStrmMsg));
PRIVATE S16 buildRecvMsg ARGS((CmInetMemInfo *info, CmInetIovec rxArr[],
S16 numBduf, MsgLen msgLen, Buffer *dBufs[],
*/
PRIVATE S16 buildSendIovec ARGS((Buffer *mBuf, MsgLen msgLen,
CmInetIovec txArr[], S16 numDBuf,
- S16 *numIovElems, U32 *strtEndDBufNum,
+ S16 *numIovElems, uint32_t *strtEndDBufNum,
MsgLen *ioLen));
#endif /* (defined(WIN32)) && !(defined(CMINETFLATBUF)) */
#ifdef IPV6_SUPPORTED
#ifdef IPV6_OPTS_SUPPORTED
PRIVATE S16 cmInet6BuildSendHBHOpts ARGS((CmInetIpv6HBHHdrArr *hbhOptsArr,
- U8 *cmsgBuf, U32 *curMsgIdx,
- U8 hdrId));
+ uint8_t *cmsgBuf, uint32_t *curMsgIdx,
+ uint8_t hdrId));
PRIVATE S16 cmInet6BuildSendRouteOpts ARGS((CmInetIpv6RtHdr *rtOptsArr,
- U8 *cmsgBuf, U32 *curMsgIdx));
+ uint8_t *cmsgBuf, uint32_t *curMsgIdx));
-PRIVATE S16 cmInet6BuildRecvRtHdr ARGS((U8 *cmsgData, U32 rtDataLen,
+PRIVATE S16 cmInet6BuildRecvRtHdr ARGS((uint8_t *cmsgData, uint32_t rtDataLen,
CmInetIpv6RtHdr0 *rtHdr0,
CmInetIpv6RtHdr *rtOptsArr,
CmInetMemInfo *info));
-PRIVATE S16 cmInet6BuildRecvHopOptsArr ARGS((U8 *cmsgData, U32 hbhDataLen,
+PRIVATE S16 cmInet6BuildRecvHopOptsArr ARGS((uint8_t *cmsgData, uint32_t hbhDataLen,
CmInetIpv6HBHHdrArr *hbhOptsArr,
- U8 hdrId, CmInetMemInfo *info));
-PRIVATE S16 cmInet6GetHopLimitValue ARGS((U8 *cmsgData, U32 hopLimitDataLen,
+ uint8_t hdrId, CmInetMemInfo *info));
+PRIVATE S16 cmInet6GetHopLimitValue ARGS((uint8_t *cmsgData, uint32_t hopLimitDataLen,
CmInetIpv6HdrParm *ipv6HdrParam));
#ifdef SS_LINUX
-PRIVATE S16 cmInetBuildSendHoplimit ARGS((U32 hoplimit, U8 *cmsgBuf,
- U32 *curMsgIdx));
+PRIVATE S16 cmInetBuildSendHoplimit ARGS((uint32_t hoplimit, uint8_t *cmsgBuf,
+ uint32_t *curMsgIdx));
#endif /* SS_LINUX */
#ifdef LOCAL_INTF
PRIVATE S16 cmInet6BuildSendPktinfo ARGS((CmInetIpAddr6 *srcAddr,
- U8 *cmsgBuf, U32 *curMsgIdx,
- U8 protType));
+ uint8_t *cmsgBuf, uint32_t *curMsgIdx,
+ uint8_t protType));
#endif /* LOCAL_INTF */
#endif /* IPV6_OPTS_SUPPORTED */
#endif /* IPV6_SUPPORTED */
S16 cmInetPoll
(
CmInetPollFd *pollFdArr, /* poll FD Array */
-U32 numFds, /* Number of Fds to be monitored */
+uint32_t numFds, /* Number of Fds to be monitored */
S16 *numRdyFds, /* number of ready descriptors */
-U32 timeout /* timeout value for Poll */
+uint32_t timeout /* timeout value for Poll */
)
#else
S16 cmInetPoll(pollFdArr,numFds,numRdyFds,timeout)
CmInetPollFd *pollFdArr; /* poll FD Array */
-U32 numFds; /* Number of Fds to be monitored */
+uint32_t numFds; /* Number of Fds to be monitored */
S16 *numRdyFds; /* number of ready descriptors */
-U32 timeout; /* timeout value for Poll */
+uint32_t timeout; /* timeout value for Poll */
#endif
{
S32 ret;
CmInetFd *sockFd, /* socket file descriptor */
CmInetPollFd *pollFdArr, /* poll FD Array */
S16 idx, /* poll Fd Array Index */
-U16 eventMask /* Event Mask to be set */
+uint16_t eventMask /* Event Mask to be set */
)
#else
S16 cmInetPollSetFd(sockFd,pollFdArr,idx,eventMask)
CmInetFd *sockFd; /* socket file descriptor */
CmInetPollFd *pollFdArr; /* poll FD Array */
S16 idx; /* poll Fd Array Index */
-U16 eventMask; /* Event Mask to be set */
+uint16_t eventMask; /* Event Mask to be set */
#endif
{
(
CmInetPollFd *pollFdArr, /* poll FD Array */
S16 idx, /* poll Fd Array Index */
-U16 eventMask /* Event Mask to be set */
+uint16_t eventMask /* Event Mask to be set */
)
#else
S16 cmInetPollFdIsSet(pollFdArr,idx,eventMask)
CmInetPollFd *pollFdArr; /* poll FD Array */
S16 idx; /* poll Fd Array Index */
-U16 eventMask; /* Event Mask to be set */
+uint16_t eventMask; /* Event Mask to be set */
#endif
{
S16 ret;
(
CmInetPollFd *pollFdArr, /* poll FD Array */
S16 idx, /* poll Fd Array Index */
-U16 eventMask /* Event Mask to be set */
+uint16_t eventMask /* Event Mask to be set */
)
#else
S16 cmInetPollClearFdREvent(sockFd,pollFdArr,eventMask)
CmInetPollFd *pollFdArr; /* poll FD Array */
S16 idx; /* poll Fd Array Index */
-U16 eventMask; /* Event Mask to be set */
+uint16_t eventMask; /* Event Mask to be set */
#endif
{
(
CmInetPollFd *pollFdArr, /* poll FD Array */
S16 idx, /* poll Fd Array Index */
-U16 eventMask /* Event Mask to be set */
+uint16_t eventMask /* Event Mask to be set */
)
#else
S16 cmInetPollClearFdEvent(sockFd,pollFdArr,eventMask)
CmInetPollFd *pollFdArr; /* poll FD Array */
S16 idx; /* poll Fd Array Index */
-U16 eventMask; /* Event Mask to be set */
+uint16_t eventMask; /* Event Mask to be set */
#endif
{
MsgLen len, /* message length */
CmInetIovec rxArr[], /* gather array */
Buffer *dBuf[], /* allocated dBufs */
-U16 maxSize, /* size of rxArr/dBuf array */
+uint16_t maxSize, /* size of rxArr/dBuf array */
struct msghdr *msg, /* message header for recvmsg() */
Bool isStrmMsg /* Is a TCP message */
)
MsgLen len; /* message length */
CmInetIovec rxArr[]; /* gather array */
Buffer *dBuf[]; /* allocated dBufs */
- U16 maxSize; /* size of rxArr/dBuf array */
+ uint16_t maxSize; /* size of rxArr/dBuf array */
struct msghdr *msg; /* message header for recvmsg() */
Bool isStrmMsg; /* Is a TCP message */
#endif
{
S16 ret; /* temporary return value */
- U16 numBuf; /* number of dBufs */
- U16 i; /* dBuf index counter */
+ uint16_t numBuf; /* number of dBufs */
+ uint16_t i; /* dBuf index counter */
Data *dPtr; /* data pointer */
/* cm_inet_c_001.main_47: 102069 Changed from S32 to MsgLen for bufLen*/
MsgLen bufLen; /* entire receive buffer length, if S16
#ifdef T2K_MEM_LEAK_DBG
char * file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
ret = SGetDBuf(info->region, info->pool, &dBuf[numBuf]);
#else
ret = SGetDBuf(info->region, info->pool, &dBuf[numBuf]);
#ifdef SS_LINUX
rxArr[numBuf].iov_base = (Void*)dPtr;
- rxArr[numBuf].iov_len = (U32)dLen;
+ rxArr[numBuf].iov_len = (uint32_t)dLen;
#else
rxArr[numBuf].iov_base = (S8*)dPtr;
rxArr[numBuf].iov_len = dLen;
}
#ifdef SS_LINUX
rxArr[numBuf].iov_base = (Void*)dPtr;
- rxArr[numBuf].iov_len = (U32)dLen;
+ rxArr[numBuf].iov_len = (uint32_t)dLen;
#else
rxArr[numBuf].iov_base = (S8*)dPtr;
rxArr[numBuf].iov_len = dLen;
{
#ifdef T2K_MEM_LEAK_DBG
char * file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
SPutDBuf(info->region, info->pool, dBufs[i]);
#else
SPutDBuf(info->region, info->pool, dBufs[i]);
CmInetIovec txArr[], /* transmit scatter vector array */
S16 numDBufs, /* Maximum number of dBufs to use */
S16 *numIovElems, /* Number of iov elements in array */
-U32 *strtEndDBufNum, /* dBuf number to start and end */
+uint32_t *strtEndDBufNum, /* dBuf number to start and end */
MsgLen *ioLen /* cm_inet_c_001.main_50 - Len of dbuf packed into IO-vector */
)
#else
CmInetIovec txArr[]; /* transmit scatter vector array */
S16 numDBufs; /* Maximum number of dBufs to use */
S16 *numIovElems; /* Number of iov elements in array */
-U32 *strtEndDBufNum; /* dBuf number to start and end */
+uint32_t *strtEndDBufNum; /* dBuf number to start and end */
MsgLen *ioLen; /* cm_inet_c_001.main_50 - Len of dbuf packed into IO-vector */
#endif
{
Buffer *dBuf;
Data *dPtr;
MsgLen allocLen;
- U32 dBufsToSkip;
+ uint32_t dBufsToSkip;
/* Initialisations */
(*numIovElems) = 0;
#ifdef IPV6_SUPPORTED
S16 cmInetSocket
(
-U8 type, /* socket type */
+uint8_t type, /* socket type */
CmInetFd *sockFd, /* socket file descriptor */
-U8 protocol, /* protocol value */
-U8 domain /* domain */
+uint8_t protocol, /* protocol value */
+uint8_t domain /* domain */
)
#else
S16 cmInetSocket
(
-U8 type, /* socket type */
+uint8_t type, /* socket type */
CmInetFd *sockFd, /* socket file descriptor */
-U8 protocol /* protocol value */
+uint8_t protocol /* protocol value */
)
#endif /* IPV6_SUPPORTED */
#else /* CM_INET2 */
S16 cmInetSocket
(
-U8 type, /* socket type */
+uint8_t type, /* socket type */
CmInetFd *sockFd /* socket file descriptor */
)
#endif /* CM_INET2 */
#ifdef CM_INET2
#ifdef IPV6_SUPPORTED
S16 cmInetSocket(type, sockFd, protocol, domain)
-U8 type; /* socket type */
+uint8_t type; /* socket type */
CmInetFd *sockFd; /* socket file descriptor */
-U8 protocol; /* protocol value */
-U8 domain; /* domain */
+uint8_t protocol; /* protocol value */
+uint8_t domain; /* domain */
#else
S16 cmInetSocket(type, sockFd, protocol)
-U8 type; /* socket type */
+uint8_t type; /* socket type */
CmInetFd *sockFd; /* socket file descriptor */
-U8 protocol; /* protocol value */
+uint8_t protocol; /* protocol value */
#endif /* IPV6_SUPPORTED */
#else /* CM_INET2 */
S16 cmInetSocket(type, sockFd)
-U8 type; /* socket type */
+uint8_t type; /* socket type */
CmInetFd *sockFd; /* socket file descriptor */
#endif /* CM_INET2 */
#endif /* ANSI */
{
S32 ret; /* temporary return value */
- U32 optVal;
+ uint32_t optVal;
#if (defined(WIN32) && defined(WIN2K))
S32 bytesReturned;
#ifdef IPV6_SUPPORTED
struct sockaddr_in6 srcAddr6; /* local IPV6 address/port */
#ifdef CMINETDBG
- U16 port;
+ uint16_t port;
#endif /* CMINETDBG */
#endif /* IPV6_SUPPORTED */
- U32 sizeOfAddr; /* sizeof address passed to the bind call */
+ uint32_t sizeOfAddr; /* sizeof address passed to the bind call */
CmInetSockAddr *sockAddrPtr;
{
memset(&srcAddr6, 0, sizeof(srcAddr6));
srcAddr6.sin6_family = AF_INET6;
- srcAddr6.sin6_port = CM_INET_HTON_U16(myAddr->u.ipv6Addr.port);
+ srcAddr6.sin6_port = CM_INET_HTON_UINT16(myAddr->u.ipv6Addr.port);
CM_INET_COPY_IPV6ADDR(&srcAddr6.sin6_addr,
&myAddr->u.ipv6Addr.ipv6NetAddr);
sizeOfAddr = sizeof(struct sockaddr_in6);
{
memset(&srcAddr, 0, sizeof(srcAddr));
srcAddr.sin_family = AF_INET;
- srcAddr.sin_port = CM_INET_HTON_U16(myAddr->u.ipv4Addr.port);
- srcAddr.sin_addr.s_addr = CM_INET_HTON_U32(myAddr->u.ipv4Addr.address);
+ srcAddr.sin_port = CM_INET_HTON_UINT16(myAddr->u.ipv4Addr.port);
+ srcAddr.sin_addr.s_addr = CM_INET_HTON_UINT32(myAddr->u.ipv4Addr.address);
sizeOfAddr = sizeof(struct sockaddr_in);
sockAddrPtr = (CmInetSockAddr *)&srcAddr;
}
#else
memset(&srcAddr, 0, sizeof(srcAddr));
srcAddr.sin_family = AF_INET;
- srcAddr.sin_port = CM_INET_HTON_U16(myAddr->port);
- srcAddr.sin_addr.s_addr = CM_INET_HTON_U32(myAddr->address);
+ srcAddr.sin_port = CM_INET_HTON_UINT16(myAddr->port);
+ srcAddr.sin_addr.s_addr = CM_INET_HTON_UINT32(myAddr->address);
sizeOfAddr = sizeof(struct sockaddr_in);
sockAddrPtr = (CmInetSockAddr *)&srcAddr;
#endif /* IPV6_SUPPORTED */
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetNetAddrLst *addrLst, /* local Internet address list */
-U16 port /* port number */
+uint16_t port /* port number */
)
#else
S16 cmInetSctpBindx(sockFd, addrLst, port)
CmInetFd *sockFd; /* socket file descriptor */
CmInetNetAddrLst *addrLst; /* locale Internet address list */
-U16 port; /* port number */
+uint16_t port; /* port number */
#endif
{
S32 ret; /* temporary return value */
S32 idx;
S32 idx4 = 0;
- U32 ipv4_array_size = 0;
+ uint32_t ipv4_array_size = 0;
struct sockaddr_in addrs[CM_INET_NUM_NET_ADDR];
#ifndef IPV6_SUPPORTED
Data address_array[(CM_INET_NUM_NET_ADDR * sizeof(struct sockaddr_in))];
#ifdef SUN_KSCTP
Data *tempAddrPtr = NULLP;
#endif
- U32 addresses_array_size = 0;
+ uint32_t addresses_array_size = 0;
#ifdef IPV6_SUPPORTED
#ifdef SUN_KSCTP
S8 *addrString = NULLP;
- U32 addrLen = 0;
+ uint32_t addrLen = 0;
S8 ipv4Format[23] = "::ffff:";
#endif /* SUN_KSCTP */
S32 idx6 = 0;
- U32 ipv6_array_size = 0;
+ uint32_t ipv6_array_size = 0;
struct sockaddr_in6 addrs6[CM_INET_NUM_NET_ADDR];
#endif /* IPV6_SUPPORTED */
struct sockaddr *sockAddrPtr = NULLP;
- U32 sockAddrLen = 0;
+ uint32_t sockAddrLen = 0;
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
}
addrs6[idx6].sin6_family = AF_INET6;
- addrs6[idx6].sin6_port = CM_INET_HTON_U16(port);
+ addrs6[idx6].sin6_port = CM_INET_HTON_UINT16(port);
CM_INET_COPY_IPV6ADDR((addrs6[idx6].sin6_addr.s6_addr), &(addrLst->addrs[idx].u.ipv6NetAddr));
idx6++;
}
}
addrs6[idx6].sin6_family = AF_INET6;
- addrs6[idx6].sin6_port = CM_INET_HTON_U16(port);
- addrLst->addrs[idx].u.ipv4NetAddr = CM_INET_HTON_U32(addrLst->addrs[idx].u.ipv4NetAddr);
+ addrs6[idx6].sin6_port = CM_INET_HTON_UINT16(port);
+ addrLst->addrs[idx].u.ipv4NetAddr = CM_INET_HTON_UINT32(addrLst->addrs[idx].u.ipv4NetAddr);
cmInetNtoa(addrLst->addrs[idx].u.ipv4NetAddr, &addrString);
- addrLen = cmStrlen((U8*)addrString);
+ addrLen = cmStrlen((uint8_t*)addrString);
memcpy((ipv4Format+7), addrString, addrLen);
ipv4Format[7+addrLen] = '\0';
cmInetPton6((CmInetIpAddr6*)(addrs6[idx6].sin6_addr.s6_addr), ipv4Format);
ipv4_array_size += sizeof(struct sockaddr_in);
addresses_array_size += sizeof(struct sockaddr_in);
addrs[idx4].sin_family = AF_INET;
- addrs[idx4].sin_port = CM_INET_HTON_U16(port);
- addrs[idx4].sin_addr.s_addr = CM_INET_HTON_U32(addrLst->addrs[idx].u.ipv4NetAddr);
+ addrs[idx4].sin_port = CM_INET_HTON_UINT16(port);
+ addrs[idx4].sin_addr.s_addr = CM_INET_HTON_UINT32(addrLst->addrs[idx].u.ipv4NetAddr);
idx4++;
#endif /* SUN_KSCTP */
}
ipv4_array_size += sizeof(struct sockaddr_in);
addresses_array_size += sizeof(struct sockaddr_in);
addrs[idx4].sin_family = AF_INET;
- addrs[idx4].sin_port = CM_INET_HTON_U16(port);
- addrs[idx4].sin_addr.s_addr = CM_INET_HTON_U32(addrLst->addrs[idx].u.ipv4NetAddr);
+ addrs[idx4].sin_port = CM_INET_HTON_UINT16(port);
+ addrs[idx4].sin_addr.s_addr = CM_INET_HTON_UINT32(addrLst->addrs[idx].u.ipv4NetAddr);
idx4++;
#endif /* IPV6_SUPPORTED */
}
CmInetFd *sockFd, /* socket file descriptor */
CmInetNetAddr *primAddr, /* primary destination Internet address */
CmInetNetAddrLst *addrLst, /* destination Internet address list */
-U16 port /* port number */
+uint16_t port /* port number */
)
#else
S16 cmInetSctpConnectx(sockFd, primAddr, addrLst, port)
CmInetFd *sockFd; /* socket file descriptor */
CmInetNetAddr *primAddr; /* primary destination Internet address */
CmInetNetAddrLst *addrLst; /* destination Internet address list */
-U16 port; /* port number */
+uint16_t port; /* port number */
#endif
{
S32 ret;
- U32 cnt;
+ uint32_t cnt;
/* cm_inet_c_001.main_46: Removed SS_LINUX flag */
S32 idx;
/* cm_inet_c_001.main_64: New variable used as an argument for sctp_connectx */
#ifdef SCTP_CONNECTX_NEW
- U32 assocId = 0;
+ uint32_t assocId = 0;
#endif
- U32 addresses_array_size = 0;
- U32 idx4 = 0;
+ uint32_t addresses_array_size = 0;
+ uint32_t idx4 = 0;
struct sockaddr_in addrs[CM_INET_NUM_NET_ADDR];
- U32 ipv4_array_size = 0;
+ uint32_t ipv4_array_size = 0;
#ifndef IPV6_SUPPORTED
Data address_array[(CM_INET_NUM_NET_ADDR * sizeof(struct sockaddr_in))];
#ifdef IPV6_SUPPORTED
#ifdef SUN_KSCTP
S8 *addrString = NULLP;
- U32 addrLen = 0;
+ uint32_t addrLen = 0;
S8 ipv4Format[23] = "::ffff:";
CmInetIpAddr ipv4NetAddr;
#endif /* SUN_KSCTP */
- U32 idx6 = 0;
+ uint32_t idx6 = 0;
struct sockaddr_in6 addrs6[CM_INET_NUM_NET_ADDR];
- U32 ipv6_array_size = 0;
+ uint32_t ipv6_array_size = 0;
#endif /* IPV6_SUPPORTED */
#ifndef SS_LINUX
- U32 sockAddrLen = 0;
+ uint32_t sockAddrLen = 0;
#endif /* sockAddrLen */
#ifndef SS_LINUX
}
addrs6[idx6].sin6_family = AF_INET6;
- addrs6[idx6].sin6_port = CM_INET_HTON_U16(port);
+ addrs6[idx6].sin6_port = CM_INET_HTON_UINT16(port);
CM_INET_COPY_IPV6ADDR(&(addrs6[idx6].sin6_addr.s6_addr), &(primAddr->u.ipv6NetAddr));
addresses_array_size += sizeof(struct sockaddr_in6);
ipv6_array_size += sizeof(struct sockaddr_in6);
return RFAILED;
}
addrs6[idx6].sin6_family = AF_INET6;
- addrs6[idx6].sin6_port = CM_INET_HTON_U16(port);
- ipv4NetAddr = CM_INET_HTON_U32(primAddr->u.ipv4NetAddr);
+ addrs6[idx6].sin6_port = CM_INET_HTON_UINT16(port);
+ ipv4NetAddr = CM_INET_HTON_UINT32(primAddr->u.ipv4NetAddr);
cmInetNtoa(ipv4NetAddr, &addrString);
- addrLen = cmStrlen((U8*)addrString);
+ addrLen = cmStrlen((uint8_t*)addrString);
memcpy((ipv4Format+7), addrString, addrLen);
ipv4Format[7+addrLen] = '\0';
cmInetPton6((CmInetIpAddr6*)&(addrs6[idx6].sin6_addr), ipv4Format);
idx6++;
#else
addrs[idx4].sin_family = AF_INET;
- addrs[idx4].sin_port = CM_INET_HTON_U16(port);
- addrs[idx4].sin_addr.s_addr = CM_INET_HTON_U32(primAddr->u.ipv4NetAddr);
+ addrs[idx4].sin_port = CM_INET_HTON_UINT16(port);
+ addrs[idx4].sin_addr.s_addr = CM_INET_HTON_UINT32(primAddr->u.ipv4NetAddr);
addresses_array_size += sizeof(struct sockaddr_in);
ipv4_array_size += sizeof(struct sockaddr_in);
idx4++;
}
#else
addrs[idx4].sin_family = AF_INET;
- addrs[idx4].sin_port = CM_INET_HTON_U16(port);
- addrs[idx4].sin_addr.s_addr = CM_INET_HTON_U32(primAddr->u.ipv4NetAddr);
+ addrs[idx4].sin_port = CM_INET_HTON_UINT16(port);
+ addrs[idx4].sin_addr.s_addr = CM_INET_HTON_UINT32(primAddr->u.ipv4NetAddr);
addresses_array_size += sizeof(struct sockaddr_in);
ipv4_array_size += sizeof(struct sockaddr_in);
idx4++;
}
addrs6[idx6].sin6_family = AF_INET6;
- addrs6[idx6].sin6_port = CM_INET_HTON_U16(port);
+ addrs6[idx6].sin6_port = CM_INET_HTON_UINT16(port);
CM_INET_COPY_IPV6ADDR(&(addrs6[idx6].sin6_addr.s6_addr),
&(addrLst->addrs[idx].u.ipv6NetAddr));
addresses_array_size += sizeof(struct sockaddr_in6);
return RFAILED;
}
addrs6[idx6].sin6_family = AF_INET6;
- addrs6[idx6].sin6_port = CM_INET_HTON_U16(port);
- ipv4NetAddr = CM_INET_HTON_U32(addrLst->addrs[idx].u.ipv4NetAddr);
+ addrs6[idx6].sin6_port = CM_INET_HTON_UINT16(port);
+ ipv4NetAddr = CM_INET_HTON_UINT32(addrLst->addrs[idx].u.ipv4NetAddr);
cmInetNtoa(ipv4NetAddr, &addrString);
- addrLen = cmStrlen((U8*)addrString);
+ addrLen = cmStrlen((uint8_t*)addrString);
memcpy((ipv4Format+7), addrString, addrLen);
ipv4Format[7+addrLen] = '\0';
cmInetPton6((CmInetIpAddr6*)(addrs6[idx6].sin6_addr.s6_addr), ipv4Format);
idx6++;
#else
addrs[idx4].sin_family = AF_INET;
- addrs[idx4].sin_port = CM_INET_HTON_U16(port);
- addrs[idx4].sin_addr.s_addr = CM_INET_HTON_U32(addrLst->addrs[idx].u.ipv4NetAddr);
+ addrs[idx4].sin_port = CM_INET_HTON_UINT16(port);
+ addrs[idx4].sin_addr.s_addr = CM_INET_HTON_UINT32(addrLst->addrs[idx].u.ipv4NetAddr);
addresses_array_size += sizeof(struct sockaddr_in);
ipv4_array_size += sizeof(struct sockaddr_in);
idx4++;
}
#else
addrs[idx4].sin_family = AF_INET;
- addrs[idx4].sin_port = CM_INET_HTON_U16(port);
- addrs[idx4].sin_addr.s_addr = CM_INET_HTON_U32(addrLst->addrs[idx].u.ipv4NetAddr);
+ addrs[idx4].sin_port = CM_INET_HTON_UINT16(port);
+ addrs[idx4].sin_addr.s_addr = CM_INET_HTON_UINT32(addrLst->addrs[idx].u.ipv4NetAddr);
addresses_array_size += sizeof(struct sockaddr_in);
ipv4_array_size += sizeof(struct sockaddr_in);
idx4++;
S16 cmInetSctpPeelOff
(
CmInetFd *sockFd, /* socket file descriptor */
-U32 assocId, /* association id */
+uint32_t assocId, /* association id */
CmInetFdType *assocFd /* association fd */
)
#else
S16 cmInetSctpPeelOff(sockFd, assocId, assocFd)
CmInetFd *sockFd; /* socket file descriptor */
-U32 assocId; /* association id */
+uint32_t assocId; /* association id */
CmInetFdType *assocFd; /* association fd */
#endif
{
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetNetAddr *dstAddr, /* destination Internet address/port */
-U16 port, /* destination port no. */
+uint16_t port, /* destination port no. */
CmInetMemInfo *info, /* buffer allocation info */
Buffer *mBuf, /* buffer structure to send */
MsgLen *len, /* number of actually sent octets */
-U16 strmId, /* sctp stream identifier */
+uint16_t strmId, /* sctp stream identifier */
Bool unorderFlg, /* flag to enable the unordered delivery */
-U16 ttl, /* time to live */
-U32 ppId, /* opaque value passed along with the message */
-U32 context /* value to be passed back, if error occurs */
+uint16_t ttl, /* time to live */
+uint32_t ppId, /* opaque value passed along with the message */
+uint32_t context /* value to be passed back, if error occurs */
)
#else
S16 cmInetSctpSendMsg(sockFd, dstAddr, port, info, mBuf, len, strmId,
unorderFlg, ttl, ppId, context)
CmInetFd *sockFd; /* socket file descriptor */
CmInetNetAddr *dstAddr; /* destination Internet address/port */
-U16 port; /* destination port no. */
+uint16_t port; /* destination port no. */
CmInetMemInfo *info; /* buffer allocation info */
Buffer *mBuf; /* buffer structure to send */
MsgLen *len; /* number of actually sent octets */
-U16 strmId; /* sctp stream identifier */
+uint16_t strmId; /* sctp stream identifier */
Bool unorderFlg; /* flag to enable the unordered delivery */
-U16 ttl; /* time to live */
-U32 ppId; /* opaque value passed along with the message */
-U32 context; /* value to be passed back, if error occurs */
+uint16_t ttl; /* time to live */
+uint32_t ppId; /* opaque value passed along with the message */
+uint32_t context; /* value to be passed back, if error occurs */
#endif
{
S32 ret;
MsgLen msgLen = 0; /* message length */
MsgLen bufLen = 0; /* send buffer length */
Data *sendBuf = NULLP; /* plain send buffer */
- U32 flags;
+ uint32_t flags;
CmInetSockAddr *sockAddrPtr = NULLP;
/* cm_inet_c_001.main_58 : Fix for klockwork issue */
MsgLen sockAddrLen = 0;
#ifdef IPV6_SUPPORTED
#ifdef SUN_KSCTP
S8 *addrString = NULLP;
- U32 addrLen = 0;
+ uint32_t addrLen = 0;
S8 ipv4Format[23] = "::ffff:";
CmInetIpAddr ipv4NetAddr;
#endif /* SUN_KSCTP */
}
/* max message length is limited to control the memory usage */
/* casting bufLen to avoid warnings */
- if ((bufLen > 0) && ((U32)bufLen > CM_INET_MAX_MSG_LEN))
+ if ((bufLen > 0) && ((uint32_t)bufLen > CM_INET_MAX_MSG_LEN))
{
return RFAILED;
}
}
addr6.sin6_family = AF_INET6;
- addr6.sin6_port = CM_INET_HTON_U16(port);
+ addr6.sin6_port = CM_INET_HTON_UINT16(port);
CM_INET_COPY_IPV6ADDR(&addr6.sin6_addr.s6_addr, &dstAddr->u.ipv6NetAddr);
sockAddrLen = sizeof(struct sockaddr_in6);
sockAddrPtr = (CmInetSockAddr*)&addr6;
return RFAILED;
}
addr6.sin6_family = AF_INET6;
- addr6.sin6_port = CM_INET_HTON_U16(port);
- ipv4NetAddr = CM_INET_HTON_U32(dstAddr->u.ipv4NetAddr);
+ addr6.sin6_port = CM_INET_HTON_UINT16(port);
+ ipv4NetAddr = CM_INET_HTON_UINT32(dstAddr->u.ipv4NetAddr);
cmInetNtoa(ipv4NetAddr, &addrString);
- addrLen = cmStrlen((U8*)addrString);
+ addrLen = cmStrlen((uint8_t*)addrString);
memcpy((ipv4Format+7), addrString, addrLen);
ipv4Format[7+addrLen] = '\0';
cmInetPton6((CmInetIpAddr6*)(addr6.sin6_addr.s6_addr), ipv4Format);
sockAddrPtr = (CmInetSockAddr*)&addr6;
#else
addr.sin_family = AF_INET;
- addr.sin_port = CM_INET_HTON_U16(port);
- addr.sin_addr.s_addr = CM_INET_HTON_U32(dstAddr->u.ipv4NetAddr);
+ addr.sin_port = CM_INET_HTON_UINT16(port);
+ addr.sin_addr.s_addr = CM_INET_HTON_UINT32(dstAddr->u.ipv4NetAddr);
sockAddrLen = sizeof(struct sockaddr_in);
sockAddrPtr = (CmInetSockAddr*)&addr;
#endif /* SUN_KSCTP */
}
#else
addr.sin_family = AF_INET;
- addr.sin_port = CM_INET_HTON_U16(port);
- addr.sin_addr.s_addr = CM_INET_HTON_U32(dstAddr->u.ipv4NetAddr);
+ addr.sin_port = CM_INET_HTON_UINT16(port);
+ addr.sin_addr.s_addr = CM_INET_HTON_UINT32(dstAddr->u.ipv4NetAddr);
/* cm_inet_c_001.main_58 : Fix for Klockwork issue */
sockAddrLen = (MsgLen)sizeof(struct sockaddr_in);
sockAddrPtr = (CmInetSockAddr*)&addr;
#endif
}
/*cm_inet_c_001.main_54: converting ppid to network*/
- ppId = CM_INET_HTON_U32(ppId);
+ ppId = CM_INET_HTON_UINT32(ppId);
ret = sctp_sendmsg(sockFd->fd, (Void*)sendBuf, bufLen,
(struct sockaddr*)sockAddrPtr, (size_t)sockAddrLen,
ppId, flags, strmId, ttl, context);
(
CmInetFd *sockFd, /* socket file descriptor */
CmInetNetAddr *srcAddr, /* source Internet address/port */
-U16 *port, /* source port no. */
+uint16_t *port, /* source port no. */
CmInetMemInfo *meminfo, /* buffer allocation info */
Buffer **mBuf, /* buffer structure received */
MsgLen *len, /* number of octets received */
CmInetSctpSndRcvInfo *sinfo, /* sctp send-receive info */
-U32 *flag, /* flags */
+uint32_t *flag, /* flags */
CmInetSctpNotification *ntfy /* notification parameters */
)
#else
sinfo, flag, ntfy)
CmInetFd *sockFd; /* socket file descriptor */
CmInetNetAddr *srcAddr; /* source Internet address/port */
-U16 *port; /* source port no. */
+uint16_t *port; /* source port no. */
CmInetMemInfo *meminfo; /* buffer allocation info */
Buffer **mBuf; /* buffer structure received */
MsgLen *len; /* number of octets received */
CmInetSctpSndRcvInfo *sinfo; /* sctp send-receive info */
-U32 *flag; /* flags */
+uint32_t *flag; /* flags */
CmInetSctpNotification *ntfy; /* notification parameters */
#endif
{
#ifdef IPV6_SUPPORTED
if (addr.ss_family == AF_INET6)
{
- U8 ipv4Format[12] = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff};
+ uint8_t ipv4Format[12] = {0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xff,0xff};
pAddr6 = (struct sockaddr_in6*)&addr;
- *port = CM_INET_NTOH_U16(pAddr6->sin6_port);
+ *port = CM_INET_NTOH_UINT16(pAddr6->sin6_port);
if((cmMemcmp(ipv4Format, pAddr6->sin6_addr.s6_addr, 12)) == 0)
{
srcAddr->type = CM_INET_IPV4ADDR_TYPE;
- memcpy(&srcAddr->u.ipv4NetAddr, ((pAddr6->sin6_addr.s6_addr) + 12), sizeof(U32));
- srcAddr->u.ipv4NetAddr = CM_INET_HTON_U32(srcAddr->u.ipv4NetAddr);
+ memcpy(&srcAddr->u.ipv4NetAddr, ((pAddr6->sin6_addr.s6_addr) + 12), sizeof(uint32_t));
+ srcAddr->u.ipv4NetAddr = CM_INET_HTON_uint32_t(srcAddr->u.ipv4NetAddr);
}
else
else
{
pAddr = (struct sockaddr_in*)&addr;
- *port = CM_INET_NTOH_U16(pAddr->sin_port);
+ *port = CM_INET_NTOH_UINT16(pAddr->sin_port);
srcAddr->type = CM_INET_IPV4ADDR_TYPE;
- srcAddr->u.ipv4NetAddr = CM_INET_NTOH_U32(pAddr->sin_addr.s_addr);
+ srcAddr->u.ipv4NetAddr = CM_INET_NTOH_UINT32(pAddr->sin_addr.s_addr);
}
#else
pAddr = (struct sockaddr_in*)&addr;
- *port = CM_INET_NTOH_U16(pAddr->sin_port);
+ *port = CM_INET_NTOH_UINT16(pAddr->sin_port);
srcAddr->type = CM_INET_IPV4ADDR_TYPE;
- srcAddr->u.ipv4NetAddr = CM_INET_NTOH_U32(pAddr->sin_addr.s_addr);
+ srcAddr->u.ipv4NetAddr = CM_INET_NTOH_UINT32(pAddr->sin_addr.s_addr);
#endif /* IPV6_SUPPORTED */
/* fill sndrcv info */
sinfo->ssn = info.sinfo_ssn;
sinfo->flags = info.sinfo_flags;
/*cm_inet_c_001.main_54: converting ppid to host*/
- sinfo->ppid = CM_INET_NTOH_U32(info.sinfo_ppid);
+ sinfo->ppid = CM_INET_NTOH_UINT32(info.sinfo_ppid);
sinfo->context = info.sinfo_context;
sinfo->timetolive = info.sinfo_timetolive;
sinfo->tsn = info.sinfo_tsn;
{
pAddr = (struct sockaddr_in*)&(sctpNtfy->sn_paddr_change.spc_aaddr);
ntfy->u.paddrChange.addr.type = CM_INET_IPV4ADDR_TYPE;
- ntfy->u.paddrChange.addr.u.ipv4NetAddr = CM_INET_NTOH_U32(pAddr->sin_addr.s_addr);
+ ntfy->u.paddrChange.addr.u.ipv4NetAddr = CM_INET_NTOH_UINT32(pAddr->sin_addr.s_addr);
}
#else
pAddr = (struct sockaddr_in*)&(sctpNtfy->sn_paddr_change.spc_aaddr);
ntfy->u.paddrChange.addr.type = CM_INET_IPV4ADDR_TYPE;
- ntfy->u.paddrChange.addr.u.ipv4NetAddr = CM_INET_NTOH_U32(pAddr->sin_addr.s_addr);
+ ntfy->u.paddrChange.addr.u.ipv4NetAddr = CM_INET_NTOH_UINT32(pAddr->sin_addr.s_addr);
#endif /* IPV6_SUPPORTED */
ntfy->u.paddrChange.error = sctpNtfy->sn_paddr_change.spc_error;
S16 cmInetSctpGetPAddrs
(
CmInetFd *sockFd, /* socket file descriptor */
-U32 assocId, /* association id */
+uint32_t assocId, /* association id */
CmInetNetAddrLst *addrlst /* peer address list */
)
#else
S16 cmInetSctpGetPAddrs(sockFd, assocId, addrlst)
CmInetFd *sockFd; /* socket file descriptor */
-U32 assocId; /* association id */
+uint32_t assocId; /* association id */
CmInetNetAddrLst *addrlst; /* peer address list */
#endif
{
/* cm_inet_c_001.main_58 : Fix for Klockwork issue */
S32 cnt;
S32 idx;
- U8 *byteAddress;
+ uint8_t *byteAddress;
struct sockaddr *peerAddrList;
struct sockaddr_in *pAddr;
#ifdef IPV6_SUPPORTED
return RFAILED;
}
- byteAddress = (U8*)peerAddrList;
+ byteAddress = (uint8_t*)peerAddrList;
for (idx = 0; idx < cnt; idx++)
{
#ifdef IPV6_SUPPORTED
{
pAddr = (struct sockaddr_in*)byteAddress;
addrlst->addrs[idx].type = CM_INET_IPV4ADDR_TYPE;
- addrlst->addrs[idx].u.ipv4NetAddr = CM_INET_NTOH_U32(pAddr->sin_addr.s_addr);
+ addrlst->addrs[idx].u.ipv4NetAddr = CM_INET_NTOH_UINT32(pAddr->sin_addr.s_addr);
byteAddress += sizeof(struct sockaddr_in);
}
#else
pAddr = (struct sockaddr_in*)byteAddress;
addrlst->addrs[idx].type = CM_INET_IPV4ADDR_TYPE;
- addrlst->addrs[idx].u.ipv4NetAddr = CM_INET_NTOH_U32(pAddr->sin_addr.s_addr);
+ addrlst->addrs[idx].u.ipv4NetAddr = CM_INET_NTOH_UINT32(pAddr->sin_addr.s_addr);
byteAddress += sizeof(struct sockaddr_in);
#endif /* IPV6_SUPPORTED */
}
/* cm_inet_c_001.main_58 : Fix for klockwork issue */
- addrlst->count = (U8)cnt;
+ addrlst->count = (uint8_t)cnt;
sctp_freepaddrs(peerAddrList);
S16 cmInetGetOpt
(
CmInetFd *sockFd, /* socket file descriptor */
-U32 level, /* option level */
-U32 type, /* option type */
+uint32_t level, /* option level */
+uint32_t type, /* option type */
Ptr value /* option value */
)
#else
S16 cmInetGetOpt(sockFd, level, type, value)
CmInetFd *sockFd; /* socket file descriptor */
-U32 level; /* option level */
-U32 type; /* option type */
+uint32_t level; /* option level */
+uint32_t type; /* option type */
Ptr value; /* option value */
#endif
{
if (status.sstat_primary.spinfo_address.ss_family == AF_INET6)
{
pAddr6 = (struct sockaddr_in6*)&(status.sstat_primary.spinfo_address);
- pSctpStatus->primary.port = CM_INET_NTOH_U16(pAddr6->sin6_port);
+ pSctpStatus->primary.port = CM_INET_NTOH_UINT16(pAddr6->sin6_port);
pSctpStatus->primary.addr.type = CM_INET_IPV6ADDR_TYPE;
CM_INET_COPY_IPV6ADDR(&pSctpStatus->primary.addr.u.ipv6NetAddr,
else
{
pAddr = (struct sockaddr_in*)&(status.sstat_primary.spinfo_address);
- pSctpStatus->primary.port = CM_INET_NTOH_U16(pAddr->sin_port);
+ pSctpStatus->primary.port = CM_INET_NTOH_UINT16(pAddr->sin_port);
pSctpStatus->primary.addr.type = CM_INET_IPV4ADDR_TYPE;
- pSctpStatus->primary.addr.u.ipv4NetAddr = CM_INET_NTOH_U32(pAddr->sin_addr.s_addr);
+ pSctpStatus->primary.addr.u.ipv4NetAddr = CM_INET_NTOH_UINT32(pAddr->sin_addr.s_addr);
}
#else
pAddr = (struct sockaddr_in*)&(status.sstat_primary.spinfo_address);
- pSctpStatus->primary.port = CM_INET_NTOH_U16(pAddr->sin_port);
+ pSctpStatus->primary.port = CM_INET_NTOH_UINT16(pAddr->sin_port);
pSctpStatus->primary.addr.type = CM_INET_IPV4ADDR_TYPE;
- pSctpStatus->primary.addr.u.ipv4NetAddr = CM_INET_NTOH_U32(pAddr->sin_addr.s_addr);
+ pSctpStatus->primary.addr.u.ipv4NetAddr = CM_INET_NTOH_UINT32(pAddr->sin_addr.s_addr);
#endif /* IPV6_SUPPORTED */
pSctpStatus->primary.assocId = status.sstat_primary.spinfo_assoc_id;
pAddr6 = (struct sockaddr_in6*)&(addrInfo.spinfo_address);
pAddr6->sin6_family = AF_INET6;
- pAddr6->sin6_port = CM_INET_HTON_U16(pPeerAddrInfo->port);
+ pAddr6->sin6_port = CM_INET_HTON_UINT16(pPeerAddrInfo->port);
CM_INET_COPY_IPV6ADDR(&pAddr6->sin6_addr.s6_addr, &pPeerAddrInfo->addr.u.ipv6NetAddr);
}
else
{
pAddr = (struct sockaddr_in*)&(addrInfo.spinfo_address);
pAddr->sin_family = AF_INET;
- pAddr->sin_port = CM_INET_HTON_U16(pPeerAddrInfo->port);
- pAddr->sin_addr.s_addr = CM_INET_HTON_U32(pPeerAddrInfo->addr.u.ipv4NetAddr);
+ pAddr->sin_port = CM_INET_HTON_UINT16(pPeerAddrInfo->port);
+ pAddr->sin_addr.s_addr = CM_INET_HTON_UINT32(pPeerAddrInfo->addr.u.ipv4NetAddr);
}
#else
pAddr = (struct sockaddr_in*)&(addrInfo.spinfo_address);
pAddr->sin_family = AF_INET;
- pAddr->sin_port = CM_INET_HTON_U16(pPeerAddrInfo->port);
- pAddr->sin_addr.s_addr = CM_INET_HTON_U32(pPeerAddrInfo->addr.u.ipv4NetAddr);
+ pAddr->sin_port = CM_INET_HTON_UINT16(pPeerAddrInfo->port);
+ pAddr->sin_addr.s_addr = CM_INET_HTON_UINT32(pPeerAddrInfo->addr.u.ipv4NetAddr);
#endif /* IPV6_SUPPORTED */
/* Not validating the address, whether Addr is a valid address or not */
pAddr6 = (struct sockaddr_in6*)&(addrParams.spp_address);
pAddr6->sin6_family = AF_INET6;
- pAddr6->sin6_port = CM_INET_HTON_U16(pPeerAddrParams->s.port);
+ pAddr6->sin6_port = CM_INET_HTON_UINT16(pPeerAddrParams->s.port);
CM_INET_COPY_IPV6ADDR(&pAddr6->sin6_addr.s6_addr, &pPeerAddrParams->s.addr.u.ipv6NetAddr);
}
else
{
pAddr = (struct sockaddr_in*)&(addrParams.spp_address);
pAddr->sin_family = AF_INET;
- pAddr->sin_port = CM_INET_HTON_U16(pPeerAddrParams->s.port);
- pAddr->sin_addr.s_addr = CM_INET_HTON_U32(pPeerAddrParams->s.addr.u.ipv4NetAddr);
+ pAddr->sin_port = CM_INET_HTON_UINT16(pPeerAddrParams->s.port);
+ pAddr->sin_addr.s_addr = CM_INET_HTON_UINT32(pPeerAddrParams->s.addr.u.ipv4NetAddr);
}
#else
pAddr = (struct sockaddr_in*)&(addrParams.spp_address);
pAddr->sin_family = AF_INET;
- pAddr->sin_port = CM_INET_HTON_U16(pPeerAddrParams->s.port);
- pAddr->sin_addr.s_addr = CM_INET_HTON_U32(pPeerAddrParams->s.addr.u.ipv4NetAddr);
+ pAddr->sin_port = CM_INET_HTON_UINT16(pPeerAddrParams->s.port);
+ pAddr->sin_addr.s_addr = CM_INET_HTON_UINT32(pPeerAddrParams->s.addr.u.ipv4NetAddr);
#endif /* IPV6_SUPPORTED */
}
else
#ifdef IPV6_SUPPORTED
struct sockaddr_in6 dstAddr6; /* foreign Internet IPV6 address/port */
#ifdef CMINETDBG
- U16 port;
+ uint16_t port;
#endif /* CMINETDBG */
#endif /* IPV6_SUPPORTED */
S32 sizeOfAddr;
{
memset(&dstAddr6, 0, sizeof(dstAddr6));
dstAddr6.sin6_family = AF_INET6;
- dstAddr6.sin6_port = CM_INET_HTON_U16(servAddr->u.ipv6Addr.port);
+ dstAddr6.sin6_port = CM_INET_HTON_UINT16(servAddr->u.ipv6Addr.port);
CM_INET_COPY_IPV6ADDR(&dstAddr6.sin6_addr,
&servAddr->u.ipv6Addr.ipv6NetAddr);
sizeOfAddr = sizeof(struct sockaddr_in6);
{
memset(&dstAddr, 0, sizeof(dstAddr));
dstAddr.sin_family = AF_INET;
- dstAddr.sin_port = CM_INET_HTON_U16(servAddr->u.ipv4Addr.port);
- dstAddr.sin_addr.s_addr = CM_INET_HTON_U32(servAddr->u.ipv4Addr.address);
+ dstAddr.sin_port = CM_INET_HTON_UINT16(servAddr->u.ipv4Addr.port);
+ dstAddr.sin_addr.s_addr = CM_INET_HTON_UINT32(servAddr->u.ipv4Addr.address);
sizeOfAddr = sizeof(struct sockaddr_in);
sockAddrPtr = (CmInetSockAddr *)&dstAddr;
}
#else
memset(&dstAddr, 0, sizeof(dstAddr));
dstAddr.sin_family = AF_INET;
- dstAddr.sin_port = CM_INET_HTON_U16(servAddr->port);
- dstAddr.sin_addr.s_addr = CM_INET_HTON_U32(servAddr->address);
+ dstAddr.sin_port = CM_INET_HTON_UINT16(servAddr->port);
+ dstAddr.sin_addr.s_addr = CM_INET_HTON_UINT32(servAddr->address);
sizeOfAddr = sizeof(struct sockaddr_in);
sockAddrPtr = (CmInetSockAddr *)&dstAddr;
#endif /* IPV6_SUPPORTED */
CmInetSockAddr sockAddr;
#endif /* IPV6_SUPPORTED */
- U32 optVal;
+ uint32_t optVal;
/* added */
{
peerAddr = (struct sockaddr_in *)&sockAddr;
fromAddr->type = CM_INET_IPV4ADDR_TYPE;
- fromAddr->u.ipv4Addr.port = CM_INET_NTOH_U16(peerAddr->sin_port);
+ fromAddr->u.ipv4Addr.port = CM_INET_NTOH_UINT16(peerAddr->sin_port);
fromAddr->u.ipv4Addr.address =
- CM_INET_NTOH_U32(peerAddr->sin_addr.s_addr);
+ CM_INET_NTOH_UINT32(peerAddr->sin_addr.s_addr);
}
else if (addrLen == sizeof(struct sockaddr_in6))
{
peerAddr6 = (struct sockaddr_in6 *)&sockAddr;
fromAddr->type = CM_INET_IPV6ADDR_TYPE;
- fromAddr->u.ipv6Addr.port = CM_INET_NTOH_U16(peerAddr6->sin6_port);
+ fromAddr->u.ipv6Addr.port = CM_INET_NTOH_UINT16(peerAddr6->sin6_port);
CM_INET_COPY_IPV6ADDR(&fromAddr->u.ipv6Addr.ipv6NetAddr,
&peerAddr6->sin6_addr);
}
#else
peerAddr = (struct sockaddr_in *)&sockAddr;
- fromAddr->port = CM_INET_NTOH_U16(peerAddr->sin_port);
- fromAddr->address = CM_INET_NTOH_U32(peerAddr->sin_addr.s_addr);
+ fromAddr->port = CM_INET_NTOH_UINT16(peerAddr->sin_port);
+ fromAddr->address = CM_INET_NTOH_UINT32(peerAddr->sin_addr.s_addr);
#endif /* IPV6_SUPPORTED */
return ROK;
} /* end of cmInetAccept */
#ifdef ANSI
PRIVATE S16 cmInet4FillTos
(
-U8 tos, /* tos value to be filled in ipheader */
-U8 *cmsgBuf, /* flat buffer where to build ext hdrs */
-U32 *curMsgIdx /* idx in cmsgBuf where HBH/Dest ext hdr ends */
+uint8_t tos, /* tos value to be filled in ipheader */
+uint8_t *cmsgBuf, /* flat buffer where to build ext hdrs */
+uint32_t *curMsgIdx /* idx in cmsgBuf where HBH/Dest ext hdr ends */
)
#else
PRIVATE S16 cmInet4FillTos(tos, cmsgBuf, curMsgIdx, protType)
-U8 tos; /* tos value to be filled in ipheader */
-U8 *cmsgBuf; /* flat buffer where to build ext hdrs */
-U32 *curMsgIdx; /* idx in cmsgBuf where HBH/Dest ext hdr ends */
+uint8_t tos; /* tos value to be filled in ipheader */
+uint8_t *cmsgBuf; /* flat buffer where to build ext hdrs */
+uint32_t *curMsgIdx; /* idx in cmsgBuf where HBH/Dest ext hdr ends */
#endif /* ANSI */
{
struct cmsghdr *tempHdr;
- U8 len;
+ uint8_t len;
len = 0;
/* fill up level & type of cmsghdr structure */
tempHdr->cmsg_level = IPPROTO_IPV6;
tempHdr->cmsg_type = IP_TOS;
- (*(U8*)CMSG_DATA(tempHdr)) = tos;
+ (*(uint8_t*)CMSG_DATA(tempHdr)) = tos;
len = CMSG_SPACE(sizeof tos);
S16 numDBufs; /* number of dBufs in message */
struct msghdr msg; /* sendmsg() message header */
MsgLen msgLen; /* message length */
- U32 strtEndDBufNum; /* starting/ending DBuf number */
+ uint32_t strtEndDBufNum; /* starting/ending DBuf number */
MsgLen unSentLen; /* sent len */
#ifdef IPV6_SUPPORTED
- U32 curMsgIdx; /* indx in cmsgData where to write an ext hdr */
+ uint32_t curMsgIdx; /* indx in cmsgData where to write an ext hdr */
/* added for IPv6 ext hdr */
#if (defined(SS_LINUX) || defined(_XPG4_2))
/* alloc from stack for IPv6 ancill data */
- U8 cmsgData[CM_INET_IPV6_ANCIL_DATA];
+ uint8_t cmsgData[CM_INET_IPV6_ANCIL_DATA];
#endif /* SS_LINUX || _XPG4_2 */
#else
- U32 curMsgIdx; /* indx in cmsgData where to write an ext hdr */
+ uint32_t curMsgIdx; /* indx in cmsgData where to write an ext hdr */
#if (defined(SS_LINUX) || defined(_XPG4_2))
/* alloc from stack for IPv4 ancill data */
- U8 cmsgData[CM_INET_IPV4_ANCIL_DATA];
+ uint8_t cmsgData[CM_INET_IPV4_ANCIL_DATA];
#endif /* SS_LINUX || _XPG4_2 */
#endif /* IPV6_SUPPORTED */
#endif /* WIN32 | CMINETFLATBUF */
#endif /* IPV8_SUPPORTED */
CmInetSockAddr *sockAddrPtr;
/* cm_inet_c_001.main_58 : Fix for klockwork issue */
- U32 sizeOfAddr;
+ uint32_t sizeOfAddr;
/* cm_inet_c_001.main_50 - Added for partial send handling */
/* cm_inet_c_001.main_59: Protected under if not defined WIN32*/
{
memset(&remAddr6, 0, sizeof(remAddr6));
remAddr6.sin6_family = AF_INET6;
- remAddr6.sin6_port = CM_INET_HTON_U16(dstAddr->u.ipv6Addr.port);
+ remAddr6.sin6_port = CM_INET_HTON_UINT16(dstAddr->u.ipv6Addr.port);
CM_INET_COPY_IPV6ADDR(&remAddr6.sin6_addr,
&dstAddr->u.ipv6Addr.ipv6NetAddr);
sizeOfAddr = sizeof(remAddr6);
{
memset(&remAddr, 0, sizeof(remAddr));
remAddr.sin_family = AF_INET;
- remAddr.sin_port = CM_INET_HTON_U16(dstAddr->u.ipv4Addr.port);
+ remAddr.sin_port = CM_INET_HTON_UINT16(dstAddr->u.ipv4Addr.port);
remAddr.sin_addr.s_addr =
- CM_INET_HTON_U32(dstAddr->u.ipv4Addr.address);
+ CM_INET_HTON_UINT32(dstAddr->u.ipv4Addr.address);
sizeOfAddr = sizeof(remAddr);
sockAddrPtr = (CmInetSockAddr *)&remAddr;
}
#else
/* memset(&remAddr, 0, sizeof(remAddr)); */
remAddr.sin_family = AF_INET;
- remAddr.sin_port = CM_INET_HTON_U16(dstAddr->port);
- remAddr.sin_addr.s_addr = CM_INET_HTON_U32(dstAddr->address);
+ remAddr.sin_port = CM_INET_HTON_UINT16(dstAddr->port);
+ remAddr.sin_addr.s_addr = CM_INET_HTON_UINT32(dstAddr->address);
sizeOfAddr = sizeof(remAddr);
sockAddrPtr = (CmInetSockAddr *)&remAddr;
#endif /* IPV6_SUPPORTED */
}
/* max message length is limited to control the memory usage */
/* casting bufLen to avoid warnings */
- if ((bufLen > 0) && ((U32)bufLen > CM_INET_MAX_MSG_LEN))
+ if ((bufLen > 0) && ((uint32_t)bufLen > CM_INET_MAX_MSG_LEN))
{
return RFAILED;
}
(ipHdrParams->u.hdrParmIpv4.tos.val != 0))
{
cmInet4FillTos(ipHdrParams->u.hdrParmIpv4.tos.val,
- (U8 *)(cmsgData + curMsgIdx), &curMsgIdx);
+ (uint8_t *)(cmsgData + curMsgIdx), &curMsgIdx);
msg.msg_control = cmsgData; /* pointer to Ancillary Data */
msg.msg_controllen = curMsgIdx; /* total length of ancillary Data */
}
#ifdef SS_LINUX
if(ipHdrParams->u.ipv6HdrParm.ttl.pres == TRUE)
{
- cmInetBuildSendHoplimit((U32)ipHdrParams->u.ipv6HdrParm.ttl.val,
- (U8 *)(cmsgData + curMsgIdx), &curMsgIdx);
+ cmInetBuildSendHoplimit((uint32_t)ipHdrParams->u.ipv6HdrParm.ttl.val,
+ (uint8_t *)(cmsgData + curMsgIdx), &curMsgIdx);
}
#endif /* SS_LINUX */
{
cmInet6BuildSendPktinfo(
&ipHdrParams->u.ipv6HdrParm.srcAddr6.u.ipv6NetAddr,
- (U8 *)(cmsgData + curMsgIdx), &curMsgIdx,
+ (uint8_t *)(cmsgData + curMsgIdx), &curMsgIdx,
sockFd->protType);
}
#endif /* LOCAL_INTF */
/* build HBH ext header in cmsgData starting at indx 0 */
cmInet6BuildSendHBHOpts(
&ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.hbhOptsArr,
- (U8 *)(cmsgData + curMsgIdx), &curMsgIdx, 0);
+ (uint8_t *)(cmsgData + curMsgIdx), &curMsgIdx, 0);
/* now copy the elements from the Destination Option array one by
* one to the Flat Buffer cmsgData. Start filling at indx curMsgIdx
/* build Dest opt hdr starting at (cmsgData + curMsgIdx) */
cmInet6BuildSendDestOpts(
&(ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.destOptsArr),
- (U8 *)(cmsgData + curMsgIdx), &curMsgIdx, 1);
+ (uint8_t *)(cmsgData + curMsgIdx), &curMsgIdx, 1);
/* copy Route header to to the Flat Buffer cmsgData */
if (ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.rtOptsPrsnt == TRUE)
/* curMsgIdx will be the indx where Dest opt ends in cmsgData */
cmInet6BuildSendRouteOpts(
&ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.rtOptsArr,
- (U8 *)(cmsgData + curMsgIdx), &curMsgIdx);
+ (uint8_t *)(cmsgData + curMsgIdx), &curMsgIdx);
/* msghrd struc's msg_control will point cmsgData and msg_controllen
* will be the curMsgIdx */
S16 numDBufs; /* number of dBufs in message */
struct msghdr msg; /* sendmsg() message header */
MsgLen msgLen; /* message length */
- U32 strtEndDBufNum; /* starting/ending DBuf number */
+ uint32_t strtEndDBufNum; /* starting/ending DBuf number */
MsgLen unSentLen; /* sent len */
#ifdef IPV6_SUPPORTED
/* added for IPv6 ext hdr */
#ifdef IPV6_OPTS_SUPPORTED
- U32 curMsgIdx; /* indx in cmsgData where to write an ext hdr */
+ uint32_t curMsgIdx; /* indx in cmsgData where to write an ext hdr */
#if (defined(SS_LINUX) || defined(_XPG4_2))
/* alloc from stack for IPv6 ancill data */
- U8 cmsgData[CM_INET_IPV6_ANCIL_DATA];
+ uint8_t cmsgData[CM_INET_IPV6_ANCIL_DATA];
#endif /* SS_LINUX || _XPG4_2 */
#endif /* IPV6_OPTS_SUPPORTED */
#else
#if (defined(SS_LINUX) || defined(_XPG4_2))
/* alloc from stack for IPv4 ancill data */
- /* U8 cmsgData[CM_INET_IPV4_ANCIL_DATA];*/
+ /* uint8_t cmsgData[CM_INET_IPV4_ANCIL_DATA];*/
#endif /* SS_LINUX || _XPG4_2 */
#endif /* IPV6_SUPPORTED */
#endif /* WIN32 | CMINETFLATBUF */
#endif /* IPV8_SUPPORTED */
CmInetSockAddr *sockAddrPtr;
/* cm_inet_c_001.main_58 : Fix for klockwork issue */
- U32 sizeOfAddr;
+ uint32_t sizeOfAddr;
/* cm_inet_c_001.main_50 - Added for partial send handling */
/* cm_inet_c_001.main_59: Protected under if not defined WIN32*/
{
memset(&remAddr6, 0, sizeof(remAddr6));
remAddr6.sin6_family = AF_INET6;
- remAddr6.sin6_port = CM_INET_HTON_U16(dstAddr->u.ipv6Addr.port);
+ remAddr6.sin6_port = CM_INET_HTON_UINT16(dstAddr->u.ipv6Addr.port);
CM_INET_COPY_IPV6ADDR(&remAddr6.sin6_addr,
&dstAddr->u.ipv6Addr.ipv6NetAddr);
sizeOfAddr = sizeof(remAddr6);
{
memset(&remAddr, 0, sizeof(remAddr));
remAddr.sin_family = AF_INET;
- remAddr.sin_port = CM_INET_HTON_U16(dstAddr->u.ipv4Addr.port);
+ remAddr.sin_port = CM_INET_HTON_UINT16(dstAddr->u.ipv4Addr.port);
remAddr.sin_addr.s_addr =
- CM_INET_HTON_U32(dstAddr->u.ipv4Addr.address);
+ CM_INET_HTON_UINT32(dstAddr->u.ipv4Addr.address);
sizeOfAddr = sizeof(remAddr);
sockAddrPtr = (CmInetSockAddr *)&remAddr;
}
#else
/* memset(&remAddr, 0, sizeof(remAddr)); */
remAddr.sin_family = AF_INET;
- remAddr.sin_port = CM_INET_HTON_U16(dstAddr->port);
- remAddr.sin_addr.s_addr = CM_INET_HTON_U32(dstAddr->address);
+ remAddr.sin_port = CM_INET_HTON_UINT16(dstAddr->port);
+ remAddr.sin_addr.s_addr = CM_INET_HTON_UINT32(dstAddr->address);
sizeOfAddr = sizeof(remAddr);
sockAddrPtr = (CmInetSockAddr *)&remAddr;
#endif /* IPV6_SUPPORTED */
}
/* max message length is limited to control the memory usage */
/* casting bufLen to avoid warnings */
- if ((bufLen > 0) && ((U32)bufLen > CM_INET_MAX_MSG_LEN))
+ if ((bufLen > 0) && ((uint32_t)bufLen > CM_INET_MAX_MSG_LEN))
{
return RFAILED;
}
#ifdef SS_LINUX
if(ipHdrParams->u.ipv6HdrParm.ttl.pres == TRUE)
{
- cmInetBuildSendHoplimit((U32)ipHdrParams->u.ipv6HdrParm.ttl.val,
- (U8 *)(cmsgData + curMsgIdx), &curMsgIdx);
+ cmInetBuildSendHoplimit((uint32_t)ipHdrParams->u.ipv6HdrParm.ttl.val,
+ (uint8_t *)(cmsgData + curMsgIdx), &curMsgIdx);
}
#endif /* SS_LINUX */
{
cmInet6BuildSendPktinfo(
&ipHdrParams->u.ipv6HdrParm.srcAddr6.u.ipv6NetAddr,
- (U8 *)(cmsgData + curMsgIdx), &curMsgIdx,
+ (uint8_t *)(cmsgData + curMsgIdx), &curMsgIdx,
sockFd->protType);
}
#endif /* LOCAL_INTF */
/* build HBH ext header in cmsgData starting at indx 0 */
cmInet6BuildSendHBHOpts(
&ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.hbhOptsArr,
- (U8 *)(cmsgData + curMsgIdx), &curMsgIdx, 0);
+ (uint8_t *)(cmsgData + curMsgIdx), &curMsgIdx, 0);
/* now copy the elements from the Destination Option array one by
* one to the Flat Buffer cmsgData. Start filling at indx curMsgIdx
/* build Dest opt hdr starting at (cmsgData + curMsgIdx) */
cmInet6BuildSendDestOpts(
&(ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.destOptsArr),
- (U8 *)(cmsgData + curMsgIdx), &curMsgIdx, 1);
+ (uint8_t *)(cmsgData + curMsgIdx), &curMsgIdx, 1);
/* copy Route header to to the Flat Buffer cmsgData */
if (ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.rtOptsPrsnt == TRUE)
/* curMsgIdx will be the indx where Dest opt ends in cmsgData */
cmInet6BuildSendRouteOpts(
&ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.rtOptsArr,
- (U8 *)(cmsgData + curMsgIdx), &curMsgIdx);
+ (uint8_t *)(cmsgData + curMsgIdx), &curMsgIdx);
/* msghrd struc's msg_control will point cmsgData and msg_controllen
* will be the curMsgIdx */
PRIVATE S16 cmInet6BuildSendPktinfo
(
CmInetIpAddr6 *srcAddr, /* src ip addr to set on outgoing packet */
-U8 *cmsgBuf, /* flat buffer where to build ext hdrs */
-U32 *curMsgIdx, /* idx in cmsgBuf where HBH/Dest ext hdr ends */
-U8 protType /* whether IPv4/IPv6 socket */
+uint8_t *cmsgBuf, /* flat buffer where to build ext hdrs */
+uint32_t *curMsgIdx, /* idx in cmsgBuf where HBH/Dest ext hdr ends */
+uint8_t protType /* whether IPv4/IPv6 socket */
)
#else
PRIVATE S16 cmInet6BuildSendPktinfo(srcAddr, cmsgBuf, curMsgIdx, protType)
CmInetIpAddr6 *srcAddr; /* src ip addr to set on outgoing packet */
-U8 *cmsgBuf; /* flat buffer where to build ext hdrs */
-U32 *curMsgIdx; /* idx in cmsgBuf where HBH/Dest ext hdr ends */
-U8 protType; /* whether IPv4/IPv6 socket */
+uint8_t *cmsgBuf; /* flat buffer where to build ext hdrs */
+uint32_t *curMsgIdx; /* idx in cmsgBuf where HBH/Dest ext hdr ends */
+uint8_t protType; /* whether IPv4/IPv6 socket */
#endif /* ANSI */
{
struct cmsghdr *tempHdr;
struct in6_pktinfo *ipv6Pktinfo;
struct in6_addr lpBkAddr;
- U8 len;
+ uint8_t len;
len = 0;
#ifdef ANSI
PRIVATE S16 cmInetBuildSendHoplimit
(
-U32 hoplimit, /* the hoplimit value to be set on outgoing packet */
-U8 *cmsgBuf, /* flat buffer where to build ext hdrs */
-U32 *curMsgIdx /* idx in cmsgBuf where HBH/Dest ext hdr ends */
+uint32_t hoplimit, /* the hoplimit value to be set on outgoing packet */
+uint8_t *cmsgBuf, /* flat buffer where to build ext hdrs */
+uint32_t *curMsgIdx /* idx in cmsgBuf where HBH/Dest ext hdr ends */
)
#else
PRIVATE S16 cmInetBuildSendHoplimit(hoplimit, cmsgBuf, curMsgIdx)
-U32 hoplimit; /* the hoplimit value to be sent on outgoing packet */
-U8 *cmsgBuf; /* flat buffer where to build ext hdrs */
-U32 *curMsgIdx; /* idx in cmsgBuf where HBH/Dest ext hdr ends */
+uint32_t hoplimit; /* the hoplimit value to be sent on outgoing packet */
+uint8_t *cmsgBuf; /* flat buffer where to build ext hdrs */
+uint32_t *curMsgIdx; /* idx in cmsgBuf where HBH/Dest ext hdr ends */
#endif /* ANSI */
{
struct cmsghdr *tempHdr;
- U8 len;
+ uint8_t len;
len = 0;
PRIVATE S16 cmInet6BuildSendHBHOpts
(
CmInetIpv6HBHHdrArr *hbhOptsArr,/* IPv6 extensions headers HBH/Dest opts */
-U8 *cmsgBuf, /* flat buffer where to build ext hdrs */
-U32 *curMsgIdx, /* idx in cmsgBuf where HBH/Dest ext hdr ends */
-U8 hdrId /* 0: HBH hdr, 1:Dest Hdr */
+uint8_t *cmsgBuf, /* flat buffer where to build ext hdrs */
+uint32_t *curMsgIdx, /* idx in cmsgBuf where HBH/Dest ext hdr ends */
+uint8_t hdrId /* 0: HBH hdr, 1:Dest Hdr */
)
#else
PRIVATE S16 cmInet6BuildSendHBHOpts(hbhOptsArr, cmsgBuf, curMsgIdx, hdrId)
CmInetIpv6HBHHdrArr *hbhOptsArr;/* IPv6 extensions headers HBH/Dest opts */
-U8 *cmsgBuf; /* flat buffer where to build ext hdrs */
-U32 *curMsgIdx; /* idx in cmsgBuf where HBH/Dest ext hdr ends */
-U8 hdrId; /* 0: HBH hdr, 1:Dest Hdr */
+uint8_t *cmsgBuf; /* flat buffer where to build ext hdrs */
+uint32_t *curMsgIdx; /* idx in cmsgBuf where HBH/Dest ext hdr ends */
+uint8_t hdrId; /* 0: HBH hdr, 1:Dest Hdr */
#endif
{
struct cmsghdr *tempHdr;
- U8 len;
- U8 optsIdx;
+ uint8_t len;
+ uint8_t optsIdx;
len = 0;
PRIVATE S16 cmInet6BuildSendRouteOpts
(
CmInetIpv6RtHdr *rtOptsArr, /* IPv6 destination options array */
-U8 *cmsgBuf, /* flat buffer where to build ext hdrs */
-U32 *curMsgIdx /* idx in cmsgBuf where to start building RT hdr */
+uint8_t *cmsgBuf, /* flat buffer where to build ext hdrs */
+uint32_t *curMsgIdx /* idx in cmsgBuf where to start building RT hdr */
)
#else
PRIVATE S16 cmInet6BuildSendRouteOpts(rtOptsArr, cmsgBuf, curMsgIdx)
CmInetIpv6RtHdr *rtOptsArr; /* IPv6 destination options array */
-U8 *cmsgBuf; /* flat buffer where to build ext hdrs */
-U32 *curMsgIdx; /* idx in cmsgBuf where to start building RT hd */
+uint8_t *cmsgBuf; /* flat buffer where to build ext hdrs */
+uint32_t *curMsgIdx; /* idx in cmsgBuf where to start building RT hd */
#endif /* ANSI */
{
struct cmsghdr *tempHdr;
CmInetIpv6RtHdr0 *tempRtHdr;
- U8 len;
- U8 addrIdx;
+ uint8_t len;
+ uint8_t addrIdx;
len = 0;
#ifdef ANSI
PRIVATE S16 cmInet6BuildRecvHopOptsArr
(
-U8 *cmsgData, /* flat buffer where to build ext hdrs */
-U32 hbhDataLen, /* byte len of cmsghdr + hbh ancil data */
+uint8_t *cmsgData, /* flat buffer where to build ext hdrs */
+uint32_t hbhDataLen, /* byte len of cmsghdr + hbh ancil data */
CmInetIpv6HBHHdrArr *hbhOptsArr, /* IPv6 extensions headers */
-U8 hdrId, /* 0: HBH, 1: DEST */
+uint8_t hdrId, /* 0: HBH, 1: DEST */
CmInetMemInfo *info /* Memory information */
)
#else
PRIVATE S16 cmInet6BuildRecvHopOptsArr(cmsgData, hbhDataLen, hbhOptsArr, hdrId,
info)
-U8 *cmsgData; /* flat buffer where to build ext hdrs */
-U32 hbhDataLen; /* byte len of cmsghdr + hbh ancil data */
+uint8_t *cmsgData; /* flat buffer where to build ext hdrs */
+uint32_t hbhDataLen; /* byte len of cmsghdr + hbh ancil data */
CmInetIpv6HBHHdrArr *hbhOptsArr; /* IPv6 extensions headers */
-U8 hdrId; /* 0: HBH, 1: DEST */
+uint8_t hdrId; /* 0: HBH, 1: DEST */
CmInetMemInfo *info; /* Memory information */
#endif /* ANSI */
{
- U32 curDataIdx; /* to keep track where we are in the hbh Data */
- U8 optsIdx; /* how many hbh opts present in data */
- U8 numOpts; /* number of hbh opts present in data */
- U8 tempLen;
- U8 tempType;
+ uint32_t curDataIdx; /* to keep track where we are in the hbh Data */
+ uint8_t optsIdx; /* how many hbh opts present in data */
+ uint8_t numOpts; /* number of hbh opts present in data */
+ uint8_t tempLen;
+ uint8_t tempType;
S16 ret;
numOpts += 1;
/* get type */
- tempType = *(U8 *)(cmsgData + curDataIdx);
+ tempType = *(uint8_t *)(cmsgData + curDataIdx);
curDataIdx += 1;
/* take care of pad1 option */
}
/* get length */
- tempLen = *(U8 *)(cmsgData + curDataIdx);
+ tempLen = *(uint8_t *)(cmsgData + curDataIdx);
/* 1 is to skip length. tempLen to skip the value field */
curDataIdx += (1 + tempLen);
#ifdef ANSI
PRIVATE S16 cmInet6BuildRecvRtHdr
(
-U8 *cmsgData, /* flat buffer where to build Route hdr */
-U32 rtDataLen, /* byte len of cmsghdr struc+rtHdr ancil data */
+uint8_t *cmsgData, /* flat buffer where to build Route hdr */
+uint32_t rtDataLen, /* byte len of cmsghdr struc+rtHdr ancil data */
CmInetIpv6RtHdr0 *rtHdr0, /* rtHeader0 struct that precedes IPV6 addrss */
CmInetIpv6RtHdr *rtOptsArr,/* IPv6 extensions headers */
CmInetMemInfo *info /* Memory information */
)
#else
PRIVATE S16 cmInet6BuildRecvRtHdr(cmsgData, rtDataLen, rtHdr0, rtOptsArr, info)
-U8 *cmsgData; /* flat buffer where to build Route hdr */
-U32 rtDataLen; /* byte len of cmsghdr struc+rtHdr ancil data */
+uint8_t *cmsgData; /* flat buffer where to build Route hdr */
+uint32_t rtDataLen; /* byte len of cmsghdr struc+rtHdr ancil data */
CmInetIpv6RtHdr0 *rtHdr0; /* rtHeader0 struct that precedes IPV6 addrss */
CmInetIpv6RtHdr *rtOptsArr;/* IPv6 extensions headers */
CmInetMemInfo *info; /* Memory information */
#endif /* ANSI */
{
- U32 curDataIdx; /* to keep track where we are in hbh Data */
- U8 i; /* loop counter */
+ uint32_t curDataIdx; /* to keep track where we are in hbh Data */
+ uint8_t i; /* loop counter */
S16 ret; /* temporary return value */
#ifdef ANSI
PRIVATE S16 cmInet6GetHopLimitValue
(
-U8 *cmsgData, /* flat buffer where to build ext hdrs */
-U32 hopLimitDataLen, /* byte len of cmsghdr + hbh ancil data */
+uint8_t *cmsgData, /* flat buffer where to build ext hdrs */
+uint32_t hopLimitDataLen, /* byte len of cmsghdr + hbh ancil data */
CmInetIpv6HdrParm *ipv6HdrParam /* ipv6 header parameters */
)
#else
PRIVATE S16 cmInet6GetHopLimitValue(cmsgData, hopLimitDataLen, ipv6HdrParam)
-U8 *cmsgData; /* flat buffer where to build ext hdrs */
-U32 hopLimitDataLen; /* byte len of cmsghdr + hbh ancil data */
+uint8_t *cmsgData; /* flat buffer where to build ext hdrs */
+uint32_t hopLimitDataLen; /* byte len of cmsghdr + hbh ancil data */
CmInetIpv6HdrParm *ipv6HdrParam; /* ipv6 header parameters */
#endif /* ANSI */
{
- U16 curDataIdx; /* to keep track where we are in the ancillary Data */
- U32 *hopLimitValue; /* ttl/hoplimit value */
+ uint16_t curDataIdx; /* to keep track where we are in the ancillary Data */
+ uint32_t *hopLimitValue; /* ttl/hoplimit value */
hopLimitValue = NULL;
curDataIdx = 0;
ipv6HdrParam->ttl.pres = TRUE;
/* the first byte will be the HopLimit value */
- hopLimitValue = (U32 *)(cmsgData);
- ipv6HdrParam->ttl.val = (U8)(*hopLimitValue);
+ hopLimitValue = (uint32_t *)(cmsgData);
+ ipv6HdrParam->ttl.val = (uint8_t)(*hopLimitValue);
return ROK;
}
{
#if (defined(WIN32) || defined(CMINETFLATBUF))
S32 ret; /* temporary return value */
- U32 pendLen; /* pending data length */
+ uint32_t pendLen; /* pending data length */
S32 recvLen; /* number of received octets by recvmsg() */
MsgLen bufLen; /* entire number of received octets */
MsgLen curLen; /* current number of octets in buffer */
Data *recvBuf; /* receive buffer */
Data *bufPtr; /* current buffer position */
Buffer *mBuf; /* received message */
- U32 remAddrLen; /* length of remote address */
+ uint32_t remAddrLen; /* length of remote address */
struct sockaddr_in *remAddr; /* remote Internet address */
#ifdef IPV6_SUPPORTED
struct sockaddr_in6 *remAddr6; /* remote Internet address */
#else
S32 ret; /* temporary return value */
/* cm_inet_c_001.main_58: Fix for g++ compilation warning */
- U16 i; /* index */
- U32 pendLen; /* pending data length */
+ uint16_t i; /* index */
+ uint32_t pendLen; /* pending data length */
S32 numBuf; /* number of allocated dBufs */
S32 recvLen; /* number of received octets by recvmsg() */
MsgLen bufLen; /* entire number of received octets */
#endif /* LOCAL_INTF */
#if (defined(SS_LINUX) || defined(_XPG4_2))
- U8 ancillData[CM_INET_IPV6_ANCIL_DATA];
+ uint8_t ancillData[CM_INET_IPV6_ANCIL_DATA];
/* from stack for IPv6 ancill data */
#endif
#else
CmInetSockAddr remSockAddr; /* to get packet's src IP address */
#if (defined(SS_LINUX) || defined(_XPG4_2))
- U8 ancillData[CM_INET_IPV4_ANCIL_DATA];
+ uint8_t ancillData[CM_INET_IPV4_ANCIL_DATA];
/* from stack for IPv4 ancill data */
#endif
#endif /* IPV6_SUPPORTED */
/* cm_inet_c_001.main_50:
* cm_inet_c_001.main_56: Removed comment for cm_inet_c_001.main_50 as
* the current patch changes its functionality */
- U8 readBuf[1]; /* declaration of variable for Peek */
+ uint8_t readBuf[1]; /* declaration of variable for Peek */
/*
* cm_inet_c_001.main_56:
}
/* check if there are enough pending data to read */
- if ((*len == CM_INET_READ_ANY) || ((U32)*len <= pendLen))
+ if ((*len == CM_INET_READ_ANY) || ((uint32_t)*len <= pendLen))
{
if (*len == CM_INET_READ_ANY)
{
{
remAddr6 = (struct sockaddr_in6 *)&remSockAddr;
fromAddr->type = CM_INET_IPV6ADDR_TYPE;
- fromAddr->u.ipv6Addr.port = CM_INET_NTOH_U16(remAddr6->sin6_port);
+ fromAddr->u.ipv6Addr.port = CM_INET_NTOH_UINT16(remAddr6->sin6_port);
CM_INET_COPY_IPV6ADDR(&fromAddr->u.ipv6Addr.ipv6NetAddr,
&remAddr6->sin6_addr);
}
{
remAddr = (struct sockaddr_in *)&remSockAddr;
fromAddr->type = CM_INET_IPV4ADDR_TYPE;
- fromAddr->u.ipv4Addr.port = CM_INET_NTOH_U16(remAddr->sin_port);
- fromAddr->u.ipv4Addr.address = CM_INET_NTOH_U32(remAddr->sin_addr.s_addr);
+ fromAddr->u.ipv4Addr.port = CM_INET_NTOH_UINT16(remAddr->sin_port);
+ fromAddr->u.ipv4Addr.address = CM_INET_NTOH_UINT32(remAddr->sin_addr.s_addr);
}
#else
remAddr = (struct sockaddr_in *)&remSockAddr;
- fromAddr->port = CM_INET_NTOH_U16(remAddr->sin_port);
- fromAddr->address = CM_INET_NTOH_U32(remAddr->sin_addr.s_addr);
+ fromAddr->port = CM_INET_NTOH_UINT16(remAddr->sin_port);
+ fromAddr->address = CM_INET_NTOH_UINT32(remAddr->sin_addr.s_addr);
#endif /* IPV6_SUPPORTED */
}
* of TCP ignore this error condition. The user will call
* cmInetRecvMsg again */
/* cm_inet_c_001.main_62:Warning fix */
- if (sockFd->type != (U8)CM_INET_STREAM)/* G++ */
+ if (sockFd->type != (uint8_t)CM_INET_STREAM)/* G++ */
{
#ifdef T2K_MEM_LEAK_DBG
char * file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
#endif
/* cleanup the dBuf array */
/* update the message structure */
#ifdef SS_LINUX
rxArr[0].iov_base = (Void*)recvBuf;
- rxArr[0].iov_len = (U32)bufLen;
+ rxArr[0].iov_len = (uint32_t)bufLen;
#else
rxArr[0].iov_base = (S8*)recvBuf;
rxArr[0].iov_len = bufLen;
{
#ifdef T2K_MEM_LEAK_DBG
char * file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
#endif
SPutDBuf(info->region, info->pool, dBufs[i]);
{
/* build up HBH opt array from recvd ancillary data */
ret = cmInet6BuildRecvHopOptsArr(
- (U8 *)CMSG_DATA(cmsgptr), cmsgptr->cmsg_len,
+ (uint8_t *)CMSG_DATA(cmsgptr), cmsgptr->cmsg_len,
&ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.hbhOptsArr,
0, info);
if (ret != ROK)
{
/* build up Dest opt array from recvd ancillary data */
ret = cmInet6BuildRecvDstOptsArr(
- (U8 *)CMSG_DATA(cmsgptr), cmsgptr->cmsg_len,
+ (uint8_t *)CMSG_DATA(cmsgptr), cmsgptr->cmsg_len,
&ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.destOptsArr,
1, info);
if (ret != ROK)
{
/* build up Route Hdr from recvd ancillary data */
ret = cmInet6BuildRecvRtHdr(
- (U8 *)CMSG_DATA(cmsgptr), cmsgptr->cmsg_len, &rtHdr0,
+ (uint8_t *)CMSG_DATA(cmsgptr), cmsgptr->cmsg_len, &rtHdr0,
&ipHdrParams->u.ipv6HdrParm.ipv6ExtHdr.rtOptsArr,
info);
if (ret != ROK)
else if(cmsgptr->cmsg_type == IPV6_HOPLIMIT)
{
/* get the received hoplimit */
- ret = cmInet6GetHopLimitValue((U8 *)CMSG_DATA(cmsgptr),
+ ret = cmInet6GetHopLimitValue((uint8_t *)CMSG_DATA(cmsgptr),
cmsgptr->cmsg_len, &ipHdrParams->u.ipv6HdrParm);
if (ret != ROK)
return (ret);
remAddr6 = (struct sockaddr_in6 *)&remSockAddr;
fromAddr->type = CM_INET_IPV6ADDR_TYPE;
fromAddr->u.ipv6Addr.port =
- CM_INET_NTOH_U16(remAddr6->sin6_port);
+ CM_INET_NTOH_UINT16(remAddr6->sin6_port);
CM_INET_COPY_IPV6ADDR(&fromAddr->u.ipv6Addr.ipv6NetAddr,
&remAddr6->sin6_addr);
}
{
remAddr = (struct sockaddr_in *)&remSockAddr;
fromAddr->type = CM_INET_IPV4ADDR_TYPE;
- fromAddr->u.ipv4Addr.port = CM_INET_NTOH_U16(remAddr->sin_port);
+ fromAddr->u.ipv4Addr.port = CM_INET_NTOH_UINT16(remAddr->sin_port);
fromAddr->u.ipv4Addr.address =
- CM_INET_NTOH_U32(remAddr->sin_addr.s_addr);
+ CM_INET_NTOH_UINT32(remAddr->sin_addr.s_addr);
}
#else
remAddr = (struct sockaddr_in *)&remSockAddr;
- fromAddr->port = CM_INET_NTOH_U16(remAddr->sin_port);
- fromAddr->address = CM_INET_NTOH_U32(remAddr->sin_addr.s_addr);
+ fromAddr->port = CM_INET_NTOH_UINT16(remAddr->sin_port);
+ fromAddr->address = CM_INET_NTOH_UINT32(remAddr->sin_addr.s_addr);
#endif /* IPV6_SUPPORTED */
}
remAddr6 = (struct sockaddr_in6 *)&remSockAddr;
fromAddr->type = CM_INET_IPV6ADDR_TYPE;
fromAddr->u.ipv6Addr.port =
- CM_INET_NTOH_U16(remAddr6->sin6_port);
+ CM_INET_NTOH_UINT16(remAddr6->sin6_port);
CM_INET_COPY_IPV6ADDR(&fromAddr->u.ipv6Addr.ipv6NetAddr,
&remAddr6->sin6_addr);
}
{
remAddr = (struct sockaddr_in *)&remSockAddr;
fromAddr->type = CM_INET_IPV4ADDR_TYPE;
- fromAddr->u.ipv4Addr.port = CM_INET_NTOH_U16(remAddr->sin_port);
+ fromAddr->u.ipv4Addr.port = CM_INET_NTOH_UINT16(remAddr->sin_port);
fromAddr->u.ipv4Addr.address =
- CM_INET_NTOH_U32(remAddr->sin_addr.s_addr);
+ CM_INET_NTOH_UINT32(remAddr->sin_addr.s_addr);
}
#else
remAddr = (struct sockaddr_in *)&remSockAddr;
- fromAddr->port = CM_INET_NTOH_U16(remAddr->sin_port);
- fromAddr->address = CM_INET_NTOH_U32(remAddr->sin_addr.s_addr);
+ fromAddr->port = CM_INET_NTOH_UINT16(remAddr->sin_port);
+ fromAddr->address = CM_INET_NTOH_UINT32(remAddr->sin_addr.s_addr);
#endif /* IPV6_SUPPORTED */
}
MsgLen i; /* index */
MsgLen j; /* index */
S32 ret; /* temporary return value */
- U32 timeout; /* timeout for cmInetSelect() */
- U32 *timeoutPtr; /* pointer to timeout */
+ uint32_t timeout; /* timeout for cmInetSelect() */
+ uint32_t *timeoutPtr; /* pointer to timeout */
S16 numFdS; /* number of ready descriptors */
/* cm_inet_c_001.main_45 - fixing the UMR issue in 64bit linux */
- U32 pendLen = 0; /* pending data length */
+ uint32_t pendLen = 0; /* pending data length */
S32 recvLen; /* number of received octets */
S32 remAddrLen; /* length of remote address length */
CmInetFdSet readFdS; /* socket file descriptor set */
remAddr6 = (struct sockaddr_in6 *)&remSockAddr;
fromAddr->type = CM_INET_IPV6ADDR_TYPE;
fromAddr->u.ipv6Addr.port =
- CM_INET_NTOH_U16(remAddr6->sin6_port);
+ CM_INET_NTOH_UINT16(remAddr6->sin6_port);
CM_INET_COPY_IPV6ADDR(&fromAddr->u.ipv6Addr.ipv6NetAddr,
&remAddr6->sin6_addr);
}
{
remAddr = (struct sockaddr_in *)&remSockAddr;
fromAddr->type = CM_INET_IPV4ADDR_TYPE;
- fromAddr->u.ipv4Addr.port = CM_INET_NTOH_U16(remAddr->sin_port);
+ fromAddr->u.ipv4Addr.port = CM_INET_NTOH_UINT16(remAddr->sin_port);
fromAddr->u.ipv4Addr.address =
- CM_INET_NTOH_U32(remAddr->sin_addr.s_addr);
+ CM_INET_NTOH_UINT32(remAddr->sin_addr.s_addr);
}
#else
remAddr = (struct sockaddr_in *)&remSockAddr;
- fromAddr->port = CM_INET_NTOH_U16(remAddr->sin_port);
- fromAddr->address = CM_INET_NTOH_U32(remAddr->sin_addr.s_addr);
+ fromAddr->port = CM_INET_NTOH_UINT16(remAddr->sin_port);
+ fromAddr->address = CM_INET_NTOH_UINT32(remAddr->sin_addr.s_addr);
#endif /* IPV6_SUPPORTED */
}
(
CmInetFdSet *readFdS, /* read socket descriptor file set */
CmInetFdSet *writeFdS, /* write socket descriptor file set */
-U32 *mSecTimeout, /* timeout in msecs */
+uint32_t *mSecTimeout, /* timeout in msecs */
S16 *numFdS /* number of ready descriptors */
)
#else
S16 cmInetSelect(readFdS, writeFdS, mSecTimeout, numFdS)
CmInetFdSet *readFdS; /* read socket descriptor file set */
CmInetFdSet *writeFdS; /* write socket descriptor file set */
-U32 *mSecTimeout; /* timeout in msecs */
+uint32_t *mSecTimeout; /* timeout in msecs */
S16 *numFdS; /* number of ready descriptors */
#endif
{
S16 cmInetSetOpt
(
CmInetFd *sockFd, /* socket file descriptor */
-U32 level, /* option level */
-U32 type, /* option type */
+uint32_t level, /* option level */
+uint32_t type, /* option type */
Ptr value /* option value */
)
#else
S16 cmInetSetOpt(sockFd, level, type, value)
CmInetFd *sockFd; /* socket file descriptor */
-U32 level; /* option level */
-U32 type; /* option type */
+uint32_t level; /* option level */
+uint32_t type; /* option type */
Ptr value; /* option value */
#endif
{
S32 ret = ROK; /* temporary return value */
- U32 disable = 0; /* disable option */
- U32 enable = 1; /* enable option */
+ uint32_t disable = 0; /* disable option */
+ uint32_t enable = 1; /* enable option */
/* added for IPv4 options */
#ifdef IPV4_OPTS_SUPPORTED
#if (defined(SUNOS)|| defined(WIN32) || defined(SS_PS) || defined(SS_VW_MCAST)\
|| defined(HPOS))
- U8 lpEnable = 1; /* multicast loop enable */
- U8 lpDisable = 0; /* multicast loop disable */
+ uint8_t lpEnable = 1; /* multicast loop enable */
+ uint8_t lpDisable = 0; /* multicast loop disable */
#endif /* SUNOS || WIN32 || SS_PS || SS_VW_MCAST || HPOS */
#ifdef WIN32
#endif /* SUNOS || WIN32 || SS_PS || SS_VW_MCAST || HPOS */
#ifdef IPV6_SUPPORTED
- U32 loopEna = 1; /* IPv6 multicast loop enable */
- U32 loopDis = 0; /* IPv6 multicast loop disable */
+ uint32_t loopEna = 1; /* IPv6 multicast loop enable */
+ uint32_t loopDis = 0; /* IPv6 multicast loop disable */
struct ipv6_mreq *stMreq6Ptr;
/* cm_inet_c_001.main_44 : some operating system doesnt have icmp6_filter. so
this flag is gaurded under ICMPV6_FILTER_SUPPORTED. so if user want this
CmInetSctpAssocParams *pSctpAssocParams;
#endif
- U32 *optVal;
+ uint32_t *optVal;
/* cm_inet_c_001.main_58 : Added NULL check for value field */
switch (type)
{
case CM_INET_OPT_BLOCK:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
switch(*optVal)
{
case CM_INET_OPT_ENABLE:
#ifdef WIN32
/* cm_inet_c_001.main_59: Fix for compilation warning */
- ret = ioctlsocket(sockFd->fd, FIONBIO, (U32 *)&disable);
+ ret = ioctlsocket(sockFd->fd, FIONBIO, (uint32_t *)&disable);
#else
#ifdef SS_PS
ret = ioctl(sockFd->fd, FIONBIO, (char*)&disable);
case CM_INET_OPT_DISABLE:
#ifdef WIN32
/* cm_inet_c_001.main_59: Fix for compilation warning */
- ret = ioctlsocket(sockFd->fd, FIONBIO, (U32 *)&enable);
+ ret = ioctlsocket(sockFd->fd, FIONBIO, (uint32_t *)&enable);
#else
#ifdef SS_PS
ret = ioctl(sockFd->fd, FIONBIO, (char*)&enable);
break;
case CM_INET_OPT_REUSEADDR:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
if (*optVal == CM_INET_OPT_ENABLE)
{
#ifdef WIN32
break;
case CM_INET_OPT_BROADCAST:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
if (*optVal == CM_INET_OPT_ENABLE)
{
#ifdef WIN32
break;
case CM_INET_OPT_KEEPALIVE:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
if (*optVal == CM_INET_OPT_ENABLE)
{
#ifdef WIN32
break;
case CM_INET_OPT_RX_BUF_SIZE:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
ret = setsockopt(sockFd->fd, level, SO_RCVBUF,
(char*)optVal, sizeof(*optVal));
break;
case CM_INET_OPT_TX_BUF_SIZE:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
ret = setsockopt(sockFd->fd, level, SO_SNDBUF,
(char*)optVal, sizeof(*optVal));
break;
case CM_INET_OPT_TCP_NODELAY:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
if (*optVal == CM_INET_OPT_ENABLE)
{
#ifdef WIN32
/* Copy the addresses to stMreq structure */
#ifdef SS_PS
- stMreq.imr_mcastaddr.s_addr = CM_INET_HTON_U32(mCast->mCastAddr);
+ stMreq.imr_mcastaddr.s_addr = CM_INET_HTON_UINT32(mCast->mCastAddr);
#else
- stMreq.imr_multiaddr.s_addr = CM_INET_HTON_U32(mCast->mCastAddr);
+ stMreq.imr_multiaddr.s_addr = CM_INET_HTON_UINT32(mCast->mCastAddr);
#endif
- stMreq.imr_interface.s_addr = CM_INET_HTON_U32(mCast->localAddr);
+ stMreq.imr_interface.s_addr = CM_INET_HTON_UINT32(mCast->localAddr);
ret = setsockopt(sockFd->fd, level, IP_ADD_MEMBERSHIP,
(char*)&stMreq, sizeof(stMreq));
/* Copy the addresses to stMreq structure */
#ifdef SS_PS
- stMreq.imr_mcastaddr.s_addr = CM_INET_HTON_U32(mCast->mCastAddr);
+ stMreq.imr_mcastaddr.s_addr = CM_INET_HTON_UINT32(mCast->mCastAddr);
#else
- stMreq.imr_multiaddr.s_addr = CM_INET_HTON_U32(mCast->mCastAddr);
+ stMreq.imr_multiaddr.s_addr = CM_INET_HTON_UINT32(mCast->mCastAddr);
#endif
- stMreq.imr_interface.s_addr = CM_INET_HTON_U32(mCast->localAddr);
+ stMreq.imr_interface.s_addr = CM_INET_HTON_UINT32(mCast->localAddr);
ret = setsockopt(sockFd->fd, level, IP_DROP_MEMBERSHIP,
(char*)&stMreq, sizeof(stMreq));
support CM_INET_OPT_BSD_COMPAT */
#ifndef CMINET_BSDCOMPAT
case CM_INET_OPT_BSD_COMPAT:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
if (*optVal == CM_INET_OPT_ENABLE)
{
ret = setsockopt(sockFd->fd, level, SO_BSDCOMPAT,
#if (defined(SUNOS)|| defined(WIN32) || defined(SS_PS) || defined(SS_VW) \
|| defined(HPOS))
case CM_INET_OPT_HDR_INCLD:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
if (*optVal == CM_INET_OPT_ENABLE)
{
#ifdef WIN32
This socket option is MUST be set (when this server is opened)
if the RSVP server wants to intercept raw RSVP packets. */
case CM_INET_OPT_IP_ROUTER_ALERT:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
if (*optVal == CM_INET_OPT_ENABLE)
{
ret = setsockopt(sockFd->fd, level, IP_ROUTER_ALERT,
#if (defined(SS_LINUX) && (!defined(SS_VW) && !defined(WIN32)))
#ifdef LOCAL_INTF
case CM_INET_OPT_IPV4_PKTINFO:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
if (*optVal == CM_INET_OPT_ENABLE)
{
/* set IP_PKTINFO option when IP_ROUTER_ALERT is set in linux */
#endif /* SUNOS || WIN32 || SS_PS || SS_VW || HPOS */
case CM_INET_OPT_DONTFRAGMENT:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
if (*optVal == CM_INET_OPT_ENABLE)
{
#ifdef WIN32
/* also add these 2 options for VxWorks */
#if (defined(SUNOS)|| defined(WIN32) || defined(HPOS) || defined(SS_VW))
case CM_INET_OPT_TOS:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
ret = setsockopt(sockFd->fd, level, IP_TOS,
(char*)optVal, sizeof(*optVal));
break;
case CM_INET_OPT_TTL:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
ret = setsockopt(sockFd->fd, level, IP_TTL,
(char*)optVal, sizeof(*optVal));
break;
#if (defined(SUNOS)|| defined(WIN32) || defined(SS_PS) || defined(SS_VW_MCAST) \
|| defined(HPOS))
case CM_INET_OPT_MCAST_LOOP:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
if (*optVal == CM_INET_OPT_ENABLE)
{
#ifdef SS_VW
break;
case CM_INET_OPT_MCAST_IF:
- optVal = (U32*)value;
- *optVal = CM_INET_HTON_U32((U32)*optVal);
+ optVal = (uint32_t*)value;
+ *optVal = CM_INET_HTON_UINT32((uint32_t)*optVal);
ret = setsockopt(sockFd->fd, level, IP_MULTICAST_IF,
(char *)optVal, sizeof(struct in_addr));
break;
case CM_INET_OPT_MCAST_TTL:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
/* remove CONSTANT in setsockopt for VW */
#ifdef SS_VW
ret = setsockopt(sockFd->fd, level, IP_MULTICAST_TTL,
- (char *)optVal, sizeof(U8));
+ (char *)optVal, sizeof(uint8_t));
#else
ret = setsockopt(sockFd->fd, level, IP_MULTICAST_TTL,
- (CONSTANT char *)optVal, sizeof(U8));
+ (CONSTANT char *)optVal, sizeof(uint8_t));
#endif /* SS_VW */
break;
#endif /* SUNOS || WIN32 || SS_PS || SS_VW_MCAST || HPOS */
#ifdef IPV6_SUPPORTED
case CM_INET_OPT_IPV6_TTL:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
ret = setsockopt(sockFd->fd, level, IPV6_UNICAST_HOPS,
(char*)optVal, sizeof(*optVal));
break;
break;
case CM_INET_OPT_MCAST6_LOOP:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
if (*optVal == CM_INET_OPT_ENABLE)
{
ret = setsockopt(sockFd->fd, level, IPV6_MULTICAST_LOOP,
case CM_INET_OPT_MCAST6_IF:
ret = setsockopt(sockFd->fd, level, IPV6_MULTICAST_IF,
- (U32 *)value, sizeof(U32));
+ (uint32_t *)value, sizeof(uint32_t));
break;
case CM_INET_OPT_MCAST6_HOPS:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
ret = setsockopt(sockFd->fd, level, IPV6_MULTICAST_HOPS,
- (char *)optVal, sizeof(U32));
+ (char *)optVal, sizeof(uint32_t));
break;
/* cm_inet_c_001.main_44 : some operating system doesnt have icmp6_filter. so
/* added new options */
#ifdef IPV6_OPTS_SUPPORTED
case CM_INET_OPT_RECVIPV6_HOPLIM:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
#ifdef SS_LINUX
ret = setsockopt(sockFd->fd, level, IPV6_HOPLIMIT,
- (char *)optVal, sizeof(U32));
+ (char *)optVal, sizeof(uint32_t));
#else
ret = setsockopt(sockFd->fd, level, IPV6_HOPLIMIT,
- (char *)optVal, sizeof(U32));
+ (char *)optVal, sizeof(uint32_t));
/* enable the reception of IPv6 HopLimit value as ancillary data */
ret = setsockopt(sockFd->fd, level, IPV6_RECVHOPLIMIT,
(char*)&enable, sizeof(enable));
break;
case CM_INET_OPT_RECVIPV6_HBHOPTS:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
#ifdef SS_LINUX
ret = setsockopt(sockFd->fd, level, IPV6_HOPOPTS,
- (char *)optVal, sizeof(U32));
+ (char *)optVal, sizeof(uint32_t));
#else
ret = setsockopt(sockFd->fd, level, IPV6_RECVHOPOPTS,
- (char *)optVal, sizeof(U32));
+ (char *)optVal, sizeof(uint32_t));
#endif /* SS_LINUX */
break;
case CM_INET_OPT_RECVIPV6_DSTOPTS:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
#ifdef SS_LINUX
ret = setsockopt(sockFd->fd, level, IPV6_DSTOPTS,
- (char *)optVal, sizeof(U32));
+ (char *)optVal, sizeof(uint32_t));
#else
ret = setsockopt(sockFd->fd, level, IPV6_RECVDSTOPTS,
- (char *)optVal, sizeof(U32));
+ (char *)optVal, sizeof(uint32_t));
#endif /* SS_LINUX */
break;
case CM_INET_OPT_RECVIPV6_RTHDR:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
#ifdef SS_LINUX
ret = setsockopt(sockFd->fd, level, IPV6_RTHDR,
- (char *)optVal, sizeof(U32));
+ (char *)optVal, sizeof(uint32_t));
#else
ret = setsockopt(sockFd->fd, level, IPV6_RECVRTHDR,
- (char *)optVal, sizeof(U32));
+ (char *)optVal, sizeof(uint32_t));
#endif /* SS_LINUX */
break;
* type, then it will fail here due to above reason */
#ifdef SS_LINUX
case CM_INET_OPT_IP_ROUTER_ALERT6:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
if(*optVal == CM_INET_OPT_ENABLE)
ret = setsockopt(sockFd->fd, IPPROTO_IPV6, IPV6_ROUTER_ALERT,
(char *)&enable, sizeof(enable));
#ifdef LOCAL_INTF
case CM_INET_OPT_IPV6_PKTINFO:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
#ifdef SS_LINUX
ret = setsockopt(sockFd->fd, level, IPV6_PKTINFO,
- (char *)optVal, sizeof(U32));
+ (char *)optVal, sizeof(uint32_t));
#else
ret = setsockopt(sockFd->fd, level, IPV6_RECVPKTINFO,
(char *)&enable, sizeof(enable));
pAddr6 = (struct sockaddr_in6*)&(setPrim.ssp_addr);
pAddr6->sin6_family = AF_INET6;
- pAddr6->sin6_port = CM_INET_HTON_U16(pSctpPrimAddr->port);
+ pAddr6->sin6_port = CM_INET_HTON_UINT16(pSctpPrimAddr->port);
CM_INET_COPY_IPV6ADDR(&pAddr6->sin6_addr.s6_addr, &pSctpPrimAddr->addr.u.ipv6NetAddr);
}
else
{
pAddr = (struct sockaddr_in*)&(setPrim.ssp_addr);
pAddr->sin_family = AF_INET;
- pAddr->sin_port = CM_INET_HTON_U16(pSctpPrimAddr->port);
- pAddr->sin_addr.s_addr = CM_INET_HTON_U32(pSctpPrimAddr->addr.u.ipv4NetAddr);
+ pAddr->sin_port = CM_INET_HTON_UINT16(pSctpPrimAddr->port);
+ pAddr->sin_addr.s_addr = CM_INET_HTON_UINT32(pSctpPrimAddr->addr.u.ipv4NetAddr);
}
#else
pAddr = (struct sockaddr_in*)&(setPrim.ssp_addr);
pAddr->sin_family = AF_INET;
- pAddr->sin_port = CM_INET_HTON_U16(pSctpPrimAddr->port);
- pAddr->sin_addr.s_addr = CM_INET_HTON_U32(pSctpPrimAddr->addr.u.ipv4NetAddr);
+ pAddr->sin_port = CM_INET_HTON_UINT16(pSctpPrimAddr->port);
+ pAddr->sin_addr.s_addr = CM_INET_HTON_UINT32(pSctpPrimAddr->addr.u.ipv4NetAddr);
#endif /* IPV6_SUPPORTED */
setPrim.ssp_assoc_id = pSctpPrimAddr->assocId;
pAddr6 = (struct sockaddr_in6*)&(addrParams.spp_address);
pAddr6->sin6_family = AF_INET6;
- pAddr6->sin6_port = CM_INET_HTON_U16(pSctpPAddrParams->s.port);
+ pAddr6->sin6_port = CM_INET_HTON_UINT16(pSctpPAddrParams->s.port);
CM_INET_COPY_IPV6ADDR(&pAddr6->sin6_addr.s6_addr, &pSctpPAddrParams->s.addr.u.ipv6NetAddr);
}
else
{
pAddr = (struct sockaddr_in*)&(addrParams.spp_address);
pAddr->sin_family = AF_INET;
- pAddr->sin_port = CM_INET_HTON_U16(pSctpPAddrParams->s.port);
- pAddr->sin_addr.s_addr = CM_INET_HTON_U32(pSctpPAddrParams->s.addr.u.ipv4NetAddr);
+ pAddr->sin_port = CM_INET_HTON_UINT16(pSctpPAddrParams->s.port);
+ pAddr->sin_addr.s_addr = CM_INET_HTON_UINT32(pSctpPAddrParams->s.addr.u.ipv4NetAddr);
}
#else
pAddr = (struct sockaddr_in*)&(addrParams.spp_address);
pAddr->sin_family = AF_INET;
- pAddr->sin_port = CM_INET_HTON_U16(pSctpPAddrParams->s.port);
- pAddr->sin_addr.s_addr = CM_INET_HTON_U32(pSctpPAddrParams->s.addr.u.ipv4NetAddr);
+ pAddr->sin_port = CM_INET_HTON_UINT16(pSctpPAddrParams->s.port);
+ pAddr->sin_addr.s_addr = CM_INET_HTON_UINT32(pSctpPAddrParams->s.addr.u.ipv4NetAddr);
#endif /* IPV6_SUPPORTED */
}
else
addrParams.spp_assoc_id = pSctpPAddrParams->assocId;
/*cm_inet_c_001.main_58 : fix for klockwork issue */
- addrParams.spp_pathmaxrxt = (U16)pSctpPAddrParams->pathMaxRxt;
+ addrParams.spp_pathmaxrxt = (uint16_t)pSctpPAddrParams->pathMaxRxt;
#ifdef SUN_KSCTP
if (pSctpPAddrParams->hbEnblFlag == CM_INET_OPT_ENABLE)
addrParams.spp_hbinterval = pSctpPAddrParams->hbInterval;
#ifdef SS_LINUX
#ifdef CM_ICMP_FILTER_SUPPORT
case CM_INET_OPT_ICMP_FILTER:
- optVal = (U32*)value;
+ optVal = (uint32_t*)value;
ret = setsockopt(sockFd->fd, level, ICMP_FILTER,
optVal, sizeof(icmpFilter));
break;
S16 cmInetGetNumRead
(
CmInetFd *sockFd, /* socket file descriptor */
-U32 *dataLen /* number of pending octets */
+uint32_t *dataLen /* number of pending octets */
/* removed 3rd argument memInfo */
)
#else
S16 cmInetGetNumRead(sockFd, dataLen)
CmInetFd *sockFd; /* socket file descriptor */
-U32 *dataLen; /* number of pending octets */
+uint32_t *dataLen; /* number of pending octets */
/* removed 3rd argument memInfo */
#endif
{
pending data in the socket recv buffer */
#ifdef WIN32
/* cm_inet_c_001.main_59: Fix for compilation warning */
- ret = ioctlsocket(sockFd->fd, FIONREAD, (U32 *)dataLen);
+ ret = ioctlsocket(sockFd->fd, FIONREAD, (uint32_t *)dataLen);
#else
#ifdef SS_PS
ret = ioctl(sockFd->fd, FIOREAD, (char*)dataLen);
#endif
{
#ifndef SS_VW
- U8 numAddrs; /* Number of Addresses */
+ uint8_t numAddrs; /* Number of Addresses */
#endif /* SS_VW */
#if (defined(WIN32) || defined(SS_LINUX) || defined(HPOS))
(hostid->h_addr_list[numAddrs] != NULLP))
{
addrTbl->netAddr[addrTbl->count++] =
- CM_INET_NTOH_U32 (*((U32 *) hostid->h_addr_list[numAddrs]));
+ CM_INET_NTOH_UINT32 (*((uint32_t *) hostid->h_addr_list[numAddrs]));
numAddrs += 1;
}
}
(hostid.h_addr_list[numAddrs] != NULLP))
{
addrTbl->netAddr[addrTbl->count++] =
- CM_INET_NTOH_U32 (*((U32 *) hostid.h_addr_list[numAddrs]));
+ CM_INET_NTOH_UINT32 (*((uint32_t *) hostid.h_addr_list[numAddrs]));
numAddrs += 1;
}
}
#else
#ifdef SUNOS
#ifndef SS_LINUX
- U8 numAddrs=0; /* Number of addresses */
+ uint8_t numAddrs=0; /* Number of addresses */
int err=0; /* error code */
struct hostent *hostid; /* host information */
#endif /* SS_LINUX */
{
addrArr->u.ipv4AddrArr.count ++;
addrArr->u.ipv4AddrArr.netAddr[numAddrs] =
- CM_INET_NTOH_U32 (*((U32 *) hostid->h_addr_list[numAddrs]));
+ CM_INET_NTOH_UINT32 (*((uint32_t *) hostid->h_addr_list[numAddrs]));
numAddrs += 1;
}
}
* Fun: cmInetAddr
*
* Desc: Converts an ASCII string containig an internet address
-* ("xxx.xxx.xxx.xxx") into a CmInetIpAddr (U32) format.
+* ("xxx.xxx.xxx.xxx") into a CmInetIpAddr (uint32_t) format.
* This function is a wrapper for the inet_addr() call.
*
* Ret: ROK - successful
#endif /* ERRCLASS & ERRCLS_INT_PAR */
*address = inet_addr(asciiAddr);
- if (*address == (U32)ERR_INADDRNONE)
+ if (*address == (uint32_t)ERR_INADDRNONE)
{
/* asciiAddr does not contain a valid internet address */
return RFAILED;
#ifdef ANSI
S16 cmInetNtop(
-U8 type, /* ip address type */
+uint8_t type, /* ip address type */
Void *address, /* 4/16 byte interent address */
S8 *asciiAddr, /* ascii adress representation */
-U32 len
+uint32_t len
)
#else
S16 cmInetNtop(type,address, asciiAddr,len)
-U8 type; /* ip address type */
+uint8_t type; /* ip address type */
Void *address; /* 4/16 byte interent address */
S8 *asciiAddr; /* ascii adress representation */
-U32 len;
+uint32_t len;
#endif
{
#ifdef WIN32
struct sockaddr_storage ss;
- U32 sslen = sizeof(ss);
+ uint32_t sslen = sizeof(ss);
#endif /* WIN32 */
#if (ERRCLASS & ERRCLS_INT_PAR)
#endif
{
#ifdef WIN32
- U16 version;
+ uint16_t version;
S32 err;
WSADATA data;
#ifdef UNIX
socklen_t size;
#else
- U32 size;
+ uint32_t size;
#endif /* SS_LINUX */
S32 errCode;
/*cm_inet_c_001.main_58 : fix for klockwork issue */
sockAddr = (struct sockaddr_in *)&lclSockAddr;
#ifdef IPV6_SUPPORTED
locAddr->type = CM_INET_IPV4ADDR_TYPE;
- locAddr->u.ipv4Addr.port = CM_INET_NTOH_U16(sockAddr->sin_port);
+ locAddr->u.ipv4Addr.port = CM_INET_NTOH_UINT16(sockAddr->sin_port);
#else
- locAddr->port = CM_INET_NTOH_U16(sockAddr->sin_port);
+ locAddr->port = CM_INET_NTOH_UINT16(sockAddr->sin_port);
#endif /* IPV6_SUPPORTED */
return ROK;
{
sockAddr6 = (struct sockaddr_in6 *)&lclSockAddr;
locAddr->type = CM_INET_IPV6ADDR_TYPE;
- locAddr->u.ipv6Addr.port = CM_INET_NTOH_U16(sockAddr6->sin6_port);
+ locAddr->u.ipv6Addr.port = CM_INET_NTOH_UINT16(sockAddr6->sin6_port);
CM_INET_COPY_IPV6ADDR(&locAddr->u.ipv6Addr.ipv6NetAddr,
&sockAddr6->sin6_addr);
}
{
sockAddr = (struct sockaddr_in *)&lclSockAddr;
locAddr->type = CM_INET_IPV4ADDR_TYPE;
- locAddr->u.ipv4Addr.port = CM_INET_NTOH_U16(sockAddr->sin_port);
+ locAddr->u.ipv4Addr.port = CM_INET_NTOH_UINT16(sockAddr->sin_port);
locAddr->u.ipv4Addr.address =
- CM_INET_NTOH_U32(sockAddr->sin_addr.s_addr);
+ CM_INET_NTOH_UINT32(sockAddr->sin_addr.s_addr);
}
#else
sockAddr = (struct sockaddr_in *)&lclSockAddr;
- locAddr->port = CM_INET_NTOH_U16(sockAddr->sin_port);
- locAddr->address = CM_INET_NTOH_U32(sockAddr->sin_addr.s_addr);
+ locAddr->port = CM_INET_NTOH_UINT16(sockAddr->sin_port);
+ locAddr->address = CM_INET_NTOH_UINT32(sockAddr->sin_addr.s_addr);
#endif /* IPV6_SUPPORTED */
return ROK;
}/* end of cmInetGetSockName() */
#endif
{
#if (defined(SUNOS) || defined(SS_LINUX) || defined(SS_VW) || defined(HPOS))
- U16 arIdx;
- U8 curByte;
- U8 bitPos;
+ uint16_t arIdx;
+ uint8_t curByte;
+ uint8_t bitPos;
CmInetFdSet *fdSet;
#endif /* SUNOS || SS_LINUX || SS_VW */
#if (defined(SUNOS) || defined(SS_LINUX) || defined(SS_VW)|| defined(HPOS))
/* Check if we are on a big endian machine */
arIdx = 0x01;
- if (*(U8 *)&arIdx)
+ if (*(uint8_t *)&arIdx)
fdSetInfo->bigEndian = FALSE;
else
fdSetInfo->bigEndian = TRUE;
for (arIdx = 1; arIdx < 256; arIdx++)
{
/* cm_inet_c_001.main_54: Fix for Klockworks issue */
- curByte = (U8)arIdx;
+ curByte = (uint8_t)arIdx;
bitPos = 0;
while(bitPos < 8)
{
/*cm_inet_c_001.main_58 : Fix for klockwork issue */
#if (!defined (WIN32))
- U32 sizOfFdSetArElem;
- U8 bytesScanned;
+ uint32_t sizOfFdSetArElem;
+ uint8_t bytesScanned;
Bool found;
- U32 curIdx;
- U8 *tempByte;
- U8 bitPos;
+ uint32_t curIdx;
+ uint8_t *tempByte;
+ uint8_t bitPos;
#endif /* !defined (WIN32) */
#if (ERRCLASS & ERRCLS_INT_PAR)
{
/* Walk through the bytes in this element */
#if (defined(SS_LINUX) && !defined(_GNU_SOURCE))
- tempByte = (U8 *)&fdSet->__fds_bits[curIdx];
+ tempByte = (uint8_t *)&fdSet->__fds_bits[curIdx];
#else
- tempByte = (U8 *)&fdSet->fds_bits[curIdx];
+ tempByte = (uint8_t *)&fdSet->fds_bits[curIdx];
#endif /* SS_LINUX */
/* Set the starting byte offset */
{
bitPos = fdSetInfo->ar[*tempByte];
/* cm_inet_c_001.main_54: Fix for Klockworks issue */
- fdSetInfo->arIdx = (U16)curIdx;
+ fdSetInfo->arIdx = (uint16_t)curIdx;
/* Calculate fd depending on where we are */
*sockFd = ((bytesScanned << 3) + bitPos);
*sockFd += (curIdx * (sizOfFdSetArElem << 3));
#ifdef ANSI
S16 cmInetConvertStrToIpAddr
(
-U16 len, /* Length of IP address */
-U8 *val, /* Domain Name String */
+uint16_t len, /* Length of IP address */
+uint8_t *val, /* Domain Name String */
CmInetNetAddr *address /* IP Address */
)
#else
S16 cmInetConvertStrToIpAddr(len, val, address)
-U16 len; /* Length of IP address */
-U8 *val; /* Domain Name String */
+uint16_t len; /* Length of IP address */
+uint8_t *val; /* Domain Name String */
CmInetNetAddr *address; /* IP Address */
#endif
{
- U8 idx; /* Index for string*/
- U8 ipv4[CM_INET_IPV4ADDR_SIZE]; /* IPV4 Address bytes */
+ uint8_t idx; /* Index for string*/
+ uint8_t ipv4[CM_INET_IPV4ADDR_SIZE]; /* IPV4 Address bytes */
#ifdef IPV6_SUPPORTED
- U16 *ipv6; /* IPV6 Address bytes */
- U16 ipv6Reg[8]; /* regular IPV6 Address bytes */
- U16 ipv6Cmp[8]; /* compressed IPV6 Address bytes */
- U8 numBlk; /* number of blocks in IPV6 addr */
+ uint16_t *ipv6; /* IPV6 Address bytes */
+ uint16_t ipv6Reg[8]; /* regular IPV6 Address bytes */
+ uint16_t ipv6Cmp[8]; /* compressed IPV6 Address bytes */
+ uint8_t numBlk; /* number of blocks in IPV6 addr */
Bool compressed; /* IPV6 in compressed format */
- U8 ipv6Idx; /* counter for IPV6 */
- U8 blkBeginIdx; /* IPV6, char index for the
+ uint8_t ipv6Idx; /* counter for IPV6 */
+ uint8_t blkBeginIdx; /* IPV6, char index for the
beginning of the block */
- U8 i; /* counter for IPV6 */
+ uint8_t i; /* counter for IPV6 */
S16 retVal; /* return value */
Bool embedIPV4 = FALSE; /* IPV4 embedded in IPV6 ? */
#endif /* IPV6_SUPPORTED*/
if (val[idx] == '.')
{
idx++;
- cmInetAsciiToIpv4(3, &(ipv4[1]), (U16)(len - idx), &(val[idx]));
+ cmInetAsciiToIpv4(3, &(ipv4[1]), (uint16_t)(len - idx), &(val[idx]));
address->type = CM_INET_IPV4ADDR_TYPE;
CM_INET_GET_IPV4_ADDR_FRM_STRING(address->u.ipv4NetAddr, ipv4);
numBlk = 7; /* copy from the last block */
} /* else, no embedded IPV4 */
- /* type cast U8 over -1 becasue we want to copy the last block,
+ /* type cast uint8_t over -1 becasue we want to copy the last block,
ipv6Cmp[0]
*/
- for (i = ipv6Idx; i != (U8) (-1); i --)
+ for (i = ipv6Idx; i != (uint8_t) (-1); i --)
{
ipv6Reg[numBlk] = ipv6Cmp[i];
numBlk--;
#ifdef ANSI
S16 cmInetAsciiToIpv4
(
-U8 numBytes, /* number of Byte to convert */
-U8 *ipv4Addr, /* IPV4 Address */
-U16 len, /* Length of IP address */
-U8 *val /* Domain Name String */
+uint8_t numBytes, /* number of Byte to convert */
+uint8_t *ipv4Addr, /* IPV4 Address */
+uint16_t len, /* Length of IP address */
+uint8_t *val /* Domain Name String */
)
#else
S16 cmInetAsciiToIpv4(numBytes, ipv4Addr, len, val)
-U8 numBytes; /* number of Byte to convert */
-U8 *ipv4Addr; /* IPV4 Address */
-U16 len; /* Length of IP address */
-U8 *val; /* Domain Name String */
+uint8_t numBytes; /* number of Byte to convert */
+uint8_t *ipv4Addr; /* IPV4 Address */
+uint16_t len; /* Length of IP address */
+uint8_t *val; /* Domain Name String */
#endif
{
- U8 byteCount; /* Byte Count */
- U8 idx; /* Index for string*/
+ uint8_t byteCount; /* Byte Count */
+ uint8_t idx; /* Index for string*/
idx = 0;
#if (ERRCLASS & ERRCLS_INT_PAR)
/* error check on parameters */
if (res == NULLP)
- RETVOID;
+ return;
#endif /* ERRCLASS & ERRCLS_INT_PAR */
freeaddrinfo(res);
#if (defined(WIN32) || defined(CMINETFLATBUF))
S32 ret; /* temporary return value */
- U32 pendLen; /* pending data length */
+ uint32_t pendLen; /* pending data length */
S32 recvLen; /* number of received octets by recvmsg() */
MsgLen curLen; /* current number of octets in buffer */
- U32 remAddrLen; /* length of remote address */
+ uint32_t remAddrLen; /* length of remote address */
struct sockaddr_in *remAddr; /* remote Internet address */
#ifdef IPV6_SUPPORTED
struct sockaddr_in6 remSockAddr; /* to get packet's source IP address */
#else
S32 ret; /* temporary return value */
MsgLen curLen; /* current number of octets in buffer */
- U32 pendLen; /* pending data length */
+ uint32_t pendLen; /* pending data length */
S32 recvLen; /* number of received octets by recvmsg() */
struct msghdr msg; /* message header */
CmInetIovec rxArr[CM_INET_MAX_DBUF]; /* dynamic gather array */
- U32 remAddrLen; /* length of remote address */
+ uint32_t remAddrLen; /* length of remote address */
#ifdef IPV6_SUPPORTED
struct sockaddr_in6 remSockAddr;/* to get packet's source IP address */
#if (defined(SS_LINUX) || defined(_XPG4_2))
- U8 ancillData[CM_INET_IPV6_ANCIL_DATA];
+ uint8_t ancillData[CM_INET_IPV6_ANCIL_DATA];
/* from stack for IPv6 ancill data */
#endif
#else
CmInetSockAddr remSockAddr; /* to get packet's src IP address */
#if (defined(SS_LINUX) || defined(_XPG4_2))
- U8 ancillData[CM_INET_IPV4_ANCIL_DATA];
+ uint8_t ancillData[CM_INET_IPV4_ANCIL_DATA];
/* from stack for IPv4 ancill data */
#endif
#endif /* IPV6_SUPPORTED */
#endif /* WIN32 | CMINETFLATBUF */
/* used by getsockopt */
- U32 errValue; /* error value */
- U32 optLen; /* option length */
+ uint32_t errValue; /* error value */
+ uint32_t optLen; /* option length */
#if (ERRCLASS & ERRCLS_INT_PAR)
}
else
{
- U8 tempBuf;
+ uint8_t tempBuf;
/* added separate recvfrom calls different OS */
#if( defined(SS_VW) || defined(HPOS) || defined(SS_PS))
recvLen = recvfrom(sockFd->fd, (S8 *)&tempBuf, pendLen, 0,
/* update the message structure */
#ifdef SS_LINUX
rxArr[0].iov_base = (Void*)recvTempBuf;
- rxArr[0].iov_len = (U32)curLen;
+ rxArr[0].iov_len = (uint32_t)curLen;
#else
rxArr[0].iov_base = (S8*)recvTempBuf;
rxArr[0].iov_len = curLen;
#define CM_INET_FD_ZERO(_fdSet) FD_ZERO(_fdSet)
/* macros to convert from network to host byteorder and vice versa */
-#define CM_INET_NTOH_U32(_long) ntohl(_long)
-#define CM_INET_HTON_U32(_long) htonl(_long)
-#define CM_INET_NTOH_U16(_word) ntohs(_word)
-#define CM_INET_HTON_U16(_word) htons(_word)
-
-/* peeks a U8 from the given position */
-#define CM_INET_PEEK_U8(_sockFd, _fromAddr, _info, _pos, _octet, _ret) \
- _ret = cmInetPeek(_sockFd, _fromAddr, _info, _pos, sizeof(U8), &_octet)
+#define CM_INET_NTOH_UINT32(_long) ntohl(_long)
+#define CM_INET_HTON_UINT32(_long) htonl(_long)
+#define CM_INET_NTOH_UINT16(_word) ntohs(_word)
+#define CM_INET_HTON_UINT16(_word) htons(_word)
+
+/* peeks a uint8_t from the given position */
+#define CM_INET_PEEK_UINT8(_sockFd, _fromAddr, _info, _pos, _octet, _ret) \
+ _ret = cmInetPeek(_sockFd, _fromAddr, _info, _pos, sizeof(uint8_t), &_octet)
/*
- * peeks a U16 from the given position (it is supposed that the U16 is
+ * peeks a uint16_t from the given position (it is supposed that the uint16_t is
* represented in big endian representation within the data stream)
*/
-#define CM_INET_PEEK_U16(_sockFd, _fromAddr, _info, _pos, _word, _ret) \
+#define CM_INET_PEEK_UINT16(_sockFd, _fromAddr, _info, _pos, _word, _ret) \
{ \
- U8 _tempWord[2]; \
+ uint8_t _tempWord[2]; \
\
- _ret = cmInetPeek(_sockFd, _fromAddr, _info, _pos, sizeof(U16), _tempWord); \
+ _ret = cmInetPeek(_sockFd, _fromAddr, _info, _pos, sizeof(uint16_t), _tempWord); \
if (_ret == ROK) \
{ \
_word = ((_tempWord[0] << 8) + (_tempWord[1])); \
}
/*
- * peeks a U32 from the given position (it is supposed that the U32 is
+ * peeks a uint32_t from the given position (it is supposed that the uint32_t is
* represented in big endian representation within the data stream)
*/
-#define CM_INET_PEEK_U32(_sockFd, _fromAddr, _info, _pos, _long, _ret) \
+#define CM_INET_PEEK_UINT32(_sockFd, _fromAddr, _info, _pos, _long, _ret) \
{ \
- U8 _tempLong[4]; \
+ uint8_t _tempLong[4]; \
\
- _ret = cmInetPeek(_sockFd, _fromAddr, _info, _pos, sizeof(U32), _tempLong); \
+ _ret = cmInetPeek(_sockFd, _fromAddr, _info, _pos, sizeof(uint32_t), _tempLong); \
if (_ret == ROK) \
{ \
_long = ((_tempLong[0] << 24) + (_tempLong[1] << 16) \
#ifdef IPV6_OPTS_SUPPORTED
#define CM_INET_FREE_IPV6_HDRPARM(_region, _pool, _hdrParmIpv6) \
{ \
- U8 numOpts; \
+ uint8_t numOpts; \
if( _hdrParmIpv6->ipv6ExtHdr.hbhHdrPrsnt) \
{ \
for(numOpts = _hdrParmIpv6->ipv6ExtHdr.hbhOptsArr.numHBHOpts; \
#define CM_INET_GET_IPV4_ADDR_FRM_STRING(_value, _str) \
{ \
- U16 _hiWord; \
- U16 _loWord; \
+ uint16_t _hiWord; \
+ uint16_t _loWord; \
\
_hiWord = 0; \
_loWord = 0; \
typedef struct cmInetIpAddrTbl
{
- U16 count; /* Number of addresses in table */
+ uint16_t count; /* Number of addresses in table */
CmInetIpAddr netAddr[CM_INET_IPV4_NUM_ADDR]; /* Address table */
}CmInetIpAddrTbl;
#ifdef IPV6_SUPPORTED
typedef struct cmInetIpv6AddrArr
{
- U16 count; /* Number of addresses in array */
+ uint16_t count; /* Number of addresses in array */
CmInetIpAddr6 netAddr[CM_INET_IPV6_NUM_ADDR]; /* Address array */
}CmInetIpv6AddrArr;
#endif /* IPV6_SUPPORTED */
typedef struct cmInetIpAddrArr
{
- U8 type;
+ uint8_t type;
union
{
CmInetIpv4AddrArr ipv4AddrArr;
/* Adding a type for socket Address */
typedef struct cmInetCmnSockAddr
{
- U32 type;
- U32 len;
+ uint32_t type;
+ uint32_t len;
union
{
struct sockaddr_in addr;
typedef struct cmInetFd /* trillium socket file descriptor */
{
CmInetFdType fd; /* socket descriptor */
- U8 blocking; /* true if socket is blocking */
- U8 type; /* socket type (stream|datagram) */
+ uint8_t blocking; /* true if socket is blocking */
+ uint8_t type; /* socket type (stream|datagram) */
#ifdef IPV6_SUPPORTED
- U8 protType; /* indicates whether IPv4 or IPv6 socket */
+ uint8_t protType; /* indicates whether IPv4 or IPv6 socket */
#endif /* IPV6_SUPPORTED */
}CmInetFd;
/* IPV4 Address */
typedef struct cmInetIpv4Addr
{
- U16 port;
+ uint16_t port;
CmInetIpAddr address;
} CmInetIpv4Addr;
/* IPV6 Address */
typedef struct cmInetIpv6Addr
{
- U16 port;
+ uint16_t port;
CmInetIpAddr6 ipv6NetAddr;
} CmInetIpv6Addr;
typedef struct CmInetAddr /* Internet address */
{
- U8 type; /* type of address present in the union */
+ uint8_t type; /* type of address present in the union */
union
{
CmInetIpv4Addr ipv4Addr; /* IPV4 Address */
typedef struct cmInetMCastInf6 /* multicast interface information */
{
CmInetIpAddr6 mCastAddr; /* multicast address */
- U32 localInf; /* local interface */
+ uint32_t localInf; /* local interface */
} CmInetMCastInf6;
#else
/* IPV4 Address */
typedef struct cmInetAddr1
{
- U16 port;
+ uint16_t port;
CmInetIpAddr address;
} CmInetAddr;
typedef CmInetAddr CmInetIpv4Addr;
used here for cmInetConvertStrToIpAddr */
typedef struct cmInetNetAddr
{
- U8 type; /* type of network address */
+ uint8_t type; /* type of network address */
union
{
CmInetIpAddr ipv4NetAddr; /* IP network address */
#ifdef CM_LKSCTP
typedef struct cmInetNetAddrLst
{
- U8 count;
+ uint8_t count;
CmInetNetAddr addrs[CM_INET_NUM_NET_ADDR];
} CmInetNetAddrLst;
#endif
typedef struct cmInetLocalInf
{
Bool intfPrsnt; /* bool to indicate if this is a valid loc intf */
- U32 localIf; /* interface index IPv4(32 bit) or IPv6(32 bit) */
+ uint32_t localIf; /* interface index IPv4(32 bit) or IPv6(32 bit) */
CmInetNetAddr localIfAddr; /* interface address */
}CmInetLocalInf;
#endif /* LOCAL_INTF */
/* structure to hold TLV of each HBH option */
typedef struct cmInetIpv6HBHHdr
{
- U8 type;
- U8 length;
- U8 *value;
+ uint8_t type;
+ uint8_t length;
+ uint8_t *value;
} CmInetIpv6HBHHdr;
/* structure to hold TLV of each Destination option */
typedef struct cmInetIpv6DestOptsHdr
{
- U8 type;
- U8 length;
- U8 *value;
+ uint8_t type;
+ uint8_t length;
+ uint8_t *value;
} CmInetIpv6DestOptsHdr;
/* structure to hold IPV6 addresses of the Route header */
typedef struct cmInetIpv6RtHdr
{
- U8 numAddrs;
- U32 slMap;
+ uint8_t numAddrs;
+ uint32_t slMap;
CmInetIpAddr6 *ipv6Addrs;
} CmInetIpv6RtHdr;
/* array of all HBH options */
typedef struct cmInetIpv6HBHHdrArr
{
- U8 numHBHOpts;
+ uint8_t numHBHOpts;
CmInetIpv6HBHHdr *hbhOpts;
} CmInetIpv6HBHHdrArr;
/* array of all Destination options */
typedef struct cmInetIpv6DestOptsArr
{
- U8 numDestOpts;
+ uint8_t numDestOpts;
CmInetIpv6DestOptsHdr *destOpts;
} CmInetIpv6DestOptsArr;
/* structure for type 0 Route Header */
typedef struct cmInetIpv6RtHdr0
{
- U8 ip6r0_nextHdr;
- U8 ip6r0_hdrExtLen;
- U8 ip6r0_type;
- U8 ip6r0_segLeft;
- U32 ip6r0_resrvAndSLmap; /* first byte reserved, last 3 srtict/loose map */
+ uint8_t ip6r0_nextHdr;
+ uint8_t ip6r0_hdrExtLen;
+ uint8_t ip6r0_type;
+ uint8_t ip6r0_segLeft;
+ uint32_t ip6r0_resrvAndSLmap; /* first byte reserved, last 3 srtict/loose map */
} CmInetIpv6RtHdr0;
#endif /* IPV6_OPTS_SUPPORTED */
typedef struct cmInetIpv6HdrParm
{
- TknU8 ttl;
+ TknUInt8 ttl;
CmInetNetAddr srcAddr6;/* used to set src addr on sending pkt(IPv6) */
#ifdef IPV6_OPTS_SUPPORTED
CmInetIpv6ExtHdr ipv6ExtHdr;
typedef struct cmInetIpv4HdrParm
{
- TknU8 proto; /* Protocol value */
- TknU8 dfBit; /* Don't fragment flag */
- TknU8 tos; /* Type of Service */
- TknU8 ttl; /* Time to Live */
+ TknUInt8 proto; /* Protocol value */
+ TknUInt8 dfBit; /* Don't fragment flag */
+ TknUInt8 tos; /* Type of Service */
+ TknUInt8 ttl; /* Time to Live */
/* added new field */
#ifdef IPV4_OPTS_SUPPORTED
TknStr64 ipv4HdrOpt; /* IPV4 hdr opt */
} CmInetIpv4HdrParm;
typedef struct cmInetIpHdrParm
{
- U8 type;
+ uint8_t type;
union
{
CmInetIpv4HdrParm hdrParmIpv4; /* IPv4 header parameters */
typedef struct cmInetFdSetInfo
{
Bool initDone; /* Initialisation done */
- U32 numFds; /* Number of file descriptors scanned */
+ uint32_t numFds; /* Number of file descriptors scanned */
} CmInetFdSetInfo;
#else
#if (defined(SUNOS) || defined(SS_LINUX) || defined(SS_VW) || defined(HPOS))
{
Bool initDone; /* Initialisation done */
Bool bigEndian; /* Big endian architecture */
- U16 arIdx; /* Current index in fd_set array */
- U32 numArElems; /* Number of array elements */
- U8 ar[256]; /* Array of bit positions */
+ uint16_t arIdx; /* Current index in fd_set array */
+ uint32_t numArElems; /* Number of array elements */
+ uint8_t ar[256]; /* Array of bit positions */
} CmInetFdSetInfo;
#endif /* SUNOS || SS_LINUX || SS_VW */
#endif /* WIN32 */
#ifdef CM_LKSCTP
typedef struct cmInetSctpSndRcvInfo
{
- U16 stream;
- U16 ssn;
- U16 flags;
- U32 ppid;
- U32 context;
- U32 timetolive;
- U32 tsn;
- U32 cumtsn;
- U32 assocId;
+ uint16_t stream;
+ uint16_t ssn;
+ uint16_t flags;
+ uint32_t ppid;
+ uint32_t context;
+ uint32_t timetolive;
+ uint32_t tsn;
+ uint32_t cumtsn;
+ uint32_t assocId;
} CmInetSctpSndRcvInfo;
typedef struct cmInetSctpNotification
{
struct
{
- U16 nType;
- U16 nFlags;
- U32 nLen;
+ uint16_t nType;
+ uint16_t nFlags;
+ uint32_t nLen;
} header;
union
{
struct
{
- U16 state;
- U16 error;
- U16 outStreams;
- U16 inStreams;
- U32 assocId;
- U8 *info;
+ uint16_t state;
+ uint16_t error;
+ uint16_t outStreams;
+ uint16_t inStreams;
+ uint32_t assocId;
+ uint8_t *info;
}assocChange;
struct
{
CmInetNetAddr addr;
S32 state;
S32 error;
- U32 assocId;
+ uint32_t assocId;
}paddrChange;
struct
{
- U16 error;
- U32 assocId;
- U8 *data;
+ uint16_t error;
+ uint32_t assocId;
+ uint8_t *data;
}remoteErr;
struct
{
- U32 error;
+ uint32_t error;
CmInetSctpSndRcvInfo info;
- U32 assocId;
- U8 *data;
+ uint32_t assocId;
+ uint8_t *data;
}sndFailed;
struct
{
- U32 assocId;
+ uint32_t assocId;
}shutdownEvt;
struct
{
- U32 adaptationInd;
- U32 assocId;
+ uint32_t adaptationInd;
+ uint32_t assocId;
}adaptationEvt;
struct
{
- U32 indication;
- U32 assocId;
+ uint32_t indication;
+ uint32_t assocId;
}pdapiEvt;
}u;
}CmInetSctpNotification;
typedef struct cmInetSockLinger
{
Bool enable;
- U32 lingerTime;
+ uint32_t lingerTime;
} CmInetSockLinger;
typedef struct cmInetSctpSockEvent
typedef struct cmInetSctpPeerAddrParams
{
- U32 assocId;
+ uint32_t assocId;
struct
{
Bool addrPres;
CmInetNetAddr addr;
- U16 port;
+ uint16_t port;
}s;
- U32 pathMaxRxt;
- U32 pathMtu;
- U32 sackDelay;
- U8 pmtudFlag;
- U8 sackDelayFlag;
- U8 hbEnblFlag;
- U32 hbInterval;
+ uint32_t pathMaxRxt;
+ uint32_t pathMtu;
+ uint32_t sackDelay;
+ uint8_t pmtudFlag;
+ uint8_t sackDelayFlag;
+ uint8_t hbEnblFlag;
+ uint32_t hbInterval;
} CmInetSctpPeerAddrParams;
typedef struct cmInetSctpPrimAddr
{
- U32 assocId;
+ uint32_t assocId;
CmInetNetAddr addr;
- U16 port;
+ uint16_t port;
}CmInetSctpPrimAddr;
typedef struct cmInetSctpPeerAddrInfo
{
- U32 assocId;
+ uint32_t assocId;
CmInetNetAddr addr;
- U16 port;
+ uint16_t port;
Bool isActive;
- U32 cwnd;
- U32 srtt;
- U32 rto;
- U32 mtu;
+ uint32_t cwnd;
+ uint32_t srtt;
+ uint32_t rto;
+ uint32_t mtu;
}CmInetSctpPeerAddrInfo;
typedef struct cmInetSctpStatus
{
- U32 assocId;
+ uint32_t assocId;
S32 state;
- U32 rwnd;
- U16 unackdata;
- U16 penddata;
- U16 instrms;
- U16 outstrms;
- U32 fragPoint;
+ uint32_t rwnd;
+ uint16_t unackdata;
+ uint16_t penddata;
+ uint16_t instrms;
+ uint16_t outstrms;
+ uint32_t fragPoint;
CmInetSctpPeerAddrInfo primary;
}CmInetSctpStatus;
HBeat value Max retransmissions (Init, Path, Association)*/
typedef struct cmInetSctpRtoInfo
{
- U32 assocId;
- U32 rtoInitial;
- U32 rtoMax;
- U32 rtoMin;
+ uint32_t assocId;
+ uint32_t rtoInitial;
+ uint32_t rtoMax;
+ uint32_t rtoMin;
}CmInetSctpRtoInfo;
typedef struct cmInetSctpInitMsg
{
- U16 maxInitReTx;
- U16 maxInitTimeout;
- U16 maxInstreams;
- U16 numOstreams;
+ uint16_t maxInitReTx;
+ uint16_t maxInitTimeout;
+ uint16_t maxInstreams;
+ uint16_t numOstreams;
}CmInetSctpInitMsg;
typedef struct cmInetSctpAssocParams
{
- U32 assocId;
- U16 assocMaxReTx;
- U16 numberOfPeerDest;
- U32 peerRwnd;
- U32 localRwnd;
- U32 cookieLife;
+ uint32_t assocId;
+ uint16_t assocMaxReTx;
+ uint16_t numberOfPeerDest;
+ uint32_t peerRwnd;
+ uint32_t localRwnd;
+ uint32_t cookieLife;
}CmInetSctpAssocParams;
#endif
#ifdef CM_INET2
#ifdef IPV6_SUPPORTED
-EXTERN S16 cmInetSocket ARGS((U8 type, CmInetFd *sockFd, U8 protocol,
- U8 family));
+EXTERN S16 cmInetSocket ARGS((uint8_t type, CmInetFd *sockFd, uint8_t protocol,
+ uint8_t family));
#else
-EXTERN S16 cmInetSocket ARGS((U8 type, CmInetFd *sockFd, U8 protocol));
+EXTERN S16 cmInetSocket ARGS((uint8_t type, CmInetFd *sockFd, uint8_t protocol));
#endif /* IPV6_SUPPORTED */
#else /* CM_INET2 */
-EXTERN S16 cmInetSocket ARGS((U8 type, CmInetFd *sockFd));
+EXTERN S16 cmInetSocket ARGS((uint8_t type, CmInetFd *sockFd));
#endif /* CM_INET2 */
/* cm_inet_x_001.main_22 1. Added new interface - cmInetFlushRecvBuf()
#endif /* IPV6_OPTS_SUPPORTED */
EXTERN S16 cmInetPeek ARGS((CmInetFd *sockFd, CmInetAddr *fromAddr,
CmInetMemInfo *info, MsgLen dataPos,
- MsgLen dataLen, U8 *data));
+ MsgLen dataLen, uint8_t *data));
/* cm_inet_x_001.main_26: Added new function declaration cmInetPeekNew() */
EXTERN S16 cmInetPeekNew ARGS((CmInetFd *sockFd, CmInetAddr *fromAddr,
CmInetMemInfo *info, MsgLen dataPos,
- MsgLen dataLen, U8 *data));
+ MsgLen dataLen, uint8_t *data));
EXTERN S16 cmInetClose ARGS((CmInetFd *sockFd));
EXTERN S16 cmInetShutdown ARGS((CmInetFd *sockFd, S32 howTo));
EXTERN S16 cmInetSelect ARGS((CmInetFdSet *readFdS, CmInetFdSet *writeFdS,
- U32 *mSecTimeout, S16 *numFdS));
-EXTERN S16 cmInetSetOpt ARGS((CmInetFd *sockFd, U32 level, U32 type,
+ uint32_t *mSecTimeout, S16 *numFdS));
+EXTERN S16 cmInetSetOpt ARGS((CmInetFd *sockFd, uint32_t level, uint32_t type,
Ptr value));
-EXTERN S16 cmInetGetNumRead ARGS((CmInetFd *sockFd, U32 *dataLen));
+EXTERN S16 cmInetGetNumRead ARGS((CmInetFd *sockFd, uint32_t *dataLen));
#ifndef SS_PS
EXTERN S16 cmInetGetHostByName ARGS((S8 *hostName, CmInetIpAddrTbl *addrTbl));
EXTERN S16 cmInetGetIpNodeByName ARGS((S8 *hostName, CmInetIpAddrArr *addrArr));
EXTERN S16 cmInetDeInit ARGS((Void));
EXTERN S16 cmInetGetSockName ARGS((CmInetFd *sockFd, CmInetAddr *locAddr));
-EXTERN S16 cmInetConvertStrToIpAddr ARGS((U16 len, U8 *val,
+EXTERN S16 cmInetConvertStrToIpAddr ARGS((uint16_t len, uint8_t *val,
CmInetNetAddr *address));
-EXTERN S16 cmInetAsciiToIpv4 ARGS((U8 numBytes, U8 *ipv4Addr,
- U16 len, U8 *val));
+EXTERN S16 cmInetAsciiToIpv4 ARGS((uint8_t numBytes, uint8_t *ipv4Addr,
+ uint16_t len, uint8_t *val));
/* cm_inet_x_001.main_29 Poll Implementation Changes */
-EXTERN S16 cmInetPoll ARGS((CmInetPollFd *pollFdArr,U32 idx,S16 *numFdS,U32 timeout));
-EXTERN S16 cmInetPollSetFd ARGS((CmInetFd *sockFd,CmInetPollFd *pollFdArr,S16 idx, U16 eventMask));
-EXTERN S16 cmInetPollFdIsSet ARGS((CmInetPollFd *pollFdArr, S16 idx, U16 eventMask));
-EXTERN S16 cmInetPollClearFdREvent ARGS((CmInetPollFd *pollFdArr, S16 idx, U16 eventMask));
-EXTERN S16 cmInetPollClearFdEvent ARGS((CmInetPollFd *pollFdArr,S16 idx, U16 eventMask));
+EXTERN S16 cmInetPoll ARGS((CmInetPollFd *pollFdArr,uint32_t idx,S16 *numFdS,uint32_t timeout));
+EXTERN S16 cmInetPollSetFd ARGS((CmInetFd *sockFd,CmInetPollFd *pollFdArr,S16 idx, uint16_t eventMask));
+EXTERN S16 cmInetPollFdIsSet ARGS((CmInetPollFd *pollFdArr, S16 idx, uint16_t eventMask));
+EXTERN S16 cmInetPollClearFdREvent ARGS((CmInetPollFd *pollFdArr, S16 idx, uint16_t eventMask));
+EXTERN S16 cmInetPollClearFdEvent ARGS((CmInetPollFd *pollFdArr,S16 idx, uint16_t eventMask));
EXTERN S16 cmInetPollDelFd ARGS((CmInetPollFd *pollFdArr, S16 delIdx, S16 crntIdx));
EXTERN S16 cmInetPollInitFdArr ARGS((CmInetPollFd *pollFdArr));
-EXTERN S16 cmInetNtop ARGS((U8 type,Void *address,S8 *asciiAddr,U32 len));
+EXTERN S16 cmInetNtop ARGS((uint8_t type,Void *address,S8 *asciiAddr,uint32_t len));
#ifdef CM_LKSCTP
EXTERN S16 cmInetSctpBindx ARGS((CmInetFd *sockFd,
CmInetNetAddrLst *addrLst,
- U16 port));
+ uint16_t port));
EXTERN S16 cmInetSctpConnectx ARGS((CmInetFd *sockFd, CmInetNetAddr *primAddr,
CmInetNetAddrLst *addrLst,
- U16 port));
-EXTERN S16 cmInetSctpPeelOff ARGS((CmInetFd *sockFd, U32 assocId,
+ uint16_t port));
+EXTERN S16 cmInetSctpPeelOff ARGS((CmInetFd *sockFd, uint32_t assocId,
CmInetFdType *assocFd));
EXTERN S16 cmInetSctpSendMsg ARGS((CmInetFd *sockFd, CmInetNetAddr *dstAddr,
- U16 port, CmInetMemInfo *info,
- Buffer *mBuf, MsgLen *len, U16 strmId,
- Bool unorderFlg, U16 ttl, U32 ppId,
- U32 context));
+ uint16_t port, CmInetMemInfo *info,
+ Buffer *mBuf, MsgLen *len, uint16_t strmId,
+ Bool unorderFlg, uint16_t ttl, uint32_t ppId,
+ uint32_t context));
EXTERN S16 cmInetSctpRecvMsg ARGS((CmInetFd *sockFd, CmInetNetAddr *srcAddr,
- U16 *port, CmInetMemInfo *info,
+ uint16_t *port, CmInetMemInfo *info,
Buffer **mBuf, MsgLen *len,
- CmInetSctpSndRcvInfo *sinfo, U32 *flag,
+ CmInetSctpSndRcvInfo *sinfo, uint32_t *flag,
CmInetSctpNotification *ntfy));
-EXTERN S16 cmInetSctpGetPAddrs ARGS((CmInetFd *sockFd, U32 assocId,
+EXTERN S16 cmInetSctpGetPAddrs ARGS((CmInetFd *sockFd, uint32_t assocId,
CmInetNetAddrLst *addrlst));
-EXTERN S16 cmInetGetOpt ARGS((CmInetFd *sockFd, U32 level, U32 type,
+EXTERN S16 cmInetGetOpt ARGS((CmInetFd *sockFd, uint32_t level, uint32_t type,
Ptr value));
/*cm_inet_x_001.main_25: Added new funcion */
*
*/
#ifdef ANSI
-U8 *cmMemcpy
+uint8_t *cmMemcpy
(
-U8 *tgt,
-CONSTANT U8 *src,
+uint8_t *tgt,
+CONSTANT uint8_t *src,
PTR len
)
#else
-U8 *cmMemcpy(tgt, src, len)
-U8 *tgt;
-CONSTANT U8 *src;
+uint8_t *cmMemcpy(tgt, src, len)
+uint8_t *tgt;
+CONSTANT uint8_t *src;
PTR len;
#endif
{
#ifdef MS_MBUF_CORRUPTION /* checking for valid memory address */
if ((tgt > startPtr128) && (tgt < (startPtr128+regMemSize)))
{
- if ((*((U32 *)(tgt + 4)) == 0xDEADDEAD) || (*((U32 *)(tgt + 24)) == 0xDEADDEAD) ||
- (*((U32 *)(tgt + 44)) == 0xDEADDEAD) || (*((U32 *)(tgt + 80)) == 0xDEADDEAD))
+ if ((*((uint32_t *)(tgt + 4)) == 0xDEADDEAD) || (*((uint32_t *)(tgt + 24)) == 0xDEADDEAD) ||
+ (*((uint32_t *)(tgt + 44)) == 0xDEADDEAD) || (*((uint32_t *)(tgt + 80)) == 0xDEADDEAD))
{
Data *crashPtr=NULLP;
*crashPtr = 9;
}
if ((src > startPtr128) && (src < (startPtr128+regMemSize)))
{
- if ((*((U32 *)(src + 4)) == 0xDEADDEAD) || (*((U32 *)(src + 24)) == 0xDEADDEAD) ||
- (*((U32 *)(src + 44)) == 0xDEADDEAD) || (*((U32 *)(src + 80)) == 0xDEADDEAD))
+ if ((*((uint32_t *)(src + 4)) == 0xDEADDEAD) || (*((uint32_t *)(src + 24)) == 0xDEADDEAD) ||
+ (*((uint32_t *)(src + 44)) == 0xDEADDEAD) || (*((uint32_t *)(src + 80)) == 0xDEADDEAD))
{
Data *crashPtr=NULLP;
*crashPtr = 9;
#ifdef ANSI
S16 cmMemcmp
(
-CONSTANT U8 *s1,
-CONSTANT U8 *s2,
+CONSTANT uint8_t *s1,
+CONSTANT uint8_t *s2,
PTR len
)
#else
S16 cmMemcmp (s1, s2, len)
-CONSTANT U8 *s1;
-CONSTANT U8 *s2;
+CONSTANT uint8_t *s1;
+CONSTANT uint8_t *s2;
PTR len;
#endif
{
*
*/
#ifdef ANSI
-U8 *cmMemset
+uint8_t *cmMemset
(
-U8 *str,
-U8 val,
+uint8_t *str,
+uint8_t val,
PTR len
)
#else
-U8 *cmMemset(str, val, len)
-U8 *str;
-U8 val;
+uint8_t *cmMemset(str, val, len)
+uint8_t *str;
+uint8_t val;
PTR len;
#endif
{
#if MS_MBUF_CORRUPTION /* checking for valid memory address */
if ((str > startPtr128) && (str < (startPtr128+regMemSize)))
{
- if ((*((U32 *)(str + 4)) == 0xDEADDEAD) || (*((U32 *)(str + 24)) == 0xDEADDEAD) ||
- (*((U32 *)(str + 44)) == 0xDEADDEAD) || (*((U32 *)(str + 80)) == 0xDEADDEAD))
+ if ((*((uint32_t *)(str + 4)) == 0xDEADDEAD) || (*((uint32_t *)(str + 24)) == 0xDEADDEAD) ||
+ (*((uint32_t *)(str + 44)) == 0xDEADDEAD) || (*((uint32_t *)(str + 80)) == 0xDEADDEAD))
{
Data *crashPtr=NULLP;
*crashPtr = 9;
#ifdef ANSI
S16 cmStrcmp
(
-CONSTANT U8 *s1,
-CONSTANT U8 *s2
+CONSTANT uint8_t *s1,
+CONSTANT uint8_t *s2
)
#else
S16 cmStrcmp (s1, s2)
-CONSTANT U8 *s1;
-CONSTANT U8 *s2;
+CONSTANT uint8_t *s1;
+CONSTANT uint8_t *s2;
#endif
{
/*cm_lib_c_001.main_14 : Fix for TRACE5 feature crash due to missing TRC MACRO*/
#ifdef ANSI
S16 cmStrncmp
(
-CONSTANT U8 *s1,
-CONSTANT U8 *s2,
+CONSTANT uint8_t *s1,
+CONSTANT uint8_t *s2,
MsgLen len /* cm_lib_c_001.main_12: Changing from S16 to MsgLen.*/
)
#else
S16 cmStrncmp (s1, s2, len)
-CONSTANT U8 *s1;
-CONSTANT U8 *s2;
+CONSTANT uint8_t *s1;
+CONSTANT uint8_t *s2;
MsgLen len;
#endif
{
#ifdef ANSI
MsgLen cmStrlen
(
-CONSTANT U8 *s
+CONSTANT uint8_t *s
)
#else
/* cm_lib_c_001.main_12: Changing from S16 to MsgLen.*/
MsgLen cmStrlen (s)
-CONSTANT U8 *s;
+CONSTANT uint8_t *s;
#endif
{
#if (STRLEN_AVAIL)
extern "C" {
#endif
-U8 *cmMemcpy ARGS((U8 *tgt, CONSTANT U8 *src, PTR len));
-S16 cmMemcmp ARGS((CONSTANT U8 *s1, CONSTANT U8 *s2, PTR len));
-U8 *cmMemset ARGS((U8 *src, U8 val, PTR len));
+uint8_t *cmMemcpy ARGS((uint8_t *tgt, CONSTANT uint8_t *src, PTR len));
+S16 cmMemcmp ARGS((CONSTANT uint8_t *s1, CONSTANT uint8_t *s2, PTR len));
+uint8_t *cmMemset ARGS((uint8_t *src, uint8_t val, PTR len));
-S16 cmStrcmp ARGS((CONSTANT U8 *s1, CONSTANT U8 *s2));
+S16 cmStrcmp ARGS((CONSTANT uint8_t *s1, CONSTANT uint8_t *s2));
/* cm_lib_x_001.main_8:Changing from S16 to MsgLen.*/
-S16 cmStrncmp ARGS((CONSTANT U8 *s1, CONSTANT U8 *s2, MsgLen len));
-MsgLen cmStrlen ARGS((CONSTANT U8 *s));
+S16 cmStrncmp ARGS((CONSTANT uint8_t *s1, CONSTANT uint8_t *s2, MsgLen len));
+MsgLen cmStrlen ARGS((CONSTANT uint8_t *s));
#ifdef __cplusplus
}
lCp->crnt = (CmLList *)NULLP;
lCp->count = 0;
- RETVOID;
+ return;
} /* end of cmLListInit */
\f
#ifdef ERRCHK
if (lCp == (CmLListCp *)NULLP)
- RETVOID;
+ return;
#endif
lCp->count++;
if (!node->next)
{
lCp->last = node;
- RETVOID;
+ return;
}
node->next->prev = node;
- RETVOID;
+ return;
} /* end of cmLListAdd2Head */
#ifdef ERRCHK
if (lCp == (CmLListCp *)NULLP)
- RETVOID;
+ return;
#endif
lCp->count++;
if (!node->prev)
{
lCp->first = node;
- RETVOID;
+ return;
}
node->prev->next = node;
- RETVOID;
+ return;
} /* end of cmLListAdd2Tail */
\f
#ifdef ERRCHK
if (!lCp)
- RETVOID;
+ return;
#endif
lCp->count++;
{
lCp->crnt = lCp->first = lCp->last = node;
node->next = NULLP;
- RETVOID;
+ return;
}
node->next = lCp->crnt;
lCp->first = node;
lCp->crnt = node;
- RETVOID;
+ return;
} /* end of cmLListInsCrnt */
\f
/* cm_llist_c_001.main_7 - Add function */
#ifdef ERRCHK
if (!lCp)
- RETVOID;
+ return;
#endif
lCp->count++;
if (lCp->count == 1)
{
lCp->crnt = lCp->first = lCp->last = node;
- RETVOID;
+ return;
}
node->prev = lCp->crnt;
lCp->last = node;
lCp->crnt = node;
- RETVOID;
+ return;
} /* end of cmLListInsAfterCrnt */
/*-- if the second list is empty nothing to do --*/
if(list2->count == 0)
{
- RETVOID;
+ return;
}
/*-- if the first list is empty make first the same as second*/
cmLListInit(list2);
- RETVOID;
+ return;
} /*-- end of cmLListCatLList --*/
/**********************************************************************
CmLList *first; /* first entry in list */
CmLList *last; /* last entry in list */
CmLList *crnt; /* entry last accessed */
- U32 count; /* number of entries */
+ uint32_t count; /* number of entries */
};
EXTERN Void cmLListInit ARGS ((CmLListCp *lList));
/* public variable declarations */
-U32 cmLteTime;
+uint32_t cmLteTime;
\f
/***********************************************************
CmLteMemInfo *mInfo;
#endif
{
- U8 numReg = 0;
- U8 numPool = 0;
- U8 idxReg;
- U8 idxPool;
+ uint8_t numReg = 0;
+ uint8_t numPool = 0;
+ uint8_t idxReg;
+ uint8_t idxPool;
SsMemDbgInfo dbgInfo;
SGetRegPoolInfo(&numReg,&numPool);
CmLteMemInfo *memInfo;
#endif
{
- U8 idxReg = 0;
- U8 idxPool = 0;
- U8 numPool = 0;
+ uint8_t idxReg = 0;
+ uint8_t idxPool = 0;
+ uint8_t numPool = 0;
memoryInfo->numRegions = memInfo->numRegions;
for(idxReg=0; idxReg < memInfo->numRegions; idxReg++)
CmLteMemInfo *memInfo;
#endif
{
- U8 idxReg = 0;
- U8 idxPool = 0;
- U8 numPool = 0;
+ uint8_t idxReg = 0;
+ uint8_t idxPool = 0;
+ uint8_t numPool = 0;
for(idxReg=0; idxReg < memInfo->numRegions; idxReg++)
{
memInfo->regInfo[idxReg].regionId = 0;
CmCpuStatsInfo *cpuInfo
#endif
{
- U8 idx= 0;
+ uint8_t idx= 0;
for(idx=0; idx < cpuInfo->numCores; idx++)
{
cpuInfo->cpuUtil[idx].maxCpuUtil = 0;
CmCpuStatsInfo *cpuInfo;
#endif
{
- U8 idx= 0;
+ uint8_t idx= 0;
cpuMeasInfo->numCores = cpuInfo->numCores;
for(idx=0; idx < cpuInfo->numCores; idx++)
{
CmTtiProc ttiProc;
#define TTI_1MS 950
-Void cmUpdateTtiCounters(U32 ttiProcessingTime)
+Void cmUpdateTtiCounters(uint32_t ttiProcessingTime)
{
ttiProc.numOfTti++;
ttiProc.totTtiProcessingTime += ttiProcessingTime;
{
ttiProc.ttiStretchCount++;
}
- RETVOID;
+ return;
}
Void cmResetTtiCounters(Void)
ttiProc.ttiStretchCount = 0;
ttiProc.ttiThresholdExceedCount = 0;
ttiProc.phyReptTtiStretchCount = 0;
- RETVOID;
+ return;
}
#endif
/* definitions for Common LTE */
/** @brief Radio Bearer ID */
-typedef U8 CmLteRbId;
+typedef uint8_t CmLteRbId;
/** @brief Cell ID */
-typedef U16 CmLteCellId;
+typedef uint16_t CmLteCellId;
/** @brief RNTI */
-typedef U16 CmLteRnti;
+typedef uint16_t CmLteRnti;
/** @brief Mode Type TM/UM/AM */
-typedef U8 CmLteRlcMode;
+typedef uint8_t CmLteRlcMode;
/** @brief Logical Channel ID */
-typedef U8 CmLteLcId;
+typedef uint8_t CmLteLcId;
/** @brief Logical Channel Type */
-typedef U8 CmLteLcType;
+typedef uint8_t CmLteLcType;
/** @brief Transport Channel Type */
-typedef U8 CmLteTrchType;
+typedef uint8_t CmLteTrchType;
/** @brief Contention Resolution ID */
-typedef U8 CmLteContResId[6];
+typedef uint8_t CmLteContResId[6];
/** @brief RLC ID */
typedef struct cmLteRlcId
{
CmLteRbId rbId; /*!< Radio Bearer ID */
- U8 rbType; /*!< RB Type */
+ uint8_t rbType; /*!< RB Type */
CmLteRnti ueId; /*!< UE ID */
CmLteCellId cellId; /*!< Cell ID */
}CmLteRlcId;
typedef struct cmLteTimingInfo
{
#if 0
- U16 hSfn; /*!< Hyper System Frame Number */
+ uint16_t hSfn; /*!< Hyper System Frame Number */
#endif
- U16 sfn; /*!< System Frame Number */
- U16 slot; /*!< Subframe number */
+ uint16_t sfn; /*!< System Frame Number */
+ uint16_t slot; /*!< Subframe number */
} CmLteTimingInfo;
/** @brief PDCP ID */
CmLteCellId cellId; /*!< Cell ID */
CmLteRnti ueId; /*!< UE ID */
CmLteRbId rbId; /*!< PDCP Instance ID */
- U8 rbType; /*!< RB type */
+ uint8_t rbType; /*!< RB type */
} CmLtePdcpId;
/* Defining structures for Memory Information for L2-MEAS */
typedef struct cmLtePoolInfo
{
- U32 poolSize;
- U32 totAvailable;
- U32 crntUsed;
- U32 maxUsed;
+ uint32_t poolSize;
+ uint32_t totAvailable;
+ uint32_t crntUsed;
+ uint32_t maxUsed;
} CmLtePoolInfo;
typedef struct cmLteRegionInfo
{
- U8 regionType; /* 0-SSI 1-Shared */
- U8 regionId;
- U8 numPools;
- U8 isGenMemInfoUpdated;
+ uint8_t regionType; /* 0-SSI 1-Shared */
+ uint8_t regionId;
+ uint8_t numPools;
+ uint8_t isGenMemInfoUpdated;
CmLtePoolInfo poolInfo[MAX_POOL_SIZE];
}CmLteRegionInfo;
typedef struct cmLteMemInfo
{
- U8 numRegions;
- U8 idx;
+ uint8_t numRegions;
+ uint8_t idx;
CmLteRegionInfo regInfo[MAX_REGION_SIZE];
}CmLteMemInfo;
/** @brief CPU Utilization INFO */
typedef struct cmLteCpuUtilInfo
{
- U32 avgCpuUtil; /*!< average cpu utilization */
- U32 maxCpuUtil; /*!< Max cpu utilization */
+ uint32_t avgCpuUtil; /*!< average cpu utilization */
+ uint32_t maxCpuUtil; /*!< Max cpu utilization */
}CmLteCpuUtilInfo;
/** @brief CPU INFO */
typedef struct cmLteCpuInfo
{
- U8 numCores; /*!< number of cores*/
+ uint8_t numCores; /*!< number of cores*/
CmLteCpuUtilInfo cpuUtil[CM_MAX_CPU_CORES]; /*!< cpu measurement info*/
}CmLteCpuInfo;
/** @brief CPU Utilization INFO */
typedef struct cmCpuUtilStatsInfo
{
- U32 numSamples;
- U32 maxCpuUtil; /*!< Max cpu utilization */
- U32 totCpuUtil; /*!< Total cpu utilization */
+ uint32_t numSamples;
+ uint32_t maxCpuUtil; /*!< Max cpu utilization */
+ uint32_t totCpuUtil; /*!< Total cpu utilization */
}CmCpuUtilStatsInfo;
/** @brief CPU INFO */
typedef struct cmCpuStatsInfo
{
- U8 numCores; /*!< number of cores*/
+ uint8_t numCores; /*!< number of cores*/
CmCpuUtilStatsInfo cpuUtil[CM_MAX_CPU_CORES]; /*!< cpu measurement info*/
}CmCpuStatsInfo;
/** @brief Counter Statistics */
-typedef U32 CntrSts;
+typedef uint32_t CntrSts;
/** @brief Aggregation Level */
typedef enum cmLteAggrLvl
EXTERN S16 cmFillMemUtilizationMeas(CmLteMemInfo *memoryInfo,CmLteMemInfo *memInfo);
EXTERN S16 cmClearMemUtilizationCounter(CmLteMemInfo *memInfo);
-EXTERN S16 UpdateSocMemInfo(U8 area , CmLteMemInfo *mInfo);
+EXTERN S16 UpdateSocMemInfo(uint8_t area , CmLteMemInfo *mInfo);
EXTERN S16 cmFillCpuUtilizationMeas(CmLteCpuInfo *cpuMeasInfo,CmCpuStatsInfo *cpuInfo);
EXTERN S16 cmClearCpuUtilizationCounter(CmCpuStatsInfo *cpuInfo);
-EXTERN Void UpdateSocCpuInfo(CmCpuStatsInfo *cpuInfo,U8 Idx);
+EXTERN Void UpdateSocCpuInfo(CmCpuStatsInfo *cpuInfo,uint8_t Idx);
-EXTERN S16 SGetRegPoolInfo(U8* numRegion, U8* numPool);
+EXTERN S16 SGetRegPoolInfo(uint8_t* numRegion, uint8_t* numPool);
/* Packing Functions */
EXTERN S16 cmPkLteRlcId ARGS ((
typedef struct cmTtiProc
{
- U32 totTtiProcessingTime;
- U32 numOfTti;
- U32 maxTtiProcessingTime;
- U32 ttiStretchCount;
- U32 ttiThresholdExceedCount;
+ uint32_t totTtiProcessingTime;
+ uint32_t numOfTti;
+ uint32_t maxTtiProcessingTime;
+ uint32_t ttiStretchCount;
+ uint32_t ttiThresholdExceedCount;
/* this count is added to compare phy reported tti stretch and calculated tti stretch */
- U32 phyReptTtiStretchCount;
+ uint32_t phyReptTtiStretchCount;
}CmTtiProc;
EXTERN CmTtiProc ttiProc;
-EXTERN Void cmUpdateTtiCounters(U32 ttiProcessingTime);
+EXTERN Void cmUpdateTtiCounters(uint32_t ttiProcessingTime);
EXTERN Void cmResetTtiCounters(Void);
#endif
*
*/
#ifdef ANSI
-U32 cmAbs
+uint32_t cmAbs
(
F64 val
)
#else
-U32 cmAbs(val)
+uint32_t cmAbs(val)
F64 val;
#endif
{
#if (defined(SUNOS)|| defined(WIN32)|| defined(WIN2K)|| defined (SS_LINUX))
- return ((U32) abs((int) val));/* G++ */
+ return ((uint32_t) abs((int) val));/* G++ */
#endif
} /* end of cmAbs */
#endif /* SS_FLOAT */
#include <math.h>
/* Math library function prototypes */
-EXTERN U32 cmAbs ARGS((F64 val));
+EXTERN uint32_t cmAbs ARGS((F64 val));
EXTERN F64 cmPow ARGS((F64 x, F64 y));
EXTERN F64 cmFloor ARGS((F64 x));
EXTERN F64 cmLog ARGS((F64 x));
EXTERN pthread_t tmpRegTidMap[20];
#define CM_MEM_GET_REGION(_region) \
{ \
- U8 _regCnt; \
+ uint8_t _regCnt; \
_region = 0xFF; \
\
for(_regCnt = 0; _regCnt < 12; _regCnt++) \
/* Intialise Memory Control Point */
CM_INIT_MEMCP(memCp,maxBlkSize,sMem);
- RETVOID;
+ return;
} /* End of cmInitMemCp */
{
/* if a chunk is already there */
if( (cb->memAllocated + size) <=
- (U32)(cb->maxSize + sizeof(CmMemList)) )
+ (uint32_t)(cb->maxSize + sizeof(CmMemList)) )
{
/* Requested memory is available in present chunk */
*allocPtr = (Ptr) cb->runPtr;
{
/* if a chunk is already there */
if( (cb->memAllocated + size) <=
- (U32)(cb->maxSize + sizeof(CmMemList)) )
+ (uint32_t)(cb->maxSize + sizeof(CmMemList)) )
{
/* Requested memory is available in present chunk */
*allocPtr = (Ptr) cb->runPtr;
- //memset(*allocPtr, (U8 )0,
+ //memset(*allocPtr, (uint8_t )0,
// (PTR)(size) );
cb->memAllocated += size;
cb->runPtr += size;
count--;
}
- RETVOID;
+ return;
} /* End of cmFreeMem */
if (!node->prev)
{
lCp->first = node;
- RETVOID;
+ return;
}
node->prev->next = node;
- RETVOID;
+ return;
} /* end of cmAddMemNode */
status->maxBlkSize = memCp->memCb.maxSize;
status->memAllocated = memCp->memCb.memAllocated;
- RETVOID;
+ return;
} /* End of cmGetMemStatus */
{
Size maxSize; /* Size of memory chunk */
Mem sMem; /* Static memory region and pool */
- U32 memAllocated; /* amount of memory already allocated */
+ uint32_t memAllocated; /* amount of memory already allocated */
PTR initPtr; /* Initial pointer */
PTR runPtr; /* Start of avaliable memory chunk */
} CmMemCb;
{
CmMemList *first; /* first entry in list */
CmMemList *last; /* last entry in list */
- U32 count; /* number of entries */
+ uint32_t count; /* number of entries */
CmMemCb memCb; /* Memory Control Block */
}CmMemListCp;
typedef struct cmMemStatus
{
Mem sMem; /* Static Memory region,pool */
- U32 memBlkCnt; /* Memory Blocks Count */
+ uint32_t memBlkCnt; /* Memory Blocks Count */
Size maxBlkSize; /* Size of memory Block */
Size memAllocated; /* Memory allocated off chunk */
} CmMemStatus;
#ifdef SS_LIGHT_MEM_LEAK_STS
MemLeakCb gmemLkCb;
- U32 queueIndxAllocCnt =0;
- U32 queueIndxFreeCnt =0;
- U32 allocQueueFullCnt =0;
- U32 allocQueueEmptyCnt =0;
+ uint32_t queueIndxAllocCnt =0;
+ uint32_t queueIndxFreeCnt =0;
+ uint32_t allocQueueFullCnt =0;
+ uint32_t allocQueueEmptyCnt =0;
#endif
\f
/* local defines */
#endif
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
-U32 memFreeCount=0;
-U32 cmFreeCaller[4]={0};
-U32 cmAllocCaller[4]={0};
+uint32_t memFreeCount=0;
+uint32_t cmFreeCaller[4]={0};
+uint32_t cmAllocCaller[4]={0};
Data *startPtr256=NULLP;
Data *startPtr128=NULLP;
-U32 cmMemInfo128[100000][2]={0, 0};
-U32 cmMemInfo256[100000][2]={0, 0};
+uint32_t cmMemInfo128[100000][2]={0, 0};
+uint32_t cmMemInfo256[100000][2]={0, 0};
Data *startPtr512=NULLP;
Data *startPtr768=NULLP;
Data *startPtr1664=NULLP;
#endif
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef SSI_DEBUG_LEVEL1
-PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr,
- U32 memType, U32 line, U8 *fileName, U8 entId, Bool hstReg));
-PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size, U32 memType, U32 line, U8 *fileName, U8 entId, Bool hstReg));
+PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr,
+ uint32_t memType, uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg));
+PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size, uint32_t memType, uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg));
/*cm_mem_c_001.main_20-added new functionto allocate memory from new region*/
#else
PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size,
- U32 line, U8 *fileName, U8 entId, Bool hstReg));
-PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr,
- U32 line, U8 *fileName, U8 entId, Bool hstReg));
+ uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg));
+PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr,
+ uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg));
#endif /* SSI_DEBUG_LEVEL1 */
-PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, U32 line,
- U8 *fileName, U8 entId, Bool hstReg));
+PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, uint32_t line,
+ uint8_t *fileName, uint8_t entId, Bool hstReg));
PRIVATE S16 cmHeapFree ARGS((CmMmHeapCb *heapCb, Data *ptr, Size size,
- U32 line, U8 *fileName, U8 entId, Bool hstReg));
+ uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg));
#else /* no histogram support */
/* cm_mem_c_001.main_12 - prototype is changed to accept memType(static/dynamic) */
#ifdef SSI_DEBUG_LEVEL1
-PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size, U32 memType));
+PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size, uint32_t memType));
#else
#ifndef USE_PURE
PRIVATE S16 cmHeapAlloc ARGS((CmMmHeapCb *heapCb, Data **ptr, Size *size));
#endif/*USE_PURE*/
/* cm_mem_c_001.main_15 :Additions */
#ifdef SS_LIGHT_MEM_LEAK_STS
-PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, U32 memType, U32 lineNo,U8 *funcName ));
-PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, U32 lineNo, U8* funcName));
+PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, uint32_t memType, uint32_t lineNo,uint8_t *funcName ));
+PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, uint32_t lineNo, uint8_t* funcName));
#else /*SS_LIGHT_MEM_LEAK_STS */
#if (defined(SSI_DEBUG_LEVEL1) || defined(BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1))
-PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, U32 memType));
+PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, uint32_t memType));
#else
#ifdef T2K_MEM_LEAK_DBG
-PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, char* file, U32 line));
+PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, char* file, uint32_t line));
#else
-PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr));
+PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr));
#endif
#endif /* SSI_DEBUG_LEVEL1 */
#ifdef T2K_MEM_LEAK_DBG
-PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, char* file, U32 line));
+PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size, char* file, uint32_t line));
#else
PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size));
#endif
#endif /*SS_LIGHT_MEM_LEAK_STS*/
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
#ifdef SS_FAP
-PRIVATE S16 cmAllocWL ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr));
+PRIVATE S16 cmAllocWL ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr));
PRIVATE S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size));
#endif
PRIVATE Void cmMmHeapInit ARGS((Data *memAddr, CmMmHeapCb *heapCb, Size size));
PRIVATE Void cmMmBktInit ARGS((Data **memAddr, CmMmRegCb *regCb,
- CmMmRegCfg *cfg, U16 bktIdx, U16 *lstMapIdx));
+ CmMmRegCfg *cfg, uint16_t bktIdx, uint16_t *lstMapIdx));
/* cm_mem_c_001.main_12 - addition of protoypes for sanity check and hash list functions */
#ifdef SSI_DEBUG_LEVEL1
PRIVATE S16 cmMmBktSanityChk ARGS((CmMmBkt *bkt));
PRIVATE S16 cmMmHeapSanityChk ARGS((CmMmHeapCb *heapCb));
-PRIVATE S16 cmMmHashFunc ARGS((CmMmHashListCp *hashListCp, U32 key, U16 *idx ));
-PRIVATE S16 cmMmHashListInit ARGS((CmMmHashListCp *hashListCp, U16 nmbBins,
+PRIVATE S16 cmMmHashFunc ARGS((CmMmHashListCp *hashListCp, uint32_t key, uint16_t *idx ));
+PRIVATE S16 cmMmHashListInit ARGS((CmMmHashListCp *hashListCp, uint16_t nmbBins,
Region region, Pool pool));
PRIVATE S16 cmMmHashListDeinit ARGS((CmMmHashListCp *hashListCp, Region region, Pool pool));
-PRIVATE S16 cmMmHashListInsert ARGS((CmMmHashListCp *hashListCp, U32 key));
+PRIVATE S16 cmMmHashListInsert ARGS((CmMmHashListCp *hashListCp, uint32_t key));
#endif /* SSI_DEBUG_LEVEL1 */
/* cm_mem_c_001.main_15 : Addtions */
#ifdef SS_HISTOGRAM_SUPPORT
-PRIVATE S16 cmHstGrmAllocInsert ARGS((CmHstGrmHashListCp *hashListCp, U32 blkSz, U32 *reqSz, U32 line, U8 *fileName, U8 entId));
-PRIVATE S16 cmHstGrmFreeInsert ARGS((CmHstGrmHashListCp* hashListCp, U32 blkSz, U32 line, U8 *fileName, U8 entId));
+PRIVATE S16 cmHstGrmAllocInsert ARGS((CmHstGrmHashListCp *hashListCp, uint32_t blkSz, uint32_t *reqSz, uint32_t line, uint8_t *fileName, uint8_t entId));
+PRIVATE S16 cmHstGrmFreeInsert ARGS((CmHstGrmHashListCp* hashListCp, uint32_t blkSz, uint32_t line, uint8_t *fileName, uint8_t entId));
PRIVATE S16 cmHstGrmHashListInit ARGS((CmHstGrmHashListCp *hashListCp));
PRIVATE S16 cmHstGrmHashListDeInit ARGS((CmHstGrmHashListCp *hashListCp));
-PRIVATE S16 cmHstGrmGetHashIdxAndKey ARGS((U8 *fileName, U32 line, U32 *binIdx, U32 *key));
-PRIVATE S16 cmHstGrmFindEntry ARGS((CmHstGrmHashListCp *hashListCp, U32 key, U32 *binIdx, CmMemEntries **entry));
-PRIVATE S16 cmHstGrmFillEntry ARGS((CmMemEntries *entry, U32 key, U32 line, U8 *fileName, U8 entId));
+PRIVATE S16 cmHstGrmGetHashIdxAndKey ARGS((uint8_t *fileName, uint32_t line, uint32_t *binIdx, uint32_t *key));
+PRIVATE S16 cmHstGrmFindEntry ARGS((CmHstGrmHashListCp *hashListCp, uint32_t key, uint32_t *binIdx, CmMemEntries **entry));
+PRIVATE S16 cmHstGrmFillEntry ARGS((CmMemEntries *entry, uint32_t key, uint32_t line, uint8_t *fileName, uint8_t entId));
#endif /* SS_HISTOGRAM_SUPPORT */
/* cm_mem_c_001.main_22: Fixing warnings on GCC compiler */
#ifdef T2K_MEM_LEAK_DBG
typedef struct {
-U8 minBktSzBitMask; /* minimum allocation size in Log(x)base 2, where X is minimum bucket size in region */
-U16 minBktSzMins1; /* X-1 */
+uint8_t minBktSzBitMask; /* minimum allocation size in Log(x)base 2, where X is minimum bucket size in region */
+uint16_t minBktSzMins1; /* X-1 */
}RegMinBktSzInfo;
static RegMinBktSzInfo regMinBktSzInfo[SS_MAX_REGS] = {{8,0xFF},{7,0x7F},{7,0x7F},{7,0x7F}};
RegionMemLeakInfo regMemLeakInfo;
-U32 getT2kMemLeakIndex(U64 address, Region region)
+uint32_t getT2kMemLeakIndex(uint64_t address, Region region)
{
return ((address - regMemLeakInfo.regStartAddr[region]) >> regMinBktSzInfo[region].minBktSzBitMask);
}
-static U32 t2kMemAllocTick;
-static U32 smallTick;
+static uint32_t t2kMemAllocTick;
+static uint32_t smallTick;
-void InsertToT2kMemLeakInfo(U64 address, U32 size, U32 lineNo, char* fileName, Region region)
+void InsertToT2kMemLeakInfo(uint64_t address, uint32_t size, uint32_t lineNo, char* fileName, Region region)
{
T2kMeamLeakInfo *leakInfo;
/* if(!startMemLeak)
{
- RETVOID;
+ return;
}*/
- U32 index1 = getT2kMemLeakIndex(address,region);
+ uint32_t index1 = getT2kMemLeakIndex(address,region);
- if(((U64)(address - regMemLeakInfo.regStartAddr[region]) & regMinBktSzInfo[region].minBktSzMins1) !=0)
+ if(((uint64_t)(address - regMemLeakInfo.regStartAddr[region]) & regMinBktSzInfo[region].minBktSzMins1) !=0)
{
printf("address in InsertToT2kMemLeakInfo is %ld size = %d file is %s line is %d \n", address, size, fileName, lineNo);
}
}
-void RemoveFromT2kMemLeakInfo(U64 address, char *file, U32 line,Region region)
+void RemoveFromT2kMemLeakInfo(uint64_t address, char *file, uint32_t line,Region region)
{
T2kMeamLeakInfo *leakInfo;
return ROK;
}*/
- U32 index1 = getT2kMemLeakIndex(address, region);
+ uint32_t index1 = getT2kMemLeakIndex(address, region);
if(index1 >= T2K_MEM_LEAK_INFO_TABLE_SIZE)
{
/* cm_mem_c_008.104 - Addition for memory calculator tool */
#ifdef MEMCAL_DEBUG
PRIVATE Txt prntBuf[200]; /* print buffer */
-PRIVATE U8 tryHeap=0;
+PRIVATE uint8_t tryHeap=0;
#endif
/* cm_mem_c_001.main_12 - addition for ssi enhancements prints */
#endif /* DEBUGP */
#endif /*SSI_DEBUG_LEVEL1 || SS_HISTOGRAM_SUPPORT */
-U32 num_times = 0;
+uint32_t num_times = 0;
#ifdef SSI_MEM_CORR_PREVENTION
-U32 cmDblFreeAttempts = 0;
+uint32_t cmDblFreeAttempts = 0;
#endif
/* private variable declarations */
#endif
{
Data *memAddr;
- U16 bktIdx;
- U16 lstMapIdx;
+ uint16_t bktIdx;
+ uint16_t lstMapIdx;
#if (ERRCLASS & ERRCLS_INT_PAR)
Size lstQnSize;
Txt errMsg[256] = {'\0'};
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
- U16 offset;
+ uint16_t offset;
CmMmBlkHdr ptrHdr;
#endif
#endif /* SSI_DEBUG_LEVEL1 */
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
/* Initialize the hast list to maintain the SSI memory information for Broadcom */
- offset = (U16)((PTR)(&ptrHdr.ent) - (PTR) &ptrHdr);
+ offset = (uint16_t)((PTR)(&ptrHdr.ent) - (PTR) &ptrHdr);
printf("###########offset is %d region %d\n", offset, region);
if(cmHashListInit(®Cb->brdcmSsiLstCp, 1000, offset, FALSE,
- CM_HASH_KEYTYPE_U32MOD, region, 0) != ROK)
+ CM_HASH_KEYTYPE_UINT32_MOD, region, 0) != ROK)
{
return RFAILED;
}
CmMmRegCb *regCb;
#endif
{
- U16 bktIdx;
+ uint16_t bktIdx;
#if (ERRCLASS & ERRCLS_INT_PAR)
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t memType,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
PRIVATE S16 cmAlloc(regionCb, size, flags, ptr, memType, line, fileName, entId, hstReg)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
-U32 memType;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t memType;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
#else
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
PRIVATE S16 cmAlloc(regionCb, size, flags, ptr, line, fileName, entId, hstReg)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
#endif /* SSI_DEBUG_LEVEL1 */
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType,
-U32 lineNo,
-U8 *funcName
+uint32_t memType,
+uint32_t lineNo,
+uint8_t *funcName
)
#else
PRIVATE S16 cmAlloc(regionCb, size, flags, ptr ,memType, lineNo, funcName)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
-U32 memType;
-U32 lineNo;
-U8 *funcName;
+uint32_t memType;
+uint32_t lineNo;
+uint8_t *funcName;
#endif
#else /*SS_LIGHT_MEM_LEAK_STS */
#ifdef SSI_DEBUG_LEVEL1
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType
+uint32_t memType
)
#else
PRIVATE S16 cmAlloc(regionCb, size, flags, ptr, memType)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
-U32 memType;
+uint32_t memType;
#endif
#else
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType
+uint32_t memType
)
#else
PRIVATE S16 cmAlloc(regionCb, size, flags, ptr, memType)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
-U32 memType;
+uint32_t memType;
#endif
#else
#ifdef T2K_MEM_LEAK_DBG
(
Void *regionCb,
Size *size,
- U32 flags,
+ uint32_t flags,
Data **ptr ,
char* file,
- U32 line
+ uint32_t line
)
#else
#ifdef ANSI
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr
)
#else
PRIVATE S16 cmAlloc(regionCb, size, flags, ptr)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
#endif
#endif
{
/* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */
#ifndef USE_PURE
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
#endif
CmMmRegCb *regCb;
/* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */
#ifndef USE_PURE
- U16 cnt;
+ uint16_t cnt;
#endif
/* cm_mem_c_001.main_15 : Additions */
#if (defined(SS_MEM_LEAK_STS) || defined( BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1))
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
- U16 memIndex=0;
+ uint16_t memIndex=0;
Data *nextptr1;
Data *prevptr1;
Data **nextptr;
memIndex = (*ptr - startPtr256) / 256;
}
#if 1
- if (*((U32 *)(*ptr + 4)) != 0xDEADDEAD && *((U32 *)(*ptr + 80)) != 0xDEADDEAD && *((U32 *)(*ptr + 24)) != 0xDEADDEAD)
+ if (*((uint32_t *)(*ptr + 4)) != 0xDEADDEAD && *((uint32_t *)(*ptr + 80)) != 0xDEADDEAD && *((uint32_t *)(*ptr + 24)) != 0xDEADDEAD)
{
}
if(bkt->size == 256)
#endif
#endif /* MS_MBUF_CORRUPTION */
#ifdef SSI_MEM_CORR_PREVENTION
- *(((U32 *)(*ptr)) + 2) = 0;
+ *(((uint32_t *)(*ptr)) + 2) = 0;
#endif
#ifdef T2K_MEM_LEAK_DBG
{
/* Lock before the transaction-start */
pthread_mutex_lock(&(regMemLeakInfo.memLock[regCb->region]));
- InsertToT2kMemLeakInfo( (U64)*ptr,*size,line,file,regCb->region);
+ InsertToT2kMemLeakInfo( (uint64_t)*ptr,*size,line,file,regCb->region);
/* UnLock after the transaction */
pthread_mutex_unlock(&(regMemLeakInfo.memLock[regCb->region]));
}
bkt->next = *((CmMmEntry **)(bkt->next));
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
*nextptr = bkt->next;
- if (*((U32 *)(*nextptr + 4)) != 0xDEADDEAD && *((U32 *)(*nextptr + 80)) != 0xDEADDEAD && *((U32 *)(*nextptr + 24)) != 0xDEADDEAD)
+ if (*((uint32_t *)(*nextptr + 4)) != 0xDEADDEAD && *((uint32_t *)(*nextptr + 80)) != 0xDEADDEAD && *((uint32_t *)(*nextptr + 24)) != 0xDEADDEAD)
{
if(bkt->size == 128)
*prevptr = startPtr128 + ((memIndex-1)*128);
cmMemInfo256[memIndex][0] = cmAllocCaller[MxGetCpuID()];
}
cmAllocCaller[MxGetCpuID()] = NULLP;
- *((U32 *)(*ptr + 4)) = 0x00000000;
- *((U32 *)(*ptr + 124)) = 0;
- *((U32 *)(*ptr + 24)) = 0x00000000;
- *((U32 *)(*ptr + 44)) = 0x00000000;
- *((U32 *)(*ptr + 80)) = 0x00000000;
- *((U32 *)(*ptr + 116)) = 0x00000000;
+ *((uint32_t *)(*ptr + 4)) = 0x00000000;
+ *((uint32_t *)(*ptr + 124)) = 0;
+ *((uint32_t *)(*ptr + 24)) = 0x00000000;
+ *((uint32_t *)(*ptr + 44)) = 0x00000000;
+ *((uint32_t *)(*ptr + 80)) = 0x00000000;
+ *((uint32_t *)(*ptr + 116)) = 0x00000000;
#endif
#endif /* SSI_DEBUG_LEVEL1 */
Void *regionCb,
Data *ptr,
Size size,
-U32 lineNo,
-U8 *funcName
+uint32_t lineNo,
+uint8_t *funcName
)
#else
PRIVATE S16 cmFree(regionCb, ptr, size, lineNo, funcName)
Void *regionCb;
Data *ptr;
Size size;
-U32 lineNo;
-U8 *funcName;
+uint32_t lineNo;
+uint8_t *funcName;
#endif
#else /*SS_LIGHT_MEM_LEAK_STS */
#ifdef SS_HISTOGRAM_SUPPORT
Void *regionCb,
Data *ptr,
Size size,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
Void *regionCb;
Data *ptr;
Size size;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
Data *ptr,
Size size,
char* file,
- U32 line
+ uint32_t line
)
#else /* T2K_MEM_LEAK_DBG */
#ifdef ANSI
{
/* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */
#ifndef USE_PURE
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
#endif
CmMmRegCb *regCb;
S8 hstGrmBuf[256];
#endif /* SS_HISTOGRAM_SUPPORT */
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption*/
- U16 memIndex=0;
+ uint16_t memIndex=0;
#endif
#ifdef T2K_MEM_LEAK_DBG
{
pthread_mutex_lock(&(regMemLeakInfo.memLock[regCb->region]));
- RemoveFromT2kMemLeakInfo((U64)ptr , file,line,regCb->region);
+ RemoveFromT2kMemLeakInfo((uint64_t)ptr , file,line,regCb->region);
pthread_mutex_unlock(&(regMemLeakInfo.memLock[regCb->region]));
}
#endif
#ifndef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
#ifdef SSI_MEM_CORR_PREVENTION
- if (*(((U32 *)(ptr)) + 2) == 0xdeaddead)
+ if (*(((uint32_t *)(ptr)) + 2) == 0xdeaddead)
{
/* Do not free an already freed block to avoid corruption */
cmDblFreeAttempts++;
*((CmMmEntry **)bkt->last) = ptr;
bkt->last = (CmMmEntry *)ptr;
*((CmMmEntry **)ptr) = NULLP;
- *(((U32 *)(ptr)) + 2) = 0xdeaddead;
+ *(((uint32_t *)(ptr)) + 2) = 0xdeaddead;
}
#else
*((CmMmEntry **)ptr) = bkt->next;
*crashPtr = 9;
}
}
- if (*((U32 *)(ptr + 4)) != 0xDEADDEAD)
+ if (*((uint32_t *)(ptr + 4)) != 0xDEADDEAD)
{
- *(U32 *)(ptr + 4) = 0xDEADDEAD;
+ *(uint32_t *)(ptr + 4) = 0xDEADDEAD;
}
else
{
Data *crashPtr=NULLP;
*crashPtr = 9;
}
- if (*((U32 *)(ptr + 24)) != 0xDEADDEAD)
+ if (*((uint32_t *)(ptr + 24)) != 0xDEADDEAD)
{
- *(U32 *)(ptr + 24) = 0xDEADDEAD;
+ *(uint32_t *)(ptr + 24) = 0xDEADDEAD;
}
else
{
Data *crashPtr=NULLP;
*crashPtr = 9;
}
- if (*((U32 *)(ptr + 44)) != 0xDEADDEAD)
+ if (*((uint32_t *)(ptr + 44)) != 0xDEADDEAD)
{
- *(U32 *)(ptr + 44) = 0xDEADDEAD;
+ *(uint32_t *)(ptr + 44) = 0xDEADDEAD;
}
else
{
Data *crashPtr=NULLP;
*crashPtr = 9;
}
- if (*((U32 *)(ptr + 80)) != 0xDEADDEAD)
+ if (*((uint32_t *)(ptr + 80)) != 0xDEADDEAD)
{
- *(U32 *)(ptr + 80) = 0xDEADDEAD;
+ *(uint32_t *)(ptr + 80) = 0xDEADDEAD;
}
else
{
*crashPtr = 9;
/* Cause a crash to identify the caller */
}
- *(U32 *)(ptr + 124) = memFreeCount++;
- (*(U32 *)(ptr + 116)) = cmFreeCaller[MxGetCpuID()];
+ *(uint32_t *)(ptr + 124) = memFreeCount++;
+ (*(uint32_t *)(ptr + 116)) = cmFreeCaller[MxGetCpuID()];
if(bkt->size == 128)
{
memIndex = (ptr - startPtr128) / 128;
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t memType,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
line, fileName, entId, hstReg)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
-U32 memType;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t memType;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
#else
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
fileName, entId, hstReg)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
#endif /* SSI_DEBUG_LEVEL1 */
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType,
-U32 lineNo,
-U8 *funcName
+uint32_t memType,
+uint32_t lineNo,
+uint8_t *funcName
)
#else
S16 cmAllocNL(regionCb, size, flags, ptr ,memType, lineNo, funcName)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
-U32 memType;
-U32 lineNo;
-U8 *funcName;
+uint32_t memType;
+uint32_t lineNo;
+uint8_t *funcName;
#endif
#else /*SS_LIGHT_MEM_LEAK_STS */
#ifdef SSI_DEBUG_LEVEL1
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType
+uint32_t memType
)
#else
S16 cmAllocNL(regionCb, size, flags, ptr, memType)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
-U32 memType;
+uint32_t memType;
#endif
#else
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType
+uint32_t memType
)
#else
S16 cmAllocNL(regionCb, size, flags, ptr, memType)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
-U32 memType;
+uint32_t memType;
#endif
#else
#ifdef ANSI
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr
)
#else
S16 cmAllocNL(regionCb, size, flags, ptr)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
#endif
#endif /* BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 */
{
/* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */
#ifndef USE_PURE
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
#endif
CmMmRegCb *regCb;
/* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */
#ifndef USE_PURE
- U16 cnt;
+ uint16_t cnt;
#endif
/* cm_mem_c_001.main_15 : Additions */
#if (defined(SS_MEM_LEAK_STS) || defined( BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1))
bkt->nextBlk = (CmMmBlkHdr *)(bkt->nextBlk->nextBlk);
#else
#ifdef SSI_MEM_CORR_PREVENTION
- *(((U32 *)(*ptr)) + 2) = 0;
+ *(((uint32_t *)(*ptr)) + 2) = 0;
#endif
bkt->next = *((CmMmEntry **)(bkt->next));
#endif /* SSI_DEBUG_LEVEL1 */
Void *regionCb,
Data *ptr,
Size size,
-U32 lineNo,
-U8 *funcName
+uint32_t lineNo,
+uint8_t *funcName
)
#else
S16 cmFreeNL(regionCb, ptr, size, lineNo, funcName)
Void *regionCb;
Data *ptr;
Size size;
-U32 lineNo;
-U8 *funcName;
+uint32_t lineNo;
+uint8_t *funcName;
#endif
#else /*SS_LIGHT_MEM_LEAK_STS */
Void *regionCb,
Data *ptr,
Size size,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
Void *regionCb;
Data *ptr;
Size size;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
{
#ifndef USE_PURE
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
#endif
CmMmRegCb *regCb;
#else
#ifdef SSI_MEM_CORR_PREVENTION
- if (*(((U32 *)(ptr)) + 2) == 0xdeaddead)
+ if (*(((uint32_t *)(ptr)) + 2) == 0xdeaddead)
{
/* Do not free an already freed block to avoid corruption */
cmDblFreeAttempts++;
*((CmMmEntry **)bkt->last) = ptr;
bkt->last = (CmMmEntry *)ptr;
*((CmMmEntry **)ptr) = NULLP;
- *(((U32 *)(ptr)) + 2) = 0xdeaddead;
+ *(((uint32_t *)(ptr)) + 2) = 0xdeaddead;
}
#else
*((CmMmEntry **)ptr) = bkt->next;
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr
)
#else
PRIVATE S16 cmAllocWL(regionCb, size, flags, ptr)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
#endif
{
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
CmMmRegCb *regCb;
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
Size size;
#endif
{
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
CmMmRegCb *regCb;
/*cm_mem_c_001.main_23 Removed support of SSI_DEBUG_LEVEL1 and SS_HISTOGRAM_SUPPORT for SS_FAP*/
/* Check if the Bucket pool is configured */
if (regCb->bktSize)
{
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
- U32 avlSize, totSize;
+ uint32_t avlSize, totSize;
/*
* The bucket pool is configured. The status value returned
* does reflect on the memory availabilty in the bucket pool.
Data **memAddr,
CmMmRegCb *regCb,
CmMmRegCfg *cfg,
-U16 bktIdx,
-U16 *lstMapIdx
+uint16_t bktIdx,
+uint16_t *lstMapIdx
)
#else
PRIVATE Void cmMmBktInit (memAddr, regCb, cfg, bktIdx, lstMapIdx)
Data **memAddr;
CmMmRegCb *regCb;
CmMmRegCfg *cfg;
-U16 bktIdx;
-U16 *lstMapIdx;
+uint16_t bktIdx;
+uint16_t *lstMapIdx;
#endif
{
- U32 cnt;
- U16 idx;
- U32 numBlks;
+ uint32_t cnt;
+ uint16_t idx;
+ uint32_t numBlks;
Size size;
/* cm_mem_c_001.main_12 - addition for temporary variables */
#if (defined(SSI_DEBUG_LEVEL1) || defined(BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1) || defined (SS_LIGHT_MEM_LEAK_STS))
#ifdef SS_LIGHT_MEM_LEAK_STS
CmMmBlkHdr *lastBlk;
#endif /*SS_LIGHT_MEM_LEAK_STS */
- U32 sigCnt;
+ uint32_t sigCnt;
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
Data *tmpMemAddr;
CmMmBlkTail *blkTail;
*nextBlk = NULLP;
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
- tmpMemAddr = (Data *)((*memAddr) - ((sizeof(CmMmBlkHdr)) + sizeof(U32) + size));
+ tmpMemAddr = (Data *)((*memAddr) - ((sizeof(CmMmBlkHdr)) + sizeof(uint32_t) + size));
regCb->bktTbl[bktIdx].lastBlk = (CmMmBlkHdr *)tmpMemAddr;
#endif
{
*next = *memAddr;
#ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
- (*(U32 *)(*next + 4)) = 0xdeaddead;
- (*(U32 *)(*next + 124)) = 0;
- (*(U32 *)(*next + 116)) = 0xdeaddead;
- (*(U32 *)(*next + 24)) = 0xdeaddead;
- (*(U32 *)(*next + 44)) = 0xdeaddead;
- (*(U32 *)(*next + 80)) = 0xdeaddead;
+ (*(uint32_t *)(*next + 4)) = 0xdeaddead;
+ (*(uint32_t *)(*next + 124)) = 0;
+ (*(uint32_t *)(*next + 116)) = 0xdeaddead;
+ (*(uint32_t *)(*next + 24)) = 0xdeaddead;
+ (*(uint32_t *)(*next + 44)) = 0xdeaddead;
+ (*(uint32_t *)(*next + 80)) = 0xdeaddead;
#endif
#ifdef SSI_MEM_CORR_PREVENTION
- *(((U32 *)(*next)) + 2) = 0xdeaddead;
+ *(((uint32_t *)(*next)) + 2) = 0xdeaddead;
#endif
next = (CmMmEntry **)(*memAddr);
*memAddr = (*memAddr) + size;
regCb->bktSize += ((size + sizeof(CmMmBlkHdr)) * numBlks);
/* Addition for considering the header size and tail */
#elif BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
- regCb->bktSize += ((size + sizeof(CmMmBlkHdr) + sizeof(U32)) * numBlks);
+ regCb->bktSize += ((size + sizeof(CmMmBlkHdr) + sizeof(uint32_t)) * numBlks);
#else
regCb->bktSize += (size * numBlks);
#endif /* SSI_DEBUG_LEVEL1 */
cmHstGrmHashListInit(&(regCb->bktTbl[bktIdx].hstGrmHashListCp));
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVOID;
+ return;
} /* end of cmMmBktInit */
\f
{
/* cm_mem_c_001.main_12 - addition for ssi enhancements */
#ifdef SSI_DEBUG_LEVEL1
- U16 idx;
+ uint16_t idx;
#endif /* SSI_DEBUG_LEVEL1 */
/* Initialize the heap control block */
/* Initialise the memory histogram hash list */
cmHstGrmHashListInit(&(heapCb->heapHstGrmHashListCp));
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVOID;
+ return;
} /* end of cmMmHeapInit */
/* cm_mem_c_001.main_12 - addition for taking another parameter memType(static/dynamic) */
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_4GMX_LCORE
-EXTERN U8 ysCellConfigDone;
+EXTERN uint8_t ysCellConfigDone;
#endif
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef SSI_DEBUG_LEVEL1
CmMmHeapCb *heapCb,
Data **ptr,
Size *size,
-U32 memType,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t memType,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
CmMmHeapCb *heapCb;
Data **ptr;
Size *size;
-U32 memType;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t memType;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
#else
CmMmHeapCb *heapCb,
Data **ptr,
Size *size,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
CmMmHeapCb *heapCb;
Data **ptr;
Size *size;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
#endif /* SSI_DEBUG_LEVEL1 */
CmMmHeapCb *heapCb,
Data **ptr,
Size *size,
-U32 memType
+uint32_t memType
)
#else
PRIVATE S16 cmHeapAlloc (heapCb, ptr, size, memType)
CmMmHeapCb *heapCb;
Data **ptr;
Size *size;
-U32 memType;
+uint32_t memType;
#endif
#else
#ifdef ANSI
CmHEntry *alocHeapBlk;
Size requestedSize;
Size hdr;
- U16 idx;
+ uint16_t idx;
#endif /* SSI_DEBUG_LEVEL1 */
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_HISTOGRAM_SUPPORT
CmMmHeapCb *heapCb,
Data *ptr,
Size size,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
CmMmHeapCb *heapCb;
Data *ptr;
Size size;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
#else
#endif/*USE_PURE*/
#ifdef SS_LIGHT_MEM_LEAK_STS
#ifdef ANSI
-U32 cmGetFreeIndx
+uint32_t cmGetFreeIndx
(
Void
)
#else
-U32 cmGetFreeIndx(Void)
+uint32_t cmGetFreeIndx(Void)
#endif
{
}
else
{
- U32 allocQIndx = gmemLkCb.queue[gmemLkCb.head];
+ uint32_t allocQIndx = gmemLkCb.queue[gmemLkCb.head];
gmemLkCb.head = (gmemLkCb.head +1) % CM_MAX_ALLOC_ENTERIES;
return (allocQIndx);
}
}
#ifdef ANSI
-U32 cmPutFreeIndx
+uint32_t cmPutFreeIndx
(
-U32 allocQIndx
+uint32_t allocQIndx
)
#else
-U32 cmPutFreeIndx(allocQIndx)
-U32 allocQIndx;
+uint32_t cmPutFreeIndx(allocQIndx)
+uint32_t allocQIndx;
#endif
{
- U32 tmpTail = (gmemLkCb.tail+1)% CM_MAX_ALLOC_ENTERIES;
+ uint32_t tmpTail = (gmemLkCb.tail+1)% CM_MAX_ALLOC_ENTERIES;
if(tmpTail == gmemLkCb.head)
{
allocQueueFullCnt++;
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
Void cmInitMemLeak (Void)
#endif
{
- U32 indx;
+ uint32_t indx;
gmemLkCb.isStarted = FALSE;
cmPutFreeIndx(indx);
}
- RETVOID;
+ return;
} /* cmInitMemLeak */
/*
*
* Desc: De-initializes the memory leak detection
*
*
- * Ret: RETVOID
+ * Ret: void
*
* Notes: This function de-initializes the memory leak detection module.
*
Void cmDeinitMemLeak (Void)
#endif
{
- U32 indx;
+ uint32_t indx;
for(indx = 0; indx < CM_MAX_ALLOC_ENTERIES; indx++)
gmemLkCb.isStarted = FALSE;
gmemLkCb.head = 0;
gmemLkCb.tail = 0;
- RETVOID;
+ return;
}
/*
*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
*
*/
#ifdef ANSI
-U32 cmStorAllocBlk
+uint32_t cmStorAllocBlk
(
Void *addr
)
#else
-U32 cmStorAllocBlk (addr)
+uint32_t cmStorAllocBlk (addr)
Void *addr;
#endif /* ANSI */
{
- U32 allocQIndx;
+ uint32_t allocQIndx;
(Void) SLock(&gmemLkCb.memLock);
allocQIndx = cmGetFreeIndx();
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
#ifdef ANSI
Void cmRlsAllocBlk
(
-U32 allocQIndx
+uint32_t allocQIndx
)
#else
Void cmRlsAllocBlk(allocQIndx)
-U32 allocQIndx;
+uint32_t allocQIndx;
#endif
{
(Void) SUnlock(&(gmemLkCb.memLock));
}
}
- RETVOID;
+ return;
} /* cmRlsAllocBlk */
/*
printf("!!leak capturing stopped\n");
cmPrintLeakLog();
}
- RETVOID;
+ return;
}
/*
#endif
{
- U32 indx;
+ uint32_t indx;
CmMmBlkHdr *aBkt;
- static U32 leakCount =0;
+ static uint32_t leakCount =0;
printf("---- START OF LEAK LOG ----");
SUnlock(&gmemLkCb.memLock);
printf("---- Lock Released ----");
leakCount =0;
- RETVOID;
+ return;
}
#endif
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
Void cmRlsAllocBlk
(
#ifdef BIT_64
-U64 addr
+uint64_t addr
#else
-U32 addr
+uint32_t addr
#endif
)
#else
Void cmRlsAllocBlk(addr)
#ifdef BIT_64
-U64 addr;
+uint64_t addr;
#else
-U32 addr;
+uint32_t addr;
#endif
#endif
#endif
{
Ptr trace[CM_MAX_STACK_TRACE];
S8 **funcNm;
- U8 idx;
- U8 i;
+ uint8_t idx;
+ uint8_t i;
S16 retVal;
S32 traceSize;
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
#ifdef BIT_64
- retVal = cmHashListFind(®Cb->brdcmSsiLstCp,(U8 *)&ptrHdr,
- (U16)sizeof(U64), 0, (PTR *)&ptrHdr);
+ retVal = cmHashListFind(®Cb->brdcmSsiLstCp,(uint8_t *)&ptrHdr,
+ (uint16_t)sizeof(uint64_t), 0, (PTR *)&ptrHdr);
#else
- retVal = cmHashListFind(®Cb->brdcmSsiLstCp,(U8 *)&ptrHdr,
- (U16)sizeof(U32), 0, (PTR *)&ptrHdr);
+ retVal = cmHashListFind(®Cb->brdcmSsiLstCp,(uint8_t *)&ptrHdr,
+ (uint16_t)sizeof(uint32_t), 0, (PTR *)&ptrHdr);
#endif
if(retVal == ROK)
{
#else
if( memLkCb.memLkMdlInit == FALSE)
{
- RETVOID;
+ return;
}
for(idx = 0; idx < CM_MEM_USR_MDL; idx++)
{
SLock(&memLkCb.memUsrMdl[idx][addr & 0x3].memLck);
#ifdef BIT_64
retVal = cmHashListFind(&memLkCb.memUsrMdl[idx][addr & 0x3].memHashCp,
- (U8 *)&addr, sizeof(U64), 0,
+ (uint8_t *)&addr, sizeof(uint64_t), 0,
(PTR *)&memAllocInfo);
#else
retVal = cmHashListFind(&memLkCb.memUsrMdl[idx][addr & 0x3].memHashCp,
- (U8 *)&addr, sizeof(U32), 0,
+ (uint8_t *)&addr, sizeof(uint32_t), 0,
(PTR *)&memAllocInfo);
#endif
if(retVal == ROK)
#endif /* SS_MEM_LEAK_SOL */
#endif/* BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 */
/*cm_mem_c_001.main_25 : */
- RETVOID;
+ return;
} /* cmRlsAllocBlk */
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
CmMmBlkHdr *ptrHdr,
Size reqSz,
Size allocSz,
-U16 bktIdx,
+uint16_t bktIdx,
CmMmRegCb *regCb
)
#else
CmMmBlkHdr *ptrHdr;
Size reqSz;
Size allocSz;
-U16 bktIdx;
+uint16_t bktIdx;
CmMmRegCb *regCb;
#endif
#else
Void cmStorAllocBlk
(
#ifdef BIT_64
-U64 addr,
+uint64_t addr,
#else
-U32 addr,
+uint32_t addr,
#endif
Size reqSz,
Size allocSz,
-U16 bktIdx
+uint16_t bktIdx
)
#else
Void cmStorAllocBlk (addr, reqSz, allocSz, bktIdx)
#ifdef BIT_64
-U64 addr;
+uint64_t addr;
#else
-U32 addr;
+uint32_t addr;
#endif
Size reqSz;
Size allocSz;
-U16 bktIdx;
+uint16_t bktIdx;
#endif /* ANSI */
#endif /* BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1 */
{
void *trace[CM_MAX_STACK_TRACE];
#endif /* SS_MEM_LEAK_SOL */
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
- U8 btrIdx;
+ uint8_t btrIdx;
#else
MemAllocInfo *allocInfo;
- U8 moduleId;
+ uint8_t moduleId;
S8 **funcNm;
S32 traceSize;
#endif
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
if( memLkCb.memLkMdlInit == FALSE)
{
- RETVOID;
+ return;
}
#endif
#ifdef SS_MEM_LEAK_SOL
* implementation. */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
- funcNm = (S8 **)MxHeapAlloc(SsiHeap, (sizeof(U32) * CM_MAX_STACK_TRACE));
- memset(funcNm, 0, (sizeof(U32) * CM_MAX_STACK_TRACE));
+ funcNm = (S8 **)MxHeapAlloc(SsiHeap, (sizeof(uint32_t) * CM_MAX_STACK_TRACE));
+ memset(funcNm, 0, (sizeof(uint32_t) * CM_MAX_STACK_TRACE));
#else
- funcNm = (S8 **)calloc(1, (sizeof(U32) * CM_MAX_STACK_TRACE));
+ funcNm = (S8 **)calloc(1, (sizeof(uint32_t) * CM_MAX_STACK_TRACE));
#endif
- /* SGetSBuf(DFLT_REGION, DFLT_POOL, &funcNm, sizeof(U32) * CM_MAX_STACK_TRACE); */
+ /* SGetSBuf(DFLT_REGION, DFLT_POOL, &funcNm, sizeof(uint32_t) * CM_MAX_STACK_TRACE); */
traceSize = backtrace((Void **)funcNm, CM_MAX_STACK_TRACE);
#else /* SS_MEM_LEAK_SOL */
#ifndef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
ptrHdr->allocSz = allocSz;
ptrHdr->bktIdx = bktIdx;
cmHashListInsert(®Cb->brdcmSsiLstCp, (PTR)ptrHdr,
- (U8 *)&(ptrHdr), sizeof(PTR));
+ (uint8_t *)&(ptrHdr), sizeof(PTR));
#else
allocInfo->memAddr = addr;
allocInfo->reqSz = reqSz;
allocInfo->moduleId = moduleId;
allocInfo->bTrcSz = traceSize;
cmHashListInsert(&memLkCb.memUsrMdl[moduleId][addr & 0x3].memHashCp,
- (PTR)allocInfo, (U8 *)&(allocInfo->memAddr),
+ (PTR)allocInfo, (uint8_t *)&(allocInfo->memAddr),
sizeof(allocInfo->memAddr));
memLkCb.memUsrMdl[moduleId][addr & 0x3].used = TRUE;
(Void) SUnlock(&(memLkCb.memUsrMdl[moduleId][addr & 0x3].memLck));
#endif
- RETVOID;
+ return;
} /* cmStorAllocBlk */
/*
*
- RETVOID;
+ return;
} /* cmStorAllocBlk */
/*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
#endif
{
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
- U8 idx;
- U8 regionIdx;
+ uint8_t idx;
+ uint8_t regionIdx;
Txt prntBuf[255];
S8 **funcNm;
CmMmBlkHdr *newBlkHdr;
#else
MemAllocInfo *oldMemInfo;
MemAllocInfo *newMemInfo;
- U8 memMdl;
- U8 hashIdx;
- U8 idx;
+ uint8_t memMdl;
+ uint8_t hashIdx;
+ uint8_t idx;
Txt prntBuf[255];
S8 **funcNm;
if( memLkCb.memLkMdlInit == FALSE)
{
- RETVOID;
+ return;
}
sprintf(prntBuf, "\n------- START OF LEAK LOG -------\n");
fwrite(prntBuf, strlen(prntBuf), 1, memLkCb.fileLkLog);
sprintf(prntBuf, "\n------- END OF LEAK LOG -------\n");
fwrite(prntBuf, strlen(prntBuf), 1, memLkCb.fileLkLog);
#endif
- RETVOID;
+ return;
}
#endif
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
Void cmInitMemLeakMdl (Void)
#endif
{
- U8 memMdl;
- U8 hashIdx;
+ uint8_t memMdl;
+ uint8_t hashIdx;
memLkCb.memLkMdlInit = FALSE;
{
SInitLock(&memLkCb.memUsrMdl[memMdl][hashIdx].memLck, 1);
cmHashListInit(&memLkCb.memUsrMdl[memMdl][hashIdx].memHashCp,
- 500, 0, FALSE, CM_HASH_KEYTYPE_U32MOD, 0, 0);
+ 500, 0, FALSE, CM_HASH_KEYTYPE_UINT32_MOD, 0, 0);
memLkCb.memUsrMdl[memMdl][hashIdx].used = FALSE;
}
}
}
memLkCb.memLkMdlInit = TRUE;
- RETVOID;
+ return;
} /* cmInitMemLeakMdl */
/* cm_mem_c_002.main_21 Added for shutdown procedure */
/*
* Desc: De-initializes the memory leak detection module
*
*
- * Ret: RETVOID
+ * Ret: void
*
* Notes: This function de-initializes the memory leak detection module.
*
Void cmDeinitMemLeakMdl (Void)
#endif
{
- U8 memMdl;
- U8 hashIdx;
+ uint8_t memMdl;
+ uint8_t hashIdx;
memLkCb.memLkMdlInit = FALSE;
memLkCb.memUsrMdl[memMdl][hashIdx].used = FALSE;
}
}
- RETVOID;
+ return;
}
/*
*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
{
memLkCb.fileLkLog = NULLP;
memLkCb.fileLkLog = fopen(arg, "w");
- RETVOID;
+ return;
}
/*
*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
#endif
{
MemAllocInfo *newMemInfo;
- U8 memMdl;
- U8 hashIdx;
+ uint8_t memMdl;
+ uint8_t hashIdx;
S8 **funcNm;
#ifdef SS_MEM_LEAK_SOL
- U8 i;
+ uint8_t i;
#endif /* SS_MEM_LEAK_SOL */
if( memLkCb.memLkMdlInit == FALSE)
{
- RETVOID;
+ return;
}
for(memMdl = 0; memMdl < CM_MEM_USR_MDL; memMdl++)
#else
free(funcNm[i]);
#endif
- /* SPutSBuf(DFLT_REGION, DFLT_POOL, funcNm[i], sizeof(U32) * CM_MAX_STACK_TRACE); */
+ /* SPutSBuf(DFLT_REGION, DFLT_POOL, funcNm[i], sizeof(uint32_t) * CM_MAX_STACK_TRACE); */
}
#endif /* SS_MEM_LEAK_SOl */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
SUnlock(&memLkCb.memUsrMdl[memMdl][hashIdx].memLck);
}
}
- RETVOID;
+ return;
}
/*
*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
*
*/
#ifdef ANSI
-U8 cmMemGetModuleId
+uint8_t cmMemGetModuleId
(
S8 **funNm,
S32 traceSize
)
#else
-U8 cmMemGetModuleId (funNm, traceSize)
+uint8_t cmMemGetModuleId (funNm, traceSize)
S8 **funNm;
S32 traceSize;
#endif /* ANSI */
{
- U8 idx;
- U8 memStrIdx;
- U32 len;
+ uint8_t idx;
+ uint8_t memStrIdx;
+ uint32_t len;
S32 retVal;
S16 memReqIdx;
S16 mdlFunStrIdx;
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
#ifdef ANSI
S16 cmMemGetStrMtchIdx
(
-U8 strtIdx,
-U8 endIdx,
+uint8_t strtIdx,
+uint8_t endIdx,
S8 *str,
S8 **strLst
)
#else
S16 cmMemGetStrMtchIdx(strtIdx, endIdx, str, strLst)
-U8 strtIdx;
-U8 endIdx;
+uint8_t strtIdx;
+uint8_t endIdx;
S8 *str;
S8 **strLst;
#endif
{
S8 cmpStr[255];
- U32 len;
+ uint32_t len;
Bool found;
- U32 tempLen;
- U8 idx;
+ uint32_t tempLen;
+ uint8_t idx;
S32 retVal;
len = strlen((const S8 *)str);
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
#endif
#endif
{
- U32 sigCnt;
+ uint32_t sigCnt;
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
CmMmBlkTail *tailPtr;
#endif
#endif
{
CmMmBlkHdr *ptrBlk;
- U32 blkCnt;
+ uint32_t blkCnt;
bkt->trampleCount = 0;
PRIVATE S16 cmMmHashFunc
(
CmMmHashListCp *hashListCp,
-U32 key,
-U16 *idx
+uint32_t key,
+uint16_t *idx
)
#else
PRIVATE S16 cmMmHashFunc (hashListCp, key, idx)
CmMmHashListCp *hashListCp; /* hash list control point */
-U32 key; /* key string */
-U16 *idx; /* idx to return */
+uint32_t key; /* key string */
+uint16_t *idx; /* idx to return */
#endif
{
- *idx = (U16)(key % hashListCp->numOfbins);
+ *idx = (uint16_t)(key % hashListCp->numOfbins);
return ROK;
PRIVATE S16 cmMmHashListInit
(
CmMmHashListCp *hashListCp, /* hash list to initialize */
-U16 nmbBins, /* number of hash list bins */
+uint16_t nmbBins, /* number of hash list bins */
Region region, /* memory region to allocate bins */
Pool pool /* memory pool to allocate bins */
)
#else
PRIVATE S16 cmMmHashListInit(hashListCp, nmbBins, region, pool)
CmMmHashListCp *hashListCp; /* hash list to initialize */
-U16 nmbBins; /* number of hash list bins */
+uint16_t nmbBins; /* number of hash list bins */
Region region; /* memory region to allocate bins */
Pool pool; /* memory pool to allocate bins */
#endif
{
- U16 i;
+ uint16_t i;
CmMmHashListEnt *hl;
PRIVATE S16 cmMmHashListInsert
(
CmMmHashListCp *hashListCp, /* hash list to add to */
-U32 key /* pointer to key */
+uint32_t key /* pointer to key */
)
#else
PRIVATE S16 cmMmHashListInsert(hashListCp, key)
CmMmHashListCp *hashListCp; /* hash list to add to */
-U32 key; /* pointer to key */
+uint32_t key; /* pointer to key */
#endif
{
CmMmHashListEnt *hashListEnt; /* pointer to hash list entry header */
- U16 idx; /* index for insertion into hash list */
- U16 i;
+ uint16_t idx; /* index for insertion into hash list */
+ uint16_t i;
/* check if hashListCp is initialised yet */
PRIVATE S16 cmHstGrmFreeInsert
(
CmHstGrmHashListCp* hashListCp, /* hash list cp */
-U32 blkSz, /* size of the block freed */
-U32 line, /* Line number */
-U8 *fileName, /* file name */
-U8 entId /* Tapa task which free the memory */
+uint32_t blkSz, /* size of the block freed */
+uint32_t line, /* Line number */
+uint8_t *fileName, /* file name */
+uint8_t entId /* Tapa task which free the memory */
)
#else
PRIVATE S16 cmHstGrmFreeInsert(hashListCp, blkSz, line, fileName, entId)
CmHstGrmHashListCp* hashListCp; /* hash list cp */
-U32 blkSz; /* size of the block freed */
-U32 line; /* line number */
-U8 *fileName; /* file Name */
-U8 entId; /* Tapa task which frees the memory */
+uint32_t blkSz; /* size of the block freed */
+uint32_t line; /* line number */
+uint8_t *fileName; /* file Name */
+uint8_t entId; /* Tapa task which frees the memory */
#endif
{
- U32 binIdx = 0; /* Bin index to insert the entry into the hash list */
- U32 key = 0; /* Key to fine the bin index */
- U32 ret = 0; /* Return value */
+ uint32_t binIdx = 0; /* Bin index to insert the entry into the hash list */
+ uint32_t key = 0; /* Key to fine the bin index */
+ uint32_t ret = 0; /* Return value */
CmMemEntries *entry = NULLP; /* Entry which contains the information */
PRIVATE S16 cmHstGrmAllocInsert
(
CmHstGrmHashListCp *hashListCp,
-U32 blkSz,
-U32 *reqSz,
-U32 line,
-U8 *fileName,
-U8 entId
+uint32_t blkSz,
+uint32_t *reqSz,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId
)
#else
PRIVATE S16 cmHstGrmAllocInsert(hashListCp, blkSz, reqSz, line, fileName, entId)
CmHstGrmHashListCp *hashListCp;
-U32 blkSz;
-U32 *reqSz;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t blkSz;
+uint32_t *reqSz;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
#endif
{
- U32 binIdx = 0;
- U32 key = 0;
- U32 ret = 0;
+ uint32_t binIdx = 0;
+ uint32_t key = 0;
+ uint32_t ret = 0;
CmMemEntries *entry = NULLP;
#ifdef ANSI
PRIVATE S16 cmHstGrmGetHashIdxAndKey
(
-U8 *fileName,
-U32 line,
-U32 *binIdx,
-U32 *key
+uint8_t *fileName,
+uint32_t line,
+uint32_t *binIdx,
+uint32_t *key
)
#else
PRIVATE S16 cmHstGrmGetHashIdxAndKey(fileName, line, binIdx, key)
-U8 *fileName;
-U32 line;
-U32 *binIdx;
-U32 *key;
+uint8_t *fileName;
+uint32_t line;
+uint32_t *binIdx;
+uint32_t *key;
#endif
{
- U32 i = 0;
+ uint32_t i = 0;
/* Calculate the key using file name and line number */
for(i = 0 ; fileName[i] != '\0'; i++)
PRIVATE S16 cmHstGrmFillEntry
(
CmMemEntries *entry,
-U32 key,
-U32 line,
-U8 *fileName,
-U8 entId
+uint32_t key,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId
)
#else
PRIVATE S16 cmHstGrmFillEntry(entry, key, line, fileName, entId)
CmMemEntries *entry;
-U32 key;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t key;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
#endif
{
- U32 idx = 0;
+ uint32_t idx = 0;
entry->key = key;
entry->line = line;
entry->entId = entId;
PRIVATE S16 cmHstGrmFindEntry
(
CmHstGrmHashListCp *hashListCp,
-U32 key,
-U32 *binIdx,
+uint32_t key,
+uint32_t *binIdx,
CmMemEntries **entry
)
#else
PRIVATE S16 cmHstGrmFindEntry(hashListCp, key, binIdx, entry)
CmHstGrmHashListCp *hashListCp;
-U32 key;
-U32 *binIdx;
+uint32_t key;
+uint32_t *binIdx;
CmMemEntries **entry;
#endif
{
- U32 numEnt = 0;
- U32 numBin = 0;
+ uint32_t numEnt = 0;
+ uint32_t numBin = 0;
CmHstGrmHashListEnt *tmpBin = NULLP;
for(numBin = 0; numBin < CMM_HIST_MAX_MEM_BIN; numBin++)
struct cmMmBktCfg
{
Size size; /* Size of the memory block */
- U32 numBlks; /* Number of the block in the bucket */
+ uint32_t numBlks; /* Number of the block in the bucket */
};
/* Memory Region configuration structure. */
{
Size size; /* Size of the memory */
Data *vAddr; /* Start address of the memory */
- U8 lType; /* Lock Type to be used */
+ uint8_t lType; /* Lock Type to be used */
- U8 chFlag; /* Flag defines the memory region characteristics */
+ uint8_t chFlag; /* Flag defines the memory region characteristics */
Data *pAddr; /* Physical address of the memory block: Valid
if CMM_REG_PHY_VALID bit of chFlag is set */
Size bktQnSize; /* Quatum size of the memory block */
- U16 numBkts; /* Number of buckets in the Bucket Pool */
+ uint16_t numBkts; /* Number of buckets in the Bucket Pool */
CmMmBktCfg bktCfg[CMM_MAX_BKT_ENT]; /* Bucket configuration structure */
};
#ifdef SS_HISTOGRAM_SUPPORT
struct cmMemEntries /* Entry information */
{
- U32 line; /* Line Number where memory allocation primitive used */
- U32 allocBytes; /* Granted Byte */
- U32 allocOverFlow; /* If the value of allocBytes overflows then we use this variable */
- U32 freedBytes; /* Freed Bytes */
- U32 freeOverFlow; /* If the value of freeByte overflows then we use this value */
- U32 wastedBytes; /* Difference between Granted and Requested bytes */
- U32 bucketAllocReq; /* No of times this Bucket used */
- U32 bucketFreeReq; /* No of times this Bucket freed */
- U32 entId; /* Tapa task used this bucket */
- U32 key; /* combination of file name and line */
- U8 fileName[CMM_HIST_MAX_FILENAME]; /* File Name where memory allocation primitive used */
+ uint32_t line; /* Line Number where memory allocation primitive used */
+ uint32_t allocBytes; /* Granted Byte */
+ uint32_t allocOverFlow; /* If the value of allocBytes overflows then we use this variable */
+ uint32_t freedBytes; /* Freed Bytes */
+ uint32_t freeOverFlow; /* If the value of freeByte overflows then we use this value */
+ uint32_t wastedBytes; /* Difference between Granted and Requested bytes */
+ uint32_t bucketAllocReq; /* No of times this Bucket used */
+ uint32_t bucketFreeReq; /* No of times this Bucket freed */
+ uint32_t entId; /* Tapa task used this bucket */
+ uint32_t key; /* combination of file name and line */
+ uint8_t fileName[CMM_HIST_MAX_FILENAME]; /* File Name where memory allocation primitive used */
};
struct cmHstGrmHashListEnt /* hash list entry */
{
CmMemEntries entries[CMM_HIST_MAX_MEM_ENTRY_PER_BIN]; /* Number of entires in each bin */
- U32 numOfEntries; /*Number of entries in hash list */
+ uint32_t numOfEntries; /*Number of entries in hash list */
};
struct cmHstGrmHashListCp /* Hash List control pointer */
{
CmHstGrmHashListEnt hashList[CMM_HIST_MAX_MEM_BIN]; /* Number of bins in hash list */
- U16 totalNumEntries; /* Total number of bins */
+ uint16_t totalNumEntries; /* Total number of bins */
};
#endif /* SS_HISTOGRAM_SUPPORT */
struct cmMmBlkHdr
{
/* trSignature shall always be maintained as the first element in this structure */
- U8 trSignature[CMM_TRAMPLING_SIGNATURE_LEN]; /* signature to detect trampling */
+ uint8_t trSignature[CMM_TRAMPLING_SIGNATURE_LEN]; /* signature to detect trampling */
CmMmBlkHdr *nextBlk; /* pointer to the next memory block header */
- U32 memFlags; /* Free/Static/Dynamic */
+ uint32_t memFlags; /* Free/Static/Dynamic */
Size requestedSize; /* requested size for which this mem blk has been allocated */
#ifdef SS_LIGHT_MEM_LEAK_STS
- U32 timeStamp; /* Time stamp */
- U32 lineNo;
- U32 allocQueueIndx;
- U8 *currFuncName;
+ uint32_t timeStamp; /* Time stamp */
+ uint32_t lineNo;
+ uint32_t allocQueueIndx;
+ uint8_t *currFuncName;
#endif
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
CmHashListEnt ent; /* hash list entry */
Size reqSz; /* Requested size */
Size allocSz;/* Allocated size */
- U8 bktIdx; /* Bucket ID */
+ uint8_t bktIdx; /* Bucket ID */
Void *backTrace[BRDCM_MEM_LEAK_BTRACE]; /* Back trace */
#endif
};
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1
typedef struct cmMmBlkTail
{
- U8 trSignature[CMM_TRAMPLING_SIGNATURE_LEN]; /* signature to detect trampling */
+ uint8_t trSignature[CMM_TRAMPLING_SIGNATURE_LEN]; /* signature to detect trampling */
}CmMmBlkTail;
typedef struct memLkInfo
{
#endif
#endif /* SSI_DEBUG_LEVEL1 */
Size size; /* Size of the block */
- U32 numBlks; /* Total number of blocks in the bucket */
- U32 maxAlloc; /* Maximum number of blocks allocated till now */
- U32 numAlloc; /* Number of blocks allocated */
+ uint32_t numBlks; /* Total number of blocks in the bucket */
+ uint32_t maxAlloc; /* Maximum number of blocks allocated till now */
+ uint32_t numAlloc; /* Number of blocks allocated */
SLockId bktLock; /* Lock to protect the bucket pool */
- U32 bktFailCnt; /* bucket alloc failure count */
- U32 bktNoFitCnt; /* number of blocks not fit */
+ uint32_t bktFailCnt; /* bucket alloc failure count */
+ uint32_t bktNoFitCnt; /* number of blocks not fit */
/* cm_mem_x_001.main_9 - addition of statistics related data */
#if (defined(SSI_DEBUG_LEVEL1) || defined(BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1))
Data *bktStartPtr; /* maintains the start address of the memory block in the bucket */
StsCntr numDeallocAttempts; /* total number of de-allocation attempts */
Size staticMemUsed; /* amount of memory used for static allocations */
Size dynamicMemUsed; /* amount of memory used for dynamic allocations */
- U8 trampleCount; /* incremented everytime a trampling is detected in any block of the bucket */
+ uint8_t trampleCount; /* incremented everytime a trampling is detected in any block of the bucket */
#endif /*SSI_DEBUG_LEVEL1*/
/* cm_mem_x_001.main_11: Additions */
#ifdef SS_HISTOGRAM_SUPPORT
/* Size-To-Bucket map table structure */
struct cmMmMapBkt
{
- U16 bktIdx; /* The index to the memory bucket */
+ uint16_t bktIdx; /* The index to the memory bucket */
#if (ERRCLASS & ERRCLS_DEBUG)
- U16 numReq; /* Number of the allocation request */
- U16 numFailure; /* Number of allocation failure form the bucket */
+ uint16_t numReq; /* Number of the allocation request */
+ uint16_t numFailure; /* Number of allocation failure form the bucket */
#endif
};
/* cm_mem_x_001.main_9 - addition to provide trampling and double-free detections support */
#ifdef SSI_DEBUG_LEVEL1
/* trSignature shall always be maintianed as the first element in this structure */
- U8 trSignature[CMM_TRAMPLING_SIGNATURE_LEN]; /* signature to detect trampling */
- U32 memFlags; /* flag to maintain the memory status */
+ uint8_t trSignature[CMM_TRAMPLING_SIGNATURE_LEN]; /* signature to detect trampling */
+ uint32_t memFlags; /* flag to maintain the memory status */
Size requestedSize; /* size of the heap entry block */
#endif /* SSI_DEBUG_LEVEL1 */
CmHEntry *next; /* Pointer to the next entry block */
Size minSize; /* Minimum size that can be allocated */
SLockId heapLock; /* Lock to protect the heap pool */
#if (ERRCLASS & ERRCLS_DEBUG)
- U16 numFragBlk; /* Number of fragmented block */
- U16 numReq; /* Number of allocation request */
- U16 numFailure; /* Number of allocation failure */
+ uint16_t numFragBlk; /* Number of fragmented block */
+ uint16_t numReq; /* Number of allocation request */
+ uint16_t numFailure; /* Number of allocation failure */
#endif
- U32 heapAllocCnt; /* Number of blocks from heap */
+ uint32_t heapAllocCnt; /* Number of blocks from heap */
/* cm_mem_x_001.main_9 - addition of statistics related data */
#ifdef SSI_DEBUG_LEVEL1
Size staticHeapMemUsed; /* amount of heap memory used for static allocations */
/* Update this in cmMmHeapInit if cmHEntry is changed */
StsCntr numAllocAttempts; /* total number of allocation attempts in heap */
StsCntr numDeallocAttempts; /* total number of de-allocation attempts in heap */
- U8 trampleCount; /* incremented everytime a trampling is detected in any block of the heap */
+ uint8_t trampleCount; /* incremented everytime a trampling is detected in any block of the heap */
#endif /* SSI_DEBUG_LEVEL1 */
/* cm_mem_x_001.main_11: Additions */
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef SSI_DEBUG_LEVEL1
struct cmMmHashListEnt /* hash list entry */
{
- U32 size; /* pointer to key */
- U32 numAttempts; /* number of attempts */
+ uint32_t size; /* pointer to key */
+ uint32_t numAttempts; /* number of attempts */
};
struct cmMmHashListCp
{
CmMmHashListEnt *hashList;
- U16 numOfbins;
- U16 numOfEntries;
+ uint16_t numOfbins;
+ uint16_t numOfEntries;
};
#endif /* SSI_DEBUG_LEVEL1 */
Region region; /* Region Id of the memory */
SRegInfo regInfo; /* Region information block */
- U8 chFlag; /* Flag defines the region characteristics */
+ uint8_t chFlag; /* Flag defines the region characteristics */
Data *pAddr; /* Physical address of the memory block.
Valid if CMM_REG_PHY_VALID bit is set */
Size bktSize; /* Size of the memory used for the bucket pool */
- U16 bktQnPwr; /* Quantum size of the bucket pool */
+ uint16_t bktQnPwr; /* Quantum size of the bucket pool */
Size bktMaxBlkSize; /* Maximum size of block in the bucket pool */
- U16 numBkts; /* Number of buckets in the Bucket Pool */
+ uint16_t numBkts; /* Number of buckets in the Bucket Pool */
CmMmMapBkt mapTbl[CMM_MAX_MAP_ENT]; /* size-to-bucket map table */
CmMmBkt bktTbl[CMM_MAX_BKT_ENT]; /* Pointer to the memory bkt tbl */
typedef struct allocInfo
{
Void *memAddr;
- U8 used;
+ uint8_t used;
}AllocInfo;
typedef struct memLeakCb
{
SLockId memLock;
- U8 isStarted;
+ uint8_t isStarted;
AllocInfo allocInfo[CM_MAX_ALLOC_ENTERIES];
- U32 queue[CM_MAX_ALLOC_ENTERIES];
- U32 head;
- U32 tail;
+ uint32_t queue[CM_MAX_ALLOC_ENTERIES];
+ uint32_t head;
+ uint32_t tail;
}MemLeakCb;
EXTERN Void cmInitMemLeak ARGS((Void));
EXTERN Void cmDeinitMemLeak ARGS((Void));
EXTERN Void cmStartStopLeakLog ARGS((Void));
-EXTERN U32 cmStorAllocBlk ARGS((Void *addr));
-EXTERN Void cmRlsAllocBlk ARGS((U32 indx));
+EXTERN uint32_t cmStorAllocBlk ARGS((Void *addr));
+EXTERN Void cmRlsAllocBlk ARGS((uint32_t indx));
EXTERN Void cmPrintLeakLog ARGS((Void));
#endif /* SS_LIGHT_MEM_LEAK_STS */
{
CmHashListEnt ent;
#ifdef BIT_64
- U64 memAddr;
+ uint64_t memAddr;
#else
- U32 memAddr;
+ uint32_t memAddr;
#endif
Size reqSz;
Size allocSz;
- U16 bktIdx;
- U8 moduleId;
- U8 bTrcSz;
+ uint16_t bktIdx;
+ uint8_t moduleId;
+ uint8_t bTrcSz;
PTR backTrace;
}MemAllocInfo;
#define T2K_MEM_LEAK_INFO_TABLE_SIZE 8388606
/* osCp.wls.allocAddr is the starting address allocated by WLS,
* whenever that changes pleasse change here */
-U64 t2k_MEM_LEAK_START_ADDR;
+uint64_t t2k_MEM_LEAK_START_ADDR;
typedef struct _t2kMemLeakInfo
{
- U64 address; /* 0 means it is free */
- U32 size; /* size of the block */
- U32 age; /* in ticks, when it was allocated */
- U32 lineNo; /* lineNo in the file from where allocation was done */
+ uint64_t address; /* 0 means it is free */
+ uint32_t size; /* size of the block */
+ uint32_t age; /* in ticks, when it was allocated */
+ uint32_t lineNo; /* lineNo in the file from where allocation was done */
char* fileName; /* from where allocation was done */
- U32 prevRemLineNo; /* lineNo in the file from where allocation was done */
+ uint32_t prevRemLineNo; /* lineNo in the file from where allocation was done */
char* prevRemFileName; /* from where allocation was done */
- U32 lastDelLineNum; /* lineNo in the file from where allocation was done */
+ uint32_t lastDelLineNum; /* lineNo in the file from where allocation was done */
char* lastDelFileName; /* from where allocation was done */
}T2kMeamLeakInfo;
typedef struct _regMemLeakInfo
{
- U32 numActvRegions;
+ uint32_t numActvRegions;
T2kMeamLeakInfo *gMemLeakInfo[SS_MAX_REGS]; /* Allocate using calloc(system Call ) size T2K_MEM_LEAK_INFO_TABLE_SIZE*/
- U64 regStartAddr[SS_MAX_REGS]; /* start Address of Region */
+ uint64_t regStartAddr[SS_MAX_REGS]; /* start Address of Region */
pthread_mutex_t memLock[SS_MAX_REGS]; /* Region Lock */
}RegionMemLeakInfo;
#ifdef BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL2
EXTERN Void cmRlsAllocBlk ARGS((CmMmBlkHdr *ptrHdr, CmMmRegCb *regCb));
EXTERN Void cmStorAllocBlk ARGS((CmMmBlkHdr *ptrHdr, Size reqSz, Size allocSz,
- U16 bktIdx, CmMmRegCb *regCb));
+ uint16_t bktIdx, CmMmRegCb *regCb));
#endif
#ifdef SS_MEM_LEAK_STS
EXTERN Void cmInitMemLeakMdl ARGS((Void));
/* cm_mem_x_001.main_12 : Additions */
EXTERN Void cmDeinitMemLeakMdl ARGS((Void));
#ifdef BIT_64
-EXTERN Void cmStorAllocBlk ARGS((U64 addr, Size reqSz, Size allocSz,
- U16 bktIdx));
-EXTERN Void cmRlsAllocBlk ARGS((U64 addr));
+EXTERN Void cmStorAllocBlk ARGS((uint64_t addr, Size reqSz, Size allocSz,
+ uint16_t bktIdx));
+EXTERN Void cmRlsAllocBlk ARGS((uint64_t addr));
#else
-EXTERN Void cmStorAllocBlk ARGS((U32 addr, Size reqSz, Size allocSz,
- U16 bktIdx));
-EXTERN Void cmRlsAllocBlk ARGS((U32 addr));
+EXTERN Void cmStorAllocBlk ARGS((uint32_t addr, Size reqSz, Size allocSz,
+ uint16_t bktIdx));
+EXTERN Void cmRlsAllocBlk ARGS((uint32_t addr));
#endif
-EXTERN U8 cmMemGetModuleId ARGS((S8 **funNm, S32 traceSize));
-EXTERN S16 cmMemGetStrMtchIdx ARGS((U8 strtIdx, U8 endIdx,
+EXTERN uint8_t cmMemGetModuleId ARGS((S8 **funNm, S32 traceSize));
+EXTERN S16 cmMemGetStrMtchIdx ARGS((uint8_t strtIdx, uint8_t endIdx,
S8 *str, S8 **strLst));
EXTERN Void cmMemOpenMemLkFile ARGS((S8 *arg));
EXTERN Void SLogLkInfo ARGS((Void));
#endif
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef SSI_DEBUG_LEVEL1
-EXTERN S16 cmAllocNL ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, U32 memType, U32 line, U8 *fileName, U8 entId, Bool hstReg));
+EXTERN S16 cmAllocNL ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, uint32_t memType, uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg));
#else
-EXTERN S16 cmAllocNL ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, U32 line, U8 *fileName, U8 entId, Bool hstReg));
+EXTERN S16 cmAllocNL ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg));
#endif
#elif defined(SS_LIGHT_MEM_LEAK_STS)
-EXTERN S16 cmAllocNL ARGS((Void *regionCb,Size *size,U32 flags,Data **ptr,U32 memType,U32 lineNo,U8 *funcName));
+EXTERN S16 cmAllocNL ARGS((Void *regionCb,Size *size,uint32_t flags,Data **ptr,uint32_t memType,uint32_t lineNo,uint8_t *funcName));
#else
#if (defined(SSI_DEBUG_LEVEL1) || defined(BRDCM_SSI_MEM_LEAK_DEBUG_LEVEL1))
-EXTERN S16 cmAllocNL ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, U32 memType));
+EXTERN S16 cmAllocNL ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, uint32_t memType));
#else
-EXTERN S16 cmAllocNL ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr));
+EXTERN S16 cmAllocNL ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr));
#endif
#endif
#ifdef SS_HISTOGRAM_SUPPORT
-EXTERN S16 cmFreeNL ARGS((Void *regionCb, Data *ptr, Size size, U32 line, U8 *fileName, U8 entId, Bool hstReg));
+EXTERN S16 cmFreeNL ARGS((Void *regionCb, Data *ptr, Size size, uint32_t line, uint8_t *fileName, uint8_t entId, Bool hstReg));
#elif defined(SS_LIGHT_MEM_LEAK_STS)
-EXTERN S16 cmFreeNL ARGS((Void *regionCb,Data *ptr, Size size,U32 lineNo,U8 *funcName));
+EXTERN S16 cmFreeNL ARGS((Void *regionCb,Data *ptr, Size size,uint32_t lineNo,uint8_t *funcName));
#else
EXTERN S16 cmFreeNL ARGS((Void *regionCb, Data *ptr, Size size));
#endif
/*ccpu00142274 - UL mem based flow control changes */
#ifdef TENB_T2K3K_SPECIFIC_CHANGES
/* selva */
-U32 gMemoryAlarm;
-PRIVATE U32 memoryCheckCounter;
+uint32_t gMemoryAlarm;
+PRIVATE uint32_t memoryCheckCounter;
#define NUM_CALLS_TO_CHECK_MEM_AGAIN 80 /* Number of calls after which need to check mem */
#ifndef L2_L3_SPLIT
#define NUM_FREE_BUFFERS 128
typedef struct cmBtInfo
{
- U32 btInfoIdx;
+ uint32_t btInfoIdx;
CmMemFreeInfo btInfo[NUM_FREE_BUFFERS];
} CmBtInfo;
}CmMemDoubleFree;
PTR prvAllocPtr[8];
-U8 stopBtInfo = FALSE;
+uint8_t stopBtInfo = FALSE;
Buffer *palBuffer;
EXTERN Buffer *mtTskBuffer1;
EXTERN Buffer *mtTskBuffer2;
#ifdef SS_USE_ICC_MEMORY
#ifdef T2K_MEM_LEAK_DBG
-PRIVATE S16 cmIccAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, char*, U32));
-PRIVATE S16 cmIccFree ARGS((Void *regionCb, Data *ptr, Size size,char*, U32));
-PRIVATE S16 cmIccAllocWithLock ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr, char*, U32));
-PRIVATE S16 cmIccFreeWithLock ARGS((Void *regionCb, Data *ptr, Size size,char*, U32));
-void InsertToT2kMemLeakInfo ARGS((U32 address, U32 size, U32 lineNo, char* fileName));
-void RemoveFromT2kMemLeakInfo ARGS((U32 address, char *file, U32 line));
-PRIVATE U32 getT2kMemLeakIndex ARGS((U32 address));
-#else
-PRIVATE S16 cmIccAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr));
+PRIVATE S16 cmIccAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, char*, uint32_t));
+PRIVATE S16 cmIccFree ARGS((Void *regionCb, Data *ptr, Size size,char*, uint32_t));
+PRIVATE S16 cmIccAllocWithLock ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr, char*, uint32_t));
+PRIVATE S16 cmIccFreeWithLock ARGS((Void *regionCb, Data *ptr, Size size,char*, uint32_t));
+void InsertToT2kMemLeakInfo ARGS((uint32_t address, uint32_t size, uint32_t lineNo, char* fileName));
+void RemoveFromT2kMemLeakInfo ARGS((uint32_t address, char *file, uint32_t line));
+PRIVATE uint32_t getT2kMemLeakIndex ARGS((uint32_t address));
+#else
+PRIVATE S16 cmIccAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr));
PRIVATE S16 cmIccFree ARGS((Void *regionCb, Data *ptr, Size size));
-PRIVATE S16 cmIccAllocWithLock ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr));
+PRIVATE S16 cmIccAllocWithLock ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr));
PRIVATE S16 cmIccFreeWithLock ARGS((Void *regionCb, Data *ptr, Size size));
#endif
#else /* SS_USE_ICC_MEMORY */
-PRIVATE S16 cmDynAllocWithLock ARGS((Void *regionCb,Size *size,U32 flags,Data **ptr));
+PRIVATE S16 cmDynAllocWithLock ARGS((Void *regionCb,Size *size,uint32_t flags,Data **ptr));
PRIVATE S16 cmDynFreeWithLock ARGS((Void *regionCb,Data *ptr, Size size));
-PRIVATE S16 cmDynAlloc ARGS((Void *regionCb,Size *size,U32 flags,Data **ptr));
+PRIVATE S16 cmDynAlloc ARGS((Void *regionCb,Size *size,uint32_t flags,Data **ptr));
PRIVATE S16 cmDynFree ARGS((Void *regionCb,Data *ptr, Size size));
#endif /* SS_USE_ICC_MEMORY */
#ifdef T2K_MEM_LEAK_DBG
-PRIVATE S16 cmAllocWL ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr,char*,U32));
-PRIVATE S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size,char*, U32));
+PRIVATE S16 cmAllocWL ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr,char*,uint32_t));
+PRIVATE S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size,char*, uint32_t));
-PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr,char*,U32));
-PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size,char*, U32));
+PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr,char*,uint32_t));
+PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size,char*, uint32_t));
#else
-PRIVATE S16 cmAllocWL ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr));
+PRIVATE S16 cmAllocWL ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr));
PRIVATE S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size));
-PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr));
+PRIVATE S16 cmAlloc ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr));
PRIVATE S16 cmFree ARGS((Void *regionCb, Data *ptr, Size size));
#endif
#ifdef T2K_MEM_LEAK_DBG
-PRIVATE S16 cmAllocWL ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr,char*,U32));
-PRIVATE S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size,char*, U32));
+PRIVATE S16 cmAllocWL ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr,char*,uint32_t));
+PRIVATE S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size,char*, uint32_t));
#else
-PRIVATE S16 cmAllocWL ARGS((Void *regionCb, Size *size, U32 flags, Data **ptr));
+PRIVATE S16 cmAllocWL ARGS((Void *regionCb, Size *size, uint32_t flags, Data **ptr));
PRIVATE S16 cmFreeWL ARGS((Void *regionCb, Data *ptr, Size size));
#endif
#ifndef USE_PURE
/* cm_mem_c_008.104 - Addition for memory calculator tool */
#ifdef MEMCAL_DEBUG
PRIVATE Txt prntBuf[200]; /* print buffer */
-PRIVATE U8 tryHeap=0;
+PRIVATE uint8_t tryHeap=0;
#endif
/* cm_mem_c_001.main_12 - addition for ssi enhancements prints */
#define T2K_MEM_LEAK_START_ADDR 0x9d200000 /*New Sercomm Board*/
#endif
-U32 num_times = 0;
+uint32_t num_times = 0;
EXTERN pthread_t tmpRegTidMap[20];
extern Bool g_usettitmr;
void DumpLayersDebugInformation()
Data **memAddr,
CmMmRegCb *regCb,
CmMmRegCfg *cfg,
-U16 bktIdx,
-U16 *lstMapIdx
+uint16_t bktIdx,
+uint16_t *lstMapIdx
)
#else
PRIVATE Void cmMmStatBktInit (memAddr, regCb, cfg, bktIdx, lstMapIdx)
Data **memAddr;
CmMmRegCb *regCb;
CmMmRegCfg *cfg;
-U16 bktIdx;
-U16 *lstMapIdx;
+uint16_t bktIdx;
+uint16_t *lstMapIdx;
#endif
{
- U32 cnt;
- U16 idx;
- U32 numBlks;
+ uint32_t cnt;
+ uint16_t idx;
+ uint32_t numBlks;
Size size;
/* cm_mem_c_001.main_12 - addition for temporary variables */
#ifdef SSI_DEBUG_LEVEL1
CmMmBlkHdr **nextBlk;
- U32 sigCnt;
+ uint32_t sigCnt;
#else
Data **next;
#endif /* SSI_DEBUG_LEVEL1 */
cmHstGrmHashListInit(&(regCb->bktTbl[bktIdx].hstGrmHashListCp));
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVOID;
+ return;
} /* end of cmMmStatBktInit */
/*
#endif
{
Data *memAddr;
- U16 bktIdx;
- U16 lstMapIdx;
+ uint16_t bktIdx;
+ uint16_t lstMapIdx;
#if (ERRCLASS & ERRCLS_INT_PAR)
Size lstQnSize;
{
Data **memAddr;
Data **next;
- U16 bktIdx;
- U16 bucketSetSize;
- U16 cnt;
+ uint16_t bktIdx;
+ uint16_t bucketSetSize;
+ uint16_t cnt;
Size size;
CmMmBlkSetElement *blkLstElem;
- U16 numBlks;
+ uint16_t numBlks;
#if (ERRCLASS & ERRCLS_INT_PAR)
Size lstQnSize;
(
Void *regionCb, /* Pointer to a region */
Size *size, /* size needs to be allocated */
-U32 flags, /* Flags used */
+uint32_t flags, /* Flags used */
Data **ptr, /* Reference to pointer for which need to be allocate */
char *file,
-U32 line
+uint32_t line
)
#endif
#else
(
Void *regionCb, /* Pointer to a region */
Size *size, /* size needs to be allocated */
-U32 flags, /* Flags used */
+uint32_t flags, /* Flags used */
Data **ptr /* Reference to pointer for which need to be allocate */
)
#else
PRIVATE S16 cmIccAllocWithLock(regionCb, size, flags, ptr)
Void *regionCb; /* Pointer to a region */
Size *size; /* size needs to be allocated */
-U32 flags; /* Flags used */
+uint32_t flags; /* Flags used */
Data **ptr; /* Reference to pointer for which need to be allocate */
#endif
#endif
}
#ifdef T2K_MEM_LEAK_DBG
- if(((U32)(memPtr - T2K_MEM_LEAK_START_ADDR) & 0xff) != 0)
+ if(((uint32_t)(memPtr - T2K_MEM_LEAK_START_ADDR) & 0xff) != 0)
{
printf("Address returned is %p size = %ld\n",memPtr,*size);
}
- InsertToT2kMemLeakInfo((U32)memPtr,*size,line,file);
+ InsertToT2kMemLeakInfo((uint32_t)memPtr,*size,line,file);
#endif
*ptr = memPtr;
Data *ptr, /* Memory block needs to be freed */
Size size, /* Size of the block */
char *file,
-U32 line
+uint32_t line
)
#endif
#else
}
#ifdef T2K_MEM_LEAK_DBG
- RemoveFromT2kMemLeakInfo((U32)ptr - ((U32)ptr % 512),file,line);
+ RemoveFromT2kMemLeakInfo((uint32_t)ptr - ((uint32_t)ptr % 512),file,line);
#endif
TL_Free(regCb->iccHdl, ptr);
(
Void *regionCb, /* Pointer to a region */
Size *size, /* size needs to be allocated */
-U32 flags, /* Flags used */
+uint32_t flags, /* Flags used */
Data **ptr, /* Reference to pointer for which need to be allocate */
char *file,
-U32 line
+uint32_t line
)
#else
#endif
(
Void *regionCb, /* Pointer to a region */
Size *size, /* size needs to be allocated */
-U32 flags, /* Flags used */
+uint32_t flags, /* Flags used */
Data **ptr /* Reference to pointer for which need to be allocate */
)
#else
PRIVATE S16 cmIccAlloc(regionCb, size, flags, ptr)
Void *regionCb; /* Pointer to a region */
Size *size; /* size needs to be allocated */
-U32 flags; /* Flags used */
+uint32_t flags; /* Flags used */
Data **ptr; /* Reference to pointer for which need to be allocate */
#endif
*p = 10;
}
#ifdef T2K_MEM_LEAK_DBG
- if(((U32)(memPtr - T2K_MEM_LEAK_START_ADDR) & 0xff) != 0)
+ if(((uint32_t)(memPtr - T2K_MEM_LEAK_START_ADDR) & 0xff) != 0)
{
printf("Address returned is %p size = %ld\n",memPtr,*size);
}
- InsertToT2kMemLeakInfo((U32)memPtr,*size,line,file);
+ InsertToT2kMemLeakInfo((uint32_t)memPtr,*size,line,file);
#endif
#ifdef YS_PHY_3_8_2
*ptr = memPtr;/*TL_VA2TRUEVA(regCb->iccHdl, memPtr); */
Data *ptr, /* Memory block needs to be freed */
Size size, /* Size of the block */
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
// memPtr = TL_TRUEVA2VA(regCb->iccHdl, ptr);
{
#ifdef T2K_MEM_LEAK_DBG
- RemoveFromT2kMemLeakInfo((U32)ptr - ((U32)ptr % 512),file,line);
+ RemoveFromT2kMemLeakInfo((uint32_t)ptr - ((uint32_t)ptr % 512),file,line);
#endif
}
#endif
{
Region region;
- U16 lstMapIdx;
- U16 cnt;
+ uint16_t lstMapIdx;
+ uint16_t cnt;
Size size;
CmMmBlkSetElement *blkLstElem;
SRegInfo regInfo;
Size bktQnSize = MT_BKTQNSIZE;
- U16 idx;
- U16 idx1;
- U16 numBkts;
+ uint16_t idx;
+ uint16_t idx1;
+ uint16_t numBkts;
/* Initialize the region control block */
CmMmRegCb *regCb;
#endif
{
- U16 bktIdx;
+ uint16_t bktIdx;
#if (ERRCLASS & ERRCLS_INT_PAR)
#ifdef ANSI
PRIVATE CmMmBlkSetElement* cmGetMemBlkSetForAlloc
(
-U8 bucketIndex, /* Index to the bucket list */
+uint8_t bucketIndex, /* Index to the bucket list */
CmMmDynBktCb *bkt /* Bucket list control block */
)
#else
PRIVATE CmMmBlkSetElement* cmGetMemBlkSetForAlloc(bucketIndex, bkt)
-U8 bucketIndex; /* Index to the bucket list */
+uint8_t bucketIndex; /* Index to the bucket list */
CmMmDynBktCb *bkt; /* Bucket list control block */
#endif
{
#ifdef ANSI
PRIVATE CmMmBlkSetElement* cmGetMemBlkSetForFree
(
-U8 bucketIndex, /* Index to the bucket list */
+uint8_t bucketIndex, /* Index to the bucket list */
CmMmDynBktCb *bkt /* Bucket list control block */
)
#else
PRIVATE CmMmBlkSetElement* cmGetMemBlkSetForFree(bucketIndex, bkt)
-U8 bucketIndex; /* Index to the bucket list */
+uint8_t bucketIndex; /* Index to the bucket list */
CmMmDynBktCb *bkt; /* Bucket list control block */
#endif
{
CmMemDoubleFree *memNode = NULLP;
SLock(&memDoubleFreeLock);
- if((cmHashListFind(&(memDoubleFree), (U8*)&ptr,
- sizeof(U32), 0, (PTR *)&memNode)) != ROK)
+ if((cmHashListFind(&(memDoubleFree), (uint8_t*)&ptr,
+ sizeof(uint32_t), 0, (PTR *)&memNode)) != ROK)
{
Void *tmpBtArr[10];
- U16 tmpBtSize;
+ uint16_t tmpBtSize;
S8 **strings;
- U16 idx;
+ uint16_t idx;
tmpBtSize = backtrace(tmpBtArr, 10);
strings = backtrace_symbols(tmpBtArr, tmpBtSize);
memNode->memBlkPtr = ptr;
SLock(&memDoubleFreeLock);
- if((cmHashListInsert(&(memDoubleFree), (PTR)memNode, (U8*)&memNode->memBlkPtr,
+ if((cmHashListInsert(&(memDoubleFree), (PTR)memNode, (uint8_t*)&memNode->memBlkPtr,
sizeof(PTR))) != ROK)
{
SUnlock(&memDoubleFreeLock);
(
Void *regionCb, /* Pointer to a region */
Size *size, /* size needs to be allocated */
-U32 flags, /* Flags used */
+uint32_t flags, /* Flags used */
Data **ptr /* Reference to pointer for which need to be allocate */
)
#else
PRIVATE S16 cmDynAllocWithLock(regionCb, size, flags, ptr)
Void *regionCb; /* Pointer to a region */
Size *size; /* size needs to be allocated */
-U32 flags; /* Flags used */
+uint32_t flags; /* Flags used */
Data **ptr; /* Reference to pointer for which need to be allocate */
#endif
{
(
Void *regionCb, /* Pointer to a region */
Size *size, /* size needs to be allocated */
-U32 flags, /* Flags used */
+uint32_t flags, /* Flags used */
Data **ptr /* Reference to pointer for which need to be allocate */
)
#else
PRIVATE S16 cmDynAlloc(regionCb, size, flags, ptr)
Void *regionCb; /* Pointer to a region */
Size *size; /* size needs to be allocated */
-U32 flags; /* Flags used */
+uint32_t flags; /* Flags used */
Data **ptr; /* Reference to pointer for which need to be allocate */
#endif
{
if ( (*size) <= regCb->bktMaxBlkSize)
#endif
{
- U32 idx;
+ uint32_t idx;
CmMmBlkSetElement *dynMemElem;
- U32 bktIdx;
+ uint32_t bktIdx;
CmMmDynBktCb *bkt;
/* Get the map to the mapping table */
#ifdef SS_MEM_WL_DEBUG
if(dynMemElem->nextBktPtr == prvAllocPtr[regCb->region])
{
- U32 *tmpDump;
+ uint32_t *tmpDump;
*tmpDump = 100;
}
#endif
#ifdef SS_MEM_WL_DEBUG
prvAllocPtr[regCb->region] = *ptr;
- **ptr = (U8) bktIdx;
+ **ptr = (uint8_t) bktIdx;
*(*ptr+1) = 0xde;
*(*ptr+2) = 0xad;
*(*ptr+3) = 0xbe;
- *ptr += sizeof (U32);
+ *ptr += sizeof (uint32_t);
if ((bktIdx == 0) && (!stopBtInfo))
{
CmBtInfo *btInfo;
- U32 btIdx;
+ uint32_t btIdx;
btInfo = &allocBtInfo[regCb->region];
btIdx = btInfo->btInfoIdx;
btInfo->btInfo[btIdx].ptr = (PTR) *ptr;
(
Void *regionCb,
Size *size,
- U32 flags,
+ uint32_t flags,
Data **ptr ,
char* file,
- U32 line
+ uint32_t line
)
#else
#ifdef SS_HISTOGRAM_SUPPORT
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t memType,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
PRIVATE S16 cmAlloc(regionCb, size, flags, ptr, memType, line, fileName, entId, hstReg)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
-U32 memType;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t memType;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
#else
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
PRIVATE S16 cmAlloc(regionCb, size, flags, ptr, line, fileName, entId, hstReg)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
#endif /* SSI_DEBUG_LEVEL1 */
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr,
-U32 memType
+uint32_t memType
)
#else
PRIVATE S16 cmAlloc(regionCb, size, flags, ptr, memType)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
-U32 memType;
+uint32_t memType;
#endif
#else
#ifdef ANSI
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr
)
#else
PRIVATE S16 cmAlloc(regionCb, size, flags, ptr)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
#endif
{
/* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */
#ifndef USE_PURE
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
- U16 bktIdx;
+ uint16_t bktIdx;
#endif
CmMmRegCb *regCb;
/* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */
#ifndef USE_PURE
- U16 cnt;
+ uint16_t cnt;
#endif
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_MEM_LEAK_STS
S16 cmInitDoubleFreeList()
#endif
{
- U16 offset;
+ uint16_t offset;
CmMemDoubleFree memNode;
- offset = (U16)((PTR)(&memNode.tmpListEnt) - (PTR)&memNode);
+ offset = (uint16_t)((PTR)(&memNode.tmpListEnt) - (PTR)&memNode);
if((cmHashListInit(&(memDoubleFree), 1000, offset, 0,
- CM_HASH_KEYTYPE_U32MOD, 0, 0)) != ROK);
+ CM_HASH_KEYTYPE_UINT32_MOD, 0, 0)) != ROK);
{
return RFAILED;
}
Void cmAnalyseBtInfo
(
PTR ptr, /* Memory block needs to be freed */
-U32 idx
+uint32_t idx
)
#else
Void cmAnalyseBtInfo (ptr,idx)
PTR ptr; /* Memory block needs to be freed */
-U32 idx;
+uint32_t idx;
#endif
{
- U32 tmpCnt;
- U32 btIdx;
+ uint32_t tmpCnt;
+ uint32_t btIdx;
CmBtInfo *btInfo;
- U8 regIdx;
+ uint8_t regIdx;
/* for(regIdx = 0; regIdx < 8; regIdx++)
{ */
(btInfo->btInfo[btIdx].ptr + 128 ) >= ptr) */
if(btInfo->btInfo[btIdx].btSize != 0)
{
- U32 i;
+ uint32_t i;
char **strings;
strings = backtrace_symbols( btInfo->btInfo[btIdx].btArr,btInfo->btInfo[btIdx].btSize);
printf("*** Last Allocation Region = %d PTR %x Timestamp sec = (%ld) usec = (%ld) ***\n", idx, ptr, btInfo->btInfo[btIdx].timeStamp.tv_sec, btInfo->btInfo[btIdx].timeStamp.tv_usec);
}
/* } */
- RETVOID;
+ return;
}
#endif
{
CmMmDynRegCb *regCb;
#ifndef USE_PURE
- U32 idx;
- U32 bktIdx;
+ uint32_t idx;
+ uint32_t bktIdx;
CmMmDynBktCb *bkt = NULLP;
CmMmBlkSetElement *dynMemElem;
#endif
#ifdef SS_MEM_WL_DEBUG
- U8 tmpBktIdx;
- U8 tmpVal;
+ uint8_t tmpBktIdx;
+ uint8_t tmpVal;
#endif
#endif
#ifdef SS_MEM_WL_DEBUG
- ptr -= sizeof (U32);
+ ptr -= sizeof (uint32_t);
size += 4;
#endif
/* The memory block was allocated from the bucket pool */
{
printf("2nd time Size = %d bucket size = %d\n", size, bkt->size);
exit(-1);
- U8 *tmpptr = NULLP;
+ uint8_t *tmpptr = NULLP;
printf("Bucket Size wrong \n");
*tmpptr = 10;
}
}
#ifdef SS_MEM_WL_DEBUG
- tmpBktIdx = (U8)*ptr;
- tmpVal = (U8)*(ptr+1);
+ tmpBktIdx = (uint8_t)*ptr;
+ tmpVal = (uint8_t)*(ptr+1);
if ((tmpBktIdx != bktIdx) || (tmpVal != 0xde))
{
- U8 *tmpptr = NULLP;
+ uint8_t *tmpptr = NULLP;
printf("bktIdx wrong \n");
*tmpptr = 10;
}
if ((bktIdx == 0) && (!stopBtInfo))
{
CmBtInfo *btInfo;
- U32 btIdx;
+ uint32_t btIdx;
btInfo = ®BtInfo[regCb->region];
btIdx = btInfo->btInfoIdx;
btInfo->btInfo[btIdx].ptr = (PTR) ptr;
Data *ptr,
Size size,
char* file,
- U32 line
+ uint32_t line
)
#else
#ifdef SS_HISTOGRAM_SUPPORT
Void *regionCb,
Data *ptr,
Size size,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
Void *regionCb;
Data *ptr;
Size size;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
{
/* cm_mem_c_001.main_26 : Fixes for Compilation Warnings */
#ifndef USE_PURE
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
- U16 bktIdx;
+ uint16_t bktIdx;
#endif
CmMmRegCb *regCb;
/* cm_mem_c_001.main_12 - addition for holding the free pointer */
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr ,
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
(
Void *regionCb,
Size *size,
-U32 flags,
+uint32_t flags,
Data **ptr
)
#else
PRIVATE S16 cmAllocWL(regionCb, size, flags, ptr)
Void *regionCb;
Size *size;
-U32 flags;
+uint32_t flags;
Data **ptr;
#endif
#endif
{
#ifndef USE_PURE
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt = NULLP;
#endif
CmMmRegCb *regCb;
Data *ptr,
Size size,
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
#endif
{
#ifndef USE_PURE
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt = NULLP;
#endif
CmMmRegCb *regCb;
/* Check if the Bucket pool is configured */
if (regCb->bktSize)
{
- U16 idx;
+ uint16_t idx;
CmMmBkt *bkt;
- U32 avlSize, totSize;
+ uint32_t avlSize, totSize;
/*
* The bucket pool is configured. The status value returned
* does reflect on the memory availabilty in the bucket pool.
{
/* cm_mem_c_001.main_12 - addition for ssi enhancements */
#ifdef SSI_DEBUG_LEVEL1
- U16 idx;
+ uint16_t idx;
#endif /* SSI_DEBUG_LEVEL1 */
/* Initialize the heap control block */
/* Initialise the memory histogram hash list */
cmHstGrmHashListInit(&(heapCb->heapHstGrmHashListCp));
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVOID;
+ return;
} /* end of cmMmHeapInit */
CmMmHeapCb *heapCb,
Data **ptr,
Size *size,
-U32 memType,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t memType,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
CmMmHeapCb *heapCb;
Data **ptr;
Size *size;
-U32 memType;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t memType;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
#else
CmMmHeapCb *heapCb,
Data **ptr,
Size *size,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
CmMmHeapCb *heapCb;
Data **ptr;
Size *size;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
#endif /* SSI_DEBUG_LEVEL1 */
CmMmHeapCb *heapCb,
Data **ptr,
Size *size,
-U32 memType
+uint32_t memType
)
#else
PRIVATE S16 cmHeapAlloc (heapCb, ptr, size, memType)
CmMmHeapCb *heapCb;
Data **ptr;
Size *size;
-U32 memType;
+uint32_t memType;
#endif
#else
#ifdef ANSI
CmHEntry *alocHeapBlk;
Size requestedSize;
Size hdr;
- U16 idx;
+ uint16_t idx;
#endif /* SSI_DEBUG_LEVEL1 */
/* cm_mem_c_001.main_15 : Additions */
#ifdef SS_HISTOGRAM_SUPPORT
CmMmHeapCb *heapCb,
Data *ptr,
Size size,
-U32 line,
-U8 *fileName,
-U8 entId,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId,
Bool hstReg
)
#else
CmMmHeapCb *heapCb;
Data *ptr;
Size size;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
Bool hstReg;
#endif
#else
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
Void cmInitMemLeakMdl (Void)
#endif
{
- U8 memMdl;
- U8 hashIdx;
+ uint8_t memMdl;
+ uint8_t hashIdx;
memLkCb.memLkMdlInit = FALSE;
{
SInitLock(&memLkCb.memUsrMdl[memMdl][hashIdx].memLck, 1);
cmHashListInit(&memLkCb.memUsrMdl[memMdl][hashIdx].memHashCp,
- 500, 0, FALSE, CM_HASH_KEYTYPE_U32MOD, 0, 0);
+ 500, 0, FALSE, CM_HASH_KEYTYPE_UINT32_MOD, 0, 0);
memLkCb.memUsrMdl[memMdl][hashIdx].used = FALSE;
}
}
}
memLkCb.memLkMdlInit = TRUE;
- RETVOID;
+ return;
} /* cmInitMemLeakMdl */
/* cm_mem_c_002.main_21 Added for shutdown procedure */
/*
* Desc: De-initializes the memory leak detection module
*
*
- * Ret: RETVOID
+ * Ret: void
*
* Notes: This function de-initializes the memory leak detection module.
*
Void cmDeinitMemLeakMdl (Void)
#endif
{
- U8 memMdl;
- U8 hashIdx;
+ uint8_t memMdl;
+ uint8_t hashIdx;
memLkCb.memLkMdlInit = FALSE;
memLkCb.memUsrMdl[memMdl][hashIdx].used = FALSE;
}
}
- RETVOID;
+ return;
}
/*
*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
{
memLkCb.fileLkLog = NULLP;
memLkCb.fileLkLog = fopen(arg, "w");
- RETVOID;
+ return;
}
/*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
MemAllocInfo *oldMemInfo;
MemAllocInfo *newMemInfo;
- U8 memMdl;
- U8 hashIdx;
- U8 idx;
+ uint8_t memMdl;
+ uint8_t hashIdx;
+ uint8_t idx;
Txt prntBuf[255];
S8 **funcNm;
if( memLkCb.memLkMdlInit == FALSE)
{
- RETVOID;
+ return;
}
sprintf(prntBuf, "\n------- START OF LEAK LOG -------\n");
fwrite(prntBuf, strlen(prntBuf), 1, memLkCb.fileLkLog);
}
sprintf(prntBuf, "\n------- END OF LEAK LOG -------\n");
fwrite(prntBuf, strlen(prntBuf), 1, memLkCb.fileLkLog);
- RETVOID;
+ return;
}
/*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
#endif
{
MemAllocInfo *newMemInfo;
- U8 memMdl;
- U8 hashIdx;
+ uint8_t memMdl;
+ uint8_t hashIdx;
S8 **funcNm;
#ifdef SS_MEM_LEAK_SOL
- U8 i;
+ uint8_t i;
#endif /* SS_MEM_LEAK_SOL */
if( memLkCb.memLkMdlInit == FALSE)
{
- RETVOID;
+ return;
}
for(memMdl = 0; memMdl < CM_MEM_USR_MDL; memMdl++)
#else
free(funcNm[i]);
#endif
- /* SPutSBuf(DFLT_REGION, DFLT_POOL, funcNm[i], sizeof(U32) * CM_MAX_STACK_TRACE); */
+ /* SPutSBuf(DFLT_REGION, DFLT_POOL, funcNm[i], sizeof(uint32_t) * CM_MAX_STACK_TRACE); */
}
#endif /* SS_MEM_LEAK_SOl */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
SUnlock(&memLkCb.memUsrMdl[memMdl][hashIdx].memLck);
}
}
- RETVOID;
+ return;
}
/*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
#ifdef ANSI
Void cmStorAllocBlk
(
-U32 addr,
+uint32_t addr,
Size reqSz,
Size allocSz,
-U16 bktIdx
+uint16_t bktIdx
)
#else
Void cmStorAllocBlk (addr, reqSz, allocSz, bktIdx)
-U32 addr;
+uint32_t addr;
Size reqSz;
Size allocSz;
-U16 bktIdx;
+uint16_t bktIdx;
#endif /* ANSI */
{
#ifndef SS_MEM_LEAK_SOL
S8 **funcNm;
S32 traceSize;
MemAllocInfo *allocInfo;
- U8 moduleId;
+ uint8_t moduleId;
if( memLkCb.memLkMdlInit == FALSE)
{
- RETVOID;
+ return;
}
#ifdef SS_MEM_LEAK_SOL
* implementation. */
/*cm_mem_c_001.main_27 SSI-4GMX specfic changes*/
#ifdef SS_4GMX_LCORE
- funcNm = (S8 **)MxHeapAlloc(SsiHeap, (sizeof(U32) * CM_MAX_STACK_TRACE));
- memset(funcNm, 0, (sizeof(U32) * CM_MAX_STACK_TRACE));
+ funcNm = (S8 **)MxHeapAlloc(SsiHeap, (sizeof(uint32_t) * CM_MAX_STACK_TRACE));
+ memset(funcNm, 0, (sizeof(uint32_t) * CM_MAX_STACK_TRACE));
#else
- funcNm = (S8 **)calloc(1, (sizeof(U32) * CM_MAX_STACK_TRACE));
+ funcNm = (S8 **)calloc(1, (sizeof(uint32_t) * CM_MAX_STACK_TRACE));
#endif
- /* SGetSBuf(DFLT_REGION, DFLT_POOL, &funcNm, sizeof(U32) * CM_MAX_STACK_TRACE); */
+ /* SGetSBuf(DFLT_REGION, DFLT_POOL, &funcNm, sizeof(uint32_t) * CM_MAX_STACK_TRACE); */
traceSize = backtrace((Void **)funcNm, CM_MAX_STACK_TRACE);
#else /* SS_MEM_LEAK_SOL */
traceSize = backtrace(trace, CM_MAX_STACK_TRACE);
allocInfo->bTrcSz = traceSize;
cmHashListInsert(&memLkCb.memUsrMdl[moduleId][addr & 0x3].memHashCp,
- (PTR)allocInfo, (U8 *)&(allocInfo->memAddr),
+ (PTR)allocInfo, (uint8_t *)&(allocInfo->memAddr),
sizeof(allocInfo->memAddr));
memLkCb.memUsrMdl[moduleId][addr & 0x3].used = TRUE;
(Void) SUnlock(&(memLkCb.memUsrMdl[moduleId][addr & 0x3].memLck));
- RETVOID;
+ return;
} /* cmStorAllocBlk */
/*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
*
*/
#ifdef ANSI
-U8 cmMemGetModuleId
+uint8_t cmMemGetModuleId
(
S8 **funNm,
S32 traceSize
)
#else
-U8 cmMemGetModuleId (funNm, traceSize)
+uint8_t cmMemGetModuleId (funNm, traceSize)
S8 **funNm;
S32 traceSize;
#endif /* ANSI */
{
- U8 idx;
- U8 memStrIdx;
- U32 len;
+ uint8_t idx;
+ uint8_t memStrIdx;
+ uint32_t len;
S32 retVal;
S16 memReqIdx;
S16 mdlFunStrIdx;
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
#ifdef ANSI
S16 cmMemGetStrMtchIdx
(
-U8 strtIdx,
-U8 endIdx,
+uint8_t strtIdx,
+uint8_t endIdx,
S8 *str,
S8 **strLst
)
#else
S16 cmMemGetStrMtchIdx(strtIdx, endIdx, str, strLst)
-U8 strtIdx;
-U8 endIdx;
+uint8_t strtIdx;
+uint8_t endIdx;
S8 *str;
S8 **strLst;
#endif
{
S8 cmpStr[255];
- U32 len;
+ uint32_t len;
Bool found;
- U32 tempLen;
- U8 idx;
+ uint32_t tempLen;
+ uint8_t idx;
S32 retVal;
len = strlen((const S8 *)str);
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
#ifdef ANSI
Void cmRlsAllocBlk
(
-U32 addr
+uint32_t addr
)
#else
Void cmRlsAllocBlk(addr)
-U32 addr;
+uint32_t addr;
#endif
{
Ptr trace[CM_MAX_STACK_TRACE];
S8 **funcNm;
- U8 idx;
- U8 i;
+ uint8_t idx;
+ uint8_t i;
S16 retVal;
S32 traceSize;
MemAllocInfo *memAllocInfo;
if( memLkCb.memLkMdlInit == FALSE)
{
- RETVOID;
+ return;
}
{
SLock(&memLkCb.memUsrMdl[idx][addr & 0x3].memLck);
retVal = cmHashListFind(&memLkCb.memUsrMdl[idx][addr & 0x3].memHashCp,
- (U8 *)&addr, sizeof(U32), 0,
+ (uint8_t *)&addr, sizeof(uint32_t), 0,
(PTR *)&memAllocInfo);
if(retVal == ROK)
{
#endif /* SS_MEM_LEAK_SOL */
/*cm_mem_c_001.main_25 : */
- RETVOID;
+ return;
} /* cmRlsAllocBlk */
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
* Desc: Initializes the memory leak detection module
*
*
-* Ret: RETVOID
+* Ret: void
*
* Notes: This function initializes the memory leak detection module.
*
#endif
{
CmMmBlkHdr *ptrBlk;
- U32 blkCnt;
+ uint32_t blkCnt;
bkt->trampleCount = 0;
CmMmBlkHdr *blkPtr;
#endif
{
- U32 sigCnt;
+ uint32_t sigCnt;
for ( sigCnt=0; sigCnt < CMM_TRAMPLING_SIGNATURE_LEN; sigCnt++)
PRIVATE S16 cmMmHashFunc
(
CmMmHashListCp *hashListCp,
-U32 key,
-U16 *idx
+uint32_t key,
+uint16_t *idx
)
#else
PRIVATE S16 cmMmHashFunc (hashListCp, key, idx)
CmMmHashListCp *hashListCp; /* hash list control point */
-U32 key; /* key string */
-U16 *idx; /* idx to return */
+uint32_t key; /* key string */
+uint16_t *idx; /* idx to return */
#endif
{
- *idx = (U16)(key % hashListCp->numOfbins);
+ *idx = (uint16_t)(key % hashListCp->numOfbins);
return ROK;
PRIVATE S16 cmMmHashListInit
(
CmMmHashListCp *hashListCp, /* hash list to initialize */
-U16 nmbBins, /* number of hash list bins */
+uint16_t nmbBins, /* number of hash list bins */
Region region, /* memory region to allocate bins */
Pool pool /* memory pool to allocate bins */
)
#else
PRIVATE S16 cmMmHashListInit(hashListCp, nmbBins, region, pool)
CmMmHashListCp *hashListCp; /* hash list to initialize */
-U16 nmbBins; /* number of hash list bins */
+uint16_t nmbBins; /* number of hash list bins */
Region region; /* memory region to allocate bins */
Pool pool; /* memory pool to allocate bins */
#endif
{
- U16 i;
+ uint16_t i;
CmMmHashListEnt *hl;
PRIVATE S16 cmMmHashListInsert
(
CmMmHashListCp *hashListCp, /* hash list to add to */
-U32 key /* pointer to key */
+uint32_t key /* pointer to key */
)
#else
PRIVATE S16 cmMmHashListInsert(hashListCp, key)
CmMmHashListCp *hashListCp; /* hash list to add to */
-U32 key; /* pointer to key */
+uint32_t key; /* pointer to key */
#endif
{
CmMmHashListEnt *hashListEnt; /* pointer to hash list entry header */
- U16 idx; /* index for insertion into hash list */
- U16 i;
+ uint16_t idx; /* index for insertion into hash list */
+ uint16_t i;
/* check if hashListCp is initialised yet */
PRIVATE S16 cmHstGrmFreeInsert
(
CmHstGrmHashListCp* hashListCp, /* hash list cp */
-U32 blkSz, /* size of the block freed */
-U32 line, /* Line number */
-U8 *fileName, /* file name */
-U8 entId /* Tapa task which free the memory */
+uint32_t blkSz, /* size of the block freed */
+uint32_t line, /* Line number */
+uint8_t *fileName, /* file name */
+uint8_t entId /* Tapa task which free the memory */
)
#else
PRIVATE S16 cmHstGrmFreeInsert(hashListCp, blkSz, line, fileName, entId)
CmHstGrmHashListCp* hashListCp; /* hash list cp */
-U32 blkSz; /* size of the block freed */
-U32 line; /* line number */
-U8 *fileName; /* file Name */
-U8 entId; /* Tapa task which frees the memory */
+uint32_t blkSz; /* size of the block freed */
+uint32_t line; /* line number */
+uint8_t *fileName; /* file Name */
+uint8_t entId; /* Tapa task which frees the memory */
#endif
{
- U32 binIdx = 0; /* Bin index to insert the entry into the hash list */
- U32 key = 0; /* Key to fine the bin index */
- U32 ret = 0; /* Return value */
+ uint32_t binIdx = 0; /* Bin index to insert the entry into the hash list */
+ uint32_t key = 0; /* Key to fine the bin index */
+ uint32_t ret = 0; /* Return value */
CmMemEntries *entry = NULLP; /* Entry which contains the information */
PRIVATE S16 cmHstGrmAllocInsert
(
CmHstGrmHashListCp *hashListCp,
-U32 blkSz,
-U32 *reqSz,
-U32 line,
-U8 *fileName,
-U8 entId
+uint32_t blkSz,
+uint32_t *reqSz,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId
)
#else
PRIVATE S16 cmHstGrmAllocInsert(hashListCp, blkSz, reqSz, line, fileName, entId)
CmHstGrmHashListCp *hashListCp;
-U32 blkSz;
-U32 *reqSz;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t blkSz;
+uint32_t *reqSz;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
#endif
{
- U32 binIdx = 0;
- U32 key = 0;
- U32 ret = 0;
+ uint32_t binIdx = 0;
+ uint32_t key = 0;
+ uint32_t ret = 0;
CmMemEntries *entry = NULLP;
#ifdef ANSI
PRIVATE S16 cmHstGrmGetHashIdxAndKey
(
-U8 *fileName,
-U32 line,
-U32 *binIdx,
-U32 *key
+uint8_t *fileName,
+uint32_t line,
+uint32_t *binIdx,
+uint32_t *key
)
#else
PRIVATE S16 cmHstGrmGetHashIdxAndKey(fileName, line, binIdx, key)
-U8 *fileName;
-U32 line;
-U32 *binIdx;
-U32 *key;
+uint8_t *fileName;
+uint32_t line;
+uint32_t *binIdx;
+uint32_t *key;
#endif
{
- U32 i = 0;
+ uint32_t i = 0;
/* Calculate the key using file name and line number */
for(i = 0 ; fileName[i] != '\0'; i++)
PRIVATE S16 cmHstGrmFillEntry
(
CmMemEntries *entry,
-U32 key,
-U32 line,
-U8 *fileName,
-U8 entId
+uint32_t key,
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId
)
#else
PRIVATE S16 cmHstGrmFillEntry(entry, key, line, fileName, entId)
CmMemEntries *entry;
-U32 key;
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t key;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
#endif
{
- U32 idx = 0;
+ uint32_t idx = 0;
entry->key = key;
entry->line = line;
entry->entId = entId;
PRIVATE S16 cmHstGrmFindEntry
(
CmHstGrmHashListCp *hashListCp,
-U32 key,
-U32 *binIdx,
+uint32_t key,
+uint32_t *binIdx,
CmMemEntries **entry
)
#else
PRIVATE S16 cmHstGrmFindEntry(hashListCp, key, binIdx, entry)
CmHstGrmHashListCp *hashListCp;
-U32 key;
-U32 *binIdx;
+uint32_t key;
+uint32_t *binIdx;
CmMemEntries **entry;
#endif
{
- U32 numEnt = 0;
- U32 numBin = 0;
+ uint32_t numEnt = 0;
+ uint32_t numBin = 0;
CmHstGrmHashListEnt *tmpBin = NULLP;
#endif /* SS_HISTOGRAM_SUPPORT */
#ifdef T2K_MEM_LEAK_DBG
T2kMeamLeakInfo gMemLeakInfo[T2K_MEM_LEAK_INFO_TABLE_SIZE];
-U32 getT2kMemLeakIndex(U32 address)
+uint32_t getT2kMemLeakIndex(uint32_t address)
{
return ((address - T2K_MEM_LEAK_START_ADDR) >> 8);
}
-static U32 t2kMemAllocTick;
-static U32 smallTick;
+static uint32_t t2kMemAllocTick;
+static uint32_t smallTick;
-void InsertToT2kMemLeakInfo(U32 address, U32 size, U32 lineNo, char* fileName)
+void InsertToT2kMemLeakInfo(uint32_t address, uint32_t size, uint32_t lineNo, char* fileName)
{
- U32 idx = getT2kMemLeakIndex(address);
+ uint32_t idx = getT2kMemLeakIndex(address);
- if(((U32)(address - T2K_MEM_LEAK_START_ADDR) & 0xff) !=0)
+ if(((uint32_t)(address - T2K_MEM_LEAK_START_ADDR) & 0xff) !=0)
{
printf("address in InsertToT2kMemLeakInfo is %lx size = %ld file is %s"
"line is %ld \n", address, size, fileName, lineNo);
}
-void RemoveFromT2kMemLeakInfo(U32 address, char *file, U32 line)
+void RemoveFromT2kMemLeakInfo(uint32_t address, char *file, uint32_t line)
{
- U32 idx = getT2kMemLeakIndex(address);
+ uint32_t idx = getT2kMemLeakIndex(address);
if(idx >= T2K_MEM_LEAK_INFO_TABLE_SIZE)
{
#ifdef ANSI
S16 UpdateSocMemInfo
(
-U8 areaIndex,
+uint8_t areaIndex,
CmLteMemInfo *mInfo
)
#else
S16 UpdateSocMemInfo(areaIndex,mInfo)
-U8 areaIndex;
+uint8_t areaIndex;
CmLteMemInfo *mInfo;
#endif
{
- U8 idxReg;
- U8 idxPool;
- U16 numPool;
+ uint8_t idxReg;
+ uint8_t idxPool;
+ uint16_t numPool;
void *iccHdl = NULLP;
- U32 poolFreeCnt[4];
- U32 poolUsedCnt[4];
- U32 poolSize[4];
- U32 poolTotAvail[4];
+ uint32_t poolFreeCnt[4];
+ uint32_t poolUsedCnt[4];
+ uint32_t poolSize[4];
+ uint32_t poolTotAvail[4];
idxReg = mInfo->numRegions;
mInfo->numRegions = mInfo->numRegions + 1;
*
*/
#ifdef ANSI
-U32 isL2MemUsageBelowLowerThreshold(
+uint32_t isL2MemUsageBelowLowerThreshold(
Region region
)
#else
-U32 isL2MemUsageBelowLowerThreshold(region)
+uint32_t isL2MemUsageBelowLowerThreshold(region)
Region region;
#endif
{
void * iccHdl = ssGetIccHdl(region);
- U32 poolZeroFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ZERO_SIZE);
- U32 poolOneFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ONE_SIZE);
+ uint32_t poolZeroFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ZERO_SIZE);
+ uint32_t poolOneFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ONE_SIZE);
/* We are below the threshold if free count in BOTH of the pools
* is above the ICC_MEM_LOWER_THRESHOLD % */
*
*/
#ifdef ANSI
-U32 isMemUsageBelowLowerThreshold(
+uint32_t isMemUsageBelowLowerThreshold(
Region region
)
#else
-U32 isMemUsageBelowLowerThreshold(region)
+uint32_t isMemUsageBelowLowerThreshold(region)
Region region;
#endif
{
void * iccHdl = ssGetIccHdl(region);
- U32 poolZeroFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ZERO_SIZE);
- U32 poolOneFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ONE_SIZE);
- U32 poolTwoFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_TWO_SIZE);
- U32 poolThreeFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_THREE_SIZE);
+ uint32_t poolZeroFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ZERO_SIZE);
+ uint32_t poolOneFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ONE_SIZE);
+ uint32_t poolTwoFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_TWO_SIZE);
+ uint32_t poolThreeFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_THREE_SIZE);
/* We are below the threshold if free count in BOTH of the pools
* is above the ICC_MEM_LOWER_THRESHOLD % */
*
*/
#ifdef ANSI
-PRIVATE U32 isMemUsageAboveUpperThreshold(
+PRIVATE uint32_t isMemUsageAboveUpperThreshold(
Region region
)
#else
-PRIVATE U32 isMemUsageAboveUpperThreshold(region)
+PRIVATE uint32_t isMemUsageAboveUpperThreshold(region)
Region region;
#endif
{
void * iccHdl = ssGetIccHdl(region);
- U32 poolZeroFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ZERO_SIZE);
- U32 poolOneFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ONE_SIZE);
- U32 poolTwoFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_TWO_SIZE);
- U32 poolThreeFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_THREE_SIZE);
+ uint32_t poolZeroFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ZERO_SIZE);
+ uint32_t poolOneFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_ONE_SIZE);
+ uint32_t poolTwoFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_TWO_SIZE);
+ uint32_t poolThreeFreeCnt = TL_GetFreeBlocks(iccHdl, ICC_POOL_THREE_SIZE);
/* We are above the threshold if free count in either of the pools
* is below the ICC_MEM_UPPER_THRESHOLD % */
*
*/
#ifdef ANSI
-U32 isMemThreshReached(
+uint32_t isMemThreshReached(
Region reg
)
#else
-U32 isMemThreshReached(reg)
+uint32_t isMemThreshReached(reg)
Region reg;
#endif
{
/* Size-To-Bucket map table structure */
struct cmMmMapBkt
{
- U16 bktIdx; /* The index to the memory bucket */
+ uint16_t bktIdx; /* The index to the memory bucket */
#if (ERRCLASS & ERRCLS_DEBUG)
- U16 numReq; /* Number of the allocation request */
- U16 numFailure; /* Number of allocation failure form the bucket */
+ uint16_t numReq; /* Number of the allocation request */
+ uint16_t numFailure; /* Number of allocation failure form the bucket */
#endif
};
{
CmLList memSetNode; /* Linked list of the first pointer of the
bucket */
- U32 numFreeBlks; /* Number of Free Blocks avilable in the current
+ uint32_t numFreeBlks; /* Number of Free Blocks avilable in the current
set */
CmMmEntry *nextBktPtr; /* Address of the first bucket which will be
used for the allocation */
* will be used in global region */
struct cmMmGlobalBktCb
{
- U8 poolId; /* Pool Id */
+ uint8_t poolId; /* Pool Id */
Size size; /* Size of the pool */
CmLListCp listValidBktSet; /* LList Cp used to store the nodes of memory element
node which holds valid pointers */
node which holds invalid information */
CmMmEntry *startAddr; /* Starting address */
CmMmEntry *next; /* Next address which will be allocated */
- U32 numBlks; /* Total number of buckets configured */
- U32 bucketSetSize;
- U32 bktFailCnt; /* bucket alloc failure count */
- U32 bktNoFitCnt; /* number of blocks not fit */
+ uint32_t numBlks; /* Total number of buckets configured */
+ uint32_t bucketSetSize;
+ uint32_t bktFailCnt; /* bucket alloc failure count */
+ uint32_t bktNoFitCnt; /* number of blocks not fit */
SLockId bucketLock; /* Lock used for the allocation/freeing of
the set of buckets */
};
* is used in the system taks local region */
struct cmMmDynBktCb
{
- U8 poolId; /* Pool Id */
+ uint8_t poolId; /* Pool Id */
Size size; /* Size of the pool */
CmLListCp memBlkSetElem; /* Memory set element likend list */
CmMmBlkSetElement *crntMemBlkSetElem; /* Pointer to the current memort block set */
CmMmEntry *startAddr; /* Starting address */
CmMmEntry *next; /* Next address which will be allocated */
- U32 numBktAlloc; /* Total number of buckets allocted */
- U32 numBkt; /* Total number of buckets configured */
- U16 bucketSetSize; /* Size of bucket sets */
- U16 blkSetRelThreshold; /* Upper threshold of bucket count upon
+ uint32_t numBktAlloc; /* Total number of buckets allocted */
+ uint32_t numBkt; /* Total number of buckets configured */
+ uint16_t bucketSetSize; /* Size of bucket sets */
+ uint16_t blkSetRelThreshold; /* Upper threshold of bucket count upon
reaching will free the set to global region */
- U16 blkSetAcquireThreshold; /* Lower threshold of bucket count upon
+ uint16_t blkSetAcquireThreshold; /* Lower threshold of bucket count upon
reaching will request the set from
global region */
- U32 bktFailCnt; /* bucket alloc failure count */
- U32 bktNoFitCnt; /* number of blocks not fit */
+ uint32_t bktFailCnt; /* bucket alloc failure count */
+ uint32_t bktNoFitCnt; /* number of blocks not fit */
};
/* The individual Task regionCb which will be associate with every system
struct cmMmDynRegCb
{
Region region; /* Region Id of the memory */
- U16 bktSize[CMM_MAX_BKT_ENT]; /* Bucket Size */
+ uint16_t bktSize[CMM_MAX_BKT_ENT]; /* Bucket Size */
void *iccHdl; /* Handler used for ICC memory */
SsAlloc alloc; /* allocation function pointer */
SsFree free; /* deallocation function pointer */
struct cmMmDynRegCb
{
Region region; /* Region Id of the memory */
- U8 regType; /* Region Type, static or dynamic or global */
- U8 numBktBlk; /* Keeps the count of number of bucket set blocks */
- U16 numBkts; /* Number of buckets in the Bucket Pool */
+ uint8_t regType; /* Region Type, static or dynamic or global */
+ uint8_t numBktBlk; /* Keeps the count of number of bucket set blocks */
+ uint16_t numBkts; /* Number of buckets in the Bucket Pool */
Size bktSize; /* Size of the memory used for the bucket pool */
- U16 bktQnPwr; /* Quantum size of the bucket pool */
+ uint16_t bktQnPwr; /* Quantum size of the bucket pool */
Size bktMaxBlkSize; /* Maximum size of block in the bucket pool */
CmMmDynBktCb bktTbl[CMM_MAX_BKT_ENT]; /* Pointer to the memory bkt tbl */
SsAlloc alloc; /* allocation function pointer */
struct cmMmGlobRegCb
{
Region region; /* Region Id of the memory */
- U16 numBkts; /* Number of buckets in the Bucket Pool */
+ uint16_t numBkts; /* Number of buckets in the Bucket Pool */
CmMmGlobalBktCb bktTbl[CMM_MAX_BKT_ENT]; /* Pointer to the memory bkt tbl */
};
struct cmMmBktCfg
{
Size size; /* Size of the memory block */
- U32 numBlks; /* Number of the block in the bucket */
+ uint32_t numBlks; /* Number of the block in the bucket */
};
/* Memory Region configuration structure. */
{
Size size; /* Size of the memory */
Data *vAddr; /* Start address of the memory */
- U8 lType; /* Lock Type to be used */
+ uint8_t lType; /* Lock Type to be used */
- U8 chFlag; /* Flag defines the memory region characteristics */
+ uint8_t chFlag; /* Flag defines the memory region characteristics */
Data *pAddr; /* Physical address of the memory block: Valid
if CMM_REG_PHY_VALID bit of chFlag is set */
Size bktQnSize; /* Quatum size of the memory block */
- U16 numBkts; /* Number of buckets in the Bucket Pool */
+ uint16_t numBkts; /* Number of buckets in the Bucket Pool */
CmMmBktCfg bktCfg[CMM_MAX_BKT_ENT]; /* Bucket configuration structure */
};
#ifdef SS_HISTOGRAM_SUPPORT
struct cmMemEntries /* Entry information */
{
- U32 line; /* Line Number where memory allocation primitive used */
- U32 allocBytes; /* Granted Byte */
- U32 allocOverFlow; /* If the value of allocBytes overflows then we use this variable */
- U32 freedBytes; /* Freed Bytes */
- U32 freeOverFlow; /* If the value of freeByte overflows then we use this value */
- U32 wastedBytes; /* Difference between Granted and Requested bytes */
- U32 bucketAllocReq; /* No of times this Bucket used */
- U32 bucketFreeReq; /* No of times this Bucket freed */
- U32 entId; /* Tapa task used this bucket */
- U32 key; /* combination of file name and line */
- U8 fileName[CMM_HIST_MAX_FILENAME]; /* File Name where memory allocation primitive used */
+ uint32_t line; /* Line Number where memory allocation primitive used */
+ uint32_t allocBytes; /* Granted Byte */
+ uint32_t allocOverFlow; /* If the value of allocBytes overflows then we use this variable */
+ uint32_t freedBytes; /* Freed Bytes */
+ uint32_t freeOverFlow; /* If the value of freeByte overflows then we use this value */
+ uint32_t wastedBytes; /* Difference between Granted and Requested bytes */
+ uint32_t bucketAllocReq; /* No of times this Bucket used */
+ uint32_t bucketFreeReq; /* No of times this Bucket freed */
+ uint32_t entId; /* Tapa task used this bucket */
+ uint32_t key; /* combination of file name and line */
+ uint8_t fileName[CMM_HIST_MAX_FILENAME]; /* File Name where memory allocation primitive used */
};
struct cmHstGrmHashListEnt /* hash list entry */
{
CmMemEntries entries[CMM_HIST_MAX_MEM_ENTRY_PER_BIN]; /* Number of entires in each bin */
- U32 numOfEntries; /*Number of entries in hash list */
+ uint32_t numOfEntries; /*Number of entries in hash list */
};
struct cmHstGrmHashListCp /* Hash List control pointer */
{
CmHstGrmHashListEnt hashList[CMM_HIST_MAX_MEM_BIN]; /* Number of bins in hash list */
- U16 totalNumEntries; /* Total number of bins */
+ uint16_t totalNumEntries; /* Total number of bins */
};
#endif /* SS_HISTOGRAM_SUPPORT */
struct cmMmBlkHdr
{
/* trSignature shall always be maintained as the first element in this structure */
- U8 trSignature[CMM_TRAMPLING_SIGNATURE_LEN]; /* signature to detect trampling */
+ uint8_t trSignature[CMM_TRAMPLING_SIGNATURE_LEN]; /* signature to detect trampling */
CmMmBlkHdr *nextBlk; /* pointer to the next memory block header */
- U32 memFlags; /* Free/Static/Dynamic */
+ uint32_t memFlags; /* Free/Static/Dynamic */
Size requestedSize; /* requested size for which this mem blk has been allocated */
};
#endif /* SSI_DEBUG_LEVEL1 */
CmMmEntry *next; /* Pointer to the next memory block */
#endif /* SSI_DEBUG_LEVEL1 */
Size size; /* Size of the block */
- U32 numBlks; /* Total number of blocks in the bucket */
- U32 maxAlloc; /* Maximum number of blocks allocated till now */
- U32 numAlloc; /* Number of blocks allocated */
+ uint32_t numBlks; /* Total number of blocks in the bucket */
+ uint32_t maxAlloc; /* Maximum number of blocks allocated till now */
+ uint32_t numAlloc; /* Number of blocks allocated */
SLockId bktLock; /* Lock to protect the bucket pool */
- U32 bktFailCnt; /* bucket alloc failure count */
- U32 bktNoFitCnt; /* number of blocks not fit */
+ uint32_t bktFailCnt; /* bucket alloc failure count */
+ uint32_t bktNoFitCnt; /* number of blocks not fit */
/* cm_mem_x_001.main_9 - addition of statistics related data */
#ifdef SSI_DEBUG_LEVEL1
Data *bktStartPtr; /* maintains the start address of the memory block in the bucket */
StsCntr numDeallocAttempts; /* total number of de-allocation attempts */
Size staticMemUsed; /* amount of memory used for static allocations */
Size dynamicMemUsed; /* amount of memory used for dynamic allocations */
- U8 trampleCount; /* incremented everytime a trampling is detected in any block of the bucket */
+ uint8_t trampleCount; /* incremented everytime a trampling is detected in any block of the bucket */
#endif /*SSI_DEBUG_LEVEL1*/
/* cm_mem_x_001.main_11: Additions */
#ifdef SS_HISTOGRAM_SUPPORT
/* cm_mem_x_001.main_9 - addition to provide trampling and double-free detections support */
#ifdef SSI_DEBUG_LEVEL1
/* trSignature shall always be maintianed as the first element in this structure */
- U8 trSignature[CMM_TRAMPLING_SIGNATURE_LEN]; /* signature to detect trampling */
- U32 memFlags; /* flag to maintain the memory status */
+ uint8_t trSignature[CMM_TRAMPLING_SIGNATURE_LEN]; /* signature to detect trampling */
+ uint32_t memFlags; /* flag to maintain the memory status */
Size requestedSize; /* size of the heap entry block */
#endif /* SSI_DEBUG_LEVEL1 */
CmHEntry *next; /* Pointer to the next entry block */
Size minSize; /* Minimum size that can be allocated */
SLockId heapLock; /* Lock to protect the heap pool */
#if (ERRCLASS & ERRCLS_DEBUG)
- U16 numFragBlk; /* Number of fragmented block */
- U16 numReq; /* Number of allocation request */
- U16 numFailure; /* Number of allocation failure */
+ uint16_t numFragBlk; /* Number of fragmented block */
+ uint16_t numReq; /* Number of allocation request */
+ uint16_t numFailure; /* Number of allocation failure */
#endif
- U32 heapAllocCnt; /* Number of blocks from heap */
+ uint32_t heapAllocCnt; /* Number of blocks from heap */
/* cm_mem_x_001.main_9 - addition of statistics related data */
#ifdef SSI_DEBUG_LEVEL1
Size staticHeapMemUsed; /* amount of heap memory used for static allocations */
/* Update this in cmMmHeapInit if cmHEntry is changed */
StsCntr numAllocAttempts; /* total number of allocation attempts in heap */
StsCntr numDeallocAttempts; /* total number of de-allocation attempts in heap */
- U8 trampleCount; /* incremented everytime a trampling is detected in any block of the heap */
+ uint8_t trampleCount; /* incremented everytime a trampling is detected in any block of the heap */
#endif /* SSI_DEBUG_LEVEL1 */
/* cm_mem_x_001.main_11: Additions */
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef SSI_DEBUG_LEVEL1
struct cmMmHashListEnt /* hash list entry */
{
- U32 size; /* pointer to key */
- U32 numAttempts; /* number of attempts */
+ uint32_t size; /* pointer to key */
+ uint32_t numAttempts; /* number of attempts */
};
struct cmMmHashListCp
{
CmMmHashListEnt *hashList;
- U16 numOfbins;
- U16 numOfEntries;
+ uint16_t numOfbins;
+ uint16_t numOfEntries;
};
#endif /* SSI_DEBUG_LEVEL1 */
Region region; /* Region Id of the memory */
SRegInfo regInfo; /* Region information block */
- U8 chFlag; /* Flag defines the region characteristics */
+ uint8_t chFlag; /* Flag defines the region characteristics */
Data *pAddr; /* Physical address of the memory block.
Valid if CMM_REG_PHY_VALID bit is set */
Size bktSize; /* Size of the memory used for the bucket pool */
- U16 bktQnPwr; /* Quantum size of the bucket pool */
+ uint16_t bktQnPwr; /* Quantum size of the bucket pool */
Size bktMaxBlkSize; /* Maximum size of block in the bucket pool */
- U16 numBkts; /* Number of buckets in the Bucket Pool */
+ uint16_t numBkts; /* Number of buckets in the Bucket Pool */
CmMmMapBkt mapTbl[CMM_MAX_MAP_ENT]; /* size-to-bucket map table */
CmMmBkt bktTbl[CMM_MAX_BKT_ENT]; /* Pointer to the memory bkt tbl */
typedef struct _memAllocInfo
{
CmHashListEnt ent;
- U32 memAddr;
+ uint32_t memAddr;
Size reqSz;
Size allocSz;
- U16 bktIdx;
- U8 moduleId;
- U8 bTrcSz;
+ uint16_t bktIdx;
+ uint8_t moduleId;
+ uint8_t bTrcSz;
PTR backTrace;
}MemAllocInfo;
EXTERN Void cmInitMemLeakMdl ARGS((Void));
/* cm_mem_x_001.main_12 : Additions */
EXTERN Void cmDeinitMemLeakMdl ARGS((Void));
-EXTERN Void cmStorAllocBlk ARGS((U32 addr, Size reqSz, Size allocSz,
- U16 bktIdx));
-EXTERN Void cmRlsAllocBlk ARGS((U32 addr));
-EXTERN U8 cmMemGetModuleId ARGS((S8 **funNm, S32 traceSize));
-EXTERN S16 cmMemGetStrMtchIdx ARGS((U8 strtIdx, U8 endIdx,
+EXTERN Void cmStorAllocBlk ARGS((uint32_t addr, Size reqSz, Size allocSz,
+ uint16_t bktIdx));
+EXTERN Void cmRlsAllocBlk ARGS((uint32_t addr));
+EXTERN uint8_t cmMemGetModuleId ARGS((S8 **funNm, S32 traceSize));
+EXTERN S16 cmMemGetStrMtchIdx ARGS((uint8_t strtIdx, uint8_t endIdx,
S8 *str, S8 **strLst));
EXTERN Void cmMemOpenMemLkFile ARGS((S8 *arg));
EXTERN Void SLogLkInfo ARGS((Void));
EXTERN Void printMacCellInfo ARGS((Void));
EXTERN Void printSchCellInfo ARGS((Void));
-EXTERN U32 isMemThreshReached ARGS((Region region));
+EXTERN uint32_t isMemThreshReached ARGS((Region region));
EXTERN S16 cmMmStatRegInit ARGS((Region region, CmMmRegCb *regCb, CmMmRegCfg *cfg));
EXTERN S16 cmMmGlobRegInit ARGS((CmMmGlobRegCb *regCb));
EXTERN S16 cmMmDynRegInit ARGS((CmMmDynRegCb *regCb));
#ifdef USE_MALLOC
-EXTERN S16 ssGetDynMemBlkSet ARGS((U8 bktIdx, CmMmBlkSetElement *dynMemSetElem));
-EXTERN S16 ssPutDynMemBlkSet ARGS((U8 bktIdx, CmMmBlkSetElement *dynMemSetElem));
+EXTERN S16 ssGetDynMemBlkSet ARGS((uint8_t bktIdx, CmMmBlkSetElement *dynMemSetElem));
+EXTERN S16 ssPutDynMemBlkSet ARGS((uint8_t bktIdx, CmMmBlkSetElement *dynMemSetElem));
#else
-EXTERN S16 ssPutDynMemBlkSet ARGS((U8 bktIdx,CmMmBlkSetElement *dynMemSetElem,
- U32 doNotBlockForLock));
-EXTERN S16 ssGetDynMemBlkSet ARGS((U8 bktIdx, CmMmBlkSetElement *dynMemSetElem,
- U32 doNotBlockForLock));
+EXTERN S16 ssPutDynMemBlkSet ARGS((uint8_t bktIdx,CmMmBlkSetElement *dynMemSetElem,
+ uint32_t doNotBlockForLock));
+EXTERN S16 ssGetDynMemBlkSet ARGS((uint8_t bktIdx, CmMmBlkSetElement *dynMemSetElem,
+ uint32_t doNotBlockForLock));
#endif /* USE_MALLOC */
#endif /* SS_LOCKLESS_MEMORY */
#ifdef __cplusplus
pst.event = TENBSTATSINIT;
SPstTsk(&pst, pBuf);
- RETVOID;
+ return;
}
/*
//TODO
TSInfTrigL2Stats(region, pool);
- RETVOID;
+ return;
}
#endif
{
S32 i;
- U32 k;
+ uint32_t k;
CMCHKPK(oduUnpackUInt32, stats->persistent.numDeactivation, mBuf);
CMCHKPK(oduUnpackUInt32, stats->nonPersistent.sch[k].dlTxOccns, mBuf);
}
CMCHKPK(oduUnpackUInt32, stats->rnti, mBuf);
- RETVOID;
+ return;
}
#ifdef ANSI
CMCHKPK(oduUnpackUInt32, stats->cellId, mBuf);
- RETVOID;
+ return;
}
#ifdef ANSI
#endif
{
S32 i;
- U32 k;
+ uint32_t k;
CMCHKUNPK(oduPackUInt32, &stats->rnti, mBuf);
CMCHKUNPK(oduPackUInt32, &stats->persistent.numActivation, mBuf);
CMCHKUNPK(oduPackUInt32, &stats->persistent.numDeactivation, mBuf);
- RETVOID;
+ return;
}
#ifdef ANSI
CMCHKUNPK(oduPackUInt32, &stats->rlc.maxRlcDrbRetxFail, mBuf);
CMCHKUNPK(oduPackUInt32, &stats->rlc.reOdrTmrExp, mBuf);
- RETVOID;
+ return;
}
#ifdef ANSI
SPkS16(suId, mBuf);
pst->event = (Event) EVTTENBL2UESTATS;
SPstTsk(pst, mBuf);
- RETVOID;
+ return;
}
#ifdef ANSI
TSInfUtlUnpkUeInfo(mBuf, &stats);
SPutMsg(mBuf);
(*func)(pst, suId, &stats);
- RETVOID;
+ return;
}
#ifdef ANSI
SPkS16(suId, mBuf);
pst->event = (Event) EVTTENBL2CELLSTATS;
SPstTsk(pst, mBuf);
- RETVOID;
+ return;
}
#ifdef ANSI
TSInfUtlUnpkCellInfo(mBuf, &stats);
SPutMsg(mBuf);
(*func)(pst, suId, &stats);
- RETVOID;
+ return;
}
#endif /* TENB_STATS */
typedef struct tsInfL2CellStats
{
- U32 cellId;
+ uint32_t cellId;
struct schCellStats{
- U32 msg4Fail;
- U32 msg3Fail;
- U32 dlSumCw0Cqi;
- U32 dlNumCw0Cqi;
- U32 dlSumCw1Cqi;
- U32 dlNumCw1Cqi;
- U32 dlSumCw0iTbs;
- U32 dlNumCw0iTbs;
- U32 dlSumCw1iTbs;
- U32 dlNumCw1iTbs;
- U32 riCnt[4]; /* Rank = 1..4 */
- U32 dlNack[2][4];
- U32 dlAckNack[2][4]; /* [CW_CNT][RV_CNT] */
- U32 dlDtx[2][4];
- U32 ulNack[4];
- U32 ulAckNack[4]; /* [RV_CNT] */
- U32 ulDtx[4];
- U32 dlPrbUsage[10]; /* dlPrbUsage[0] to have overall PRB usage */
- U32 ulPrbUsage[10]; /* dlPrbUsage[0] to have overall PRB usage */
- U32 dlPdbRatio[10];
- U32 avgTtiProcTime; /* In us */
- U32 cntTtiProcTime1000; /* Count of instances where TTI proc time was
+ uint32_t msg4Fail;
+ uint32_t msg3Fail;
+ uint32_t dlSumCw0Cqi;
+ uint32_t dlNumCw0Cqi;
+ uint32_t dlSumCw1Cqi;
+ uint32_t dlNumCw1Cqi;
+ uint32_t dlSumCw0iTbs;
+ uint32_t dlNumCw0iTbs;
+ uint32_t dlSumCw1iTbs;
+ uint32_t dlNumCw1iTbs;
+ uint32_t riCnt[4]; /* Rank = 1..4 */
+ uint32_t dlNack[2][4];
+ uint32_t dlAckNack[2][4]; /* [CW_CNT][RV_CNT] */
+ uint32_t dlDtx[2][4];
+ uint32_t ulNack[4];
+ uint32_t ulAckNack[4]; /* [RV_CNT] */
+ uint32_t ulDtx[4];
+ uint32_t dlPrbUsage[10]; /* dlPrbUsage[0] to have overall PRB usage */
+ uint32_t ulPrbUsage[10]; /* dlPrbUsage[0] to have overall PRB usage */
+ uint32_t dlPdbRatio[10];
+ uint32_t avgTtiProcTime; /* In us */
+ uint32_t cntTtiProcTime1000; /* Count of instances where TTI proc time was
greater than 1000us */
- U32 cntTtiProcTime900; /* Count of instances where TTI proc time was
+ uint32_t cntTtiProcTime900; /* Count of instances where TTI proc time was
greater than 900us and less than 1000us */
- U32 cntTtiProcTime800;
- U32 cntTtiProcTime700;
- U32 cntTtiProcTime600;
- U32 cntTtiProcTime500;
+ uint32_t cntTtiProcTime800;
+ uint32_t cntTtiProcTime700;
+ uint32_t cntTtiProcTime600;
+ uint32_t cntTtiProcTime500;
#ifdef RG_5GTF
- U32 dl5gtfUePick;
- U32 dl5gtfRbAllocPass;
- U32 dl5gtfRbAllocFail;
- U32 dl5gtfFnlzPass;
- U32 dl5gtfFnlzFail;
- U32 dl5gtfBoUpd;
- U32 dl5gtfPdcchSend;
- U32 dl5gtfPdschCons;
+ uint32_t dl5gtfUePick;
+ uint32_t dl5gtfRbAllocPass;
+ uint32_t dl5gtfRbAllocFail;
+ uint32_t dl5gtfFnlzPass;
+ uint32_t dl5gtfFnlzFail;
+ uint32_t dl5gtfBoUpd;
+ uint32_t dl5gtfPdcchSend;
+ uint32_t dl5gtfPdschCons;
- U32 ul5gtfSrRecv;
- U32 ul5gtfBsrRecv;
- U32 ul5gtfUeSchPick;
- U32 ul5gtfPdcchSchd;
- U32 ul5gtfAllocAllocated;
- U32 ul5gtfUeRbAllocDone;
- U32 ul5gtfUeRmvFnlzZeroBo;
- U32 ul5gtfUeFnlzReAdd;
- U32 ul5gtfPdcchSend;
- U32 ul5gtfRbAllocFail;
+ uint32_t ul5gtfSrRecv;
+ uint32_t ul5gtfBsrRecv;
+ uint32_t ul5gtfUeSchPick;
+ uint32_t ul5gtfPdcchSchd;
+ uint32_t ul5gtfAllocAllocated;
+ uint32_t ul5gtfUeRbAllocDone;
+ uint32_t ul5gtfUeRmvFnlzZeroBo;
+ uint32_t ul5gtfUeFnlzReAdd;
+ uint32_t ul5gtfPdcchSend;
+ uint32_t ul5gtfRbAllocFail;
#endif
- U32 ulSumCqi;
- U32 ulNumCqi;
- U32 ulSumiTbs;
- U32 ulNumiTbs;
- U32 dlTtlTpt;
- U32 ulTtlTpt;
+ uint32_t ulSumCqi;
+ uint32_t ulNumCqi;
+ uint32_t ulSumiTbs;
+ uint32_t ulNumiTbs;
+ uint32_t dlTtlTpt;
+ uint32_t ulTtlTpt;
}sch;
struct rlcCellStats{
- U32 maxRlcSrbRetxFail;
- U32 maxRlcDrbRetxFail;
- U32 reOdrTmrExp;
+ uint32_t maxRlcSrbRetxFail;
+ uint32_t maxRlcDrbRetxFail;
+ uint32_t reOdrTmrExp;
}rlc;
}TSInfL2CellStats;
typedef struct tsInfL2UeStats
{
- U32 rnti;
+ uint32_t rnti;
struct nonPersistentUeStats{
struct schUeStats{
- U32 dlTxOccns;
- U32 dlRetxOccns;
- U32 dlPrbUsg;
- U32 dlNackCnt[2]; /* [CW_CNT] */
- U32 dlAckNackCnt[2]; /* [CW_CNT] */
- U32 dlDtxCnt[2]; /* [CW_CNT] */
- U32 dlSumCw0Cqi;
- U32 dlNumCw0Cqi;
- U32 dlSumCw1Cqi;
- U32 dlNumCw1Cqi;
- U32 dlSumCw0iTbs;
- U32 dlNumCw0iTbs;
- U32 dlSumCw1iTbs;
- U32 dlNumCw1iTbs;
- U32 cqiDropCnt;
- U32 dlPdbLvl[5]; /* PDB Levels */
- U32 riCnt[4]; /* Rank = 1..4 */
- U32 dlBo;
- U32 dlTpt;
- U32 ulTxOccns;
- U32 ulRetxOccns;
- U32 ulPrbUsg;
- U32 ulAckNackCnt;
- U32 ulNackCnt;
- U32 ulDtxCnt;
- U32 ulSumCqi;
- U32 ulNumCqi;
- U32 ulSumiTbs;
- U32 ulNumiTbs;
- U32 ulTpt;
+ uint32_t dlTxOccns;
+ uint32_t dlRetxOccns;
+ uint32_t dlPrbUsg;
+ uint32_t dlNackCnt[2]; /* [CW_CNT] */
+ uint32_t dlAckNackCnt[2]; /* [CW_CNT] */
+ uint32_t dlDtxCnt[2]; /* [CW_CNT] */
+ uint32_t dlSumCw0Cqi;
+ uint32_t dlNumCw0Cqi;
+ uint32_t dlSumCw1Cqi;
+ uint32_t dlNumCw1Cqi;
+ uint32_t dlSumCw0iTbs;
+ uint32_t dlNumCw0iTbs;
+ uint32_t dlSumCw1iTbs;
+ uint32_t dlNumCw1iTbs;
+ uint32_t cqiDropCnt;
+ uint32_t dlPdbLvl[5]; /* PDB Levels */
+ uint32_t riCnt[4]; /* Rank = 1..4 */
+ uint32_t dlBo;
+ uint32_t dlTpt;
+ uint32_t ulTxOccns;
+ uint32_t ulRetxOccns;
+ uint32_t ulPrbUsg;
+ uint32_t ulAckNackCnt;
+ uint32_t ulNackCnt;
+ uint32_t ulDtxCnt;
+ uint32_t ulSumCqi;
+ uint32_t ulNumCqi;
+ uint32_t ulSumiTbs;
+ uint32_t ulNumiTbs;
+ uint32_t ulTpt;
}sch[L2_STATS_MAX_CELLS];
struct pdcpUeStats{
- U32 dlPdcpDropCnt;
- U32 dlPdcpAckWaitDropCnt;
- U32 dlFlowCtrlDropCnt;
+ uint32_t dlPdcpDropCnt;
+ uint32_t dlPdcpAckWaitDropCnt;
+ uint32_t dlFlowCtrlDropCnt;
}pdcp;
struct rlcUeStats{
- U32 ulReOdrTmrExpCnt;
- U32 dlMaxPktsInSduQ;
- U32 dlMaxWindowSz;
+ uint32_t ulReOdrTmrExpCnt;
+ uint32_t dlMaxPktsInSduQ;
+ uint32_t dlMaxWindowSz;
}rlc;
}nonPersistent;
struct persistentUeStats{
- U32 activatedSCells;
- U32 numActivation;
- U32 numDeactivation;
+ uint32_t activatedSCells;
+ uint32_t numActivation;
+ uint32_t numDeactivation;
}persistent;
}TSInfL2UeStats;
Bool sockSend;
Bool fileSend;
Bool consPrint;
- U32 statsPer;
- U32 sockPort;
+ uint32_t statsPer;
+ uint32_t sockPort;
Bool startSockSend;
- U8 cmdForFileStats;
+ uint8_t cmdForFileStats;
char fileName[100];
FILE *fptr;
- U32 enbIp;
+ uint32_t enbIp;
}TSInfStatsCb;
typedef Void (*TSInfL2UeStatsInd) ARGS((
Buffer *mBuf; /* message buffer */
#endif
{
- U16 ndx;
+ uint16_t ndx;
if(tknStr->pres)
Buffer *mBuf; /* message buffer */
#endif
{
- U16 ndx;
- U16 len;
+ uint16_t ndx;
+ uint16_t len;
if(tknStr->pres)
Buffer *mBuf; /* message buffer */
#endif
{
- U8 ndx;
+ uint8_t ndx;
if(tknStr->pres)
Buffer *mBuf; /* message buffer */
#endif
{
- U16 ndx;
+ uint16_t ndx;
if(tknStr->pres)
Buffer *mBuf; /* message buffer */
#endif
{
- U8 ndx;
+ uint8_t ndx;
if(tknStr->pres)
Buffer *mBuf; /* message buffer */
#endif
{
- U16 ndx;
+ uint16_t ndx;
if(tknStr->pres)
Ptr ptr; /* pointer to control memory block */
#endif
{
- U16 ndx;
+ uint16_t ndx;
CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- U16 ndx;
- U16 len;
+ uint16_t ndx;
+ uint16_t len;
CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- U8 ndx;
+ uint8_t ndx;
/* Token Header */
Ptr ptr; /* pointer to control memory block */
#endif
{
- U16 ndx;
+ uint16_t ndx;
CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- U8 ndx;
+ uint8_t ndx;
/* Token Header */
Ptr ptr; /* pointer to control memory block */
#endif
{
- U16 ndx;
+ uint16_t ndx;
CMCHKUNPK(oduPackUInt8, &tknStr->pres, mBuf);
\f
/* defines */
-#define cmPkTknPres(x, mBuf) cmPkTknU8(x, mBuf)
+#define cmPkTknPres(x, mBuf) cmPkTknUInt8(x, mBuf)
-#define cmUnpkTknPres(x, mBuf) cmUnpkTknU8(x, mBuf)
+#define cmUnpkTknPres(x, mBuf) cmUnpkTknUInt8(x, mBuf)
/* packing and unpacking for token bit strings */
/* typedefs */
/* Token Present */
-typedef TknU8 TknPres;
+typedef TknUInt8 TknPres;
/* Do not remove TknBool definition. If cm_gprs.x is used then include this
* file before cm_gprs.x */
-typedef TknU8 TknBool;
+typedef TknUInt8 TknBool;
typedef struct tknS16
{
- U8 pres; /* present flag */
- U8 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t spare1; /* for alignment */
S16 val; /* value */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
} TknS16;
/* Token TknStr8 */
typedef struct tknStr8 /* token string */
{
- U8 pres; /* present flag */
- U8 len; /* length */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* length */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
- U8 val[8]; /* string value - 4 byte alligned */
+ uint8_t val[8]; /* string value - 4 byte alligned */
} TknStr8;
/* Token TknStr16 */
typedef struct tknStr16 /* token string */
{
- U8 pres; /* present flag */
- U8 len; /* length */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* length */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
- U8 val[16]; /* string value - 4 byte alligned */
+ uint8_t val[16]; /* string value - 4 byte alligned */
} TknStr16;
typedef struct tknStrOSXL
{
- U8 pres; /* present flag */
- U8 spare1; /* spare */
- U16 len; /* length */
+ uint8_t pres; /* present flag */
+ uint8_t spare1; /* spare */
+ uint16_t len; /* length */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
- U8 *val; /* string value - 4 byte alligned */
+ uint8_t *val; /* string value - 4 byte alligned */
} TknStrOSXL;
/* Token TknBStr32 : length field indicates number of Bits present */
/* Token TknStrBMP4 */
typedef struct tknStrBMP4 /* token string */
{
- U8 pres; /* present flag */
- U8 len; /* length */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* length */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
- U16 val[4]; /* string value - 4 byte alligned */
+ uint16_t val[4]; /* string value - 4 byte alligned */
} TknStrBMP4;
/* Token TknStrBMPXL */
typedef struct tknStrBMPXL
{
- U8 pres; /* present flag */
- U8 spare1; /* spare */
- U16 len; /* length */
+ uint8_t pres; /* present flag */
+ uint8_t spare1; /* spare */
+ uint16_t len; /* length */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
- U16 *val; /* string value - 4 byte alligned */
+ uint16_t *val; /* string value - 4 byte alligned */
} TknStrBMPXL;
/* Token TknStrUNI4 */
typedef struct tknStrUNI4 /* token string */
{
- U8 pres; /* present flag */
- U8 len; /* length */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* length */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
- U32 val[4]; /* string value - 4 byte alligned */
+ uint32_t val[4]; /* string value - 4 byte alligned */
} TknStrUNI4;
typedef struct tknStrUNIXL /* Universal String */
{
- U8 pres; /* present flag */
- U8 spare1; /* spare */
- U16 len; /* length */
+ uint8_t pres; /* present flag */
+ uint8_t spare1; /* spare */
+ uint16_t len; /* length */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
- U32 *val; /* string value- 4 byte alligned */
+ uint32_t *val; /* string value- 4 byte alligned */
} TknStrUNIXL;
/* common packing functions */
Buffer *mBuf; /* message buffer */
#endif
{
- U8 num;
- U8 *ptr = (U8*)pkParam;
+ uint8_t num;
+ uint8_t *ptr = (uint8_t*)pkParam;
for(num = 0; num < CM_IPV6ADDR_SIZE; num++)
Buffer *mBuf; /* message buffer */
#endif
{
- U16 idx; /* Loop Index */
+ uint16_t idx; /* Loop Index */
CmNetAddr *netAddr; /* Network Address */
Buffer *mBuf; /* message buffer */
#endif
{
- U32 num;
+ uint32_t num;
if( pkParam->numOpts > CM_MAX_SOCK_OPTS)
Buffer *mBuf; /* message buffer */
#endif
{
- U32 num;
+ uint32_t num;
if( pkParam->numOpts > CM_MAX_SOCK_OPTS)
Buffer *mBuf; /* message buffer */
#endif
{
- U32 num;
- U8 *ptr = (U8*)unpkParam;
+ uint32_t num;
+ uint8_t *ptr = (uint8_t*)unpkParam;
ptr += (CM_INET_IPV6ADDR_SIZE - 1);
Buffer *mBuf; /* message buffer */
#endif
{
- U16 idx; /* Loop Index */
+ uint16_t idx; /* Loop Index */
CmNetAddr *netAddr; /* Network Address */
Buffer *mBuf; /* message buffer */
#endif
{
- U32 num;
+ uint32_t num;
CMCHKUNPK(oduPackUInt8, &unpkParam->listenQSize, mBuf);
Buffer *mBuf; /* message buffer */
#endif
{
- U32 num;
+ uint32_t num;
CMCHKUNPK(SUnpkS16, &unpkParam->ctxId, mBuf);
CMCHKPK(cmPkTknStr64, &pkParam->u.hdrParmIpv4.ipv4HdrOpt, mBuf);
#endif /* IPV4_OPTS_SUPPORTED */
- CMCHKPK(cmPkTknU8, &pkParam->u.hdrParmIpv4.ttl, mBuf);
- CMCHKPK(cmPkTknU8, &pkParam->u.hdrParmIpv4.tos, mBuf);
- CMCHKPK(cmPkTknU8, &pkParam->u.hdrParmIpv4.dfBit, mBuf);
- CMCHKPK(cmPkTknU8, &pkParam->u.hdrParmIpv4.proto, mBuf);
+ CMCHKPK(cmPkTknUInt8, &pkParam->u.hdrParmIpv4.ttl, mBuf);
+ CMCHKPK(cmPkTknUInt8, &pkParam->u.hdrParmIpv4.tos, mBuf);
+ CMCHKPK(cmPkTknUInt8, &pkParam->u.hdrParmIpv4.dfBit, mBuf);
+ CMCHKPK(cmPkTknUInt8, &pkParam->u.hdrParmIpv4.proto, mBuf);
break;
case CM_HDRPARM_IPV6:
CMCHKPK(cmPkCmIpv6ExtHdr, &pkParam->u.hdrParmIpv6.ipv6ExtHdr, mBuf);
#endif /* IPV6_OPTS_SUPPORTED */
CMCHKPK(cmPkCmNetAddr, &pkParam->u.hdrParmIpv6.srcAddr6, mBuf);
- CMCHKPK(cmPkTknU8, &pkParam->u.hdrParmIpv6.ttl, mBuf);
+ CMCHKPK(cmPkTknUInt8, &pkParam->u.hdrParmIpv6.ttl, mBuf);
#endif /* IPV6_SUPPORTED */
break;
Buffer *mBuf; /* message buffer */
#endif
{
- U8 idx;
+ uint8_t idx;
/* pack all IPV6 addrs in the route hdr */
Mem *memInfo; /* meminfo to allocate for Route hdr */
#endif
{
- U8 idx; /* array index */
+ uint8_t idx; /* array index */
S32 retVal; /* temporary return value */
#endif
{
- U8 numOptions;
+ uint8_t numOptions;
/* pack all HBH options */
Buffer *mBuf; /* message buffer */
#endif
{
- U8 optLen;
+ uint8_t optLen;
for(optLen = 0; optLen < pkParam->length; optLen++)
#endif
{
S32 retVal; /* temporary return value */
- U8 optLen; /* length of value field */
+ uint8_t optLen; /* length of value field */
/* unpack type, length */
Mem *memInfo; /* meminfo to allocate mem for dest opts */
#endif
{
- U8 numOptions;
+ uint8_t numOptions;
S16 retVal;
Buffer *mBuf; /* message buffer */
#endif
{
- U8 numOptions;
+ uint8_t numOptions;
for(numOptions = 0; numOptions<pkParam->numHBHOpts; numOptions++)
Buffer *mBuf; /* message buffer */
#endif
{
- U8 optLen;
+ uint8_t optLen;
/* pack value field */
#endif
{
S32 retVal; /* temporary return value */
- U8 optLen; /* length of value field */
+ uint8_t optLen; /* length of value field */
CMCHKUNPK(oduPackUInt8, &unpkParam->type, mBuf);
Mem *memInfo; /* meminfo to allocate space for HBH opt */
#endif
{
- U8 numOptions;
+ uint8_t numOptions;
S16 retVal;
break;
case CM_HDRPARM_IPV4:
- CMCHKUNPK(cmUnpkTknU8, &unpkParam->u.hdrParmIpv4.proto, mBuf);
- CMCHKUNPK(cmUnpkTknU8, &unpkParam->u.hdrParmIpv4.dfBit, mBuf);
- CMCHKUNPK(cmUnpkTknU8, &unpkParam->u.hdrParmIpv4.tos, mBuf);
- CMCHKUNPK(cmUnpkTknU8, &unpkParam->u.hdrParmIpv4.ttl, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, &unpkParam->u.hdrParmIpv4.proto, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, &unpkParam->u.hdrParmIpv4.dfBit, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, &unpkParam->u.hdrParmIpv4.tos, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, &unpkParam->u.hdrParmIpv4.ttl, mBuf);
#ifdef IPV4_OPTS_SUPPORTED
CMCHKUNPK(cmUnpkTknStr64, &unpkParam->u.hdrParmIpv4.ipv4HdrOpt, mBuf);
#endif /* IPV4_OPTS_SUPPORTED */
case CM_HDRPARM_IPV6:
#ifdef IPV6_SUPPORTED
- CMCHKUNPK(cmUnpkTknU8, &unpkParam->u.hdrParmIpv6.ttl, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, &unpkParam->u.hdrParmIpv6.ttl, mBuf);
CMCHKUNPK(cmUnpkCmNetAddr,
&unpkParam->u.hdrParmIpv6.srcAddr6, mBuf);
#define CM_TPT_FREE_IPV6_HDRPARM(_region, _pool, _hdrParm) \
{ \
CmIpv6HdrParm *_hdrParmIpv6; \
- U8 numOpts; \
+ uint8_t numOpts; \
if (_hdrParm->type == CM_HDRPARM_IPV6) \
{ \
_hdrParmIpv6 = &_hdrParm->u.hdrParmIpv6; \
typedef CmInetIpAddr CmIpv4NetAddr;
#ifndef IPV6_SUPPORTED
-typedef U8 CmInetIpAddr6[16]; /* 16 byte IPV6 address */
+typedef uint8_t CmInetIpAddr6[16]; /* 16 byte IPV6 address */
/* IPV6 Address */
typedef struct cmInetIpv6Addr
{
- U16 port;
+ uint16_t port;
CmInetIpAddr6 ipv6NetAddr;
} CmInetIpv6Addr;
#endif /* IPV6_SUPPORTED */
/* Network address */
typedef struct cmNetAddr
{
- U8 type; /* type of network address */
+ uint8_t type; /* type of network address */
union
{
CmIpv4NetAddr ipv4NetAddr; /* IP network address */
/* list of addresses */
typedef struct _cmNetAddrTbl
{
- U16 count; /* Number of Table Entries */
+ uint16_t count; /* Number of Table Entries */
CmNetAddr netAddr[CM_MAX_NET_ADDR]; /* IPV4/IPV6 addresses */
}CmNetAddrTbl;
typedef struct cmTptLocalInf
{
Bool intfPrsnt; /* valid intf is present or not */
- U32 localIf; /* interface index IPv4(32 bit) or IPv6(32 bit) */
+ uint32_t localIf; /* interface index IPv4(32 bit) or IPv6(32 bit) */
CmNetAddr localIfAddr; /* interface address */
}CmTptLocalInf;
#endif /* LOCAL_INTF */
/* Transport address */
typedef struct cmTptAddr
{
- U8 type; /* type of transport address */
+ uint8_t type; /* type of transport address */
union
{
CmIpv4TptAddr ipv4TptAddr; /* IP transport address */
/* Array of Transport Addresses */
typedef struct cmTptAddrLst
{
- U8 nmb; /* Number of Network Addresses */
+ uint8_t nmb; /* Number of Network Addresses */
CmTptAddr tptAddr[CM_MAX_NET_ADDR]; /* List of Network Addresses */
} CmTptAddrLst;
/* Socket Options */
typedef struct cmSockOpts
{
- U32 level; /* option level */
- U32 option; /* option name */
+ uint32_t level; /* option level */
+ uint32_t option; /* option name */
union /* option parameters */
{
#ifdef CM_INET2
#ifdef IPV6_SUPPORTED
CmNetMCastInf6 mCastInfo6; /* IPV6 multicast information */
- U32 infId; /* IPV6 multicast outgoing interface */
+ uint32_t infId; /* IPV6 multicast outgoing interface */
#endif /* IPV6_SUPPORTED */
CmNetMCastInf mCastInfo; /* multicast information */
#else
CmNetAddr mCastAddr; /* multicast information */
#endif /* CM_INET2 */
CmNetAddr lclAddr; /* local outgoing interface */
- U32 value; /* option value */
+ uint32_t value; /* option value */
/*cm_tpt_x_001.main_12 Updated for TUCL 2.1 Release (Kernel SCTP Support) */
#ifdef CM_LKSCTP
CmSockLinger sockLinger;
/* socket parameters */
typedef struct cmSockParam
{
- U8 listenQSize; /* listen queue size */
- U8 numOpts; /* number of socket options */
+ uint8_t listenQSize; /* listen queue size */
+ uint8_t numOpts; /* number of socket options */
CmSockOpts sockOpts[CM_MAX_SOCK_OPTS]; /* socket options */
} CmSockParam;
typedef struct tlsTptParam
{
S16 ctxId;
- U8 listenQSize;
- U8 numOpts;
+ uint8_t listenQSize;
+ uint8_t numOpts;
CmSockOpts sockOpts[CM_MAX_SOCK_OPTS];
} TlsTptParam;
#ifdef CM_LKSCTP
typedef struct sctpSockParam
{
- U8 numOpts; /* number of socket options */
+ uint8_t numOpts; /* number of socket options */
CmSockOpts sockOpts[CM_MAX_SOCK_OPTS]; /* socket options */
} SctpSockParam;
#endif
/* Transport parameters */
typedef struct cmTptParam
{
- U8 type; /* type of transport parameters */
+ uint8_t type; /* type of transport parameters */
union
{
/* IPv4 header parameters */
typedef struct cmIpv4HdrParm
{
- TknU8 proto; /* Protocol value */
- TknU8 dfBit; /* Don't fragment flag */
- TknU8 tos; /* Type of Service */
- TknU8 ttl; /* Time to Live */
+ TknUInt8 proto; /* Protocol value */
+ TknUInt8 dfBit; /* Don't fragment flag */
+ TknUInt8 tos; /* Type of Service */
+ TknUInt8 ttl; /* Time to Live */
/* added new field */
#ifdef IPV4_OPTS_SUPPORTED
TknStr64 ipv4HdrOpt; /* IPV4 hdr opt */
/* structure to hold TLV of each HBH option */
typedef struct cmIpv6HBHHdr
{
- U8 type;
- U8 length;
- U8 *value;
+ uint8_t type;
+ uint8_t length;
+ uint8_t *value;
} CmIpv6HBHHdr;
/* structure to hold TLV of each Destination option */
typedef struct cmIpv6DestOptsHdr
{
- U8 type;
- U8 length;
- U8 *value;
+ uint8_t type;
+ uint8_t length;
+ uint8_t *value;
} CmIpv6DestOptsHdr;
/* structure to hold IPV6 addresses of the Route header */
typedef struct cmIpv6RtHdr
{
- U8 numAddrs;
- U32 slMap;
+ uint8_t numAddrs;
+ uint32_t slMap;
CmIpv6NetAddr *ipv6Addrs;
} CmIpv6RtHdr;
/* array of all HBH options */
typedef struct cmIpv6HBHHdrArr
{
- U8 numHBHOpts;
+ uint8_t numHBHOpts;
CmIpv6HBHHdr *hbhOpts;
} CmIpv6HBHHdrArr;
/* array of all Destination options */
typedef struct cmIpv6DestOptsArr
{
- U8 numDestOpts;
+ uint8_t numDestOpts;
CmIpv6DestOptsHdr *destOpts;
} CmIpv6DestOptsArr;
/* IPV6 header parameters */
typedef struct cmIpv6HdrParm
{
- TknU8 ttl; /* Set the hop limit */
+ TknUInt8 ttl; /* Set the hop limit */
/* added new field */
CmNetAddr srcAddr6; /* src addr to set on send pkt(IPv6) */
/* IP header paramters */
typedef struct cmIpHdrParm
{
- U8 type; /* Type of IP header parameters */
+ uint8_t type; /* Type of IP header parameters */
union
{
CmIpv4HdrParm hdrParmIpv4; /* IPv4 header parameters */
/* IPv4 header */
typedef struct cmIpv4Hdr
{
- U8 hdrVer; /* Header and Version */
- U8 tos; /* Type Of Service */
+ uint8_t hdrVer; /* Header and Version */
+ uint8_t tos; /* Type Of Service */
S16 length; /* Total length */
- U16 id; /* Identification */
+ uint16_t id; /* Identification */
S16 off; /* Flags and Offset */
- U8 ttl; /* Time to Live */
- U8 proto; /* Protocol */
- U16 chkSum; /* Checksum */
- U32 srcAddr; /* Source Address */
- U32 destAddr; /* Destination Address */
+ uint8_t ttl; /* Time to Live */
+ uint8_t proto; /* Protocol */
+ uint16_t chkSum; /* Checksum */
+ uint32_t srcAddr; /* Source Address */
+ uint32_t destAddr; /* Destination Address */
} CmIpv4Hdr;
{
struct ip6_hdrctl
{
- U32 ip6_un1_flow;
- U16 ip6_un1_plen;
- U8 ip6_un1_nxt;
- U8 ip6_un1_hlim;
+ uint32_t ip6_un1_flow;
+ uint16_t ip6_un1_plen;
+ uint8_t ip6_un1_nxt;
+ uint8_t ip6_un1_hlim;
} ip6_un1;
- U8 ip6_un2_vfc;
+ uint8_t ip6_un2_vfc;
} ip6_ctlun;
CmIpv6NetAddr ip6_src;
CmIpv6NetAddr ip6_dst;
typedef struct cmIcmpError
{
- U8 errType; /* ICMP Error Type */
- U32 errCodeMask; /* ICMP Error Code Mask */
+ uint8_t errType; /* ICMP Error Type */
+ uint32_t errCodeMask; /* ICMP Error Code Mask */
} CmIcmpError;
/* ICMP v4 filter parameters */
typedef struct cmIcmpv4Filter
{
- U8 icmpMsgFlag; /* Flag to listen to any ICMP msgs */
- U8 allMsg; /* Flag to listen to ICMP messages */
- U8 protocol; /* ICMP packets with protocol only */
- U8 num; /* Number of valid type - code
+ uint8_t icmpMsgFlag; /* Flag to listen to any ICMP msgs */
+ uint8_t allMsg; /* Flag to listen to ICMP messages */
+ uint8_t protocol; /* ICMP packets with protocol only */
+ uint8_t num; /* Number of valid type - code
* combinations in the error array */
CmIcmpError icmpError[CM_MAX_ICMP_ERROR]; /* Error type & Code array */
#ifdef IPV6_SUPPORTED
typedef struct cmIcmpv6Filter
{
- U8 icmpMsgFlag; /* Flag to listen to any ICMP msgs */
- U8 allMsg; /* Flag to listen to all ICMP messages */
- U8 num; /* Number of valid type - code
+ uint8_t icmpMsgFlag; /* Flag to listen to any ICMP msgs */
+ uint8_t allMsg; /* Flag to listen to all ICMP messages */
+ uint8_t num; /* Number of valid type - code
* combinations in the error array */
CmIcmpError icmpError[CM_MAX_ICMP_ERROR]; /* Error type & Code array */
/* ICMP filter paramters */
typedef struct cmIcmpFilter
{
- U8 type; /* ICMP version */
+ uint8_t type; /* ICMP version */
union
{
CmIcmpv4Filter icmpv4Filter; /* ICMPv4 filter structure */
/* ICMP header */
typedef struct cmIcmpv4Hdr
{
- U8 icmpType; /* Type of message */
- U8 icmpCode; /* Message code */
- U16 chkSum; /* Ones complement cksum of struct */
+ uint8_t icmpType; /* Type of message */
+ uint8_t icmpCode; /* Message code */
+ uint16_t chkSum; /* Ones complement cksum of struct */
union
{
- U8 ihPptr; /* ICMP parameter problem */
- U32 rdrctAddr; /* ICMP redirect address */
+ uint8_t ihPptr; /* ICMP parameter problem */
+ uint32_t rdrctAddr; /* ICMP redirect address */
struct idSeq
{
S16 icdId; /* Identifier */
S16 icdSeq; /* Sequence Number */
} u1;
- U32 ihVoid;
+ uint32_t ihVoid;
} u2;
union
{
struct idTime
{
- U32 itOtime; /* Original time stamp */
- U32 itRtime; /* Received time stamp */
- U32 itTtime; /* Transmit time stamp */
+ uint32_t itOtime; /* Original time stamp */
+ uint32_t itRtime; /* Received time stamp */
+ uint32_t itTtime; /* Transmit time stamp */
} s;
CmIpv4Hdr icmpIpHdr; /* IP header */
- U32 id_mask;
+ uint32_t id_mask;
} u3;
} CmIcmpv4Hdr;
#ifdef IPV6_SUPPORTED
typedef struct cmIcmpv6Hdr
{
- U8 icmp6_type; /* type field */
- U8 icmp6_code; /* code field */
- U16 icmp6_cksum; /* checksum field */
+ uint8_t icmp6_type; /* type field */
+ uint8_t icmp6_code; /* code field */
+ uint16_t icmp6_cksum; /* checksum field */
union
{
- U32 icmp6_un_data32[1]; /* type-specific field */
- U16 icmp6_un_data16[2]; /* type-specific field */
- U8 icmp6_un_data8[4]; /* type-specific field */
+ uint32_t icmp6_un_data32[1]; /* type-specific field */
+ uint16_t icmp6_un_data16[2]; /* type-specific field */
+ uint8_t icmp6_un_data8[4]; /* type-specific field */
} icmp6_dataun;
} CmIcmpv6Hdr;
#endif /* IPV6_SUPPORTED */
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 cmPkCrgBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
#endif
{
SuId suId;
- U8 status;
+ uint8_t status;
if (SUnpkS16(&suId, mBuf) != ROK) {
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] CrgCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
Pst* pst,
SuId suId,
CrgCfgTransId transId,
-U8 status
+uint8_t status
)
#else
S16 cmPkCrgCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
CrgCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] CrgCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
{
SuId suId;
CrgCfgTransId transId;
- U8 status;
+ uint8_t status;
if (SUnpkS16(&suId, mBuf) != ROK) {
S8 idx;
for(idx = param->numSCells - 1; idx >= 0; idx--)
{
- CMCHKPK(cmPkCrgUeSCellCfg, ¶m->ueSCellCfg[(U8)idx], mBuf);
+ CMCHKPK(cmPkCrgUeSCellCfg, ¶m->ueSCellCfg[(uint8_t)idx], mBuf);
}
CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->isSCellCfgPres, mBuf);
if(TRUE == param->isSCellCfgPres)
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
CMCHKUNPK(cmUnpkCrgUeUlHqCfg, ¶m->ueUlHqCfg, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->txMode.pres, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->txMode.tm = (CrgTxMode) tmpEnum;
#ifdef TENB_MULT_CELL_SUPPRT
CMCHKUNPK(SUnpkS16, ¶m->rguUlSapId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->newCrnti, mBuf);
CMCHKUNPK(cmUnpkCrgUeUlHqCfg, ¶m->ueUlHqRecfg, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->txMode.pres, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->txMode.tm, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->txMode.tm, mBuf);
#ifdef LTE_ADV
CMCHKUNPK(cmUnpkCrgUeSecCellInfo, ¶m->crgSCellCfg, mBuf);
#endif /* LTE_ADV */
@brief Transaction ID between MAC and RRC. */
typedef struct crgCfgTransId
{
- U8 trans[CRG_CFG_TRANSID_SIZE]; /*!< RRC transaction ID */
+ uint8_t trans[CRG_CFG_TRANSID_SIZE]; /*!< RRC transaction ID */
} CrgCfgTransId;
/**
@brief Bandwidth configuration per cell. */
typedef struct crgBwCfg
{
- U8 dlTotalBw; /*!< Total Dowlink Bandwidth */
- U8 ulTotalBw; /*!< Total Uplink Bandwidth */
+ uint8_t dlTotalBw; /*!< Total Dowlink Bandwidth */
+ uint8_t ulTotalBw; /*!< Total Uplink Bandwidth */
} CrgBwCfg;
/**
@brief RACH configuration per cell. */
typedef struct crgRachCfg
{
- U8 maxMsg3Tx; /*!< Maximum number of message 3 transmissions */
+ uint8_t maxMsg3Tx; /*!< Maximum number of message 3 transmissions */
} CrgRachCfg;
#ifdef LTE_ADV
/** @brief UE secondary cell config params to MAC*/
typedef struct crgUeSCellInfo
{
- U16 sCellId; /*!< This will be secondary cellId */
+ uint16_t sCellId; /*!< This will be secondary cellId */
Inst macInst; /*!< MAC instance for SCell */
SuId rguUlSapId; /*!< MAC-RLC UL Sap ID */
SuId rguDlSapId; /*!< MAC-RLC DL SAP ID */
{
Bool isSCellCfgPres; /*!< Bool indicates whether configuration
is present */
- U8 numSCells; /*!< Number of SCells
+ uint8_t numSCells; /*!< Number of SCells
*/
CrgUeSCellInfo ueSCellCfg[CRG_MAX_SCELL_PER_UE]; /*!< Secondary cell
configuration per UE */
SpId rguDlSapId; /*!< RLC DL SAP Id for common channels */
#endif
#ifdef EMTC_ENABLE
- U8 emtcEnable;
+ uint8_t emtcEnable;
#endif
} CrgCellCfg;
@brief Uplink HARQ configuration per UE. */
typedef struct crgUeUlHqCfg
{
- U8 maxUlHqTx; /*!< Maximum number of UL HARQ transmissions */
+ uint8_t maxUlHqTx; /*!< Maximum number of UL HARQ transmissions */
} CrgUeUlHqCfg;
/* crg_x_001.main_3 - Changes for MIMO feature addition */
@brief Logical channel configuration information for downlink logical channels. */
typedef struct crgDlLchCfg
{
- U8 dlTrchType; /*!< Indicates type of DL transport channel:
+ uint8_t dlTrchType; /*!< Indicates type of DL transport channel:
Validated only for BCCH at MAC. DL Transport
channel type can take following values:<br>
CM_LTE_TRCH_BCH<br>
@brief Logical channel configuration information for uplink logical channels. */
typedef struct crgUlLchCfg
{
- U8 ulTrchType; /*!< Indicates type of UL transport channel:
+ uint8_t ulTrchType; /*!< Indicates type of UL transport channel:
Validated only for BCCH at MAC.
UL Transport channel type can take following values:<br>
CM_LTE_TRCH_RACH<br>
CM_LTE_TRCH_UL_SCH */
- U8 lcgId; /*!< Logical channel group ID */
+ uint8_t lcgId; /*!< Logical channel group ID */
} CrgUlLchCfg;
/* crg_x_001.main_2: Documentation update */
CM_LTE_LCH_DCCH<br>
CM_LTE_LCH_DTCH */
- U8 dir; /*!< Indicates Direction. Direction can take following
+ uint8_t dir; /*!< Indicates Direction. Direction can take following
values:<br>
CRG_DIR_TX<br>
CRG_DIR_RX<br>
CrgUlLchCfg ulInfo; /*!< Uplink logical channel configuration info */
/* crg_x_001.main_5 - ADD - Members corresponding to LTE_L2_MEAS */
#ifdef LTE_L2_MEAS
- U8 qci; /*!< QCI for the logical channel.
+ uint8_t qci; /*!< QCI for the logical channel.
Valid Range:[0-255] (Actual QCI - 1). */
#endif /* LTE_L2_MEAS */
@brief Basic configuration information for MAC. */
typedef struct crgCfg
{
- U8 cfgType; /*!< Indicates configuration type */
+ uint8_t cfgType; /*!< Indicates configuration type */
union crgCfgU
{
CrgCellCfg cellCfg; /*!< Cell configuration */
struct ulRecfgS
{
- U8 lcgId; /*!< Logical channel group ID */
+ uint8_t lcgId; /*!< Logical channel group ID */
} ulRecfg; /*!< Uplink logical channel reconfiguration information */
} CrgLchRecfg;
@brief Basic reconfiguration information for MAC. */
typedef struct crgRecfg
{
- U8 recfgType; /*!< Indicates reconfiguration type */
+ uint8_t recfgType; /*!< Indicates reconfiguration type */
union crgRecfgU
{
CrgCellRecfg cellRecfg; /*!< Cell Reconfig information */
@brief Basic Delete information for MAC. */
typedef struct crgDel
{
- U8 delType; /*!< Indicates configuration item to be deleted */
+ uint8_t delType; /*!< Indicates configuration item to be deleted */
union crgDelU
{
struct cellDelS
CmLteCellId cellId; /*!< Cell ID */
CmLteRnti crnti; /*!< CRNTI for DTCH and DCCH */
CmLteLcId lcId; /*!< Logical channel ID */
- U8 dir; /*!< Indicates Direction. Direction can take following
+ uint8_t dir; /*!< Indicates Direction. Direction can take following
values:<br>
CRG_DIR_TX<br>
CRG_DIR_RX<br>
@brief Config/Reconfig/Delete information for MAC. */
typedef struct crgCfgReqInfo
{
- U8 action; /*!< Determines cfg/recfg/del/reset */
+ uint8_t action; /*!< Determines cfg/recfg/del/reset */
union cfgReqInfoU
{
CrgCfg cfgInfo; /*!< Configuration related infomation */
typedef S16 (*CrgBndCfm) ARGS((
Pst* pst,
SuId suId,
- U8 status));
+ uint8_t status));
/** @brief Request from RRC to MAC to unbind the interface SAPs. */
typedef S16 (*CrgUbndReq) ARGS((
Pst* pst,
Pst* pst,
SuId suId,
CrgCfgTransId transId,
- U8 status));
+ uint8_t status));
/** @brief Request from RRC to MAC to bind the interface SAPs. */
EXTERN S16 RgUiCrgBndReq ARGS((
EXTERN S16 RgUiCrgBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/** @brief Request from RRC to MAC to Unbind the interface SAPs. */
EXTERN S16 RgUiCrgUbndReq ARGS((
Pst* pst,
SuId suId,
CrgCfgTransId transId,
- U8 status
+ uint8_t status
));
#ifdef NH
EXTERN S16 NhLiCrgBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/** @brief Request from RRC to MAC to Unbind the interface SAPs. */
EXTERN S16 NhLiCrgUbndReq ARGS((
Pst* pst,
SuId suId,
CrgCfgTransId transId,
- U8 status
+ uint8_t status
));
#endif
EXTERN S16 cmPkCrgBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/** @brief Confirmation from MAC to RRC for the bind/unbind
* request for the interface SAPs. */
Pst* pst,
SuId suId,
CrgCfgTransId transId,
- U8 status
+ uint8_t status
));
/** @brief Configuration Confirm from MAC to RRC. */
EXTERN S16 cmUnpkCrgCfgCfm ARGS((
EXTERN S16 DmUiCrgBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/** @brief Request from RRC to MAC to unbind the interface SAPs. */
EXTERN S16 DmUiCrgUbndReq ARGS((
Pst* pst,
SuId suId,
CrgCfgTransId transId,
- U8 status
+ uint8_t status
));
#endif
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 cmPkCtfBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
#endif
{
SuId suId = 0;
- U8 status;
+ uint8_t status;
if (SUnpkS16(&suId, mBuf) != ROK) {
{
for(i= param->numOfVendorSpecifcParam-1; i >= 0; i--)
{
- CMCHKPK(oduUnpackUInt32,(U32)param->vendorSpecifcParam[i], mBuf);
+ CMCHKPK(oduUnpackUInt32,(uint32_t)param->vendorSpecifcParam[i], mBuf);
}
}
CMCHKPK(oduUnpackUInt16, param->numOfVendorSpecifcParam, mBuf);
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt16, ¶m->dlCarrFreq, mBuf);
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt16, ¶m->dlCarrFreq, mBuf);
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->intgAlgoType, mBuf);
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] CtfCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
SuId suId,
CtfCfgTransId transId,
CtfKdfCfmInfo *kdfCfmInfo,
-U8 status
+uint8_t status
)
#else
S16 cmPkCtfKdfCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
CtfCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] CtfCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
Pst* pst,
SuId suId,
CtfCfgTransId transId,
-U8 status
+uint8_t status
)
#else
S16 cmPkCtfCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
CtfCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
#endif
{
- U8 idx;
+ uint8_t idx;
for(idx=0;idx<32;idx++)
#endif
{
- U8 idx;
+ uint8_t idx;
for(idx=0;idx<32;idx++)
#endif
{
- U8 idx;
+ uint8_t idx;
for(idx=0;idx<16;idx++)
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] CtfCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
{
SuId suId = 0;
CtfCfgTransId transId;
- U8 status;
+ uint8_t status;
CtfKdfCfmInfo kdfCfmInfo;
* @param[in] Pst* pst
* @param[in] SuId suId
* @param[in] CtfCfgTransId transId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
{
SuId suId = 0;
CtfCfgTransId transId;
- U8 status;
+ uint8_t status;
if (SUnpkS16(&suId, mBuf) != ROK) {
* @param[in] SuId suId
* @param[in] CtfCfgTransId transId
* @param[in] CtfUeInfo * ueInfo
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
* @param[in] SuId suId
* @param[in] CtfCfgTransId transId
* @param[in] CtfUeInfo * ueInfo
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
/* ctf_c_001.main_4: Removed UnPacking of param->pres */
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->dlBw = (CtfBandwidth)tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ulBw = (CtfBandwidth)tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->eUtraBand, mBuf);
return ROK;
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
/* ctf_c_001.main_4: Removed UnPacking of param->pres */
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->duplexMode = (CtfDuplexMode)tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->scSpacing = (CtfSCSpacing)tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->cycPfx = (CtfCPCfg)tmpEnum;
return ROK;
}
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->antPortsCnt = (CtfAntennaPortsCount)tmpEnum;
return ROK;
}
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->noOfsubBands, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->hoppingMode = (CtfPuschHoppingMode)tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->hoppingOffset, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->enable64QAM, mBuf);
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->duration = (CtfPhichDuration)tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->resource = (CtfPhichResource)tmpEnum;
}
return ROK;
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->nRB, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->nCS, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->n1PUCCH, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->deltaShift = (CtfPucchDeltaShift)tmpEnum;
}
return ROK;
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKPK(SPkS32, param->txPowerLimit, mBuf);
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->numFreq, mBuf);
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
/* ctf_c_001.main_3: Added the unpack for newly added fileds inside the CFG structure*/
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ctfReCfgType = (CtfReCfgType)tmpEnum;
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cellIdGrpId, mBuf);
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
{
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->pA = (CtfPdschPaParam)tmpEnum;
}
return ROK;
if (param->pucchSetup.repFactPres)
{
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->pucchSetup.repFact, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->pucchSetup.repFact, mBuf);
}
#else
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->pucchSetup.repFact, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->pucchSetup.repFact, mBuf);
#endif /*CTF_VER3 */
CMCHKUNPK(oduPackUInt16, ¶m->pucchSetup.n1PUCCHRep, mBuf);
#ifdef CTF_VER3
if (param->tddAckNackCfgPres != FALSE)
{
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->tddAckNackFBMode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->tddAckNackFBMode, mBuf);
}
#endif /* CTF_VER3 */
}
/* ctf_c_001.main_2: added packning for cqiMask*/
#ifdef CTF_VER1
- CMCHKPK(oduUnpackUInt32, (U32 )param->cqiSetup.cqiMask.cqiMaskSetup, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t )param->cqiSetup.cqiMask.cqiMaskSetup, mBuf);
CMCHKPK(oduUnpackUInt8, param->cqiSetup.cqiMask.pres, mBuf);
#endif /* CTF_VER1 */
CMCHKPK(oduUnpackUInt8, param->cqiSetup.simultaneousAckNack, mBuf);
#endif
{
#ifdef CTF_VER1
- U32 tmpEnum;
+ uint32_t tmpEnum;
#endif
CMCHKUNPK(oduPackUInt8, ¶m->cqiPeriodicCfgType, mBuf);
/* ctf_c_001.main_2: added Unpackning for cqiMask*/
#ifdef CTF_VER1
CMCHKUNPK(oduPackUInt8, ¶m->cqiSetup.cqiMask.pres, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->cqiSetup.cqiMask.cqiMaskSetup = tmpEnum;
#endif /* CTF_VER1 */
return ROK;
#endif
{
#if defined (CTF_VER1) || defined (CTF_VER2)
- U32 tmpEnum;
+ uint32_t tmpEnum;
#endif
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/* ctf_c_001.main_2: added Unpackning for cqiMask*/
#ifdef CTF_VER1
CMCHKUNPK(oduPackUInt8, ¶m->pmiRiRpt.pres, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->pmiRiRpt.pmiRiRptSetup = tmpEnum;
#endif /* CTF_VER1 */
CMCHKUNPK(oduPackUInt8, ¶m->reportMode.aPeriodicRpt.pres, mBuf)
if(param->reportMode.aPeriodicRpt.pres != FALSE)
{
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->reportMode.aPeriodicRpt.aPeriodicRptMode =
(CtfCqiRptModeAperiodic)tmpEnum;
}
CMCHKUNPK(oduPackUInt8, ¶m->reportingMode, mBuf);
switch(param->reportingMode) {
case CTF_CQI_RPTMODE_APRDIOC:
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->reportMode.aPeriodicRpt, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->reportMode.aPeriodicRpt, mBuf);
break;
case CTF_CQI_RPTMODE_PRDIOC:
CMCHKUNPK(cmUnpkCtfCqiRptModePeriodic, ¶m->reportMode.periodicRpt, mBuf);
{
#ifdef CTF_VER2
- U8 idx;
+ uint8_t idx;
#endif /* CTF_VER2 */
CMCHKPK(oduUnpackUInt32, param->ueTxAntSelection.txAntSelect, mBuf);
CMCHKPK(oduUnpackUInt8, param->ueTxAntSelection.cfgType, mBuf);
/* ctf_c_001.main_3 txMode is of type enum and is 32bit length */
- CMCHKPK(oduUnpackUInt32, (U32)param->txMode, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t)param->txMode, mBuf);
#ifdef CTF_VER2
/*
*ctf_c_001.main_2: Added Packing of CodeBookSubsetRestriction parameter
S16 idx;
#endif /* CTF_VER2 */
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*
* Added Unpacking for CodeBookSubsetRestriction parameter
*/
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->codeBookSubsetRes.ctfCdBkRestType = (CtfCdBkSubsetRestnType)tmpEnum;
switch(param->codeBookSubsetRes.ctfCdBkRestType)
{
}
#endif /* CTF_VER2 */
/* ctf_c_001.main_3 Enum is 32bit length */
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->txMode = (CtfUeTxAntMode)tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->ueTxAntSelection.cfgType, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ueTxAntSelection.txAntSelect = (CtfUeTxAntSelectType)tmpEnum;
}
return ROK;
for(idx = param->numSCells - 1; idx >= 0; idx--)
{
- CMCHKPK(cmPkCtfUeSecCellCfgInfo, ¶m->ueSCellDedCfg[(U8)idx], mBuf);
+ CMCHKPK(cmPkCtfUeSecCellCfgInfo, ¶m->ueSCellDedCfg[(uint8_t)idx], mBuf);
}
CMCHKPK(oduUnpackUInt32, param->sCellAction, mBuf);
CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->numSCells, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32*)¶m->sCellAction, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)¶m->sCellAction, mBuf);
for(idx = 0 ; idx < param->numSCells; idx++)
{
CMCHKUNPK(cmUnpkCtfUeSecCellCfgInfo, ¶m->ueSCellDedCfg[idx], mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
/*ctf_c_001.main_1*/
if(param->pres != FALSE)
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->ueCategory, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->ueCategory, mBuf);
return ROK;
}
/* Added the pack for newly added reference signal Power*/
- CMCHKPK(oduUnpackUInt32, (U32)param->ctfCellStatus, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t)param->ctfCellStatus, mBuf);
CMCHKPK(SPkS16, param->pilotSigPwr, mBuf);
CMCHKPK(SPkS16, param->priSigPwr, mBuf);
CMCHKPK(SPkS16, param->secSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->secSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->priSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->pilotSigPwr, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->ctfCellStatus, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->ctfCellStatus, mBuf);
return ROK;
}
/* Added the pack for newly added reference signal Power*/
- CMCHKPK(oduUnpackUInt32, (U32)param->ctfCellStatus, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t)param->ctfCellStatus, mBuf);
CMCHKPK(SPkS16, param->pilotSigPwr, mBuf);
CMCHKPK(SPkS16, param->priSigPwr, mBuf);
CMCHKPK(SPkS16, param->secSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->secSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->priSigPwr, mBuf);
CMCHKUNPK(SUnpkS16, ¶m->pilotSigPwr, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->ctfCellStatus, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->ctfCellStatus, mBuf);
return ROK;
}
/**
@brief Transaction ID between CTF and User. */
typedef struct ctfCfgTransId {
- U8 trans[CTF_CFG_TRANSID_SIZE]; /*!< User transaction ID */
+ uint8_t trans[CTF_CFG_TRANSID_SIZE]; /*!< User transaction ID */
} CtfCfgTransId;
Bool pres; /*!< Present field */
CtfBandwidth dlBw; /*!< Downlink Bandwidth in RBs */
CtfBandwidth ulBw; /*!< Uplink Bandwidth in RBs */
- U8 eUtraBand; /*!< EUTRA Operating Band - 36.104 (5.5)
+ uint8_t eUtraBand; /*!< EUTRA Operating Band - 36.104 (5.5)
FDD:(1..14), TDD:(33..40) */
} CtfBwCfgInfo;
*/
typedef struct ctfPrachCfgInfo {
Bool pres; /*!< Indicates the presence of this info */
- U16 rootSequenceIndex; /*!< Range (0..837) */
- U8 prachCfgIndex; /*!< Prach Config Index (0..63) */
- U8 zeroCorrelationZoneCfg; /*!< Used for preamble sequence generation
+ uint16_t rootSequenceIndex; /*!< Range (0..837) */
+ uint8_t prachCfgIndex; /*!< Prach Config Index (0..63) */
+ uint8_t zeroCorrelationZoneCfg; /*!< Used for preamble sequence generation
(36.211, 5.7.2); FDD:0..15, TDD:0..6 */
Bool highSpeedFlag; /*!< TRUE: Restricted set,
FALSE: Unrestricted Set */
- U8 prachFreqOffset; /*!< Range(0..94) */
+ uint8_t prachFreqOffset; /*!< Range(0..94) */
} CtfPrachCfgInfo;
/**
Bool pres; /*!< Indicates the presence of this info */
S16 refSigPwr; /*!< Provides downlink reference signal EPRE,
in (-60..50)dBm */
- U8 p_b; /*!< Range(0..3) [36.213, 5.2] */
+ uint8_t p_b; /*!< Range(0..3) [36.213, 5.2] */
} CtfPdschCfgInfo;
/**
* configuration at PHY.
*/
typedef struct ctfPuschCfgBasic {
- U8 noOfsubBands; /*!< Number of sub-bands, (1..4) */
+ uint8_t noOfsubBands; /*!< Number of sub-bands, (1..4) */
CtfPuschHoppingMode hoppingMode; /*!< Hopping Mode */
- U8 hoppingOffset; /*!< Hopping Offset(0..98) */
+ uint8_t hoppingOffset; /*!< Hopping Offset(0..98) */
Bool enable64QAM; /*!< 64 QAM,TRUE: enabled,
FALSE: disabled */
} CtfPuschCfgBasic;
typedef struct ctfPuschUlRS {
Bool grpHopEnabled; /*!< Group hopping, TRUE: enabled, FALSE: disabled */
Bool seqHopEnabled; /*!< Sequence hopping, TRUE: enabled, FALSE: disabled */
- U8 grpNum; /*!< Group number (0..29) */
- U8 cycShift; /*!< Cyclic shift(0..7) */
+ uint8_t grpNum; /*!< Group number (0..29) */
+ uint8_t cycShift; /*!< Cyclic shift(0..7) */
} CtfPuschUlRS;
/**
*/
typedef struct ctfPucchCfgInfo {
Bool pres; /*!< Indicates the presence of PUCCH configuration info */
- U8 nRB; /*!< Number of RBs that are available for use by
+ uint8_t nRB; /*!< Number of RBs that are available for use by
PUCCH formats (0..98) */
- U8 nCS; /*!< Number of cyclic shifts used for PUCCH formats (0..7) */
- U16 n1PUCCH; /*!< PUCCH resource for transmission of ACK/NACK (0..2047) */
+ uint8_t nCS; /*!< Number of cyclic shifts used for PUCCH formats (0..7) */
+ uint16_t n1PUCCH; /*!< PUCCH resource for transmission of ACK/NACK (0..2047) */
CtfPucchDeltaShift deltaShift; /*!< PUCCH delta shift */
} CtfPucchCfgInfo;
*/
typedef struct ctfSrsUlCfgInfo {
Bool pres; /*!< Indicates the presence of UL SRS info */
- U8 srsCfgType; /*!< Setup/Release: The setup structure
+ uint8_t srsCfgType; /*!< Setup/Release: The setup structure
is valid ,only if srcCfgType is setup. */
struct srsSetupS
{
- U8 srsBw; /*!< SRS bandwidth config (0..7) */
- U8 sfCfg; /*!< SRS sub-frame config (0..15) */
+ uint8_t srsBw; /*!< SRS bandwidth config (0..7) */
+ uint8_t sfCfg; /*!< SRS sub-frame config (0..15) */
Bool srsANSimultTx; /*!< Simultaneous transmisson
of SRS and ACK/NACK */
Bool srsMaxUpPts; /*!< SRS MaxUpPTS: TRUE/FALSE,
*/
typedef struct ctfTddSfCfgInfo {
Bool pres; /*!< Indicates if this info is valid */
- U8 sfAssignment; /*!< UL-DL subframe assignment : (0..6)
+ uint8_t sfAssignment; /*!< UL-DL subframe assignment : (0..6)
36.211 Table 4.2-2 */
- U8 spclSfPatterns; /*!< Special subframe configuration : (0..8)
+ uint8_t spclSfPatterns; /*!< Special subframe configuration : (0..8)
36.211 Table 4.2-1 */
} CtfTddSfCfgInfo;
*/
typedef struct ctfVendorSpecific{
- U16 buffLen ; /*!< Length of parameters in bytes */
- U8 *paramBuffer ; /*!< parameter Buffer */
+ uint16_t buffLen ; /*!< Length of parameters in bytes */
+ uint8_t *paramBuffer ; /*!< parameter Buffer */
} CtfVendorSpecific;
#endif
/* Cell specific configuration parameters */
* of an unlicensed SDL cell and its associated resources at PHY.
*/
typedef struct ctfUnLicnsdCellCfg {
- U8 coExistMethod; /*!< Continuous/LTE-U/LAA */
- U8 lteOnPeriod; /*!< Percentage of time SDL
+ uint8_t coExistMethod; /*!< Continuous/LTE-U/LAA */
+ uint8_t lteOnPeriod; /*!< Percentage of time SDL
is active */
- U8 ccaMethod; /*!< Clear channel assesment method */
+ uint8_t ccaMethod; /*!< Clear channel assesment method */
Bool adaptiveTx; /*!< Indicates if the duty cycle is
adaptive or fixed */
- U16 transPeriod; /*!< Defines the duty cycle */
- U16 listenPrd; /*!< Time duration in us for clear channel
+ uint16_t transPeriod; /*!< Defines the duty cycle */
+ uint16_t listenPrd; /*!< Time duration in us for clear channel
assessment */
S16 energyTh; /*!< Energy threshold in dBFS */
- U16 scanTimePrd; /*!< Time period for RF channel scan */
- U16 activityTh; /*!< Percentage of time for activity detection
+ uint16_t scanTimePrd; /*!< Time period for RF channel scan */
+ uint16_t activityTh; /*!< Percentage of time for activity detection
to select different EARFCN */
S32 txPowerLimit; /*! Reference Signal power for Unlicensed Cell */
- U8 numFreq; /*!< Number of unlicensed channels */
- U32 earfcn[CTF_LTEU_MAX_EARFCN]; /*!< Unlicensed channels */
+ uint8_t numFreq; /*!< Number of unlicensed channels */
+ uint32_t earfcn[CTF_LTEU_MAX_EARFCN]; /*!< Unlicensed channels */
} CtfUnLicnsdCfgInfo;
typedef struct ctfLaaScanInd {
S32 status;
- U32 nEarfcn;
- U32 earfcn[CTF_LTEU_MAX_EARFCN];
+ uint32_t nEarfcn;
+ uint32_t earfcn[CTF_LTEU_MAX_EARFCN];
} CtfLaaScanInd;
#ifdef EMTC_ENABLE
typedef struct ctfEmtcCElevelInfoLst {
- U8 firstPreamble; /*!< for each CE mode, starting preamble */
- U8 lastPreamble; /*!< for each CE mode, starting preamble */
- U8 emtcNumRepPerPreambleAtt;/*!< num of repetition per preamble attempt*/
+ uint8_t firstPreamble; /*!< for each CE mode, starting preamble */
+ uint8_t lastPreamble; /*!< for each CE mode, starting preamble */
+ uint8_t emtcNumRepPerPreambleAtt;/*!< num of repetition per preamble attempt*/
}CtfEmtcCElevelInfoLst;
#endif
*/
typedef struct ctfCellCfgInfo {
CmLteCellId cellId; /*!< Cell ID */
- U8 cellIdGrpId;/*!< Cell Identity Group ID (0..167) */
+ uint8_t cellIdGrpId;/*!< Cell Identity Group ID (0..167) */
SpId macSapId; /*!< MAC SAP Id for Tfu Interface*/
SpId schSapId; /*!< Scheduler SAP Id for Tfu Interface */
/*ctf_x_001.main_3: Adding the remaining parameters */
Bool physCellIdPres ;
- U8 physCellId; /*!< Cell ID (0..2) */
+ uint8_t physCellId; /*!< Cell ID (0..2) */
CtfBwCfgInfo bwCfg; /*!< Bandwidth configuration */
CtfTxSchemeCfg txCfg; /*!< Basic transmission scheme
configuration [36.300, 5.1.1] */
CtfTddSfCfgInfo tddSfCfg; /*!< SubFrame configuration for TDD only */
/*ctf_x_001.main_3: Adding the remaining parameters */
- U16 syncSigPowOs; /*!< Synchronization signal power offset */
+ uint16_t syncSigPowOs; /*!< Synchronization signal power offset */
Bool syncSigPowOsPres;
- U16 cfiPowOs; /*!< Cfi Power Offset */
+ uint16_t cfiPowOs; /*!< Cfi Power Offset */
Bool cfiPowOsPres;
- U16 dciPowOs; /*!< Dci Power Offser */
+ uint16_t dciPowOs; /*!< Dci Power Offser */
Bool dciPowOsPres;
- U16 extWinMargin; /*!< Extraction Window Marin */
+ uint16_t extWinMargin; /*!< Extraction Window Marin */
Bool extWinMarginPres;
- U16 pucchNoiseGamma; /*!< PUCCH Noise Estimation Gamma*/
+ uint16_t pucchNoiseGamma; /*!< PUCCH Noise Estimation Gamma*/
Bool pucchNoiseGammaPres;
- U16 prachPkRatio4; /*!< PRACH Format4 Peak Ratio */
+ uint16_t prachPkRatio4; /*!< PRACH Format4 Peak Ratio */
Bool prachPkRatio4Pres;
- U16 prachPkRatio0; /*!< PRACH Format0 Peak Ratio */
+ uint16_t prachPkRatio0; /*!< PRACH Format0 Peak Ratio */
Bool prachPkRatio0Pres;
- U16 srsDopEstFactor; /*!< Doppler Estimation Compensation Power */
+ uint16_t srsDopEstFactor; /*!< Doppler Estimation Compensation Power */
Bool srsDopEstFactorPres;
- U16 puschProbDtxAck; /*!< Portability Dtx Ack PUSCH */
+ uint16_t puschProbDtxAck; /*!< Portability Dtx Ack PUSCH */
Bool puschProbDtxAckPres;
- U16 pucchProbDtxAck; /*!< Portability Dtx Ack PUCCH Format1 */
+ uint16_t pucchProbDtxAck; /*!< Portability Dtx Ack PUCCH Format1 */
Bool pucchProbDtxAckPres;
- U16 txAntennaPorts ; /*!< The number of cell specific transmit antenna ports */
+ uint16_t txAntennaPorts ; /*!< The number of cell specific transmit antenna ports */
Bool txAntennaPortsPres;
- U16 rxAntennaPorts ; /*!< The number of cell specific receive antenna ports */
+ uint16_t rxAntennaPorts ; /*!< The number of cell specific receive antenna ports */
Bool rxAntennaPortsPres ;
- U16 phySyncMode; /*!< The method used by the PHY to signal the 1ms subframe */
+ uint16_t phySyncMode; /*!< The method used by the PHY to signal the 1ms subframe */
Bool phySyncModePres;
- U16 dataRepMode; /*!< The data report mode for the uplink data */
+ uint16_t dataRepMode; /*!< The data report mode for the uplink data */
Bool dataRepModePres ;
- U16 rachSrRepMode; /*!< The reporting mode for RACH.indication and SR.indcation */
+ uint16_t rachSrRepMode; /*!< The reporting mode for RACH.indication and SR.indcation */
Bool rachSrRepModePres;
/* PHY configuration parameters */
- U16 opMode;
- U32 counter;
- U32 period;
+ uint16_t opMode;
+ uint32_t counter;
+ uint32_t period;
S16 priSigPwr;
S16 secSigPwr;
- U16 dlEarfcn;
- U16 ulEarfcn;
+ uint16_t dlEarfcn;
+ uint16_t ulEarfcn;
/*Start Fix for CR ccpu00123185 */
S16 pilotSigPwr;
/*End Fix for CR ccpu00123185 */
/* Added parameter for rgu dynamic delta*/
- U8 numDlUePerTti;
+ uint8_t numDlUePerTti;
Bool unLicnsdCfgPres; /*!< Flag to indicate unlicensed cell config */
CtfUnLicnsdCfgInfo lteUCfg; /*!< Unlicensed carrier config */
#ifdef EMTC_ENABLE
- U8 catMenabled;
- U8 mPdcchStart;
+ uint8_t catMenabled;
+ uint8_t mPdcchStart;
CtfEmtcCElevelInfoLst ceLevelInfo[CTF_MAX_CE_LEVEL];
#endif
} CtfCellCfgInfo;
CtfReCfgType ctfReCfgType ;
CmLteCellId cellId; /*!< Cell ID */
/*ctf_x_001.main_3: Adding the remaining parameters */
- U8 cellIdGrpId;/*!< Cell Identity Group ID (0..167) */
+ uint8_t cellIdGrpId;/*!< Cell Identity Group ID (0..167) */
Bool physCellIdPres ;
- U8 physCellId; /*!< Cell ID (0..2) */
+ uint8_t physCellId; /*!< Cell ID (0..2) */
CtfBwCfgInfo bwCfg; /*!< Bandwidth configuration */
CtfTxSchemeCfg txCfg; /*!< Basic transmission scheme
configuration [36.300, 5.1.1] */
CtfSrsUlCfgInfo srsUlCfg; /*!< SRS UL configuration, setup case */
CtfTddSfCfgInfo tddSfCfg; /*!< SubFrame configuration for TDD only */
/*ctf_x_001.main_3: Adding the remaining parameters */
- U16 syncSigPowOs; /*!< Synchronization signal power offset */
+ uint16_t syncSigPowOs; /*!< Synchronization signal power offset */
Bool syncSigPowOsPres;
- U16 cfiPowOs; /*!< Cfi Power Offset */
+ uint16_t cfiPowOs; /*!< Cfi Power Offset */
Bool cfiPowOsPres;
- U16 dciPowOs; /*!< Dci Power Offser */
+ uint16_t dciPowOs; /*!< Dci Power Offser */
Bool dciPowOsPres;
- U16 extWinMargin; /*!< Extraction Window Marin */
+ uint16_t extWinMargin; /*!< Extraction Window Marin */
Bool extWinMarginPres;
- U16 pucchNoiseGamma; /*!< PUCCH Noise Estimation Gamma*/
+ uint16_t pucchNoiseGamma; /*!< PUCCH Noise Estimation Gamma*/
Bool pucchNoiseGammaPres;
- U16 prachPkRatio4; /*!< PRACH Format4 Peak Ratio */
+ uint16_t prachPkRatio4; /*!< PRACH Format4 Peak Ratio */
Bool prachPkRatio4Pres;
- U16 prachPkRatio0; /*!< PRACH Format0 Peak Ratio */
+ uint16_t prachPkRatio0; /*!< PRACH Format0 Peak Ratio */
Bool prachPkRatio0Pres;
- U16 srsDopEstFactor; /*!< Doppler Estimation Compensation Power */
+ uint16_t srsDopEstFactor; /*!< Doppler Estimation Compensation Power */
Bool srsDopEstFactorPres;
- U16 puschProbDtxAck; /*!< Portability Dtx Ack PUSCH */
+ uint16_t puschProbDtxAck; /*!< Portability Dtx Ack PUSCH */
Bool puschProbDtxAckPres;
- U16 pucchProbDtxAck; /*!< Portability Dtx Ack PUCCH Format1 */
+ uint16_t pucchProbDtxAck; /*!< Portability Dtx Ack PUCCH Format1 */
Bool pucchProbDtxAckPres;
- U16 txAntennaPorts ; /*!< The number of cell specific transmit antenna ports */
+ uint16_t txAntennaPorts ; /*!< The number of cell specific transmit antenna ports */
Bool txAntennaPortsPres;
- U16 rxAntennaPorts ; /*!< The number of cell specific receive antenna ports */
+ uint16_t rxAntennaPorts ; /*!< The number of cell specific receive antenna ports */
Bool rxAntennaPortsPres ;
- U16 phySyncMode; /*!< The method used by the PHY to signal the 1ms subframe */
+ uint16_t phySyncMode; /*!< The method used by the PHY to signal the 1ms subframe */
Bool phySyncModePres;
- U16 dataRepMode; /*!< The data report mode for the uplink data */
+ uint16_t dataRepMode; /*!< The data report mode for the uplink data */
Bool dataRepModePres ;
- U16 rachSrRepMode; /*!< The reporting mode for RACH.indication and SR.indcation */
+ uint16_t rachSrRepMode; /*!< The reporting mode for RACH.indication and SR.indcation */
Bool rachSrRepModePres;
/*Start Fix for CR ccpu00123185 */
S16 pilotSigPwr;
/*End Fix for CR ccpu00123185 */
CtfCellStatus ctfCellStatus;
#ifdef ENABLE_API_LOG
- U8 enableAPILog;
+ uint8_t enableAPILog;
#endif /* ENABLE_API_LOG */
} CtfCellRecfgInfo;
*/
typedef struct ctfDedPucchCfgInfo {
Bool pres; /*!< Indicates the presence of PUCCH info */
- U8 dedPucchCfgType; /*!< Setup/Release */
+ uint8_t dedPucchCfgType; /*!< Setup/Release */
struct pucchSetupS
{
#ifdef CTF_VER3
is configured or not */
#endif /* CTF_VER3 */
CtfPucchRepFactor repFact; /*!< ACK/NACK repetition factor */
- U16 n1PUCCHRep; /*!< PUCCH resource to repeat the
+ uint16_t n1PUCCHRep; /*!< PUCCH resource to repeat the
transmission of the corresponding
ACK/NACK responce [36.213, 10.1] */
} pucchSetup;
*/
typedef struct ctfDedPuschCfgInfo {
Bool pres; /*!< Indicates the presence of PUSCH info */
- U8 betaOffsetAckIdx; /*!< Beta offset ACK index, (0..15)
+ uint8_t betaOffsetAckIdx; /*!< Beta offset ACK index, (0..15)
[36.213, Table 8.6.3.-1] */
- U8 betaOffsetRiIdx; /*!< Beta offset RI index, (0..15)
+ uint8_t betaOffsetRiIdx; /*!< Beta offset RI index, (0..15)
[36.213, Table 8.6.3.-2] */
- U8 betaOffsetCqiIdx; /*!< Beta offset CQI index, (0..15)
+ uint8_t betaOffsetCqiIdx; /*!< Beta offset CQI index, (0..15)
[36.213, Table 8.6.3.-3] */
} CtfDedPuschCfgInfo;
#ifdef CTF_VER2
Bool pres;
#endif /* CTF_VER2 */
- U8 cqiPeriodicCfgType; /*!< Configuration type: Setup/Release */
+ uint8_t cqiPeriodicCfgType; /*!< Configuration type: Setup/Release */
struct cqiSetupS
{
- U16 cqiPUCCHRsrcIndx; /*!< Range (0..1185) */
- U16 cqiPmiCfgIndx; /*!< Range (0..1023) */
- U8 formatIndicator; /*!< Type: Wideband/Subband */
+ uint16_t cqiPUCCHRsrcIndx; /*!< Range (0..1185) */
+ uint16_t cqiPmiCfgIndx; /*!< Range (0..1023) */
+ uint8_t formatIndicator; /*!< Type: Wideband/Subband */
struct subbandCqiS
{
- U8 k; /*!< Range (1..4) */
+ uint8_t k; /*!< Range (1..4) */
} subbandCqi; /*!< Valid only if formatIndicator is Subband */
Bool riCfgPres; /*!< RI Configuration index is present or absent */
- U16 riCfgIndx; /*!< Range (0..1023) */
+ uint16_t riCfgIndx; /*!< Range (0..1023) */
Bool simultaneousAckNack; /*!< Simultaneous ACK/NACK with CQI support
TRUE: YES, FALSE: NO */
/* ctf_x_001.main_2: Added cqiMask*/
CtfCqiRptModePeriodic periodicRpt;
} reportMode;
#else /* CTF_VER2 */
- U8 reportingMode; /*!< Reporting mode: Periodic/Aperiodic */
+ uint8_t reportingMode; /*!< Reporting mode: Periodic/Aperiodic */
union
{
CtfCqiRptModeAperiodic aPeriodicRpt;
*/
typedef struct ctfDedSrsUlCfgInfo {
Bool pres; /*!< Indicates the presence of SRS UL info */
- U8 dedSrsUlCfgType; /*!< Setup/Release */
+ uint8_t dedSrsUlCfgType; /*!< Setup/Release */
struct dedSrsSetupS
{
- U8 srsBw; /*!< SRS bandwidth(0,1,2,3) */
- U8 srsHopngBw; /*!< SRS hopping bandwidth (0,1,2,3) */
- U8 freqDmnPos; /*!< Frequency domain position (0..23) */
+ uint8_t srsBw; /*!< SRS bandwidth(0,1,2,3) */
+ uint8_t srsHopngBw; /*!< SRS hopping bandwidth (0,1,2,3) */
+ uint8_t freqDmnPos; /*!< Frequency domain position (0..23) */
Bool duration; /*!< Duration, FALSE: single,
TRUE: indefinite */
- U16 srsCfgIdx; /*!< SRS config index (0..1023) */
- U8 txComb; /*!< transmission comb (0..1) */
- U8 cyclicShift; /*!< Cyclic shift (0..7) */
+ uint16_t srsCfgIdx; /*!< SRS config index (0..1023) */
+ uint8_t txComb; /*!< transmission comb (0..1) */
+ uint8_t cyclicShift; /*!< Cyclic shift (0..7) */
} dedSrsSetup;
} CtfDedSrsUlCfgInfo;
*/
typedef struct ctfDedSRCfgInfo {
Bool pres; /*!< Indicates the presence of SR info */
- U8 dedSRCfgType; /*!< Setup/Release */
+ uint8_t dedSRCfgType; /*!< Setup/Release */
struct dedSrSetupS
{
- U16 srPUCCHRi; /*!< SR PUCCH Resource Index, n(1)PUCCH,SRI
+ uint16_t srPUCCHRi; /*!< SR PUCCH Resource Index, n(1)PUCCH,SRI
(0..2047) */
- U8 srCfgIdx; /*!< SR config index, Isr (0..155) */
+ uint8_t srCfgIdx; /*!< SR config index, Isr (0..155) */
} dedSrSetup; /*!< Valid only if dedSRCfgType is setup */
} CtfDedSRCfgInfo;
#endif /* TFU_UPGRADE */
CtfCdBkSubsetRestnType ctfCdBkRestType;
union
{
- U8 n2TxAntTm3; /*!< 2 Antenna Ports for transmissiom mode 3*/
- U8 n4TxAntTm3; /*!< 4 Antenna Ports for transmissiom mode 3*/
- U8 n2TxAntTm4; /*!< 2 Antenna Ports for transmissiom mode 4*/
- U8 n4TxAntTm4[8]; /*!< 4 Antenna Ports for transmissiom mode 4*/
- U8 n2TxAntTm5; /*!< 2 Antenna Ports for transmissiom mode 5*/
- U16 n4TxAntTm5; /*!< 4 Antenna Ports for transmissiom mode 5*/
- U8 n2TxAntTm6; /*!< 2 Antenna Ports for transmissiom mode 6*/
- U16 n4TxAntTm6; /*!< 4 Antenna Ports for transmissiom mode 6*/
+ uint8_t n2TxAntTm3; /*!< 2 Antenna Ports for transmissiom mode 3*/
+ uint8_t n4TxAntTm3; /*!< 4 Antenna Ports for transmissiom mode 3*/
+ uint8_t n2TxAntTm4; /*!< 2 Antenna Ports for transmissiom mode 4*/
+ uint8_t n4TxAntTm4[8]; /*!< 4 Antenna Ports for transmissiom mode 4*/
+ uint8_t n2TxAntTm5; /*!< 2 Antenna Ports for transmissiom mode 5*/
+ uint16_t n4TxAntTm5; /*!< 4 Antenna Ports for transmissiom mode 5*/
+ uint8_t n2TxAntTm6; /*!< 2 Antenna Ports for transmissiom mode 6*/
+ uint16_t n4TxAntTm6; /*!< 4 Antenna Ports for transmissiom mode 6*/
}codeBookSubsetRestn;
}CtfDedAntCodeBkSubsetRes;
#endif /* CTF_VER2 */
CtfUeTxAntMode txMode; /*!< Transmission Mode: 36.213, 7.1 */
struct ueTxAntSelectionS
{
- U8 cfgType; /*!< Setup/Release */
+ uint8_t cfgType; /*!< Setup/Release */
CtfUeTxAntSelectType txAntSelect; /*!< Closed/Open, valid only if
cfgType is setup:36.213, 8.7 */
} ueTxAntSelection;
* deriving the AS security keys using HMAC-SHA256 KDF.
*/
typedef struct ctfKenbCfgInfo{
- U8 pres;
- U8 algoType;
- U8 secKey[CTF_SEC_KEY_LEN];
+ uint8_t pres;
+ uint8_t algoType;
+ uint8_t secKey[CTF_SEC_KEY_LEN];
}CtfKenbCfgInfo;
#endif
#endif /* TFU_UPGRADE */
CtfDedAntCfgInfo antInfo; /*!< Antenna configuration */
#ifdef EMTC_ENABLE
- U8 isEmtcUe; /*!< UE type is EMTC or not */
+ uint8_t isEmtcUe; /*!< UE type is EMTC or not */
#endif
} CtfDedCfgInfo;
/** @brief Each Secondary cell configuration Info for a UE*/
typedef struct ctfUeSecCellCfgInfo
{
- U8 sCellIdx; /*!< This will be secondary cell Idx */
- U16 sCellId; /*!< This will be secondary cellId */
+ uint8_t sCellIdx; /*!< This will be secondary cell Idx */
+ uint16_t sCellId; /*!< This will be secondary cellId */
}CtfUeSecCellCfgInfo;
/** @brief Secondary cell action for a UE*/
/** @brief Secondary Cell Configuration for a UE*/
typedef struct ctfSecCellCfgInfo
{
- U8 numSCells;
+ uint8_t numSCells;
CtfScellAction sCellAction;
CtfUeSecCellCfgInfo ueSCellDedCfg[CTF_MAX_SCELL_PER_UE];
}CtfSecCellCfgInfo;
* cell or UE-specific configuration at PHY.
*/
typedef struct ctfCfgInfo {
- U8 cfgElem; /*!< Configuration element : Cell/UE */
+ uint8_t cfgElem; /*!< Configuration element : Cell/UE */
union
{
CtfCellCfgInfo cellCfg; /*!< Cell configuration */
* cell or UE-specific configuration at PHY.
*/
typedef struct ctfReCfgInfo {
- U8 cfgElem; /*!< Configuration element: Cell/UE */
+ uint8_t cfgElem; /*!< Configuration element: Cell/UE */
union
{
CtfCellRecfgInfo cellRecfg; /*!< Cell reconfiguration */
* cell or UE-specific configuration at PHY.
*/
typedef struct ctfReleaseInfo {
- U8 cfgElem; /*!< Configuration element : Cell/UE */
+ uint8_t cfgElem; /*!< Configuration element : Cell/UE */
union
{
CtfCellReleaseInfo cellRel; /*!< Cell release */
* -# The result of configuration is indicated in TfUiCtfCfgCfm.
*/
typedef struct ctfCfgReqInfo {
- U8 cfgType; /*!< Configuration type: Config/Reconfig/Release */
+ uint8_t cfgType; /*!< Configuration type: Config/Reconfig/Release */
union
{
CtfCfgInfo cfg; /*!< Cell/UE Configuration information */
/*AS key generation input information structure*/
typedef struct ctfAsKeyInfo{
- U8 intgAlgoType; /*!SNOW3g or AES used in key derivation as well */
- U8 ciphAlgoType; /*!SNOW3g or AES used in key derivation as well */
- U8 secKey[CTF_SEC_KEY_LEN]; /*!< eNodeB key received in initial context setup */
+ uint8_t intgAlgoType; /*!SNOW3g or AES used in key derivation as well */
+ uint8_t ciphAlgoType; /*!SNOW3g or AES used in key derivation as well */
+ uint8_t secKey[CTF_SEC_KEY_LEN]; /*!< eNodeB key received in initial context setup */
}CtfAsKeyInfo;
/*Horizontal keNB derivation input information structure*/
typedef struct ctfKenbStarInfo{
- U16 dlCarrFreq; /*!< DL UARFCN*/
- U16 physCellId; /*!< Physical cell ID*/
- U8 secKey[CTF_SEC_KEY_LEN]; /*!< Current eNodeB key at App used to derive keNB*. Horizontal KD */
+ uint16_t dlCarrFreq; /*!< DL UARFCN*/
+ uint16_t physCellId; /*!< Physical cell ID*/
+ uint8_t secKey[CTF_SEC_KEY_LEN]; /*!< Current eNodeB key at App used to derive keNB*. Horizontal KD */
}CtfKenbStarInfo;
/*Vertical keNB derivation input information structure*/
typedef struct ctfNhKeyInfo{
- U16 dlCarrFreq; /*!< DL UARFCN*/
- U16 physCellId; /*!< Physical cell ID*/
- U8 secKey[CTF_SEC_KEY_LEN]; /*!< NH key provided by MME used to derive keNB*. Vertical KD */
+ uint16_t dlCarrFreq; /*!< DL UARFCN*/
+ uint16_t physCellId; /*!< Physical cell ID*/
+ uint8_t secKey[CTF_SEC_KEY_LEN]; /*!< NH key provided by MME used to derive keNB*. Vertical KD */
}CtfNhKeyInfo;
typedef struct ctfKdfReqInfo {
- U8 keyDerType; /*!< Keyderivation type type: for AS security keys/keNB* from keNB/keNB* from NH key */
+ uint8_t keyDerType; /*!< Keyderivation type type: for AS security keys/keNB* from keNB/keNB* from NH key */
union
{
CtfAsKeyInfo kEnbInf; /*!< eNodeB key for for deriving AS security keys */
/*AS key generation output information structure*/
typedef struct ctfAskeyCfmInfo{
- U8 intKey[CTF_SEC_KEY_LEN]; /*!< eNodeB key received in initial context setup */
- U8 upCiphKey[CTF_SEC_KEY_LEN]; /*!< eNodeB key received in initial context setup */
- U8 cpCiphKey[CTF_SEC_KEY_LEN]; /*!< eNodeB key received in initial context setup */
+ uint8_t intKey[CTF_SEC_KEY_LEN]; /*!< eNodeB key received in initial context setup */
+ uint8_t upCiphKey[CTF_SEC_KEY_LEN]; /*!< eNodeB key received in initial context setup */
+ uint8_t cpCiphKey[CTF_SEC_KEY_LEN]; /*!< eNodeB key received in initial context setup */
}CtfAskeyCfmInfo;
/*Horizontal keNB derivation output information structure*/
typedef struct ctfKenbStarCfmInfo{
- U8 secKey[CTF_SEC_KEY_LEN]; /*!< Current eNodeB key at App used to derive keNB*. Horizontal KD */
+ uint8_t secKey[CTF_SEC_KEY_LEN]; /*!< Current eNodeB key at App used to derive keNB*. Horizontal KD */
}CtfKenbStarCfmInfo;
/*Vertical keNB derivation output information structure*/
typedef struct ctfNhKeyCfmInfo{
- U8 secKey[CTF_SEC_KEY_LEN]; /*!< NH key provided by MME used to derive keNB*. Vertical KD */
+ uint8_t secKey[CTF_SEC_KEY_LEN]; /*!< NH key provided by MME used to derive keNB*. Vertical KD */
}CtfNhKeyCfmInfo;
typedef struct ctfKdfCfmInfo {
- U8 keyDerType; /*!< Keyderivation type type: for AS security keys/keNB* from keNB/keNB* from NH key */
+ uint8_t keyDerType; /*!< Keyderivation type type: for AS security keys/keNB* from keNB/keNB* from NH key */
union
{
CtfAskeyCfmInfo kEnbInf; /*!< AS security keys */
typedef struct ctfCnmVendorSpecificInfo{
- U16 numOfVendorSpecifcParam; /* Number of vendor specific parameters */
- U32 vendorSpecifcParam[CTF_CNM_MAX_VENDOR_PARAMS]; /*List of vendor specific parameters */
+ uint16_t numOfVendorSpecifcParam; /* Number of vendor specific parameters */
+ uint32_t vendorSpecifcParam[CTF_CNM_MAX_VENDOR_PARAMS]; /*List of vendor specific parameters */
}CtfCnmVendorSpecificInfo;
typedef struct ctfCnmCellSyncReq {
- U16 nbrEarfcn; /*earfcn of the neighbour to be synced with*/
- U16 nbrPCellId; /*PCI of the neighbour to be synced with*/
- U8 nbrTxAntCount; /*Number of Anttennas of the neighbour to be synced with
+ uint16_t nbrEarfcn; /*earfcn of the neighbour to be synced with*/
+ uint16_t nbrPCellId; /*PCI of the neighbour to be synced with*/
+ uint8_t nbrTxAntCount; /*Number of Anttennas of the neighbour to be synced with
Possible values 1,2,4 */
- U8 nbrCellCp; /* Cyclic perifx type of the neighbout cell
+ uint8_t nbrCellCp; /* Cyclic perifx type of the neighbout cell
* 0 : Normal Cp, 1:Extended Cp */
- U8 nbrCellNRb; /* Number of Resource blocks of the neighbour cell
+ uint8_t nbrCellNRb; /* Number of Resource blocks of the neighbour cell
* possible values 6,15,25,50,75,100 */
- U8 nbrSpecSfCfg; /* Special Subframe configuraiton value of the neighbour cell */
+ uint8_t nbrSpecSfCfg; /* Special Subframe configuraiton value of the neighbour cell */
CtfCnmVendorSpecificInfo ctfCnmVendorSpecificInfo;
}CtfCnmCellSyncReq;
typedef struct ctfCnmInitSyncReq {
- U8 searchType; /*0: search for all cells.
+ uint8_t searchType; /*0: search for all cells.
*1: search for strongest cell.
*2: Search for specific cell. */
- U8 mibRequest; /*Flag to indicate if MIB information
+ uint8_t mibRequest; /*Flag to indicate if MIB information
of the searched cell should be
indicated in cell search response message.*/
- U16 earfcn; /*earfcn to the searched for */
- U8 measBandWidth; /*Number of Rb */
- U16 numOfPciList; /*Number of Pci to be searched for */
+ uint16_t earfcn; /*earfcn to the searched for */
+ uint8_t measBandWidth; /*Number of Rb */
+ uint16_t numOfPciList; /*Number of Pci to be searched for */
CtfCnmCellSyncReq pciList[CTF_CNM_MAX_CELL_SEARCH];
}CtfCnmInitSyncReq;
/********************************************************************************************************************************/
/********************************************************************************************************************************/
typedef struct ctfCnmMibInfo {
- U16 sfn; /* The radio frame the data was received on */
- U8 numTxAntennas; /* Number of TX antennas of the cell */
- U8 phichDuration; /* The PHICH duration of the cell 0-Normal 1-Extended*/
- U8 phichResource; /* 0=1/6, 1=1/2 , 2=1 ,3=2 */
- U8 dlSystemBandWidht; /*Possible values 6,15,25,50,75,100 */
+ uint16_t sfn; /* The radio frame the data was received on */
+ uint8_t numTxAntennas; /* Number of TX antennas of the cell */
+ uint8_t phichDuration; /* The PHICH duration of the cell 0-Normal 1-Extended*/
+ uint8_t phichResource; /* 0=1/6, 1=1/2 , 2=1 ,3=2 */
+ uint8_t dlSystemBandWidht; /*Possible values 6,15,25,50,75,100 */
}CtfCnmMibInfo;
typedef struct ctfCnmInitSyncInfo {
- U16 pci; /* Physical cell Id of the Cell */
- U8 rsrp; /* RSRP of the measured cell */
- U8 mibValidFlag; /* 1=MIB present 0=MIB not present */
- U16 localSfn; /* The radio frame data was received on the local cell */
+ uint16_t pci; /* Physical cell Id of the Cell */
+ uint8_t rsrp; /* RSRP of the measured cell */
+ uint8_t mibValidFlag; /* 1=MIB present 0=MIB not present */
+ uint16_t localSfn; /* The radio frame data was received on the local cell */
CtfCnmMibInfo ctfCnmMibInfo;/* MIB information */
CtfCnmVendorSpecificInfo ctfCnmVendorSpecificInfo;
}CtfCnmInitSyncInfo;
typedef struct ctfCnmInitSyncRsp {
- U8 status; /*RFAILURE or ROK */
- U16 earfcn; /*Frequency channel of the searched cell */
- U8 numOfNeighbourInfo; /* number of neighboure Cell search Info */
+ uint8_t status; /*RFAILURE or ROK */
+ uint16_t earfcn; /*Frequency channel of the searched cell */
+ uint8_t numOfNeighbourInfo; /* number of neighboure Cell search Info */
CtfCnmInitSyncInfo ctfCnmInitSyncInfo[CTF_CNM_MAX_CELL_SEARCH];
}CtfCnmInitSyncRsp;
typedef struct ctfCnmCellSyncRsp {
- U8 status; /*RFAILURE or ROK */
+ uint8_t status; /*RFAILURE or ROK */
}CtfCnmCellSyncRsp;
typedef struct ctfCnmCellSyncInd {
- U8 status; /*RFAILURE or ROK */
+ uint8_t status; /*RFAILURE or ROK */
CtfCnmVendorSpecificInfo ctfCnmVendorSpecificInfo;
}CtfCnmCellSyncInd;
/* Periodic REM for TPM */
typedef struct ctfPeriodicRemCellInfo {
- U16 pci;
- U8 rsrp;
- U8 dlBw;
- U8 numTx;
+ uint16_t pci;
+ uint8_t rsrp;
+ uint8_t dlBw;
+ uint8_t numTx;
}CtfPeriodicRemCellInfo;
typedef struct ctfPeriodicRemCellSearchRsp {
- U8 numCells; /* Number of Cells */
+ uint8_t numCells; /* Number of Cells */
CtfPeriodicRemCellInfo cellInfo[CTF_REM_MAX_CELL_SEARCH];
}CtfPeriodicRemCellSearchRsp;
/* Periodic REM for TPM End */
typedef S16 (*CtfBndCfm) ARGS((
Pst* pst,
SuId suId,
- U8 status));
+ uint8_t status));
/* Request from User to PHY to Unbind the CTF interface SAP. */
typedef S16 (*CtfUbndReq) ARGS((
Pst* pst,
SuId suId,
CtfCfgTransId transId,
- U8 status));
+ uint8_t status));
/* EnodeB stop indication from PHY to User. */
typedef S16 (*CtfEnbStopInd) ARGS((
SuId suId,
CtfCfgTransId transId,
CtfKdfCfmInfo* kdfCfmInfo,
- U8 status));
+ uint8_t status));
#endif
/* CNM start */
typedef S16 (*CtfCnmInitSyncReqMsg) ARGS((
EXTERN S16 TfUiCtfBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/**
Pst* pst,
SuId suId,
CtfCfgTransId transId,
- U8 status
+ uint8_t status
));
/**
EXTERN S16 NhLiCtfBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/* Request from User to PHY to Unbind the CTF interface SAP. */
EXTERN S16 NhLiCtfUbndReq ARGS((
Pst* pst,
SuId suId,
CtfCfgTransId transId,
- U8 status
+ uint8_t status
));
/** UE ID Change Request from User to PHY. */
EXTERN S16 NhLiCtfUeIdChgReq ARGS((
EXTERN S16 cmPkCtfBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/* Confirmation from PHY to User for the Bind/Unbind
* Request for the CTF interface SAP.
SuId suId,
CtfCfgTransId transId,
CtfKdfCfmInfo *kdfCfmInfo,
- U8 status
+ uint8_t status
));
/* Configuration Confirm from PHY to User. */
EXTERN S16 cmUnpkCtfKdfCfm ARGS((
Pst* pst,
SuId suId,
CtfCfgTransId transId,
- U8 status
+ uint8_t status
));
/* ENB-STOP Indication from PHY to User. */
EXTERN S16 cmPkCtfEnbStopInd ARGS((
EXTERN S16 DmUiCtfBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/* Request from User to PHY to Unbind the CTF interface SAP. */
EXTERN S16 DmUiCtfUbndReq ARGS((
Pst* pst,
SuId suId,
CtfCfgTransId transId,
- U8 status
+ uint8_t status
));
/** UE ID Change Request from User to PHY. */
EXTERN S16 DmUiCtfUeIdChgReq ARGS((
SuId suId,
CtfCfgTransId transId,
CtfUeInfo * ueInfo,
- U8 status
+ uint8_t status
));
#endif /* DM */
SuId suId,
CtfCfgTransId transId,
CtfKdfCfmInfo *kdfCfmInfo,
-U8 status
+uint8_t status
));
EXTERN S16 cmUnpkCtfNhKeyCfmInfo ARGS(
(
File: envdep.h
*********************************************************************21*/
-
#ifndef __ENVDEPH__
#define __ENVDEPH__
typedef unsigned char Bool; /* boolean */
typedef char S8; /* signed - 8 bits */
-typedef unsigned char U8; /* unsigned - 8 bits */
typedef int S16; /* signed - 16 bits */
-typedef unsigned int U16; /* unsigned - 16 bits */
typedef long S32; /* signed - 32 bits */
-typedef unsigned long U32; /* unsigned - 32 bits */
/* envdep_h_001.main_71 */
typedef __int64 S64; /* signed - 64 bits */
-typedef unsigned __int64 U64; /* unsigned - 64 bits */
/*
void
typedef unsigned char Bool; /* boolean */
typedef char S8; /* signed - 8 bits */
-typedef unsigned char U8; /* unsigned - 8 bits */
typedef int S16; /* signed - 16 bits */
-typedef unsigned int U16; /* unsigned - 16 bits */
typedef long S32; /* signed - 32 bits */
-typedef unsigned long U32; /* unsigned - 32 bits */
/*
void
/*envdep_h_001.main_78 :removed signed to supress sprintf' differ in signedness warnings */
typedef char S8; /* signed - 8 bits*/
#endif
-typedef unsigned char U8; /* unsigned - 8 bits */
typedef short S16; /* signed - 16 bits */
-typedef unsigned short U16; /* unsigned - 16 bits */
#if !(defined(ALPHA) || defined(BIT_64))
typedef long S32; /* signed - 32 bits */
-typedef unsigned long U32; /* unsigned - 32 bits */
/* envdep_h_001.main_71 */
#ifdef SS_LINUX
/* envdep_h_001.main_79 RVDT compiler warning fix */
#ifndef SS_4GMX_LCORE
/* envdep_h_001.main_72: Support for C89 standard */
__extension__ typedef long long S64; /* signed - 64 bits */
-__extension__ typedef unsigned long long U64; /* unsigned - 64 bits */
#else
typedef long long S64; /* signed - 64 bits */
-typedef unsigned long long U64; /* unsigned - 64 bits */
#define Void void /* RVDT compiler warning fix */
#endif /* SS_4GMX_LCORE */
#else
typedef long long S64; /* signed - 64 bits */
-typedef unsigned long long U64; /* unsigned - 64 bits */
#endif /* SS_LINUX */
#else /* ALPHA & BIT_64 */
typedef int S32; /* signed - 32 bits */
-typedef unsigned int U32; /* unsigned - 32 bits */
/* envdep_h_001.main_71 */
typedef long S64; /* signed - 64 bits */
-typedef unsigned long U64; /* unsigned - 64 bits */
#endif /* ALPHA & BIT_64 */
/* 1. Added F32 and F64 */
#ifdef SS_FLOAT
typedef unsigned char Bool; /* boolean */
typedef char S8; /* signed - 8 bits */
-typedef unsigned char U8; /* unsigned - 8 bits */
typedef short S16; /* signed - 16 bits */
-typedef unsigned short U16; /* unsigned - 16 bits */
typedef int S32; /* signed - 32 bits */
-typedef unsigned int U32; /* unsigned - 32 bits */
#ifndef ANSI
/* size_t is not defined, for some odd reason, in mcc68k's stddef.h */
typedef unsigned char Bool; /* boolean */
typedef char S8; /* signed - 8 bits */
-typedef unsigned char U8; /* unsigned - 8 bits */
typedef short S16; /* signed - 16 bits */
-typedef unsigned short U16; /* unsigned - 16 bits */
typedef int S32; /* signed - 32 bits */
-typedef unsigned int U32; /* unsigned - 32 bits */
/*
void
typedef unsigned char Bool; /* boolean */
typedef char S8; /* signed - 8 bits */
-typedef unsigned char U8; /* unsigned - 8 bits */
typedef short S16; /* signed - 16 bits */
-typedef unsigned short U16; /* unsigned - 16 bits */
typedef int S32; /* signed - 32 bits */
-typedef unsigned int U32; /* unsigned - 32 bits */
/*
void
typedef unsigned char Bool; /* boolean */
typedef char S8; /* signed - 8 bits */
-typedef unsigned char U8; /* unsigned - 8 bits */
typedef short S16; /* signed - 16 bits */
-typedef unsigned short U16; /* unsigned - 16 bits */
typedef int S32; /* signed - 32 bits */
-typedef unsigned int U32; /* unsigned - 32 bits */
/* envdep_h_001.main_71 */
typedef long long S64; /* signed - 64 bits */
-typedef unsigned long long U64; /* unsigned - 64 bits */
/* 1. Added F32 and F64 types */
#ifdef SS_FLOAT
typedef float F32; /* float - 32 bits */
#ifdef SOLMRI43 /* solaris microtec c cross-compiler */
typedef unsigned char Bool; /* boolean */
typedef char S8; /* signed - 8 bits */
-typedef unsigned char U8; /* unsigned - 8 bits */
typedef short S16; /* signed - 16 bits */
-typedef unsigned short U16; /* unsigned - 16 bits */
typedef int S32; /* signed - 32 bits */
-typedef unsigned int U32; /* unsigned - 32 bits */
/*
void
typedef unsigned char Bool; /* boolean */
typedef char S8; /* signed - 8 bits */
-typedef unsigned char U8; /* unsigned - 8 bits */
typedef short S16; /* signed - 16 bits */
-typedef unsigned short U16; /* unsigned - 16 bits */
typedef long S32; /* signed - 32 bits */
-typedef unsigned long U32; /* unsigned - 32 bits */
/*
void
#ifdef WIN32
typedef unsigned char Bool; /* boolean */
typedef char S8; /* signed - 8 bits */
-typedef unsigned char U8; /* unsigned - 8 bits */
typedef short S16; /* signed - 16 bits */
-typedef unsigned short U16; /* unsigned - 16 bits */
typedef int S32; /* signed - 32 bits */
-typedef unsigned int U32; /* unsigned - 32 bits */
/* envdep_h_001.main_76 Take care of the windows compiler non compliance
* to ANSI-C for data type ranges
*/
typedef long long S64; /* signed - 64 bits */
-typedef unsigned long long U64; /* unsigned - 64 bits */
/* 1. Added F32 and F64 types */
#ifdef SS_FLOAT
#ifdef PROC_68349
typedef unsigned char Bool; /* boolean */
typedef char S8; /* signed - 8 bits */
-typedef unsigned char U8; /* unsigned - 8 bits */
typedef short S16; /* signed - 16 bits */
-typedef unsigned short U16; /* unsigned - 16 bits */
typedef long S32; /* signed - 32 bits */
-typedef unsigned long U32; /* unsigned - 32 bits */
/*
void
#ifdef PROC_PPC
typedef unsigned char Bool; /* boolean */
typedef char S8; /* signed - 8 bits */
-typedef unsigned char U8; /* unsigned - 8 bits */
typedef short S16; /* signed - 16 bits */
-typedef unsigned short U16; /* unsigned - 16 bits */
#ifndef BIT_64
typedef long S32; /* signed - 32 bits */
-typedef unsigned long U32; /* unsigned - 32 bits */
/* envdep_h_001.main_74 - additions */
typedef long long S64; /* signed - 64 bits */
-typedef unsigned long long U64; /* unsigned - 64 bits */
#else /* BIT_64 */
typedef int S32; /* signed - 32 bits */
-typedef unsigned int U32; /* unsigned - 32 bits */
typedef long S64; /* signed - 64 bits */
-typedef unsigned long U64; /* unsigned - 64 bits */
#endif /* BIT_64 */
/* 1. Added F32 and F64 types */
#ifdef SS_PS
typedef unsigned char Bool; /* boolean */
typedef char S8; /* signed - 8 bits */
-typedef unsigned char U8; /* unsigned - 8 bits */
typedef short S16; /* signed - 16 bits */
-typedef unsigned short U16; /* unsigned - 16 bits */
#ifndef BIT_64
typedef long S32; /* signed - 32 bits */
-typedef unsigned long U32; /* unsigned - 32 bits */
/* envdep_h_001.main_71 - additions */
typedef int64_t S64; /* signed - 64 bits */
-typedef uint64_t U64; /* unsigned - 64 bits */
#else /* BIT_64 */
typedef int S32; /* signed - 32 bits */
-typedef unsigned int U32; /* unsigned - 32 bits */
typedef long S64; /* signed - 64 bits */
-typedef unsigned long U64; /* unsigned - 64 bits */
#endif /* BIT_64 */
/*
typedef unsigned char Bool; /* boolean */
typedef char S8; /* signed - 8 bits */
-typedef unsigned char U8; /* unsigned - 8 bits */
typedef int S16; /* signed - 16 bits */
-typedef unsigned int U16; /* unsigned - 16 bits */
typedef long S32; /* signed - 32 bits */
-typedef unsigned long U32; /* unsigned - 32 bits */
/*
void
#ifdef I86SM /* Intel 80x86 small model */
-#define NULLP 0 /* null pointer */
-#define NULLD 0L /* null data */
-#define PTR U16 /* pointer */
-#define PTRSIZE sizeof(U16) /* pointer size */
+#define NULLP 0 /* null pointer */
+#define NULLD 0L /* null data */
+#define PTR uint16_t /* pointer */
+#define PTRSIZE sizeof(uint16_t) /* pointer size */
#define STKALIGN 2 /* stack alignment */
#define REG1 register /* register 1 - highest priority */
#ifdef I86MM /* Intel 80x86 medium model */
-#define NULLP 0 /* null pointer */
-#define NULLD 0L /* null data */
-#define PTR U16 /* pointer */
-#define PTRSIZE sizeof(U16) /* pointer size */
+#define NULLP 0 /* null pointer */
+#define NULLD 0L /* null data */
+#define PTR uint16_t /* pointer */
+#define PTRSIZE sizeof(uint16_t) /* pointer size */
#define STKALIGN 2 /* stack alignment */
#define REG1 register /* register 1 - highest priority */
#define NULLP 0L /* null pointer */
#define NULLD 0L /* null data */
#ifndef BIT_64
-#define PTR U32 /* pointer */
-#define PTRSIZE sizeof(U32) /* pointer size */
+#define PTR uint32_t /* pointer */
+#define PTRSIZE sizeof(uint32_t) /* pointer size */
/* #define PTRFAR pointer far */
#define STKALIGN 4 /* stack alignment */
#else /* BIT_64 */
-#define PTR U64 /* pointer */
+#define PTR uint64_t /* pointer */
/* envdep_h_001.main_78:Warning fix*/
-#define PTRSIZE sizeof(U64) /* pointer size */
+#define PTRSIZE sizeof(uint64_t) /* pointer size */
/* #define PTRFAR pointer far */
#define STKALIGN 8 /* stack alignment */
#endif /* BIT_64 */
#define NULLP 0L /* null pointer */
#define NULLD 0L /* null data */
#ifndef BIT_64
-#define PTR U32 /* pointer */
-#define PTRSIZE sizeof(U32) /* pointer size */
+#define PTR uint32_t /* pointer */
+#define PTRSIZE sizeof(uint32_t) /* pointer size */
#define PTRFAR /* pointer far */
#define STKALIGN 4 /* stack alignment */
#else /* BIT_64 */
-#define PTR U64 /* pointer */
+#define PTR uint64_t /* pointer */
/* envdep_h_001.main_78:Warning fix*/
-#define PTRSIZE sizeof(U64) /* pointer size */
+#define PTRSIZE sizeof(uint64_t) /* pointer size */
/* #define PTRFAR pointer far */
#define STKALIGN 8 /* stack alignment */
#endif /* BIT_64 */
#define NULLP 0L /* null pointer */
#define NULLD 0L /* null data */
#ifndef BIT_64
-#define PTR U32 /* pointer */
-#define PTRSIZE sizeof(U32) /* pointer size */
+#define PTR uint32_t /* pointer */
+#define PTRSIZE sizeof(uint32_t) /* pointer size */
#define PTRFAR /* pointer far */
#define STKALIGN 4 /* stack alignment */
#else /* BIT_64 */
-#define PTR U64 /* pointer */
-#define PTRSIZE sizeof(U64) /* pointer size */
+#define PTR uint64_t /* pointer */
+#define PTRSIZE sizeof(uint64_t) /* pointer size */
#define PTRFAR /* pointer far */
#define STKALIGN 8 /* stack alignment */
#endif /* BIT_64 */
#define NULLP 0L /* null pointer */
#define NULLD 0L /* null data */
-#define PTR U32 /* pointer */
-#define PTRSIZE sizeof(U32) /* pointer size */
+#define PTR uint32_t /* pointer */
+#define PTRSIZE sizeof(uint32_t) /* pointer size */
/* #define PTRFAR pointer far */
#define STKALIGN 4 /* stack alignment */
#define NULLP 0L /* null pointer */
#define NULLD 0L /* null data */
#ifndef BIT_64
-#define PTR U32 /* pointer */
-#define PTRSIZE sizeof(U32) /* pointer size */
+#define PTR uint32_t /* pointer */
+#define PTRSIZE sizeof(uint32_t) /* pointer size */
/* #define PTRFAR pointer far */
#define STKALIGN 4 /* stack alignment */
#else /* BIT_64 */
-#define PTR U64 /* pointer */
-#define PTRSIZE sizeof(U64) /* pointer size */
+#define PTR uint64_t /* pointer */
+#define PTRSIZE sizeof(uint64_t) /* pointer size */
/* #define PTRFAR pointer far */
#define STKALIGN 8 /* stack alignment */
#endif /* BIT_64 */
#define NULLP 0L /* null pointer */
#define NULLD 0L /* null data */
#ifndef BIT_64
-#define PTR U32 /* pointer */
-#define PTRSIZE sizeof(U32) /* pointer size */
+#define PTR uint32_t /* pointer */
+#define PTRSIZE sizeof(uint32_t) /* pointer size */
/* #define PTRFAR pointer far */
#define STKALIGN 4 /* stack alignment */
#else
-#define PTR U64 /* pointer */
-#define PTRSIZE sizeof(U64) /* pointer size */
+#define PTR uint64_t /* pointer */
+#define PTRSIZE sizeof(uint64_t) /* pointer size */
/* #define PTRFAR pointer far */
#define STKALIGN 8 /* stack alignment */
#endif /* BIT_64 */
#define NULLP 0L /* null pointer */
#define NULLD 0L /* null data */
#ifndef BIT_64
-#define PTR U32 /* pointer */
-#define PTRSIZE sizeof(U32) /* pointer size */
+#define PTR uint32_t /* pointer */
+#define PTRSIZE sizeof(uint32_t) /* pointer size */
#define STKALIGN 4 /* stack alignment */
#else /* BIT_64 */
-#define PTR U64 /* pointer */
-#define PTRSIZE sizeof(U64) /* pointer size */
+#define PTR uint64_t /* pointer */
+#define PTRSIZE sizeof(uint64_t) /* pointer size */
#define STKALIGN 8 /* stack alignment */
#endif /* BIT_64 */
#define NULLP 0L /* null pointer */
#define NULLD 0L /* null data */
-#define PTR U32 /* pointer */
-#define PTRSIZE sizeof(U32) /* pointer size */
+#define PTR uint32_t /* pointer */
+#define PTRSIZE sizeof(uint32_t) /* pointer size */
/* #define PTRFAR pointer far */
#define STKALIGN 4 /* stack alignment */
#define NULLP 0L /* null pointer */
#define NULLD 0L /* null data */
-#define PTR U64 /* pointer */
-#define PTRSIZE sizeof(U64) /* pointer size */
+#define PTR uint64_t /* pointer */
+#define PTRSIZE sizeof(uint64_t) /* pointer size */
/* #define PTRFAR pointer far */
#define STKALIGN 8 /* stack alignment */
#define NULLP 0L /* null pointer */
#define NULLD 0L /* null data */
-#define PTR U32 /* pointer */
-#define PTRSIZE sizeof(U32) /* pointer size */
+#define PTR uint32_t /* pointer */
+#define PTRSIZE sizeof(uint32_t) /* pointer size */
/* #define PTRFAR pointer far */
#define STKALIGN 4 /* stack alignment */
#define NULLP 0L /* null pointer */
#define NULLD 0L /* null data */
#ifndef BIT_64
-#define PTR U32 /* pointer */
-#define PTRSIZE sizeof(U32) /* pointer size */
+#define PTR uint32_t /* pointer */
+#define PTRSIZE sizeof(uint32_t) /* pointer size */
/* #define PTRFAR pointer far */
#define STKALIGN 4 /* stack alignment */
#else /* BIT_64 */
-#define PTR U64 /* pointer */
-#define PTRSIZE sizeof(U64) /* pointer size */
+#define PTR uint64_t /* pointer */
+#define PTRSIZE sizeof(uint64_t) /* pointer size */
/* #define PTRFAR pointer far */
#define STKALIGN 8 /* stack alignment */
#endif /* BIT_64 */
#define NULLP 0L /* null pointer */
#define NULLD 0L /* null data */
#ifndef BIT_64
-#define PTR U32 /* pointer */
-#define PTRSIZE sizeof(U32) /* pointer size */
+#define PTR uint32_t /* pointer */
+#define PTRSIZE sizeof(uint32_t) /* pointer size */
#define STKALIGN 4 /* stack alignment */
#else /* BIT_64 */
-#define PTR U64 /* pointer */
-#define PTRSIZE sizeof(U64) /* pointer size */
+#define PTR uint64_t /* pointer */
+#define PTRSIZE sizeof(uint64_t) /* pointer size */
#define STKALIGN 8 /* stack alignment */
#endif /* BIT_64 */
/*envdep_h_001.main_77 SSI-4GMX specfic changes*/
#ifndef SS_4GMX_LCORE
#ifdef _WIN64
-#define PTR U64 /* pointer */
-#define PTRSIZE sizeof(U64) /* pointer size */
+#define PTR uint64_t /* pointer */
+#define PTRSIZE sizeof(uint64_t) /* pointer size */
#define STKALIGN 8 /* stack alignment */
#else /* _WIN64 */
-#define PTR U32 /* pointer */
-#define PTRSIZE sizeof(U32) /* pointer size */
+#define PTR uint32_t /* pointer */
+#define PTRSIZE sizeof(uint32_t) /* pointer size */
#define STKALIGN 4 /* stack alignment */
#endif
#else
-#define PTR U32 /* pointer */
-#define PTRSIZE sizeof(U32) /* pointer size */
+#define PTR uint32_t /* pointer */
+#define PTRSIZE sizeof(uint32_t) /* pointer size */
#define STKALIGN 4 /* stack alignment */
#endif
\f
/* message function type macro */
-typedef U32 MFTYPE;
\f
/* typedef and defines for argument manipulation */
/* RG: changed the order of parentheses to make the casts more accurate */
-#define GetHiByte(w) (((U16)(w) >> 8) & 0xff) /* get hi byte from word */
-#define GetLoByte(w) ((U16)(w) & 0xff) /* get lo byte from word */
-#define GetHiWord(l) (((U32)(l) >> 16) & 0xffffL) /* get hi word of long */
-#define GetLoWord(l) ((U32)(l) & 0xffffL) /* get lo word of long */
+#define GetHiByte(w) (((uint16_t)(w) >> 8) & 0xff) /* get hi byte from word */
+#define GetLoByte(w) ((uint16_t)(w) & 0xff) /* get lo byte from word */
+#define GetHiWord(l) (((uint32_t)(l) >> 16) & 0xffffL) /* get hi word of long */
+#define GetLoWord(l) ((uint32_t)(l) & 0xffffL) /* get lo word of long */
/* envind_h_001_102: add 64 bit support */
#if (defined(ALPHA) || defined(BIT_64))
-#define GetLo32Bit(l) ((U64)(l) & 0xffffffffL) /*get lo 32 bits */
-#define GetHi32Bit(l) (((U64)(l) >> 32) & 0xffffffffL) /*get hi 32 bits */
+#define GetLo32Bit(l) ((uint64_t)(l) & 0xffffffffL) /*get lo 32 bits */
+#define GetHi32Bit(l) (((uint64_t)(l) >> 32) & 0xffffffffL) /*get hi 32 bits */
#endif
/* RG: changed put macros so the target does not have to be cleared before use */
-#define PutHiByte(w,b) (U16) (((U16)(b) << 8) | ((U16)(w) & 0x00ff)) /* put hi byte to word */
-#define PutLoByte(w,b) (U16) (((U16)(b) & 0xff) | ((U16)(w) & 0xff00)) /* put lo byte to word */
-#define PutHiWord(l,w) (U32) (((U32)(w) << 16) | ((U32)(l) & (U32)0x0000ffff)) /* put hi word to long */
-#define PutLoWord(l,w) (U32) (((U32)(w) & 0xffff) | ((U32)(l) & (U32)0xffff0000)) /* put lo word to long */
+#define PutHiByte(w,b) (uint16_t) (((uint16_t)(b) << 8) | ((uint16_t)(w) & 0x00ff)) /* put hi byte to word */
+#define PutLoByte(w,b) (uint16_t) (((uint16_t)(b) & 0xff) | ((uint16_t)(w) & 0xff00)) /* put lo byte to word */
+#define PutHiWord(l,w) (uint32_t) (((uint32_t)(w) << 16) | ((uint32_t)(l) & (uint32_t)0x0000ffff)) /* put hi word to long */
+#define PutLoWord(l,w) (uint32_t) (((uint32_t)(w) & 0xffff) | ((uint32_t)(l) & (uint32_t)0xffff0000)) /* put lo word to long */
/* envind_h_001_102: add 64 bit support */
#if (defined(ALPHA) || defined(BIT_64))
-#define PutLo32Bit(l,w) (U64) (((U64)(w) & 0xffffffff) | ((U64)(l) & (U64)0xffffffff00000000)) /* put lo 32 bits */
-#define PutHi32Bit(l,w) (U64) (((U64)(w) << 32) | ((U64)(l) & (U64)0x00000000ffffffff)) /* put hi 32 bits */
+#define PutLo32Bit(l,w) (uint64_t) (((uint64_t)(w) & 0xffffffff) | ((uint64_t)(l) & (uint64_t)0xffffffff00000000)) /* put lo 32 bits */
+#define PutHi32Bit(l,w) (uint64_t) (((uint64_t)(w) << 32) | ((uint64_t)(l) & (uint64_t)0x00000000ffffffff)) /* put hi 32 bits */
#endif
#define Char(c) ((c) & 0x7f) /* truncate to 7 bits */
#define AM_CV_TMPFAIL 41 /* Temporary failure */
#define AM_CV_ACCINFODISC 43 /* access info discarded */
#define AM_CV_NOVCCAVAIL 45 /* no VPCI/VCI unavailable */
-#define AM_CV_RESAIL 47 /* resources unavailable, unspecified */
+#define AM_CV_RESAIL 47 /* resources unavailable, unspecified */
#define AM_CV_QOSUNAVAIL 49 /* Quality of Service unavailable */
#define AM_CV_RATEUNAVAIL 51 /* UNI 3.0: user cell rate unavailable */
#define AM_CV_REQPVPCVCCUNAV 53 /* PNNI: Requested Called party soft PVPC/PVCC not available */
#define CBUF_WRITE(_class,_argList) \
{ \
S32 tmpLen = 0; \
- U32 idx; \
+ uint32_t idx; \
tmpLen = sprintf _argList; \
if(CBUFPRNTSZE >= tmpLen) \
{ \
#define CBUF_DATA_PRINT(_class) \
{ \
S8 *tmpBuf = NULLP ;\
- U32 cBufIdx; \
- U32 tmpIdx=0; \
+ uint32_t cBufIdx; \
+ uint32_t tmpIdx=0; \
SGetSBuf((_class).region,(_class).pool, \
- (U8 **)&tmpBuf,(_class).cBuf.cBufSize); \
+ (uint8_t **)&tmpBuf,(_class).cBuf.cBufSize); \
memset(tmpBuf,0,(_class).cBuf.cBufSize); \
for(cBufIdx = (_class).cBuf.cBufIdx; cBufIdx < (_class).cBuf.cBufSize; cBufIdx++) \
{ \
} \
SPrint(tmpBuf); \
SPutSBuf((_class).region,(_class).pool, \
- (U8 *)tmpBuf,(_class).cBuf.cBufSize); \
+ (uint8_t *)tmpBuf,(_class).cBuf.cBufSize); \
}
#else
/* system services typedefs */
-#define oduPackBool(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Bool */
+#define oduPackBool(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Bool */
#define cmPkStatus(x, mBuf) SPkS16(x, mBuf) /* pack Status */
#define cmPkTicks(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack Ticks */
#define cmPkQLen(x, mBuf) SPkS16(x, mBuf) /* pack QLen */
#define cmPkDgn(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack Dgn */
#define cmPkAction(x, mBuf) SPkS16(x, mBuf) /* pack Action */
#define cmPkSeqS16(x, mBuf) SPkS16(x, mBuf) /* pack SeqS16 */
-#define cmPkSeqU16(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack SeqU16 */
+#define cmPkSeqUInt16(x, mBuf) oduUnpackUInt16(x, mBuf) /* pack SeqUInt16 */
#define cmPkSeqS24(x, mBuf) SPkS32(x, mBuf) /* pack SeqS24 */
-#define cmPkSeqU24(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack SeqU24 */
+#define cmPkSeqUInt24(x, mBuf) oduUnpackUInt32(x, mBuf) /* pack SeqUInt24 */
#define cmPkSetUpArb(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack SetUpArb */
#define cmPkEvntType(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack EvntType */
#define cmPkState(x, mBuf) oduUnpackUInt8(x, mBuf) /* pack State */
/* system services typedefs */
-#define oduUnpackBool(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Bool */
+#define oduUnpackBool(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Bool */
#define cmUnpkStatus(x, mBuf) SUnpkS16(x, mBuf) /* unpack Status */
#define cmUnpkTicks(x, mBuf) oduPackUInt32(x, mBuf) /* unpack Ticks */
#define cmUnpkQLen(x, mBuf) SUnpkS16(x, mBuf) /* unpack QLen */
#define cmUnpkDgn(x, mBuf) oduPackUInt8(x, mBuf) /* unpack Dgn */
#define cmUnpkAction(x, mBuf) SUnpkS16(x, mBuf) /* unpack Action */
#define cmUnpkSeqS16(x, mBuf) SUnpkS16(x, mBuf) /* unpack SeqS16 */
-#define cmUnpkSeqU16(x, mBuf) oduPackUInt16(x, mBuf) /* unpack SeqU16 */
+#define cmUnpkSeqUInt16(x, mBuf) oduPackUInt16(x, mBuf) /* unpack SeqUInt16 */
#define cmUnpkSeqS24(x, mBuf) SUnpkS32(x, mBuf) /* unpack SeqS24 */
-#define cmUnpkSeqU24(x, mBuf) oduPackUInt32(x, mBuf) /* unpack SeqU24 */
+#define cmUnpkSeqUInt24(x, mBuf) oduPackUInt32(x, mBuf) /* unpack SeqUInt24 */
#define cmUnpkSetUpArb(x, mBuf) oduPackUInt8(x, mBuf) /* unpack SetUpArb */
#define cmUnpkEvntType(x, mBuf) oduPackUInt8(x, mBuf) /* unpack EvntType */
#define cmUnpkState(x, mBuf) oduPackUInt8(x, mBuf) /* unpack State */
#endif /* CMFILE_REORG_1 */
#define cmPkTranId(x, mBuf) oduUnpackUInt32(x, mBuf) /* Pack transaction Id */
-#define cmUnpkTranId(x, mBuf) oduPackUInt32(x, mBuf) /* unpack transaction Id */
+#define cmUnpkTranId(x, mBuf) oduPackUInt32(x, mBuf) /* unpack transaction Id */
#ifdef L2_L3_SPLIT
typedef struct _debugInfo
{
- U32 mBuf;
- U32 res[8];
- U32 count;
+ uint32_t mBuf;
+ uint32_t res[8];
+ uint32_t count;
} DebugInfo;
EXTERN DebugInfo debugInfo;
typedef S8 Txt; /* text */
-typedef U8 Ent; /* entity */
+typedef uint8_t Ent; /* entity */
-typedef U8 Inst; /* instance */
+typedef uint8_t Inst; /* instance */
typedef struct entityId /* entity id */
{
ElmntInst3 elmntInst3; /* element instance 3 */
} ElmntId;
-typedef U8 Region; /* region */
+typedef uint8_t Region; /* region */
-typedef U8 Pool; /* pool */
+typedef uint8_t Pool; /* pool */
-typedef U8 Prior; /* priority */
+typedef uint8_t Prior; /* priority */
typedef Prior Priority; /* priority */
-typedef U8 Route; /* route */
+typedef uint8_t Route; /* route */
-typedef U8 Data; /* data */
+typedef uint8_t Data; /* data */
-typedef U8 Selector; /* selector */
+typedef uint8_t Selector; /* selector */
typedef S16 Reason; /* reason */
-typedef U16 ProcId; /* processor id */
+typedef uint16_t ProcId; /* processor id */
-typedef U8 Event; /* event */
+typedef uint8_t Event; /* event */
-typedef U32 TranId; /* transaction Id */
+typedef uint32_t TranId; /* transaction Id */
typedef S16 IntNum; /* Interface Number */
-typedef U16 TranNum; /* Transaction Number */
+typedef uint16_t TranNum; /* Transaction Number */
-typedef U16 CmIntfId; /* Interface identifier */
-typedef U16 CmIntfVer; /* Interface version */
+typedef uint16_t CmIntfId; /* Interface identifier */
+typedef uint16_t CmIntfVer; /* Interface version */
#ifdef TDS_ROLL_UPGRADE_SUPPORT
typedef struct cmIntf /* Attributes of an interface */
/* post structure *** ALIGNED & ORDERED *** */
typedef struct pst /* parameters for SPstTsk */
{
- ProcId dstProcId; /* destination processor id (U16) */
- ProcId srcProcId; /* source processor id (U16) */
+ ProcId dstProcId; /* destination processor id (uint16_t) */
+ ProcId srcProcId; /* source processor id (uint16_t) */
- Ent dstEnt; /* destination entity (U8) */
- Inst dstInst; /* destination instance (U8) */
- Ent srcEnt; /* source entity (U8) */
- Inst srcInst; /* source instance (U8) */
+ Ent dstEnt; /* destination entity (uint8_t) */
+ Inst dstInst; /* destination instance (uint8_t) */
+ Ent srcEnt; /* source entity (uint8_t) */
+ Inst srcInst; /* source instance (uint8_t) */
- Prior prior; /* priority (U8) */
- Route route; /* route (U8) */
- Event event; /* event (U8) */
- Region region; /* region (U8) */
+ Prior prior; /* priority (uint8_t) */
+ Route route; /* route (uint8_t) */
+ Event event; /* event (uint8_t) */
+ Region region; /* region (uint8_t) */
- Pool pool; /* pool (U8) */
- Selector selector; /* selector (U8) */
- CmIntfVer intfVer; /* interface version (U16) */
+ Pool pool; /* pool (uint8_t) */
+ Selector selector; /* selector (uint8_t) */
+ CmIntfVer intfVer; /* interface version (uint16_t) */
} Pst;
/* systemId structure */
*/
typedef struct protAddr
{
- U16 protType; /* Protocol Type */
- U8 len; /* Protocol Address Length in bytes */
- U8 preLen; /* prefix length in bits */
- U8 address[MAX_PROTADDR_LEN]; /* Protocol Address */
+ uint16_t protType; /* Protocol Type */
+ uint8_t len; /* Protocol Address Length in bytes */
+ uint8_t preLen; /* prefix length in bits */
+ uint8_t address[MAX_PROTADDR_LEN]; /* Protocol Address */
#ifdef CM_ARI2
Bool autoSysIdPres; /* Is Autonomous System Id Present */
- U32 autoSysId; /* Autonomous System Id */
+ uint32_t autoSysId; /* Autonomous System Id */
#endif /* CM_ARI2 */
}ProtAddr;
typedef struct protAddrTbl
{
- U8 count; /* Number of addresses */
+ uint8_t count; /* Number of addresses */
ProtAddr addr[MAX_PROT_ADDRS]; /* Protocol Address List */
}ProtAddrTbl;
typedef struct addrs /* address */
{
- U8 length; /* length (bytes or nibbles) */
- U8 strg[ADRLEN]; /* address */
+ uint8_t length; /* length (bytes or nibbles) */
+ uint8_t strg[ADRLEN]; /* address */
} Addrs;
typedef struct shrtAddr /* short address */
{
- U8 length; /* length bytes */
- U8 strg[SHRTADRLEN]; /* address */
+ uint8_t length; /* length bytes */
+ uint8_t strg[SHRTADRLEN]; /* address */
} ShrtAddrs;
typedef struct lngAddr /* long address */
{
- U8 length; /* length bytes */
- U8 strg[LNGADRLEN]; /* address */
+ uint8_t length; /* length bytes */
+ uint8_t strg[LNGADRLEN]; /* address */
} LngAddrs;
/* bndCfg structure */
typedef struct bndCfg /* bind configuration */
{
Txt *usrId; /* user id */
- U8 bufOwnshp; /* buffer ownership */
- U8 flcTyp; /* flow control type */
- U8 wdw; /* window */
+ uint8_t bufOwnshp; /* buffer ownership */
+ uint8_t flcTyp; /* flow control type */
+ uint8_t wdw; /* window */
Ent ent; /* entity */
Inst inst; /* instance */
Region region; /* region */
/* Circular Buffer Structure */
#ifdef CBUF_ENABLE
typedef struct cb {
- U32 cBufIdx;
- U32 cBufSize;
- U8 *cBufPtr;
+ uint32_t cBufIdx;
+ uint32_t cBufSize;
+ uint8_t *cBufPtr;
S8 tmpBuf[CBUFPRNTSZE];
}cBuffer;
#endif /* CBUF_ENABLE */
Bool usta; /* unsolicited status */
Bool trc; /* trace */
#ifdef DEBUGP
- U32 dbgMask; /* debug mask */
+ uint32_t dbgMask; /* debug mask */
Txt prntBuf[255]; /* print buffer */
#endif
Txt *prntCirBuf; /* print buffer for each system task */
#ifdef SS_DIAG
/* gen_x_001.main_96 :Added logmask */
- U32 logMask; /* Logging mask */
+ uint32_t logMask; /* Logging mask */
#endif
BndCfg lmBnd; /* layer management bind */
ProcId procId; /* processor id */
\f
typedef S32 Cntr; /* counter */
-typedef U32 StsCntr; /* Statistics counter */
+typedef uint32_t StsCntr; /* Statistics counter */
typedef S16 LnkNmb; /* link number */
typedef S16 SpInstId; /* service provider instance id */
-typedef U16 PortId; /* port id */
+typedef uint16_t PortId; /* port id */
-typedef U8 Sapi; /* service access point id */
+typedef uint8_t Sapi; /* service access point id */
-typedef U8 Tei; /* terminal endpoint id */
+typedef uint8_t Tei; /* terminal endpoint id */
-typedef U8 Ces; /* connection endpoint suffix */
+typedef uint8_t Ces; /* connection endpoint suffix */
-typedef U32 Dlci; /* data link control identifier */
+typedef uint32_t Dlci; /* data link control identifier */
-typedef U16 CalRef; /* call Reference */
+typedef uint16_t CalRef; /* call Reference */
typedef S16 Origin; /* origin */
-typedef U16 NwId; /* Network Identifier */
+typedef uint16_t NwId; /* Network Identifier */
typedef S16 Swtch; /* switch */
-typedef U8 Cause; /* cause code */
+typedef uint8_t Cause; /* cause code */
-typedef U8 Dgn; /* diagnostic code */
+typedef uint8_t Dgn; /* diagnostic code */
typedef S16 Action; /* action */
typedef S16 SeqS16; /* signed 16 bit sequence number */
-typedef U16 SeqU16; /* unsigned 16 bit sequence number */
+typedef uint16_t SeqUInt16; /* unsigned 16 bit sequence number */
typedef S32 SeqS24; /* signed 24 bit sequence number */
-typedef U32 SeqU24; /* unsigned 24 bit sequence number */
+typedef uint32_t SeqUInt24; /* unsigned 24 bit sequence number */
-typedef U8 SetUpArb; /* set up arbitration (PASSIVE/ACTIVE) */
+typedef uint8_t SetUpArb; /* set up arbitration (PASSIVE/ACTIVE) */
-typedef U8 EvntType; /* event type */
+typedef uint8_t EvntType; /* event type */
-typedef U8 State; /* state */
+typedef uint8_t State; /* state */
-typedef U8 Mode; /* mode */
+typedef uint8_t Mode; /* mode */
typedef S32 ConnId; /* connection id */
-typedef U32 UConnId; /* unsigned connection id */
+typedef uint32_t UConnId; /* unsigned connection id */
-typedef U16 ProtId; /* protocol id */
+typedef uint16_t ProtId; /* protocol id */
-typedef U16 ChannelId; /* channel id */
+typedef uint16_t ChannelId; /* channel id */
-typedef U8 Arr64U8[64]; /* Array of 64 of type U8*/
+typedef uint8_t Arr64UInt8[64]; /* Array of 64 of type uint8_t*/
-typedef U16 Efa; /* Envelope Address Function */
+typedef uint16_t Efa; /* Envelope Address Function */
-typedef U32 BitState; /* Sa Bit ID and Value */
+typedef uint32_t BitState; /* Sa Bit ID and Value */
-typedef U8 CChanId; /* V5UA Channel ID */
+typedef uint8_t CChanId; /* V5UA Channel ID */
-typedef U16 MibOpCode; /* Op code for Mib Request MIB_REQUEST_GET,
+typedef uint16_t MibOpCode; /* Op code for Mib Request MIB_REQUEST_GET,
MIB_REQUEST_GET_FIRST, MIB_REQUEST */
-typedef U16 MibStatus; /* Status returned in Mib Cfm */
+typedef uint16_t MibStatus; /* Status returned in Mib Cfm */
-typedef U16 MibTblType; /* table type */
+typedef uint16_t MibTblType; /* table type */
typedef S32 MibReqId; /* request identifier */
-typedef U8 UstaType; /* unsolicited status type */
+typedef uint8_t UstaType; /* unsolicited status type */
typedef S8 ChannelNo; /* Channel Number */
/* ATM typedefs */
#ifndef CMFILE_REORG_1
-typedef U16 AtmVpci; /* ATM virtual path connection id */
-typedef U16 AtmVpi; /* ATM virtual path id */
+typedef uint16_t AtmVpci; /* ATM virtual path connection id */
+typedef uint16_t AtmVpi; /* ATM virtual path id */
-typedef U16 AtmVci; /* ATM virtual channel id */
+typedef uint16_t AtmVci; /* ATM virtual channel id */
-typedef U8 AtmLp; /* ATM loss priority */
+typedef uint8_t AtmLp; /* ATM loss priority */
-typedef U8 AtmCi; /* ATM congestion indication */
+typedef uint8_t AtmCi; /* ATM congestion indication */
-typedef U8 AtmRs; /* ATM reception status */
+typedef uint8_t AtmRs; /* ATM reception status */
-typedef U8 AtmUu; /* ATM user-to-user field in CPCS PDUs */
+typedef uint8_t AtmUu; /* ATM user-to-user field in CPCS PDUs */
-typedef U32 AtmUui; /* ATM user-to-user indication field in SSCOP PDUs */
+typedef uint32_t AtmUui; /* ATM user-to-user indication field in SSCOP PDUs */
-typedef U8 AtmPt; /* ATM cell payload type */
+typedef uint8_t AtmPt; /* ATM cell payload type */
typedef struct atmQos /* ATM quality of service */
{
- U8 qosFwd; /* qos in forward direction */
- U8 qosBwd; /* qos in backward direction */
+ uint8_t qosFwd; /* qos in forward direction */
+ uint8_t qosBwd; /* qos in backward direction */
} AtmQos;
/* Vitual channel structure */
/* VCC table */
typedef struct atmVccTbl /* VCC table */
{
- U16 count; /* number of VCCs */
+ uint16_t count; /* number of VCCs */
AtmVccId tbl[MAX_ATMVCCTBL_SZ]; /* VCC list */
} AtmVccTbl;
/* Generic ATM address */
typedef struct atmAddr
{
- U8 type; /* type of Address (AESA or E.164) */
- U8 len; /* length (bytes) */
- U8 strg[ADRLEN]; /* address string */
+ uint8_t type; /* type of Address (AESA or E.164) */
+ uint8_t len; /* length (bytes) */
+ uint8_t strg[ADRLEN]; /* address string */
} AtmAddr;
/* ATM address table */
typedef struct atmAddrTbl /* ATM address table */
{
- U16 count; /* number of ATM addresses */
+ uint16_t count; /* number of ATM addresses */
AtmAddr tbl[MAX_ATMADDRTBL_SZ]; /* ATM address list */
} AtmAddrTbl;
typedef struct atmTfcDesc /* ATM traffic descriptor */
{
- U32 fwdPeakCellRate0; /* forward peak cell rate, CLP = 0 */
- U32 bwdPeakCellRate0; /* backward peak cell rate, CLP = 0 */
- U32 fwdPeakCellRate1; /* forward peak cell rate, CLP = 0+1 */
- U32 bwdPeakCellRate1; /* backward peak cell rate, CLP = 0+1 */
- U32 fwdSustCellRate0; /* forward sust. cell rate, CLP = 0 */
- U32 bwdSustCellRate0; /* backward sust. cell rate, CLP = 0 */
- U32 fwdSustCellRate1; /* forward sust. cell rate, CLP = 0+1 */
- U32 bwdSustCellRate1; /* backward sust. cell rate, CLP = 0+1 */
- U32 fwdMeanBurstSize0; /* forward mean burst size, CLP = 0 */
- U32 bwdMeanBurstSize0; /* backward mean burst size, CLP = 0 */
- U32 fwdMeanBurstSize1; /* forward mean burst size, CLP = 0+1 */
- U32 bwdMeanBurstSize1; /* backward mean burst size, CLP = 0+1 */
+ uint32_t fwdPeakCellRate0; /* forward peak cell rate, CLP = 0 */
+ uint32_t bwdPeakCellRate0; /* backward peak cell rate, CLP = 0 */
+ uint32_t fwdPeakCellRate1; /* forward peak cell rate, CLP = 0+1 */
+ uint32_t bwdPeakCellRate1; /* backward peak cell rate, CLP = 0+1 */
+ uint32_t fwdSustCellRate0; /* forward sust. cell rate, CLP = 0 */
+ uint32_t bwdSustCellRate0; /* backward sust. cell rate, CLP = 0 */
+ uint32_t fwdSustCellRate1; /* forward sust. cell rate, CLP = 0+1 */
+ uint32_t bwdSustCellRate1; /* backward sust. cell rate, CLP = 0+1 */
+ uint32_t fwdMeanBurstSize0; /* forward mean burst size, CLP = 0 */
+ uint32_t bwdMeanBurstSize0; /* backward mean burst size, CLP = 0 */
+ uint32_t fwdMeanBurstSize1; /* forward mean burst size, CLP = 0+1 */
+ uint32_t bwdMeanBurstSize1; /* backward mean burst size, CLP = 0+1 */
Bool bstEffortReq; /* best effort requested */
Bool fwdTagReq; /* tagging requested in forward direction */
Bool bwdTagReq; /* tagging requested in backward direction */
/* tcp/ip typedefs */
-typedef U32 IpAddr; /* IP address */
+typedef uint32_t IpAddr; /* IP address */
-typedef U16 Port; /* TCP/UDP port */
+typedef uint16_t Port; /* TCP/UDP port */
-typedef U8 Cmd; /* command */
+typedef uint8_t Cmd; /* command */
-typedef U8 Flags; /* TCP/UDP flags */
+typedef uint8_t Flags; /* TCP/UDP flags */
-typedef U8 Ttl; /* time to live */
+typedef uint8_t Ttl; /* time to live */
-typedef U8 Prec; /* TCP/UDP precedence */
+typedef uint8_t Prec; /* TCP/UDP precedence */
-typedef U32 Window; /* TCP/UDP window */
+typedef uint32_t Window; /* TCP/UDP window */
-typedef U8 MtpStatus; /* MTP status */
+typedef uint8_t MtpStatus; /* MTP status */
-typedef U8 Credit; /* credit */
+typedef uint8_t Credit; /* credit */
/* ISUP typedefs */
-typedef U32 CirId; /* circuit Id */
+typedef uint32_t CirId; /* circuit Id */
-typedef U16 Cic; /* cic */
+typedef uint16_t Cic; /* cic */
-typedef U32 SiInstId; /* instance id */
+typedef uint32_t SiInstId; /* instance id */
/* B-ISUP typedefs */
-typedef U32 BiInstId; /* instance id */
+typedef uint32_t BiInstId; /* instance id */
/* TUP typedefs */
-typedef U32 TpInstId; /* instance id */
+typedef uint32_t TpInstId; /* instance id */
/* LLC/SNAP definitions */
-typedef U32 Oui; /* 3-octet OUI in SNAP header */
-typedef U16 Pid; /* 2-octet protocol id in SNAP header */
-typedef U32 LlcId; /* LLC id */
+typedef uint32_t Oui; /* 3-octet OUI in SNAP header */
+typedef uint16_t Pid; /* 2-octet protocol id in SNAP header */
+typedef uint32_t LlcId; /* LLC id */
#ifndef CMFILE_REORG_1
/* q.93b typedefs */
typedef S32 AmInstId; /* service user/provider instance id */
-typedef U16 AmEndptRefType; /* endpoint reference */
-typedef U32 AmSeqNmb; /* sequence number */
+typedef uint16_t AmEndptRefType; /* endpoint reference */
+typedef uint32_t AmSeqNmb; /* sequence number */
/* q.saal typedefs */
-typedef U16 AsErrorCode; /* q.saal error code (Q.SAAL1 Appendix 1) */
+typedef uint16_t AsErrorCode; /* q.saal error code (Q.SAAL1 Appendix 1) */
/* ume typedefs */
-typedef U32 UmInteger; /* ume integer */
+typedef uint32_t UmInteger; /* ume integer */
typedef struct umObjId /* ume object identifier */
{
/* general typedefs */
-typedef U16 LecId; /* LEC Id */
-typedef U8 Protocol; /* protocol */
-typedef U8 Version; /* version */
-typedef U16 OpCode; /* op code in control frames */
-typedef U16 LaneStatus; /* status in control frames */
-typedef U32 TransId; /* transaction id */
-typedef U16 LaneFlags; /* flags in control frames */
-typedef U8 LanType; /* LAN type */
-typedef U8 MtuIdx; /* max frame size - index */
-typedef U16 MtuVal; /* max frame size - value */
-typedef U16 Tag; /* tag indicating LAN destination type */
-typedef U8 VccNature; /* VCC nature - SVC, PVC, etc. */
-typedef U8 VccType; /* VCC type - control, data, etc */
-typedef U8 ProfileId; /* HCC profile id */
+typedef uint16_t LecId; /* LEC Id */
+typedef uint8_t Protocol; /* protocol */
+typedef uint8_t Version; /* version */
+typedef uint16_t OpCode; /* op code in control frames */
+typedef uint16_t LaneStatus; /* status in control frames */
+typedef uint32_t TransId; /* transaction id */
+typedef uint16_t LaneFlags; /* flags in control frames */
+typedef uint8_t LanType; /* LAN type */
+typedef uint8_t MtuIdx; /* max frame size - index */
+typedef uint16_t MtuVal; /* max frame size - value */
+typedef uint16_t Tag; /* tag indicating LAN destination type */
+typedef uint8_t VccNature; /* VCC nature - SVC, PVC, etc. */
+typedef uint8_t VccType; /* VCC type - control, data, etc */
+typedef uint8_t ProfileId; /* HCC profile id */
typedef struct lanName /* LAN name */
{
- U8 length; /* length of string */
- U8 strg[MAX_LANNAME]; /* name string */
+ uint8_t length; /* length of string */
+ uint8_t strg[MAX_LANNAME]; /* name string */
} LanName;
/* LAN destination typedefs */
typedef struct macAddr /* MAC address */
{
- U8 strg[MACADDRLEN]; /* address string */
+ uint8_t strg[MACADDRLEN]; /* address string */
} MacAddr;
typedef struct macAddrTblEntry /* entry in table of MAC addresses */
{
- U8 proxyClass; /* proxy class - local, learned */
+ uint8_t proxyClass; /* proxy class - local, learned */
MacAddr macAddr; /* MAC address */
} MacAddrTblEntry;
typedef struct macAddrTbl /* table of MAC addresses */
{
- U8 count; /* number of entries */
+ uint8_t count; /* number of entries */
MacAddrTblEntry tbl[MAX_MACADDRTBL]; /* table of MAC addresses */
} MacAddrTbl;
typedef struct rd /* route designator */
{
- U16 lanId; /* LAN id, segment id - 12 bits */
- U8 bridgeId; /* bridge id - 4 bits */
+ uint16_t lanId; /* LAN id, segment id - 12 bits */
+ uint8_t bridgeId; /* bridge id - 4 bits */
} Rd;
typedef struct rdTblEntry /* entry in table of route designators */
typedef struct rdTbl /* table of route designators */
{
- U8 count; /* number of entries */
+ uint8_t count; /* number of entries */
RdTblEntry tbl[MAX_RDTBL];/* table of route designator */
} RdTbl;
Addrs dstAtmAddr; /* target ATM address */
LanType lanType; /* LAN type */
MtuIdx mtuIdx; /* MTU */
- U8 nmbTLV; /* number of TLV entries in list */
+ uint8_t nmbTLV; /* number of TLV entries in list */
LanName lanName; /* LAN name */
} LaneCtrlHdr;
typedef struct laneTLVEnt /* type-length-value entry */
{
- U32 type; /* type of value */
- U8 length; /* length of value */
- U8 value[MAX_TLV_LEN]; /* value */
+ uint32_t type; /* type of value */
+ uint8_t length; /* length of value */
+ uint8_t value[MAX_TLV_LEN]; /* value */
} LaneTLVEnt;
typedef struct laneCfg /* configuration frame */
/* PNNI typedefs */
/* pnni port id */
-typedef U32 PnPortId;
+typedef uint32_t PnPortId;
/* pnni node Id */
typedef struct pnNodeId
{
- U8 id[PN_NODEID_LEN];
+ uint8_t id[PN_NODEID_LEN];
} PnNodeId;
#endif /* CMFILE_REORG_1 */
typedef struct octStrg /* octet string */
{
S32 length; /* length */
- U8 val[MF_SIZE_TKNSTR]; /* value */
+ uint8_t val[MF_SIZE_TKNSTR]; /* value */
} OctStrg;
typedef struct tknHdr /* token header */
{
- U8 pres; /* present */
- U8 spare1; /* for 16 bit alignment */
- U16 spare2; /* for 32 bit alignment */
+ uint8_t pres; /* present */
+ uint8_t spare1; /* for 16 bit alignment */
+ uint16_t spare2; /* for 32 bit alignment */
#ifdef ALIGN_64BIT
- U32 spare3; /* for 64 bit alignment */
+ uint32_t spare3; /* for 64 bit alignment */
#endif
} TknHdr;
typedef struct elmtHdr /* element header */
{
- U8 pres; /* present */
- U8 actnInd; /* action indicator */
- U16 compInd; /* for alignment */
+ uint8_t pres; /* present */
+ uint8_t actnInd; /* action indicator */
+ uint16_t compInd; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare; /* for 64 bit alignment */
+ uint32_t spare; /* for 64 bit alignment */
#endif
} ElmtHdr;
/* token typedefs */
-typedef struct tknU8 /* token U8 */
+typedef struct tknUInt8 /* token uint8_t */
{
- U8 pres; /* present flag */
- U8 val; /* value */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t val; /* value */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
-} TknU8;
+} TknUInt8;
typedef struct tknS8 /* token S8 */
{
- U8 pres; /* present flag */
+ uint8_t pres; /* present flag */
S8 val; /* value */
- U16 spare1; /* for alignment */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
} TknS8;
-typedef struct tknU16 /* token U16 */
+typedef struct tknUInt16 /* token uint16_t */
{
- U8 pres; /* present flag */
- U8 spare1; /* for alignment */
- U16 val; /* value */
+ uint8_t pres; /* present flag */
+ uint8_t spare1; /* for alignment */
+ uint16_t val; /* value */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
-} TknU16;
+} TknUInt16;
-typedef struct tknU32 /* token U32 */
+typedef struct tknUInt32 /* token uint32_t */
{
- U8 pres; /* present flag */
- U8 spare1; /* for alignment */
- U16 spare2; /* for alignment */
- U32 val; /* value */
-} TknU32;
+ uint8_t pres; /* present flag */
+ uint8_t spare1; /* for alignment */
+ uint16_t spare2; /* for alignment */
+ uint32_t val; /* value */
+} TknUInt32;
typedef struct tknS32 /* token S32 */
{
- U8 pres; /* present flag */
- U8 spare1; /* for alignment */
- U16 spare2; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t spare1; /* for alignment */
+ uint16_t spare2; /* for alignment */
S32 val; /* value */
} TknS32;
typedef struct tknStrS /* token string */
{
- U8 pres; /* present flag */
- U8 len; /* length */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* length */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
- U8 val[(MF_SIZE_TKNSTRS + 7) & 0xff8]; /* string value */
+ uint32_t spare2; /* for 64 bit alignment */
+ uint8_t val[(MF_SIZE_TKNSTRS + 7) & 0xff8]; /* string value */
#else
- U8 val[(MF_SIZE_TKNSTRS + 3) & 0xffc]; /* string value */
+ uint8_t val[(MF_SIZE_TKNSTRS + 3) & 0xffc]; /* string value */
#endif
} TknStrS;
typedef struct tknStrM /* token string */
{
- U8 pres; /* present flag */
- U8 len; /* length */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* length */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
- U8 val[(MF_SIZE_TKNSTRM + 7) & 0xff8]; /* string value */
+ uint32_t spare2; /* for 64 bit alignment */
+ uint8_t val[(MF_SIZE_TKNSTRM + 7) & 0xff8]; /* string value */
#else
- U8 val[(MF_SIZE_TKNSTRM + 3) & 0xffc]; /* string value */
+ uint8_t val[(MF_SIZE_TKNSTRM + 3) & 0xffc]; /* string value */
#endif
} TknStrM;
typedef struct tknStr /* token string */
{
- U8 pres; /* present flag */
- U8 len; /* length */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* length */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
- U8 val[(MF_SIZE_TKNSTR + 7) & 0xff8]; /* string value */
+ uint32_t spare2; /* for 64 bit alignment */
+ uint8_t val[(MF_SIZE_TKNSTR + 7) & 0xff8]; /* string value */
#else
- U8 val[(MF_SIZE_TKNSTR + 3) & 0xffc]; /* string value */
+ uint8_t val[(MF_SIZE_TKNSTR + 3) & 0xffc]; /* string value */
#endif
} TknStr;
typedef struct tknStrE /* token string extended */
{
- U8 pres; /* present flag */
- U8 len; /* length */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* length */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
- U8 val[(MF_SIZE_TKNSTRE + 7) & 0xff8]; /* string value */
+ uint32_t spare2; /* for 64 bit alignment */
+ uint8_t val[(MF_SIZE_TKNSTRE + 7) & 0xff8]; /* string value */
#else
- U8 val[(MF_SIZE_TKNSTRE + 3) & 0xffc]; /* string value */
+ uint8_t val[(MF_SIZE_TKNSTRE + 3) & 0xffc]; /* string value */
#endif
} TknStrE;
typedef struct tknStrXL /* token string extra long */
{
- U16 len; /* length */
- U8 pres; /* present flag */
- U8 spare1; /* for alignment */
+ uint16_t len; /* length */
+ uint8_t pres; /* present flag */
+ uint8_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
- U8 *val; /* string value (use allocated memory) */
+ uint8_t *val; /* string value (use allocated memory) */
} TknStrXL;
typedef struct tknStr4 /* token string */
{
- U8 pres; /* present flag */
- U8 len; /* length */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* length */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
- U8 val[8]; /* string value - 8 byte alligned */
+ uint32_t spare2; /* for 64 bit alignment */
+ uint8_t val[8]; /* string value - 8 byte alligned */
#else
- U8 val[4]; /* string value - 4 byte alligned */
+ uint8_t val[4]; /* string value - 4 byte alligned */
#endif /* ALIGN_64BIT */
} TknStr4;
typedef struct tknStr12 /* token string */
{
- U8 pres; /* present flag */
- U8 len; /* length */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* length */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
- U8 val[16]; /* string value - 8 byte alligned */
+ uint32_t spare2; /* for 64 bit alignment */
+ uint8_t val[16]; /* string value - 8 byte alligned */
#else
- U8 val[12]; /* string value - 4 byte alligned */
+ uint8_t val[12]; /* string value - 4 byte alligned */
#endif /* ALIGN_64BIT */
} TknStr12;
typedef struct tknStr32 /* token string */
{
- U8 pres; /* present flag */
- U8 len; /* length */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* length */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
- U8 val[32]; /* string value - 4 byte alligned */
+ uint8_t val[32]; /* string value - 4 byte alligned */
} TknStr32;
typedef struct tknStr64 /* token string */
{
- U8 pres; /* present flag */
- U8 len; /* length */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* length */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
- U8 val[64]; /* string value - 4 byte alligned */
+ uint8_t val[64]; /* string value - 4 byte alligned */
} TknStr64;
typedef struct tknStr132 /* token string */
{
- U8 pres; /* present flag */
- U8 len; /* length */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* length */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
- U8 val[136]; /* string value - 8 byte alligned */
+ uint32_t spare2; /* for 64 bit alignment */
+ uint8_t val[136]; /* string value - 8 byte alligned */
#else
- U8 val[132]; /* string value - 4 byte alligned */
+ uint8_t val[132]; /* string value - 4 byte alligned */
#endif /* ALIGN_64BIT */
} TknStr132;
typedef struct tknStr256 /* token string */
{
- U8 pres; /* present flag */
- U8 len; /* length */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* length */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
- U8 val[256]; /* string value - 4 byte alligned */
+ uint8_t val[256]; /* string value - 4 byte alligned */
} TknStr256;
typedef struct tknOid /* Object Identifier */
{
- U8 pres; /* present flag */
- U8 len; /* length */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* length */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
+ uint32_t spare2; /* for 64 bit alignment */
#endif
- /* gen_x_001.main_81 : changed val from U32 to U16 with comilation flag
- * TKNOID_U16 */
-#ifndef TKNOID_U16
- U32 val[32]; /* max 32 integers of less than 64k value */
+ /* gen_x_001.main_81 : changed val from uint32_t to uint16_t with comilation flag
+ * TKNOID_UINT16 */
+#ifndef TKNOID_UINT16
+ uint32_t val[32]; /* max 32 integers of less than 64k value */
#else
- U16 val[32]; /* max 32 integers of less than 64k value */
+ uint16_t val[32]; /* max 32 integers of less than 64k value */
#endif
} TknOid;
typedef struct tknBits /* token bits */
{
- U8 pres; /* present flag */
- U8 len; /* for alignment */
- U16 spare1; /* for alignment */
+ uint8_t pres; /* present flag */
+ uint8_t len; /* for alignment */
+ uint16_t spare1; /* for alignment */
#ifdef ALIGN_64BIT
- U32 spare2; /* for 64 bit alignment */
- U8 val[(MF_SIZE_TKNBITS + 7) & 0xff8]; /* string value */
+ uint32_t spare2; /* for 64 bit alignment */
+ uint8_t val[(MF_SIZE_TKNBITS + 7) & 0xff8]; /* string value */
#else
- U8 val[(MF_SIZE_TKNBITS + 3) & 0xffc]; /* string value */
+ uint8_t val[(MF_SIZE_TKNBITS + 3) & 0xffc]; /* string value */
#endif
} TknBits;
typedef struct cdPtyNmb /* called party number tokens */
{
ElmtHdr eh; /* element header */
- TknU8 nmbPlanId; /* numbering plan identification */
- TknU8 typeNmb0; /* type of number */
+ TknUInt8 nmbPlanId; /* numbering plan identification */
+ TknUInt8 typeNmb0; /* type of number */
#ifdef CDPTYNMB_32DIGIT
TknStrM nmbDigits; /* number digits */
#else
typedef struct redirNmb /* redirecting number tokens */
{
ElmtHdr eh; /* element header */
- TknU8 nmbPlanId; /* numbering plan identification */
- TknU8 typeNmb; /* type of number */
- TknU8 screenInd; /* screening indicator */
- TknU8 presInd; /* presentation indicator */
- TknU8 rsnRedirect; /* reason for redirection */
+ TknUInt8 nmbPlanId; /* numbering plan identification */
+ TknUInt8 typeNmb; /* type of number */
+ TknUInt8 screenInd; /* screening indicator */
+ TknUInt8 presInd; /* presentation indicator */
+ TknUInt8 rsnRedirect; /* reason for redirection */
TknStrS nmbDigits; /* number digits */
} RedirNmb;
typedef struct srvClass /* service class */
{
- U8 type; /* type */
+ uint8_t type; /* type */
union
{
struct /* frame relay */
typedef struct _ip /* ip header */
{
- U8 ip_hl; /* header length */
+ uint8_t ip_hl; /* header length */
Prec ip_tos; /* type of service */
- U16 ip_len; /* total length */
- U16 ip_id; /* identification */
- U16 ip_off; /* fragment offset field */
+ uint16_t ip_len; /* total length */
+ uint16_t ip_id; /* identification */
+ uint16_t ip_off; /* fragment offset field */
Ttl ip_ttl; /* time to live */
- U8 ip_p; /* protocol */
- U16 ip_sum; /* checksum */
+ uint8_t ip_p; /* protocol */
+ uint16_t ip_sum; /* checksum */
IpAddr ip_src; /* source address */
IpAddr ip_dst; /* dest address */
} Ip;
typedef struct amCdPtySad /* Called Party Sub Address Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 oddEvenInd; /* odd/even indicator */
- TknU8 typeSad; /* type of sub address */
+ TknUInt8 oddEvenInd; /* odd/even indicator */
+ TknUInt8 typeSad; /* type of sub address */
TknStrS sadInfo; /* address/number information */
} AmCdPtySad;
typedef struct amBHiLyrInfo /* Broadband High Layer Information Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 hiLyrInfoType; /* high layer information type */
+ TknUInt8 hiLyrInfoType; /* high layer information type */
TknStrS hiLyrInfo; /* high layer information */
} AmBHiLyrInfo;
typedef struct amBBearCap /* Broadband Bearer Capability Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 bearClass; /* bearer class */
- TknU8 timingReq; /* timing requirement */
- TknU8 tfcType; /* traffic type */
- TknU8 atmTfrCap; /* ATM transfer capability */
- TknU8 usrPlaneConCfg; /* user plane connection configuration */
- TknU8 suscClip; /* susceptability to clipping */
+ TknUInt8 bearClass; /* bearer class */
+ TknUInt8 timingReq; /* timing requirement */
+ TknUInt8 tfcType; /* traffic type */
+ TknUInt8 atmTfrCap; /* ATM transfer capability */
+ TknUInt8 usrPlaneConCfg; /* user plane connection configuration */
+ TknUInt8 suscClip; /* susceptability to clipping */
} AmBBearCap;
typedef struct amQosParam /* Quality of Service Parameter Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 qosClassFwd; /* quality of service class forward */
- TknU8 qosClassBwd; /* quality of service class backward */
+ TknUInt8 qosClassFwd; /* quality of service class forward */
+ TknUInt8 qosClassBwd; /* quality of service class backward */
} AmQosParam;
typedef struct amEtoeDly /* End To End Transit Delay Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 cumTransDlyId; /* cumulative transit delay id */
- TknU16 cumTransDly; /* cumulative transit delay value */
- TknU8 reqTransDlyId; /* requested max end to end transit delay id */
- TknU16 reqTransDly; /* maximum end to end transit delay value */
- TknU8 pnniAccFMCTDId; /* PNNI acceptable forward max. CTD ID */
- TknU32 pnniAccFMCTD; /* PNNI acceptable forward max. CTD */
- TknU8 pnniCumFMCTDId; /* PNNI acceptable forward max. CTD ID */
- TknU32 pnniCumFMCTD; /* PNNI acceptable forward max. CTD */
- TknU8 netGenInd; /* network generated indicator */
+ TknUInt8 cumTransDlyId; /* cumulative transit delay id */
+ TknUInt16 cumTransDly; /* cumulative transit delay value */
+ TknUInt8 reqTransDlyId; /* requested max end to end transit delay id */
+ TknUInt16 reqTransDly; /* maximum end to end transit delay value */
+ TknUInt8 pnniAccFMCTDId; /* PNNI acceptable forward max. CTD ID */
+ TknUInt32 pnniAccFMCTD; /* PNNI acceptable forward max. CTD */
+ TknUInt8 pnniCumFMCTDId; /* PNNI acceptable forward max. CTD ID */
+ TknUInt32 pnniCumFMCTD; /* PNNI acceptable forward max. CTD */
+ TknUInt8 netGenInd; /* network generated indicator */
} AmEtoeDly;
typedef struct amOamTfcDesc /* OAM Traffic Descriptor Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 usrNetFaultMgmt; /* user network fault management indicator */
- TknU8 compInd; /* compliance indicator */
- TknU8 shapingInd; /* shaping indicator */
- TknU8 bwdEtoeOamF5FlInd; /* backward e-to-e OAM F5 flow indicator */
- TknU8 fwdEtoeOamF5FlInd; /* forward e-to-e OAM F5 flow indicator */
+ TknUInt8 usrNetFaultMgmt; /* user network fault management indicator */
+ TknUInt8 compInd; /* compliance indicator */
+ TknUInt8 shapingInd; /* shaping indicator */
+ TknUInt8 bwdEtoeOamF5FlInd; /* backward e-to-e OAM F5 flow indicator */
+ TknUInt8 fwdEtoeOamF5FlInd; /* forward e-to-e OAM F5 flow indicator */
} AmOamTfcDesc;
typedef struct amEndptRef /* Endpoint Reference Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 endptRefType; /* endpoint reference type */
- TknU16 endptRefVal; /* endpoint reference value */
+ TknUInt8 endptRefType; /* endpoint reference type */
+ TknUInt16 endptRefVal; /* endpoint reference value */
} AmEndptRef;
typedef struct amAalParam /* AAL Parameters Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 aalType; /* AAL type */
+ TknUInt8 aalType; /* AAL type */
/* Token definition for AAL-1 */
- TknU8 subTypeId; /* Subtype Identifier */
- TknU8 subType; /* Subtype */
- TknU8 cbrRateId; /* CBR Rate Identifier */
- TknU8 cbrRate; /* CBR Rate */
- TknU8 multId; /* Multiplier Identifier */
- TknU16 multVal; /* Multiplier value */
- TknU8 srcClkFreqMetId; /* Source clock Frequency method identifier */
- TknU8 srcClkFreqMet; /* Source Clock frequency method */
- TknU8 errCrMetId; /* Error correction method identifier */
- TknU8 errCrMet; /* Error correction method */
- TknU8 strDatTxBlkszId; /* Structured data transfer blocksize Id. */
- TknU8 strDatTxBlksz0; /* Structured data transfer blocksize - oct 1*/
+ TknUInt8 subTypeId; /* Subtype Identifier */
+ TknUInt8 subType; /* Subtype */
+ TknUInt8 cbrRateId; /* CBR Rate Identifier */
+ TknUInt8 cbrRate; /* CBR Rate */
+ TknUInt8 multId; /* Multiplier Identifier */
+ TknUInt16 multVal; /* Multiplier value */
+ TknUInt8 srcClkFreqMetId; /* Source clock Frequency method identifier */
+ TknUInt8 srcClkFreqMet; /* Source Clock frequency method */
+ TknUInt8 errCrMetId; /* Error correction method identifier */
+ TknUInt8 errCrMet; /* Error correction method */
+ TknUInt8 strDatTxBlkszId; /* Structured data transfer blocksize Id. */
+ TknUInt8 strDatTxBlksz0; /* Structured data transfer blocksize - oct 1*/
/* Token definition for AAL-1, except in UNI 3.0 */
- TknU8 strDatTxBlksz1; /* Structured data transfer blocksize - oct 2*/
+ TknUInt8 strDatTxBlksz1; /* Structured data transfer blocksize - oct 2*/
/* Token definition for AAL-1 */
- TknU8 prtFillCellId; /* Partially filled cells Identifier */
- TknU8 prtFillCellMet; /* Partially filled cells method */
+ TknUInt8 prtFillCellId; /* Partially filled cells Identifier */
+ TknUInt8 prtFillCellMet; /* Partially filled cells method */
/* Token definition for AAL-3/4 and AAL-5 */
- TknU8 fwdMaxCpcsSduSzId; /* Forward maximum CPCS-SDU size identifier */
- TknU16 fwdMaxCpcsSduSz; /* Forward maximum CPCS-SDU size */
- TknU8 bwdMaxCpcsSduSzId; /* Forward maximum CPCS-SDU size identifier */
- TknU16 bwdMaxCpcsSduSz; /* Forward maximum CPCS-SDU size */
+ TknUInt8 fwdMaxCpcsSduSzId; /* Forward maximum CPCS-SDU size identifier */
+ TknUInt16 fwdMaxCpcsSduSz; /* Forward maximum CPCS-SDU size */
+ TknUInt8 bwdMaxCpcsSduSzId; /* Forward maximum CPCS-SDU size identifier */
+ TknUInt16 bwdMaxCpcsSduSz; /* Forward maximum CPCS-SDU size */
/* Token definition for AAL-3/4 only */
- TknU8 midRangeId; /* MID Range identifier */
- TknU16 loMidRange; /* MID Range value */
+ TknUInt8 midRangeId; /* MID Range identifier */
+ TknUInt16 loMidRange; /* MID Range value */
/* Token definition for AAL-3/4 only, except in UNI 3.0 */
- TknU16 hiMidRange; /* MID Range value */
+ TknUInt16 hiMidRange; /* MID Range value */
/* Token definition for AAL-3/4 and AAL-5 and only for UNI 3.0 */
- TknU8 modeId; /* Mode identifier */
- TknU8 mode; /* Mode - Streaming/Message */
+ TknUInt8 modeId; /* Mode identifier */
+ TknUInt8 mode; /* Mode - Streaming/Message */
/* Token definition for AAL-3/4 and AAL-5 */
- TknU8 sscsTypeId; /* SSCS Type Identifier */
- TknU8 sscsType; /* SSCS Type */
+ TknUInt8 sscsTypeId; /* SSCS Type Identifier */
+ TknUInt8 sscsType; /* SSCS Type */
/* Token definition for User defined AAL */
- TknU32 usrDefAalInfo; /* User defined AAL information */
+ TknUInt32 usrDefAalInfo; /* User defined AAL information */
} AmAalParam;
typedef struct amBLoLyrInfo /* Broadband Low Layer Information Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 usrInfoLyr1Prot; /* user information layer 1 protocol */
- TknU8 lyr1Id; /* Layer 1 id */
- TknU8 usrInfoLyr2Prot; /* user information layer 2 protocol */
- TknU8 lyr2Id; /* Layer 2 id */
- TknU8 q933Use; /* Q.933 use */
- TknU8 lyr2OprMode; /* Mode of operation */
- TknU8 winSize; /* Window size */
- TknU8 usrSpecLyr2ProtInfo; /* User specified layer 2 protocol info */
- TknU8 usrInfoLyr3Prot; /* user information layer 3 protocol */
- TknU8 lyr3Id; /* Layer 3 id */
- TknU8 lyr3OprMode; /* Mode of operation */
- TknU8 defPktSize; /* Default packet size */
- TknU8 pktWinSize; /* Default packet size */
- TknU8 usrSpecLyr3ProtInfo; /* User specified layer 3 protocol info */
- TknU8 initProtId; /* Initial protocol Identifier bits 8-2 */
- TknU8 snapId; /* SNAP identifier */
- TknU32 oui; /* Organisation unique identifier */
- TknU16 protId; /* Protocol identifier */
+ TknUInt8 usrInfoLyr1Prot; /* user information layer 1 protocol */
+ TknUInt8 lyr1Id; /* Layer 1 id */
+ TknUInt8 usrInfoLyr2Prot; /* user information layer 2 protocol */
+ TknUInt8 lyr2Id; /* Layer 2 id */
+ TknUInt8 q933Use; /* Q.933 use */
+ TknUInt8 lyr2OprMode; /* Mode of operation */
+ TknUInt8 winSize; /* Window size */
+ TknUInt8 usrSpecLyr2ProtInfo; /* User specified layer 2 protocol info */
+ TknUInt8 usrInfoLyr3Prot; /* user information layer 3 protocol */
+ TknUInt8 lyr3Id; /* Layer 3 id */
+ TknUInt8 lyr3OprMode; /* Mode of operation */
+ TknUInt8 defPktSize; /* Default packet size */
+ TknUInt8 pktWinSize; /* Default packet size */
+ TknUInt8 usrSpecLyr3ProtInfo; /* User specified layer 3 protocol info */
+ TknUInt8 initProtId; /* Initial protocol Identifier bits 8-2 */
+ TknUInt8 snapId; /* SNAP identifier */
+ TknUInt32 oui; /* Organisation unique identifier */
+ TknUInt16 protId; /* Protocol identifier */
} AmBLoLyrInfo;
typedef struct amAtmTfcDesc /* ATM Traffic Descriptor Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 fwdPeakCellRateId0; /* forward peak cell rate id, CLP = 0 */
- TknU32 fwdPeakCellRate0; /* forward peak cell rate, CLP = 0 */
- TknU8 bwdPeakCellRateId0; /* backward peak cell rate id, CLP = 0 */
- TknU32 bwdPeakCellRate0; /* backward peak cell rate, CLP = 0 */
- TknU8 fwdPeakCellRateId1; /* forward peak cell rate id, CLP = 0+1 */
- TknU32 fwdPeakCellRate1; /* forward peak cell rate, CLP = 0+1 */
- TknU8 bwdPeakCellRateId1; /* backward peak cell rate id, CLP = 0+1 */
- TknU32 bwdPeakCellRate1; /* backward peak cell rate, CLP = 0+1 */
- TknU8 fwdSustCellRateId0; /* forward sust. cell rate id, CLP = 0 */
- TknU32 fwdSustCellRate0; /* forward sust. cell rate, CLP = 0 */
- TknU8 bwdSustCellRateId0; /* backward sust. cell rate id, CLP = 0 */
- TknU32 bwdSustCellRate0; /* backward sust. cell rate, CLP = 0 */
- TknU8 fwdSustCellRateId1; /* forward sust. cell rate id, CLP = 0+1 */
- TknU32 fwdSustCellRate1; /* forward sust. cell rate, CLP = 0+1 */
- TknU8 bwdSustCellRateId1; /* backward sust. cell rate id, CLP = 0+1 */
- TknU32 bwdSustCellRate1; /* backward sust. cell rate, CLP = 0+1 */
- TknU8 fwdMeanBurstSizeId0; /* forward mean burst size id, CLP = 0 */
- TknU32 fwdMeanBurstSize0; /* forward mean burst size, CLP = 0 */
- TknU8 bwdMeanBurstSizeId0; /* backward mean burst size id, CLP = 0 */
- TknU32 bwdMeanBurstSize0; /* backward mean burst size, CLP = 0 */
- TknU8 fwdMeanBurstSizeId1; /* forward mean burst size id, CLP = 0+1 */
- TknU32 fwdMeanBurstSize1; /* forward mean burst size, CLP = 0+1 */
- TknU8 bwdMeanBurstSizeId1; /* backward mean burst size id, CLP = 0+1 */
- TknU32 bwdMeanBurstSize1; /* backward mean burst size, CLP = 0+1 */
- TknU8 bstEffortReq; /* best effort requested */
- TknU8 tfcMgmtOptId; /* traffic management options identifier */
- TknU8 fwdTagReq; /* tagging requested in forward direction */
- TknU8 bwdTagReq; /* tagging requested in backward direction */
- TknU8 bwdFrmDisc; /* frame discard in backward direction */
- TknU8 fwdFrmDisc; /* frame discard in forward direction */
- TknU8 fwdAbrMinCellRateId; /* forward ABR min. cell rate id, CLP = 0+1 */
- TknU32 fwdAbrMinCellRate; /* forward ABR min. cell rate, CLP = 0+1 */
- TknU8 bwdAbrMinCellRateId; /* backward ABR min. cell rate id, CLP = 0+1 */
- TknU32 bwdAbrMinCellRate; /* backward ABR min. cell rate, CLP = 0+1 */
+ TknUInt8 fwdPeakCellRateId0; /* forward peak cell rate id, CLP = 0 */
+ TknUInt32 fwdPeakCellRate0; /* forward peak cell rate, CLP = 0 */
+ TknUInt8 bwdPeakCellRateId0; /* backward peak cell rate id, CLP = 0 */
+ TknUInt32 bwdPeakCellRate0; /* backward peak cell rate, CLP = 0 */
+ TknUInt8 fwdPeakCellRateId1; /* forward peak cell rate id, CLP = 0+1 */
+ TknUInt32 fwdPeakCellRate1; /* forward peak cell rate, CLP = 0+1 */
+ TknUInt8 bwdPeakCellRateId1; /* backward peak cell rate id, CLP = 0+1 */
+ TknUInt32 bwdPeakCellRate1; /* backward peak cell rate, CLP = 0+1 */
+ TknUInt8 fwdSustCellRateId0; /* forward sust. cell rate id, CLP = 0 */
+ TknUInt32 fwdSustCellRate0; /* forward sust. cell rate, CLP = 0 */
+ TknUInt8 bwdSustCellRateId0; /* backward sust. cell rate id, CLP = 0 */
+ TknUInt32 bwdSustCellRate0; /* backward sust. cell rate, CLP = 0 */
+ TknUInt8 fwdSustCellRateId1; /* forward sust. cell rate id, CLP = 0+1 */
+ TknUInt32 fwdSustCellRate1; /* forward sust. cell rate, CLP = 0+1 */
+ TknUInt8 bwdSustCellRateId1; /* backward sust. cell rate id, CLP = 0+1 */
+ TknUInt32 bwdSustCellRate1; /* backward sust. cell rate, CLP = 0+1 */
+ TknUInt8 fwdMeanBurstSizeId0; /* forward mean burst size id, CLP = 0 */
+ TknUInt32 fwdMeanBurstSize0; /* forward mean burst size, CLP = 0 */
+ TknUInt8 bwdMeanBurstSizeId0; /* backward mean burst size id, CLP = 0 */
+ TknUInt32 bwdMeanBurstSize0; /* backward mean burst size, CLP = 0 */
+ TknUInt8 fwdMeanBurstSizeId1; /* forward mean burst size id, CLP = 0+1 */
+ TknUInt32 fwdMeanBurstSize1; /* forward mean burst size, CLP = 0+1 */
+ TknUInt8 bwdMeanBurstSizeId1; /* backward mean burst size id, CLP = 0+1 */
+ TknUInt32 bwdMeanBurstSize1; /* backward mean burst size, CLP = 0+1 */
+ TknUInt8 bstEffortReq; /* best effort requested */
+ TknUInt8 tfcMgmtOptId; /* traffic management options identifier */
+ TknUInt8 fwdTagReq; /* tagging requested in forward direction */
+ TknUInt8 bwdTagReq; /* tagging requested in backward direction */
+ TknUInt8 bwdFrmDisc; /* frame discard in backward direction */
+ TknUInt8 fwdFrmDisc; /* frame discard in forward direction */
+ TknUInt8 fwdAbrMinCellRateId; /* forward ABR min. cell rate id, CLP = 0+1 */
+ TknUInt32 fwdAbrMinCellRate; /* forward ABR min. cell rate, CLP = 0+1 */
+ TknUInt8 bwdAbrMinCellRateId; /* backward ABR min. cell rate id, CLP = 0+1 */
+ TknUInt32 bwdAbrMinCellRate; /* backward ABR min. cell rate, CLP = 0+1 */
} AmAtmTfcDesc;
typedef struct amCauseDgn /* Cause and Diagnostics Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 location; /* location */
- TknU8 causeVal; /* cause value */
+ TknUInt8 location; /* location */
+ TknUInt8 causeVal; /* cause value */
TknStrM dgnVal; /* Diagnostics value */
} AmCauseDgn;
typedef struct amCgPtyNmb /* Calling Party Number Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 nmbPlanId; /* address/numbering plan identification */
- TknU8 typeNmb; /* type of number */
- TknU8 screenInd; /* screening indicator */
- TknU8 presInd; /* presentation indicator */
+ TknUInt8 nmbPlanId; /* address/numbering plan identification */
+ TknUInt8 typeNmb; /* type of number */
+ TknUInt8 screenInd; /* screening indicator */
+ TknUInt8 presInd; /* presentation indicator */
TknStrS nmbDigits; /* address/number information */
} AmCgPtyNmb;
typedef struct amCgPtySad /* Calling Party Sub Address Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 oddEvenInd; /* odd/even indicator */
- TknU8 typeSad; /* type of sub address */
+ TknUInt8 oddEvenInd; /* odd/even indicator */
+ TknUInt8 typeSad; /* type of sub address */
TknStrS sadInfo; /* address/number information */
} AmCgPtySad;
typedef struct amNBearCap /* Narrowband Bearer Capability Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 infoTranCap; /* information transfer capability */
- TknU8 codingStd; /* coding standard */
- TknU8 infoTranRate0; /* information transfer rate */
- TknU8 tranMode; /* transfer mode */
- TknU8 establish; /* establishment */
- TknU8 cfg; /* configuration */
- TknU8 chanStruct; /* structure */
- TknU8 infoTranRate1; /* information transfer rate */
- TknU8 symmetry; /* symmetry */
- TknU8 usrInfoLyr1Prot; /* usr information layer 1 protocol */
- TknU8 lyr1Ident; /* layer 1 identity */
- TknU8 usrRate; /* user rate */
- TknU8 negot; /* negotiation */
- TknU8 syncAsync; /* synchronous/asynchronous */
+ TknUInt8 infoTranCap; /* information transfer capability */
+ TknUInt8 codingStd; /* coding standard */
+ TknUInt8 infoTranRate0; /* information transfer rate */
+ TknUInt8 tranMode; /* transfer mode */
+ TknUInt8 establish; /* establishment */
+ TknUInt8 cfg; /* configuration */
+ TknUInt8 chanStruct; /* structure */
+ TknUInt8 infoTranRate1; /* information transfer rate */
+ TknUInt8 symmetry; /* symmetry */
+ TknUInt8 usrInfoLyr1Prot; /* usr information layer 1 protocol */
+ TknUInt8 lyr1Ident; /* layer 1 identity */
+ TknUInt8 usrRate; /* user rate */
+ TknUInt8 negot; /* negotiation */
+ TknUInt8 syncAsync; /* synchronous/asynchronous */
/*------------------------------------------------------------------------*/
/* The following six tokens represent a uinon of octets 5b.1 and 5b.2 of */
/* the Narrow Band Bearer Capability. */
/*------------------------------------------------------------------------*/
- TknU8 FlcRx_BandNeg; /* flow control on reception or
+ TknUInt8 FlcRx_BandNeg; /* flow control on reception or
inband/outband negotiation */
- TknU8 FlcTx_Assgn; /* flow control on transmission or
+ TknUInt8 FlcTx_Assgn; /* flow control on transmission or
assignor/assignee*/
- TknU8 NicRx_LLINeg; /* network independent clock on reception or
+ TknUInt8 NicRx_LLINeg; /* network independent clock on reception or
logical link identifier negotiation */
- TknU8 NicTx_Mode; /* network independent clock on transmission or
+ TknUInt8 NicTx_Mode; /* network independent clock on transmission or
mode of operation */
- TknU8 Rate_MFrm; /* intermediate rate (low bit) or Multi
+ TknUInt8 Rate_MFrm; /* intermediate rate (low bit) or Multi
frame support */
- TknU8 Rate_Hdr; /* intermediate rate (high bit) or rate
+ TknUInt8 Rate_Hdr; /* intermediate rate (high bit) or rate
adaptation Hdr/ no Headr */
- TknU8 parity; /* parity information */
- TknU8 nmbDatBits; /* number of data bits excluding parity bit */
- TknU8 nmbStopBits; /* number of stop bits */
- TknU8 modemType; /* modem type */
- TknU8 duplexMode; /* duplex mode */
- TknU8 usrInfoLyr2Prot; /* user information layer 2 protocol */
- TknU8 lyr2Ident; /* layer 2 identity */
- TknU8 usrInfoLyr3Prot; /* user information layer 3 protocol */
- TknU8 lyr3Ident0; /* layer 3 identity */
+ TknUInt8 parity; /* parity information */
+ TknUInt8 nmbDatBits; /* number of data bits excluding parity bit */
+ TknUInt8 nmbStopBits; /* number of stop bits */
+ TknUInt8 modemType; /* modem type */
+ TknUInt8 duplexMode; /* duplex mode */
+ TknUInt8 usrInfoLyr2Prot; /* user information layer 2 protocol */
+ TknUInt8 lyr2Ident; /* layer 2 identity */
+ TknUInt8 usrInfoLyr3Prot; /* user information layer 3 protocol */
+ TknUInt8 lyr3Ident0; /* layer 3 identity */
} AmNBearCap;
typedef struct amNLoLyrComp /* Narrowband Low Layer Compatibility Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 infoTranCap; /* information transfer capability */
- TknU8 codingStd; /* coding standard */
- TknU8 negInd; /* negotiation indicator */
- TknU8 infoTranRate0; /* information transfer rate */
- TknU8 tranMode; /* transfer mode */
- TknU8 establish; /* establishment */
- TknU8 cfg; /* configuration */
- TknU8 chanStruct; /* structure */
- TknU8 infoTranRate1; /* information transfer rate */
- TknU8 symmetry; /* symmetry */
- TknU8 usrInfoLyr1Prot; /* usr information layer 1 protocol */
- TknU8 lyr1Ident; /* layer 1 identity */
- TknU8 usrRate; /* user rate */
- TknU8 negot; /* negotiation */
- TknU8 syncAsync; /* synchronous/asynchronous */
+ TknUInt8 infoTranCap; /* information transfer capability */
+ TknUInt8 codingStd; /* coding standard */
+ TknUInt8 negInd; /* negotiation indicator */
+ TknUInt8 infoTranRate0; /* information transfer rate */
+ TknUInt8 tranMode; /* transfer mode */
+ TknUInt8 establish; /* establishment */
+ TknUInt8 cfg; /* configuration */
+ TknUInt8 chanStruct; /* structure */
+ TknUInt8 infoTranRate1; /* information transfer rate */
+ TknUInt8 symmetry; /* symmetry */
+ TknUInt8 usrInfoLyr1Prot; /* usr information layer 1 protocol */
+ TknUInt8 lyr1Ident; /* layer 1 identity */
+ TknUInt8 usrRate; /* user rate */
+ TknUInt8 negot; /* negotiation */
+ TknUInt8 syncAsync; /* synchronous/asynchronous */
/*------------------------------------------------------------------------*/
/* The following six tokens represent a uinon of octets 5b.1 and 5b.2 of */
/* the Narrow Band Lower Layer Compatibility */
/*------------------------------------------------------------------------*/
- TknU8 FlcRx_BandNeg; /* flow control on reception or
+ TknUInt8 FlcRx_BandNeg; /* flow control on reception or
inband/outband negotiation */
- TknU8 FlcTx_Assgn; /* flow control on transmission or
+ TknUInt8 FlcTx_Assgn; /* flow control on transmission or
assignor/assignee*/
- TknU8 NicRx_LLINeg; /* network independent clock on reception or
+ TknUInt8 NicRx_LLINeg; /* network independent clock on reception or
logical link identifier negotiation */
- TknU8 NicTx_Mode; /* network independent clock on transmission or
+ TknUInt8 NicTx_Mode; /* network independent clock on transmission or
mode of operation */
- TknU8 Rate_MFrm; /* intermediate rate (low bit) or Multi
+ TknUInt8 Rate_MFrm; /* intermediate rate (low bit) or Multi
frame support */
- TknU8 Rate_Hdr; /* intermediate rate (high bit) or rate
+ TknUInt8 Rate_Hdr; /* intermediate rate (high bit) or rate
adaptation Hdr/ no Headr */
- TknU8 parity; /* parity information */
- TknU8 nmbDatBits; /* number of data bits excluding parity bit */
- TknU8 nmbStopBits; /* number of stop bits */
- TknU8 modemType; /* modem type */
- TknU8 duplexMode; /* duplex mode */
- TknU8 usrInfoLyr2Prot; /* user information layer 2 protocol */
- TknU8 lyr2Ident; /* layer 2 identity */
- TknU8 optLyr2ProtInfo; /* optional layer 2 protocol information */
- TknU8 usrInfoLyr3Prot; /* user information layer 3 protocol */
- TknU8 lyr3Ident1; /* layer 3 identity */
- TknU8 optLyr3ProtInfo; /* optional layer 3 protocol information */
+ TknUInt8 parity; /* parity information */
+ TknUInt8 nmbDatBits; /* number of data bits excluding parity bit */
+ TknUInt8 nmbStopBits; /* number of stop bits */
+ TknUInt8 modemType; /* modem type */
+ TknUInt8 duplexMode; /* duplex mode */
+ TknUInt8 usrInfoLyr2Prot; /* user information layer 2 protocol */
+ TknUInt8 lyr2Ident; /* layer 2 identity */
+ TknUInt8 optLyr2ProtInfo; /* optional layer 2 protocol information */
+ TknUInt8 usrInfoLyr3Prot; /* user information layer 3 protocol */
+ TknUInt8 lyr3Ident1; /* layer 3 identity */
+ TknUInt8 optLyr3ProtInfo; /* optional layer 3 protocol information */
} AmNLoLyrComp;
typedef struct amNHiLyrComp /* Narrowband High Layer Compatibility Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 presMethod; /* presentation method */
- TknU8 interpretation; /* interpretation */
- TknU8 codingStd; /* coding standard */
- TknU8 highLyrCharId; /* high layer characteristics identification */
- TknU8 extHighLyrCharId; /* extended high layer characteristics id */
+ TknUInt8 presMethod; /* presentation method */
+ TknUInt8 interpretation; /* interpretation */
+ TknUInt8 codingStd; /* coding standard */
+ TknUInt8 highLyrCharId; /* high layer characteristics identification */
+ TknUInt8 extHighLyrCharId; /* extended high layer characteristics id */
} AmNHiLyrComp;
typedef struct amProgInd /* Progress Indicator Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 progLocation; /* location */
- TknU8 codingStd; /* coding standard */
- TknU8 progDesc; /* progress description */
+ TknUInt8 progLocation; /* location */
+ TknUInt8 codingStd; /* coding standard */
+ TknUInt8 progDesc; /* progress description */
} AmProgInd;
#if (DEF_SIG_PNNI | DEF_SIG_AINI)
typedef struct amCrankback /* Crankback Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 cbLevel; /* crankback level */
- TknU8 blkTransType; /* blocked transit type */
+ TknUInt8 cbLevel; /* crankback level */
+ TknUInt8 blkTransType; /* blocked transit type */
#ifdef SIG_PNNI
TknStrS blkNodeId; /* blocked node id */
TknStrS blkLinkPreNodeId; /* blocked link's preceeding node id */
- TknU32 blkLinkPortId; /* blocked link port id */
+ TknUInt32 blkLinkPortId; /* blocked link port id */
TknStrS blkLinkSuccNodeId; /* blocked link's succeding node id */
#endif /* SIG_PNNI */
- TknU8 cbCause; /* crankback cause */
+ TknUInt8 cbCause; /* crankback cause */
#ifdef SIG_PNNI
TknStrM cbDgn; /* crankback cause diagnostics */
#endif /* SIG_PNNI */
typedef struct amCdPtySoftPvc /* Called Party Soft PVPC/PVCC Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 selType; /* VPI/VCI selection Type */
- TknU8 vpiId; /* VPI id */
- TknU16 vpi; /* VPI */
- TknU8 vciId; /* VCI id */
- TknU16 vci; /* VCI */
+ TknUInt8 selType; /* VPI/VCI selection Type */
+ TknUInt8 vpiId; /* VPI id */
+ TknUInt16 vpi; /* VPI */
+ TknUInt8 vciId; /* VCI id */
+ TknUInt16 vci; /* VCI */
#ifdef SPVC_FR
- TknU8 dlciId; /* DLCI Identifer */
- TknU32 dlci; /* Dlci Value */
+ TknUInt8 dlciId; /* DLCI Identifer */
+ TknUInt32 dlci; /* Dlci Value */
#endif /* SPVC_FR */
} AmCdPtySoftPvc;
typedef struct amCgPtySoftPvc /* Calling Party Soft PVPC/PVCC Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 vpiId; /* VPI id */
- TknU16 vpi; /* VPI */
- TknU8 vciId; /* VCI id */
- TknU16 vci; /* VCI */
+ TknUInt8 vpiId; /* VPI id */
+ TknUInt16 vpi; /* VPI */
+ TknUInt8 vciId; /* VCI id */
+ TknUInt16 vci; /* VCI */
#ifdef SPVC_FR
- TknU8 dlciId; /* DLCI Identifer */
- TknU32 dlci; /* Dlci Value */
+ TknUInt8 dlciId; /* DLCI Identifer */
+ TknUInt32 dlci; /* Dlci Value */
#endif /* SPVC_FR */
} AmCgPtySoftPvc;
#endif /* DEF_SIG_PNNI | DEF_SIG_AINI */
typedef struct amConnNmb /* Connected Number Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 nmbPlanId; /* address/numbering plan identification */
- TknU8 typeNmb; /* type of number */
- TknU8 screenInd; /* screening indicator */
- TknU8 presInd; /* presentation indicator */
+ TknUInt8 nmbPlanId; /* address/numbering plan identification */
+ TknUInt8 typeNmb; /* type of number */
+ TknUInt8 screenInd; /* screening indicator */
+ TknUInt8 presInd; /* presentation indicator */
TknStrS nmbDigits; /* address/number information */
} AmConnNmb;
typedef struct amConnSad /* Calling Party Sub Address Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 oddEvenInd; /* odd/even indicator */
- TknU8 typeSad; /* type of sub address */
+ TknUInt8 oddEvenInd; /* odd/even indicator */
+ TknUInt8 typeSad; /* type of sub address */
TknStrS sadInfo; /* address/number information */
} AmConnSad;
typedef struct amMinAccAtmTfcDesc /* Minimum acceptable ATM Traffic Desc. */
{
ElmtHdr eh; /* element header */
- TknU8 fwdPeakCellRateId0; /* forward peak cell rate id, CLP = 0 */
- TknU32 fwdPeakCellRate0; /* forward peak cell rate, CLP = 0 */
- TknU8 bwdPeakCellRateId0; /* backward peak cell rate id, CLP = 0 */
- TknU32 bwdPeakCellRate0; /* backward peak cell rate, CLP = 0 */
- TknU8 fwdPeakCellRateId1; /* forward peak cell rate id, CLP = 0+1 */
- TknU32 fwdPeakCellRate1; /* forward peak cell rate, CLP = 0+1 */
- TknU8 bwdPeakCellRateId1; /* backward peak cell rate id, CLP = 0+1 */
- TknU32 bwdPeakCellRate1; /* backward peak cell rate, CLP = 0+1 */
+ TknUInt8 fwdPeakCellRateId0; /* forward peak cell rate id, CLP = 0 */
+ TknUInt32 fwdPeakCellRate0; /* forward peak cell rate, CLP = 0 */
+ TknUInt8 bwdPeakCellRateId0; /* backward peak cell rate id, CLP = 0 */
+ TknUInt32 bwdPeakCellRate0; /* backward peak cell rate, CLP = 0 */
+ TknUInt8 fwdPeakCellRateId1; /* forward peak cell rate id, CLP = 0+1 */
+ TknUInt32 fwdPeakCellRate1; /* forward peak cell rate, CLP = 0+1 */
+ TknUInt8 bwdPeakCellRateId1; /* backward peak cell rate id, CLP = 0+1 */
+ TknUInt32 bwdPeakCellRate1; /* backward peak cell rate, CLP = 0+1 */
} AmMinAccAtmTfcDesc;
typedef struct amExtQosParam /* Extended QOS parameter */
{
ElmtHdr eh; /* element header */
- TknU8 origin; /* origin of this IE */
- TknU8 accFwdPpCDVId; /* acceptable forward peak-to-peak cell
+ TknUInt8 origin; /* origin of this IE */
+ TknUInt8 accFwdPpCDVId; /* acceptable forward peak-to-peak cell
* delay variation identifier */
- TknU32 accFwdPpCDV; /* acceptable forward peak-to-peak cell
+ TknUInt32 accFwdPpCDV; /* acceptable forward peak-to-peak cell
* delay variation */
- TknU8 accBwdPpCDVId; /* acceptable backward peak-to-peak cell
+ TknUInt8 accBwdPpCDVId; /* acceptable backward peak-to-peak cell
* delay variation identifier */
- TknU32 accBwdPpCDV; /* acceptable backward peak-to-peak cell
+ TknUInt32 accBwdPpCDV; /* acceptable backward peak-to-peak cell
* delay variation */
- TknU8 cumFwdPpCDVId; /* cumulative forward peak-to-peak cell
+ TknUInt8 cumFwdPpCDVId; /* cumulative forward peak-to-peak cell
* delay variation identifier */
- TknU32 cumFwdPpCDV; /* cumulative forward peak-to-peak cell
+ TknUInt32 cumFwdPpCDV; /* cumulative forward peak-to-peak cell
* delay variation */
- TknU8 cumBwdPpCDVId; /* cumulative backward peak-to-peak cell
+ TknUInt8 cumBwdPpCDVId; /* cumulative backward peak-to-peak cell
* delay variation identifier */
- TknU32 cumBwdPpCDV; /* cumulative backward peak-to-peak cell
+ TknUInt32 cumBwdPpCDV; /* cumulative backward peak-to-peak cell
* delay variation */
- TknU8 accFwdCLRId; /* acceptable forward cell loss ratio
+ TknUInt8 accFwdCLRId; /* acceptable forward cell loss ratio
* identifier */
- TknU8 accFwdCLR; /* acceptable forward cell loss ratio */
- TknU8 accBwdCLRId; /* acceptable backward cell loss ratio
+ TknUInt8 accFwdCLR; /* acceptable forward cell loss ratio */
+ TknUInt8 accBwdCLRId; /* acceptable backward cell loss ratio
* identifier */
- TknU8 accBwdCLR; /* acceptable backward cell loss ratio */
+ TknUInt8 accBwdCLR; /* acceptable backward cell loss ratio */
} AmExtQosParam;
typedef struct amAbrAddParam /* ABR additional parameters */
{
ElmtHdr eh; /* element header */
- TknU8 fwdAddParamRecId; /* forward additional parameters record identifier */
- TknU32 fwdAddParamRec; /* forward additional parameters record */
- TknU8 bwdAddParamRecId; /* backward additional parameters record identifier */
- TknU32 bwdAddParamRec; /* backward additional parameters record */
+ TknUInt8 fwdAddParamRecId; /* forward additional parameters record identifier */
+ TknUInt32 fwdAddParamRec; /* forward additional parameters record */
+ TknUInt8 bwdAddParamRecId; /* backward additional parameters record identifier */
+ TknUInt32 bwdAddParamRec; /* backward additional parameters record */
} AmAbrAddParam;
typedef struct amAbrSetupParam /* ABR Setup parameters */
{
ElmtHdr eh; /* element header */
- TknU8 fwdAbrICRId; /* forward ABR initial cell rate identifier */
- TknU32 fwdAbrICR; /* forward ABR initial cell rate */
- TknU8 bwdAbrICRId; /* backward ABR initial cell rate identifier */
- TknU32 bwdAbrICR; /* backward ABR initial cell rate */
- TknU8 fwdAbrTBEId; /* forward ABR transient buffer exposure identifier */
- TknU32 fwdAbrTBE; /* forward ABR transient buffer exposure */
- TknU8 bwdAbrTBEId; /* backward ABR transient buffer exposure identifier */
- TknU32 bwdAbrTBE; /* backward ABR transient buffer exposure */
- TknU8 cumRmFRTTId; /* cumulative RM fixed round trip time identifier */
- TknU32 cumRmFRTT; /* cumulative RM fixed round trip time */
- TknU8 fwdRIFId; /* forward rate increment factor identifier */
- TknU8 fwdRIF; /* forward rate increment factor */
- TknU8 bwdRIFId; /* backward rate increment factor identifier */
- TknU8 bwdRIF; /* backward rate increment factor */
- TknU8 fwdRDFId; /* forward rate decrement factor identifier */
- TknU8 fwdRDF; /* forward rate decrement factor */
- TknU8 bwdRDFId; /* backward rate decrement factor identifier */
- TknU8 bwdRDF; /* backward rate decrement factor */
+ TknUInt8 fwdAbrICRId; /* forward ABR initial cell rate identifier */
+ TknUInt32 fwdAbrICR; /* forward ABR initial cell rate */
+ TknUInt8 bwdAbrICRId; /* backward ABR initial cell rate identifier */
+ TknUInt32 bwdAbrICR; /* backward ABR initial cell rate */
+ TknUInt8 fwdAbrTBEId; /* forward ABR transient buffer exposure identifier */
+ TknUInt32 fwdAbrTBE; /* forward ABR transient buffer exposure */
+ TknUInt8 bwdAbrTBEId; /* backward ABR transient buffer exposure identifier */
+ TknUInt32 bwdAbrTBE; /* backward ABR transient buffer exposure */
+ TknUInt8 cumRmFRTTId; /* cumulative RM fixed round trip time identifier */
+ TknUInt32 cumRmFRTT; /* cumulative RM fixed round trip time */
+ TknUInt8 fwdRIFId; /* forward rate increment factor identifier */
+ TknUInt8 fwdRIF; /* forward rate increment factor */
+ TknUInt8 bwdRIFId; /* backward rate increment factor identifier */
+ TknUInt8 bwdRIF; /* backward rate increment factor */
+ TknUInt8 fwdRDFId; /* forward rate decrement factor identifier */
+ TknUInt8 fwdRDF; /* forward rate decrement factor */
+ TknUInt8 bwdRDFId; /* backward rate decrement factor identifier */
+ TknUInt8 bwdRDF; /* backward rate decrement factor */
} AmAbrSetupParam;
#endif /* DEF_SIG_PNNI | DEF_SIG_AINI | DEF_UNI40 */
typedef struct amCdPtyNmb /* Called Party Number Tokens */
{
ElmtHdr eh; /* element header */
- TknU8 nmbPlanId; /* address/numbering plan identification */
- TknU8 typeNmb; /* type of number */
+ TknUInt8 nmbPlanId; /* address/numbering plan identification */
+ TknUInt8 typeNmb; /* type of number */
TknStrS nmbDigits; /* address/number information */
} AmCdPtyNmb;
{
Region region; /* region */
Pool pool; /* pool */
- U16 spare; /* spare for alignment */
+ uint16_t spare; /* spare for alignment */
} Mem;
typedef Mem MemoryId; /* memory id */
typedef struct tds_header /* header */
{
- U16 msgLen; /* message length - optional */
- U8 msgType; /* message type - mandatory */
- U8 version; /* version - optional */
- U16 seqNmb; /* sequence number - optional */
+ uint16_t msgLen; /* message length - optional */
+ uint8_t msgType; /* message type - mandatory */
+ uint8_t version; /* version - optional */
+ uint16_t seqNmb; /* sequence number - optional */
EntityId entId; /* entity id - mandatory */
ElmntId elmId; /* element id - mandatory */
#ifdef LMINT3
typedef struct tmrCfg /* timer configuration structure */
{
Bool enb; /* enable */
- U16 val; /* value */
+ uint16_t val; /* value */
} TmrCfg;
typedef struct asyncCfg /* asynchronous configuration */
typedef struct dateTime /* date and time */
{
- U8 month; /* month */
- U8 day; /* day */
- U8 year; /* year */
- U8 hour; /* hour - 24 hour clock */
- U8 min; /* minute */
- U8 sec; /* second */
- U8 tenths; /* tenths of second */
+ uint8_t month; /* month */
+ uint8_t day; /* day */
+ uint8_t year; /* year */
+ uint8_t hour; /* hour - 24 hour clock */
+ uint8_t min; /* minute */
+ uint8_t sec; /* second */
+ uint8_t tenths; /* tenths of second */
/*-- gen_x_001.main_90 - Added variable for microseconds in DateTime--*/
#ifdef SS_DATETIME_USEC
- U32 usec; /* micro seconds */
+ uint32_t usec; /* micro seconds */
#endif /*-- SS_DATETIME_USEC --*/
} DateTime;
/* gen_x_001.main_94: Additions */
/* gen_x_001.main_95: Modifications */
-typedef U64 EpcTime;
+typedef uint64_t EpcTime;
/* common status */
typedef struct cmStatus
{
- U16 status; /* status of request */
- U16 reason; /* failure reason */
+ uint16_t status; /* status of request */
+ uint16_t reason; /* failure reason */
}CmStatus;
/* common alarm */
typedef struct cmAlarm
{
DateTime dt; /* data and time */
- U16 category; /* alarm category*/
- U16 event; /* alarm event */
- U16 cause; /* alarm cause */
+ uint16_t category; /* alarm category*/
+ uint16_t event; /* alarm event */
+ uint16_t cause; /* alarm cause */
}CmAlarm;
/* duration structure */
typedef struct duration /* duration */
{
- U8 days; /* days */
- U8 hours; /* hours */
- U8 mins; /* minutes */
- U8 secs; /* seconds */
- U8 tenths; /* tenths of seconds */
+ uint8_t days; /* days */
+ uint8_t hours; /* hours */
+ uint8_t mins; /* minutes */
+ uint8_t secs; /* seconds */
+ uint8_t tenths; /* tenths of seconds */
} Duration;
#ifdef FLAT_BUFFER_OPT
typedef struct _flatBuffer
{
- U8* startAddr;
- U8* ptr;
- U32 len;
+ uint8_t* startAddr;
+ uint8_t* ptr;
+ uint32_t len;
}FlatBuffer;
#endif
typedef struct tknBuf
{
- U8 pres; /* Present Flag */
- U8 spare1; /* for alignment */
- U16 spare2; /* for 32 bit alignment */
+ uint8_t pres; /* Present Flag */
+ uint8_t spare1; /* for alignment */
+ uint16_t spare2; /* for 32 bit alignment */
#ifdef ALIGN_64BIT
- U32 spare3; /* for 64 bit alignment */
+ uint32_t spare3; /* for 64 bit alignment */
#endif
Buffer *val; /* Buffer type (use allocated memory) */
} TknBuf;
/* defining the CmIpAddr and CmIpAddr6 */
/* socket typedefs and structs */
-typedef U32 CmIpAddr; /* 4 byte IP address */
+typedef uint32_t CmIpAddr; /* 4 byte IP address */
#ifdef IPV6_SUPPORTED
-typedef U8 CmIpAddr6[16]; /* 16 byte IPV6 address */
+typedef uint8_t CmIpAddr6[16]; /* 16 byte IPV6 address */
#endif /* IPV6_SUPPORTED */
/* common packing functions */
EXTERN S16 cmPkProtAddr ARGS((ProtAddr *protAddr, Buffer *mBuf));
EXTERN S16 cmPkProtAddrTbl ARGS((ProtAddrTbl *protAddr, Buffer *mBuf));
EXTERN S16 cmPkShrtAddrs ARGS((ShrtAddrs *addrs, Buffer *mBuf));
-EXTERN S16 cmPkAddrMask ARGS((U8 *mask, Buffer *mBuf));
+EXTERN S16 cmPkAddrMask ARGS((uint8_t *mask, Buffer *mBuf));
EXTERN S16 cmPkBndCfg ARGS((BndCfg *bndCfg, Buffer *mBuf));
EXTERN S16 cmPkPst ARGS((Pst *pst, Buffer *mBuf));
EXTERN S16 cmPkElmtHdr ARGS((ElmtHdr *m, Buffer *mBuf));
-EXTERN S16 cmPkTknU8 ARGS((TknU8 *tknU8, Buffer *mBuf));
+EXTERN S16 cmPkTknUInt8 ARGS((TknUInt8 *tknUInt8, Buffer *mBuf));
EXTERN S16 cmPkTknS8 ARGS((TknS8 *tknS8, Buffer *mBuf));
-EXTERN S16 cmPkTknU16 ARGS((TknU16 *tknU16, Buffer *mBuf));
-EXTERN S16 cmPkTknU32 ARGS((TknU32 *tknU32, Buffer *mBuf));
+EXTERN S16 cmPkTknUInt16 ARGS((TknUInt16 *tknUInt16, Buffer *mBuf));
+EXTERN S16 cmPkTknUInt32 ARGS((TknUInt32 *tknUInt32, Buffer *mBuf));
EXTERN S16 cmPkTknStr ARGS((TknStr *tknStr, Buffer *mBuf));
EXTERN S16 cmPkTknStrM ARGS((TknStrM *tknStr, Buffer *mBuf));
EXTERN S16 cmPkTknStrS ARGS((TknStrS *tknStr, Buffer *mBuf));
EXTERN S16 cmUnpkProtAddr ARGS((ProtAddr *protAddr, Buffer *mBuf));
EXTERN S16 cmUnpkProtAddrTbl ARGS((ProtAddrTbl *protAddr, Buffer *mBuf));
EXTERN S16 cmUnpkShrtAddrs ARGS((ShrtAddrs *addrs, Buffer *mBuf));
-EXTERN S16 cmUnpkAddrMask ARGS((U8 *mask, Buffer *mBuf));
+EXTERN S16 cmUnpkAddrMask ARGS((uint8_t *mask, Buffer *mBuf));
EXTERN S16 cmUnpkBndCfg ARGS((BndCfg *bndCfg, Buffer *mBuf));
EXTERN S16 cmUnpkPst ARGS((Pst *pst, Buffer *mBuf));
EXTERN S16 cmUnpkElmtHdr ARGS((ElmtHdr *m, Buffer *mBuf));
-EXTERN S16 cmUnpkTknU8 ARGS((TknU8 *tknU8, Buffer *mBuf));
+EXTERN S16 cmUnpkTknUInt8 ARGS((TknUInt8 *tknUInt8, Buffer *mBuf));
EXTERN S16 cmUnpkTknS8 ARGS((TknS8 *tknS8, Buffer *mBuf));
-EXTERN S16 cmUnpkTknU16 ARGS((TknU16 *tknU16, Buffer *mBuf));
-EXTERN S16 cmUnpkTknU32 ARGS((TknU32 *tknU32, Buffer *mBuf));
+EXTERN S16 cmUnpkTknUInt16 ARGS((TknUInt16 *tknUInt16, Buffer *mBuf));
+EXTERN S16 cmUnpkTknUInt32 ARGS((TknUInt32 *tknUInt32, Buffer *mBuf));
EXTERN S16 cmUnpkTknStr ARGS((TknStr *tknStr, Buffer *mBuf));
EXTERN S16 cmUnpkTknStrM ARGS((TknStrM *tknStr, Buffer *mBuf));
EXTERN S16 cmUnpkTknStrS ARGS((TknStrS *tknStr, Buffer *mBuf));
(
Pst * pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 cmPkKwuBndCfm(pst, suId, status)
Pst * pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
S16 ret1;
Buffer *mBuf;
#endif
{
- register U32 iter;
+ register uint32_t iter;
for(iter = 0; iter < param->numSduIds; iter++)
{
for (i = (param->numSdu - 1); i >= 0; i--)
{
- CMCHKPK(oduUnpackUInt32, param->sduId[(U16)i], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->sduId[(uint16_t)i], mBuf);
}
CMCHKPK(oduUnpackUInt32, param->numSdu, mBuf);
CMCHKPK(cmPkLteRlcId, ¶m->rlcId, mBuf);
#endif
{
SuId suId = 0;
- U8 status = 0;
+ uint8_t status = 0;
CMCHKUNPKLOG(SUnpkS16, &suId, mBuf, EKWU022, pst);
Buffer *mBuf;
#endif
{
- U32 i;
+ uint32_t i;
CMCHKUNPK(cmUnpkLteRlcId, ¶m->rlcId, mBuf);
SuId suId = 0;
CmLteRlcId rlcId;
-
memset(&rlcId, 0, sizeof(CmLteRlcId));
-
CMCHKUNPK(SUnpkS16, &(suId), mBuf);
switch(pst->selector)
{
typedef struct kwuDatReqInfo
{
CmLteRlcId rlcId; /*!< RLC ID */
- U32 sduId; /*!< SDU ID */
+ uint32_t sduId; /*!< SDU ID */
#ifdef CCPU_OPT
CmLteLcType lcType; /*!<Logical Channel Type */
#ifdef EMTC_ENABLE
- U8 emtcDiReason; /* !< DI reason */
-
U8 pnb; /*!<paging narrowBand on which Ue perform Paging Reception*/
+ uint8_t emtcDiReason; /* !< DI reason */
+
uint8_t pnb; /*!<paging narrowBand on which Ue perform Paging Reception*/
#endif
union
{
typedef struct kwuDatCfmInfo
{
CmLteRlcId rlcId; /*!< RLC ID */
- U32 numSduIds; /*!< Number of Id's in the sudIds array */
- U32 sduIds[KWU_MAX_DAT_CFM]; /*!< SDU Ids */
+ uint32_t numSduIds; /*!< Number of Id's in the sudIds array */
+ uint32_t sduIds[KWU_MAX_DAT_CFM]; /*!< SDU Ids */
}KwuDatCfmInfo;
/** @brief Discard SDU Request Information from PDCP to RLC */
typedef struct kwuStaIndInfo
{
CmLteRlcId rlcId; /*!< RLC ID */
- U32 numSdu; /*!< Number of SDUs */
- U32 sduId[KWU_MAX_STA_IND_SDU]; /*!< SDU Id Array */
+ uint32_t numSdu; /*!< Number of SDUs */
+ uint32_t sduId[KWU_MAX_STA_IND_SDU]; /*!< SDU Id Array */
}KwuStaIndInfo;
typedef struct kwuFlowCntrlIndInfo
{
CmLteRlcId rlcId;
- U32 pktAdmitCnt;
+ uint32_t pktAdmitCnt;
}KwuFlowCntrlIndInfo;
/* kwu_x_001.main_3 Added support for L2 Measurement */
#ifdef LTE_L2_MEAS
typedef struct kwuDatAckInfo
{
CmLteRlcId rlcId; /*!< RLC ID */
- U32 sduId; /*!< SDU Id Array */
+ uint32_t sduId; /*!< SDU Id Array */
}KwuDatAckInfo;
#endif /* LTE_L2_MEAS */
Buffer *mBuf;
CmLteLcType lcType;
Ticks arrTime;
- U32 sduId;
+ uint32_t sduId;
CmLteRlcId rlcId;
}KwuDatReqDetl;
#endif
/* Control primitives towards LTE RRC */
typedef S16 (*KwuBndReq) ARGS((Pst *pst, SuId suId, SpId spId));
-typedef S16 (*KwuBndCfm) ARGS((Pst *pst, SuId suId, U8 status));
+typedef S16 (*KwuBndCfm) ARGS((Pst *pst, SuId suId, uint8_t status));
typedef S16 (*KwuUbndReq) ARGS((Pst *pst, SuId suId, Reason reason));
typedef S16 (*KwuDatReq) ARGS((Pst *pst, KwuDatReqInfo* datReq, Buffer *mBuf));
*/
EXTERN S16 RlcUiKwuBndCfm ARGS((Pst *pst,
SuId suId,
- U8 status));
+ uint8_t status));
/**
* @details The RLC service user initiates this primitive for performing
EXTERN S16 NhLiKwuBndCfm ARGS((Pst *pst,
SuId suId,
- U8 status));
+ uint8_t status));
EXTERN S16 NhLiKwuUbndReq ARGS((Pst *pst,
SpId spId,
EXTERN S16 DmUiKwuBndCfm ARGS((Pst *pst,
SuId suId,
- U8 status));
+ uint8_t status));
EXTERN S16 DmUiKwuUbndReq ARGS((Pst *pst,
SpId spId,
EXTERN S16 PjLiKwuBndCfm ARGS((Pst *pst,
SuId suId,
- U8 status));
+ uint8_t status));
EXTERN S16 PjLiKwuUbndReq ARGS((Pst *pst,
SpId spId,
EXTERN S16 cmPkKwuBndCfm ARGS ((
Pst * pst,
SuId suId,
-U8 status
+uint8_t status
));
EXTERN uint8_t cmPkKwuDatReq ARGS ((
typedef struct tSL2UeStatsCb
{
CmLList lnk;
- U32 inUse;
+ uint32_t inUse;
TSInfL2UeStats stats;
}TSL2UeStatsCb;
Pool pool
));
EXTERN TSL2UeStatsCb* TSL2AllocUeStatsBlk ARGS((
- U16 rnti
+ uint16_t rnti
));
EXTERN Void TSL2DeallocUeStatsBlk ARGS((
- U16 rnti,
+ uint16_t rnti,
TSL2UeStatsCb *statsCb
));
EXTERN TSL2CellStatsCb* TSL2AllocCellStatsBlk ARGS((
- U32 cellId
+ uint32_t cellId
));
EXTERN Void TSL2DeallocCellStatsBlk ARGS((
- U32 cellId
+ uint32_t cellId
));
EXTERN Void TSL2SendStatsToApp ARGS((
Pst *pst,
/*Extension Header */
typedef struct egtpExtHdr
{
- TknU16 udpPort; /**< UDP Port */
- TknU16 pdcpNmb; /**< PDCP Number */
+ TknUInt16 udpPort; /**< UDP Port */
+ TknUInt16 pdcpNmb; /**< PDCP Number */
}EgtpExtHdr;
/*Structure for MsgHdr */
typedef struct egtpMsgHdr
{
- TknU8 nPdu; /**< N-PDU Number */
- TknU32 seqNum; /**< Sequence Number */
+ TknUInt8 nPdu; /**< N-PDU Number */
+ TknUInt32 seqNum; /**< Sequence Number */
EgtpExtHdr extHdr; /**< Extension headers present flag */
uint32_t teId; /**< Tunnel Endpoint Id */
uint8_t msgType; /**< eGTP-U Message Type */
Buffer *mBuf;
#endif
{
- U8 subAction; /* sub action */
+ uint8_t subAction; /* sub action */
switch( elmnt )
Buffer *mBuf;
#endif
{
- U8 subAction;
+ uint8_t subAction;
RlcDbgCntrl *dbgCntrl;
RlcTrcCntrl *trcCntrl;
Buffer *mBuf;
#endif
{
- U8 idx;
- U16 idx1;
+ uint8_t idx;
+ uint16_t idx1;
if((param->measType & LKW_L2MEAS_DL_IP) ||
S16 cmPkLkwL2MeasStopReq
(
Pst *pst,
-U8 measType
+uint8_t measType
)
#else
S16 cmPkLkwL2MeasStopReq(pst, measType)
Pst *pst;
-U8 measType;
+uint8_t measType;
#endif
{
Buffer *mBuf = NULLP;
S16 cmPkLkwL2MeasSendReq
(
Pst *pst,
-U8 measType
+uint8_t measType
)
#else
S16 cmPkLkwL2MeasSendReq(pst, measType)
Pst *pst;
-U8 measType;
+uint8_t measType;
#endif
{
Buffer *mBuf = NULLP;
Buffer *mBuf;
#endif
{
- U8 idx;
- U16 idx1;
+ uint8_t idx;
+ uint16_t idx1;
CMCHKUNPK(oduPackUInt8, ¶m->measType, mBuf);
Buffer *mBuf;
#endif
{
- U8 measType;
+ uint8_t measType;
CMCHKUNPK(oduPackUInt8, &measType, mBuf);
SPutMsg(mBuf);
Buffer *mBuf;
#endif
{
- U8 measType;
+ uint8_t measType;
CMCHKUNPK(oduPackUInt8, &measType, mBuf);
#endif
{
Buffer *mBuf = NULLP;
- U8 idx;
- U8 idx1;
+ uint8_t idx;
+ uint8_t idx1;
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) {
(
RlcL2MeasCfmInfo *param,
Buffer *mBuf,
-U8 measType
+uint8_t measType
)
#else
S16 cmPkRlcL2MeasCfmInfo(param, mBuf, measType)
RlcL2MeasCfmInfo *param;
Buffer *mBuf;
-U8 measType;
+uint8_t measType;
#endif
{
Buffer *mBuf;
#endif
{
- U8 idx;
- U16 idx1;
+ uint8_t idx;
+ uint16_t idx1;
RlcL2MeasCfmEvt measCfmEvt;
-
memset(&measCfmEvt, 0 , sizeof(RlcL2MeasCfmEvt));
-
if (oduPackUInt32(&measCfmEvt.transId, mBuf) != ROK) {
SPutMsg(mBuf);
#if (ERRCLASS & ERRCLS_ADD_RES)
(
RlcL2MeasCfmInfo *param,
Buffer *mBuf,
-U8 measType
+uint8_t measType
)
#else
S16 cmUnpkRlcL2MeasCfmInfo(param, mBuf, measType)
RlcL2MeasCfmInfo *param;
Buffer *mBuf;
-U8 measType;
+uint8_t measType;
#endif
{
S16 cmPkLkwL2MeasStopCfm
(
Pst * pst,
-U8 measType,
-U8 status
+uint8_t measType,
+uint8_t status
)
#else
S16 cmPkLkwL2MeasStopCfm(pst, measType,status)
Pst * pst;
-U8 measType;
-U8 status
+uint8_t measType;
+uint8_t status
#endif
{
Buffer *mBuf = NULLP;
Buffer *mBuf;
#endif
{
- U8 measType;
- U8 status;
+ uint8_t measType;
+ uint8_t status;
CMCHKUNPK(oduPackUInt8, &measType, mBuf);
CMCHKUNPK(oduPackUInt8, &status, mBuf);
SPutMsg(mBuf);
{
Pst lmPst; /*!< Post structure for communicating
with LM. */
- U32 maxUe; /*!< Maximum number of UEs supported
+ uint32_t maxUe; /*!< Maximum number of UEs supported
by RLC. */
- U16 maxKwuSaps; /*!< Maximum KWU SAPs. */
+ uint16_t maxKwuSaps; /*!< Maximum KWU SAPs. */
/* Supported by SPLIT Architecture */
- U16 maxUdxSaps; /*!< Maximum Udx SAPs. */
+ uint16_t maxUdxSaps; /*!< Maximum Udx SAPs. */
/* Supported by SPLIT Architecture ends */
Ticks timeRes; /*!< Time resolution. */
/* Supported by SPLIT Architecture */
- U8 rlcMode; /*!< RLC_DL or RLC_UL */
+ uint8_t rlcMode; /*!< RLC_DL or RLC_UL */
/* Supported by SPLIT Architecture ends */
- U16 maxRguSaps; /*!< Maximum RGU SAPs. */
+ uint16_t maxRguSaps; /*!< Maximum RGU SAPs. */
}RlcGenCfg;
/** @brief
Ent ent; /*!< Entity ID. */
Inst inst; /*!< Instance ID. */
SpId sapId; /*!< SAP ID. */
- U16 bndTmrIntvl; /*!< Bind timer interval. */
+ uint16_t bndTmrIntvl; /*!< Bind timer interval. */
Priority priority; /*!< Priority. */
Route route; /*!< Route. */
}RlcSapCfg;
Trace Control Structure */
typedef struct rlcTrcCntrl
{
- U8 trcMask; /*!< Trace mask. */
+ uint8_t trcMask; /*!< Trace mask. */
S16 trcLen; /*!< Trace length. */
}RlcTrcCntrl;
Debug Control Structure */
typedef struct rlcDbgCntrl
{
- U32 dbgMask; /*!< Debug mask. Assign non zero value to enable
+ uint32_t dbgMask; /*!< Debug mask. Assign non zero value to enable
and zero to disable debug */
}RlcDbgCntrl;
typedef struct rlcCntrl
{
DateTime dt; /*!< Date and Time structure. */
- U8 action; /*!< Action. */
- U8 subAction; /*!< Sub action. */
+ uint8_t action; /*!< Action. */
+ uint8_t subAction; /*!< Sub action. */
union
{
RlcTrcCntrl trcCntrl; /*!< Trace Control Structure. */
RlcDbgCntrl dbgCntrl; /*!< Debug Control Structure. */
RlcSapCntrl sapCntrl; /*!< SAP Control Structure. */
#ifdef SS_DIAG
- U32 logMask; /*!< Logging Control Structure. */
+ uint32_t logMask; /*!< Logging Control Structure. */
#endif
}s;
}RlcCntrl;
DateTime dt; /*!< Date and Time structure. */
CmAlarm alarm; /*!< Alarm. */
SuId suId; /*!< Service user ID. */
- U32 ueId; /*!< Urnti UE ID. */
+ uint32_t ueId; /*!< Urnti UE ID. */
/* lkw_x_001.main_2, added support for L2 measurement */
#ifdef LTE_L2_MEAS
- U8 qci; /*!< Qci value */
+ uint8_t qci; /*!< Qci value */
#endif
}RlcUSta;
typedef struct rlcTrc
{
DateTime dt; /*!< Date and Time structure. */
- U16 event; /*!< Event. Events defined in the differenct RLC
+ uint16_t event; /*!< Event. Events defined in the differenct RLC
interfaces are pssible values here.*/
}RlcTrc;
/** @brief Measurement Request Params Structure. */
typedef struct rlcL2MeasReqInfo
{
- U8 measType; /*!< Measurement type, bit 1 to 4 (LSB nibble)
+ uint8_t measType; /*!< Measurement type, bit 1 to 4 (LSB nibble)
will be used for non IP Throughput and
bit 5 and 6 will be used for DL and UL
Ipthroughput respectively */
{
struct
{
- U16 numSamples; /*!<Sampling period: */
- U8 numQci; /*!<number of qCI to take measurement for */
- U8 qci[LKW_MAX_QCI]; /*!<QCI for the measurement */
+ uint16_t numSamples; /*!<Sampling period: */
+ uint8_t numQci; /*!<number of qCI to take measurement for */
+ uint8_t qci[LKW_MAX_QCI]; /*!<QCI for the measurement */
}nonIpThMeas;
struct
{
- U16 numUes;
+ uint16_t numUes;
struct
{
- U8 numQci; /*!<number of qCI to take measurement for */
- U8 qci[LKW_MAX_QCI]; /*!<QCI for the measurement */
+ uint8_t numQci; /*!<number of qCI to take measurement for */
+ uint8_t qci[LKW_MAX_QCI]; /*!<QCI for the measurement */
CmLteRnti ueId; /*!< UE ID (Used only for IP Throughput in UL/DL */
CmLteCellId cellId; /*!< Cell ID (Used only for IP Throughput in UL/DL */
}ueInfoLst[LKW_MAX_UE];
/** @brief Measurement Request Exvent Structure. */
typedef struct rlcL2MeasReqEvt
{
- U32 transId; /*!< Transaction Identifier */
- U16 measPeriod; /*!< Measurement Period */
+ uint32_t transId; /*!< Transaction Identifier */
+ uint16_t measPeriod; /*!< Measurement Period */
RlcL2MeasReqInfo measReq; /*!< Measurement request structure */
}RlcL2MeasReqEvt;
/** @brief Measurement Confirm Params Structure. */
typedef struct rlcL2MeasCfmInfo
{
- U8 qci; /*!< QCI value */
+ uint8_t qci; /*!< QCI value */
union
{
struct
{
- U32 numActUe; /*!< num of Active UEs*/
- U32 uuLoss; /*!< Uu Loss Rate */
+ uint32_t numActUe; /*!< num of Active UEs*/
+ uint32_t uuLoss; /*!< Uu Loss Rate */
/* Discard new changes starts */
- U32 dlDiscRate; /*!< DL Discard rate to be reported */
+ uint32_t dlDiscRate; /*!< DL Discard rate to be reported */
/* Discard new changes ends */
- U32 dlSduDelay;
+ uint32_t dlSduDelay;
}nonIpThrput;
struct /*!< Structure for IP throughput*/
CmLteRnti ueId; /*!< UE Id used for DL/UL Ipthroughput*/
CmLteCellId cellId; /*!< Cell Id used for DL/UL Ipthroughput*/
RlcL2MeasCfmInfo measCfm[LKW_MAX_QCI]; /*!< Measurement confirm structure*/
- U16 numCfm; /*!< Number of Measurement confirm*/
+ uint16_t numCfm; /*!< Number of Measurement confirm*/
}RlcL2MeasCfmUeInfoLst;
typedef struct rlcL2MeasCfmIpThMeas
{
- U16 numUes; /*!< Number of Ue Info*/
+ uint16_t numUes; /*!< Number of Ue Info*/
RlcL2MeasCfmUeInfoLst ueInfoLst[LKW_MAX_UE]; /*!< UE info list*/
}RlcL2MeasCfmIpThMeas;
typedef struct rlcL2MeasCfmNonIpThMeas
{
- U16 numCfm; /*!< Number of confirm */
+ uint16_t numCfm; /*!< Number of confirm */
RlcL2MeasCfmInfo measCfm[LKW_MAX_QCI]; /*!< Confirmation info */
}RlcL2MeasCfmNonIpThMeas;
/** @brief Measurement Confirm Event Structure. */
typedef struct rlcL2MeasCfmEvt
{
- U32 transId; /*!< Transaction id */
+ uint32_t transId; /*!< Transaction id */
CmStatus status; /*!< Status is for all QCIs */
- U8 measType; /*!< Measurement type, bit 1 to 4 (LSB nibble)
+ uint8_t measType; /*!< Measurement type, bit 1 to 4 (LSB nibble)
will be used for non IP Throughput and
bit 5 and 6 will be used for DL and UL
Ipthroughput respectively. It is same for
#ifdef LTE_L2_MEAS
typedef S16 (*LkwL2MeasReq) ARGS((Pst *pst, RlcL2MeasReqEvt *measEvt));
typedef S16 (*LkwL2MeasCfm) ARGS((Pst *pst, RlcL2MeasCfmEvt *measEvt));
-typedef S16 (*LkwL2MeasSendReq) ARGS((Pst *pst, U8 measType));
-typedef S16 (*LkwL2MeasStopReq) ARGS((Pst *pst, U8 measType));
-typedef S16 (*LkwL2MeasStopCfm) ARGS((Pst *pst, U8 measType,U8 status));
+typedef S16 (*LkwL2MeasSendReq) ARGS((Pst *pst, uint8_t measType));
+typedef S16 (*LkwL2MeasStopReq) ARGS((Pst *pst, uint8_t measType));
+typedef S16 (*LkwL2MeasStopCfm) ARGS((Pst *pst, uint8_t measType,uint8_t status));
#endif /* LTE_L2_MEAS */
/* Layer primitives */
@return ROK if success , RFAILED if failure
*/
S16 RlcMiLkwL2MeasReq ARGS((Pst *pst, RlcL2MeasReqEvt *measEvt));
-S16 RlcMiLkwL2MeasStopReq ARGS((Pst *pst,U8 measType));
-S16 RlcMiLkwL2MeasSendReq ARGS((Pst *pst,U8 measType));
+S16 RlcMiLkwL2MeasStopReq ARGS((Pst *pst,uint8_t measType));
+S16 RlcMiLkwL2MeasSendReq ARGS((Pst *pst,uint8_t measType));
/**
@details This function can be used by PDCP to send the measurement values
after doing L2 measurement that was requested by the layer manager.
@return ROK if success , RFAILED if failure
*/
S16 RlcMiLkwL2MeasCfm ARGS((Pst *pst, RlcL2MeasCfmEvt *measCfm));
-S16 RlcMiLkwL2MeasStopCfm ARGS((Pst *pst, U8 measType, U8 status));
+S16 RlcMiLkwL2MeasStopCfm ARGS((Pst *pst, uint8_t measType, uint8_t status));
#endif /* LTE_L2_MEAS */
S16 RlcMiLkwStaInd ARGS((Pst *pst, RlcMngmt *staReq));
Void rlcSendLmAlarm ARGS ((
- U16 category,
- U16 event,
- U16 cause,
+ uint16_t category,
+ uint16_t event,
+ uint16_t cause,
SuId suId,
- U32 ueId));
+ uint32_t ueId));
#ifdef SM
S16 SmMiRlcConfigCfm ARGS((
));
S16 SmMiLkwL2MeasStopReq ARGS((
Pst *pst,
- U8 measType
+ uint8_t measType
));
S16 SmMiLkwL2MeasSendReq ARGS((
Pst *pst,
- U8 measType
+ uint8_t measType
));
S16 SmMiLkwL2MeasCfm ARGS((
Pst *,
));
S16 SmMiLkwL2MeasStopCfm ARGS((
Pst *pst,
- U8 measType,
- U8 status
+ uint8_t measType,
+ uint8_t status
));
#endif /* LTE_L2_MEAS */
#endif
S16 cmPkRlcL2MeasCfmInfo ARGS((
RlcL2MeasCfmInfo * measCfmInfo,
Buffer *mBuf,
- U8 measType
+ uint8_t measType
));
S16 cmUnpkRlcL2MeasCfmInfo ARGS((
RlcL2MeasCfmInfo * measCfmInfo,
Buffer *mBuf,
- U8 measType
+ uint8_t measType
));
S16 cmPkLkwL2MeasStopReq ARGS((
Pst * pst,
- U8 measType
+ uint8_t measType
));
S16 cmUnpkLkwL2MeasStopReq ARGS((
LkwL2MeasStopReq func,
));
S16 cmPkLkwL2MeasSendReq ARGS((
Pst * pst,
- U8 measType
+ uint8_t measType
));
S16 cmUnpkLkwL2MeasSendReq ARGS((
LkwL2MeasSendReq func,
));
S16 cmPkLkwL2MeasStopCfm ARGS((
Pst * pst,
- U8 measType,
- U8 status
+ uint8_t measType,
+ uint8_t status
));
S16 cmUnpkLkwL2MeasStopCfm ARGS((
LkwL2MeasStopCfm func,
RgSsta *param,
S16 elmnt,
#ifdef LRG_V1
-U8 eventType,
+uint8_t eventType,
#endif
Buffer *mBuf
)
S16 elmnt;
/* lrg_c_001.main_3 - ADD - Added the extra parameter eventType to the function */
#ifdef LRG_V1
-U8 eventType;
+uint8_t eventType;
#endif
Buffer *mBuf;
#endif
(
Pst *pst,
RgMngmt *param,
-U8 eventType,
+uint8_t eventType,
Buffer *mBuf
)
#else
S16 cmPkRgMngmt(pst, param, eventType, mBuf)
Pst *pst;
RgMngmt *param;
-U8 eventType;
+uint8_t eventType;
Buffer *mBuf;
#endif
{
(
Pst *pst,
RgMngmt *param,
-U8 eventType,
+uint8_t eventType,
Buffer *mBuf
)
#else
S16 cmUnpkRgMngmt(pst, param, eventType, mBuf)
Pst *pst;
RgMngmt *param;
-U8 eventType;
+uint8_t eventType;
Buffer *mBuf;
#endif
{
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
for(idx = 0; idx < nmbActvUeQci->numQci; idx++)
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
for(idx = 0; idx < avgPrbQciReq->numQci; idx++)
{
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->sampPrd, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
for(idx = 0; idx < param->numQci; idx++)
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
for(idx = 0; idx < param->numQci; idx++)
{
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
for(idx = param->numQci; idx > 0; idx--)
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->numQci, mBuf);
{
Pst lmPst; /*!< Layer manager post structure */
MemoryId mem; /*!< Region and pool ID */
- U8 tmrRes; /*!< Timer resolution for Low SAP Bind Timer */
- U8 numRguSaps; /*!< Number of RGU SAP's */
- U8 startCellId; /*!< Start cell id value */
+ uint8_t tmrRes; /*!< Timer resolution for Low SAP Bind Timer */
+ uint8_t numRguSaps; /*!< Number of RGU SAP's */
+ uint8_t startCellId; /*!< Start cell id value */
#ifdef LTE_ADV
Bool forceCntrlSrbBoOnPCel; /*!< value 1 means scheduler will schedule
RLC control BO and SRBs only on PCEll
/* Data structures */
typedef struct rgAckNack
{
- U8 mcs;
- U16 numOfNacks;
- U16 numOfAcks;
+ uint8_t mcs;
+ uint16_t numOfNacks;
+ uint16_t numOfAcks;
} RgAckNack;
typedef struct rgSchNackAckStats
typedef struct rgSchHqNumRetx
{
- U8 mcs;
- U16 numOfHQ_1;
- U16 numOfHQ_2;
- U16 numOfHQ_3;
- U16 numOfHQ_4;
- U32 totalTx;
+ uint8_t mcs;
+ uint16_t numOfHQ_1;
+ uint16_t numOfHQ_2;
+ uint16_t numOfHQ_3;
+ uint16_t numOfHQ_4;
+ uint32_t totalTx;
} RgSchHqNumRetx;
typedef struct rgSchHqRetxStats
This structure holds General statistical information of MAC. */
typedef struct rgGenSts
{
- U32 numHarqFail; /*!< Number of HARQ failures */
- U32 numUeCfg; /*!< Number of UEs configured */
- U16 numCellCfg; /*!< Number of Cells configured */
+ uint32_t numHarqFail; /*!< Number of HARQ failures */
+ uint32_t numUeCfg; /*!< Number of UEs configured */
+ uint16_t numCellCfg; /*!< Number of Cells configured */
#ifdef MAC_SCH_STATS
RgSchNackAckStats nackAckStats;
RgSchHqRetxStats hqRetxStats;
This structure holds statistical information of a SAP in MAC. */
typedef struct rgSapSts
{
- U32 numPduRcvd; /*!< Number of PDUs received. At TFU, PDU refers to TB,
+ uint32_t numPduRcvd; /*!< Number of PDUs received. At TFU, PDU refers to TB,
and at RGU it is SDU. */
- U32 numPduTxmit; /*!< Number of PDUs transmitted. This field is
+ uint32_t numPduTxmit; /*!< Number of PDUs transmitted. This field is
applicable to TFU. */
- U32 numPduDrop; /*!< Number of PDUs dropped. At TFU, PDU refers to TB,
+ uint32_t numPduDrop; /*!< Number of PDUs dropped. At TFU, PDU refers to TB,
and at RGU it is SDU. */
}RgSapSts;
typedef struct rgSchInstCfg
{
- U8 instId; /*!< Sheduler instance ID */
+ uint8_t instId; /*!< Sheduler instance ID */
RgGenCfg genCfg; /*!< General Configuration for the scheduler instance */
- U8 numSaps; /*!< Number of RGR and TFU SAPs must be same */
+ uint8_t numSaps; /*!< Number of RGR and TFU SAPs must be same */
RgUpSapCfg rgrSap[LRG_MAX_SAPS_PER_INST]; /*!< RGR interface SAPS */
RgUpSapCfg rgmSap[LRG_MAX_SAPS_PER_INST]; /*!< RGR interface SAPS */
RgLowSapCfg tfuSap[LRG_MAX_SAPS_PER_INST]; /*!< TFU interface SAPS */
This structure holds a SAP's status information. */
typedef struct rgSapSta
{
- U8 sapState; /*!< SAP state */
+ uint8_t sapState; /*!< SAP state */
}RgSapSta;
/**
typedef struct rgSts
{
DateTime dt; /*!< Date and Time. */
- U8 sapInst; /*!< SAP instance. */
+ uint8_t sapInst; /*!< SAP instance. */
Action action; /*!< Action on Trafffic load related statistic values.
ARST: To reset the statistic values. */
union
typedef struct rgSsta
{
DateTime dt; /*!< Date and time */
- U8 sapInst; /*!< SAP instance */
+ uint8_t sapInst; /*!< SAP instance */
union
{
SystemId sysId; /*!< System information */
Alarm diagnostics structure. */
typedef struct rgUstaDgn
{
- U8 type; /*!< Diagnostics Type */
+ uint8_t type; /*!< Diagnostics Type */
union
{
/*lrg_x_001.main_3 - Changed for documentation*/
{
DateTime dt; /*!< Date and time */
/*lrg_x_001.main_3 - changed for documentation*/
- U8 evnt; /*!< Event <BR>
+ uint8_t evnt; /*!< Event <BR>
EVTRGUDATREQ Trace for Dedicated channel Data Request. <BR>
EVTRGUCDATREQ Trace for common channel data request.<BR>
*/
This structure holds MAC's Debug Control information. */
typedef struct rgDbgCntrl
{
- U32 dbgMask; /*!< iThe Layer Manager electively enables or disables various levels of Debug printing <BR>
+ uint32_t dbgMask; /*!< iThe Layer Manager electively enables or disables various levels of Debug printing <BR>
Following are the values: <BR>
DBGMASK_PRM Enable/Disable function parameter debug prints <BR>
DBGMASK_ERR Enable/Disable error prints <BR>
#ifdef PHY_ERROR_LOGING
typedef struct rgSchUlAllocCntrl
{
- U8 mcs;
- U16 numOfRb;
- U16 rbStart;
+ uint8_t mcs;
+ uint16_t numOfRb;
+ uint16_t rbStart;
Bool testStart;
Bool enaLog;
- U16 logTime;
+ uint16_t logTime;
}RgSchUlAllocCntrl;
#endif
typedef struct rgCntrl
{
DateTime dt; /*!< Date and Time */
- U8 action; /*!< Action */
- U8 subAction; /*!< Sub-action */
- U8 instId; /*!< Scheduler instance ID */
+ uint8_t action; /*!< Action */
+ uint8_t subAction; /*!< Sub-action */
+ uint8_t instId; /*!< Scheduler instance ID */
union
{
RgDbgCntrl rgDbgCntrl; /*!< Debug Control */
iii)Or any valid S16 value in case where only the specified number
of bytes, as indicated by trcLen, are to be sent.*/
RgSapCntrl rgSapCntrl; /*!< SAP Control */
- U32 logMask; /*!< Logging control Mask */
+ uint32_t logMask; /*!< Logging control Mask */
#ifdef PHY_ERROR_LOGING
RgSchUlAllocCntrl rgSchUlAllocCntrl; /* For setting MCS,Number of RB and RB start */
#endif
*/
typedef struct lrgAvgPrbQCI
{
- U8 numQci; /*!< Numner of QCI's in requests */
- U8 qci[LRG_MAX_QCI_PER_REQ]; /*!< QCI for which PRB has to be measured */
+ uint8_t numQci; /*!< Numner of QCI's in requests */
+ uint8_t qci[LRG_MAX_QCI_PER_REQ]; /*!< QCI for which PRB has to be measured */
} LrgAvgPrbQCI;
/**
**/
typedef struct lrgNmbActvUeQCI
{
- U8 sampPrd; /*!< sampling prd for which active UE's measured
+ uint8_t sampPrd; /*!< sampling prd for which active UE's measured
Where sampling period is in milli seconds
value can be at most 100ms */
- U8 numQci; /*!< Numner of QCI's in requests */
- U8 qci[LRG_MAX_QCI_PER_REQ]; /*!< QCI for which UE has to be considered */
+ uint8_t numQci; /*!< Numner of QCI's in requests */
+ uint8_t qci[LRG_MAX_QCI_PER_REQ]; /*!< QCI for which UE has to be considered */
} LrgNmbActvUeQCI;
/**
typedef struct lrgSchMeasReqInfo
{
Header hdr; /*!< Header */
- U16 measType; /*!< For type of measurement Following are the */
+ uint16_t measType; /*!< For type of measurement Following are the */
/*!< allowed values */
/*!< LRG_L2MEAS_AVG_PRB_DL , LRG_L2MEAS_AVG_PRB_UL*/
/*!< LRG_L2MEAS_AVG_PRB_PER_QCI_DL */
/*!< LRG_L2MEAS_TB_TRANS_DL_FAULTY_COUNT */
/*!< LRG_L2MEAS_TB_TRANS_UL_COUNT */
/*!< LRG_L2MEAS_TB_TRANS_UL_FAULTY_COUNT */
- U32 timePrd; /*!< Time period UNITS and value will differ depending
+ uint32_t timePrd; /*!< Time period UNITS and value will differ depending
on the action. Might be milli seconds/seconds. */
CmLteCellId cellId; /*!< CELL Id for which measurement is Done */
LrgAvgPrbQCI avgPrbQciUl; /*!< Average PRB usage per QCI in UL */
typedef struct lrgSchMeasSndReqInfo
{
Header hdr; /*!< Header */
- U16 measType; /*!< For type of measurement Following are the */
+ uint16_t measType; /*!< For type of measurement Following are the */
/*!< allowed values */
/*!< LRG_L2MEAS_AVG_PRB_DL , LRG_L2MEAS_AVG_PRB_UL*/
/*!< LRG_L2MEAS_AVG_PRB_PER_QCI_DL */
/*!< LRG_L2MEAS_RA_PREAMBLE */
/*!< LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL */
/*!< LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL */
- U32 timePrd; /*!< Time period UNITS and value will differ depending
+ uint32_t timePrd; /*!< Time period UNITS and value will differ depending
on the action. Might be milli seconds/seconds. */
CmLteCellId cellId; /*!< CELL Id for which measurement is Done */
// LrgAvgPrbQCI avgPrbQciUl; /*!< Average PRB usage per QCI in UL */
typedef struct lrgSchMeasStopReqInfo
{
Header hdr; /*!< Header */
- U16 measType; /*!< For type of measurement Following are the */
+ uint16_t measType; /*!< For type of measurement Following are the */
/*!< allowed values */
/*!< LRG_L2MEAS_AVG_PRB_DL , LRG_L2MEAS_AVG_PRB_UL*/
/*!< LRG_L2MEAS_AVG_PRB_PER_QCI_DL */
/*!< LRG_L2MEAS_RA_PREAMBLE */
/*!< LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_UL */
/*!< LRG_L2MEAS_NMB_ACTV_UE_PER_QCI_DL */
- /* U16 timePrd; */ /*!< Time period UNITS and value will differ depending
+ /* uint16_t timePrd; */ /*!< Time period UNITS and value will differ depending
on the action. Might be milli seconds/seconds. */
CmLteCellId cellId; /*!< CELL Id for which measurement is Done */
/* LrgAvgPrbQCI avgPrbQciUl; */ /*!< Average PRB usage per QCI in UL */
**/
typedef struct lrgRaPreambles
{
- U16 dedPreambles; /*!< Dedicated RA Preamble received */
- U16 randSelPreLowRange; /*!< Randomly selected preambles in low range */
- U16 randSelPreHighRange; /*!< Randomly selected preambles in high range */
+ uint16_t dedPreambles; /*!< Dedicated RA Preamble received */
+ uint16_t randSelPreLowRange; /*!< Randomly selected preambles in low range */
+ uint16_t randSelPreHighRange; /*!< Randomly selected preambles in high range */
} LrgRaPreamblesCfm;
/**
* */
typedef struct lrgAvgPrbcfm
{
- U8 prbPerc; /*!< PRB usage in percentage for UL */
+ uint8_t prbPerc; /*!< PRB usage in percentage for UL */
} LrgAvgPrbCfm;
/*LRG : Review Tag*/
typedef struct prbPercQci
{
- U8 qciValue;
- U8 prbPercQci;
+ uint8_t qciValue;
+ uint8_t prbPercQci;
}PrbPercQci;
typedef struct numActvUeQci
{
- U8 qciValue;
- U8 numActvUeQci;
+ uint8_t qciValue;
+ uint8_t numActvUeQci;
}NumActvUeQci;
/*LRG : Review Tag*/
/**
* */
typedef struct lrgAvgPrbQCICfm
{
- U8 numQci; /*!< number of QCI */
+ uint8_t numQci; /*!< number of QCI */
/*LRG : Review Tag*/
PrbPercQci prbPercQci[LRG_MAX_QCI_PER_REQ]; /*!< PRB usage in percentage per QCI for UL/DL */
/*LRG : Review Tag*/
*/
typedef struct lrgNumActvUeQCICfm
{
- U8 numQci; /*!< Numner of QCI's in requests */
+ uint8_t numQci; /*!< Numner of QCI's in requests */
/*LRG : Review Tag*/
NumActvUeQci numActvUeQci[LRG_MAX_QCI_PER_REQ]; /*!< Number of Active UE's in UL/DL per QCI */
/*LRG : Review Tag*/
typedef struct lrgSchMeasCfmInfo
{
Header hdr; /*!< Header information */
- U16 measType; /*!< Type of measurement */
+ uint16_t measType; /*!< Type of measurement */
CmStatus cfm; /*!< Confirmation possible Values when measType
is invalid status -> NOK and reason -> INVALID
*/
LrgRaPreamblesCfm raPrmbsCfm; /*!< Different received RA preambles */
LrgNumActvUeQCICfm numUeQciUlCfm; /*!< Number of Active UE's in UL per QCI */
LrgNumActvUeQCICfm numUeQciDlCfm; /*!< Number of Active UE's in DL per QCI */
- U32 tbTransDlTotalCnt; /*!< Count of DL TB transmitteed */
- U32 tbTransDlFaulty; /*!< Count of DL TB for wich NACK not recieved from UE */
- U32 tbTransUlTotalCnt; /*!< Count of UL TB received successfully */
- U32 tbTransUlFaulty; /*!< Count of UL TB not recieved successfully */
+ uint32_t tbTransDlTotalCnt; /*!< Count of DL TB transmitteed */
+ uint32_t tbTransDlFaulty; /*!< Count of DL TB for wich NACK not recieved from UE */
+ uint32_t tbTransUlTotalCnt; /*!< Count of UL TB received successfully */
+ uint32_t tbTransUlFaulty; /*!< Count of UL TB not recieved successfully */
} LrgSchMeasCfmInfo;
#endif /* LTE_L2_MEAS */
RgSsta *param,
S16 elmnt,
/*ccpu00118255 - ADD - eventType param */
- U8 eventType,
+ uint8_t eventType,
Buffer *mBuf
));
#else /*LRG_V1 not defined */
S16 cmPkRgMngmt ARGS((
Pst *pst,
RgMngmt *param,
- U8 eventType,
+ uint8_t eventType,
Buffer *mBuf
));
S16 cmUnpkRgMngmt ARGS((
Pst *pst,
RgMngmt *param,
- U8 eventType,
+ uint8_t eventType,
Buffer *mBuf
));
typedef struct tSL2UeStatsCb
{
CmLList lnk;
- U32 inUse;
+ uint32_t inUse;
TSInfL2UeStats stats;
}TSL2UeStatsCb;
Pool pool
));
EXTERN TSL2UeStatsCb* TSL2AllocUeStatsBlk ARGS((
- U16 rnti
+ uint16_t rnti
));
EXTERN Void TSL2DeallocUeStatsBlk ARGS((
- U16 rnti,
+ uint16_t rnti,
TSL2UeStatsCb *statsCb
));
EXTERN TSL2CellStatsCb* TSL2AllocCellStatsBlk ARGS((
- U32 cellId
+ uint32_t cellId
));
EXTERN Void TSL2DeallocCellStatsBlk ARGS((
- U32 cellId
+ uint32_t cellId
));
EXTERN Void TSL2SendStatsToApp ARGS((
Pst *pst,
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 cmPkLwLcRgmBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
#endif
{
SuId suId;
- U8 status;
+ uint8_t status;
if (oduPackUInt8(&status, mBuf) != ROK)
#endif
{
Buffer *mBuf = NULLP;
- U32 len = sizeof(RgmPrbRprtCfg);
+ uint32_t len = sizeof(RgmPrbRprtCfg);
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 cmPkRgmBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
#endif
{
SuId suId;
- U8 status;
+ uint8_t status;
if (oduPackUInt8(&status, mBuf) != ROK)
#endif
{
Buffer *mBuf = NULLP;
- U32 len = sizeof(RgmPrbRprtCfg);
+ uint32_t len = sizeof(RgmPrbRprtCfg);
if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK)
{
Buffer *mBuf;
#endif
{
- U32 idx = 0;
+ uint32_t idx = 0;
/* RRM_SP1_START */
Buffer *mBuf;
#endif
{
- U32 tmpModeEnum;
+ uint32_t tmpModeEnum;
CMCHKUNPK(oduPackUInt8, &transModeInd->bCellId, mBuf);
CMCHKUNPK(oduPackUInt16, &transModeInd->usCrnti, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpModeEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpModeEnum, mBuf);
transModeInd->eMode = (RgmTxnMode)tmpModeEnum;
return ROK;
}
typedef struct rgmPrbRprtCfg
{
- U16 usPrbAvgPeriodicty; /* It is in milli sec */
- U8 bConfigType;
- U8 bCellId;
+ uint16_t usPrbAvgPeriodicty; /* It is in milli sec */
+ uint8_t bConfigType;
+ uint8_t bCellId;
}RgmPrbRprtCfg;
/* RRM_SP1_START */
typedef struct rgmPrbRptPerQci
{
- U8 bQci;
- U8 bAvgPrbUlUsage;
- U8 bAvgPrbDlUsage;
+ uint8_t bQci;
+ uint8_t bAvgPrbUlUsage;
+ uint8_t bAvgPrbDlUsage;
}RgmPrbRptPerQci;
typedef struct rgmPrbRprtInd
{
RgmPrbRptPerQci stQciPrbRpts[RGM_MAX_QCI_REPORTS];
/* RRM_SP1_END */
- U8 bCellId;
+ uint8_t bCellId;
/* TDD: DL PRB Usage pres = 2 and
* UL PRB Usage pres = 1
* FDD: DL and UL Usage Pres = 3
*/
- U8 bPrbUsageMask;
+ uint8_t bPrbUsageMask;
}RgmPrbRprtInd;
typedef enum
typedef struct rgmTransModeInd
{
RgmTxnMode eMode; /* Indicate TM Mode */
- U16 usCrnti; /* UE Crnti value */
- U8 bCellId; /* Cell Id */
+ uint16_t usCrnti; /* UE Crnti value */
+ uint8_t bCellId; /* Cell Id */
}RgmTransModeInd;
/***********************************************************************
type definitions for upper layer interface - RLC primitives
typedef S16 (*RgmBndCfm) ARGS((
Pst* pst,
SuId suId,
- U8 status));
+ uint8_t status));
/** @brief Data Request from RLC to MAC for forwarding SDUs on common
* channel for transmission */
typedef S16 (*RgmCfgPrbRprtFptr) ARGS((
* @param status Status of the bind request.
* @return ROK/RFAILED
*/
-EXTERN S16 RgUiRgmBndCfm ARGS((Pst* pst,SuId suId,U8 status));
+EXTERN S16 RgUiRgmBndCfm ARGS((Pst* pst,SuId suId,uint8_t status));
/** @brief Data Request from RLC to MAC for forwarding SDUs on common
* channel for transmission
* @param pst Pointer to the post structure.
EXTERN S16 RmLiRgmBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/** @brief Request from RLC to MAC for forwarding SDUs on common
* channel for transmission */
EXTERN S16 cmPkLwLcRgmBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/** @brief Confirmation from MAC to RLC for the bind/Unbind
* request for the interface saps */
EXTERN S16 cmPkRgmBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/** @brief Confirmation from MAC to RLC for the bind/Unbind
* request for the interface saps */
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 cmPkRgrBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
#endif
{
SuId suId;
- U8 status;
+ uint8_t status;
if (SUnpkS16(&suId, mBuf) != ROK) {
(
Pst* pst,
RgrCfgTransId transId,
-U8 status
+uint8_t status
)
#else
S16 cmPkRgrCfgCfm(pst, transId, status)
Pst* pst;
RgrCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
#endif
{
RgrCfgTransId transId;
- U8 status;
+ uint8_t status;
if (cmUnpkRgrCfgTransId(&transId, mBuf) != ROK) {
Pst* pst,
SuId suId,
RgrCfgTransId transId,
-U8 status
+uint8_t status
)
#else
S16 cmPkRgrSiCfgCfm(pst, suId, transId, status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
{
SuId suId;
RgrCfgTransId transId;
- U8 status;
+ uint8_t status;
if (SUnpkS16(&suId, mBuf) != ROK) {
{
S32 i;
- U32 tmpEnum;
- CMCHKUNPK(oduPackUInt8, ¶m->numSi, mBuf);
+ uint32_t tmpEnum;
+ CMCHKUNPK(oduPackUInt8, ¶m->numSi, mBuf);
- for (i=0; i < param->numSi ; i++) {
- CMCHKUNPK(oduPackUInt32,(U32*)&tmpEnum,mBuf);
- param->siPeriodicity[i] = (RgrSiPeriodicity) tmpEnum;
+ for (i=0; i < param->numSi ; i++)
+ {
+ CMCHKUNPK(oduPackUInt32,(uint32_t*)&tmpEnum,mBuf);
+ param->siPeriodicity[i] = (RgrSiPeriodicity) tmpEnum;
}
- for (i=0; i < param->numSi ; i++) {
- CMCHKUNPK(oduPackUInt16, ¶m->schdInfo[i].emtcSiTbs, mBuf);
- CMCHKUNPK(oduPackUInt8, ¶m->schdInfo[i].emtcSiNarrowBand, mBuf);
+ for (i=0; i < param->numSi ; i++)
+ {
+ CMCHKUNPK(oduPackUInt16, ¶m->schdInfo[i].emtcSiTbs, mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->schdInfo[i].emtcSiNarrowBand, mBuf);
}
//CMCHKUNPK(oduPackUInt16, ¶m->fddDlOrTddSfBitmapBR, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->fddDLOrTddSfBitmapLC.sfnPtnChoice, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->siRepetition, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->sib1Repetition, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->siWinSizeBr, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32*)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)&tmpEnum, mBuf);
param->modPrd = (RgrModPeriodicity) tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->siHoppingEnable, mBuf);
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ngEnum = (RgrPhichNg) tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->isDurExtend, mBuf);
return ROK;
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->isSrsCfgSetup, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->srsCfgPrdEnum = (RgrSrsCfgPrd) tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->srsBwEnum = (RgrSrsBwCfg) tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->srsSubFrameCfg, mBuf);
return ROK;
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
S32 i;
#ifdef RGR_V1
CMCHKUNPK(oduPackUInt8, ¶m->preambleFormat, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->raWinSize, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->raOccasion.size, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->raOccasion.sfnEnum = (RgrRaSfn) tmpEnum;
for (i=0; i<param->raOccasion.size; i++) {
CMCHKUNPK(oduPackUInt8, ¶m->raOccasion.subFrameNum[i], mBuf);
sizeof(param->siPeriodicity[0]);
for (idx=param->numSi-1; idx >= 0; idx--) {
- /* Enum to be packed/unpacked as U32 instead of S32 */
+ /* Enum to be packed/unpacked as uint32_t instead of S32 */
CMCHKPK(oduUnpackUInt32, param->siPeriodicity[idx], mBuf);
}
CMCHKPK(oduUnpackUInt8, param->numSi, mBuf);
/*rgr_c_001.main_9 ccpu00115364 MOD changed modPrd to enum*/
- CMCHKPK(oduUnpackUInt32, (U32)param->modPrd, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t)param->modPrd, mBuf);
#endif/*RGR_SI_SCH*/
CMCHKPK(oduUnpackUInt8, param->retxCnt, mBuf);
CMCHKPK(oduUnpackUInt8, param->siWinSize, mBuf);
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
/* rgr_c_001.main_4:MOD-Modified for SI Enhancement. */
#ifdef RGR_SI_SCH
S16 idx;
CMCHKUNPK(oduPackUInt8, ¶m->retxCnt, mBuf);
#ifdef RGR_SI_SCH
/*rgr_c_001.main_9 ccpu00115364 MOD changed modPrd to enum*/
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->modPrd = (RgrModPeriodicity) tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->numSi, mBuf);
param->numSi = sizeof(param->siPeriodicity)/
sizeof(param->siPeriodicity[0]);
- /* Enum to be packed/unpacked as U32 instead of S32 */
+ /* Enum to be packed/unpacked as uint32_t instead of S32 */
for (idx=0; idx < param->numSi; idx++) {
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->siPeriodicity[idx] = (RgrSiPeriodicity) tmpEnum;
}
#endif/*RGR_SI_SCH*/
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(SUnpkS8, ¶m->p0NominalPusch, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->alpha = (RgrPwrAlpha) tmpEnum;
CMCHKUNPK(SUnpkS8, ¶m->p0NominalPucch, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->deltaPreambleMsg3, mBuf);
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->freqIdx, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->sfn = tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->halfFrm, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->ulStartSfIdx, mBuf);
for (idx = MAX_5GTF_SUBFRAME_INFO - 1; idx >= 0 ;--idx)
{
- CMCHKPK(oduUnpackUInt32, param->dynConfig[(U8)idx], mBuf);
+ CMCHKPK(oduUnpackUInt32, param->dynConfig[(uint8_t)idx], mBuf);
}
CMCHKPK(oduUnpackUInt8, param->uePerGrp, mBuf);
CMCHKPK(oduUnpackUInt8, param->ueGrpPerTti, mBuf);
for (idx = 0; idx < MAX_5GTF_SUBFRAME_INFO ; ++idx)
{
- CMCHKUNPK(oduPackUInt32, ¶m->dynConfig[(U8)idx], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->dynConfig[(uint8_t)idx], mBuf);
}
return ROK;
}
{
S8 indx = 0;
- CMCHKPK(oduUnpackUInt32, (U32)param->status, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t)param->status, mBuf);
for (indx = RGR_ABS_PATTERN_LEN-1; indx >= 0; indx--)
{
- CMCHKPK(oduUnpackUInt8, param->absPattern[(U8)indx], mBuf);
+ CMCHKPK(oduUnpackUInt8, param->absPattern[(uint8_t)indx], mBuf);
}
CMCHKPK(oduUnpackUInt32, param->absPatternType, mBuf);
#endif
{
- CMCHKPK(oduUnpackUInt32, (U32)param->status, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t)param->status, mBuf);
#ifdef TFU_UPGRADE
CMCHKPK(oduUnpackUInt32, param->pwrThreshold.pHigh, mBuf);
CMCHKPK(oduUnpackUInt32, param->pwrThreshold.pLow, mBuf);
#endif
{
- CMCHKPK(oduUnpackUInt32, (U32)param->status, mBuf);
+ CMCHKPK(oduUnpackUInt32, (uint32_t)param->status, mBuf);
return ROK;
#endif
{
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->status, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->status, mBuf);
return ROK;
}
CMCHKUNPK(oduPackUInt32, ¶m->absPatternType, mBuf);
for (indx = 0; indx <RGR_ABS_PATTERN_LEN; indx++)
{
- CMCHKUNPK(oduPackUInt8, ¶m->absPattern[(U8)indx], mBuf);
+ CMCHKUNPK(oduPackUInt8, ¶m->absPattern[(uint8_t)indx], mBuf);
}
- CMCHKUNPK(oduPackUInt32, (U32*)¶m->status, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)¶m->status, mBuf);
return ROK;
CMCHKUNPK(oduPackUInt8, ¶m->cellEdgeRbRange.startRb, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cellEdgeRbRange.endRb, mBuf);
#ifdef TFU_UPGRADE
- CMCHKUNPK(oduPackUInt32, (U32*)¶m->pwrThreshold.pLow, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32*)¶m->pwrThreshold.pHigh, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)¶m->pwrThreshold.pLow, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)¶m->pwrThreshold.pHigh, mBuf);
#endif
- CMCHKUNPK(oduPackUInt32, (U32*)¶m->status, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)¶m->status, mBuf);
return ROK;
}
CMCHKPK(oduPackUInt16, ¶m->phichTxPwrOffset, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isDynCfiEnb, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isAutoCfgModeEnb, mBuf);
- CMCHKPK(oduPackUInt32, (U32*)¶m->msg4pAVal, mBuf);
+ CMCHKPK(oduPackUInt32, (uint32_t*)¶m->msg4pAVal, mBuf);
/*LAA: Unpack LAA Cell params*/
CMCHKUNPK(cmUnpkRgrLteUCellCfg, ¶m->lteUCfg, mBuf);
#ifdef LTE_ADV
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->aprdModeEnum = (RgrAprdCqiMode) tmpEnum;
#ifdef LTE_ADV
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->prdModeEnum = tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->prdicityEnum = tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->subframeOffst, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->cqiOffst, mBuf);
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(oduPackUInt16, ¶m->cqiPResIdx, mBuf);
/*rgr_c_001.main_9 DEL removed unwanted comments*/
CMCHKUNPK(oduPackUInt16, ¶m->riCfgIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->sANCQI, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->prdModeEnum = (RgrPrdCqiMode) tmpEnum;
return ROK;
}
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
/*rgr_c_001.main_9 DEL removed unwanted comments*/
CMCHKUNPK(oduPackUInt16, ¶m->srsCfgIdx, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->srsBw = (RgrUlSrsBwInfo) tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->srsHopBw = (RgrUlSrsHoBwInfo) tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->cycShift = (RgrUlSrsCycShiftInfo) tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->duration, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->sANSrs, mBuf);
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->isAckNackEnabled, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->pucchAckNackRep, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ackNackRepFactor = (RgrAckNackRepFactor) tmpEnum;
return ROK;
}
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->tmTrnstnState = (RgrTxModeTrnstn) tmpEnum;
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->txModeEnum = (RgrTxMode) tmpEnum;
return ROK;
}
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
S32 i;
for (i=0; i<param->numPucchVal; i++) {
CMCHKUNPK(oduPackUInt32, ¶m->n1PucchVal[i], mBuf);
}
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->dlSpsPrdctyEnum = tmpEnum;
CMCHKUNPK(oduPackUInt16, ¶m->explicitRelCnt, mBuf);
return ROK;
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
S32 i;
CMCHKUNPK(oduPackUInt8, ¶m->isUlSpsEnabled, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->implicitRelCnt = tmpEnum;
#ifdef LTE_TDD
CMCHKUNPK(oduPackUInt8, ¶m->pwrCfgPres, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->pwrCfg.p0NominalPuschVal, mBuf);
CMCHKUNPK(SUnpkS8, ¶m->pwrCfg.p0UePuschVal, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ulSpsPrdctyEnum = tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->lcCnt, mBuf);
for (i=0; i<param->lcCnt; i++) {
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(oduPackUInt8, ¶m->pres, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->selType = (RgrUeTxAntSelType) tmpEnum;
return ROK;
}
CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.mpddchPdschHop),mBuf);
CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.csiNumRep),mBuf);
CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->extaddgrp2.pres),mBuf);
- CMCHKUNPK(cmUnpkTknU8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
- CMCHKUNPK(cmUnpkTknU32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
+ CMCHKUNPK(cmUnpkTknUInt32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->pucchResStartoffset),mBuf);
CMCHKUNPK(oduPackUInt32,&(epdcchAddModLst->dmrsScrambSeq),mBuf);
for(idx = 0; idx < 5; idx++)
CMCHKUNPK(oduPackUInt8,&(epdcchAddModLst->setConfigId),mBuf);
}
- CMCHKUNPK(cmUnpkTknU32,&(emtcEpdcchCfg->startSymbolr11),mBuf);
+ CMCHKUNPK(cmUnpkTknUInt32,&(emtcEpdcchCfg->startSymbolr11),mBuf);
for(indx = 0; indx < 5; indx++)
{
CMCHKUNPK(oduPackUInt8,&(emtcEpdcchCfg->sfPtn.measSfPatFDD[indx]),mBuf);
{
CMCHKPK(oduUnpackUInt8,emtcEpdcchCfg->sfPtn.measSfPatFDD[indx],mBuf);
}
- CMCHKPK(cmPkTknU32,&emtcEpdcchCfg->startSymbolr11,mBuf);
+ CMCHKPK(cmPkTknUInt32,&emtcEpdcchCfg->startSymbolr11,mBuf);
for(indx = RGR_MAX_EPDCCH_SET-1 ; indx >= 0; indx--)
{
epdcchAddModLst = &(emtcEpdcchCfg->epdcchAddModLst[indx]);
}
CMCHKPK(oduUnpackUInt32,epdcchAddModLst->dmrsScrambSeq,mBuf);
CMCHKPK(oduUnpackUInt32,epdcchAddModLst->pucchResStartoffset,mBuf);
- CMCHKPK(cmPkTknU32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
- CMCHKPK(cmPkTknU8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
+ CMCHKPK(cmPkTknUInt32,&(epdcchAddModLst->pdschRemapQLcfgId),mBuf);
+ CMCHKPK(cmPkTknUInt8,&(epdcchAddModLst->mpdcchNumPRBpair),mBuf);
CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.pres,mBuf);
CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.csiNumRep,mBuf);
CMCHKPK(oduUnpackUInt8,epdcchAddModLst->extaddgrp2.mpddchPdschHop,mBuf);
CMCHKPK(oduUnpackUInt32, param->ackNackModeEnum, mBuf);
#endif
- CMCHKPK(cmPkTknU8, ¶m->dedPreambleId, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->dedPreambleId, mBuf);
CMCHKPK(cmPkRgrCodeBookRstCfg, ¶m->ueCodeBookRstCfg, mBuf);
CMCHKPK(cmPkRgrUeCapCfg, ¶m->ueCapCfg, mBuf);
CMCHKPK(cmPkRgrUeMeasGapCfg, ¶m->ueMesGapCfg, mBuf);
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
* retxBSR-timer */
CMCHKUNPK(cmUnpkRgrUeBsrTmrCfg, ¶m->ueBsrTmrCfg, mBuf);
#endif
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ueCatEnum = (CmLteUeCategory) tmpEnum;
/*rgr_c_001.main_9 ADD added changes for DRX*/
CMCHKUNPK(cmUnpkRgrUeMeasGapCfg, ¶m->ueMesGapCfg, mBuf);
CMCHKUNPK(cmUnpkRgrUeCapCfg, ¶m->ueCapCfg, mBuf);
CMCHKUNPK(cmUnpkRgrCodeBookRstCfg, ¶m->ueCodeBookRstCfg, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->dedPreambleId, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->dedPreambleId, mBuf);
#ifdef LTE_TDD
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ackNackModeEnum = tmpEnum;
#endif
/* LTE_ADV_FLAG_REMOVED_START */
CMCHKUNPK(cmUnpkRgrLteAdvancedUeConfig, ¶m->ueLteAdvCfg, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->accessStratumRls, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->accessStratumRls, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->csgMmbrSta, mBuf);
#ifdef EMTC_ENABLE
CMCHKPK(cmPkRgrUeAprdDlCqiCfg, ¶m->aprdDlCqiRecfg, mBuf);
CMCHKPK(cmPkRgrUeTxModeCfg, ¶m->txMode, mBuf);
- /*rgr_c_001.main_9: changing ueRecfgTypes to U32 */
+ /*rgr_c_001.main_9: changing ueRecfgTypes to uint32_t */
/* LTE_ADV_FLAG_REMOVED_START */
/* KW fix for LTE_ADV */
CMCHKPK(oduUnpackUInt32, param->ueRecfgTypes, mBuf);
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->oldCrnti, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->newCrnti, mBuf);
/* LTE_ADV_FLAG_REMOVED_START */
- /*rgr_c_001.main_9: changing ueRecfgTypes to U32 */
+ /*rgr_c_001.main_9: changing ueRecfgTypes to uint32_t */
/* KW fix for LTE_ADV */
CMCHKUNPK(oduPackUInt32, ¶m->ueRecfgTypes, mBuf);
/* LTE_ADV_FLAG_REMOVED_END */
CMCHKUNPK(cmUnpkRgrUeMeasGapCfg, ¶m->ueMeasGapRecfg, mBuf);
CMCHKUNPK(cmUnpkRgrCodeBookRstCfg, ¶m->ueCodeBookRstRecfg, mBuf);
/* rgr_c_001.main_7 - Changes for UE category Reconfiguration */
- CMCHKUNPK(oduPackUInt32, (U32 *)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)&tmpEnum, mBuf);
param->ueCatEnum = (CmLteUeCategory) tmpEnum;
CMCHKUNPK(cmUnpkRgrUeTxAntSelCfg, ¶m->ulTxAntSel, mBuf);
/*rgr_c_001.main_7 - Added support for SPS*/
CMCHKUNPK(cmUnpkRgrUeSCellAckPucchCfg, ¶m->sCellAckN1ResCfg,mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->simulAckNackCQIFormat3, mBuf);
#endif
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->accessStratumRls, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->accessStratumRls, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->csgMmbrSta, mBuf);
#ifdef EMTC_ENABLE
S8 idx;
for(idx = param->numSCells - 1; idx >= 0; idx--)
{
- CMCHKPK(cmPkRgrUeDlSecCellRelInfo, ¶m->ueSCellRelDedCfg[(U8)idx],mBuf);
+ CMCHKPK(cmPkRgrUeDlSecCellRelInfo, ¶m->ueSCellRelDedCfg[(uint8_t)idx],mBuf);
}
CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->numSCells, mBuf);
}
for(count = 0; count < RGR_SCH_MAX_PA_PER_PRB; count ++)
{
- CMCHKUNPK(oduPackUInt32,(U32 *) ¶m->paLevelPerPrb[count], mBuf);
+ CMCHKUNPK(oduPackUInt32,(uint32_t *) ¶m->paLevelPerPrb[count], mBuf);
}
return ROK;
}
#endif
{
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->cfgType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->cfgType, mBuf);
switch(param->cfgType)
{
case RGR_SON_PRB_CFG :
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numOfSCells, mBuf);
S8 idx;
for(idx = param->numOfSCells - 1; idx >= 0; idx--)
{
- CMCHKPK(cmPkRgrSCellActDeactInfo, ¶m->sCellActDeactInfo[(U8)idx], mBuf);
+ CMCHKPK(cmPkRgrSCellActDeactInfo, ¶m->sCellActDeactInfo[(uint8_t)idx], mBuf);
}
CMCHKPK(oduUnpackUInt8, param->numOfSCells, mBuf);
#endif
{
MsgLen msgLen;
- U32 count;
+ uint32_t count;
CmLList *node, *prevNode;
RgrSegmentInfo *pdu;
#endif
{
MsgLen msgLen, totalMsgLen;
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
Buffer *pdu;
CmLList *node;
Pst *pst,
SpId spId,
RgrCfgTransId transId,
-U8 siId
+uint8_t siId
)
#else
S16 cmPkRgrWarningSiStopReq(pst,spId, transId, siId)
Pst *pst;
SpId spId;
RgrCfgTransId transId;
-U8 siId;
+uint8_t siId;
#endif
{
Buffer *mBuf = NULLP;
#endif
{
SpId spId;
- U8 siId;
+ uint8_t siId;
RgrCfgTransId transId;
Pst* pst,
SuId suId,
RgrCfgTransId transId,
-U8 siId,
-U8 status
+uint8_t siId,
+uint8_t status
)
#else
S16 cmPkRgrWarningSiCfgCfm(pst, suId, transId, siId, status)
Pst* pst;
SuId suId;
RgrCfgTransId transId;
-U8 siId;
-U8 status;
+uint8_t siId;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
#endif
{
SuId suId;
- U8 siId;
+ uint8_t siId;
RgrCfgTransId transId;
- U8 status;
+ uint8_t status;
if (SUnpkS16(&suId, mBuf) != ROK)
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->numCqiRept, mBuf);
for (idx = 0; idx < param->numCqiRept; idx++)
#endif
{
S8 idx;
- U8 count;
+ uint8_t count;
CMCHKPK(oduUnpackUInt8, param->cqi[0], mBuf);
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->numSubBand, mBuf);
for (idx = 0; idx < param->numSubBand; idx++)
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKPK(cmPkLteCellId, param->cellId, mBuf);
CMCHKPK(oduUnpackUInt16, param->bw, mBuf);
/* dsfr_pal_fixes ** 21-March-2013 ** SKS */
TknStrOSXL *tknStr;
- U16 ndx;
+ uint16_t ndx;
CMCHKUNPK(oduPackUInt32, ¶m->type, mBuf);
{
for(idx = RGR_ABS_PATTERN_LEN -1 ; idx >= 0; idx--)
{
- CMCHKUNPK(oduPackUInt32, ¶m->u.absLoadInfo[(U8)idx], mBuf);
+ CMCHKUNPK(oduPackUInt32, ¶m->u.absLoadInfo[(uint8_t)idx], mBuf);
}
}
else
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
- CMCHKUNPK(oduPackUInt8, (U8 *)¶m->pAPrsnt, mBuf);
+ CMCHKUNPK(oduPackUInt8, (uint8_t *)¶m->pAPrsnt, mBuf);
if (param->pAPrsnt)
{
- CMCHKUNPK(oduPackUInt32, (U32*)&tmpEnum, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)&tmpEnum, mBuf);
param->pA = (RgrUeDlPwrCntrlPaCfg) tmpEnum;
}
CMCHKPK(cmPkRgrUePdschDedCfg, ¶m->uePdschDedCfg, mBuf);
#endif
CMCHKPK(cmPkRgrUeDlCqiCfg,¶m->ueSCellDlCqiCfg, mBuf);
- CMCHKPK(cmPkTknU32, ¶m->sCellDeActTmr, mBuf);
+ CMCHKPK(cmPkTknUInt32, ¶m->sCellDeActTmr, mBuf);
CMCHKPK(oduUnpackUInt16, param->sCellId, mBuf);
CMCHKPK(oduUnpackUInt8, param->sCellIdx, mBuf);
S8 idx;
for(idx = param->numSCells - 1; idx >= 0; idx--)
{
- CMCHKPK(cmPkRgrUeSecCellCfg, ¶m->ueSCellDedCfg[(U8)idx],mBuf);
+ CMCHKPK(cmPkRgrUeSecCellCfg, ¶m->ueSCellDedCfg[(uint8_t)idx],mBuf);
}
CMCHKPK(oduUnpackUInt8, param->numSCells, mBuf);
{
CMCHKUNPK(oduPackUInt8, ¶m->sCellIdx, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->sCellId, mBuf);
- CMCHKUNPK(cmUnpkTknU32, ¶m->sCellDeActTmr, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt32, ¶m->sCellDeActTmr, mBuf);
CMCHKUNPK(cmUnpkRgrUeDlCqiCfg, ¶m->ueSCellDlCqiCfg, mBuf);
#ifdef TFU_UPGRADE
CMCHKUNPK(cmUnpkRgrUePdschDedCfg, ¶m->uePdschDedCfg, mBuf);
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->useExtBSRSizes, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numSCells, mBuf);
{
for(idx = param->u.format1Bcs.sCellAckN1ResTb2Count - 1; idx >=0 ;idx--)
{
- CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb2[(U8)idx], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb2[(uint8_t)idx], mBuf);
}
CMCHKPK(oduUnpackUInt8, param->u.format1Bcs.sCellAckN1ResTb2Count, mBuf);
for(idx = param->u.format1Bcs.sCellAckN1ResTb1Count - 1; idx >=0 ;idx--)
{
- CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb1[(U8)idx], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->u.format1Bcs.sCellAckN1ResTb1[(uint8_t)idx], mBuf);
}
CMCHKPK(oduUnpackUInt8, param->u.format1Bcs.sCellAckN1ResTb1Count, mBuf);
{
for(idx = param->u.format3.sCellAckN3ResAntP1Count - 1; idx >=0 ;idx--)
{
- CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP1[(U8)idx], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP1[(uint8_t)idx], mBuf);
}
CMCHKPK(oduUnpackUInt8, param->u.format3.sCellAckN3ResAntP1Count, mBuf);
for(idx = param->u.format3.sCellAckN3ResAntP0Count- 1; idx >=0 ;idx--)
{
- CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP0[(U8)idx], mBuf);
+ CMCHKPK(oduUnpackUInt16, param->u.format3.sCellAckN3ResAntP0[(uint8_t)idx], mBuf);
}
CMCHKPK(oduUnpackUInt8, param->u.format3.sCellAckN3ResAntP0Count, mBuf);
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
- CMCHKUNPK(oduPackUInt32, (U32*)¶m->pucchFormatType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t*)¶m->pucchFormatType, mBuf);
//if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS)
if (param->pucchFormatType == RG_SCH_UCI_FORMAT1B_CS || param->pucchFormatType == RG_SCH_UCI_FORMAT1A_1B)
{
Buffer *mBuf;
#endif
{
- U32 tmpEnum;
+ uint32_t tmpEnum;
CMCHKUNPK(oduPackUInt32, &tmpEnum, mBuf);
RGR_SI_PERD_512 = 512 /**< SI Periodicity 512 RF */
} RgrSiPeriodicity;
-/*rgr_x_001.main_11 ccpu00115364 ADD changed U8 to enum for modPrd*/
+/*rgr_x_001.main_11 ccpu00115364 ADD changed uint8_t to enum for modPrd*/
/*modification period = (modificationPeriodCoeff * defaultPagingCycle)%m*/
/*where modificationPeriodCoeff={2,4,8,16} defaultPagingCycle={32,64,128,256}*/
/**
/** @brief Transaction ID between MAC and RRM */
typedef struct rgrCfgTransId
{
- U8 trans[RGR_CFG_TRANSID_SIZE]; /*!< RRM Transaction ID */
+ uint8_t trans[RGR_CFG_TRANSID_SIZE]; /*!< RRM Transaction ID */
} RgrCfgTransId;
/** @brief Downlink HARQ configuration per Cell */
typedef struct rgrDlHqCfg
{
- U8 maxDlHqTx; /*!< Maximum number of DL HARQ Transmissions.
+ uint8_t maxDlHqTx; /*!< Maximum number of DL HARQ Transmissions.
Minimum value is 1, maximum can be defined
by the user */
- U8 maxMsg4HqTx; /*!< Maximum msg4(Random Access) HARQ Transmissions
+ uint8_t maxMsg4HqTx; /*!< Maximum msg4(Random Access) HARQ Transmissions
Minimum value is 1, Maximum can be defined by
the user */
} RgrDlHqCfg;
typedef struct rgrRntiCfg
{
CmLteRnti startRnti; /*!< Start RNTI for the range managed by MAC */
- U16 size; /*!< Indicates contiguous range of RNTI managed by
+ uint16_t size; /*!< Indicates contiguous range of RNTI managed by
MAC */
} RgrRntiCfg;
/** @brief Downlink common channel code rate configuration per cell */
typedef struct rgrDlCmnCodeRateCfg
{
- U16 bcchPchRaCodeRate; /*!< BCCH on DLSCH, PCH and RARsp coding rate.
+ uint16_t bcchPchRaCodeRate; /*!< BCCH on DLSCH, PCH and RARsp coding rate.
* This defines the actual number of bits per 1024
* physical layer bits */
- U16 pdcchCodeRate; /*!< PDCCH code rate defines actual number of bits
+ uint16_t pdcchCodeRate; /*!< PDCCH code rate defines actual number of bits
* per 1024 physical layer bits. This is used to
* calculate aggregation level for PDCCH meant
* for broadcasting RNTIs */
- U8 ccchCqi; /*!< Default CQI to be used for Msg4 in case where
+ uint8_t ccchCqi; /*!< Default CQI to be used for Msg4 in case where
* no CQI is available for the UE. ccchCqi ranges
* from 1 to 15.*/
} RgrDlCmnCodeRateCfg;
/** @brief Control Format Indicator (CFI) configuration per cell */
typedef struct rgrCfiCfg
{
- U8 cfi; /*!< CFI for PDCCH: a value in set {1,2,3} */
+ uint8_t cfi; /*!< CFI for PDCCH: a value in set {1,2,3} */
} RgrCfiCfg;
/** @brief PUSCH sub-band configuration per cell */
typedef struct rgrPuschSubBandCfg
{
- U8 subbandStart; /*!< Sub-band start */
- U8 numSubbands; /*!< Number of equal sized sub-bands */
- U8 size; /*!< Size of a sub-band */
- U8 dmrs[RGR_MAX_SUBBANDS]; /*!< DMRS information per sub-band */
+ uint8_t subbandStart; /*!< Sub-band start */
+ uint8_t numSubbands; /*!< Number of equal sized sub-bands */
+ uint8_t size; /*!< Size of a sub-band */
+ uint8_t dmrs[RGR_MAX_SUBBANDS]; /*!< DMRS information per sub-band */
} RgrPuschSubBandCfg;
/** @brief Uplink common channel code rate configuration per cell */
typedef struct rgrUlCmnCodeRateCfg
{
- U8 ccchCqi; /*!< CCCH CQI index, also used as default
+ uint8_t ccchCqi; /*!< CCCH CQI index, also used as default
* initial CQI for UEs */
} RgrUlCmnCodeRateCfg;
/** @brief Target Uplink CQI to achieve through group power control configured per cell */
typedef struct rgrUlTrgCqiCfg
{
- U8 trgCqi; /*!< Target UL CQI to be achieved through power
+ uint8_t trgCqi; /*!< Target UL CQI to be achieved through power
control.Range is defined is between 1 to 15 */
} RgrUlTrgCqiCfg;
/**
@brief Bandwidth configuration per cell */
typedef struct rgrBwCfg
{
- U8 dlTotalBw; /*!< Total Dowlink Bandwidth */
- U8 ulTotalBw; /*!< Total Uplink Bandwidth */
+ uint8_t dlTotalBw; /*!< Total Dowlink Bandwidth */
+ uint8_t ulTotalBw; /*!< Total Uplink Bandwidth */
} RgrBwCfg;
/**
@brief PUCCH configuration per cell */
typedef struct rgrPucchCfg
{
- U8 resourceSize; /*!< PUCCH resource-size or N^(2)_RB (in RBs) */
- U16 n1PucchAn; /*!< N^(1)_PUCCH */
- U8 deltaShift; /*!< Delta Shift for PUCCH: a value in set {1,2,3} */
- U8 cyclicShift; /*!< Cyclic Shift for PUCCH (N^(1)_CS): a value in
+ uint8_t resourceSize; /*!< PUCCH resource-size or N^(2)_RB (in RBs) */
+ uint16_t n1PucchAn; /*!< N^(1)_PUCCH */
+ uint8_t deltaShift; /*!< Delta Shift for PUCCH: a value in set {1,2,3} */
+ uint8_t cyclicShift; /*!< Cyclic Shift for PUCCH (N^(1)_CS): a value in
range [0-7] */
- U8 maxPucchRb; /*!< The max number of RBs for PUCCH. This will be
+ uint8_t maxPucchRb; /*!< The max number of RBs for PUCCH. This will be
used to limit the max CFI value when dynamic
CFI feature is enabled. If there is no
limitation on the max PUCCH RBs, this variable
RgrSrsCfgPrd srsCfgPrdEnum; /*!< SRS configuration period (in subframes).*/
RgrSrsBwCfg srsBwEnum; /*!< SRS Bandwidth configuration per cell.
Range - [0-7] */
- U8 srsSubFrameCfg;/*!< SRS subframe configuration index per cell.
+ uint8_t srsSubFrameCfg;/*!< SRS subframe configuration index per cell.
Range - [0-15] */
} RgrSrsCfg;
/**
@brief RACH configuration per cell */
typedef struct rgrRachCfg
{
- U8 preambleFormat; /*!< RACH Preamble format: a value in set {0,1,2,3} */
- U8 raWinSize; /*!< RA Window size */
+ uint8_t preambleFormat; /*!< RACH Preamble format: a value in set {0,1,2,3} */
+ uint8_t raWinSize; /*!< RA Window size */
/** @brief Ocassion at Which Random Access Is Expected */
struct raOccasionS
{
- U8 size; /*!< Number of subframe numbers */
+ uint8_t size; /*!< Number of subframe numbers */
RgrRaSfn sfnEnum; /*!< System Frame Number */
- U8 subFrameNum[RGR_MAX_SUBFRAME_NUM]; /*!< Subframe numbers */
+ uint8_t subFrameNum[RGR_MAX_SUBFRAME_NUM]; /*!< Subframe numbers */
} raOccasion; /*!< Random access occasions */
- U8 maxMsg3Tx; /*!< Maximum number of message 3 transmissions */
- U8 numRaPreamble; /*!< Number of RA Preambles */
- U8 sizeRaPreambleGrpA; /*!< Size of RA Preamble in Group A */
- U16 msgSizeGrpA; /*!< MESSAGE_SIZE_GROUP_A */
- U8 prachResource; /*!< N^RA_PRB: PRACH resource for random access */
+ uint8_t maxMsg3Tx; /*!< Maximum number of message 3 transmissions */
+ uint8_t numRaPreamble; /*!< Number of RA Preambles */
+ uint8_t sizeRaPreambleGrpA; /*!< Size of RA Preamble in Group A */
+ uint16_t msgSizeGrpA; /*!< MESSAGE_SIZE_GROUP_A */
+ uint8_t prachResource; /*!< N^RA_PRB: PRACH resource for random access */
/**@name RGR_V1 */
/**@{ */
#ifdef RGR_V1
/* rgr_x_001.main_7: [ccpu00112372] Added contention resolution timer */
- U8 contResTmr; /*!< Contention resolution timer */
+ uint8_t contResTmr; /*!< Contention resolution timer */
#endif
/**@} */
} RgrRachCfg;
*/
typedef struct rgrSiCfg
{
- U8 siWinSize; /*!< SI window size */
- U8 retxCnt; /*!< Retransmission count */
+ uint8_t siWinSize; /*!< SI window size */
+ uint8_t retxCnt; /*!< Retransmission count */
/* rgr_x_001.main_5-ADD-Added for SI Enhancement. */
/**@name RGR_SI_SCH */
/**@{ */
#ifdef RGR_SI_SCH
-/*rgr_x_001.main_11 ccpu00115364 MOD changed U8 to enum for modPrd*/
+/*rgr_x_001.main_11 ccpu00115364 MOD changed uint8_t to enum for modPrd*/
RgrModPeriodicity modPrd; /*!< Modificiation Period for SI */
- U8 numSi; /*!<Number of SIs, SI Id starts from 1 */
+ uint8_t numSi; /*!<Number of SIs, SI Id starts from 1 */
RgrSiPeriodicity siPeriodicity[RGR_MAX_NUM_SI]; /*!<Periodicities of SIs */
- U16 minPeriodicity; /*!< Minimum Periodicity Configured */
+ uint16_t minPeriodicity; /*!< Minimum Periodicity Configured */
#endif/*RGR_SI_SCH*/
/**@} */
} RgrSiCfg;
typedef struct rgrTpcRntiCfg
{
CmLteRnti startTpcRnti; /*!< Start RNTI for TPC */
- U16 size; /*!< Indicates contiguous range of RNTI */
+ uint16_t size; /*!< Indicates contiguous range of RNTI */
} RgrTpcRntiCfg;
/* rgr_x_001.main_6 : documentation update. */
* @brief Cell-specific hopping configuration */
typedef struct rgrPuschCfg
{
- U8 numSubBands; /*!< Number of sub-bands
+ uint8_t numSubBands; /*!< Number of sub-bands
Currently this is unused parameter */
Bool isIntraHop; /*!< Hopping mode inter/intra subframe
Currently this is unused parameter */
- U8 hopOffst; /*!< Hopping offset {0 ... 98}
+ uint8_t hopOffst; /*!< Hopping offset {0 ... 98}
Currently this is unused parameter*/
} RgrPuschCfg;
typedef struct rgrCodeBookRstCfg
{
Bool pres; /*!< Code Book restriction present ?*/
- U32 pmiBitMap[2]; /*!< Array for number of Bits for ports and TX Mode*/
+ uint32_t pmiBitMap[2]; /*!< Array for number of Bits for ports and TX Mode*/
} RgrCodeBookRstCfg;
/**
* @brief Range of PDCCH Order Preamble Set managed by MAC */
typedef struct rgrPreambleSetCfg
{
Bool pres; /*!< Indicates if other configuration fields are valid */
- U8 start; /*!< Start Preamble ID for the range managed by MAC */
- U8 size; /*!< Indicates contiguous range of premables managaed by
+ uint8_t start; /*!< Start Preamble ID for the range managed by MAC */
+ uint8_t size; /*!< Indicates contiguous range of premables managaed by
MAC */
} RgrPreambleSetCfg;
CM_LTE_LCH_CCCH
CM_LTE_LCH_DCCH
CM_LTE_LCH_DTCH */
- U8 dir; /*!< Indicates Direction. Direction can take following
+ uint8_t dir; /*!< Indicates Direction. Direction can take following
values:
RGR_DIR_TX
RGR_DIR_RX
@brief RGR configuration for DLFS scheduler */
typedef struct rgrDlfsCfg
{
- U8 isDlFreqSel; /*!< Indicates if resource allocation is frequency
+ uint8_t isDlFreqSel; /*!< Indicates if resource allocation is frequency
selective or not */
- U8 thresholdCqi; /*!< This value is used by the DL frequency
+ uint8_t thresholdCqi; /*!< This value is used by the DL frequency
selective scheduler. This is the threshold
value below which the sub-band is not
considered for allocation for a frequency
@brief RGR RB range for SFR */
typedef struct rgrSfrRbRange
{
- U8 startRb; /*<! Start RB for cell edge user */
- U8 endRb; /*<! End RB for cell edge user */
+ uint8_t startRb; /*<! Start RB for cell edge user */
+ uint8_t endRb; /*<! End RB for cell edge user */
} RgrSfrRbRange;
#ifdef TFU_UPGRADE
typedef struct rgrAbsConfig
{
RgrFeatureStatus status; /*!< Indicate feature is enabled or disabled */
- U32 absPatternType; /*!< Indicate it as Mute and/or Transmit type */
- U8 absPattern[RGR_ABS_PATTERN_LEN]; /*!< ABS pattern */
- U32 absLoadPeriodicity; /*!< ABS Load Ind periodicity in msec */
+ uint32_t absPatternType; /*!< Indicate it as Mute and/or Transmit type */
+ uint8_t absPattern[RGR_ABS_PATTERN_LEN]; /*!< ABS pattern */
+ uint32_t absLoadPeriodicity; /*!< ABS Load Ind periodicity in msec */
} RgrAbsConfig;
/**
@brief RGR configuration for LTE Advanced feature */
typedef struct rgrLteAdvancedCellConfig
{
- U32 pres; /*!< To indicate presence of feature config */
+ uint32_t pres; /*!< To indicate presence of feature config */
RgrAbsConfig absCfg; /*!< Configuration of ABS feature */
RgrSfrConfig sfrCfg; /*!< Configuration of SFR feature */
RgrDsfrConfig dsfrCfg;/*!< Configuration of DSFR feature */
/** @brief PRACH resource information for TDD */
typedef struct rgrTddPrachInfo
{
- U8 freqIdx; /*!< Frequency Index */
+ uint8_t freqIdx; /*!< Frequency Index */
RgrRaSfn sfn; /*!< Even/Odd/All Radio Frames */
- U8 halfFrm; /*!< First/Second Half Frame */
- U8 ulStartSfIdx; /*!< Uplink Start Subframe Index;
+ uint8_t halfFrm; /*!< First/Second Half Frame */
+ uint8_t ulStartSfIdx; /*!< Uplink Start Subframe Index;
RGR_TDD_SPL_UL_IDX must be used
to configure special subframes */
} RgrTddPrachInfo;
/** @brief Set of PRACH information for TDD */
typedef struct rgrTddPrachRscInfo
{
- U8 numRsc; /*!< Number of PRACH resources*/
+ uint8_t numRsc; /*!< Number of PRACH resources*/
RgrTddPrachInfo prachInfo[RGR_TDD_MAX_FREQ_RSRC]; /*!< PRACH information */
} RgrTddPrachRscInfo;
#endif /* LTE_TDD */
/** @brief set of PF Scheduler Parameters */
typedef struct rgrEnbPfs
{
- U8 tptCoeffi; /*!< Downlink Throughput Coeffiecient
+ uint8_t tptCoeffi; /*!< Downlink Throughput Coeffiecient
Range 0 -10 */
- U8 fairCoeffi; /*!< Downlink Fairness Coeffiecient
+ uint8_t fairCoeffi; /*!< Downlink Fairness Coeffiecient
Range 0 -10 */
- U32 qciWgt[RGR_MAX_NUM_QCI]; /*!< Downlink Qci Weights */
+ uint32_t qciWgt[RGR_MAX_NUM_QCI]; /*!< Downlink Qci Weights */
} RgrEnbPfs;
/**
struct rachOvrLd
{
Bool backOffEnb; /*!< backoff RACH during overlaod */
- U8 backOffVal; /*!< backoff value during overload */
+ uint8_t backOffVal; /*!< backoff value during overload */
}rachOvrLd;
/** @brief CPU OverLoad Cntrl Cmd Description */
struct cpuOvrLd
{
- U8 instruction; /*!< CPU Over Load Cntrl Instruction */
+ uint8_t instruction; /*!< CPU Over Load Cntrl Instruction */
}cpuOvrLd;
}cmdDesc;
} RgrCellCntrlCmdCfg;
*/
typedef struct macSchedGnbCfg
{
- U8 numTxAntPorts; /*!< Number of Tx antenna ports */
- U8 ulSchdType; /*!< Indicates which UL scheduler to use, range
+ uint8_t numTxAntPorts; /*!< Number of Tx antenna ports */
+ uint8_t ulSchdType; /*!< Indicates which UL scheduler to use, range
* is 0..(number of schedulers - 1) */
- U8 dlSchdType; /*!< Indicates which DL scheduler to use, range
+ uint8_t dlSchdType; /*!< Indicates which DL scheduler to use, range
* is 0..(number of schedulers - 1) */
- U8 numCells; /*!< Max number of cells */
- U8 maxUlUePerTti; /*!< Max number of UE in UL per TTI */
- U8 maxDlUePerTti; /*!< Max number of UE in DL per TTI */
+ uint8_t numCells; /*!< Max number of cells */
+ uint8_t maxUlUePerTti; /*!< Max number of UE in UL per TTI */
+ uint8_t maxDlUePerTti; /*!< Max number of UE in DL per TTI */
}MacSchedGnbCfg;
/**
* @brief
*/
typedef struct rgrSchedEnbCfg
{
- U8 numTxAntPorts; /*!< Number of Tx antenna ports */
- U8 dlSchdType; /*!< Indicates which DL scheduler to use, range
+ uint8_t numTxAntPorts; /*!< Number of Tx antenna ports */
+ uint8_t dlSchdType; /*!< Indicates which DL scheduler to use, range
* is 0..(number of schedulers - 1) */
union rgrDlSchInfoS
{
RgrEnbPfs dlPfs; /*!< Information related to DL PFS
Scheduler */
} dlSchInfo;
- U8 ulSchdType; /*!< Indicates which UL scheduler to use, range
+ uint8_t ulSchdType; /*!< Indicates which UL scheduler to use, range
is 0..(number of schedulers - 1) */
union rgrUlSchInfoS
{
There is no range defined for the
values, However the product of all
three priorities must not exceed the
- range of U32 */
+ range of uint32_t */
} ulSchInfo;
RgrCellAccsMode accsMode; /*!< Cell Access Mode */
#ifdef RG_5GTF
/* SPS_DEV */
typedef struct rgrSpsCellCfg
{
- U8 maxSpsDlBw; /*!< BW used of SPS Scheduling */
+ uint8_t maxSpsDlBw; /*!< BW used of SPS Scheduling */
- U16 maxSpsUePerDlSf; /*!< Maximum DL SPS UEs that can be
+ uint16_t maxSpsUePerDlSf; /*!< Maximum DL SPS UEs that can be
scheduled in a TTI */
- U16 maxSpsUePerUlSf; /*!< Maximum UL SPS UEs that can be scheduled
+ uint16_t maxSpsUePerUlSf; /*!< Maximum UL SPS UEs that can be scheduled
in a TTI */
} RgrSpsCellCfg;
*/
typedef struct rgrCellCsgParamCfg
{
- U8 minDlResNonCsg; /*!< Min PDSCH Resources for Non-CSG Members */
- U8 minUlResNonCsg; /*!< Min PUSCH Resources for Non-CSG Members */
+ uint8_t minDlResNonCsg; /*!< Min PDSCH Resources for Non-CSG Members */
+ uint8_t minUlResNonCsg; /*!< Min PUSCH Resources for Non-CSG Members */
} RgrCellCsgParamCfg;
/** @brief LAA Cell Configuration */
/* emtc */
typedef struct rgrEmtcSiSchedInfo
{
- U8 emtcSiNarrowBand; /*!< narrowband assigned to SI */
- U16 emtcSiTbs; /*!< tbs value for SI */
+ uint8_t emtcSiNarrowBand; /*!< narrowband assigned to SI */
+ uint16_t emtcSiTbs; /*!< tbs value for SI */
}RgrEmtcSiSchedInfo;
typedef struct rgrEmtcPrmbleMap
{
- U8 firstPreamble; /*!< for each CE mode, starting preamble */
- U8 lastPreamble; /*!< for each CE mode, starting preamble */
+ uint8_t firstPreamble; /*!< for each CE mode, starting preamble */
+ uint8_t lastPreamble; /*!< for each CE mode, starting preamble */
}RgrEmtcPrmbleMap;
typedef struct rgrEmtcRachCElevelInfoLst
{
- U8 emtcRarHopping; /*!< by defualt off */
- U16 raEmtcWinSize; /*!< RA Window size */
- U16 raEmtcContResTmr; /*!< Contension Resolution */
- U16 emtcPreambleTransMax; /*!< PreambleTransMax */
+ uint8_t emtcRarHopping; /*!< by defualt off */
+ uint16_t raEmtcWinSize; /*!< RA Window size */
+ uint16_t raEmtcContResTmr; /*!< Contension Resolution */
+ uint16_t emtcPreambleTransMax; /*!< PreambleTransMax */
RgrEmtcPrmbleMap emtcPreambleMap; /*!< preamble mapping Info */
}RgrEmtcRachCElevelInfoLst;
typedef struct rgrEmtcRachCfg
{
- U8 emtcCeLvlSupported;
+ uint8_t emtcCeLvlSupported;
RgrEmtcRachCElevelInfoLst ceLevelInfo[RGR_MAX_CE_LEVEL]; /* for all CE levels 0,1,2,3*/
}RgrEmtcRachCfg;
typedef struct rgrEmtcPdschCfg
{
- U16 emtcMaxRepCeModeA; /*!< max repetition for CE ModeA */
- U16 emtcMaxRepCeModeB; /*!< max repetition for CE ModeB */
+ uint16_t emtcMaxRepCeModeA; /*!< max repetition for CE ModeA */
+ uint16_t emtcMaxRepCeModeB; /*!< max repetition for CE ModeB */
}RgrEmtcPdschCfg;
typedef struct rgrEmtcPuschCfg
{
- U16 emtcMaxRepCeModeA; /*!< max repetition for CE ModeA */
- U16 emtcMaxRepCeModeB; /*!< max repetition for CE ModeB */
- U8 emtcHoppingOffset; /*!< Hopping offset */
+ uint16_t emtcMaxRepCeModeA; /*!< max repetition for CE ModeA */
+ uint16_t emtcMaxRepCeModeB; /*!< max repetition for CE ModeB */
+ uint8_t emtcHoppingOffset; /*!< Hopping offset */
}RgrEmtcPuschCfg;
typedef struct rgrEmtcPrachCEParamLst
{
- U8 emtcPrachCfgIdx; /*!< Prach config index */
- U8 emtcPrachFreqOffset; /*!< Prach Frequency Offset */
- U16 emtcPrachStartSubFrame; /*!< Starting sub frame */
- U8 emtcMaxPremAttemptCE; /*!< max preamble attempt CE */
- U8 emtcNumRepPerPreambleAtt;/*!< num of repetition per preamble attempt*/
- U8 emtcNumMpdcchNBtoMonitor;/*!< num of Mpddch NB to monitor */
- U8 emtcMpdcchNBtoMonitor[RGR_MAX_NUM_MPDCCH_MONITOR];/*!< Mpddch NB to monitor */
- U16 emtcMpdcchNumRep; /*!< num of Mpddch Number of repetition */
- U8 emtcPrachHoppingCfg; /*!< num of Prach Hopping config */
+ uint8_t emtcPrachCfgIdx; /*!< Prach config index */
+ uint8_t emtcPrachFreqOffset; /*!< Prach Frequency Offset */
+ uint16_t emtcPrachStartSubFrame; /*!< Starting sub frame */
+ uint8_t emtcMaxPremAttemptCE; /*!< max preamble attempt CE */
+ uint8_t emtcNumRepPerPreambleAtt;/*!< num of repetition per preamble attempt*/
+ uint8_t emtcNumMpdcchNBtoMonitor;/*!< num of Mpddch NB to monitor */
+ uint8_t emtcMpdcchNBtoMonitor[RGR_MAX_NUM_MPDCCH_MONITOR];/*!< Mpddch NB to monitor */
+ uint16_t emtcMpdcchNumRep; /*!< num of Mpddch Number of repetition */
+ uint8_t emtcPrachHoppingCfg; /*!< num of Prach Hopping config */
}RgrEmtcPrachCEParamLst;
typedef struct rgrEmtcPrachCfg
{
- U8 emtcMpdcchStartSFCssRaFdd; /*!< mdpcch start SubFrame Ra type2 */
- U8 emtcPrachHopingOffset; /*!< prach hopping offset value */
- U8 emtcInitialCElevel; /*!< Initial CE level to start with */
+ uint8_t emtcMpdcchStartSFCssRaFdd; /*!< mdpcch start SubFrame Ra type2 */
+ uint8_t emtcPrachHopingOffset; /*!< prach hopping offset value */
+ uint8_t emtcInitialCElevel; /*!< Initial CE level to start with */
RgrEmtcPrachCEParamLst emtcPrachCEparmLst[RGR_MAX_CE_LEVEL];
}RgrEmtcPrachCfg;
/*Changes by Simran*/
typedef struct rgrFddDownlinkOrTddSubframeBitmapLC
{
- U8 sfnPtnChoice;
+ uint8_t sfnPtnChoice;
union
{
- U16 ptn10;
- U32 ptn40[2];
+ uint16_t ptn10;
+ uint32_t ptn40[2];
}u;
}RgrFddDownlinkOrTddSubframeBitmapLC;
{
Bool siHoppingEnable; /*!< SI Hopping enabled or not */
RgrModPeriodicity modPrd; /*!< Modificiation Period for SI */
- U8 siWinSizeBr; /*!< SI window size */
- U8 sib1Repetition; /*!< sib1-br repetition */
- U8 siRepetition; /*!< SI repetition pattern
+ uint8_t siWinSizeBr; /*!< SI window size */
+ uint8_t sib1Repetition; /*!< sib1-br repetition */
+ uint8_t siRepetition; /*!< SI repetition pattern
everyRF,every2ndRF,every4thRF,every8thRF*/
- U16 startSymbolLc;
+ uint16_t startSymbolLc;
/*Changes by Simran*/
RgrFddDownlinkOrTddSubframeBitmapLC fddDLOrTddSfBitmapLC;
- //U16 fddDlOrTddSfBitmapBR; /*!< 10 bit value for sending SI*/
+ //uint16_t fddDlOrTddSfBitmapBR; /*!< 10 bit value for sending SI*/
RgrEmtcSiSchedInfo schdInfo[RGR_MAX_NUM_SI];
- U8 numSi; /*!<Number of SIs, SI Id starts from 1 */
+ uint8_t numSi; /*!<Number of SIs, SI Id starts from 1 */
RgrSiPeriodicity siPeriodicity[RGR_MAX_NUM_SI]; /*!<Periodicities of SIs */
} RgrEmtcSiCfg;
typedef struct rgrEmtcPucchCfg
{
- U16 emtcN1pucchAnInfoLst[RGR_MAX_CE_LEVEL]; /*!< Max CE level is 4 */
- U8 emtcPucchNumRepCEMsg4Lvl0; /*!< update the level 0 */
- U8 emtcPucchNumRepCEMsg4Lvl1; /*!< update the level 1 */
- U8 emtcPucchNumRepCEMsg4Lvl2; /*!< update the level 2 */
- U8 emtcPucchNumRepCEMsg4Lvl3; /*!< update the level 3 */
+ uint16_t emtcN1pucchAnInfoLst[RGR_MAX_CE_LEVEL]; /*!< Max CE level is 4 */
+ uint8_t emtcPucchNumRepCEMsg4Lvl0; /*!< update the level 0 */
+ uint8_t emtcPucchNumRepCEMsg4Lvl1; /*!< update the level 1 */
+ uint8_t emtcPucchNumRepCEMsg4Lvl2; /*!< update the level 2 */
+ uint8_t emtcPucchNumRepCEMsg4Lvl3; /*!< update the level 3 */
}RgrEmtcPucchCfg;
typedef struct rgrEmtcRntiCfg
{
CmLteRnti rntiCeModeAStart; /*!< EMTC Start RNTI for the range managed by MAC */
CmLteRnti rntiCeModeARange; /*!< EMTC Range of RNTI for the CEMODE A */
- U16 rntiCeModeBStart; /*!< EMTC Start RNTI for the range managed by MAC */
+ uint16_t rntiCeModeBStart; /*!< EMTC Start RNTI for the range managed by MAC */
CmLteRnti rntiCeModeBRange; /*!< EMTC Range of RNTI for the CEMODE B */
- U16 size; /*!< Indicates contiguous range of RNTI managed by EMTC
+ uint16_t size; /*!< Indicates contiguous range of RNTI managed by EMTC
MAC */
} RgrEmtcRntiCfg;
typedef struct rgrEmtcCellCfg
{
- U16 pci; /*!< Physical Cell ID */
- U32 emtcT300Tmr; /*!< T300 timer as per Rel13 */
- U32 emtcT301Tmr; /*!< T301 timer as per Rel13 */
+ uint16_t pci; /*!< Physical Cell ID */
+ uint32_t emtcT300Tmr; /*!< T300 timer as per Rel13 */
+ uint32_t emtcT301Tmr; /*!< T301 timer as per Rel13 */
RgrEmtcSiCfg emtcSiCfg; /*!< SI configuration */
RgrEmtcRachCfg emtcRachCfg; /*!< Rach config as per Rel13*/
RgrEmtcPdschCfg emtcPdschCfg; /*!< Pdsch config as per Rel13*/
RgrEmtcPrachCfg emtcPrachCfg; /*!< Prach config as per Rel13*/
RgrEmtcPucchCfg emtcPucchCfg; /*!< Pucch config as per Rel13*/
RgrEmtcRntiCfg emtcMacRnti;
- U8 emtcPdschNbIdx;
- U8 emtcMpdcchNbIdx;
- U8 emtcPuschNbIdx;
+ uint8_t emtcPdschNbIdx;
+ uint8_t emtcMpdcchNbIdx;
+ uint8_t emtcPuschNbIdx;
}RgrEmtcCellCfg;
#endif
typedef struct rgr5gtfCellCfg
{
RgSchSfType dynConfig[MAX_5GTF_SUBFRAME_INFO];
- U8 uePerGrp;
- U8 ueGrpPerTti;
- U8 numUes;
- U8 numOfCC;
- U8 bwPerCC;
- U8 cfi;
+ uint8_t uePerGrp;
+ uint8_t ueGrpPerTti;
+ uint8_t numUes;
+ uint8_t numOfCC;
+ uint8_t bwPerCC;
+ uint8_t cfi;
}Rgr5gtfCellCfg;
#endif
typedef struct rgrSlotCfg
{
Bool duplexMode; /*!< FDD:0, TDD:1 */
-U32 slotFrmt[RGR_MAX_SLOTS_IN_10MS]; /*!< Least significant 2 bits indicates:
+uint32_t slotFrmt[RGR_MAX_SLOTS_IN_10MS]; /*!< Least significant 2 bits indicates:
00-DL, 01-UL, 10-Flexi, 11-Mixed
Rest 28 bits indicates 14 symbols
types(DL/UL/Flexi) 2 bits for
#if 0
CmLteCellId cellId; /*!< Cell ID */
- U16 pci; /*!< Physical Cell ID */
- U8 maxMsg3PerUlSlot; /*!< Maximum MSG3 that may be scheduled
+ uint16_t pci; /*!< Physical Cell ID */
+ uint8_t maxMsg3PerUlSlot; /*!< Maximum MSG3 that may be scheduled
per uplink slot */
- U8 maxUePerUlSlot; /*!<Maximum UE scheduled per UL slot */
- U8 maxUePerDlSlot; /*!<Maximum UE scheduled per DL in a TTI */
+ uint8_t maxUePerUlSlot; /*!<Maximum UE scheduled per UL slot */
+ uint8_t maxUePerDlSlot; /*!<Maximum UE scheduled per DL in a TTI */
Bool isCpUlExtend; /*!< Cyclic prefix: TRUE-extended,
FALSE-normal for UL */
Bool isCpDlExtend; /*!< Cyclic prefix: TRUE-extended,
RgrPreambleSetCfg macPreambleSet; /*!< Range of PDCCH Order Preamble IDs
to be managed by MAC */
- U16 bcchTxPwrOffset; /*!< Tx Pwr Offset for BCCH tx on PDSCH.
+ uint16_t bcchTxPwrOffset; /*!< Tx Pwr Offset for BCCH tx on PDSCH.
Offset to the reference signal
power. Value: 0 -> 10000,
representing -6 dB to 4 dB in 0.001
dB steps */
- U16 pcchTxPwrOffset; /*!< Tx Pwr Offset for PCCH tx.
+ uint16_t pcchTxPwrOffset; /*!< Tx Pwr Offset for PCCH tx.
Offset to the reference signal
power. Value: 0 -> 10000,
representing -6 dB to 4 dB in 0.001
dB steps */
- U16 rarTxPwrOffset; /*!< Tx Pwr Offset for RAR tx.
+ uint16_t rarTxPwrOffset; /*!< Tx Pwr Offset for RAR tx.
Offset to the reference signal
power. Value: 0 -> 10000,
representing -6 dB to 4 dB in 0.001
dB steps */
- U8 nrMu; /*!<Indicates the number of Slot for a radio frame*/
- U8 tbScalingField;/*!< TB Scaling Factor used while
+ uint8_t nrMu; /*!<Indicates the number of Slot for a radio frame*/
+ uint8_t tbScalingField;/*!< TB Scaling Factor used while
calucating TBS for P-RNTI, or
RA-RNTI*/
RgrSlotCfg slotCfg; /*!< Slot config as per 38.211, sec
#ifdef RGR_V1
/* rgr_x_001.main_7: [ccpu00112789] Added configuration for maximum number
of MSG3s */
- U8 maxMsg3PerUlSf; /*!< Maximum MSG3 that may be scheduled
+ uint8_t maxMsg3PerUlSf; /*!< Maximum MSG3 that may be scheduled
per uplink subframe */
#endif /* RGR_V1 */
/** @} */
- U8 maxUePerUlSf; /*!< Maximum UEs that may be scheduled
+ uint8_t maxUePerUlSf; /*!< Maximum UEs that may be scheduled
per uplink subframe. Currently this is
unused parameter */
- U8 maxUePerDlSf; /*!< Maximum UE to be considered for DL
+ uint8_t maxUePerDlSf; /*!< Maximum UE to be considered for DL
scheduling in a TTI.Currently this is
unused parameter */
/*[ccpu00138609]-ADD- Max limit for Msg4/DL CCCH Ues */
- U8 maxCcchPerDlSf; /*!< Max num of Msg4/DL CCCH SDU UEs that
+ uint8_t maxCcchPerDlSf; /*!< Max num of Msg4/DL CCCH SDU UEs that
can be scheduled per TTI. It cannot
exceed max UE per Dl sf. If set as
0, this will be a don't care
parameter */
- U8 maxUlBwPerUe; /*!< Maximum number of RBs that can be
+ uint8_t maxUlBwPerUe; /*!< Maximum number of RBs that can be
allocated to an UE in an UL subframe
Maximum value is defined by
RG_SCH_CMN_MAX_UL_BW_PER_UE in
rg_env.h. This can be modified as
per need basis */
- U8 maxDlBwPerUe; /*!< Maximum number of RBs that can be
+ uint8_t maxDlBwPerUe; /*!< Maximum number of RBs that can be
allocated to an UE in an DL subframe
Maximum value is defined by
RG_SCH_CMN_MAX_DL_BW_PER_UE in
rg_env.h. This can be modified as
per need basis */
- U8 maxDlRetxBw; /*!< Maximum number of RBs that can be
+ uint8_t maxDlRetxBw; /*!< Maximum number of RBs that can be
allocated for retransmission in DL
Maximum value is defined by
RG_SCH_CMN_MAX_DL_RETX_BW in
rg_env.h. This can be modified as
per need basis */
- U8 maxDlUeNewTxPerTti; /*!< Maximum number of UEs that can
+ uint8_t maxDlUeNewTxPerTti; /*!< Maximum number of UEs that can
be scheduled for a new DL
transmission in a TTI. Value should
be configured by the user as per
specific needs */
- U8 maxUlUeNewTxPerTti; /*!< Maximum number of UEs that can
+ uint8_t maxUlUeNewTxPerTti; /*!< Maximum number of UEs that can
be scheduled for a new UL
transmission in a TTI. Value should
be configured by the user as per
S8 pMax; /*!< To limit the Cell Uplink
transmission power */
- U8 dlfsSchdType; /*!< Indicates which DLFS scheduler to use, range
+ uint8_t dlfsSchdType; /*!< Indicates which DLFS scheduler to use, range
* is 0..(number of schedulers - 1) */
RgrDlHqCfg dlHqCfg; /*!< HARQ related configuration */
RgrRntiCfg macRnti; /*!< Range of RNTIs to be managed by MAC */
RgrPuschCfg puschCfg; /*!< Cell-specific hopping configuration */
RgrPreambleSetCfg macPreambleSet; /*!< Range of PDCCH Order Preamble IDs
to be managed by MAC */
- U8 numCmnLcs; /*!< Number of common logical channels*/
+ uint8_t numCmnLcs; /*!< Number of common logical channels*/
RgrCmnLchCfg cmnLcCfg[RGR_MAX_CMN_LC_PER_CELL]; /*!< Configuration for
common logical channels */
RgrCellCsgParamCfg csgParamCfg; /* Cell-specific configuration for CSG */
/** @name LTE_TDD */
/** @{ */
#ifdef LTE_TDD
- U8 ulDlCfgIdx; /*!< UL-DL configuration index*/
- U8 spclSfCfgIdx; /*!< Special Subframe configuration index*/
+ uint8_t ulDlCfgIdx; /*!< UL-DL configuration index*/
+ uint8_t spclSfCfgIdx; /*!< Special Subframe configuration index*/
RgrTddPrachRscInfo prachRscInfo; /*!< PRACH information */
#endif /* LTE_TDD */
/** @} */
/* rgr_x_001.main_4: Added 0 as valid value to shut off RGR TICKs. */
/** @name RGR_RRM_TICK */
/** @{ */
- U8 rrmTtiIndPrd; /*!< Periodicity of TTI indication from
+ uint8_t rrmTtiIndPrd; /*!< Periodicity of TTI indication from
MAC towards RGR user. Range [0-255]. A
value of 1 means one tick per System
Frame and 2 means one tick per 2 System
RgrLteAdvancedCellConfig rgrLteAdvCfg; /*!< RGR Configuration of LTE Adv */
/* LTE_ADV_FLAG_REMOVED_END */
#ifdef AIRSPAN
- U8 dlCqiOverrideFloor;
- U8 dlCqiOverrideCeil;
- U8 ulCqiOverrideFloor;
- U8 ulCqiOverrideCeil;
+ uint8_t dlCqiOverrideFloor;
+ uint8_t dlCqiOverrideCeil;
+ uint8_t ulCqiOverrideFloor;
+ uint8_t ulCqiOverrideCeil;
#endif
/** @} */
- U16 t300TmrVal; /*!< t300Timer value configured in Frames */
+ uint16_t t300TmrVal; /*!< t300Timer value configured in Frames */
/* ccpu00132314-ADD-Tx power offsets for Common PDSCH transmissions */
- U16 bcchTxPwrOffset; /*!< Tx Pwr Offset for BCCH tx on PDSCH.
+ uint16_t bcchTxPwrOffset; /*!< Tx Pwr Offset for BCCH tx on PDSCH.
Offset to the reference signal
power. Value: 0 -> 10000,
representing -6 dB to 4 dB in 0.001
dB steps */
- U16 pcchTxPwrOffset; /*!< Tx Pwr Offset for PCCH tx.
+ uint16_t pcchTxPwrOffset; /*!< Tx Pwr Offset for PCCH tx.
Offset to the reference signal
power. Value: 0 -> 10000,
representing -6 dB to 4 dB in 0.001
dB steps */
- U16 rarTxPwrOffset; /*!< Tx Pwr Offset for RAR tx.
+ uint16_t rarTxPwrOffset; /*!< Tx Pwr Offset for RAR tx.
Offset to the reference signal
power. Value: 0 -> 10000,
representing -6 dB to 4 dB in 0.001
dB steps */
/* ccpu00138898 - Added Tx pwr offset for PHICH Tx*/
- U16 phichTxPwrOffset; /*!< Tx Pwr Offset for PHICH tx.
+ uint16_t phichTxPwrOffset; /*!< Tx Pwr Offset for PHICH tx.
Offset to the reference signal
power. Value: 0 -> 10000,
representing -6 dB to 4 dB in 0.001
RgrAprdCqiMode aprdModeEnum; /*!< Aperiodic CQI reporting mode */
/* These two fields are only valid for Pcell*/
#ifdef LTE_ADV
- U8 triggerSet1; /*!< Trigger set one*/
- U8 triggerSet2; /*!< Trigger set two*/
+ uint8_t triggerSet1; /*!< Trigger set one*/
+ uint8_t triggerSet2; /*!< Trigger set two*/
#endif
} RgrUeAprdDlCqiCfg;
RgrPrdCqiMode prdModeEnum; /*!< Peiodic CQI reporting mode. */
RgrCqiPrdicity prdicityEnum; /*!< Periodicity values for CQI.
Currently, this is unused parameter. */
- U8 subframeOffst; /*!< Subframe offset.
+ uint8_t subframeOffst; /*!< Subframe offset.
Currently, this is unused parameter. */
S8 cqiOffst; /*!< Delta^cqi_offset: (actual_value*10).
Currently, this is unused parameter. */
- U8 k; /*!< k value: range [1-4] */
- U16 cqiPmiCfgIdx; /*!< CQI-PMI configuration index. */
+ uint8_t k; /*!< k value: range [1-4] */
+ uint16_t cqiPmiCfgIdx; /*!< CQI-PMI configuration index. */
} RgrUePrdDlCqiCfg;
#else /* TFU_UPGRADE */
/* Reference: 36.313: CQI-ReportPeriodic */
typedef struct rgrUeDlPCqiSetup
{
- U16 cqiPResIdx; /*!< cqi-PUCCH-ResourceIndex (0.. 1185) */
- U16 cqiPCfgIdx; /*!< cqi-pmi-ConfigIndex (0..1023) */
- U8 cqiRepType; /*!< Wideband CQI = 1 Subband CQI =2 */
- U8 k; /*!< Ref: 36.213 [23, 7.2.2] (1..4).
+ uint16_t cqiPResIdx; /*!< cqi-PUCCH-ResourceIndex (0.. 1185) */
+ uint16_t cqiPCfgIdx; /*!< cqi-pmi-ConfigIndex (0..1023) */
+ uint8_t cqiRepType; /*!< Wideband CQI = 1 Subband CQI =2 */
+ uint8_t k; /*!< Ref: 36.213 [23, 7.2.2] (1..4).
Valid only for Subband CQI */
- U8 riEna; /*!< Rand Indicator is Enabled TRUE(1) FALSE(0) */
- U16 riCfgIdx; /*!< ri-ConfigIndex (0..1023) */
+ uint8_t riEna; /*!< Rand Indicator is Enabled TRUE(1) FALSE(0) */
+ uint16_t riCfgIdx; /*!< ri-ConfigIndex (0..1023) */
Bool sANCQI; /*!< simultaneousAckNackAndCQI TRUE(1) FALSE(0) */
RgrPrdCqiMode prdModeEnum; /*!< Peiodic CQI reporting mode */
}RgrUeDlPCqiSetup;
*/
typedef struct rgrUeDlPCqiCfg
{
- U8 type; /*!< Setup(1) or Release(0) */
+ uint8_t type; /*!< Setup(1) or Release(0) */
RgrUeDlPCqiSetup cqiSetup; /*!< Periodic CQI Setup */
} RgrUePrdDlCqiCfg;
*/
typedef struct rgrUeUlSrsSetupCfg
{
- U16 srsCfgIdx; /*!< SRS Configuration Index ISRS
+ uint16_t srsCfgIdx; /*!< SRS Configuration Index ISRS
Ref: 36.213: Table 8.2-1; Range: 0-636*/
RgrUlSrsBwInfo srsBw; /*!< SRS Bandwidth */
RgrUlSrsHoBwInfo srsHopBw; /*!< SRS Hoping Bandwidth */
same value for all the UEs configured for
the same cell. */
/* rgr_x_001.main_13 - DEL - Removed the redeclaration of sANSrs and added the proper comment termination above */
- U8 txComb; /*!< Tranmission Comb: 0..1 */
- U8 fDomPosi; /*!< Frequency Domain Position */
+ uint8_t txComb; /*!< Tranmission Comb: 0..1 */
+ uint8_t fDomPosi; /*!< Frequency Domain Position */
}RgrUeUlSrsSetupCfg;
*/
typedef struct rgrUeSrSetupCfg
{
- U16 srResIdx; /*!< Range: 0-2047; Reference: SchedulingRequestConfig */
- U8 srCfgIdx; /*!< Range: 0 -155; Reference: SchedulingRequestConfig */
+ uint16_t srResIdx; /*!< Range: 0-2047; Reference: SchedulingRequestConfig */
+ uint8_t srCfgIdx; /*!< Range: 0 -155; Reference: SchedulingRequestConfig */
/*ccpu00131601:DEL - dTMax will not be required by scheduler */
}RgrUeSrSetupCfg;
*/
typedef struct rgrUeUlSrsCfg
{
- U8 type; /*!< Release=0 Setup =1 */
+ uint8_t type; /*!< Release=0 Setup =1 */
RgrUeUlSrsSetupCfg srsSetup; /*!< SRS Setup Configuration */
}RgrUeUlSrsCfg;
#ifdef LTE_ADV/* Sprint 3*/
typedef struct rgrUePucchFormat3Cfg
{
- U8 sCellAckN3ResAntP0Count;
- U8 sCellAckN3ResAntP1Count;
- U16 sCellAckN3ResAntP0[4];
- U16 sCellAckN3ResAntP1[4];
+ uint8_t sCellAckN3ResAntP0Count;
+ uint8_t sCellAckN3ResAntP1Count;
+ uint16_t sCellAckN3ResAntP0[4];
+ uint16_t sCellAckN3ResAntP1[4];
}RgrUePucchFormat3Cfg;
typedef struct rgrUePucchFormat1BCSCfg
{
- U8 sCellAckN1ResTb1Count; /* !< num of N1 res for TB1 */
- U8 sCellAckN1ResTb2Count; /* !< num of N1 res for TB2 */
- U16 sCellAckN1ResTb1[4]; /*!< TB1 N1 resources */
- U16 sCellAckN1ResTb2[4]; /* !< TB2 N1 resources */
+ uint8_t sCellAckN1ResTb1Count; /* !< num of N1 res for TB1 */
+ uint8_t sCellAckN1ResTb2Count; /* !< num of N1 res for TB2 */
+ uint16_t sCellAckN1ResTb1[4]; /*!< TB1 N1 resources */
+ uint16_t sCellAckN1ResTb2[4]; /* !< TB2 N1 resources */
}RgrUePucchFormat1BCSCfg;
typedef struct rgrUeSCellAckPucchCfg
{
typedef struct rgrUePuschDedCfg
{
Bool pres; /*! Prsent TRUE(1)/FALSE(0) */
- U8 bACKIdx; /*! betaOffset-ACK-Index (0..15) */
- U8 bRIIdx; /*! betaOffset-RI-Index (0..15) */
- U8 bCQIIdx; /*! betaOffset-CQI-Index (0..15) */
+ uint8_t bACKIdx; /*! betaOffset-ACK-Index (0..15) */
+ uint8_t bRIIdx; /*! betaOffset-RI-Index (0..15) */
+ uint8_t bCQIIdx; /*! betaOffset-CQI-Index (0..15) */
}RgrUePuschDedCfg;
/**
* @brief Downlink CQI reporting related configuration per UE
typedef struct rgrUeMeasGapCfg
{
Bool isMesGapEnabled; /*!< Is Measuremnet Gap enabled or disabled */
- U8 gapPrd; /*!< Gap period 40ms/80ms */
- U8 gapOffst; /*!< Gap offset - Vaue is 0 to 1*/
+ uint8_t gapPrd; /*!< Gap period 40ms/80ms */
+ uint8_t gapOffst; /*!< Gap offset - Vaue is 0 to 1*/
} RgrUeMeasGapCfg;
/**
@brief DRX Long Cycle Offset */
typedef struct rgrDrxLongCycleOffst
{
- U16 longDrxCycle; /*!< DRX Long Cycle value in subframes*/
- U16 drxStartOffst; /*!< DRX Long Cycle offset value in subframes*/
+ uint16_t longDrxCycle; /*!< DRX Long Cycle value in subframes*/
+ uint16_t drxStartOffst; /*!< DRX Long Cycle offset value in subframes*/
} RgrDrxLongCycleOffst;
/**
typedef struct rgrDrxShortDrx
{
Bool pres; /*!< Short cycle is configured or not */
- U16 shortDrxCycle; /*!< DRX Short Cycle value in sub-frames*/
- U8 drxShortCycleTmr; /*!< Value in multiples of Short DRX Cycles*/
+ uint16_t shortDrxCycle; /*!< DRX Short Cycle value in sub-frames*/
+ uint8_t drxShortCycleTmr; /*!< Value in multiples of Short DRX Cycles*/
} RgrDrxShortDrx;
/**
only a enum SETUP*/
#endif
/** @} */
- U16 drxOnDurTmr; /*!< DRX On-duration Timer value in
+ uint16_t drxOnDurTmr; /*!< DRX On-duration Timer value in
PDCCH subframes */
- U16 drxInactvTmr; /*!< DRX Inactivity Timer value in
+ uint16_t drxInactvTmr; /*!< DRX Inactivity Timer value in
PDCCH subframes */
- U16 drxRetxTmr; /*!< DRX Retransmission Timer value in PDCCH
+ uint16_t drxRetxTmr; /*!< DRX Retransmission Timer value in PDCCH
subframes */
RgrDrxLongCycleOffst drxLongCycleOffst; /*!< DRX Long cycle and offset, values in subframes */
RgrDrxShortDrx drxShortDrx; /*!< DRX Short cycle value and offset */
#ifdef EMTC_ENABLE
- U16 emtcDrxUlRetxTmr; /*Rel13 Drx Ul Retx Timer */
+ uint16_t emtcDrxUlRetxTmr; /*Rel13 Drx Ul Retx Timer */
Bool isEmtcUe;
Bool drxOnDurTmrR13Pres;
Bool drxRetxTmrR13Pres;
* @brief UE capability Configuration */
typedef struct rgrUeCapCfg
{
- U8 pwrClass; /*!< Power class per UE */
+ uint8_t pwrClass; /*!< Power class per UE */
Bool intraSfFeqHop; /*!< Intra subframe frequency hopping for PUSCH */
Bool resAloocType1; /*!< Resource allocation type 1 for PDSCH */
Bool simCqiAckNack; /*!< Simultaneous CQI and ACK/NACK on PUCCH */
variable can be used in reconfiguration
also to stop/release the ACK/NACK
Repetition */
- U16 pucchAckNackRep; /*!< n1PUCCH-AN-Rep */
+ uint16_t pucchAckNackRep; /*!< n1PUCCH-AN-Rep */
RgrAckNackRepFactor ackNackRepFactor; /*!< ACK/NACK Repetition factor */
} RgrUeAckNackRepCfg;
@brief Uplink HARQ configuration per UE */
typedef struct rgrUeUlHqCfg
{
- U8 maxUlHqTx; /*!< Maximum number of UL HARQ transmissions */
- U8 deltaHqOffst; /*!< Delta HARQ offset
+ uint8_t maxUlHqTx; /*!< Maximum number of UL HARQ transmissions */
+ uint8_t deltaHqOffst; /*!< Delta HARQ offset
Currently this is unused parameter */
} RgrUeUlHqCfg;
/**
{
Bool pres; /*!< Indicates presence of UE PUCCH/PUSCH group power configuration */
CmLteRnti tpcRnti; /*!< TPC PUCCH/PUSCH RNTI for UE */
- U8 idx; /*!< Index for format 3/3A */
+ uint8_t idx; /*!< Index for format 3/3A */
} RgrUeGrpPwrCfg;
/**
@brief Uplink power configuration per UE */
Bool isDeltaMCSEnabled; /*!< To indicate Delta MCS Enabled */
S8 p0UePusch; /*!< P_0UE_PUSCH*/
S8 p0UePucch; /*!< P_0_PUCCH*/
- U8 pSRSOffset; /*!< P_SRS_OFFSET
+ uint8_t pSRSOffset; /*!< P_SRS_OFFSET
Currently this is unused parameter */
- U8 trgCqi; /*!< CQI to aim for during PUSCH power
+ uint8_t trgCqi; /*!< CQI to aim for during PUSCH power
* control. Zero indicates absence, where
* cell-wide trgCqi is used */
} RgrUeUlPwrCfg;
typedef struct rgrUeQosCfg
{
Bool ambrPres; /*!< Indicates presence of AMBR */
- U32 dlAmbr; /*!< DL AMBR value for UE (bytes/sec): Optional */
- U32 ueBr; /*!< UL Byte Rate value for UE (bytes/sec): Optional */
+ uint32_t dlAmbr; /*!< DL AMBR value for UE (bytes/sec): Optional */
+ uint32_t ueBr; /*!< UL Byte Rate value for UE (bytes/sec): Optional */
} RgrUeQosCfg;
/**
@brief Time Alignment timer configuration per UE */
typedef struct rgrUeTaTmrCfg
{
Bool pres; /*!< rgr_x_001.main_7: Pres=NOTPRSNT indicates taTmr INFINITY */
- U16 taTmr; /*!< Timer configuration (in subframes) */
+ uint16_t taTmr; /*!< Timer configuration (in subframes) */
} RgrUeTaTmrCfg;
/** @name RGR_V1 */
/** @{ */
{
Bool isPrdBsrTmrPres; /*!< Indicates if periodic BSR timer is present
*/
- U16 prdBsrTmr; /*!< periodicBSR-Timer configuration
+ uint16_t prdBsrTmr; /*!< periodicBSR-Timer configuration
(in subframes): Value 0xFFFF indicates
'Infinity' */
- U16 retxBsrTmr; /*!< retxBSR-Timer configuration (in subframes)
+ uint16_t retxBsrTmr; /*!< retxBSR-Timer configuration (in subframes)
: Mandatory parameter */
} RgrUeBsrTmrCfg;
#endif
typedef struct rgrUeSpsDlCfg
{
Bool isDlSpsEnabled; /*!< Bool indicating if DL SPS is enabled */
- U8 numSpsHqProc; /*!< Number of SPS harq Proc: Value in set
+ uint8_t numSpsHqProc; /*!< Number of SPS harq Proc: Value in set
[1..8] */
- U8 numPucchVal; /*!< Count for configured PUCCH values */
- U32 n1PucchVal[4]; /*!< Array of n1Pucch values */
+ uint8_t numPucchVal; /*!< Count for configured PUCCH values */
+ uint32_t n1PucchVal[4]; /*!< Array of n1Pucch values */
RgrSpsPrd dlSpsPrdctyEnum; /*!< Periodicity for DL SPS */
- U16 explicitRelCnt; /*!< Number of SPS ocassions with BO = 0 after
+ uint16_t explicitRelCnt; /*!< Number of SPS ocassions with BO = 0 after
which SPS is released */
} RgrUeSpsDlCfg;
typedef struct rgrUlSpsLcInfo
{
Bool isSpsEnabled;
- U8 lcId;
+ uint8_t lcId;
}RgrUlSpsLcInfo;
/**
S8 p0UePuschVal; /*!< Value in range [-8....7] */
} pwrCfg;
RgrSpsPrd ulSpsPrdctyEnum; /*!< Periodicity for UL SPS */
- U8 lcCnt; /*!< Number of logical channels */
+ uint8_t lcCnt; /*!< Number of logical channels */
RgrUlSpsLcInfo spsLcInfo[RGR_MAX_SPS_LC];/*!< Array of SPS logical channels -
All these are assumed to be
mapped onto SPS lcg with ID=1 */
@brief PUSH n CQI Reporting related configuration for an UE*/
typedef struct rgrUeCqiReptCfg
{
- U8 numColltdCqiRept; /*!< Number of CQI reports to be sent in PUSH n
+ uint8_t numColltdCqiRept; /*!< Number of CQI reports to be sent in PUSH n
Reporting */
}RgrUeCqiReptCfg;
@brief CQI for subband number subBandIdx */
typedef struct rgrSubBandCqiInfo
{
- U8 cqi[2]; /*!< Subband CQI for two codewords */
- U8 subBandIdx; /*!< Index of the subband starting from 0,
+ uint8_t cqi[2]; /*!< Subband CQI for two codewords */
+ uint8_t subBandIdx; /*!< Index of the subband starting from 0,
in ascending order of frequency */
} RgrSubBandCqiInfo;
@brief A CQI Report used in PUSH n Reporting*/
typedef struct rgrUeCqiRept
{
- U8 cqi[2]; /*!< Wideband CQI Value for two codewords*/
- U8 cqiMode; /*!< Reporting mode by which CQI was reported */
+ uint8_t cqi[2]; /*!< Wideband CQI Value for two codewords*/
+ uint8_t cqiMode; /*!< Reporting mode by which CQI was reported */
RgrSubBandCqiInfo sbCqiInfo[RGR_MAX_DL_CQI_SUBBAND];
- U8 numSubBand;/*!< Number of Subbands for which CQI is
+ uint8_t numSubBand;/*!< Number of Subbands for which CQI is
being reported */
} RgrUeCqiRept;
typedef struct RgrUeCqiInfo
{
RgrUeCqiRept cqiRept[RGR_CQIRPTS_MAXN]; /*!< CQI reports */
- U8 numCqiRept; /*!< Number of CQI reports present */
+ uint8_t numCqiRept; /*!< Number of CQI reports present */
} RgrUeCqiInfo;
/*rgr_x_001.main_11 ADD added changes for CQI management*/
typedef struct rgrLoadInfIndInfo
{
CmLteCellId cellId; /*!< Cell ID */
- U16 bw; /*!< Bandwidth */
- U32 type;
+ uint16_t bw; /*!< Bandwidth */
+ uint32_t type;
union
{
TknStrOSXL rntpInfo; /*!< RNTP Info */
- U32 absLoadInfo[RGR_ABS_PATTERN_LEN];
+ uint32_t absLoadInfo[RGR_ABS_PATTERN_LEN];
} u;
}RgrLoadInfIndInfo;
/* LTE_ADV_FLAG_REMOVED_END */
/* @brief UE Configuration for LTE Adv feature */
typedef struct rgrLteAdvancedUeConfig
{
- U32 pres;
+ uint32_t pres;
Bool isUeCellEdge; /*! Flag to indicate UE is cell edge or cell center */
Bool isAbsUe; /*! Flag to indicate ABS UE or Not */
} RgrLteAdvancedUeConfig;
typedef struct rgrExtaddgrp2
{
Bool pres;
- U8 csiNumRep;// MAPPING
- U8 mpddchPdschHop;
- U8 mpdcchStartUESSFDD;// MAPPING
- U16 mpdcchNumRep;// MAPPING
- U32 mpddchNB;//1.. maxAvailNarrowBands-r13
+ uint8_t csiNumRep;// MAPPING
+ uint8_t mpddchPdschHop;
+ uint8_t mpdcchStartUESSFDD;// MAPPING
+ uint16_t mpdcchNumRep;// MAPPING
+ uint32_t mpddchNB;//1.. maxAvailNarrowBands-r13
}RgrExtaddgrp2;
typedef struct rgrRbAssignment
{
- U8 numPRBpairs; // MAPPING
- U8 rbAssignment[5];
+ uint8_t numPRBpairs; // MAPPING
+ uint8_t rbAssignment[5];
}RgrRbAssignment;
typedef struct rgrEpdcchAddModLst
{
- U8 setConfigId;
- U8 transmissionType;
+ uint8_t setConfigId;
+ uint8_t transmissionType;
RgrRbAssignment resBlkAssignment;
- U32 dmrsScrambSeq;
- U32 pucchResStartoffset;
- TknU32 pdschRemapQLcfgId;
- TknU8 mpdcchNumPRBpair; // MAPPING
+ uint32_t dmrsScrambSeq;
+ uint32_t pucchResStartoffset;
+ TknUInt32 pdschRemapQLcfgId;
+ TknUInt8 mpdcchNumPRBpair; // MAPPING
RgrExtaddgrp2 extaddgrp2;
}RgrEpdcchAddModLst;
typedef struct rgrSubFrmPatCfg
{
Bool pres;
- U8 measSfPatFDD[5];
+ uint8_t measSfPatFDD[5];
}RgrSubFrmPatCfg;
typedef struct rgrEpdcchConfigRel11
{
Bool pres;
RgrSubFrmPatCfg sfPtn;
- TknU32 startSymbolr11;
+ TknUInt32 startSymbolr11;
RgrEpdcchAddModLst epdcchAddModLst[RGR_MAX_EPDCCH_SET];
}RgrEpdcchConfigRel11;
typedef struct rgrPucchRepCfgRel13
{
Bool isPucchRepPres;
- U8 modeANumPucchRepFormat1;
- U8 modeANumPucchRepFormat2;
+ uint8_t modeANumPucchRepFormat1;
+ uint8_t modeANumPucchRepFormat2;
}RgrPucchRepCfgRel13;
Bool pres;
RgrEpdcchConfigRel11 emtcEpdcchCfg;
RgrPucchRepCfgRel13 emtcPucchRepCfg;
- U8 pdschReptLevModeA;
+ uint8_t pdschReptLevModeA;
}RgrUeEmtcCfg;
#endif
#ifdef RG_5GTF
typedef struct rgrUe5gtfCfg
{
- U8 grpId;
- U8 BeamId;
- U8 numCC;
- U8 mcs;
- U8 maxPrb;
+ uint8_t grpId;
+ uint8_t BeamId;
+ uint8_t numCC;
+ uint8_t mcs;
+ uint8_t maxPrb;
}RgrUe5gtfCfg;
#endif
RgrUeCapCfg ueCapCfg; /*!< UE Capabilty reconfiguration */
RgrCodeBookRstCfg ueCodeBookRstCfg; /*!< Number of bits in code book for
transmission modes */
- TknU8 dedPreambleId; /*!< If present, then mapping exists at
+ TknUInt8 dedPreambleId; /*!< If present, then mapping exists at
RGR user with CRNTI */
/** @name LTE_TDD */
/** @{ */
RgrLteAdvancedUeConfig ueLteAdvCfg; /*!< LTE Adv configuration per UE */
/* LTE_ADV_FLAG_REMOVED_END */
RgrAccessStratumRls accessStratumRls; /*!< UE Access Stratum Release */
- U8 csgMmbrSta; /* CSG Membership status, refer RgrUeCsgMbrStatus */
+ uint8_t csgMmbrSta; /* CSG Membership status, refer RgrUeCsgMbrStatus */
#ifdef EMTC_ENABLE
RgrUeEmtcCfg emtcUeCfg;
#endif
@brief QCI, GBR, and MBR configuration for dedicated logical channels */
typedef struct rgrLchQosCfg
{
- U8 qci; /*!< QCI for the logical channel.
+ uint8_t qci; /*!< QCI for the logical channel.
Valid Range:[0-255] (Actual QCI - 1). */
- U32 gbr; /*!< GBR value for a logical channel (bytes/sec). */
- U32 mbr; /*!< MBR value for a logical channel (bytes/sec). */
+ uint32_t gbr; /*!< GBR value for a logical channel (bytes/sec). */
+ uint32_t mbr; /*!< MBR value for a logical channel (bytes/sec). */
} RgrLchQosCfg;
/*rgr_x_001.main_9 - Added support for SPS*/
/**
RgrLchQosCfg dlQos; /*!< DL QoS parameters: Only for dedicated channels */
/*rgr_x_001.main_9 - Added support for SPS*/
RgrLchSpsCfg dlSpsCfg; /*!< SPS configuration for DL logical channel */
- U8 rlcReorderTmr; /*!< RLC reordering timer required for LAA*/
+ uint8_t rlcReorderTmr; /*!< RLC reordering timer required for LAA*/
} RgrDlLchCfg;
/**
typedef struct rgrUlLchCfg
{
CmLteLcId lcId; /*!< LC ID for uplink logical channel*/
- U8 qci; /*!< QCI associated with LC ID */
+ uint8_t qci; /*!< QCI associated with LC ID */
} RgrUlLchCfg;
/**
@brief Logical channel group configuration information for uplink logical channels */
typedef struct rgrUlLcgCfg
{
- U8 lcgId; /*!< Logical channel group ID */
+ uint8_t lcgId; /*!< Logical channel group ID */
/*rgr_x_001.main_11 ADD added changes for L2 measurements*/
#ifdef LTE_L2_MEAS
- U8 numLch; /*!< Number of LC's for this group in Uplink */
+ uint8_t numLch; /*!< Number of LC's for this group in Uplink */
RgrUlLchCfg lchUlCfg[RGR_MAX_LC_PER_LCG]; /*!< Logical Channel details for
this LCG*/
#endif /*LTE_L2_MEAS */
- U32 gbr; /*!< Commulative UL GBR of all LC mapping to this LCG */
- U32 mbr; /*!< Commulative UL MBR of all LC mapping to this LCG */
+ uint32_t gbr; /*!< Commulative UL GBR of all LC mapping to this LCG */
+ uint32_t mbr; /*!< Commulative UL MBR of all LC mapping to this LCG */
} RgrUlLcgCfg;
/**
typedef struct rgrUlLchQciCfg
{
CmLteLcId lcId; /*!< Logical channel ID */
- U8 qci; /*!< Qci */
- U8 lcgId; /*!< Logical channel group ID */
+ uint8_t qci; /*!< Qci */
+ uint8_t lcgId; /*!< Logical channel group ID */
}RgrUlLchQciCfg;
/**
CM_LTE_LCH_DTCH */
RgrDlLchCfg dlInfo; /*!< Downlink logical channel configuration information */
RgrUlLchQciCfg ulLchQciInfo; /*!< Uplink logical channel configuration information */
- U8 lcgId; /*!< Logical channel group ID */
+ uint8_t lcgId; /*!< Logical channel group ID */
} RgrLchCfg;
/** @brief Set of parameters for logical channelgroup Configuration */
/** @brief Basic configuration structure at RRM */
typedef struct rgrCfg
{
- U8 cfgType; /*!< Indicates configuration type */
+ uint8_t cfgType; /*!< Indicates configuration type */
union /*!< cfgType is selector */
{
RgrCellCfg cellCfg; /*!< Cell configuration */
typedef struct rgrCellRecfg
{
CmLteCellId cellId; /*!< Cell ID */
- U32 recfgTypes; /*!< Bitmask indicating reconfiguration types */
+ uint32_t recfgTypes; /*!< Bitmask indicating reconfiguration types */
RgrActvTime recfgActvTime; /*!< Activation Time for cell reconfiguration */
RgrDlHqCfg dlHqRecfg; /*!< DL HARQ related reconfiguration */
RgrCfiCfg cfiRecfg; /*!< CFI reconfiguration for PDCCH */
#ifdef RGR_SI_SCH
RgrSiCfg siReCfg; /*!<SI Re-Configuration structure */
#endif
- U16 t300TmrVal; /*!< t300Timer value configured in Frames */
+ uint16_t t300TmrVal; /*!< t300Timer value configured in Frames */
/* LTE_ADV_FLAG_REMOVED_START */
RgrLteAdvancedCellConfig rgrLteAdvCfg; /*!< RGR Configuration of LTE Adv for a cell */
/* LTE_ADV_FLAG_REMOVED_END */
*/
typedef struct rgrSCellActDeactInfo
{
- U8 sCellIdx; /*!< sCell Index to be activated */
+ uint8_t sCellIdx; /*!< sCell Index to be activated */
}RgrSCellActDeactInfo;
/**
typedef struct rgrSCellActDeactEvnt
{
CmLteRnti crnti; /*!< UE ID: To fetch UeCb in a cell*/
- U8 numOfSCells; /* !<No of SCells to be Activated */
+ uint8_t numOfSCells; /* !<No of SCells to be Activated */
RgrSCellActDeactInfo sCellActDeactInfo[RGR_MAX_SCELL_PER_UE];
/* !<SCH SCell Activation Deactivation Information */
} RgrSCellActDeactEvnt;
Bool isAccumulated; /*!< To indicate if accumulation is enabled */
Bool isDeltaMCSEnabled; /*!< To indicate Delta MCS Enabled */
S8 p0UePusch; /*!< P_0UE_PUSCH*/
- U8 pSRSOffset; /*!< P_SRS_OFFSET
+ uint8_t pSRSOffset; /*!< P_SRS_OFFSET
Currently this is unused parameter */
} RgrUeUlPwrDedSCellCfg;
/** @brief UE Downlink secondary cell config params */
typedef struct rgrUeSecCellCfg
{
- U8 sCellIdx;
- U16 sCellId; /*!< This will be secondary cellId */
- TknU32 sCellDeActTmr; /*!< for Activating the sCell for UE */
+ uint8_t sCellIdx;
+ uint16_t sCellId; /*!< This will be secondary cellId */
+ TknUInt32 sCellDeActTmr; /*!< for Activating the sCell for UE */
RgrUeDlCqiCfg ueSCellDlCqiCfg; /*!< Secondary cell dedicated configuration */
#ifdef TFU_UPGRADE
RgrUePdschDedCfg uePdschDedCfg; /*!< Secondary cell dedicated configuration */
typedef struct rgrUeSecCellInfo
{
Bool useExtBSRSizes; /*!< If TRUE used R10 Extended BSR Size Table*/
- U8 numSCells;
+ uint8_t numSCells;
RgrUeSecCellCfg ueSCellDedCfg[RGR_MAX_SCELL_PER_UE]; /*!< Secondary cell configuration per
UE */
}RgrUeSecCellInfo;
/** @brief Configuration of every SCell for a UE*/
typedef struct rgrUeDlSecCellRelInfo
{
- U8 sCellIdx; /*!< This will be secondary cell Idx */
- U16 sCellId; /*!< This will be secondary cellId */
+ uint8_t sCellIdx; /*!< This will be secondary cell Idx */
+ uint16_t sCellId; /*!< This will be secondary cellId */
}RgrUeDlSecCellRelInfo;
/** @brief Configuration for SCell Release for a UE*/
typedef struct rgrUeSecCellRelInfo
{
- U8 numSCells; /*!< This will be the number of secondary cells*/
+ uint8_t numSCells; /*!< This will be the number of secondary cells*/
RgrUeDlSecCellRelInfo ueSCellRelDedCfg[RGR_MAX_SCELL_PER_UE]; /*!< Secondary cell configuration per
UE */
}RgrUeSecCellRelInfo;
CmLteRnti oldCrnti; /*!< Old UE ID */
CmLteRnti newCrnti; /*!< New UE ID: This value must match
'oldCrnti', if no CRNTI change during reconfiguration */
- /*rgr_x_001.main_11 : changing RecfgTypes to U32
+ /*rgr_x_001.main_11 : changing RecfgTypes to uint32_t
* as all 16 bits are exhausted*/
/* LTE_ADV_FLAG_REMOVED_START */
/* KW fix for LTE_ADV */
- U32 ueRecfgTypes; /*!< Bitmask indicating UE reconfiguration items */
+ uint32_t ueRecfgTypes; /*!< Bitmask indicating UE reconfiguration items */
/* LTE_ADV_FLAG_REMOVED_END */
RgrUeTxModeCfg txMode; /*!< UE transmission mode */
RgrUeAprdDlCqiCfg aprdDlCqiRecfg; /*!< Aperiodic CQI-related information */
RgrUeSecCellInfo ueSCellCfgInfo;/*!< Secondary cell dedicated informaton
per UE */
RgrUeSCellAckPucchCfg sCellAckN1ResCfg; /*!< N1ResCfg for SCell ack feedback */
- U8 simulAckNackCQIFormat3;
+ uint8_t simulAckNackCQIFormat3;
#endif /* LTE_ADV */
RgrAccessStratumRls accessStratumRls; /*!< UE Access Stratum Release */
- U8 csgMmbrSta; /* CSG Membership status, refer RgrUeCsgMbrStatus */
+ uint8_t csgMmbrSta; /* CSG Membership status, refer RgrUeCsgMbrStatus */
#ifdef EMTC_ENABLE
RgrUeEmtcRecfg emtcUeRecfg;
#endif
CmLteRnti crnti; /*!< CRNTI for DTCH and DCCH */
CmLteLcId lcId; /*!< Logical channel ID */
/*rgr_x_001.main_9 - Added support for SPS*/
- U8 recfgTypes; /*!< Reconfiguration type for DL LC */
+ uint8_t recfgTypes; /*!< Reconfiguration type for DL LC */
/** @brief Reconfiguration Parameters during the DownLink */
struct dlRecfgS
} dlRecfg; /*!< Downlink logical channel reconfiguration information */
RgrUlLchQciCfg ulLchQciInfo;
- U8 lcgId; /*!< Logical channel group ID */
+ uint8_t lcgId; /*!< Logical channel group ID */
} RgrLchRecfg;
/** @brief Set of parameters Corresponding To Logical channel group Reconfiguration */
/** @brief Uplink Reconfiguration Parameters for logical channel Groups */
struct ullcgRecfgS
{
- U8 lcgId; /*!< Logical channel group ID */
+ uint8_t lcgId; /*!< Logical channel group ID */
#ifdef RG_UNUSED
- U8 numLch; /*!< Number of LC's for this group in Uplink */
+ uint8_t numLch; /*!< Number of LC's for this group in Uplink */
RgrUlLchCfg lchUlCfg[RGR_MAX_LC_PER_LCG]; /*!< Logical Channel details for
this LCG*/
#endif /*LTE_L2_MEAS */
- U32 gbr; /*!< Commulative UL GBR of all LC mapping to this LCG */
- U32 mbr; /*!< Commulative UL MBR of all LC mapping to this LCG */
+ uint32_t gbr; /*!< Commulative UL GBR of all LC mapping to this LCG */
+ uint32_t mbr; /*!< Commulative UL MBR of all LC mapping to this LCG */
} ulRecfg;
}RgrLcgRecfg;
/** @brief Basic reconfiguration structure at RRM */
typedef struct rgrRecfg
{
- U8 recfgType; /*!< Indicates reconfiguration type */
+ uint8_t recfgType; /*!< Indicates reconfiguration type */
union /*!< Reconfiguration type is selector */
{
RgrCellRecfg cellRecfg; /*!< Cell reconfiguration */
@brief Basic Delete information for MAC */
typedef struct rgrDel
{
- U8 delType; /*!< Indicates configuration item to be deleted */
+ uint8_t delType; /*!< Indicates configuration item to be deleted */
/** @brief Indicates The Cell/UE/Logical Channel Group to be deleted */
union rgrDelU
{
CmLteCellId cellId; /*!< Cell ID */
CmLteRnti crnti; /*!< CRNTI for DTCH and DCCH */
CmLteLcId lcId; /*!< Logical channel ID */
- U8 lcgId; /*!< Logical channel group ID */
+ uint8_t lcgId; /*!< Logical channel group ID */
} lchDel; /*!< Logical channel delete information */
/** @brief Delete The Logical channel groups */
{
CmLteCellId cellId; /*!< Cell ID */
CmLteRnti crnti; /*!< CRNTI for DTCH and DCCH */
- U8 lcgId; /*!< Logical channel group ID */
+ uint8_t lcgId; /*!< Logical channel group ID */
} lcgDel;
#ifdef LTE_ADV
/** @brief Delete Secondary cell for a UE */
{
CmLteCellId cellId; /*!< Cell ID */
CmLteRnti crnti; /*!< UE ID: CRNTI */
- U32 ueDelTypes; /*!< Bitmask indicating UE reconfiguration items */
+ uint32_t ueDelTypes; /*!< Bitmask indicating UE reconfiguration items */
RgrUeSecCellRelInfo ueSCellRelCfgInfo;/*!< Secondary cell dedicated informaton*/
} ueScellRel;
#endif
typedef struct rgrPrbCfg
{
- U8 isSonIcicEnable;
- U8 numCellEdgeUEs;
- U8 numCellCentreUEs;
+ uint8_t isSonIcicEnable;
+ uint8_t numCellEdgeUEs;
+ uint8_t numCellCentreUEs;
CmLteRnti cellEdgeUe[RG_SCH_MAX_UE]; /*!< List of cell Edge UE's */
CmLteRnti cellCentreUe[RG_SCH_MAX_UE]; /*!< List of cell centre UE's */
RgrPaLevel paLevelPerPrb[RGR_SCH_MAX_PA_PER_PRB]; /*!< Mapping of PRB to Pa Values */
typedef struct rgrCfgReqInfo
{
- U8 action; /*!< Determines configuration/reconfiguration */
+ uint8_t action; /*!< Determines configuration/reconfiguration */
union /*!< Action is selector */
{
RgrCfg cfgInfo; /*!< Configuration information at RRM */
typedef struct rgrTtiIndInfo
{
CmLteCellId cellId; /*!< Cell ID */
- U16 hSfn; /*!< Hyper System Frame Number */
- U16 sfn; /*!< System Frame Number */
+ uint16_t hSfn; /*!< Hyper System Frame Number */
+ uint16_t sfn; /*!< System Frame Number */
} RgrTtiIndInfo;
/** @} */
{
CmLteCellId cellId; /*! Cell Id */
RgrSiCfgType cfgType; /*! MIB/SIB1/SI */
- U8 siId; /*! SI ID, if cfgType is SI.
+ uint8_t siId; /*! SI ID, if cfgType is SI.
SI ID starts from 1 */
Buffer *pdu; /*! PDU, one of MIB/SIB1/SI */
}RgrSiCfgReqInfo;
*/
typedef struct rgrWarningSiCfgReqInfo
{
- U8 emtcEnable; /*! indicates EMTC enabled or not */
+ uint8_t emtcEnable; /*! indicates EMTC enabled or not */
CmLteCellId cellId; /*! Cell Id */
- U8 siId; /*! SI ID */
+ uint8_t siId; /*! SI ID */
CmLListCp siPduLst; /*! list of PDUs,each corresponding to one segment*/
}RgrWarningSiCfgReqInfo;
{
CmLteCellId cellId; /*!< Cell ID */
CmLteRnti crnti; /*!< UE identifier UE ID: CRNTI */
- U8 status; /*!< Status */
+ uint8_t status; /*!< Status */
}RgrUeStaIndInfo;
/** @} */
typedef struct rgrLoadInfReqInfo
{
CmLteCellId cellId; /*! Cell Id */
- U8 rgrCcPHighStartRb; /*! Start RB for power high cell centre user */
- U8 rgrCcPHighEndRb; /*! End RB for power high cell centre use */
+ uint8_t rgrCcPHighStartRb; /*! Start RB for power high cell centre user */
+ uint8_t rgrCcPHighEndRb; /*! End RB for power high cell centre use */
}RgrLoadInfReqInfo;
/* LTE_ADV_FLAG_REMOVED_END */
/** @} */
typedef S16 (*RgrBndCfm) ARGS((
Pst* pst,
SuId suId,
- U8 status));
+ uint8_t status));
/** @brief Request from RRM to MAC to unbind the interface SAPs.
*
EXTERN S16 cmPkRgrCfgCfm ARGS((
Pst* pst,
RgrCfgTransId transId,
- U8 status
+ uint8_t status
));
/** @brief Configuration confirm from MAC to RRM.
typedef S16 (*RgrCfgCfm) ARGS((
Pst* pst,
RgrCfgTransId transId,
- U8 status));
+ uint8_t status));
/* rgr_x_001.main_5-ADD-Added for SI Enhancement. */
/** @name RGR_SI_SCH */
Pst* pst,
SuId suId,
RgrCfgTransId transId,
- U8 status));
+ uint8_t status));
/** @brief SI Configuration Request primitive for warning SI configuration
*
Pst* pst,
SuId suId,
RgrCfgTransId transId,
- U8 siId,
- U8 status));
+ uint8_t siId,
+ uint8_t status));
/** @brief SI Configuration stop Request primitive for warning SI configuration
*
Pst *pst,
SpId spId,
RgrCfgTransId transId,
- U8 siId ));
+ uint8_t siId ));
#endif /*RGR_SI_SCH*/
EXTERN S16 RgUiRgrBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/** @brief Request from RRM to MAC to unbind the interface SAPs.
EXTERN S16 RgUiRgrCfgCfm ARGS((
Pst* pst,
RgrCfgTransId transId,
- U8 status
+ uint8_t status
));
/* rgr_x_001.main_5-ADD-Added for SI Enhancement. */
/** @name RGR_SI_SCH */
Pst* pst,
SuId suId,
RgrCfgTransId transId,
- U8 status
+ uint8_t status
));
/** @brief SI Configuration Confirm from MAC to RRM.
Pst* pst,
SuId suId,
RgrCfgTransId transId,
- U8 siId,
- U8 status
+ uint8_t siId,
+ uint8_t status
));
/** @brief SI Configuration Confirm from MAC to RRM.
Pst *pst,
SpId spId,
RgrCfgTransId transId,
- U8 siId
+ uint8_t siId
));
#endif /*RGR_SI_SCH*/
*
* @param[in] Pst* pst A pointer to post structure.
* @param[in] SuId suId Service User SAP Id.
- * @param[in] U8 status An information on status confirmation.
+ * @param[in] uint8_t status An information on status confirmation.
* @return S16
*/
EXTERN S16 NxLiRgrBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/** @brief Request from RRM to MAC to unbind the interface SAPs
Pst* pst,
SuId suId,
RgrCfgTransId transId,
- U8 status
+ uint8_t status
));
/* rgr_x_001.main_5-ADD-Added for SI Enhancement. */
/** @name RGR_SI_SCH */
* @param[in] Pst* pst A pointer to post structure.
* @param[in] SuId suId Service User SAP Id.
* @param[in] RgrCfgTransId transId RRM to MAC transaction Id
-* @param[in] U8 status An information on confirmation status.
+* @param[in] uint8_t status An information on confirmation status.
* @return S16
*/
EXTERN S16 NxLiRgrSiCfgCfm ARGS((
Pst* pst,
SuId suId,
RgrCfgTransId transId,
- U8 status
+ uint8_t status
));
Pst* pst,
SuId suId,
RgrCfgTransId transId,
-U8 siId,
-U8 status
+uint8_t siId,
+uint8_t status
));
Pst* pst,
SuId suId,
RgrCfgTransId transId,
- U8 status
+ uint8_t status
));
/* PH04_CMAS : end */
*
* @param[in] Pst* pst A pointer to post structure.
* @param[in] SuId suId Service User SAP Id.
-* @param[in] U8 siId SI Index
+* @param[in] uint8_t siId SI Index
* @param[in] RgrCfgTransId transId RRM to MAC transaction Id
-* @param[in] U8 status An information on confirmation status.
+* @param[in] uint8_t status An information on confirmation status.
* @return S16
*/
EXTERN S16 NxLiRgrWarningSiCfgCfm ARGS((
Pst* pst,
SuId suId,
RgrCfgTransId transId,
- U8 siId,
- U8 status
+ uint8_t siId,
+ uint8_t status
));
/** @brief SI Configuration request from RRM to MAC for
*
* @param[in] Pst* pst A pointer to post structure.
* @param[in] SpId spId Service Provider SAP Id.
- * @param[in] U8 siId SI Index
+ * @param[in] uint8_t siId SI Index
*/
EXTERN S16 NxLiRgrWarningSiStopReq ARGS((
Pst* pst,
SpId spId,
RgrCfgTransId transId,
- U8 siId
+ uint8_t siId
));
#endif/*RGR_SI_SCH */
EXTERN S16 cmPkRgrBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
EXTERN S16 cmUnpkRgrBndCfm ARGS((
Pst *pst,
SpId spId,
RgrCfgTransId transId,
- U8 siId
+ uint8_t siId
));
EXTERN S16 cmUnpkRgrWarningSiStopReq ARGS((
Pst* pst,
SuId suId,
RgrCfgTransId transId,
- U8 siId,
- U8 status
+ uint8_t siId,
+ uint8_t status
));
EXTERN S16 cmUnpkRgrWarningSiCfgCfm ARGS((
Pst* pst,
SuId suId,
RgrCfgTransId transId,
- U8 status
+ uint8_t status
));
EXTERN S16 cmUnpkRgrSiCfgCfm ARGS((
EXTERN S16 DmUiRgrBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/** @brief Request from RRM to MAC to unbind the interface SAPs */
EXTERN S16 DmUiRgrUbndReq ARGS((
Pst* pst,
SuId suId,
RgrCfgTransId transId,
- U8 status
+ uint8_t status
));
#endif
/** @brief Sta Indication from Scheduler to RRM
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
(
Pst* pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 cmPkRguBndCfm(pst, suId, status)
Pst* pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
*
* @param[in] Pst* pst
* @param[in] SuId suId
-* @param[in] U8 status
+* @param[in] uint8_t status
* @return S16
* -# ROK
**/
#endif
{
SuId suId;
- U8 status;
+ uint8_t status;
if (SUnpkS16(&suId, mBuf) != ROK) {
Buffer *mBuf;
#endif
{
- U8 loop;
+ uint8_t loop;
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
{
Buffer *mBuf;
- U8 idx;
+ uint8_t idx;
RguHarqStatusInd *harqStaInd = NULL;
#ifdef XEON_SPECIFIC_CHANGES
{
RguHarqStatusInd *hqStaInd;
SuId suId;
- U8 idx;
+ uint8_t idx;
if (SUnpkS16(&suId, mBuf) != ROK) {
Buffer *mBuf;
#endif
{
- U32 idx;
+ uint32_t idx;
for(idx=(param->numLcs - 1); idx >= 0; idx--)
Buffer *mBuf;
#endif
{
- U32 idx;
+ uint32_t idx;
for (idx=(param->numUes - 1); idx >= 0; idx--)
Buffer *mBuf;
#endif
{
- U32 idx;
+ uint32_t idx;
CMCHKUNPK(cmUnpkLteRnti, ¶m->ueId, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->numLcs, mBuf);
for(idx=0; idx < param->numLcs; idx++)
Buffer *mBuf;
#endif
{
- U32 idx;
+ uint32_t idx;
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
*/
typedef struct rguPduInfo
{
- U8 numPdu; /*!< Number of PDUs */
+ uint8_t numPdu; /*!< Number of PDUs */
Buffer *mBuf[RGU_MAX_PDU]; /*!< numPdu data buffers */
} RguPduInfo;
{
S32 bo; /*!< Buffer occupancy reported by RLC */
#ifdef CCPU_OPT
- U16 estRlcHdrSz; /*!< Estimated RLC header size */
+ uint16_t estRlcHdrSz; /*!< Estimated RLC header size */
Bool staPduPrsnt; /*!< Indicates whether the BO includes
a status PDU as well */
#endif
- U32 staPduBo; /*!< Indicates the Status PDU BO.
+ uint32_t staPduBo; /*!< Indicates the Status PDU BO.
This is included in bo */
- U32 oldestSduArrTime;
+ uint32_t oldestSduArrTime;
} RguDBoReport;
/**
CmLteCellId cellId; /*!< CELL ID */
CmLteLcId lcId; /*!< Logical channel ID */
CmLteLcType lcType; /*!< Logical channel Type */
- U32 transId; /*!< Transaction ID */
+ uint32_t transId; /*!< Transaction ID */
#ifdef EMTC_ENABLE
- U8 pnb; /*Paging narrowBand on which UE performs Paging*/
+ uint8_t pnb; /*Paging narrowBand on which UE performs Paging*/
#endif
union{
CmLteTimingInfo timeToTx; /*!< Actual time when PHY transmits
typedef struct rguLchmapInfo
{
CmLteLcId lChId; /*!< Logical channel Id */
- U16 snList[RGU_MAX_LC]; /*!< Set of sequence numbers */
+ uint16_t snList[RGU_MAX_LC]; /*!< Set of sequence numbers */
}RguLchMapInfo;
/**
* @brief Sequence Number mapping info per TB
* */
typedef struct rguSnMapInfo
{
- U32 tbId; /*!< TB id for which sn info map */
- U8 numLch; /*!< Number of Ded Logical Channels */
+ uint32_t tbId; /*!< TB id for which sn info map */
+ uint8_t numLch; /*!< Number of Ded Logical Channels */
RguLchMapInfo lchMap[RGU_MAX_LC]; /*!< LC to SN Mapping Info*/
} RguSnMapInfo;
{
CmLteCellId cellId; /*!< Cell Id*/
CmLteRnti ueId; /*!< ue Id*/
- U8 numTbs; /*!< Number of Tbs present */
+ uint8_t numTbs; /*!< Number of Tbs present */
- U32 tbId[RGU_MAX_TB]; /*!< tbId provided by RLC in
+ uint32_t tbId[RGU_MAX_TB]; /*!< tbId provided by RLC in
DatReq */
- U16 status[RGU_MAX_TB]; /*!< Status back to RLC ACK/NACK*/
+ uint16_t status[RGU_MAX_TB]; /*!< Status back to RLC ACK/NACK*/
} RguHarqStatusInd;
/*
{
CmLteCellId cellId; /*!< Cell Id*/
CmLteRnti rnti; /*!< UE Id*/
- U8 numLcId; /*!< Number of LC Ids configured */
- U8 lcId[RGU_MAX_LC]; /*!< LC ID indices that are
+ uint8_t numLcId; /*!< Number of LC Ids configured */
+ uint8_t lcId[RGU_MAX_LC]; /*!< LC ID indices that are
configured */
Bool enbMeas; /*!< Indication to enable/disable
measurement for the LC ID*/
*/
typedef struct rguDatReqTb
{
- U8 nmbLch; /*!< Number of logical channels of a UE
+ uint8_t nmbLch; /*!< Number of logical channels of a UE
that have data for this TB */
RguLchDatReq lchData[RGU_MAX_LC]; /*!< Data Buffers and BO of
logical channels for this TB */
/* rgu_x_001.main_3 - ADD - L2M Support */
#ifdef LTE_L2_MEAS
- U32 tbId; /*!< RLC's internal tbId maintained
+ uint32_t tbId; /*!< RLC's internal tbId maintained
per UE */
#endif /* LTE_L2_MEAS */
}RguDatReqTb;
typedef struct rguDDatReqPerUe
{
CmLteRnti rnti; /*!< UE ID */
- U32 transId; /*!< Transaction ID */
- U8 nmbOfTbs; /*!< Number of TBs. Relevant for MIMO */
+ uint32_t transId; /*!< Transaction ID */
+ uint8_t nmbOfTbs; /*!< Number of TBs. Relevant for MIMO */
RguDatReqTb datReqTb[2]; /*!< DatReq info for MAX 2 TBs */
} RguDDatReqPerUe;
typedef struct rguDDatReqInfo
{
CmLteCellId cellId; /*!< CELL ID */
- U8 nmbOfUeGrantPerTti; /*!< Number of TBs. Relevant for MIMO */
+ uint8_t nmbOfUeGrantPerTti; /*!< Number of TBs. Relevant for MIMO */
RguDDatReqPerUe datReq[RGU_MAX_NUM_UE_PER_TTI]; /*!< Pointer to DatReq for MAX UEs configured Per TTI */
} RguDDatReqInfo;
*/
typedef struct rgL2MeasUlThrpTimInfo
{
- U32 thrpTimeUl; /*!< Difference in Timing values T1, T2 */
+ uint32_t thrpTimeUl; /*!< Difference in Timing values T1, T2 */
RguL2MUlThrpSegInd firstLastSegInd; /*!< Indication of Data Burst */
}RgL2MeasUlThrpTimInfo;
{
CmLteCellId cellId; /*!< CELL ID */
CmLteRnti rnti; /*!< UE ID */
- U8 numLch; /*!< Number of logical channels within
+ uint8_t numLch; /*!< Number of logical channels within
the UE that has data */
RguLchDatInd lchData[MAX_NUM_LC]; /*!< Data buffers of logical channels */
#ifdef LTE_L2_MEAS
- U32 ttiCnt; /*!< The Current TTI in the Cell */
- U8 burstInd; /*!< Indicates the Burst Start or End */
+ uint32_t ttiCnt; /*!< The Current TTI in the Cell */
+ uint8_t burstInd; /*!< Indicates the Burst Start or End */
#endif
} RguDDatIndInfo;
CmLteLcType lcType; /*!< Logical channel type */
S32 bo; /*!< Buffer occupancy reported by RLC */
#ifdef EMTC_ENABLE
- U8 emtcDiReason; /*!< Reason for DI message to send. */
- U8 pnb; /*paging narrowBand on which UE will perform paging*/
+ uint8_t emtcDiReason; /*!< Reason for DI message to send. */
+ uint8_t pnb; /*paging narrowBand on which UE will perform paging*/
#endif
union /*!< lcType in the primitive is
the union selector */
{
CmLteCellId cellId; /*!< CELL ID */
CmLteLcId lcId; /*!< Logical channel ID */
- U32 transId; /*!< Transaction ID */
+ uint32_t transId; /*!< Transaction ID */
CmLteRnti rnti; /*!< Temporary CRNTI */
#ifdef EMTC_ENABLE
Bool isEmtcPaging; /*!< To Identify whether Paging is EMTC or Lagecy */
*/
typedef struct rguStaIndTb
{
- U8 nmbLch; /*!< Number of logical channels scheduled
+ uint8_t nmbLch; /*!< Number of logical channels scheduled
for this TB */
RguLchStaInd lchStaInd[RGU_MAX_LC];/*!< Buffer size allocated for scheduled
logical channels for this TB */
#ifdef LTE_L2_MEAS
- U32 tbId; /*!< RLC internal TB id */
- U16 status; /*!< Status back to RLC ACK/NACK/RGU_NACK_LOSS */
+ uint32_t tbId; /*!< RLC internal TB id */
+ uint16_t status; /*!< Status back to RLC ACK/NACK/RGU_NACK_LOSS */
#endif
}RguStaIndTb;
/**
typedef struct rguDStaIndPerUe
{
CmLteRnti rnti; /*!< UE ID */
- U32 transId; /*!< Transaction ID */
- U8 nmbOfTbs; /*!< Number of TBs. Relevant for MIMO */
+ uint32_t transId; /*!< Transaction ID */
+ uint8_t nmbOfTbs; /*!< Number of TBs. Relevant for MIMO */
RguStaIndTb staIndTb[2]; /*!< StaInd info for MAX 2 TBs */
Bool fillCtrlPdu; /*!< Flag to fill RLC control PDU */
} RguDStaIndPerUe;
typedef struct rguDStaIndInfo
{
CmLteCellId cellId; /*!< CELL ID */
- U8 nmbOfUeGrantPerTti; /*!< Number of TBs. Relevant for MIMO */
+ uint8_t nmbOfUeGrantPerTti; /*!< Number of TBs. Relevant for MIMO */
RguDStaIndPerUe staInd[RGU_MAX_NUM_UE_PER_TTI]; /*!< StaInd info for MAX number of UEs per TTI */
} RguDStaIndInfo;
typedef struct rguLcFlowCntrlInfo
{
CmLteLcId lcId;
- U32 pktAdmitCnt;
- U32 maxBo4FlowCtrl; /*!< MAX BO of Queued SDUs at RLC beyond which Flow is Controlled */
+ uint32_t pktAdmitCnt;
+ uint32_t maxBo4FlowCtrl; /*!< MAX BO of Queued SDUs at RLC beyond which Flow is Controlled */
}RguLcFlowCntrlInfo;
/**
typedef struct rguUeFlowCntrlInfo
{
CmLteRnti ueId;
- U32 numLcs;
+ uint32_t numLcs;
RguLcFlowCntrlInfo lcInfo[RGU_MAX_LC];
}RguUeFlowCntrlInfo;
typedef struct rguFlowCntrlInd
{
CmLteCellId cellId; /*!< CELL ID */
- U32 numUes;
+ uint32_t numUes;
RguUeFlowCntrlInfo ueFlowCntrlInfo[RGU_MAX_NUM_UE_PER_TTI];
}RguFlowCntrlInd;
typedef struct rguInfoRingElem
{
SpId spId;
- U8 event;
+ uint8_t event;
Void *msg;
}RguInfoRingElem;
typedef S16 (*RguBndCfm) ARGS((
Pst* pst,
SuId suId,
- U8 status));
+ uint8_t status));
/** @brief Data Request from RLC to MAC for forwarding SDUs on common
* channel for transmission */
typedef S16 (*RguCDatReq) ARGS((
* @param status Status of the bind request.
* @return ROK/RFAILED
*/
-EXTERN S16 RgUiRguBndCfm ARGS((Pst* pst,SuId suId,U8 status));
+EXTERN S16 RgUiRguBndCfm ARGS((Pst* pst,SuId suId,uint8_t status));
/** @brief Data Request from RLC to MAC for forwarding SDUs on common
* channel for transmission
* @param pst Pointer to the post structure.
EXTERN S16 RlcLiRguBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/** @brief Request from RLC to MAC for forwarding SDUs on common
* channel for transmission */
EXTERN S16 cmPkRguBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/** @brief Confirmation from MAC to RLC for the bind/Unbind
* request for the interface saps */
#ifdef MSVER2 /* mos version 2 */
#define MINBUFSIZE (PTRALIGN(sizeof(SBuf)))
#define SBUFSIZE(size) (size < (Size) MINBUFSIZE ? (Size) MINBUFSIZE : (Size)PTRALIGN(size))
-#define SLockId U8 /* lock type */
+#define SLockId uint8_t /* lock type */
#define SInitLock(l, t) ((*l) = ROK)
#define SLock(l) ((*l) = ROK)
#define SUnlock(l) ((*l) = ROK)
#define OWNREGION DFLT_REGION /* own region */
/* lock data types */
-#define SsSemaId U8
-#define SLockId U8
+#define SsSemaId uint8_t
+#define SLockId uint8_t
/* ssi_h_001.main_143: Additions */
-#define SLockInfo U8
+#define SLockInfo uint8_t
/* basic lock types */
#define SS_LOCK_MUTEX 1
* allocation/de-allocation from static memory pool
*/
#ifdef SS_HISTOGRAM_SUPPORT
-#define SGetSBuf(region, pool, bufPtr, size) SGetSBufNew(region,pool,bufPtr,size, __LINE__, (U8*)__FILE__)
-#define SPutSBuf(region, pool, buf, size) SPutSBufNew(region, pool, buf, size, __LINE__, (U8*)__FILE__)
-#define SGetMsg(region, pool, mBufPtr) SGetMsgNew(region, pool, mBufPtr, __LINE__, (U8*)__FILE__)
-#define SPutMsg(mBuf) SPutMsgNew(mBuf, __LINE__, (U8*)__FILE__)
+#define SGetSBuf(region, pool, bufPtr, size) SGetSBufNew(region,pool,bufPtr,size, __LINE__, (uint8_t*)__FILE__)
+#define SPutSBuf(region, pool, buf, size) SPutSBufNew(region, pool, buf, size, __LINE__, (uint8_t*)__FILE__)
+#define SGetMsg(region, pool, mBufPtr) SGetMsgNew(region, pool, mBufPtr, __LINE__, (uint8_t*)__FILE__)
+#define SPutMsg(mBuf) SPutMsgNew(mBuf, __LINE__, (uint8_t*)__FILE__)
#elif defined(SS_LIGHT_MEM_LEAK_STS)
-#define SGetSBuf(region, pool, bufPtr, size) SGetSBufNew(region,pool,bufPtr,size, __LINE__, (U8*)__func__)
-#define SGetMsg(region, pool, mBufPtr) SGetMsgNew(region, pool, mBufPtr, __LINE__, (U8*)__func__)
-#define SGetDBuf(region, pool, bufPtr) SGetDBufNew(region,pool,bufPtr, __LINE__, (U8*)__func__)
-#define SPutSBuf(region, pool, buf, size) SPutSBufNew(region, pool, buf, size, __LINE__, (U8 *)__func__)
-#define SPutMsg(mBuf) SPutMsgNew(mBuf, __LINE__, (U8*)__func__)
-#define SPutDBuf(region, pool, buf) SPutDBufNew(region, pool, buf, __LINE__, (U8*)__func__)
+#define SGetSBuf(region, pool, bufPtr, size) SGetSBufNew(region,pool,bufPtr,size, __LINE__, (uint8_t*)__func__)
+#define SGetMsg(region, pool, mBufPtr) SGetMsgNew(region, pool, mBufPtr, __LINE__, (uint8_t*)__func__)
+#define SGetDBuf(region, pool, bufPtr) SGetDBufNew(region,pool,bufPtr, __LINE__, (uint8_t*)__func__)
+#define SPutSBuf(region, pool, buf, size) SPutSBufNew(region, pool, buf, size, __LINE__, (uint8_t *)__func__)
+#define SPutMsg(mBuf) SPutMsgNew(mBuf, __LINE__, (uint8_t*)__func__)
+#define SPutDBuf(region, pool, buf) SPutDBufNew(region, pool, buf, __LINE__, (uint8_t*)__func__)
#endif /* SS_HISTOGRAM_SUPPORT */
/* ssi_h_001.main_142 Readwrite additions */
/* ssi_h_001.main_144 Readwrite locks Guarded */
#define GetTIMETICK() 0
#endif
#ifdef PHY_SHUTDOWN_ENABLE
-#define stop_printf(...) do {EXTERN U8 sndPhyShutDwn;printf(__VA_ARGS__); mtStopHndlr(); sndPhyShutDwn = 1;} while (0)
+#define stop_printf(...) do {EXTERN uint8_t sndPhyShutDwn;printf(__VA_ARGS__); mtStopHndlr(); sndPhyShutDwn = 1;} while (0)
#else
#define stop_printf(...) do {printf(__VA_ARGS__); mtStopHndlr(); exit(-1);} while (0)
#endif
#ifdef MS_MUBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
#define MS_BUF_ADD_CALLER()\
{\
- extern U32 cmFreeCaller[4];\
+ extern uint32_t cmFreeCaller[4];\
if(cmFreeCaller[MxGetCpuID()] == NULLP)\
cmFreeCaller[MxGetCpuID()] = __return_address()-4;\
}
typedef S16 Status; /* status */
-typedef U32 Ticks; /* system clock ticks */
+typedef uint32_t Ticks; /* system clock ticks */
#ifdef LONG_MSG
typedef S32 MsgLen; /* message length */
typedef S16 Order; /* message or queue order */
#ifdef DOS
-typedef U16 Size; /* size (for number of bytes per region or per s-pool) */
+typedef uint16_t Size; /* size (for number of bytes per region or per s-pool) */
#else
-typedef U32 Size; /* size (for number of bytes per region or per s-pool) */
+typedef uint32_t Size; /* size (for number of bytes per region or per s-pool) */
typedef S32 PtrOff; /* signed pointer offset */
#endif
-typedef U32 QLen; /* queue length */
+typedef uint32_t QLen; /* queue length */
typedef QLen BufQLen; /* buffer queue length */
typedef S16 DPoolSize; /* dynamic pool size (for number of buffers per d-pool) */
-typedef U16 Random; /* random number */
+typedef uint16_t Random; /* random number */
typedef S16 Seq; /* sequence */
/* ssi_x_001.main_64 Additions */
-typedef U32 CoreId; /* core id */
+typedef uint32_t CoreId; /* core id */
/* Error */
-typedef U32 ErrCls; /* Error Class */
+typedef uint32_t ErrCls; /* Error Class */
-typedef U32 ErrCode; /* Error Code */
+typedef uint32_t ErrCode; /* Error Code */
-typedef U32 ErrVal; /* Error Value */
+typedef uint32_t ErrVal; /* Error Value */
typedef S16 VectNmb; /* vector number */
MsgLen msgLen; /* message length */
S16 refCnt; /* reference count */
Pst pst; /* post (optional) */
- U32 wsU32[2]; /* workspace unsigned 32 bit values (optional) */
- U16 wsU16[1]; /* workspace unsigned 16 bit values (optional) */
- U8 wsU8[2]; /* workspace unsigned 8 bit values (optional) */
+ uint32_t wsUInt32[2]; /* workspace unsigned 32 bit values (optional) */
+ uint16_t wsUInt16[1]; /* workspace unsigned 16 bit values (optional) */
+ uint8_t wsUInt8[2]; /* workspace unsigned 8 bit values (optional) */
} msg; /* message buffer */
struct
MsgLen endIdx; /* end index (2b) */
MsgLen size; /* size (2b) */
Pool pool; /* size (1b); Not used for MOS as of now */
- U8 spare; /* spare for alignment (1b) */
+ uint8_t spare; /* spare for alignment (1b) */
Data data[DSIZE]; /* data (4b) */
} Dat;
Buffer *nxtDBuf; /* next DBuf */
MsgLen msgLen; /* message length */
Pool pool; /* size (1b); Not used for MOS as of now */
- U8 spare; /* spare for alingment */
+ uint8_t spare; /* spare for alingment */
} Msg;
/* buffer - typedef'd earlier */
{
DChn dChn; /* dynamic chain */
S8 bufType; /* buffer type */
- U8 spare1; /* spare for alignment */
- U16 spare2; /* spare for alignment */
+ uint8_t spare1; /* spare for alignment */
+ uint16_t spare2; /* spare for alignment */
union {
Dat dat; /* data buffer */
Msg msg; /* message buffer */
SChn sChn; /* static chain */
Size size; /* size */
S8 bufType; /* buffer type */
- U8 spare1; /* spare 1 */
- U16 spare2; /* spare 2 */
+ uint8_t spare1; /* spare 1 */
+ uint16_t spare2; /* spare 2 */
};
EXTERN S16 msOptInd;
{
Buffer *fwd; /* forward chain pointer for queues */
Buffer *bck; /* backward chain pointer for queues */
- U16 mPid; /* VRTXsa memory partition ID */
+ uint16_t mPid; /* VRTXsa memory partition ID */
S16 start; /* starting index of message in byte array */
S16 end; /* ending index of message in byte array */
- U16 status; /* buffer status */
+ uint16_t status; /* buffer status */
};
/* chain */
MsgLen endIdx; /* end index */
MsgLen size; /* size */
Pool pool; /* pool id */
- U8 spare; /* spare */
+ uint8_t spare; /* spare */
Data *data; /* data */
} Dat;
Buffer *nxtDBuf; /* next DBuf */
MsgLen msgLen; /* message length */
Pool pool; /* pool id */
- U8 spare; /* spare */
+ uint8_t spare; /* spare */
} Msg;
/* buffer - typedef'd earlier */
{
DChn dChn; /* dynamic chain */
S8 bufType; /* buffer type */
- U8 spare1; /* spare for alignment */
- U16 spare2; /* spare for alignment */
+ uint8_t spare1; /* spare for alignment */
+ uint16_t spare2; /* spare for alignment */
union {
Dat dat; /* data buffer */
Msg msg; /* message buffer */
{
RyDChn dChn;
QLen crntSize; /* current size */
- U16 ryChanId; /* relay channel Id */
+ uint16_t ryChanId; /* relay channel Id */
};
/* buffer - typedef'd earlier */
MsgLen endIdx; /* end index */
MsgLen size; /* size */
Pool pool; /* pool id */
- U8 spare; /* spare */
+ uint8_t spare; /* spare */
Data *data; /* data */
} Dat;
Buffer *nxtDBuf; /* next DBuf */
MsgLen msgLen; /* message length */
Pool pool; /* pool id */
- U8 spare; /* spare */
+ uint8_t spare; /* spare */
} Msg;
/* buffer - typedef'd earlier */
{
DChn dChn; /* dynamic chain */
S8 bufType; /* buffer type */
- U8 spare1; /* spare for alignment */
- U16 spare2; /* spare for alignment */
+ uint8_t spare1; /* spare for alignment */
+ uint16_t spare2; /* spare for alignment */
union {
Dat dat; /* data buffer */
Msg msg; /* message buffer */
SChn sChn; /* static chain */
Size size; /* size */
S8 bufType; /* buffer type */
- U8 spare1; /* spare 1 */
- U16 spare2; /* spare 2 */
+ uint8_t spare1; /* spare 1 */
+ uint16_t spare2; /* spare 2 */
};
typedef S32 MtRwLockId;
/* task related stuff */
/* data range modified */
#ifndef SS_MULTIPLE_PROCS
-typedef U8 SSTskId; /* System Task Id */
+typedef uint8_t SSTskId; /* System Task Id */
#else /* SS_MULTIPLE_PROCS */
-typedef U16 SSTskId; /* System Task Id */
+typedef uint16_t SSTskId; /* System Task Id */
#endif /* SS_MULTIPLE_PROCS */
typedef S32 SSTskPrior; /* System Task Priority */
/* task related stuff */
/* data range modified */
#ifndef SS_MULTIPLE_PROCS
-typedef U8 SSTskId; /* System Task Id */
+typedef uint8_t SSTskId; /* System Task Id */
#else /* SS_MULTIPLE_PROCS */
-typedef U16 SSTskId; /* System Task Id */
+typedef uint16_t SSTskId; /* System Task Id */
#endif /* SS_MULTIPLE_PROCS */
typedef S32 SSTskPrior; /* System Task Priority */
struct ssmsgb *b_next; /* next message */
struct ssmsgb *b_prev; /* previous message */
struct ssmsgb *b_cont; /* next message block */
- U8 *b_rptr; /* 1st unread data byte of buffer */
- U8 *b_wptr; /* 1st unwritten data byte of buffer */
+ uint8_t *b_rptr; /* 1st unread data byte of buffer */
+ uint8_t *b_wptr; /* 1st unwritten data byte of buffer */
struct ssdatab *b_datap; /* pointer to data block */
};
/* Memory CTL operations structure */
typedef struct sMemCtl
{
- U8 op; /* operation */
+ uint8_t op; /* operation */
union
{
/* ssi_x_001.main_57 : Additions */
#ifdef SS_HISTOGRAM_SUPPORT
#ifdef SSI_DEBUG_LEVEL1
-typedef S16 (*SsAlloc) ARGS((Void *, Size *, U32, Data **, U32, U32, U8*, U8, Bool));
+typedef S16 (*SsAlloc) ARGS((Void *, Size *, uint32_t, Data **, uint32_t, uint32_t, uint8_t*, uint8_t, Bool));
#else
-typedef S16 (*SsAlloc) ARGS((Void *, Size *, U32, Data **, U32, U8*, U8, Bool));
+typedef S16 (*SsAlloc) ARGS((Void *, Size *, uint32_t, Data **, uint32_t, uint8_t*, uint8_t, Bool));
#endif /* SSI_DEBUG_LEVEL1 */
-typedef S16 (*SsFree) ARGS((Void *, Data *, Size, U32, U8*, U8, Bool));
+typedef S16 (*SsFree) ARGS((Void *, Data *, Size, uint32_t, uint8_t*, uint8_t, Bool));
typedef S16 (*SsCtl) ARGS((Void *, Event, SMemCtl *));
#elif defined(SS_LIGHT_MEM_LEAK_STS)
-typedef S16 (*SsAlloc) ARGS((Void *, Size *, U32 , Data **, U32, U32 , U8 *));
-typedef S16 (*SsFree) ARGS((Void *, Data *, Size, U32, U8 *));
+typedef S16 (*SsAlloc) ARGS((Void *, Size *, uint32_t , Data **, uint32_t, uint32_t , uint8_t *));
+typedef S16 (*SsFree) ARGS((Void *, Data *, Size, uint32_t, uint8_t *));
typedef S16 (*SsCtl) ARGS((Void *, Event, SMemCtl *));
#else
#ifdef SSI_DEBUG_LEVEL1
-typedef S16 (*SsAlloc) ARGS((Void *, Size *, U32, Data **, U32));
+typedef S16 (*SsAlloc) ARGS((Void *, Size *, uint32_t, Data **, uint32_t));
#else
#ifdef T2K_MEM_LEAK_DBG
-typedef S16 (*SsAlloc) ARGS((Void *, Size *, U32, Data **,char*, U32));
+typedef S16 (*SsAlloc) ARGS((Void *, Size *, uint32_t, Data **,char*, uint32_t));
#else
-typedef S16 (*SsAlloc) ARGS((Void *, Size *, U32, Data **));
+typedef S16 (*SsAlloc) ARGS((Void *, Size *, uint32_t, Data **));
#endif
#endif /* SSI_DEBUG_LEVEL1 */
#ifdef T2K_MEM_LEAK_DBG
-typedef S16 (*SsFree) ARGS((Void *, Data *, Size,char*, U32));
+typedef S16 (*SsFree) ARGS((Void *, Data *, Size,char*, uint32_t));
#else
typedef S16 (*SsFree) ARGS((Void *, Data *, Size));
#endif
typedef struct sRegInfo
{
Void *regCb; /* region control block pointer */
- U32 flags; /* region characteristics flags */
+ uint32_t flags; /* region characteristics flags */
/* ssi_x_001.main_64 Additions */
#ifdef SS_CAVIUM
cvmx_arena_list_t regArena; /* arena for the region */
/*
typedef struct entInfo
{
- U8 entid;
+ uint8_t entid;
}EntInfo;
typedef struct secondIndex
/* procId and control block added */
#ifndef SS_MULTIPLE_PROCS
-typedef S16 (*PAIFS16) ARGS((Ent ent,Inst inst,Region region,Reason reason ));
+typedef uint8_t (*PAIFS16) ARGS((Ent ent,Inst inst,Region region,Reason reason ));
/* ssi_x_001.main_54 */
/* ssi_x_001.main_53 */
/* ssi_x_001.main_69: Removed the SS_MT_TMR guard from PAIFTMRS16
typedef S16 (*PAIFTMRS16) ARGS((Ent ent, Inst inst));
#else
-typedef S16 (*PAIFS16) ARGS((ProcId proc,
+typedef uint8_t (*PAIFS16) ARGS((ProcId proc,
Ent ent,
Inst inst,
Region region,
ProcId low; /* procId low value */
ProcId high; /* procId high value */
ActvTsk actvTsk; /* activation function for drvr task */
- U16 isFlag; /* interrupt service flag */
+ uint16_t isFlag; /* interrupt service flag */
ISTsk isTsk; /* interrupt service task */
};
EXTERN S16 rdConQ ARGS((Data data));
EXTERN S16 SPkS8 ARGS((S8 val,Buffer *mBuf));
-EXTERN S16 oduUnpackUInt8 ARGS((U8 val,Buffer *mBuf));
+EXTERN S16 oduUnpackUInt8 ARGS((uint8_t val,Buffer *mBuf));
EXTERN S16 SPkS16 ARGS((S16 val,Buffer *mBuf));
-EXTERN S16 oduUnpackUInt16 ARGS((U16 val,Buffer *mBuf));
+EXTERN S16 oduUnpackUInt16 ARGS((uint16_t val,Buffer *mBuf));
EXTERN S16 SPkS32 ARGS((S32 val,Buffer *mBuf));
-EXTERN S16 oduUnpackUInt32 ARGS((U32 val,Buffer *mBuf));
+EXTERN S16 oduUnpackUInt32 ARGS((uint32_t val,Buffer *mBuf));
/* ssi_x_001.main_49 : added packing of F32 and F64*/
#ifdef SS_FLOAT
EXTERN S16 SPkF32 ARGS((F32 val,Buffer *mBuf));
EXTERN S16 SPkF64 ARGS((F64 val,Buffer *mBuf));
#endif /* SS_FLOAT */
EXTERN S16 SUnpkS8 ARGS((S8 *val,Buffer *mBuf));
-EXTERN S16 oduPackUInt8 ARGS((U8 *val,Buffer *mBuf));
+EXTERN S16 oduPackUInt8 ARGS((uint8_t *val,Buffer *mBuf));
EXTERN S16 SUnpkS16 ARGS((S16 *val,Buffer *mBuf));
-EXTERN S16 oduPackUInt16 ARGS((U16 *val,Buffer *mBuf));
+EXTERN S16 oduPackUInt16 ARGS((uint16_t *val,Buffer *mBuf));
EXTERN S16 SUnpkS32 ARGS((S32 *val,Buffer *mBuf));
-EXTERN S16 oduPackUInt32 ARGS((U32 *val,Buffer *mBuf));
+EXTERN S16 oduPackUInt32 ARGS((uint32_t *val,Buffer *mBuf));
/* ssi_x_001.main_49 : added unpacking of F32 and F64*/
#ifdef SS_FLOAT
EXTERN S16 SUnpkF32 ARGS((F32 *val,Buffer *mBuf));
#ifdef T2K_MEM_LEAK_DBG
#define SGetDBuf(region,pool,buf) SGetDBufNew(region,pool,buf,__FILE__,__LINE__)
#define SPutDBuf(region,pool,buf) SPutDBufNew(region,pool,buf,file,line)
-EXTERN S16 SGetDBufNew ARGS((Region region,Pool pool,Buffer * *bufPtr,char*,U32));
-EXTERN S16 SPutDBufNew ARGS((Region region,Pool pool,Buffer *buf,char*,U32));
+EXTERN S16 SGetDBufNew ARGS((Region region,Pool pool,Buffer * *bufPtr,char*,uint32_t));
+EXTERN S16 SPutDBufNew ARGS((Region region,Pool pool,Buffer *buf,char*,uint32_t));
EXTERN S16 SAttachPtrToBufNew ARGS((Region region, Pool pool, Data
- *ptr, MsgLen totalLen, Buffer** mBuf, char* file, U32 line));
+ *ptr, MsgLen totalLen, Buffer** mBuf, char* file, uint32_t line));
#define SAttachPtrToBuf(region,pool,ptr,totalLen,mBuf) SAttachPtrToBufNew(region,pool,ptr,totalLen,mBuf,__FILE__,__LINE__)
#define SPutZbcDBuf(region,buf) SPutZbcDBufNew(region,buf,__FILE__,__LINE__)
#elif SS_LIGHT_MEM_LEAK_STS
-EXTERN S16 SGetDBufNew ARGS((Region region,Pool pool,Buffer * *bufPtr,U32 line,U8 *fnName));
-EXTERN S16 SPutDBufNew ARGS((Region region,Pool pool,Buffer *buf, U32 line, U8 *fnName));
+EXTERN S16 SGetDBufNew ARGS((Region region,Pool pool,Buffer * *bufPtr,uint32_t line,uint8_t *fnName));
+EXTERN S16 SPutDBufNew ARGS((Region region,Pool pool,Buffer *buf, uint32_t line, uint8_t *fnName));
#else
EXTERN S16 SGetDBuf ARGS((Region region,Pool pool,Buffer * *bufPtr));
#ifdef T2K_MEM_LEAK_DBG
#define SGetDBuf(region,pool,buf) SGetDBufNew(region,pool,buf,__FILE__,__LINE__)
#define SPutDBuf(region,pool,buf) SPutDBufNew(region,pool,buf,__FILE__,__LINE__)
-EXTERN S16 SGetDBufNew ARGS((Region region,Pool pool,Buffer * *bufPtr,char*,U32));
-EXTERN S16 SPutDBufNew ARGS((Region region,Pool pool,Buffer *buf,char*,U32));
+EXTERN S16 SGetDBufNew ARGS((Region region,Pool pool,Buffer * *bufPtr,char*,uint32_t));
+EXTERN S16 SPutDBufNew ARGS((Region region,Pool pool,Buffer *buf,char*,uint32_t));
#elif SS_LIGHT_MEM_LEAK_STS
-EXTERN S16 SGetDBufNew ARGS((Region region,Pool pool,Buffer * *bufPtr,U32 line,U8 *fnName));
-EXTERN S16 SPutDBufNew ARGS((Region region,Pool pool,Buffer *buf, U32 line, U8 *fnName));
+EXTERN S16 SGetDBufNew ARGS((Region region,Pool pool,Buffer * *bufPtr,uint32_t line,uint8_t *fnName));
+EXTERN S16 SPutDBufNew ARGS((Region region,Pool pool,Buffer *buf, uint32_t line, uint8_t *fnName));
#else
EXTERN S16 SGetDBuf ARGS((Region region,Pool pool,Buffer * *bufPtr));
EXTERN S16 SPutDBuf ARGS((Region region,Pool pool,Buffer *buf));
/* ssi_x_001.main_57 : Additions */
/* ssi_x_001.main_59 : Added compile time flag */
#ifdef SS_LIGHT_MEM_LEAK_STS
-EXTERN S16 SGetMsgNew ARGS((Region region, Pool pool, Buffer * *mBufPtr, U32 line, U8 *fnName));
-EXTERN S16 SGetSBufNew ARGS((Region region,Pool pool, Data * *bufPtr, Size size, U32 line, U8* fnName));
-EXTERN S16 SPutMsgNew ARGS((Buffer *mBuf, U32 line, U8 *fnName));
-EXTERN S16 SPutSBufNew ARGS((Region region, Pool pool, Data *buf, Size size, U32 line, U8 *fnName));
+EXTERN S16 SGetMsgNew ARGS((Region region, Pool pool, Buffer * *mBufPtr, uint32_t line, uint8_t *fnName));
+EXTERN S16 SGetSBufNew ARGS((Region region,Pool pool, Data * *bufPtr, Size size, uint32_t line, uint8_t* fnName));
+EXTERN S16 SPutMsgNew ARGS((Buffer *mBuf, uint32_t line, uint8_t *fnName));
+EXTERN S16 SPutSBufNew ARGS((Region region, Pool pool, Data *buf, Size size, uint32_t line, uint8_t *fnName));
#else /*SS_LIGHT_MEM_LEAK_STS */
#ifdef SS_HISTOGRAM_SUPPORT
-EXTERN S16 SPutMsgNew ARGS((Buffer *mBuf, U32 line, U8 *fileName));
-EXTERN S16 SGetMsgNew ARGS((Region region, Pool pool, Buffer * *mBufPtr, U32 line, U8 *fileName));
-EXTERN S16 SGetSBufNew ARGS((Region region,Pool pool, Data * *bufPtr, Size size, U32 line, U8 *fileName));
-EXTERN S16 SPutSBufNew ARGS((Region region, Pool pool, Data *buf, Size size, U32 line, U8 *fileName));
+EXTERN S16 SPutMsgNew ARGS((Buffer *mBuf, uint32_t line, uint8_t *fileName));
+EXTERN S16 SGetMsgNew ARGS((Region region, Pool pool, Buffer * *mBufPtr, uint32_t line, uint8_t *fileName));
+EXTERN S16 SGetSBufNew ARGS((Region region,Pool pool, Data * *bufPtr, Size size, uint32_t line, uint8_t *fileName));
+EXTERN S16 SPutSBufNew ARGS((Region region, Pool pool, Data *buf, Size size, uint32_t line, uint8_t *fileName));
#else
/*ssi_x_001.main_67 : RMIOS specific changes*/
#ifndef SS_RMIOS
#ifdef T2K_MEM_LEAK_DBG
#define SPutMsg(mBuf) SPutMsgNew(mBuf,__FILE__,__LINE__)
#define SGetMsg(region,pool,mBuf) SGetMsgNew(region,pool,mBuf,__FILE__,__LINE__)
-EXTERN S16 SPutMsgNew ARGS((Buffer *mBuf,char*, U32));
-EXTERN S16 SGetMsgNew ARGS((Region region, Pool pool, Buffer * *mBufPtr, char*,U32));
+EXTERN S16 SPutMsgNew ARGS((Buffer *mBuf,char*, uint32_t));
+EXTERN S16 SGetMsgNew ARGS((Region region, Pool pool, Buffer * *mBufPtr, char*,uint32_t));
#else
EXTERN S16 SPutMsg ARGS((Buffer *mBuf));
EXTERN S16 SGetMsg ARGS((Region region, Pool pool, Buffer * *mBufPtr));
#endif
#if (defined(SSI_STATIC_MEM_LEAK_DETECTION)|| defined(T2K_MEM_LEAK_DBG))
#define SGetSBuf(region,pool,bufPtr,size) SGetSBuf1(region,pool,bufPtr,size,__FILE__,__LINE__)
-EXTERN S16 SGetSBuf1 ARGS((Region region,Pool pool, Data * *bufPtr, Size size, char* file, U32 line));
+EXTERN S16 SGetSBuf1 ARGS((Region region,Pool pool, Data * *bufPtr, Size size, char* file, uint32_t line));
EXTERN void DumpStaticMemLeakFiles ARGS((void));
EXTERN void DumpT2kMemLeakInfoToFile ARGS((void));
#define SPutSBuf(region,pool,buf,size) SPutSBuf1(region,pool,buf,size,__FILE__,__LINE__)
-EXTERN S16 SPutSBuf1 ARGS((Region region, Pool pool, Data *buf, Size size, char*, U32));
+EXTERN S16 SPutSBuf1 ARGS((Region region, Pool pool, Data *buf, Size size, char*, uint32_t));
#else
EXTERN S16 SGetSBuf ARGS((Region region,Pool pool, Data * *bufPtr, Size size));
EXTERN S16 SPutSBuf ARGS((Region region, Pool pool, Data *buf, Size size));
#ifdef T2K_MEM_LEAK_DBG
#define SGetSBufWls(region,pool,bufPtr,size) SGetSBufWls1(region,pool,bufPtr,size,__FILE__,__LINE__)
#define SPutSBufWls(region,pool,bufPtr,size) SPutSBufWls1(region,pool,bufPtr,size,__FILE__,__LINE__)
-EXTERN S16 SPutSBufWls1(Region region, Pool pool, Data *ptr, Size size,char* file, U32 line);
-EXTERN S16 SGetSBufWls1(Region region, Pool pool, Data **ptr, Size size,char* file, U32 line);
+EXTERN S16 SPutSBufWls1(Region region, Pool pool, Data *ptr, Size size,char* file, uint32_t line);
+EXTERN S16 SGetSBufWls1(Region region, Pool pool, Data **ptr, Size size,char* file, uint32_t line);
#define SAttachWlsPtrToMBuf(region,pool,bufPtr,rPtr,size,pLen,mBuf) SAttachWlsPtrToMBuf1(region,pool,bufPtr,rPtr,size,pLen,mBuf,__FILE__,__LINE__)
-EXTERN S16 SAttachWlsPtrToMBuf1(Region region, Pool pool, Data *ptr, Data *readPtr, MsgLen totalLen, MsgLen ptrLen, Buffer** mBuf,char* file, U32 line);
+EXTERN S16 SAttachWlsPtrToMBuf1(Region region, Pool pool, Data *ptr, Data *readPtr, MsgLen totalLen, MsgLen ptrLen, Buffer** mBuf,char* file, uint32_t line);
#define SAttachPtrToMBuf(region,pool,bufPtr,size,pLen,mBuf) SAttachPtrToMBuf1(region,pool,bufPtr,size,pLen,mBuf,__FILE__,__LINE__)
#else
EXTERN S16 SAttachWlsPtrToMBuf(Region region, Pool pool, Data *ptr, Data *readPtr, MsgLen totalLen, MsgLen ptrLen, Buffer** mBuf);
#endif
#endif
-EXTERN S16 SGetStaticBuffer ARGS((Region region,Pool pool, Data * *bufPtr, Size size, U8 memType));
-EXTERN S16 SPutStaticBuffer ARGS((Region region, Pool pool, Data *buf, Size size, U8 memType));
+EXTERN S16 SGetStaticBuffer ARGS((Region region,Pool pool, Data * *bufPtr, Size size, uint8_t memType));
+EXTERN S16 SPutStaticBuffer ARGS((Region region, Pool pool, Data *buf, Size size, uint8_t memType));
/* ssi_x_001.main_65: Additions */
#ifdef SS_SEUM_CAVIUM
EXTERN S16 ssInitRcvWork ARGS((void));
#define SAddPreMsgMult(src, cnt, mBuf) SAddPreMsgMult1(src, cnt, mBuf, __FILE__,__LINE__)
#define SAddPstMsgMult(src, cnt, mBuf) SAddPstMsgMult1(src, cnt, mBuf, __FILE__,__LINE__)
-EXTERN S16 SAddPreMsgMult1 ARGS((Data *src,MsgLen cnt,Buffer *mBuf, char *file, U32 line));
-EXTERN S16 SAddPstMsgMult1 ARGS((Data *src,MsgLen cnt,Buffer *mBuf, char *file, U32 line));
+EXTERN S16 SAddPreMsgMult1 ARGS((Data *src,MsgLen cnt,Buffer *mBuf, char *file, uint32_t line));
+EXTERN S16 SAddPstMsgMult1 ARGS((Data *src,MsgLen cnt,Buffer *mBuf, char *file, uint32_t line));
#else
EXTERN S16 SAddPreMsgMult ARGS((Data *src,MsgLen cnt,Buffer *mBuf));
EXTERN S16 SAddPstMsgMult ARGS((Data *src,MsgLen cnt,Buffer *mBuf));
EXTERN S16 SCatMsg ARGS((Buffer *mBuf1,Buffer *mBuf2,Order order));
#ifdef T2K_MEM_LEAK_DBG
#define SSegMsg(mBuf1, idx, mBuf2) SSegMsgNew(mBuf1, idx, mBuf2, __FILE__, __LINE__)
-EXTERN S16 SSegMsgNew ARGS((Buffer *mBuf1,MsgLen idx,Buffer **mBuf2,char*,U32));
+EXTERN S16 SSegMsgNew ARGS((Buffer *mBuf1,MsgLen idx,Buffer **mBuf2,char*,uint32_t));
#else
EXTERN S16 SSegMsg ARGS((Buffer *mBuf1,MsgLen idx,Buffer **mBuf2));
#endif
#define SAddMsgRef(mBuf,region,pool,dstBuf) SAddMsgRefNew(mBuf,region,pool,dstBuf,__FILE__,__LINE__)
#define SCpyMsgMsg(mBuf,region,pool, dstBuf) SCpyMsgMsgNew(mBuf,region,pool, dstBuf, __FILE__, __LINE__)
EXTERN S16 SAddMsgRefNew ARGS((Buffer *mBuf, Region region, Pool pool,
- Buffer **dstBuf,char*,U32));
+ Buffer **dstBuf,char*,uint32_t));
EXTERN S16 SCpyMsgMsgNew ARGS((Buffer *mBuf, Region region, Pool pool,
- Buffer **dstBuf,char* , U32));
+ Buffer **dstBuf,char* , uint32_t));
#else
EXTERN S16 SCpyMsgMsg ARGS((Buffer *mBuf, Region region, Pool pool,
Buffer **dstBuf));
#endif
#endif
EXTERN S16 SChkRes ARGS((Region region,Pool pool,Status *status));
-EXTERN S16 SChkResUtl ARGS((Region region,U8 *wSum));
+EXTERN S16 SChkResUtl ARGS((Region region,uint8_t *wSum));
EXTERN S16 SSetDateTime ARGS((DateTime *dt));
EXTERN S16 SGetDateTime ARGS((DateTime *dt));
#ifdef L2_OPTMZ
/* ssi_x_001.main_48: Added Timestamp changes */
EXTERN S16 SGetTimeStamp ARGS(( S8 *ts));
EXTERN S16 SGetSysTime ARGS((Ticks *sysTime));
-EXTERN S16 SGetRefTime ARGS((U32 refTime, U32 *sec, U32 *usec));
+EXTERN S16 SGetRefTime ARGS((uint32_t refTime, uint32_t *sec, uint32_t *usec));
EXTERN S16 SRandom ARGS((Random *value));
EXTERN S16 SError ARGS((Seq seq,Reason reason));
EXTERN Void SLogError ARGS((Ent ent, Inst inst, ProcId procId, Txt *file,
S32 line, ErrCls errCls, ErrCode errCode,
ErrVal errVal, Txt *errDesc));
/* ssi_x_001.main_49 : added prototype for SGetSystemTsk() */
-EXTERN U32 SGetSystemTsk ARGS ((Void));
+EXTERN uint32_t SGetSystemTsk ARGS ((Void));
/* changes to support multiple processors in single SSI */
/* multiple proc id changes:
these functions are not supported with multiple proc Ids */
typedef struct {
- U32 numCores; /* total number of cores available */
- U32 threadsPerCore; /* total number of threads available per core */
- U32 threadRegister[SS_MAX_CORES]; /* available threads per core */
+ uint32_t numCores; /* total number of cores available */
+ uint32_t threadsPerCore; /* total number of threads available per core */
+ uint32_t threadRegister[SS_MAX_CORES]; /* available threads per core */
} SCpuInfo;
EXTERN S16 SRegCpuInfo ARGS((SCpuInfo *cpuInfo));
-EXTERN S16 SSetAffinity ARGS((SSTskId *tskId, SsAffinityMode mode, U32 coreId, SSTskId *tskAssociatedTskId));
-EXTERN S16 SGetAffinity ARGS((SSTskId *tskId, U32 *coreId));
+EXTERN S16 SSetAffinity ARGS((SSTskId *tskId, SsAffinityMode mode, uint32_t coreId, SSTskId *tskAssociatedTskId));
+EXTERN S16 SGetAffinity ARGS((SSTskId *tskId, uint32_t *coreId));
#endif /* SS_MULTICORE_SUPPORT || SS_AFFINITY_SUPPORT*/
EXTERN S16 SGetDataRx ARGS((Buffer *dBuf, MsgLen pad, Data **dat, MsgLen *mLen));
EXTERN S16 SGetDataTx ARGS((Buffer *dBuf, Data **dat, MsgLen *mLen));
EXTERN S16 SUpdMsg ARGS((Buffer *mBuf, Buffer *dBuf, MsgLen mLen));
-EXTERN S16 SCacheFlush ARGS( (U16 cache_type, Data *addr, Size size));
-EXTERN S16 SCacheInvalidate ARGS( (U16 cache_type, Data *addr, Size size));
+EXTERN S16 SCacheFlush ARGS( (uint16_t cache_type, Data *addr, Size size));
+EXTERN S16 SCacheInvalidate ARGS( (uint16_t cache_type, Data *addr, Size size));
EXTERN S16 SAlignDBufEven ARGS((Buffer *dBuf));
-EXTERN S16 SAlignDBuf ARGS((Buffer *dBuf, U32 align));
+EXTERN S16 SAlignDBuf ARGS((Buffer *dBuf, uint32_t align));
EXTERN S16 SInitNxtDBuf ARGS((Buffer *mBuf));
EXTERN S16 SGetNxtDBuf ARGS((Buffer *mBuf, Buffer **dBuf));
EXTERN S16 SChkNxtDBuf ARGS((Buffer *mBuf));
-EXTERN S16 SSetIntPend ARGS((U16 id, Bool flag));
+EXTERN S16 SSetIntPend ARGS((uint16_t id, Bool flag));
EXTERN S16 SChkMsg ARGS((Buffer *mBuf));
EXTERN S16 SDeregInitTskTmr ARGS((Ent ent,Inst inst));
EXTERN S16 SExitTsk ARGS((void ));
#ifdef WINNT_KERN
EXTERN S16 SPutIsrDpr ARGS((VectNmb vectNmb, Void *context, PIF isrFnct,
PIF dprFnct));
-EXTERN S16 SSyncInt ARGS((U16 adapterNmb, PFVOID syncFnct,
+EXTERN S16 SSyncInt ARGS((uint16_t adapterNmb, PFVOID syncFnct,
Void *syncContext));
#endif
EXTERN S16 SInitSema ARGS((Region region, Sema *sema));
#ifndef SS_FAP
/* ssi_x_001.main_57 : Additions */
#ifdef SS_HISTOGRAM_SUPPORT
-EXTERN S16 SAlloc ARGS((Region region, Size *size, U32 flags, Data **ptr,U32 line, U8 *fileName, U8 entId));
-EXTERN S16 SFree ARGS((Region region, Data *ptr, Size size, U32 line, U8 *fileName, U8 entId));
+EXTERN S16 SAlloc ARGS((Region region, Size *size, uint32_t flags, Data **ptr,uint32_t line, uint8_t *fileName, uint8_t entId));
+EXTERN S16 SFree ARGS((Region region, Data *ptr, Size size, uint32_t line, uint8_t *fileName, uint8_t entId));
#else
#ifdef T2K_MEM_LEAK_DBG
#define SAlloc(region,size,flags,ptr) SAllocNew(region,size,flags,ptr,file,line)
#define SFree(region,ptr,size) SFreeNew(region,ptr,size,file,line)
-EXTERN S16 SAllocNew ARGS((Region region, Size *size, U32 flags, Data **ptr,char*,U32));
-EXTERN S16 SFreeNew ARGS((Region region, Data *ptr, Size size,char*,U32));
+EXTERN S16 SAllocNew ARGS((Region region, Size *size, uint32_t flags, Data **ptr,char*,uint32_t));
+EXTERN S16 SFreeNew ARGS((Region region, Data *ptr, Size size,char*,uint32_t));
#elif defined(SS_LIGHT_MEM_LEAK_STS)
-EXTERN S16 SAlloc ARGS((Region region, Size *size, U32 flags, Data **ptr,U32 line, U8 *fnName));
-EXTERN S16 SFree ARGS((Region region, Data *ptr, Size size, U32 line, U8 *fnName));
+EXTERN S16 SAlloc ARGS((Region region, Size *size, uint32_t flags, Data **ptr,uint32_t line, uint8_t *fnName));
+EXTERN S16 SFree ARGS((Region region, Data *ptr, Size size, uint32_t line, uint8_t *fnName));
#else
-EXTERN S16 SAlloc ARGS((Region region, Size *size, U32 flags, Data **ptr));
+EXTERN S16 SAlloc ARGS((Region region, Size *size, uint32_t flags, Data **ptr));
EXTERN S16 SFree ARGS((Region region, Data *ptr, Size size));
#endif
#endif
EXTERN S16 SThreadYield ARGS((void));
#endif /* SS_OLD_THREAD */
-EXTERN S16 SInitLock ARGS((SLockId *lock,U8 type));
+EXTERN S16 SInitLock ARGS((SLockId *lock,uint8_t type));
EXTERN S16 SLock ARGS((SLockId *lock));
EXTERN S16 SUnlock ARGS((SLockId *lock));
EXTERN S16 SDestroyLock ARGS((SLockId *lock));
-EXTERN S16 SInitSemaphore ARGS((SsSemaId *sem, U8 value));
+EXTERN S16 SInitSemaphore ARGS((SsSemaId *sem, uint8_t value));
EXTERN S16 SWaitSemaphore ARGS((SsSemaId *sem));
EXTERN S16 SPostSemaphore ARGS((SsSemaId *sem));
EXTERN S16 SDestroySemaphore ARGS((SsSemaId *sem));
/* multiple proc id changes:
new function required to implement multiple procIds */
#ifdef SS_MULTIPLE_PROCS
-EXTERN S16 SAddProcIdLst ARGS((U16 numPIds, ProcId *pIdLst));
-EXTERN S16 SRemProcIdLst ARGS((U16 numPIds, ProcId *pIdLst));
-EXTERN S16 SGetProcIdLst ARGS((U16 *numPIds, ProcId *pIdLst));
+EXTERN S16 SAddProcIdLst ARGS((uint16_t numPIds, ProcId *pIdLst));
+EXTERN S16 SRemProcIdLst ARGS((uint16_t numPIds, ProcId *pIdLst));
+EXTERN S16 SGetProcIdLst ARGS((uint16_t *numPIds, ProcId *pIdLst));
#endif /* SS_MULTIPLE_PROCS */
#endif /* SS */
EXTERN S16 SGetBufRegionPool ARGS((Buffer *mBuf, Region *region, Pool *pool));
#endif /* SS_ENABLE_MACROS */
-EXTERN S16 SInitLock ARGS((SLockId *lock,U8 type));
+EXTERN S16 SInitLock ARGS((SLockId *lock,uint8_t type));
EXTERN S16 SLock ARGS((SLockId *lock));
EXTERN S16 SUnlock ARGS((SLockId *lock));
EXTERN S16 SDestroyLock ARGS((SLockId *lock));
-EXTERN S16 SInitSemaphore ARGS((SsSemaId *sem, U8 value));
+EXTERN S16 SInitSemaphore ARGS((SsSemaId *sem, uint8_t value));
EXTERN S16 SWaitSemaphore ARGS((SsSemaId *sem));
EXTERN S16 SPostSemaphore ARGS((SsSemaId *sem));
EXTERN S16 SDestroySemaphore ARGS((SsSemaId *sem));
/* functions required to implement multiple procIds */
#ifdef SS_MULTIPLE_PROCS
-EXTERN S16 SAddProcIdLst ARGS((U16 numPIds, ProcId *pIdLst));
-EXTERN S16 SRemProcIdLst ARGS((U16 numPIds, ProcId *pIdLst));
-EXTERN S16 SGetProcIdLst ARGS((U16 *numPIds, ProcId *pIdLst));
+EXTERN S16 SAddProcIdLst ARGS((uint16_t numPIds, ProcId *pIdLst));
+EXTERN S16 SRemProcIdLst ARGS((uint16_t numPIds, ProcId *pIdLst));
+EXTERN S16 SGetProcIdLst ARGS((uint16_t *numPIds, ProcId *pIdLst));
#endif /* SS_MULTIPLE_PROCS */
#endif /* PORTVER */
*/
/* ssi_x_001.main_51 : Added control flag as these are only used by windows */
#ifdef SS_WIN
-EXTERN S16 WTInitLock ARGS((SLockId *lock,U8 type));
+EXTERN S16 WTInitLock ARGS((SLockId *lock,uint8_t type));
EXTERN S16 WTLock ARGS((SLockId *lock));
EXTERN S16 WTUnlock ARGS((SLockId *lock));
EXTERN S16 WTDestroyLock ARGS((SLockId *lock));
#endif /* End of SS_WIN */
/* ssi_x_001.main_57 : Additions */
#ifdef SS_LOGGER_SUPPORT
-EXTERN S16 SRegLogCfg ARGS(( U8 mode, S8 *path, U32 size, S8 *IPA, U16 port));
+EXTERN S16 SRegLogCfg ARGS(( uint8_t mode, S8 *path, uint32_t size, S8 *IPA, uint16_t port));
EXTERN S16 SWrtLogBuf ARGS(( Txt *buf ));
/* ssi_x_001.main_60 */
EXTERN S16 SDeregLogCfg ARGS((Void ));
EXTERN S16 SRegForHstGrm ARGS((Ent ent));
EXTERN S16 SHstGrmInfoShow ARGS((Ent *entId));
EXTERN S16 SFillEntIds ARGS((Void));
-EXTERN S16 SGetEntInd ARGS((Ent *entId, U8 *fileName));
+EXTERN S16 SGetEntInd ARGS((Ent *entId, uint8_t *fileName));
#endif /* SS_HISTOGRAM_SUPPORT */
/* ssi_x_001.main_68 Multiple declaration removed , one already in cm_task.x */
/* ssi_x_001.main_61: Lock support guraded under the flag */
#ifdef SS_LOCK_SUPPORT
-EXTERN S16 SLockNew ARGS((SLockInfo *LockId, U8 lockType));
-EXTERN S16 SInitLockNew ARGS((SLockInfo *LockId, U8 lockType));
-EXTERN S16 SUnlockNew ARGS((SLockInfo *LockId, U8 lockType));
-EXTERN S16 SDestroyLockNew ARGS((SLockInfo *LockId, U8 lockType));
+EXTERN S16 SLockNew ARGS((SLockInfo *LockId, uint8_t lockType));
+EXTERN S16 SInitLockNew ARGS((SLockInfo *LockId, uint8_t lockType));
+EXTERN S16 SUnlockNew ARGS((SLockInfo *LockId, uint8_t lockType));
+EXTERN S16 SDestroyLockNew ARGS((SLockInfo *LockId, uint8_t lockType));
#endif /* SS_LOCK_SUPPORT */
EXTERN S8* SGetConfigPath ARGS((Void));
EXTERN S16 SRepPartMsg ARGS((Buffer *srcBuf, MsgLen idx, MsgLen cnt, Buffer *dstBuf));
EXTERN S16 SMovPartMsg ARGS((Buffer *srcBuf, MsgLen idx, Buffer *dstBuf));
EXTERN S16 SPkMsgMult ARGS((Data *src, MsgLen cnt, Buffer *mBuf));
-EXTERN S16 SGetReadPtr ARGS((Buffer *mBuf, U8** data, MsgLen *len));
+EXTERN S16 SGetReadPtr ARGS((Buffer *mBuf, uint8_t** data, MsgLen *len));
typedef enum
{
#endif
/* ssi_x_001.main_69: Added MSPD debug macro */
#ifdef MSPD
-extern U32 ysGT;
+extern uint32_t ysGT;
extern char ys_global_printbuf[256];
EXTERN Void rbCallstackShow ARGS((Void));
-EXTERN Void rbCallstackShowForCore ARGS((U32 coreId));
-EXTERN U32 MacGetTick ARGS ((void));
+EXTERN Void rbCallstackShowForCore ARGS((uint32_t coreId));
+EXTERN uint32_t MacGetTick ARGS ((void));
#endif /* MSPD */
#ifdef LTE_L2_MEAS
-extern U64 glblTtiCnt;
+extern uint64_t glblTtiCnt;
#endif
-EXTERN S16 SStartTask ARGS((VOLATILE U32 *startTime, U32 tarkId));
-EXTERN S16 SStopTask ARGS((VOLATILE U32 startTime,U32 taskId));
+EXTERN S16 SStartTask ARGS((VOLATILE uint32_t *startTime, uint32_t tarkId));
+EXTERN S16 SStopTask ARGS((VOLATILE uint32_t startTime,uint32_t taskId));
#ifdef MSPD_MLOG_NEW
/* Removed for C++ Compilation
EXTERN unsigned int MLogTask (unsigned int taskid, unsigned int resourceid ,
EXTERN Void ssMlogInit(Void);
EXTERN Void ssMlogIncrCounter(Void);
EXTERN Void ssMemlogInit(Void);
-EXTERN Void ssMemlog(char *, U32 size);
+EXTERN Void ssMemlog(char *, uint32_t size);
EXTERN Void ssMemlogWrite(Void);
#endif /* TENB_T2K3K_SPECIFIC_CHANGES */
#ifdef T2K_MEM_LEAK_DBG
#define ssGetDBufOfSize(region,size,dBuf) ssGetDBufOfSizeNew(region,size,dBuf,__FILE__,__LINE__)
-S16 ssGetDBufOfSizeNew ARGS((Region region, Size size, Buffer **dBuf,char*,U32));
+S16 ssGetDBufOfSizeNew ARGS((Region region, Size size, Buffer **dBuf,char*,uint32_t));
#else
EXTERN S16 ssGetDBufOfSize(Region region,Size size,Buffer **dBuf);
#endif
/* ssi_x_001.main_69: Added MSPD debug macro */
#ifdef MSPD
-EXTERN void SEND_DBG_MSG(U8 *str, ...);
+EXTERN void SEND_DBG_MSG(uint8_t *str, ...);
#endif
#endif /* __SSIX__ */
(
Pst * pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 cmPkTfuBndCfm(pst, suId, status)
Pst * pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
#endif
{
SuId suId;
- U8 status;
+ uint8_t status;
if (SUnpkS16(&suId, mBuf) != ROK) {
(
Pst * pst,
SuId suId,
-U8 status
+uint8_t status
)
#else
S16 cmPkTfuSchBndCfm(pst, suId, status)
Pst * pst;
SuId suId;
-U8 status;
+uint8_t status;
#endif
{
Buffer *mBuf = NULLP;
#endif
{
SuId suId;
- U8 status;
+ uint8_t status;
if (SUnpkS16(&suId, mBuf) != ROK) {
S32 i;
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_ALLOC_TYPE_RIV:
CMCHKUNPK(oduPackUInt32, ¶m->u.riv, mBuf);
CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(cmPkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKPK(cmPkTknU8, ¶m->nGap2, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->nGap2, mBuf);
CMCHKPK(oduUnpackUInt8, param->isLocal, mBuf);
return ROK;
}
CMCHKUNPK(oduPackUInt8, ¶m->isLocal, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
CMCHKPK(oduUnpackUInt8, param->iTbs, mBuf);
CMCHKPK(cmPkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKPK(cmPkTknU8, ¶m->nGap2, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->nGap2, mBuf);
return ROK;
}
{
- CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->iTbs, mBuf);
return ROK;
CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(cmPkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKPK(cmPkTknU8, ¶m->nGap2, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->nGap2, mBuf);
CMCHKPK(oduUnpackUInt8, param->isLocal, mBuf);
return ROK;
}
CMCHKUNPK(oduPackUInt8, ¶m->isLocal, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
CMCHKPK(oduUnpackUInt8, param->ndi, mBuf);
- CMCHKPK(cmPkTknU8, ¶m->harqProcId, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->harqProcId, mBuf);
CMCHKPK(oduUnpackUInt8, param->rv, mBuf);
CMCHKPK(oduUnpackUInt8, param->mcs, mBuf);
CMCHKPK(cmPkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
- CMCHKPK(cmPkTknU8, ¶m->nGap2, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->nGap2, mBuf);
CMCHKPK(oduUnpackUInt8, param->isLocal, mBuf);
return ROK;
}
CMCHKUNPK(oduPackUInt8, ¶m->isLocal, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->nGap2, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->nGap2, mBuf);
CMCHKUNPK(cmUnpkTfuAllocMapOrRiv, ¶m->alloc, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->mcs, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->harqProcId, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->harqProcId, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->ndi, mBuf);
return ROK;
}
CMCHKPK(oduUnpackUInt8, param->tpcCmd, mBuf);
#ifdef TFU_TDD
- CMCHKPK(cmPkTknU8, ¶m->dai, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->dai, mBuf);
#endif
CMCHKPK(cmPkTfuDciFormat1aAllocInfo, ¶m->allocInfo, mBuf);
CMCHKUNPK(cmUnpkTfuDciFormat1aAllocInfo, ¶m->allocInfo, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(cmUnpkTknU8, ¶m->dai, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->dai, mBuf);
#endif
CMCHKUNPK(oduPackUInt8, ¶m->tpcCmd, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->dciFormat, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->dciFormat, mBuf);
switch(param->dciFormat) {
case TFU_DCI_FORMAT_0:
CMCHKUNPK(cmUnpkTfuDciFormat0Info, ¶m->u.format0Info, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cceIdx, mBuf);
- CMCHKUNPK(cmUnpkLteAggrLvl,(U32 *)¶m->aggrLvl, mBuf);
+ CMCHKUNPK(cmUnpkLteAggrLvl,(uint32_t *)¶m->aggrLvl, mBuf);
return ROK;
}
{
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
{
- CMCHKPK(cmPkTknU8, ¶m->wideDiffCqi, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->wideDiffCqi, mBuf);
CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
return ROK;
CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->wideDiffCqi, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->wideDiffCqi, mBuf);
return ROK;
}
{
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
{
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
{
- CMCHKPK(cmPkTknU8, ¶m->diffCqi, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->diffCqi, mBuf);
CMCHKPK(oduUnpackUInt8, param->l, mBuf);
CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
return ROK;
CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->l, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->diffCqi, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->diffCqi, mBuf);
return ROK;
}
{
- CMCHKPK(cmPkTknU8, ¶m->diffCqi, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->diffCqi, mBuf);
CMCHKPK(oduUnpackUInt8, param->pmi, mBuf);
CMCHKPK(oduUnpackUInt8, param->cqi, mBuf);
return ROK;
CMCHKUNPK(oduPackUInt8, ¶m->cqi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->pmi, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->diffCqi, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->diffCqi, mBuf);
return ROK;
}
{
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RPT_RI:
CMCHKUNPK(oduPackUInt8, ¶m->u.ri, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cellIdx, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->mode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->mode, mBuf);
switch(param->mode) {
case TFU_PUCCH_CQI_MODE10:
CMCHKUNPK(cmUnpkTfuCqiPucchMode10, ¶m->u.mode10Info, mBuf);
return RFAILED;
}
- CMCHKPK(cmPkTknU8, ¶m->ri, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->ri, mBuf);
CMCHKPK(oduUnpackUInt32, param->mode, mBuf);
CMCHKPK(oduUnpackUInt8, param->cellIdx, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cellIdx, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->mode, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->ri, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->mode, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->ri, mBuf);
switch(param->mode) {
case TFU_PUSCH_CQI_MODE_12:
CMCHKUNPK(cmUnpkTfuCqiPuschMode12, ¶m->u.mode12Info, mBuf);
#ifdef ANSI
S16 cmPkTfuDlCqiInfo
(
-U8 selector,
+uint8_t selector,
TfuDlCqiInfo *param,
Buffer *mBuf
)
#else
S16 cmPkTfuDlCqiInfo(selector, param, mBuf)
-U8 selector;
+uint8_t selector;
TfuDlCqiInfo *param;
Buffer *mBuf;
#endif
{
- U32 idx;
+ uint32_t idx;
switch(selector) {
#ifdef ANSI
S16 cmUnpkTfuDlCqiInfo
(
-U8 selector,
+uint8_t selector,
TfuDlCqiInfo *param,
Buffer *mBuf
)
#else
S16 cmUnpkTfuDlCqiInfo(selector, param, mBuf)
-U8 selector;
+uint8_t selector;
TfuDlCqiInfo *param;
Buffer *mBuf;
#endif
{
- U8 idx;
+ uint8_t idx;
switch(selector) {
case TRUE:
#endif
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuUeRecpReqInfo *tfuUeRecpReqInfo;
#endif
{
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuUeRecpReqInfo *tfuUeRecpReqInfo;
CMCHKUNPK(cmUnpkLteRnti, ¶m->crnti, mBuf);
#endif
CMCHKUNPK(oduPackUInt16, ¶m->nCce, mBuf);
- CMCHKUNPK(cmUnpkLteAggrLvl, (U32*)¶m->aggrLvl, mBuf);
+ CMCHKUNPK(cmUnpkLteAggrLvl, (uint32_t*)¶m->aggrLvl, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->dciNumOfBits, mBuf);
CMCHKUNPK(cmUnpkTfuDciInfo, ¶m->dci, mBuf);
#ifdef TFU_5GTF
TfuPdcchInfo *tfuPdcchInfo;
TfuPhichInfo *tfuPhichInfo;
CmLList *node;
- U32 count;
+ uint32_t count;
#ifdef EMTC_ENABLE
count = param->dlMpdcchLst.count;
{
TfuPdcchInfo *tfuPdcchInfo;
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuPhichInfo *tfuPhichInfo;
{
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->format, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->format, mBuf);
switch(param->format) {
case TFU_DCI_FORMAT_1:
CMCHKUNPK(cmUnpkTfuDciFormat1AllocInfo, ¶m->u.format1AllocInfo, mBuf);
{
S32 i;
- U8 tbMask = 0;
+ uint8_t tbMask = 0;
#ifdef L2_OPTMZ
- U32 lchIdx, pduIdx;
+ uint32_t lchIdx, pduIdx;
#endif
CMCHKPK(oduUnpackUInt8, param->numLayers, mBuf);
#endif
CMCHKPK(oduPackBool, param->isTApres, mBuf);
- CMCHKPK(cmPkTknU32, ¶m->doa, mBuf);
+ CMCHKPK(cmPkTknUInt32, ¶m->doa, mBuf);
CMCHKPK(oduUnpackUInt32, param->transMode, mBuf);
CMCHKPK(cmPkTfuDlCqiPuschInfo, ¶m->puschPmiInfo, mBuf);
CMCHKPK(oduUnpackUInt8, param->puschRptUsd, mBuf);
#endif
{
- U8 i;
- U8 tbMask = 0;
+ uint8_t i;
+ uint8_t tbMask = 0;
#ifdef L2_OPTMZ
- U32 lchIdx, pduIdx;
+ uint32_t lchIdx, pduIdx;
#endif
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
CMCHKUNPK(cmUnpkBuffer, ¶m->tbInfo[i].macHdr, mBuf);
CMCHKUNPK(cmUnpkBuffer, ¶m->tbInfo[i].macCes, mBuf);
CMCHKUNPK(oduPackUInt32, ¶m->tbInfo[i].padSize, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->tbInfo[i].numLch, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->tbInfo[i].numLch, mBuf);
for(lchIdx = 0; lchIdx < param->tbInfo[i].numLch; lchIdx++)
{
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->tbInfo[i].lchInfo[lchIdx].numPdu,
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->tbInfo[i].lchInfo[lchIdx].numPdu,
mBuf);
for(pduIdx = 0; pduIdx < param->tbInfo[i].lchInfo[lchIdx].numPdu;
pduIdx++)
CMCHKUNPK(oduPackUInt8, ¶m->puschRptUsd, mBuf);
CMCHKUNPK(cmUnpkTfuDlCqiPuschInfo, ¶m->puschPmiInfo, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->transMode, mBuf);
- CMCHKUNPK(cmUnpkTknU32, ¶m->doa, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->transMode, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt32, ¶m->doa, mBuf);
CMCHKUNPK(oduUnpackBool, ¶m->isTApres, mBuf);
/* tfu_c_001.main_7. Added changes of TFU_UPGRADE */
#ifdef TFU_UPGRADE
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuDatReqPduInfo *tfuDatReqPduInfo;
#endif
{
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuDatReqPduInfo *tfuDatReqPduInfo;
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuDatInfo *tfuDatInfo;
#endif
{
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuDatInfo *tfuDatInfo;
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuSrInfo *tfuSrInfo;
#endif
{
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuSrInfo *tfuSrInfo;
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
/* ACC-TDD ccpu00130520 */
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqFdbkMode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->hqFdbkMode, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->noOfTbs, mBuf);
#ifdef TFU_TDD
CMCHKUNPK(oduPackUInt8, ¶m->M, mBuf);
#endif
for (i=0; i<TFU_MAX_HARQ_FDBKS; i++) {
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->isAck[i], mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->isAck[i], mBuf);
}
CMCHKUNPK(oduPackUInt8, ¶m->isPusch, mBuf);
return ROK;
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuHqInfo *tfuHqInfo;
#endif
{
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuHqInfo *tfuHqInfo;
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuUlCqiRpt *tfuUlCqiRpt;
#endif
{
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuUlCqiRpt *tfuUlCqiRpt;
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuDlCqiRpt *tfuDlCqiRpt;
#endif
{
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuDlCqiRpt *tfuDlCqiRpt;
{
- CMCHKPK(cmPkTknU8, ¶m->rv, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->rv, mBuf);
CMCHKPK(oduUnpackUInt8, param->isFailure, mBuf);
CMCHKPK(cmPkLteRnti, param->rnti, mBuf);
return ROK;
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->isFailure, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->rv, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->rv, mBuf);
return ROK;
}
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuCrcInfo *tfuCrcIndInfo;
#endif
{
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuCrcInfo *tfuCrcIndInfo;
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuTimingAdvInfo *tfuTimingAdvInfo;
#endif
{
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuTimingAdvInfo *tfuTimingAdvInfo;
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuPucchDeltaPwr *tfuPucchDeltaPwr;
#endif
{
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuPucchDeltaPwr *tfuPucchDeltaPwr;
{
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->mode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->mode, mBuf);
switch(param->mode) {
case TFU_PUSCH_CQI_MODE_12:
CMCHKUNPK(cmUnpkTfuCqiPuschMode12, ¶m->u.mode12Info, mBuf);
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuDoaRpt *tfuDoaRpt;
count = param->doaRpt.count;
#endif
{
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuDoaRpt *tfuDoaRpt;
CMCHKUNPK(cmUnpkLteCellId, ¶m->cellId, mBuf);
{
CmLList *node;
- U32 count;
+ uint32_t count;
TfuSrsRpt *tfuSrsRpt;
#endif
{
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuSrsRpt *tfuSrsRpt;
#endif
{
- U32 count;
+ uint32_t count;
TfuRawCqiRpt *tfuRawCqiRpt;
CmLList *node;
#endif
{
- U32 count, loopCnt;
+ uint32_t count, loopCnt;
TfuRawCqiRpt *tfuRawCqiRpt;
S32 i;
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqFdbkMode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->hqFdbkMode, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->hqSz, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->pucchResCnt, mBuf);
for (i=0; i<TFU_MAX_HQ_RES; i++) {
#endif
{
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqFdbkMode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->hqFdbkMode, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->hqSz, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->pucchResCnt, mBuf);
#ifdef LTE_ADV
{
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->srsBw, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->srsBw, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->nRrc, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->srsHopBw, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->srsHopBw, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->transComb, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->srsCfgIdx, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->srsCyclicShft, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->srsCyclicShft, mBuf);
return ROK;
}
{
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->uciInfo, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->uciInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchCqiRecpInfo, ¶m->cqiInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchSrRecpInfo, ¶m->srInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchHqRecpInfo, ¶m->hqInfo, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rbStart, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->numRb, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->modType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->modType, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->hoppingEnbld, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->hoppingBits, mBuf);
#endif
{
- U32 idx = 0;
+ uint32_t idx = 0;
CMCHKPK(oduUnpackUInt8, param->riBetaOff, mBuf);
CMCHKPK(oduUnpackUInt8, param->cqiBetaOff, mBuf);
for (idx = 0; idx < param->cCNum; idx++)
{
- CMCHKPK(cmPkTknU8, ¶m->riSz[idx], mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->riSz[idx], mBuf);
CMCHKPK(oduUnpackUInt8, param->cqiPmiSzRn1[idx], mBuf);
CMCHKPK(oduUnpackUInt8, param->cqiPmiSzR1[idx], mBuf);
}
#endif
{
- U32 idx;
+ uint32_t idx;
CMCHKUNPK(oduPackUInt8, ¶m->reportType, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cCNum, mBuf);
{
CMCHKUNPK(oduPackUInt8, ¶m->cqiPmiSzR1[idx-1], mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->cqiPmiSzRn1[idx-1], mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->riSz[idx-1], mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->riSz[idx-1], mBuf);
}
CMCHKUNPK(oduPackUInt8, ¶m->cqiBetaOff, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->riBetaOff, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->hqBetaOff, mBuf);
#ifdef TFU_TDD
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqFdbkMode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->hqFdbkMode, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->nBundled, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->ulDai, mBuf);
#endif
{
- CMCHKPK(cmPkTknU8, ¶m->initialNumRbs, mBuf);
- CMCHKPK(cmPkTknU8, ¶m->initialNSrs, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->initialNumRbs, mBuf);
+ CMCHKPK(cmPkTknUInt8, ¶m->initialNSrs, mBuf);
CMCHKPK(cmPkTfuUePucchSrsRecpInfo, ¶m->srsInfo, mBuf);
CMCHKPK(cmPkTfuUePuschHqRecpInfo, ¶m->hqInfo, mBuf);
CMCHKPK(cmPkTfuUePuschCqiRecpInfo, ¶m->cqiRiInfo, mBuf);
{
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->rcpInfo, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->rcpInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUeUlSchRecpInfo, ¶m->ulSchInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePuschCqiRecpInfo, ¶m->cqiRiInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePuschHqRecpInfo, ¶m->hqInfo, mBuf);
CMCHKUNPK(cmUnpkTfuUePucchSrsRecpInfo, ¶m->srsInfo, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->initialNSrs, mBuf);
- CMCHKUNPK(cmUnpkTknU8, ¶m->initialNumRbs, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->initialNSrs, mBuf);
+ CMCHKUNPK(cmUnpkTknUInt8, ¶m->initialNumRbs, mBuf);
return ROK;
}
#ifdef TFU_5GTF
CMCHKUNPK(oduPackUInt8, ¶m->groupId, mBuf);
#endif /* TFU_5GTF */
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RECP_REQ_PUCCH:
CMCHKUNPK(cmUnpkTfuUePucchRecpReq, ¶m->t.pucchRecpReq, mBuf);
S32 i;
#endif
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->hqType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->hqType, mBuf);
switch(param->hqType) {
#ifndef TFU_TDD
default :
return RFAILED;
}
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
#ifdef TFU_TDD
CMCHKUNPK(oduPackUInt8, ¶m->multCnt, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->rv, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->modType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->modType, mBuf);
return ROK;
}
CMCHKUNPK(oduPackUInt8, ¶m->nDmrs, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->expCqi, mBuf);
CMCHKUNPK(oduPackUInt8, ¶m->expHarq, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->mode, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->mode, mBuf);
CMCHKUNPK(oduPackUInt16, ¶m->size, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->modType, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->modType, mBuf);
return ROK;
}
CMCHKUNPK(cmUnpkLteRnti, ¶m->rnti, mBuf);
- CMCHKUNPK(oduPackUInt32, (U32 *)¶m->type, mBuf);
+ CMCHKUNPK(oduPackUInt32, (uint32_t *)¶m->type, mBuf);
switch(param->type) {
case TFU_RECP_REQ_PUCCH:
CMCHKUNPK(cmUnpkTfuUePucchRecpReq, ¶m->t.pucchRecpReq, mBuf);
struct _rgSchUlAllocCntr
{
- U8 mcs;
- U16 numOfRb;
- U16 rbStart;
+ uint8_t mcs;
+ uint16_t numOfRb;
+ uint16_t rbStart;
Bool testStart;
Bool enaLog;
- U16 logTime;
- U32 crcOk;
- U32 crcErr;
- U32 numUlPackets;
- U32 numPrach;
- U32 taZero;
+ uint16_t logTime;
+ uint32_t crcOk;
+ uint32_t crcErr;
+ uint32_t numUlPackets;
+ uint32_t numPrach;
+ uint32_t taZero;
};
EXTERN RgSchUlAllocCntr rgSchUlAllocCntr;
#ifdef DLHQ_STATS
typedef struct rgSchDlHqStats
{
- U16 sfn;
- U8 sf;
- U8 ack;
- U8 cellId;
- U8 ulDai;
- U8 dlDai;
- U8 fdbkIdx;
- U8 ue;
- U8 ack0;
- U8 ack1;
- U8 ack2;
- U8 ack3;
- U8 ack4;
- U8 ack5;
- U8 ack6;
- U8 ack7;
+ uint16_t sfn;
+ uint8_t sf;
+ uint8_t ack;
+ uint8_t cellId;
+ uint8_t ulDai;
+ uint8_t dlDai;
+ uint8_t fdbkIdx;
+ uint8_t ue;
+ uint8_t ack0;
+ uint8_t ack1;
+ uint8_t ack2;
+ uint8_t ack3;
+ uint8_t ack4;
+ uint8_t ack5;
+ uint8_t ack6;
+ uint8_t ack7;
}RgSchDlHqStats;
typedef struct ysMsDlHqStats
{
- U16 sfn;
- U8 sf;
- U8 mode; /*1 = PUCCH 2= PUSCH*/
- U8 M;
- U8 o0; /*For PUCCH n1PUCCH*/
- U8 o1; /*For PUCCH Invalid*/
- U8 o2;
- U8 o3;
- U8 ack0;
- U8 ack1;
- U8 ack2;
- U8 ack3;
- U8 ack4;
- U8 ack5;
- U8 ack6;
- U8 ack7;
+ uint16_t sfn;
+ uint8_t sf;
+ uint8_t mode; /*1 = PUCCH 2= PUSCH*/
+ uint8_t M;
+ uint8_t o0; /*For PUCCH n1PUCCH*/
+ uint8_t o1; /*For PUCCH Invalid*/
+ uint8_t o2;
+ uint8_t o3;
+ uint8_t ack0;
+ uint8_t ack1;
+ uint8_t ack2;
+ uint8_t ack3;
+ uint8_t ack4;
+ uint8_t ack5;
+ uint8_t ack6;
+ uint8_t ack7;
}YsMsDlHqStats;
#define MAX_STATS_CNT
#endif
/* Considers case where RIV is <= 324 for DCI format A1 */
typedef struct tfuRbAssignA1Val324
{
- U8 hqProcId; /*!< HARQ process ID */
- U8 mcs; /*!< 4 bits for MCS */
+ uint8_t hqProcId; /*!< HARQ process ID */
+ uint8_t mcs; /*!< 4 bits for MCS */
Bool ndi; /*!< 1 bit for new data indicator */
} TfuRbAssignA1Val324;
/* Considers case where RIV is <= 324 for DCI format B1 */
typedef struct tfuRbAssignB1Val324
{
- U8 hqProcId; /*!< HARQ process ID */
- U8 mcs; /*!< 4 bits for MCS */
+ uint8_t hqProcId; /*!< HARQ process ID */
+ uint8_t mcs; /*!< 4 bits for MCS */
Bool ndi; /*!< 1 bit for new data indicator */
- U8 RV; /*!< 2 bits Redundancy version */
- U8 bmiHqAckNack; /* BMI: Bit Mapping Index for Harq-Ack
+ uint8_t RV; /*!< 2 bits Redundancy version */
+ uint8_t bmiHqAckNack; /* BMI: Bit Mapping Index for Harq-Ack
Refer sec 8.5 of 213 spec */
} TfuRbAssignB1Val324;
/* Considers case where RIV is == 326 */
typedef struct tfuRbAssignVal326
{
- U8 FreqBandIdx; /* nRACH: Frequency band index Value:0 -> 7 */
+ uint8_t FreqBandIdx; /* nRACH: Frequency band index Value:0 -> 7 */
Bool OCCInd; /* nOCC: OCC indicator Value:0 -> 1 */
- U8 CyclicShiftInd; /* nNcs: Cyclic shift indicator Value:0 -> 3 */
+ uint8_t CyclicShiftInd; /* nNcs: Cyclic shift indicator Value:0 -> 3 */
} TfuRbAssignVal326;
typedef struct tfuDciFormatA1Info
{
Bool formatType; /* Format Descriminator 00: A1, 01:A2 */
- U8 xPUSCHRange; /* 0 : the stopping of xPUSCH is the 12th symbol,
+ uint8_t xPUSCHRange; /* 0 : the stopping of xPUSCH is the 12th symbol,
1 : the stopping of xPUSCH is the 13th symbol,
2 : the stopping of xPUSCH is the final (14th) symbol */
- U8 xPUSCH_TxTiming; /* Transmission timing of xPUSCH Value: 0->7
+ uint8_t xPUSCH_TxTiming; /* Transmission timing of xPUSCH Value: 0->7
l E {0,1,...,7}*/
- U16 RBAssign; /*!< same as phy i/f RBAssign: RIV as defined in V5G.213
+ uint16_t RBAssign; /*!< same as phy i/f RBAssign: RIV as defined in V5G.213
Value <= 324: this field assigns morethan zero RB.
Value ==325: this format assigns zero RB.
Value ==326: this format assigns zero RB and used
for Randon Access procedure initiated by xPDCCH order. */
- U8 beamIndex; /*!< transmit beam index: Value: 0->7 */
- U8 symbIdx; /*!< OFDM symbol index for the xPDCCH: Value: 0->1 */
- U8 rv; /*!< HARQ redundancy version, Value: 0 -> 3 */
+ uint8_t beamIndex; /*!< transmit beam index: Value: 0->7 */
+ uint8_t symbIdx; /*!< OFDM symbol index for the xPDCCH: Value: 0->1 */
+ uint8_t rv; /*!< HARQ redundancy version, Value: 0 -> 3 */
/* Based on RBAssign/RIV value*/
union
TfuRbAssignVal326 rbAssignVal326;
}u;
- U8 CSI_BSI_BRI_Req; /* CSI / BSI / BRI request Value:0 -> 7 */
- U8 CSIRS_BRRS_TxTiming; /* Transmission timing of CSI-RS / BRRS, Value:0 -> 3
+ uint8_t CSI_BSI_BRI_Req; /* CSI / BSI / BRI request Value:0 -> 7 */
+ uint8_t CSIRS_BRRS_TxTiming; /* Transmission timing of CSI-RS / BRRS, Value:0 -> 3
m E {0,1,2,3} */
#ifdef FIVEGTF_PHY_API
- U16 rbgStart;
- U16 rbgSize;
+ uint16_t rbgStart;
+ uint16_t rbgSize;
#endif
/* ToDo: following 4 fields can be made as union with an indicator type*/
- U8 CSIRS_BRRS_SymbIdx; /* Indication of OFDM symbol index for CSI-RS / BRRS allocations
+ uint8_t CSIRS_BRRS_SymbIdx; /* Indication of OFDM symbol index for CSI-RS / BRRS allocations
Value:0 -> 3 */
- U8 CSI_BRRS_Indicator; /* If this DCI format allocates either of
+ uint8_t CSI_BRRS_Indicator; /* If this DCI format allocates either of
CSI-RS or BRRS transmission Value:0 -> 3 */
- U8 CSIRS_BRRS_ProcInd; /* Process indicator : Value:0 -> 3 */
- U8 numBSI_Reports; /* Number of BSI reports Value:0 -> 3 */
+ uint8_t CSIRS_BRRS_ProcInd; /* Process indicator : Value:0 -> 3 */
+ uint8_t numBSI_Reports; /* Number of BSI reports Value:0 -> 3 */
Bool uciOnxPUSCH; /* "UCI on xPUSCH w/o xUL-SCH data" indicator. Value:0 -> 1 */
Bool beamSwitch; /* beam switch indication. Value:0 -> 1 */
- U8 SRS_Config; /* Indication of SRS configurations Value:0 -> 3
+ uint8_t SRS_Config; /* Indication of SRS configurations Value:0 -> 3
00 : {No SRS request}, 01 : {Config. #0},
10 : {Config. #1}, 11 : {Config. #2} */
Bool SRS_Symbol; /* If SRS is requested, 0: SRS transmission on the 13th OFDM symbol
and 1: SRS transmission on the 14th OFDM symbol */
- U8 REMapIdx_DMRS_PCRS_numLayers; /* RE Mapping index, Ki for DMRS/PCRS and number of layers
+ uint8_t REMapIdx_DMRS_PCRS_numLayers; /* RE Mapping index, Ki for DMRS/PCRS and number of layers
Value: 0 -> 7
0: 1 Layer, k0 = 0, 1: 1 Layer, k0 = 1
2: 1 Layer, k0 = 2, 3: 1 Layer, k0 = 3
6,7: Reserved */
Bool SCID; /* nSCID is applied for both DMRS in subframe n and
CSI-RS in subframe n+m Value: 0 -> 1 */
- U8 PMI; /* Precoding matrix indicator Value:0 -> 7 */
+ uint8_t PMI; /* Precoding matrix indicator Value:0 -> 7 */
#ifdef FIVEGTF_PHY_API
- U8 AntPorts_numLayers;
- U8 TransmissionScheme;
+ uint8_t AntPorts_numLayers;
+ uint8_t TransmissionScheme;
#endif
Bool UL_PCRS; /* UL dual PCRS Value: 0 -> 1 */
- U8 tpcCmd; /*!< 2 bits for TPC command for xPUSCH, Values: 0->3 */
+ uint8_t tpcCmd; /*!< 2 bits for TPC command for xPUSCH, Values: 0->3 */
} TfuDciFormatA1Info;
/* DCI format A2: UL xPDCCH */
typedef struct tfuDciFormatB1Info
{
Bool formatType; /* Format Descriminator 2: B1, 3:B2 */
- U8 xPDSCHRange; /* MSB (starting of xPDSCH including DMRS symbol) :
+ uint8_t xPDSCHRange; /* MSB (starting of xPDSCH including DMRS symbol) :
0 is the second symbol, 1 is the third symbol.
LSB (stopping of xPDSCH): 0 is the 12th symbol,
1 is the 14th symbol */
- U16 RBAssign; /*!< same as phy i/f RBAssign: RIV as defined in V5G.213
+ uint16_t RBAssign; /*!< same as phy i/f RBAssign: RIV as defined in V5G.213
Value <= 324: this field assigns morethan zero RB.
Value ==325: this format assigns zero RB.
Value ==326: this format assigns zero RB and used
for Randon Access procedure initiated by xPDCCH order. */
- U8 beamIndex; /*!< transmit beam index: Value: 0->7 */
- U8 symbIdx; /*!< OFDM symbol index for the xPDCCH: Value: 0->1 */
+ uint8_t beamIndex; /*!< transmit beam index: Value: 0->7 */
+ uint8_t symbIdx; /*!< OFDM symbol index for the xPDCCH: Value: 0->1 */
/* Based on RBAssign/RIV value*/
union
{
TfuRbAssignVal326 rbAssignVal326;
}u;
- U8 CSI_BSI_BRI_Req; /* CSI / BSI / BRI request Value:0 -> 7 */
- U8 CSIRS_BRRS_TxTiming; /* Transmission timing of CSI-RS / BRRS, Value:0 -> 3
+ uint8_t CSI_BSI_BRI_Req; /* CSI / BSI / BRI request Value:0 -> 7 */
+ uint8_t CSIRS_BRRS_TxTiming; /* Transmission timing of CSI-RS / BRRS, Value:0 -> 3
m E {0,1,2,3} */
/* ToDo: following 4 fields can be made as union with an indicator type*/
- U8 CSIRS_BRRS_SymbIdx; /* Indication of OFDM symbol index for CSI-RS / BRRS allocations
+ uint8_t CSIRS_BRRS_SymbIdx; /* Indication of OFDM symbol index for CSI-RS / BRRS allocations
Value:0 -> 3 */
- U8 CSI_BRRS_Indicator; /* If this DCI format allocates either of
+ uint8_t CSI_BRRS_Indicator; /* If this DCI format allocates either of
CSI-RS or BRRS transmission Value:0 -> 3 */
- U8 CSIRS_BRRS_ProcInd; /* Process indicator : Value:0 -> 3 */
- U8 numBSI_Reports; /* Number of BSI reports Value:0 -> 3 */
+ uint8_t CSIRS_BRRS_ProcInd; /* Process indicator : Value:0 -> 3 */
+ uint8_t numBSI_Reports; /* Number of BSI reports Value:0 -> 3 */
Bool xPUCCH_TxTiming; /* field indicates transmission time offset value k.{0, 1, ., 7} */
- U8 freqResIdx_xPUCCH; /* Frequency resource index of xPUCCH for UCI report */
+ uint8_t freqResIdx_xPUCCH; /* Frequency resource index of xPUCCH for UCI report */
Bool beamSwitch; /* beam switch indication. Value:0 -> 1 */
- U8 SRS_Config; /* Indication of SRS configurations Value:0 -> 3
+ uint8_t SRS_Config; /* Indication of SRS configurations Value:0 -> 3
00 : {No SRS request}, 01 : {Config. #0},
10 : {Config. #1}, 11 : {Config. #2} */
Bool SRS_Symbol; /* If SRS is requested, 0: SRS transmission on the 13th OFDM symbol
and 1: SRS transmission on the 14th OFDM symbol */
- U8 AntPorts_numLayers;
+ uint8_t AntPorts_numLayers;
Bool SCID; /* nSCID is applied for both DMRS in subframe n and
CSI-RS in subframe n+m Value: 0 -> 1 */
- U8 tpcCmd; /*!< 2 bits for TPC command for xPUCCH, Values: 0->3 */
+ uint8_t tpcCmd; /*!< 2 bits for TPC command for xPUCCH, Values: 0->3 */
Bool DL_PCRS; /* DL PCRS Value: 0 -> 3
00 : {No PCRS }, 01 : {PCRS on AP 60},
10 : {PCRS on AP 61}, 11 : {PCRS on AP 60 and 61}*/
Bool isMsg4PdcchWithCrnti; /* This is to aid rgNumMsg4PdcchWithCrnti counter which counts
num of PDCCH scrambled with CRNTI for CRNTI Based contention resolution */
Bool hoppingEnbld; /*!< TRUE, if hopping is enabled */
- U8 rbStart; /*!< Starting RB */
- U8 numRb; /*!< Number of RBs */
+ uint8_t rbStart; /*!< Starting RB */
+ uint8_t numRb; /*!< Number of RBs */
#ifdef TFU_UPGRADE
- U32 riv; /*!< RIV as defined in 213
+ uint32_t riv; /*!< RIV as defined in 213
section 7.1.6.3 - used only for
SPS release */
#endif
- U8 hoppingBits; /*!< Hopping bits as mentioned in 213 section 8.4 */
- U8 mcs; /*!< 5 bits for MCS and RV */
+ uint8_t hoppingBits; /*!< Hopping bits as mentioned in 213 section 8.4 */
+ uint8_t mcs; /*!< 5 bits for MCS and RV */
Bool ndi; /*!< 1 bit for new data indicator */
- U8 tpcCmd; /*!< 2 bits for TPC command */
+ uint8_t tpcCmd; /*!< 2 bits for TPC command */
/** @name TFU_TDD */
/** @{ */
#ifdef TFU_TDD
- U8 ulIdx; /*!< UL index applicable only for TDD */
- U8 dai; /*!< The downlink assignement index */
+ uint8_t ulIdx; /*!< UL index applicable only for TDD */
+ uint8_t dai; /*!< The downlink assignement index */
#endif
/** @} */
- U8 nDmrs; /*!< 3 bits for DMRS cyclic shift */
- U8 cqiReq; /*!< 1 bit for CQI non-CA while value 00, 01, 10 and 11 for CA */
- U8 numCqiBit; /*!< Number of CsiReq Bit(s) Values : 1 or 2(CA)*/
- U8 txAntenna; /*!< Antenna selection - 213 section 8.7 */
+ uint8_t nDmrs; /*!< 3 bits for DMRS cyclic shift */
+ uint8_t cqiReq; /*!< 1 bit for CQI non-CA while value 00, 01, 10 and 11 for CA */
+ uint8_t numCqiBit; /*!< Number of CsiReq Bit(s) Values : 1 or 2(CA)*/
+ uint8_t txAntenna; /*!< Antenna selection - 213 section 8.7 */
/* tfu_x_001.main_4: Adding hqProcId */
- U8 hqProcId; /*!< HARQ process ID */
+ uint8_t hqProcId; /*!< HARQ process ID */
} TfuDciFormat0Info;
/** @enum TfuAllocType
union
{
- U32 riv; /*!< RIV as defined in 213 section 7.1.6.3. */
+ uint32_t riv; /*!< RIV as defined in 213 section 7.1.6.3. */
/*tfu_x_001.main_8 - ADD - TFU_RESMAP_CHANGE support */
#ifndef TFU_RESMAP_CHANGE
- U8 resAllocMap[TFU_MAX_ALLOC_BYTES]; /*!< Resource
+ uint8_t resAllocMap[TFU_MAX_ALLOC_BYTES]; /*!< Resource
allocation bitmap. LSB aligns with the
LSB of the allocation bits.*/
#else /* TFU_RESMAP_CHANGE */
{
struct
{
- U32 allocMask; /*!< Allocation Mask for RBGs */
+ uint32_t allocMask; /*!< Allocation Mask for RBGs */
} allocType0;
struct
{
- U8 rbgSubset; /*!< RBG Subset number: Value in set
+ uint8_t rbgSubset; /*!< RBG Subset number: Value in set
{0,1,2,3} */
- U8 shift; /*!< Shift value for RBG mask: Value in
+ uint8_t shift; /*!< Shift value for RBG mask: Value in
set {0,1} */
- U32 allocMask; /*!< Allocation bitmask */
+ uint32_t allocMask; /*!< Allocation bitmask */
} allocType1;
} u;
} TfuAllocMap;
typedef struct tfuDciFormat1AllocInfo
{
Bool isAllocType0; /*!< TRUE, if allocation type is 0 */
- U8 resAllocMap[TFU_MAX_ALLOC_BYTES]; /*!< Resource allocation bitmap.
+ uint8_t resAllocMap[TFU_MAX_ALLOC_BYTES]; /*!< Resource allocation bitmap.
LSB aligns with the LSB of the
allocation bits.*/
- U8 harqProcId; /*!< HARQ process ID */
+ uint8_t harqProcId; /*!< HARQ process ID */
Bool ndi; /*!< 1 bit for new data indicator */
- U8 mcs; /*!< 5 bits for MCS */
- U8 rv; /*!< Redundancy version */
+ uint8_t mcs; /*!< 5 bits for MCS */
+ uint8_t rv; /*!< Redundancy version */
} TfuDciFormat1AllocInfo;
/** @brief This structure contains the information needed to convey DCI format 1.
/** @name TFU_TDD */
/** @{ */
#ifdef TFU_TDD
- U8 dai; /*!< The downlink assignement index */
+ uint8_t dai; /*!< The downlink assignement index */
#endif
/** @} */
- U8 tpcCmd; /*!< 2 bits for TPC command */
+ uint8_t tpcCmd; /*!< 2 bits for TPC command */
} TfuDciFormat1Info;
/** @brief This structure contains the TB level DCI signalling
typedef struct tfuDciFormatTbInfo
{
Bool ndi; /*!< New data indicator */
- U8 rv; /*!< Redundancy version Indicator */
- U8 mcs; /*!< 5 bits for MCS */
+ uint8_t rv; /*!< Redundancy version Indicator */
+ uint8_t mcs; /*!< 5 bits for MCS */
}TfuDciFormatTbInfo;
/** @} */
/** @brief This structure contains only the allocation information, that is part
Bool isAllocType0; /*!< TRUE, if allocation type is 0 */
/*tfu_x_001.main_8 - ADD - TFU_RESMAP_CHANGE support */
#ifndef TFU_RESMAP_CHANGE
- U8 resAllocMap[TFU_MAX_ALLOC_BYTES]; /*!< Resource allocation bitmap.
+ uint8_t resAllocMap[TFU_MAX_ALLOC_BYTES]; /*!< Resource allocation bitmap.
LSB aligns with the LSB of the
allocation bits.*/
#else
TfuAllocMap allocMap; /*!< Allocation Map */
#endif /* TFU_RESMAP_CHANGE */
- U8 harqProcId; /*!< HARQ process ID */
+ uint8_t harqProcId; /*!< HARQ process ID */
TfuDciFormatTbInfo tbInfo[2]; /*!< DCI Format 2/2A info per TB */
- U8 precoding; /*!< Precoding information bit */
+ uint8_t precoding; /*!< Precoding information bit */
Bool transSwap; /*!< Transport block to codeword swap flag */
} TfuDciFormat2AAllocInfo;
/** @name TFU_TDD */
/** @{ */
#ifdef TFU_TDD
- U8 dai; /*!< The downlink assignement index */
+ uint8_t dai; /*!< The downlink assignement index */
#endif
/** @} */
- U8 tpcCmd; /*!< 2 bits for TPC command */
+ uint8_t tpcCmd; /*!< 2 bits for TPC command */
} TfuDciFormat2AInfo;
/** @brief This structure contains only the allocation information, that is part
{
Bool isAllocType0; /*!< TRUE, if allocation type is 0 */
#ifndef TFU_RESMAP_CHANGE
- U8 resAllocMap[TFU_MAX_ALLOC_BYTES]; /*!< Resource
+ uint8_t resAllocMap[TFU_MAX_ALLOC_BYTES]; /*!< Resource
allocation bitmap. LSB aligns
with the LSB of the allocation
bits.*/
/** @name TFU_TDD */
/** @{ */
#ifdef TFU_TDD
- U8 dai; /*!< The downlink assignement index */
+ uint8_t dai; /*!< The downlink assignement index */
#endif
/** @} */
Bool transSwap; /*!< Transport block to codeword swap
flag */
- U8 precoding; /*!< Precoding information bit */
- U8 harqProcId; /*!< HARQ process ID */
+ uint8_t precoding; /*!< Precoding information bit */
+ uint8_t harqProcId; /*!< HARQ process ID */
TfuDciFormatTbInfo tbInfo[2]; /*!< DCI Format 2/2A info per TB */
} TfuDciFormat2AllocInfo;
{
TfuDciFormat2AllocInfo allocInfo; /*!< Allocation Information to map
data on PDSCH */
- U8 tpcCmd; /*!< 2 bits for TPC command */
+ uint8_t tpcCmd; /*!< 2 bits for TPC command */
/** @{ */
/** @name TFU_TDD */
/** @{ */
#ifdef TFU_TDD
- U8 dai; /*!< The downlink assignment index */
+ uint8_t dai; /*!< The downlink assignment index */
#endif
/** @} */
/** @} */
*/
typedef struct tfuDciFormat3Info
{
- U8 tpcCmd[TFU_MAX_2BIT_TPC]; /*!< 2 bits for TPC command.
+ uint8_t tpcCmd[TFU_MAX_2BIT_TPC]; /*!< 2 bits for TPC command.
LSB corresponds to the 1st bit of the 1st
byte.*/
- U8 isPucch; /*!< 1 if the TPC meant for PUCCH, 0 if the TPC meant for PUSCH */
+ uint8_t isPucch; /*!< 1 if the TPC meant for PUCCH, 0 if the TPC meant for PUSCH */
} TfuDciFormat3Info;
*/
typedef struct tfuDciFormat3AInfo
{
- U8 tpcCmd[TFU_MAX_1BIT_TPC]; /*!< 1 bit for TPC command.
+ uint8_t tpcCmd[TFU_MAX_1BIT_TPC]; /*!< 1 bit for TPC command.
LSB corresponds to the 1st bit of the
1st byte.*/
- U8 isPucch; /*!< 1 if the TPC meant for PUCCH, 0 if the TPC meant for PUSCH */
+ uint8_t isPucch; /*!< 1 if the TPC meant for PUCCH, 0 if the TPC meant for PUSCH */
} TfuDciFormat3AInfo;
typedef struct tfuDciFormat1dAllocInfo
{
Bool isLocal; /*!< TRUE, if localised VRB */
- TknU8 nGap2; /*!< 1 indicates Ngap=Ngap,1 and 2 indicates Ngap,2 */
+ TknUInt8 nGap2; /*!< 1 indicates Ngap=Ngap,1 and 2 indicates Ngap,2 */
TfuAllocMapOrRiv alloc; /*!< Allocation represented as a bit-map or RIV */
- U8 mcs; /*!< 5 bits for MCS */
- U8 rv; /*!< Redundancy version */
- U8 tPmi; /*!< PMI */
+ uint8_t mcs; /*!< 5 bits for MCS */
+ uint8_t rv; /*!< Redundancy version */
+ uint8_t tPmi; /*!< PMI */
} TfuDciFormat1dAllocInfo;
/** @brief This structure contains the information carried by DCI format 1D.
typedef struct tfuDciFormat1dInfo
{
TfuDciFormat1dAllocInfo allocInfo; /*!< Allocation information */
- U8 harqProcId; /*!< HARQ process ID */
+ uint8_t harqProcId; /*!< HARQ process ID */
Bool ndi; /*!< 1 bit for new data indicator */
- U8 tpcCmd; /*!< 2 bits for TPC command */
+ uint8_t tpcCmd; /*!< 2 bits for TPC command */
/** @name TFU_TDD */
/** @{ */
#ifdef TFU_TDD
- U8 dai; /*!< The downlink assignement index */
+ uint8_t dai; /*!< The downlink assignement index */
#endif
/** @} */
- U8 dlPwrOffset; /*!< Downlink power offset */
+ uint8_t dlPwrOffset; /*!< Downlink power offset */
} TfuDciFormat1dInfo;
*/
typedef struct tfuDciFormat1cInfo
{
- TknU8 nGap2; /*!< 1 indicates Ngap=Ngap,1 and 2 indicates Ngap,2 */
+ TknUInt8 nGap2; /*!< 1 indicates Ngap=Ngap,1 and 2 indicates Ngap,2 */
TfuAllocMapOrRiv alloc; /*!< Allocation represented as a bit-map or RIV */
- U8 iTbs; /*!< 5 bits for I-tbs */
+ uint8_t iTbs; /*!< 5 bits for I-tbs */
} TfuDciFormat1cInfo;
typedef struct tfuDciFormat1bAllocInfo
{
Bool isLocal; /*!< TRUE, if localised VRB */
- TknU8 nGap2; /*!< 1 indicates Ngap=Ngap,1 and 2 indicates Ngap,2 */
+ TknUInt8 nGap2; /*!< 1 indicates Ngap=Ngap,1 and 2 indicates Ngap,2 */
TfuAllocMapOrRiv alloc; /*!< Allocation represented as a bit-map or RIV */
- U8 mcs; /*!< 5 bits for MCS */
- U8 rv; /*!< Redundancy version */
- U8 harqProcId; /*!< HARQ process ID */
+ uint8_t mcs; /*!< 5 bits for MCS */
+ uint8_t rv; /*!< Redundancy version */
+ uint8_t harqProcId; /*!< HARQ process ID */
Bool ndi; /*!< 1 bit for new data indicator */
- U8 tPmi; /*!< PMI */
+ uint8_t tPmi; /*!< PMI */
Bool pmiCfm; /*!< PMI confirmation bit */
} TfuDciFormat1bAllocInfo;
*/
typedef struct tfuPdcchOrderInfo
{
- U8 preambleIdx; /*!< Dedicated preamble index */
- U8 prachMaskIdx; /*!< PRACH Mask index used to determine the
+ uint8_t preambleIdx; /*!< Dedicated preamble index */
+ uint8_t prachMaskIdx; /*!< PRACH Mask index used to determine the
subframe to be used for RACH */
} TfuPdcchOrderInfo;
typedef struct tfuDciFormat1aAllocInfo
{
Bool isLocal; /*!< TRUE, if localised VRB */
- TknU8 nGap2; /*!< 1 indicates Ngap=Ngap,1 and 2 indicates Ngap,2 */
+ TknUInt8 nGap2; /*!< 1 indicates Ngap=Ngap,1 and 2 indicates Ngap,2 */
TfuAllocMapOrRiv alloc; /*!< Allocation carries RIV or a bitmap */
- U8 mcs; /*!< 5 bits for MCS */
- U8 rv; /*!< Redundancy version */
- TknU8 harqProcId; /*!< HARQ process ID. Reserved
+ uint8_t mcs; /*!< 5 bits for MCS */
+ uint8_t rv; /*!< Redundancy version */
+ TknUInt8 harqProcId; /*!< HARQ process ID. Reserved
if RA-RNTI, P-RNTI, SI-RNTI is used */
Bool ndi; /*!< 1 bit for new data indicator */
} TfuDciFormat1aAllocInfo;
/** @name TFU_TDD */
/** @{ */
#ifdef TFU_TDD
- TknU8 dai; /*!< The downlink assignement index. Reserved
+ TknUInt8 dai; /*!< The downlink assignement index. Reserved
if RA-RNTI, P-RNTI, SI-RNTI is used. */
#endif
/** @} */
- U8 tpcCmd; /*!< 2 bits for TPC command. */
+ uint8_t tpcCmd; /*!< 2 bits for TPC command. */
Bool isTBMsg4; /*!< This field is added to help counting num of Msg4 Tx failures */
} Tfudciformat1aPdsch;
/*tfu_x_001.main_6 - Added for SPS support*/
/** @name TFU_TDD */
/** @{ */
#ifdef TFU_TDD
- U8 dai; /*!< The downlink assignement index */
+ uint8_t dai; /*!< The downlink assignement index */
#endif
/** @} */
- U8 tpcCmd; /*!< 2 bits for TPC command */
+ uint8_t tpcCmd; /*!< 2 bits for TPC command */
} TfuDciFormat1bInfo;
#ifdef EMTC_ENABLE
/** @brief This structure contains the information needed to convey DCI format 6-0A.
typedef struct tfuDciFormat60aInfo
{
Bool hoppingEnbld; /*!< TRUE, if hopping is enabled */
- U32 riv; /*!<9 bits, type2 allocation, RIV as defined in 213 section 7.1.6.3. */
- U8 mcs; /*!< 4 bits for MCS and RV */
- U8 rep; /*!< 2 bits, repetion number */
- U8 hqProcId; /*!< HARQ process ID */
+ uint32_t riv; /*!<9 bits, type2 allocation, RIV as defined in 213 section 7.1.6.3. */
+ uint8_t mcs; /*!< 4 bits for MCS and RV */
+ uint8_t rep; /*!< 2 bits, repetion number */
+ uint8_t hqProcId; /*!< HARQ process ID */
Bool ndi; /*!< 1 bit for new data indicator */
- U8 rv; /*!< 2 bits - Redundancy version */
- U8 tpcCmd; /*!< 2 bits for TPC command */
+ uint8_t rv; /*!< 2 bits - Redundancy version */
+ uint8_t tpcCmd; /*!< 2 bits for TPC command */
#ifdef TFU_TDD
/* TODO_Mavericks: Check if DAI is required for FDD also */
- U8 ulIdx; /*!< UL index applicable only for TDD */
- U8 dai; /*!< The downlink assignement index */
+ uint8_t ulIdx; /*!< UL index applicable only for TDD */
+ uint8_t dai; /*!< The downlink assignement index */
#endif
Bool cqiReq; /*!< 1 bit for CQI */
Bool isSrs; /*!< 1 bit for SRS */
- U8 dciRep; /*!< 2 bits for DCI Subframe repetition */
+ uint8_t dciRep; /*!< 2 bits for DCI Subframe repetition */
} TfuDciFormat60aInfo;
/** @brief This structure contains only the allocation information, that is part
* of DCI format 6-1A.
*/
typedef struct tfuDciFormat61AllocInfo
{
- U32 riv; /*!<9 bits, type2 allocation, RIV as defined in 213 section 7.1.6.3. */
+ uint32_t riv; /*!<9 bits, type2 allocation, RIV as defined in 213 section 7.1.6.3. */
/* TODO_EMTC: Add start RB, number of RB, Narrow band if required */
- U8 harqProcId; /*!< HARQ process ID */
+ uint8_t harqProcId; /*!< HARQ process ID */
Bool ndi; /*!< 1 bit for new data indicator */
- U8 mcs; /*!< 4 bits for MCS and RV */
- U8 rv; /*!< 2 bits - Redundancy version */
- U32 scramblerInitValue; /*!< Scrambler init(Cinit) value as per 36.211 */
+ uint8_t mcs; /*!< 4 bits for MCS and RV */
+ uint8_t rv; /*!< 2 bits - Redundancy version */
+ uint32_t scramblerInitValue; /*!< Scrambler init(Cinit) value as per 36.211 */
} TfuDciFormat61AllocInfo;
/** @brief This structure contains the information carried in DCI format 6-1A
{
TfuDciFormat61AllocInfo allocInfo; /* Allocation info for 6-1A */
Bool hoppingEnbld; /*!< TRUE, if hopping is enabled */
- U8 rep; /*!< 2 bits, repetion number */
- U8 tpcCmd; /*!< 2 bits for TPC command */
+ uint8_t rep; /*!< 2 bits, repetion number */
+ uint8_t tpcCmd; /*!< 2 bits for TPC command */
#ifdef TFU_TDD
/* TODO_Maveri: Check if DAI is required for FDD also */
- U8 dai; /*!< The downlink assignement index */
+ uint8_t dai; /*!< The downlink assignement index */
#endif
- U8 antPortAndScrId; /*!< 2 bits - Antenna port(s) and scrambling identity */
+ uint8_t antPortAndScrId; /*!< 2 bits - Antenna port(s) and scrambling identity */
Bool isSrs; /*!< 1 bit for SRS */
- U8 tPmi; /*!< 2 0r 4 bits: TPMI information for precoding */
- U8 pmiCfm; /*!< 1 bit, PMI confirmation for precoding */
- U8 harqAckOffst; /*!< 2 bits, HARQ-ACK resource offset */
- U8 dciRep; /*!< 2 bits for DCI Subframe repetition */
+ uint8_t tPmi; /*!< 2 0r 4 bits: TPMI information for precoding */
+ uint8_t pmiCfm; /*!< 1 bit, PMI confirmation for precoding */
+ uint8_t harqAckOffst; /*!< 2 bits, HARQ-ACK resource offset */
+ uint8_t dciRep; /*!< 2 bits for DCI Subframe repetition */
Bool isTBMsg4; /*!< This field is added to help counting num of Msg4 Tx failures */
} Tfudciformat61aPdsch;
typedef struct tfuPdcchOrderInfoEmtc
{
- U32 riv; /*!<9 bits, type2 allocation, RIV as defined in 213 section 7.1.6.3. */
- U8 preambleIdx; /*!< Dedicated preamble index */
- U8 prachMaskIdx; /*!< PRACH Mask index used to determine the
+ uint32_t riv; /*!<9 bits, type2 allocation, RIV as defined in 213 section 7.1.6.3. */
+ uint8_t preambleIdx; /*!< Dedicated preamble index */
+ uint8_t prachMaskIdx; /*!< PRACH Mask index used to determine the
subframe to be used for RACH */
- U8 ceLevel; /*!< 2 bits, Starting CE level */
+ uint8_t ceLevel; /*!< 2 bits, Starting CE level */
} TfuPdcchOrderInfoEmtc;
/** @brief This structure contains the information needed to convey DCI format 6-1A.
typedef struct tfuDciFormatForEmtcBcch
{
- U8 mcs;
- U16 numOfRb;
- U16 rbStart;
+ uint8_t mcs;
+ uint16_t numOfRb;
+ uint16_t rbStart;
}TfuDciFormatForEmtcBcch;
typedef struct tfuDirectIndication
{
- U8 directInd; /*!< 8 bit direct Indication Information*/
+ uint8_t directInd; /*!< 8 bit direct Indication Information*/
}TfuDirectIndication;
typedef struct tfuDciFormat62AllocInfo
{
- U8 riv; /*!< Narrow Band Index*/
- U8 mcs; /*!<MCS */
- U32 scramblerInitValue; /*!< Scrambler init(Cinit) value as per 36.211 */
- U8 rv; /*!<Redundancy version */
+ uint8_t riv; /*!< Narrow Band Index*/
+ uint8_t mcs; /*!<MCS */
+ uint32_t scramblerInitValue; /*!< Scrambler init(Cinit) value as per 36.211 */
+ uint8_t rv; /*!<Redundancy version */
}TfuDciFormat62AllocInfo;
typedef struct tfudciformat62Pdsch
{
TfuDciFormat62AllocInfo format62AllocInfo;
- U8 repNum; /*!< 3 bits, repetion number */
- U8 dciSubRepNum; /*!< 2 bits for DCI Subframe repetition */
+ uint8_t repNum; /*!< 3 bits, repetion number */
+ uint8_t dciSubRepNum; /*!< 2 bits for DCI Subframe repetition */
}Tfudciformat62Pdsch;
*/
typedef struct tfuSubbandInfo
{
- U8 rbStart; /*!< Starting RB */
- U8 numRb; /*!< Number of RBs */
+ uint8_t rbStart; /*!< Starting RB */
+ uint8_t numRb; /*!< Number of RBs */
} TfuSubbandInfo;
/** @brief This structure is used to convey the sub-band CQI reported.
typedef struct tfuSubbandDlCqiInfo
{
TfuSubbandInfo subband; /*!< Sub-band information */
- U8 cqiIdx[TFU_MAX_TB]; /*!< Sub-band CQI index per CW */
+ uint8_t cqiIdx[TFU_MAX_TB]; /*!< Sub-band CQI index per CW */
} TfuSubbandDlCqiInfo;
/** @} */
typedef struct tfuSubbandCqiInfo
{
TfuSubbandInfo subband; /*!< Sub-band information */
- U8 cqiIdx; /*!< CQI index */
+ uint8_t cqiIdx; /*!< CQI index */
} TfuSubbandCqiInfo;
/** @brief This structure conveys the CCE information.
*/
typedef struct tfuPdcchCceInfo
{
- U8 cceIdx; /*!< CCE index */
+ uint8_t cceIdx; /*!< CCE index */
CmLteAggrLvl aggrLvl; /*!< Aggregation level */
} TfuPdcchCceInfo;
TfuRptType type; /*!< Either RI or CQI reported */
union
{
- U8 ri; /*!< One RI assuming transmission on S sub-bands */
- U8 cqi; /*!< Wide-band CQI assuming transmission on S sub-bands */
+ uint8_t ri; /*!< One RI assuming transmission on S sub-bands */
+ uint8_t cqi; /*!< Wide-band CQI assuming transmission on S sub-bands */
}u;
} TfuCqiPucchMode10;
*/
typedef struct tfuCqiMode11Cqi
{
- U8 cqi; /*!< Wide-band CQI */
- U8 pmi; /*!< PMI */
- TknU8 wideDiffCqi; /*!< Wide-band differential CQI */
+ uint8_t cqi; /*!< Wide-band CQI */
+ uint8_t pmi; /*!< PMI */
+ TknUInt8 wideDiffCqi; /*!< Wide-band differential CQI */
} TfuCqiMode11Cqi;
/** @brief This structure maps to the CQI mode 11. The report can either
TfuRptType type; /*!< Either RI or CQI reported */
union
{
- U8 ri; /*!< One RI assuming transmission on S sub-bands */
+ uint8_t ri; /*!< One RI assuming transmission on S sub-bands */
TfuCqiMode11Cqi cqi; /*!< CQI assuming transmission on S sub-bands */
}u;
} TfuCqiPucchMode11;
*/
typedef struct tfuCqiMode20SubCqi
{
- U8 cqi; /*!< CQI value */
- U8 l; /*!< L bit sub-band label */
+ uint8_t cqi; /*!< CQI value */
+ uint8_t l; /*!< L bit sub-band label */
} TfuCqiMode20SubCqi;
/** @brief This structure contains Mode 20 CQI report. It can either be a
Bool isWideband; /*!< TRUE, if wide-band CQI is reported */
union
{
- U8 wideCqi; /*!< Single Wide-band CQI */
+ uint8_t wideCqi; /*!< Single Wide-band CQI */
TfuCqiMode20SubCqi subCqi; /*!< Sub-band CQI */
}u;
} TfuCqiMode20Cqi;
TfuRptType type; /*!< Either RI or CQI reported */
union
{
- U8 ri; /*!< One RI assuming transmission on S sub-bands */
+ uint8_t ri; /*!< One RI assuming transmission on S sub-bands */
TfuCqiMode20Cqi cqi; /*!< CQI assuming transmission on S sub-bands */
}u;
} TfuCqiPucchMode20;
*/
typedef struct tfuCqiMode21SubCqi
{
- U8 cqi; /*!< CQI */
- U8 l; /*!< L bit sub-band label */
- TknU8 diffCqi; /*!< Optional Differential CQI */
+ uint8_t cqi; /*!< CQI */
+ uint8_t l; /*!< L bit sub-band label */
+ TknUInt8 diffCqi; /*!< Optional Differential CQI */
} TfuCqiMode21SubCqi;
*/
typedef struct tfuCqiMode21WideCqi
{
- U8 cqi; /*!< CQI */
- U8 pmi; /*!< PMI */
- TknU8 diffCqi; /*!< Optional Differential CQI */
+ uint8_t cqi; /*!< CQI */
+ uint8_t pmi; /*!< PMI */
+ TknUInt8 diffCqi; /*!< Optional Differential CQI */
} TfuCqiMode21WideCqi;
TfuRptType type; /*!< Either RI or CQI reported */
union
{
- U8 ri; /*!< One RI assuming transmission on S sub-bands */
+ uint8_t ri; /*!< One RI assuming transmission on S sub-bands */
TfuCqiMode21Cqi cqi; /*!< CQI assuming transmission on S sub-bands */
}u;
} TfuCqiPucchMode21;
*/
typedef struct tfuDlCqiPucch
{
- U8 cellIdx;
+ uint8_t cellIdx;
TfuDlCqiPucchMode mode; /*!< PUSCH CQI mode */
union
{
*/
typedef struct tfuSubbandMode12
{
- U8 pmi; /*!< PMI for this sub-band */
+ uint8_t pmi; /*!< PMI for this sub-band */
TfuSubbandInfo subBand; /*!< Sub-band information start and length */
} TfuSubbandMode12;
*/
typedef struct tfuCqiPuschMode12
{
- U8 numSubband; /*!< Number of sub-bands */
- U8 cqiIdx[TFU_MAX_TB]; /*!< Single Wide-band CQI per
+ uint8_t numSubband; /*!< Number of sub-bands */
+ uint8_t cqiIdx[TFU_MAX_TB]; /*!< Single Wide-band CQI per
codeword */
TfuSubbandMode12 subbandArr[TFU_MAX_DL_SUBBAND]; /*!< Sub-band information array */
} TfuCqiPuschMode12;
*/
typedef struct tfuCqiPuschMode20
{
- U8 cqiIdx; /*!< CQI index transmission
+ uint8_t cqiIdx; /*!< CQI index transmission
over M sub-bands */
- U8 wideBandCqi; /*!< Wide-band CQI index, that is,
+ uint8_t wideBandCqi; /*!< Wide-band CQI index, that is,
transmission over S sub-bands */
- U8 numSubband; /*!< Number of sub-bands */
+ uint8_t numSubband; /*!< Number of sub-bands */
TfuSubbandInfo subbandArr[TFU_MAX_DL_SUBBAND]; /*!< Sub-band information array */
} TfuCqiPuschMode20;
*/
typedef struct tfuCqiPuschMode22
{
- U8 cqi[TFU_MAX_TB]; /*!< CQI index over M preferred
+ uint8_t cqi[TFU_MAX_TB]; /*!< CQI index over M preferred
Sub-bands */
- U8 pmi; /*!< PMI preferred PMI over M
+ uint8_t pmi; /*!< PMI preferred PMI over M
sub-bands */
- U8 wideBandCqi[TFU_MAX_TB]; /*!< Wide-band CQI */
- U8 wideBandPmi; /*!< PMI */
- U8 numSubband; /*!< Number of sub-bands, that is, M mentioned in 213, each of size k */
+ uint8_t wideBandCqi[TFU_MAX_TB]; /*!< Wide-band CQI */
+ uint8_t wideBandPmi; /*!< PMI */
+ uint8_t numSubband; /*!< Number of sub-bands, that is, M mentioned in 213, each of size k */
TfuSubbandInfo subbandArr[TFU_MAX_DL_SUBBAND]; /*!< Sub-band information array */
} TfuCqiPuschMode22;
*/
typedef struct tfuSubbandMode30
{
- U8 cqi; /*!< CQI for this sub-band */
+ uint8_t cqi; /*!< CQI for this sub-band */
TfuSubbandInfo subBand; /*!< Sub-band information start and length. */
} TfuSubbandMode30;
*/
typedef struct tfuCqiPuschMode30
{
- U8 wideBandCqi; /*!< Wide-band CQI */
- U8 numSubband; /*!< Number of sub-bands */
+ uint8_t wideBandCqi; /*!< Wide-band CQI */
+ uint8_t numSubband; /*!< Number of sub-bands */
TfuSubbandMode30 subbandArr[TFU_MAX_DL_SUBBAND]; /*!< Sub-band information array */
} TfuCqiPuschMode30;
*/
typedef struct tfuSubbandMode31
{
- U8 cqi[TFU_MAX_TB]; /*!< CQI for this sub-band */
+ uint8_t cqi[TFU_MAX_TB]; /*!< CQI for this sub-band */
TfuSubbandInfo subBand; /*!< Sub-band information start and length */
} TfuSubbandMode31;
*/
typedef struct tfuCqiPuschMode31
{
- U8 pmi; /*!< PMI */
- U8 wideBandCqi[TFU_MAX_TB]; /*!< Wide-band CQI per CW */
- U8 numSubband; /*!< Number of sub-bands */
+ uint8_t pmi; /*!< PMI */
+ uint8_t wideBandCqi[TFU_MAX_TB]; /*!< Wide-band CQI per CW */
+ uint8_t numSubband; /*!< Number of sub-bands */
TfuSubbandDlCqiInfo subbandCqiArr[TFU_MAX_DL_SUBBAND]; /*!< Array of
sub-bands and CQI for
each of them */
*/
typedef struct tfuDlCqiPusch
{
- U8 cellIdx;
+ uint8_t cellIdx;
TfuDlCqiPuschMode mode; /*!< PUSCH CQI mode */
- TknU8 ri; /*!< Rank Indicator for TM 3,4 */
+ TknUInt8 ri; /*!< Rank Indicator for TM 3,4 */
union
{
TfuCqiPuschMode12 mode12Info; /*!< Mode 1-2 information */
{
CmLList lnk; /*!< Link to the list of rerports */
CmLteRnti ueId; /*!< CRNTI */
- U16 dopEst; /*!< Doppler estimation [0-255] */
- U16 ta; /*!< Timing advance for the UE */
- U8 numRbs; /*!< Number of RBs to be reported for this UE */
- U8 rbStart; /*!< Starting RB to be reported */
- U8 snr[TFU_MAX_UL_RB]; /*!< snr for each RB */
+ uint16_t dopEst; /*!< Doppler estimation [0-255] */
+ uint16_t ta; /*!< Timing advance for the UE */
+ uint8_t numRbs; /*!< Number of RBs to be reported for this UE */
+ uint8_t rbStart; /*!< Starting RB to be reported */
+ uint8_t snr[TFU_MAX_UL_RB]; /*!< snr for each RB */
Bool wideCqiPres; /*!< Flag to indicate Wide-band CQI */
- U8 wideCqi; /*!< Wide-band CQI for an UL channel */
+ uint8_t wideCqi; /*!< Wide-band CQI for an UL channel */
} TfuSrsRpt;
{
CmLList lnk; /*!< Link to the list of reports */
CmLteRnti crnti; /*!< CRNTI of the UE */
- U8 numBits; /*!< Number of valid CQI bits */
+ uint8_t numBits; /*!< Number of valid CQI bits */
#ifdef TFU_5GTF
- U32 uciPayload; /*!< Raw UCI bit payload */
+ uint32_t uciPayload; /*!< Raw UCI bit payload */
#else
- U8 cqiConfBitMask;
- U8 cqiBits[TFU_MAX_CQI_BYTES]; /*!< An array of bits
+ uint8_t cqiConfBitMask;
+ uint8_t cqiBits[TFU_MAX_CQI_BYTES]; /*!< An array of bits
corresponding to the Raw CQI report */
- U8 ri[CM_LTE_MAX_CELLS]; /*!< Array of bits comprising of a Rank */
+ uint8_t ri[CM_LTE_MAX_CELLS]; /*!< Array of bits comprising of a Rank */
#endif
} TfuRawCqiRpt;
typedef struct tfuUePucchHqRecpInfo
{
TfuAckNackMode hqFdbkMode; /*!< Feedback mode in TDD */
- U8 hqSz; /*!< Size of feedback in bits */
- U8 pucchResCnt; /*!< Number of ACK/NACK responses
+ uint8_t hqSz; /*!< Size of feedback in bits */
+ uint8_t pucchResCnt; /*!< Number of ACK/NACK responses
received in this subframe [0-4] */
- U16 hqRes[TFU_MAX_HQ_RES]; /*!< (n^1PUCCH(0-3))
+ uint16_t hqRes[TFU_MAX_HQ_RES]; /*!< (n^1PUCCH(0-3))
values [0-2047] */
- U8 a; /*!< A value to interpret Hq feedback */
+ uint8_t a; /*!< A value to interpret Hq feedback */
} TfuUePucchHqRecpInfo;
/** @brief This structure is sent from scheduler to PHY in order to request the
*/
typedef struct tfuUePucchSrRecpInfo
{
- U16 n1PucchIdx; /*!< (n^1PUCCH) value [0-2047] */
+ uint16_t n1PucchIdx; /*!< (n^1PUCCH) value [0-2047] */
} TfuUePucchSrRecpInfo;
/** @brief This structure is sent from scheduler to PHY in order to request the
*/
typedef struct tfuUePucchCqiRecpInfo
{
- U16 n2PucchIdx; /*!< (n^2PUCCH) value[0-1185] */
- U8 cqiPmiSz; /*!< DL CQI/PMI size in bits [0-255] */
+ uint16_t n2PucchIdx; /*!< (n^2PUCCH) value[0-1185] */
+ uint8_t cqiPmiSz; /*!< DL CQI/PMI size in bits [0-255] */
} TfuUePucchCqiRecpInfo;
/** Different values for UL SRS BW information */
{
TfuUlSrsBwInfo srsBw; /*!< UE specific SRS Bandwidth (B,srs)
parameter. Given by RRC[0-3] */
- U8 nRrc; /*!< Frequency Domain position given by
+ uint8_t nRrc; /*!< Frequency Domain position given by
RRC per UE.[0-23]*/
TfuUlSrsHoBwInfo srsHopBw; /*!< SRS Hopping BW given by RRC per
UE (b,Hop)[0-3] */
- U8 transComb; /*!< Frequency location given by RRC
+ uint8_t transComb; /*!< Frequency location given by RRC
per UE (k,TC) [0-1] */
- U16 srsCfgIdx; /*!< (Isrs) - defines SRS periodicity
+ uint16_t srsCfgIdx; /*!< (Isrs) - defines SRS periodicity
and subframe offset,given by RRC
[0-1023] */
TfuUlSrsCycShiftInfo srsCyclicShft; /*!< (n^cs,srs) given by RRC [0-7] */
- /*Need to add U8 AntPort for Rel10 when SRS is supported */
+ /*Need to add uint8_t AntPort for Rel10 when SRS is supported */
} TfuUePucchSrsRecpInfo;
#ifdef TFU_5GTF
*/
typedef struct tfuUePucchBsiBriRecpInfo
{
- U8 puschFlag; /*!< UCI is carried in xPUSCH or not
+ uint8_t puschFlag; /*!< UCI is carried in xPUSCH or not
0 -> UCI is in xPUCCH,
1 -> UCI is in xPUSCH */
- U8 pucchIndex; /*!< Frequency resource index of xPUCCH
+ uint8_t pucchIndex; /*!< Frequency resource index of xPUCCH
for UCI report. [0-15] */
- U8 SCID; /*!< SCID : 0 or 1 */
- U8 bsiRpt; /*!< total num of BSI report[0,1,2,4] */
- U8 briRpt; /*!< total num of BRI report[0,1,2,4] */
+ uint8_t SCID; /*!< SCID : 0 or 1 */
+ uint8_t bsiRpt; /*!< total num of BSI report[0,1,2,4] */
+ uint8_t briRpt; /*!< total num of BRI report[0,1,2,4] */
} TfuUePucchBsiBriRecpInfo;
/** @brief This structure is sent from scheduler to PHY in order to request the
*/
typedef struct tfuUePucchUciRecpInfo
{
- U8 numBits; /*!< 1-22, 1-Only HQ, 5-Only CQI/RI, 6- both HQ CQI/RI */
- U8 pucchIndex; /*!< 0-15, PUCCH Freq Res Idx */
- U8 SCID; /*!< SCID : 0 or 1 */
+ uint8_t numBits; /*!< 1-22, 1-Only HQ, 5-Only CQI/RI, 6- both HQ CQI/RI */
+ uint8_t pucchIndex; /*!< 0-15, PUCCH Freq Res Idx */
+ uint8_t SCID; /*!< SCID : 0 or 1 */
} TfuUePucchUciRecpInfo;
#endif
TfuUePucchUciRecpInfo uciPduInfo; /*!< Info needed to receive HQ/CQI/RI.*/
#endif
#ifdef EMTC_ENABLE
- U16 format1aRepNumber;
- U16 format2aRepNumber;
- U32 catMScramblerInitVal;
+ uint16_t format1aRepNumber;
+ uint16_t format2aRepNumber;
+ uint32_t catMScramblerInitVal;
#endif
} TfuUePucchRecpReq;
*/
typedef struct tfuUeUlSchRecpInfo
{
- U16 size; /*!< Length of the Data in bytes*/
+ uint16_t size; /*!< Length of the Data in bytes*/
/* ToDo : rbStart and numRb is kept for legacy, need to remove later */
- U8 rbStart; /*!< Start of Resource Block of
+ uint8_t rbStart; /*!< Start of Resource Block of
allocation */
- U8 numRb; /*!< Number of RBs allocated */
+ uint8_t numRb; /*!< Number of RBs allocated */
TfuModScheme modType; /*!< Modulation order */
- U8 nDmrs; /*!< 3 bits for DMRS cyclic shift */
+ uint8_t nDmrs; /*!< 3 bits for DMRS cyclic shift */
Bool hoppingEnbld; /*!< TRUE, if hopping is enabled */
- U8 hoppingBits; /*!< Hopping bits as mentioned in
+ uint8_t hoppingBits; /*!< Hopping bits as mentioned in
213 8.4 */
Bool isRtx; /*!< TRUE, if this is a retx */
Bool ndi; /*!< New Data Indication */
- U8 rv; /*!< Redundancy version */
- U8 harqProcId; /*!< HARQ process ID */
- U8 txMode; /*!< UE's UL transmission mode:
+ uint8_t rv; /*!< Redundancy version */
+ uint8_t harqProcId; /*!< HARQ process ID */
+ uint8_t txMode; /*!< UE's UL transmission mode:
0 = SISO/SIMO, 1 = MIMO */
- U8 crntTxNb; /*!< Current Harq Tx Cntr of this TB.
+ uint8_t crntTxNb; /*!< Current Harq Tx Cntr of this TB.
Valid if frequency hopping is
enabled */
Bool nSrs; /*!< Indicates if RBs for this TB
overlap with SRS configuration.
FALSE = No overlap,TRUE=overlap */
- U8 mcs; /*!< MCS */
+ uint8_t mcs; /*!< MCS */
#ifdef EMTC_ENABLE
- U32 repetitionNumber;
- U32 scramblerInitValue;
+ uint32_t repetitionNumber;
+ uint32_t scramblerInitValue;
#endif
#ifdef TFU_5GTF
- U8 rbgStart; /* The starting resource block group for
+ uint8_t rbgStart; /* The starting resource block group for
this xPUSCH allocation.*/
- U8 numRbg; /* The number of resource block groups
+ uint8_t numRbg; /* The number of resource block groups
allocated to this ULSCH grant.*/
- U8 xPUSCHRange; /* 0 : the stopping of xPUSCH is the 12th symbol,
+ uint8_t xPUSCHRange; /* 0 : the stopping of xPUSCH is the 12th symbol,
1 : the stopping of xPUSCH is the 13th symbol
2 : the stopping of xPUSCH is the final (14th) symbol */
- U8 nAntPortLayer;/* 0:1 Layer, port 40 1:1 Layer, port 41 2:1 Layer, port 42
+ uint8_t nAntPortLayer;/* 0:1 Layer, port 40 1:1 Layer, port 41 2:1 Layer, port 42
3:1 Layer, port 43 4:2 Layers, ports {40, 41}
5:2 Layers, ports {42, 43} */
- U8 SCID; /*SCID : 0 or 1 */
- U8 PMI; /* Precoding matrix indicator, see V5G.211 section Table 5.3.3A.2-1 */
+ uint8_t SCID; /*SCID : 0 or 1 */
+ uint8_t PMI; /* Precoding matrix indicator, see V5G.211 section Table 5.3.3A.2-1 */
Bool uciWoTBFlag; /* 0: UCI without transmit block
1: with transmit block */
- U8 beamIndex; /* Receiving beam index Value: 0->7 */
+ uint8_t beamIndex; /* Receiving beam index Value: 0->7 */
#endif
} TfuUeUlSchRecpInfo;
*/
typedef struct tfuUePuschCqiRecpInfo
{
- U8 reportType; /*! Type of CSI report.
+ uint8_t reportType; /*! Type of CSI report.
0 = periodic report.
1 = aperiodic report */
- U8 cCNum; /*! The number of CC in the aperiodic report.
+ uint8_t cCNum; /*! The number of CC in the aperiodic report.
Value: 1->5 */
- U8 cqiPmiSzR1[CM_LTE_MAX_CELLS]; /*!< Size of DL CQI/PMI in bits for
+ uint8_t cqiPmiSzR1[CM_LTE_MAX_CELLS]; /*!< Size of DL CQI/PMI in bits for
rank 1 report[0-255] */
- U8 cqiPmiSzRn1[CM_LTE_MAX_CELLS]; /*!< Size of DL CQI/PMI in bits for
+ uint8_t cqiPmiSzRn1[CM_LTE_MAX_CELLS]; /*!< Size of DL CQI/PMI in bits for
rank > 1 report[0-255] */
- TknU8 riSz[CM_LTE_MAX_CELLS]; /*!< Size of RI in bits[1-2]. Value will
+ TknUInt8 riSz[CM_LTE_MAX_CELLS]; /*!< Size of RI in bits[1-2]. Value will
be 0 (present flag-false) in frames
with no RI Occasion*/
- U8 cqiBetaOff; /*!< Beta offset for CQI[0-15]. Given
+ uint8_t cqiBetaOff; /*!< Beta offset for CQI[0-15]. Given
by RRC */
- U8 riBetaOff; /*!< Beta offset for RI[0-15]. Given
+ uint8_t riBetaOff; /*!< Beta offset for RI[0-15]. Given
by RRC */
} TfuUePuschCqiRecpInfo;
*/
typedef struct tfuUePuschHqRecpInfo
{
- U8 hqSz; /*!< Number of feedback bits:
+ uint8_t hqSz; /*!< Number of feedback bits:
FDD- 1 or 2 TDD- 1 to 4*/
- U8 hqBetaOff; /*!< Beta offset for Harq[0-15]. Given
+ uint8_t hqBetaOff; /*!< Beta offset for Harq[0-15]. Given
by RRC */
#ifdef TFU_TDD
TfuAckNackMode hqFdbkMode; /*!< Feedback mode in TDD */
- U8 nBundled; /*!< nBundled value intended for PHY */
- U8 ulDai; /*!< Ul Dai */
+ uint8_t nBundled; /*!< nBundled value intended for PHY */
+ uint8_t ulDai; /*!< Ul Dai */
#endif
} TfuUePuschHqRecpInfo;
in rcpInfo */
TfuUePuschSrsRecpInfo srsInfo; /*!< Info needed to receive SRS. Valid
if SRS is included in rcpInfo */
- TknU8 initialNSrs; /*!< Not present in case of only data
+ TknUInt8 initialNSrs; /*!< Not present in case of only data
[0/1]. 0 = last OFDM symbol is
not punctured. 1 = last OFDM
symbol is punctured */
- TknU8 initialNumRbs; /*!< Number of RBs for initial
+ TknUInt8 initialNumRbs; /*!< Number of RBs for initial
transmission of this TB. Not
present in case of only data */
} TfuUePuschRecpReq;
CmLList lnk; /*!< Link of Linked List */
CmLteRnti rnti; /*!< RNTI of the scheduled UE */
#ifdef TFU_5GTF
- U8 groupId; /*!< UE Group ID */
+ uint8_t groupId; /*!< UE Group ID */
#endif
TfuRecpReqType type; /*!< Type indicating PUCCH or PUSCH */
union
/** @name TFU_TDD */
/** @{ */
#ifndef TFU_TDD
- U16 nCce; /*!< Number of first CCE used for transmission of
+ uint16_t nCce; /*!< Number of first CCE used for transmission of
the corresponding DCI assignment. Used to decode
HARQ-ACK. */
#else
- U16 nCce[TFU_MAX_M]; /*!< nCCE is an array in the case of TDD
+ uint16_t nCce[TFU_MAX_M]; /*!< nCCE is an array in the case of TDD
HARQ ACK multiplexing. This value is
needed for the calculation of
(n^1 PUCCH,i) for i = {0,1,2,3} */
#endif
/** @} */
- U16 n1Pucch; /*!< n1 PUCCH for ACK NACK repetition.
+ uint16_t n1Pucch; /*!< n1 PUCCH for ACK NACK repetition.
This is the resource that UE must
transmit the HARQ Feedback except
the first one. */
/** @name TFU_TDD */
/** @{ */
#ifdef TFU_TDD
- U8 multCnt; /*!< Number of ACK/NACK resources present */
- U8 M; /*!< Number of elements in the set K - tb.
+ uint8_t multCnt; /*!< Number of ACK/NACK resources present */
+ uint8_t M; /*!< Number of elements in the set K - tb.
10.1-1 213 */
- U8 m[TFU_MAX_M]; /*!< Values utilized for TDD HARQ-ACK bundling
+ uint8_t m[TFU_MAX_M]; /*!< Values utilized for TDD HARQ-ACK bundling
mode */
- U8 p[TFU_MAX_M]; /*!< "p" from 10.1 in 213 */
+ uint8_t p[TFU_MAX_M]; /*!< "p" from 10.1 in 213 */
#endif
/** @} */
} TfuUePucchRecpReq;
typedef struct tfuUeMsg3RecpReq
{
Bool hoppingEnbld; /*!< TRUE, if hopping is enabled */
- U8 rbStart; /*!< Start of Resource Block of allocation */
- U8 numRb; /*!< Number of RBs allocated */
- U8 mcs; /*!< 3 bits for MCS */
+ uint8_t rbStart; /*!< Start of Resource Block of allocation */
+ uint8_t numRb; /*!< Number of RBs allocated */
+ uint8_t mcs; /*!< 3 bits for MCS */
Bool expCqi; /*!< TRUE, if CQI report along
with PUSCH data is expected */
Bool ulDelay; /*!< UL Delay bit 6.2 of 213 */
* Non-adaptive retransmission is implemented */
Bool isRtx; /*!< TRUE, if this is a Msg3 retransmission */
/*ccpu00128993 - ADD - fix for msg3 softcombining bug*/
- U8 harqProcId; /*!< HARQ process ID */
+ uint8_t harqProcId; /*!< HARQ process ID */
Bool ndi; /*!< 1 bit for new data indicator */
- U8 rv; /*!< Redundancy version */
- U8 nDmrs; /*!< 3 bits for DMRS cyclic shift */
+ uint8_t rv; /*!< Redundancy version */
+ uint8_t nDmrs; /*!< 3 bits for DMRS cyclic shift */
/* tfu_x_001.main_2:107387:To include the size and ModOrder in DataRecp Request */
- U16 size; /*!< Length of the Data in bytes */
+ uint16_t size; /*!< Length of the Data in bytes */
TfuModScheme modType; /*!< Modulation order */
} TfuUeMsg3RecpReq;
typedef struct tfuUePuschRecpReq
{
Bool hoppingEnbld; /*!< TRUE, if hopping is enabled */
- U8 hoppingBits; /*!< Hopping bits as mentioned in 213 8.4 */
- U8 rbStart; /*!< Start of Resource Block of allocation */
- U8 numRb; /*!< Number of RBs allocated */
- U8 mcs; /*!< 5 bits for MCS and RV */
- U8 harqProcId; /*!< HARQ process ID */
+ uint8_t hoppingBits; /*!< Hopping bits as mentioned in 213 8.4 */
+ uint8_t rbStart; /*!< Start of Resource Block of allocation */
+ uint8_t numRb; /*!< Number of RBs allocated */
+ uint8_t mcs; /*!< 5 bits for MCS and RV */
+ uint8_t harqProcId; /*!< HARQ process ID */
Bool ndi; /*!< 1 bit for new data indicator */
Bool isRtx; /*!< TRUE, if this is a retransmission */
- U8 rv; /*!< Redundancy version */
- U8 nDmrs; /*!< 3 bits for DMRS cyclic shift */
+ uint8_t rv; /*!< Redundancy version */
+ uint8_t nDmrs; /*!< 3 bits for DMRS cyclic shift */
Bool expCqi; /*!< TRUE, if CQI report along
with PUSCH data is expected */
Bool expHarq; /*!< TRUE, if HARQ feedback along
this value is valid, only if expCqi is
TRUE. */
/* tfu_x_001.main_2:107387:To include the size and ModOrder in DataRecp Req.*/
- U16 size; /*!< Length of the Data in bytes*/
+ uint16_t size; /*!< Length of the Data in bytes*/
TfuModScheme modType; /*!< Modulation order */
} TfuUePuschRecpReq;
{
TfuDlCqiPucch pucchCqi; /*!< PUCCH CQI information */
struct {
- U8 numOfCells;
+ uint8_t numOfCells;
TfuDlCqiPusch puschCqi[CM_LTE_MAX_CELLS]; /*!< PUSCH CQI information */
}pusch;
} TfuDlCqiInfo;
Bool isSpsRnti; /*!< TRUE if rnti is SPS RNTI */
CmLteRnti crnti; /*!< crnti in case rnti is SPS RNTI */
#endif
- U16 nCce; /*!< CCE index */
+ uint16_t nCce; /*!< CCE index */
CmLteAggrLvl aggrLvl; /*!< Aggregation level possible values are
{1, 2, ...,8}. */
- U8 dciNumOfBits; /*!< The size of DCI in bits */
+ uint8_t dciNumOfBits; /*!< The size of DCI in bits */
TfuDciInfo dci; /*!< PDCCH DCI format */
#ifdef EMTC_ENABLE
- U8 distributedAlloc;
- U8 localizedAntPortIndex;
- U16 dmrs_txpowerControl;
- U8 nRBxm;
- U8 startRB;
- U32 scramblerInit;
- U32 demodRSInitValue;
+ uint8_t distributedAlloc;
+ uint8_t localizedAntPortIndex;
+ uint16_t dmrs_txpowerControl;
+ uint8_t nRBxm;
+ uint8_t startRB;
+ uint32_t scramblerInit;
+ uint32_t demodRSInitValue;
#endif
#ifdef TFU_5GTF
- U8 sectorId; /* Sector index of the 5GNB. Value: 0->2 */
- U8 sccIdx; /* Serving Cell index in the given sector. Value: 0->7 */
- U8 grpId; /* Ue group Id */
+ uint8_t sectorId; /* Sector index of the 5GNB. Value: 0->2 */
+ uint8_t sccIdx; /* Serving Cell index in the given sector. Value: 0->7 */
+ uint8_t grpId; /* Ue group Id */
#endif
} TfuPdcchInfo;
typedef struct tfuPhichInfo
{
CmLList lnk; /*!< Link of Linked List */
- U8 rbStart; /*!< Starting RB */
- U8 nDmrs; /*!< DMRS offset index */
+ uint8_t rbStart; /*!< Starting RB */
+ uint8_t nDmrs; /*!< DMRS offset index */
Bool isAck; /*!< TRUE, if ACK, else NACK */
Bool isForMsg3;
#ifdef TFU_TDD
- U8 iPhich; /*!< Needed to Calculate PHICH
+ uint8_t iPhich; /*!< Needed to Calculate PHICH
location. For TDD only */
#endif
/* tfu_x_001.main_8. Added changes of TFU_UPGRADE */
#ifdef TFU_UPGRADE
- U16 txPower; /*!< Offset to the ref. signal power */
+ uint16_t txPower; /*!< Offset to the ref. signal power */
#endif
} TfuPhichInfo;
CmLteCellId cellId; /*!< Cell ID */
CmLteTimingInfo ulTiming; /*!< Timing information for UL PDCCHs and PHICH */
CmLteTimingInfo dlTiming; /*!< Timing information for DL PDCCHs and CFI */
- U8 cfi; /*!< CFI value that goes on the PCFICH control channel */
- U32 numDlActvUes; /*!< Active Ues reqrd for rgu dyna delta*/
+ uint8_t cfi; /*!< CFI value that goes on the PCFICH control channel */
+ uint32_t numDlActvUes; /*!< Active Ues reqrd for rgu dyna delta*/
CmLListCp ulPdcchLst; /*!< List of Uplink PDCCHs (DCI format 0) for the TfuPdcchInfo subframe */
CmLListCp dlPdcchLst; /*!< List of Downlink PDCCHs for the TfuPdcchInfo subframe */
CmLListCp phichLst; /*!< List of PHICHs for the TfuPhichInfo subframe */
*/
typedef struct tfuBfVectorInfo
{
- U8 sbIndex; /** Subband Index */
- U8 numPhyAnt; /** Number of Physical Antennas */
- U16 bfValue[TFU_MAX_PHY_ANTENNA]; /** Beam forming vector element for
+ uint8_t sbIndex; /** Subband Index */
+ uint8_t numPhyAnt; /** Number of Physical Antennas */
+ uint16_t bfValue[TFU_MAX_PHY_ANTENNA]; /** Beam forming vector element for
physical antenna #i real 8 bits followed by imaginary 8 bits */
}TfuBfVectorInfo;
#endif
typedef struct tfuDatReqLchInfo
{
Bool freeBuff; /* !< If TRUE, the buffer is to be freed by MAC */
- U32 numPdu; /*!< No of PDUs */
+ uint32_t numPdu; /*!< No of PDUs */
Buffer *mBuf[TFU_MAX_PDU]; /*!<SIncMsgRef in MAC.
Freed by CL as well*/
}TfuDatReqLchInfo;
MsgLen tbSize;
Buffer *macHdr; /*!< Pre allocated. CL shall not free this*/
Buffer *macCes; /*!< Pre-allocated. CL shall not free this */
- U32 padSize;
- U32 numLch; /*!< No of logical channels associated to TB*/
+ uint32_t padSize;
+ uint32_t numLch; /*!< No of logical channels associated to TB*/
TfuDatReqLchInfo lchInfo[TFU_MAX_LC]; /*!< Array of logical channels */
}TfuDatReqTbInfo;
#endif
CmLteRnti rnti; /*!< RNTI of the UE */
TfuPdschDciInfo dciInfo; /*!< Carries the control data
needed for processing PDSCH data */
- U8 nmbOfTBs; /*!< Number of TBs, in cases where
+ uint8_t nmbOfTBs; /*!< Number of TBs, in cases where
one TB is disabled */
#ifdef FIVEGTF_PHY_API
- U16 crcResult;
+ uint16_t crcResult;
#endif
#ifndef L2_OPTMZ
Buffer *mBuf[TFU_MAX_TB]; /*!< MAC PDUs buffer */
PMI details for the entire
DL BW */
TfuTxMode transMode; /*!< Transmission Mode of this UE */
- TknU32 doa; /*!< DOA indicator for this UE */
+ TknUInt32 doa; /*!< DOA indicator for this UE */
Bool isTApres;
#ifdef TFU_UPGRADE
/*tfu_x_001.main_8 - ADD - Detailed comments for fields */
- U8 numLayers; /*!< Number of Layers. Note: Field
+ uint8_t numLayers; /*!< Number of Layers. Note: Field
specified at Interface. Value
not set from LTE MAC */
- U8 deltaPowOffIdx; /*!< Delta power offset. Note:
+ uint8_t deltaPowOffIdx; /*!< Delta power offset. Note:
Field specified at Interface. Value
not set from LTE MAC */
- U8 numBfPrbPerSb; /*!< Number of PRBs that are
+ uint8_t numBfPrbPerSb; /*!< Number of PRBs that are
treated as one Subband. Note:
Field specified at interface.
Value not set from LTE MAC */
- U8 numBfVectors; /*!< Number of Beam Forming
+ uint8_t numBfVectors; /*!< Number of Beam Forming
vectors. Note: Field specified at
Interface. Value not set from LTE
MAC */
specified at Interface.
Value not set from LTE
MAC */
- U16 txPwrOffset; /*!< Offset to the reference
+ uint16_t txPwrOffset; /*!< Offset to the reference
signal power. Value 0->10000,
representing -6 dB to 4 dB in
0.001 dB steps */
/* LTE_ADV_FLAG_REMOVED_START */
- U8 pa; /*!< ratio of PDSCH EPRE to cell-specific RS
+ uint8_t pa; /*!< ratio of PDSCH EPRE to cell-specific RS
EPRE among PDSCH REs */
#endif
- U8 isEnbSFR; /*to tell if SFR is enabled*/
+ uint8_t isEnbSFR; /*to tell if SFR is enabled*/
} TfuDatReqPduInfo;
CmLteTimingInfo timingInfo; /*!< Timing information */
CmLListCp datIndLst; /*!< List of data PDUs - TfuDatInfo */
#ifdef TFU_5GTF
- U8 sectorId; /* Sector index of the 5GNB. Value: 0->2 */
- U8 sccIdx; /* Serving Cell index in the given sector. Value: 0->7 */
+ uint8_t sectorId; /* Sector index of the 5GNB. Value: 0->2 */
+ uint8_t sccIdx; /* Serving Cell index in the given sector. Value: 0->7 */
#endif
} TfuDatIndInfo;
CmLList lnk; /*!< Link of Linked List */
CmLteRnti rnti; /*!< RNTI of the UE */
TfuAckNackMode hqFdbkMode; /*!< Feedback mode */
- U8 noOfTbs; /*!< Number of TBs */
+ uint8_t noOfTbs; /*!< Number of TBs */
#ifdef TFU_TDD
- U8 M; /*!< Number of feedbacks multiplexed */
+ uint8_t M; /*!< Number of feedbacks multiplexed */
#endif /* TFU_TDD */
TfuHqFdbk isAck[TFU_MAX_HARQ_FDBKS]; /*!< Harq feedbacks */
Bool isPusch; /*!< Indicates if this HARQ feedback is
CmLteRnti rnti; /*!< RNTI */
Bool isTxPort0; /*!< TRUE, if TX port is
0, else TX port is 1 */
- U8 wideCqi; /*!< Wide-band CQI*/
- U8 numSubband; /*!< Number of sub-bands */
+ uint8_t wideCqi; /*!< Wide-band CQI*/
+ uint8_t numSubband; /*!< Number of sub-bands */
TfuUlCqiInfo ulCqiInfoArr[TFU_MAX_UL_SUBBAND]; /*!< UL CQI information array */
} TfuUlCqiRpt;
{
CmLList lnk; /*!< Link of Linked List */
CmLteRnti rnti; /*!< RNTI */
- U32 doa; /*!< DOA for rnti */
+ uint32_t doa; /*!< DOA for rnti */
} TfuDoaRpt;
/** @brief This structure conveys the DOA (Direction Of Arrival) indicator.
CmLList lnk; /*!< Link of Linked List */
CmLteRnti rnti; /*!< RNTI of the UE */
Bool isFailure; /*!< TRUE, if CRC check fails */
- TknU8 rv; /*!< Redundancy version provided by PHY */
+ TknUInt8 rv; /*!< Redundancy version provided by PHY */
Bool isDtx; /*! If SNR < 0 , set to TRUE */
} TfuCrcInfo;
CmLteTimingInfo timingInfo; /*!< Timing information */
CmLListCp crcLst; /*!< List of CRC indications - TfuCrcInfo */
#ifdef TFU_5GTF
- U8 sectorId; /* Sector index of the 5GNB. Value: 0->2 */
- U8 sccIdx; /* Serving Cell index in the given sector. Value: 0->7 */
+ uint8_t sectorId; /* Sector index of the 5GNB. Value: 0->2 */
+ uint8_t sccIdx; /* Serving Cell index in the given sector. Value: 0->7 */
#endif
} TfuCrcIndInfo;
{
CmLList lnk; /*!< Link of Linked List */
CmLteRnti rnti; /*!< RNTI */
- U8 timingAdv; /*!< Value of the Timing advance */
+ uint8_t timingAdv; /*!< Value of the Timing advance */
} TfuTimingAdvInfo;
CmLteTimingInfo timingInfo; /*!< SFN, SF for each cell */
Bool isDummyTti; /*!< Flag to indicate dummy TTI */
/* 4UE_TTI_DELTA */
- U8 schTickDelta; /*!< Dynamic Delta for SCH. Value will vary
+ uint8_t schTickDelta; /*!< Dynamic Delta for SCH. Value will vary
according to num of active UEs */
- U8 dlBlankSf; /*!< TODO */
- U8 ulBlankSf; /*!< TODO */
+ uint8_t dlBlankSf; /*!< TODO */
+ uint8_t ulBlankSf; /*!< TODO */
} TfuTtiCellInfo;
*/
typedef struct tfuTtiIndInfo
{
- U8 numCells; /*!< Num of Cells */
+ uint8_t numCells; /*!< Num of Cells */
TfuTtiCellInfo cells[CM_LTE_MAX_CELLS]; /*!< Array of Cell timing info */
} TfuTtiIndInfo;
*/
typedef struct tfuRaReqInfo
{
- U8 rapId; /*!< ID of the preamble choosen by the UE for Random Acess.*/
- U16 ta; /*!< Amount of Timing advance needed by the UE for it
+ uint8_t rapId; /*!< ID of the preamble choosen by the UE for Random Acess.*/
+ uint16_t ta; /*!< Amount of Timing advance needed by the UE for it
to be uplink synchronized, this is calculated by Physical layer. */
- U8 tpc; /*!< Transmit power control command that the physical
+ uint8_t tpc; /*!< Transmit power control command that the physical
layer calculates from the RA request received.*/
Bool cqiPres; /*!< TRUE, if CQI present. */
- U8 cqiIdx; /*!< This is the Channel Quality Index of the UL channel estimated by the
+ uint8_t cqiIdx; /*!< This is the Channel Quality Index of the UL channel estimated by the
physical layer. This aids MAC in the scheduling of this UE. */
} TfuRaReqInfo;
typedef struct tfuRachInfo
{
CmLteRnti raRnti; /*!< RA-RNTI */
- U8 numRaReqInfo; /*!< Number of RA requests */
+ uint8_t numRaReqInfo; /*!< Number of RA requests */
#ifdef PRACH_5GTF
- U8 nPreambleFormat;
- U8 nPRACHConfiguration;
- U8 nRootSeq;
- U8 nCyclicShift;
- U8 nf1Value;
- U8 nPRACHSymbIndex;
- U16 nPwrFactor;
+ uint8_t nPreambleFormat;
+ uint8_t nPRACHConfiguration;
+ uint8_t nRootSeq;
+ uint8_t nCyclicShift;
+ uint8_t nf1Value;
+ uint8_t nPRACHSymbIndex;
+ uint16_t nPwrFactor;
#endif
TfuRaReqInfo *raReqInfoArr; /*!< RA requests */
} TfuRachInfo;
CmMemListCp memCp; /*!< Memory control point */
CmLteCellId cellId; /*!< Cell ID */
CmLteTimingInfo timingInfo; /*!< Timing information */
- U8 nmbOfRaRnti; /*!< Number of RA-RNTIs present for FDD this
+ uint8_t nmbOfRaRnti; /*!< Number of RA-RNTIs present for FDD this
must be 1 for TDD, it can be a max of 6. */
TfuRachInfo *rachInfoArr; /*!< Array of
RACH information per
typedef S16 (*TfuBndCfm) ARGS((
Pst* pst,
SuId suId,
- U8 status));
+ uint8_t status));
typedef S16 (*TfuUbndReq) ARGS((
Pst* pst,
SpId spId,
typedef S16 (*TfuSchBndCfm) ARGS((
Pst* pst,
SuId suId,
- U8 status));
+ uint8_t status));
typedef S16 (*TfuSchUbndReq) ARGS((
Pst* pst,
SpId spId,
* @param status Status of the bind request.
* @return ROK/RFAILED
*/
-EXTERN S16 TfUiTfuBndCfm ARGS((Pst *pst, SuId suId, U8 status));
+EXTERN S16 TfUiTfuBndCfm ARGS((Pst *pst, SuId suId, uint8_t status));
/** @brief This API is used to receive a Bind Confirm from PHY to Scheduler.
* @param pst Pointer to the post structure.
* @param status Status of the bind request.
* @return ROK/RFAILED
*/
-EXTERN S16 TfUiTfuSchBndCfm ARGS((Pst *pst, SuId suId, U8 status));
+EXTERN S16 TfUiTfuSchBndCfm ARGS((Pst *pst, SuId suId, uint8_t status));
/** @brief This API is used to send an Unbind Request from MAC to PHY.
EXTERN S16 RgLiTfuBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
EXTERN S16 RgLiTfuUbndReq ARGS((
Pst* pst,
EXTERN S16 RgLiTfuSchBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
EXTERN S16 RgLiTfuSchUbndReq ARGS((
Pst* pst,
EXTERN S16 cmPkTfuBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/** @brief This API is used to receive a Bind Confirm from PHY to MAC.
*/
EXTERN S16 cmPkTfuSchBndCfm ARGS((
Pst* pst,
SuId suId,
- U8 status
+ uint8_t status
));
/** @brief This API is used to receive a Bind Confirm from PHY to SCH.
*/
));
EXTERN S16 cmPkTfuDlCqiInfo ARGS((
- U8 selector,
+ uint8_t selector,
TfuDlCqiInfo *param,
Buffer *mBuf
));
EXTERN S16 cmUnpkTfuDlCqiInfo ARGS((
- U8 selector,
+ uint8_t selector,
TfuDlCqiInfo *param,
Buffer *mBuf
));
S16 BuildNrCellId(BIT_STRING_t *nrcell)
{
- U8 tmp;
+ uint8_t tmp;
for (tmp = 0 ; tmp < nrcell->size-1; tmp++)
{
nrcell->buf[tmp] = 0;
* ****************************************************************/
S16 BuildAndSendF1SetupRsp()
{
- U8 idx,ieIdx;
- U8 elementCnt,cellCnt;
+ uint8_t idx,ieIdx;
+ uint8_t elementCnt,cellCnt;
F1AP_PDU_t *f1apMsg = NULL;
F1SetupResponse_t *f1SetupRsp;
GNB_CU_Name_t *cuName;
rrcVer = &f1SetupRsp->protocolIEs.list.array[idx]->value.choice.RRC_Version;
rrcVer->latest_RRC_Version.size = RRC_SIZE;
- CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(U8));
+ CU_ALLOC(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
if(rrcVer->latest_RRC_Version.buf == NULLP)
{
CU_FREE(cuName->buf, sizeof(cuName->size));
CU_ALLOC(rrcVer->iE_Extensions,sizeof(ProtocolExtensionContainer_4624P81_t));
if(rrcVer->iE_Extensions == NULLP)
{
- CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
+ CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
{
CU_FREE(rrcVer->iE_Extensions,\
sizeof(ProtocolExtensionContainer_4624P81_t));
- CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
+ CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
sizeof(struct RRC_Version_ExtIEs *));
CU_FREE(rrcVer->iE_Extensions,\
sizeof(ProtocolExtensionContainer_4624P81_t));
- CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
+ CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
rrcVer->iE_Extensions->list.array[0]->extensionValue.present = \
RRC_Version_ExtIEs__extensionValue_PR_Latest_RRC_Version_Enhanced;
rrcVer->iE_Extensions->list.array[0]->extensionValue.choice.\
- Latest_RRC_Version_Enhanced.size = 3*sizeof(U8);
+ Latest_RRC_Version_Enhanced.size = 3*sizeof(uint8_t);
CU_ALLOC(rrcVer->iE_Extensions->list.\
array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf,\
- 3*sizeof(U8));
+ 3*sizeof(uint8_t));
if(rrcVer->iE_Extensions->list.\
array[0]->extensionValue.choice.Latest_RRC_Version_Enhanced.buf == NULLP)
{
sizeof(struct RRC_Version_ExtIEs *));
CU_FREE(rrcVer->iE_Extensions,\
sizeof(ProtocolExtensionContainer_4624P81_t));
- CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
+ CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
CU_FREE(cuName->buf, sizeof(cuName->size));
for(ieIdx=0; ieIdx<elementCnt; ieIdx++)
{
encRetVal = aper_encode(&asn_DEF_F1AP_PDU, 0, f1apMsg, PrepFinalEncBuf, encBuf);
/* Clean up */
- CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(U8));
+ CU_FREE(rrcVer->latest_RRC_Version.buf, sizeof(uint8_t));
CU_FREE(cuName->buf, sizeof(cuName->size));
for(idx=0; idx<elementCnt; idx++)
{
S16 BuildAndSendDUUpdateAck()
{
- U8 idx;
- U8 elementCnt;
+ uint8_t idx;
+ uint8_t elementCnt;
F1AP_PDU_t *f1apMsg = NULL;
GNBDUConfigurationUpdateAcknowledge_t *gNBDuCfgAck;
asn_enc_rval_t enRetVal; /* Encoder return value */
{
/* encode DL-DCCH message into RRC Container */
xer_fprint(stdout, &asn_DEF_DL_DCCH_MessageType, &dl_DCCH_Msg);
- cmMemset((U8 *)encBuf, 0, ENC_BUF_MAX_LEN);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
encBufSize = 0;
encRetVal = aper_encode(&asn_DEF_DL_DCCH_MessageType, 0, &dl_DCCH_Msg, PrepFinalEncBuf, encBuf);
/* Encode results */
void readCuCfg()
{
- U32 ipv4_du, ipv4_cu;
+ uint32_t ipv4_du, ipv4_cu;
DU_LOG("\nReading CU configurations");
cmInetAddr((S8*)DU_IP_V4_ADDR, &ipv4_du);
cmInetAddr((S8*)CU_IP_V4_ADDR, &ipv4_cu);
- //U32 ipv6_int = inet_addr(DU_IP_V6_ADDR);
cuCfgParams.cuId = CU_ID;
strcpy(cuCfgParams.cuName, CU_NAME);
typedef struct ipAddr
{
- Bool ipV4Pres;
- U32 ipV4Addr;
- Bool ipV6Pres;
- U8 ipV6Addr[MAX_IPV6_LEN];
+ Bool ipV4Pres;
+ uint32_t ipV4Addr;
+ Bool ipV6Pres;
+ uint8_t ipV6Addr[MAX_IPV6_LEN];
}SctpIpAddr;
typedef struct RrcVersion
{
- U8 rrcVer; /* Latest RRC Version */
- U32 extRrcVer; /* Latest RRC version extended */
+ uint8_t rrcVer; /* Latest RRC Version */
+ uint32_t extRrcVer; /* Latest RRC version extended */
}RrcVersion;
typedef struct egtpParams
{
SctpIpAddr localIp;
- U16 localPort;
+ uint16_t localPort;
SctpIpAddr destIp;
- U16 destPort;
- U32 minTunnelId;
- U32 maxTunnelId;
+ uint16_t destPort;
+ uint32_t minTunnelId;
+ uint32_t maxTunnelId;
}EgtpParams;
typedef struct CuSctpParams
{
SctpIpAddr duIpAddr;
- U16 duPort;
+ uint16_t duPort;
SctpIpAddr cuIpAddr;
- U16 cuPort;
+ uint16_t cuPort;
}CuSctpParams;
typedef struct cuCfgParams
{
- U32 cuId;
+ uint32_t cuId;
char cuName[CU_DU_NAME_LEN_MAX];
CuSctpParams sctpParams;
Plmn plmn;
* ***********************************************************************/
S16 cuEgtpCfgReq()
{
- U8 ret;
+ uint8_t ret;
memcpy(&egtpCb.egtpCfg, &cuCfgParams.egtpParams, sizeof(EgtpParams));
- egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr);
+ egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr);
egtpCb.recvTptSrvr.addr.port = EGTP_DFLT_PORT;
- egtpCb.dstCb.dstIp = CM_INET_NTOH_U32(egtpCb.egtpCfg.destIp.ipV4Addr);
+ egtpCb.dstCb.dstIp = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.destIp.ipV4Addr);
egtpCb.dstCb.dstPort = egtpCb.egtpCfg.destPort;
- egtpCb.dstCb.sendTptSrvr.addr.address = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr);
+ egtpCb.dstCb.sendTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr);
egtpCb.dstCb.sendTptSrvr.addr.port = egtpCb.egtpCfg.localPort;
egtpCb.dstCb.numTunn = 0;
- ret = cmHashListInit(&(egtpCb.dstCb.teIdLst), 1024, sizeof(EgtpTeIdCb), FALSE, CM_HASH_KEYTYPE_U32MOD, CU_APP_MEM_REG, CU_POOL);
+ ret = cmHashListInit(&(egtpCb.dstCb.teIdLst), 1024, sizeof(EgtpTeIdCb), FALSE, CM_HASH_KEYTYPE_UINT32_MOD, CU_APP_MEM_REG, CU_POOL);
if(ret != ROK)
{
S16 cuEgtpSrvOpenReq(Pst *pst)
{
- U8 ret;
+ uint8_t ret;
DU_LOG("\nEGTP : Received open server request");
teidCb->teId = tnlEvt.lclTeid;
teidCb->remTeId = tnlEvt.remTeid;
- ret = cmHashListInsert(&(egtpCb.dstCb.teIdLst), (PTR)teidCb, (U8 *)&(teidCb->teId), sizeof(U32));
+ ret = cmHashListInsert(&(egtpCb.dstCb.teIdLst), (PTR)teidCb, (uint8_t *)&(teidCb->teId), sizeof(uint32_t));
if(ret != ROK)
{
DU_LOG("\nEGTP : Failed to insert in hash list");
preDefHdr.extHdr.udpPort.pres = FALSE;
preDefHdr.nPdu.pres = FALSE;
- cuEgtpEncodeHdr((U8 *)teidCb->preEncodedHdr.hdr, &preDefHdr, &(teidCb->preEncodedHdr.cnt));
+ cuEgtpEncodeHdr((uint8_t *)teidCb->preEncodedHdr.hdr, &preDefHdr, &(teidCb->preEncodedHdr.cnt));
/* SPutSBuf(CU_APP_MEM_REG, CU_POOL, (Data *)teidCb, (Size)sizeof(EgtpTeIdCb));*/
printf("\nTunnel modification : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
- cmHashListFind(&(egtpCb.dstCb.teIdLst), (U8 *)&(tnlEvt.teId), sizeof(U32), 0, (PTR *)&teidCb);
+ cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(tnlEvt.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
printf("\nTunnel id not found");
DU_LOG("\nEGTP : Tunnel deletion : Local Teid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
- cmHashListFind(&(egtpCb.dstCb.teIdLst), (U8 *)&(tnlEvt.lclTeid), sizeof(U32), 0, (PTR *)&teidCb);
+ cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(tnlEvt.lclTeid), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
DU_LOG("\nEGTP : Tunnel id[%d] not configured", tnlEvt.lclTeid);
* RFAILED - failure
*
* ****************************************************************/
-S16 cuEgtpEncodeHdr(U8 *preEncodedHdr, EgtpMsgHdr *preDefHdr, U8 *hdrIdx)
+S16 cuEgtpEncodeHdr(uint8_t *preEncodedHdr, EgtpMsgHdr *preDefHdr, uint8_t *hdrIdx)
{
- U8 tmpByte = 0; /* Stores one byte of data for enc */
- U8 cnt = EGTP_MAX_HDR_LEN; /* Stores the position */
+ uint8_t tmpByte = 0; /* Stores one byte of data for enc */
+ uint8_t cnt = EGTP_MAX_HDR_LEN; /* Stores the position */
Bool extPres = FALSE; /* Flag for indication of S, E or P presense flag */
- U16 nwWord = 0;
+ uint16_t nwWord = 0;
/* Encoding header */
tmpByte |= EGTP_MASK_BIT6; /* Setting 6th LSB of 1st byte as version */
/* Encode Tunnel endpoint */
preEncodedHdr[--cnt] = 0;
preEncodedHdr[--cnt] = 0;
- nwWord = (U16)(GetHiWord(preDefHdr->teId));
- preEncodedHdr[--cnt] = (U8)(GetHiByte(nwWord));
- preEncodedHdr[--cnt] = (U8)(GetLoByte(nwWord));
- nwWord = (U16)(GetLoWord(preDefHdr->teId));
- preEncodedHdr[--cnt] = (U8)(GetHiByte(nwWord));
- preEncodedHdr[--cnt] = (U8)(GetLoByte(nwWord));
+ nwWord = (uint16_t)(GetHiWord(preDefHdr->teId));
+ preEncodedHdr[--cnt] = (uint8_t)(GetHiByte(nwWord));
+ preEncodedHdr[--cnt] = (uint8_t)(GetLoByte(nwWord));
+ nwWord = (uint16_t)(GetLoWord(preDefHdr->teId));
+ preEncodedHdr[--cnt] = (uint8_t)(GetHiByte(nwWord));
+ preEncodedHdr[--cnt] = (uint8_t)(GetLoByte(nwWord));
/* Encode sequence number */
if(preDefHdr->seqNum.pres)
S16 cuEgtpDecodeHdr(Buffer *mBuf)
{
EgtpMsg egtpMsg;
- U8 tmpByte[5]; /* Holds one byte of data after Dec */
- U8 version = 0; /* Holds the version type, decoded */
+ uint8_t tmpByte[5]; /* Holds one byte of data after Dec */
+ uint8_t version = 0; /* Holds the version type, decoded */
MsgLen msgLen = 0; /* Holds the msgLen from the Hdr */
MsgLen bufLen = 0; /* Holds the total buffer length */
- U8 extHdrType = 0; /* Holds the Extension hdr type */
- U8 extHdrLen = 0; /* Extension hdr length */
+ uint8_t extHdrType = 0; /* Holds the Extension hdr type */
+ uint8_t extHdrLen = 0; /* Extension hdr length */
Bool extPres = FALSE; /* Flag for indication of S, E or P presense flag */
ODU_GET_MSG_LEN(mBuf, &bufLen);
S16 cuEgtpDatReq()
{
- U8 cnt = 0;
+ uint8_t cnt = 0;
EgtpMsg egtpMsg;
/* Build Application message that is supposed to come from app to egtp */
ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
ipv4Hdr.hdrVer = 0x45;
ipv4Hdr.proto = 1;
- ipv4Hdr.srcAddr = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr);
- ipv4Hdr.destAddr = CM_INET_NTOH_U32(egtpCb.egtpCfg.destIp.ipV4Addr);
+ ipv4Hdr.srcAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr);
+ ipv4Hdr.destAddr = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.destIp.ipV4Addr);
/* Packing IPv4 header into buffer */
S16 ret, cnt, idx;
{
EgtpTeIdCb *teidCb = NULLP;
MsgLen tPduSize;
- U8 hdrLen;
- U32 msgLen;
+ uint8_t hdrLen;
+ uint32_t msgLen;
EgtpMsgHdr *msgHdr;
- cmHashListFind(&(egtpCb.dstCb.teIdLst), (U8 *)&(egtpMsg->msgHdr.teId), sizeof(U32), 0, (PTR *)&teidCb);
+ cmHashListFind(&(egtpCb.dstCb.teIdLst), (uint8_t *)&(egtpMsg->msgHdr.teId), sizeof(uint32_t), 0, (PTR *)&teidCb);
if(teidCb == NULLP)
{
DU_LOG("\nEGTP : Tunnel id[%d] not configured", egtpMsg->msgHdr.teId);
/***********************************************
* Fill the length field of the message header *
***********************************************/
- teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 3] = (U8)GetHiByte(msgLen);
- teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 4] = (U8)GetLoByte(msgLen);
+ teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 3] = (uint8_t)GetHiByte(msgLen);
+ teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 4] = (uint8_t)GetLoByte(msgLen);
/*Update the sequence number*/
if(egtpMsg->msgHdr.seqNum.pres)
{
teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 1] |= (EGTP_MASK_BIT2);
- teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 9] = (U8)GetHiByte(egtpMsg->msgHdr.seqNum.val);
- teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 10] = (U8)GetLoByte(egtpMsg->msgHdr.seqNum.val);
+ teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 9] = (uint8_t)GetHiByte(egtpMsg->msgHdr.seqNum.val);
+ teidCb->preEncodedHdr.hdr[EGTP_MAX_HDR_LEN - 10] = (uint8_t)GetLoByte(egtpMsg->msgHdr.seqNum.val);
}
else
{
#define EGTP_MASK_BIT7 0x40
#define EGTP_MASK_BIT8 0x80
-U8 sockType;
-U8 protType;
+uint8_t sockType;
+uint8_t protType;
typedef enum egtpMsgType
{
/*Extension Header */
typedef struct egtpExtHdr
{
- TknU16 udpPort; /**< UDP Port */
- TknU16 pdcpNmb; /**< PDCP Number */
+ TknUInt16 udpPort; /**< UDP Port */
+ TknUInt16 pdcpNmb; /**< PDCP Number */
}EgtpExtHdr;
/*Structure for MsgHdr */
typedef struct egtpMsgHdr
{
- TknU8 nPdu; /**< N-PDU Number */
- TknU32 seqNum; /**< Sequence Number */
+ TknUInt8 nPdu; /**< N-PDU Number */
+ TknUInt32 seqNum; /**< Sequence Number */
EgtpExtHdr extHdr; /**< Extension headers present flag */
- U32 teId; /**< Tunnel Endpoint Id */
- U8 msgType; /**< eGTP-U Message Type */
+ uint32_t teId; /**< Tunnel Endpoint Id */
+ uint8_t msgType; /**< eGTP-U Message Type */
}EgtpMsgHdr;
typedef struct egtpMsg
typedef struct egtpTnlEvt
{
- U8 action;
- U32 lclTeid;
- U32 remTeid;
+ uint8_t action;
+ uint32_t lclTeid;
+ uint32_t remTeid;
}EgtpTnlEvt;
typedef struct egtpTptSrvr
typedef struct EgtpTeIdCb
{
- U32 teId; /* Local tunnel id */
- U32 remTeId; /* Remote tunnel id */
+ uint32_t teId; /* Local tunnel id */
+ uint32_t remTeId; /* Remote tunnel id */
struct
{
- U8 hdr[EGTP_MAX_HDR_LEN];
- U8 cnt;
+ uint8_t hdr[EGTP_MAX_HDR_LEN];
+ uint8_t cnt;
}preEncodedHdr; /* Pre-encoded header for PDUs on this tunnel */
}EgtpTeIdCb;
typedef struct egtpDstCb
{
CmInetIpAddr dstIp; /* destination IP */
- U16 dstPort; /* Remote port that sends data */
+ uint16_t dstPort; /* Remote port that sends data */
EgtpTptSrvr sendTptSrvr; /* Transport server for sending UDP msg to */
- U32 numTunn; /* Number of tunnels */
+ uint32_t numTunn; /* Number of tunnels */
CmHashListCp teIdLst; /* Tunnel Id list for this destination */
}EgtpDstCb;
S16 cuEgtpTnlAdd(EgtpTnlEvt tnlEvt);
S16 cuEgtpTnlMod(EgtpTnlEvt tnlEvt);
S16 cuEgtpTnlDel(EgtpTnlEvt tnlEvt);
-S16 cuEgtpEncodeHdr(U8 *preEncodedHdr, EgtpMsgHdr *preDefHdr, U8 *hdrIdx);
+S16 cuEgtpEncodeHdr(uint8_t *preEncodedHdr, EgtpMsgHdr *preDefHdr, uint8_t *hdrIdx);
S16 cuEgtpHdlRecvMsg(Buffer *mBuf);
S16 cuEgtpDatReq();
S16 BuildAppMsg(EgtpMsg *egtpMsg);
{
addrLstPtr->count++;
addrLstPtr->addrs[(addrLstPtr->count - 1)].type = CM_INET_IPV4ADDR_TYPE;
- addrLstPtr->addrs[(addrLstPtr->count - 1)].u.ipv4NetAddr = CM_INET_NTOH_U32(ipAddr->ipV4Addr);
+ addrLstPtr->addrs[(addrLstPtr->count - 1)].u.ipv4NetAddr = CM_INET_NTOH_UINT32(ipAddr->ipV4Addr);
return ROK;
}
{
/* Filling destination address */
destAddrPtr->type = CM_INET_IPV4ADDR_TYPE;
- destAddrPtr->u.ipv4NetAddr = CM_INET_NTOH_U32(dstIpPtr->ipV4Addr);
+ destAddrPtr->u.ipv4NetAddr = CM_INET_NTOH_UINT32(dstIpPtr->ipV4Addr);
return ROK;
}
* ****************************************************************/
S16 sctpAccept(CmInetFd *lstnSock_Fd, CmInetAddr *peerAddr, CmInetFd *sock_Fd)
{
- U8 ret;
+ uint8_t ret;
ret = cmInetListen(lstnSock_Fd, 1);
if (ret != ROK)
* ****************************************************************/
S16 sctpSockPoll()
{
- U16 ret = ROK;
- U32 timeout;
- U32 *timeoutPtr;
+ uint16_t ret = ROK;
+ uint32_t timeout;
+ uint32_t *timeoutPtr;
Buffer *egtpBuf;
MsgLen egtpBufLen;
CmInetAddr egtpFromAddr;
*
* ****************************************************************/
-S16 processPolling(sctpSockPollParams *pollParams, CmInetFd *sockFd, U32 *timeoutPtr, CmInetMemInfo *memInfo)
+S16 processPolling(sctpSockPollParams *pollParams, CmInetFd *sockFd, uint32_t *timeoutPtr, CmInetMemInfo *memInfo)
{
- U16 ret = ROK;
+ uint16_t ret = ROK;
CM_INET_FD_SET(sockFd, &pollParams->readFd);
ret = cmInetSelect(&pollParams->readFd, NULLP, timeoutPtr, &pollParams->numFd);
if(CM_INET_FD_ISSET(sockFd, &pollParams->readFd))
* ****************************************************************/
S16 sctpSend(Buffer *mBuf)
{
- U8 ret;
+ uint8_t ret;
MsgLen len; /* number of actually sent octets */
CmInetMemInfo memInfo;
#define MAX_RETRY 5
/* Global variable declaration */
-U8 socket_type; /* Socket type */
+uint8_t socket_type; /* Socket type */
Bool nonblocking; /* Blocking/Non-blocking socket */
Bool connUp; /* Is connection up */
int assocId; /* Assoc Id of connected assoc */
typedef struct
{
- S16 numFd;
- U16 port;
- U32 flag;
- Buffer *mBuf;
- MsgLen bufLen;
- CmInetNetAddr addr;
+ S16 numFd;
+ uint16_t port;
+ uint32_t flag;
+ Buffer *mBuf;
+ MsgLen bufLen;
+ CmInetNetAddr addr;
CmInetFdSet readFd;
CmInetSctpSndRcvInfo info;
CmInetSctpNotification ntfy;
typedef struct
{
- U16 destPort; /* DU PORTS */
- U16 srcPort;
+ uint16_t destPort; /* DU PORTS */
+ uint16_t srcPort;
Bool bReadFdSet;
CmInetFd sockFd; /* Socket file descriptor */
CmInetAddr peerAddr;
S16 sctpSetSockOpts(CmInetFd *sock_Fd);
S16 sctpSockPoll();
S16 sctpAccept(CmInetFd *lstnSock_Fd, CmInetAddr *peerAddr, CmInetFd *sock_Fd);
-S16 processPolling(sctpSockPollParams *pollParams, CmInetFd *sockFd, U32 *timeoutPtr, CmInetMemInfo *memInfo);
+S16 processPolling(sctpSockPollParams *pollParams, CmInetFd *sockFd, uint32_t *timeoutPtr, CmInetMemInfo *memInfo);
#endif
/**********************************************************************
* ***********************************************************************/
uint8_t egtpCfgReq(Pst *pst, EgtpConfig egtpCfg)
{
- uint8_t ret; /* Return value */
- Pst rspPst; /* Response Pst structure */
+ uint8_t ret; /* Return value */
+ Pst rspPst; /* Response Pst structure */
CmStatus cfgCfm; /* Configuration Confirm */
memcpy(&egtpCb.egtpCfg, &egtpCfg, sizeof(EgtpConfig));
- egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr);
+ egtpCb.recvTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr);
egtpCb.recvTptSrvr.addr.port = EGTP_DFLT_PORT;
- egtpCb.dstCb.dstIp = CM_INET_NTOH_U32(egtpCb.egtpCfg.destIp.ipV4Addr);
+ egtpCb.dstCb.dstIp = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.destIp.ipV4Addr);
egtpCb.dstCb.dstPort = egtpCb.egtpCfg.destPort;
- egtpCb.dstCb.sendTptSrvr.addr.address = CM_INET_NTOH_U32(egtpCb.egtpCfg.localIp.ipV4Addr);
+ egtpCb.dstCb.sendTptSrvr.addr.address = CM_INET_NTOH_UINT32(egtpCb.egtpCfg.localIp.ipV4Addr);
egtpCb.dstCb.sendTptSrvr.addr.port = egtpCb.egtpCfg.localPort;
egtpCb.dstCb.numTunn = 0;
- ret = cmHashListInit(&(egtpCb.dstCb.teIdLst), 1024, sizeof(EgtpTeIdCb), FALSE, CM_HASH_KEYTYPE_U32MOD, DU_APP_MEM_REGION, DU_POOL);
+ ret = cmHashListInit(&(egtpCb.dstCb.teIdLst), 1024, sizeof(EgtpTeIdCb), FALSE, CM_HASH_KEYTYPE_UINT32_MOD, DU_APP_MEM_REGION, DU_POOL);
if(ret != ROK)
{
* ***************************************************************************/
uint8_t egtpTnlAdd(EgtpTnlEvt tnlEvt)
{
- uint8_t ret;
- EgtpTeIdCb *teidCb; /* Tunnel endpoint control block */
- EgtpMsgHdr preDefHdr; /* pre-define header for this tunnel */
+ uint8_t ret;
+ EgtpTeIdCb *teidCb; /* Tunnel endpoint control block */
+ EgtpMsgHdr preDefHdr; /* pre-define header for this tunnel */
DU_LOG("\nEGTP : Tunnel addition : LocalTeid[%d] Remote Teid[%d]", tnlEvt.lclTeid, tnlEvt.remTeid);
* ****************************************************************/
uint8_t egtpHdlDatInd(EgtpMsg egtpMsg)
{
- EgtpTeIdCb *teidCb = NULLP;
- uint16_t tPduSize;
+ EgtpTeIdCb *teidCb = NULLP;
+ uint16_t tPduSize;
uint8_t hdrLen;
uint32_t msgLen;
- EgtpMsgHdr *msgHdr;
+ EgtpMsgHdr *msgHdr;
DU_LOG("\nEGTP : Received Data Indication");
* ****************************************************************/
uint8_t egtpEncodeHdr(uint8_t *preEncodedHdr, EgtpMsgHdr *preDefHdr, uint8_t *hdrIdx)
{
- uint8_t tmpByte = 0; /* Stores one byte of data for enc */
- uint8_t cnt = EGTP_MAX_HDR_LEN; /* Stores the position */
+ uint8_t tmpByte = 0; /* Stores one byte of data for enc */
+ uint8_t cnt = EGTP_MAX_HDR_LEN; /* Stores the position */
bool extPres = FALSE; /* Flag for indication of S, E or P presense flag */
- uint16_t nwWord = 0;
+ uint16_t nwWord = 0;
/* Encoding header */
tmpByte |= EGTP_MASK_BIT6; /* Setting 6th LSB of 1st byte as version */
* ****************************************************************/
uint8_t egtpSendMsg(Buffer *mBuf)
{
- uint8_t ret;
- uint16_t txLen;
+ uint8_t ret;
+ uint16_t txLen;
CmInetMemInfo info;
CmInetAddr dstAddr;
uint8_t egtpRecvMsg()
{
- uint8_t ret; /* Return value */
- uint8_t nMsg; /* Number of messages to read from UDP socked */
- uint16_t bufLen; /* Length of received buffer */
+ uint8_t ret; /* Return value */
+ uint8_t nMsg; /* Number of messages to read from UDP socked */
+ uint16_t bufLen; /* Length of received buffer */
Buffer *recvBuf; /* Received buffer */
CmInetAddr fromAddr; /* Egtp data sender address */
CmInetMemInfo memInfo; /* Buffer allocation info */
uint8_t egtpDecodeHdr(Buffer *mBuf, EgtpMsg *egtpMsg)
{
- uint8_t tmpByte[5]; /* Holds 5 byte of data after Decoding */
- uint8_t version = 0; /* Holds the version type, decoded */
+ uint8_t tmpByte[5]; /* Holds 5 byte of data after Decoding */
+ uint8_t version = 0; /* Holds the version type, decoded */
uint16_t msgLen = 0; /* Holds the msgLen from the Hdr */
uint16_t bufLen = 0; /* Holds the total buffer length */
- uint8_t extHdrType = 0; /* Holds the Extension hdr type */
- uint8_t extHdrLen = 0; /* Extension hdr length */
- bool extPres = FALSE; /* Flag for indication of S, E or P presense flag */
+ uint8_t extHdrType = 0; /* Holds the Extension hdr type */
+ uint8_t extHdrLen = 0; /* Extension hdr length */
+ bool extPres = FALSE; /* Flag for indication of S, E or P presense flag */
ODU_GET_MSG_LEN(mBuf, (int16_t *)&bufLen);
}
else
{
- DU_LOG("\nF1AP : Created APER encoded buffer for F1SetupResponse\n");
+ DU_LOG("\nF1AP : Created APER encoded buffer for F1ResetAck\n");
for(int i=0; i< encBufSize; i++)
{
printf("%x",encBuf[i]);
extern uint8_t BuildAndSendDUConfigUpdate();
extern uint16_t getTransId();
extern uint8_t cmPkLrgSchCfgReq(Pst * pst,RgMngmt * cfg);
+uint8_t BuildAndSendRrcDeliveryReport(uint32_t gnbCuUeF1apId, uint32_t gnbDuUeF1apId, RrcDeliveryReport *rrcDelivery);
packMacCellCfgReq packMacCellCfgOpts[] =
{
uint8_t duBuildRlcLsapCfg(Ent ent, Inst inst, uint8_t lsapInst)
{
- RlcMngmt rlcMngmt;
- RlcSapCfg *lSap = NULLP;
+ RlcMngmt rlcMngmt;
+ RlcSapCfg *lSap = NULLP;
Pst pst;
DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt));
***************************************************************************/
uint8_t duBuildRlcUsapCfg(uint8_t elemId, Ent ent, Inst inst)
{
- RlcMngmt rlcMngmt;
- RlcSapCfg *uSap = NULLP;
+ RlcMngmt rlcMngmt;
+ RlcSapCfg *uSap = NULLP;
Pst pst;
DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt));
***************************************************************************/
uint8_t duProcCfgComplete()
{
- uint8_t ret = ROK;
+ uint8_t ret = ROK;
static uint16_t cellId = 0;
- uint16_t idx;
+ uint16_t idx;
for(idx=0; idx< DEFAULT_CELLS; idx++)
{
DuCellCb *cell = NULLP;
{
RlcCntrl *cntrl = NULLP;
RlcMngmt rlcMngmt;
- Pst pst;
+ Pst pst;
DU_SET_ZERO(&rlcMngmt, sizeof(RlcMngmt));
ipv4Hdr.length = CM_IPV4_HDRLEN + mLen;
ipv4Hdr.hdrVer = 0x45;
ipv4Hdr.proto = 1;
- ipv4Hdr.srcAddr = CM_INET_NTOH_U32(duCfgParam.egtpParams.localIp.ipV4Addr);
- ipv4Hdr.destAddr = CM_INET_NTOH_U32(duCfgParam.egtpParams.destIp.ipV4Addr);
+ ipv4Hdr.srcAddr = CM_INET_NTOH_UINT32(duCfgParam.egtpParams.localIp.ipV4Addr);
+ ipv4Hdr.destAddr = CM_INET_NTOH_UINT32(duCfgParam.egtpParams.destIp.ipV4Addr);
/* Packing IPv4 header into buffer */
uint8_t ret, cnt, idx;
uint8_t duSctpCfgReq(SctpParams sctpCfg)
{
- uint8_t ret = ROK;
- CmStatus cfm;
+ uint8_t ret = ROK;
+ CmStatus cfm;
/* Fill F1 Params */
f1Params.destIpAddr.ipV4Pres = sctpCfg.cuIpAddr.ipV4Pres;
{
addrLstPtr->count++;
addrLstPtr->addrs[(addrLstPtr->count - 1)].type = CM_INET_IPV4ADDR_TYPE;
- addrLstPtr->addrs[(addrLstPtr->count - 1)].u.ipv4NetAddr = CM_INET_NTOH_U32(ipAddr->ipV4Addr);
+ addrLstPtr->addrs[(addrLstPtr->count - 1)].u.ipv4NetAddr = CM_INET_NTOH_UINT32(ipAddr->ipV4Addr);
return ROK;
}
{
/* Filling destination address */
destAddrPtr->type = CM_INET_IPV4ADDR_TYPE;
- destAddrPtr->u.ipv4NetAddr = CM_INET_NTOH_U32(dstIpPtr->ipV4Addr);
+ destAddrPtr->u.ipv4NetAddr = CM_INET_NTOH_UINT32(dstIpPtr->ipV4Addr);
return ROK;
}
uint8_t duSctpAssocReq(uint8_t itfType)
{
- uint8_t ret = ROK;
- CmStatus cfm;
+ uint8_t ret = ROK;
+ CmStatus cfm;
DuSctpDestCb *paramPtr = NULLP;
DU_ALLOC(paramPtr, sizeof(DuSctpDestCb));
* ****************************************************************/
uint8_t sctpSockPoll()
{
- uint8_t ret = ROK;
- uint32_t timeout;
- uint32_t *timeout_Ptr;
+ uint8_t ret = ROK;
+ uint32_t timeout;
+ uint32_t *timeout_Ptr;
CmInetMemInfo memInfo;
sctpSockPollParams f1PollParams, e2PollParams;
uint8_t BuildMib(MIB_t *mib)
{
mib->systemFrameNumber.size = sizeof(uint8_t);
- DU_ALLOC(mib->systemFrameNumber.buf,
- mib->systemFrameNumber.size);
- if(!(mib->systemFrameNumber.buf))
- {
- DU_LOG("DU APP: MIB msg memory allocation failure");
- return RFAILED;
- }
-
- *(mib->systemFrameNumber.buf) =
- duCfgParam.mibParams.sysFrmNum;
- mib->systemFrameNumber.bits_unused = ODU_VALUE_TWO;
-
- mib->subCarrierSpacingCommon =\
- duCfgParam.mibParams.subCarrierSpacingCommon;
- mib->ssb_SubcarrierOffset =\
- duCfgParam.mibParams.ssb_SubcarrierOffset;
- mib->dmrs_TypeA_Position =\
- duCfgParam.mibParams.dmrs_TypeA_Position;
- mib->pdcch_ConfigSIB1.controlResourceSetZero = \
- duCfgParam.mibParams.controlResourceSetZero;
- mib->pdcch_ConfigSIB1.searchSpaceZero = \
- duCfgParam.mibParams.searchSpaceZero;
- mib->cellBarred = duCfgParam.mibParams.cellBarred;
- mib->intraFreqReselection =
- duCfgParam.mibParams.intraFreqReselection;
- mib->spare.size = sizeof(uint8_t);
- DU_ALLOC(mib->spare.buf, mib->spare.size);
- if(!mib->spare.buf)
- {
- DU_LOG("DU APP: MIB msg memory allocation failure");
- return RFAILED;
- }
- *(mib->spare.buf) = SPARE;
- mib->spare.bits_unused = ODU_VALUE_SEVEN;
+ DU_ALLOC(mib->systemFrameNumber.buf, mib->systemFrameNumber.size);
+ if(!(mib->systemFrameNumber.buf))
+ {
+ DU_LOG("DU APP: MIB msg memory allocation failure");
+ return RFAILED;
+ }
+
+ *(mib->systemFrameNumber.buf) = duCfgParam.mibParams.sysFrmNum;
+ mib->systemFrameNumber.bits_unused = ODU_VALUE_TWO;
+
+ mib->subCarrierSpacingCommon = duCfgParam.mibParams.subCarrierSpacingCommon;
+ mib->ssb_SubcarrierOffset = duCfgParam.mibParams.ssb_SubcarrierOffset;
+ mib->dmrs_TypeA_Position = duCfgParam.mibParams.dmrs_TypeA_Position;
+ mib->pdcch_ConfigSIB1.controlResourceSetZero = duCfgParam.mibParams.controlResourceSetZero;
+ mib->pdcch_ConfigSIB1.searchSpaceZero = duCfgParam.mibParams.searchSpaceZero;
+ mib->cellBarred = duCfgParam.mibParams.cellBarred;
+ mib->intraFreqReselection = duCfgParam.mibParams.intraFreqReselection;
+ mib->spare.size = sizeof(uint8_t);
+ DU_ALLOC(mib->spare.buf, mib->spare.size);
+ if(!mib->spare.buf)
+ {
+ DU_LOG("DU APP: MIB msg memory allocation failure");
+ return RFAILED;
+ }
+ *(mib->spare.buf) = SPARE;
+ mib->spare.bits_unused = ODU_VALUE_SEVEN;
return ROK;
}
/*******************************************************************
* @return void
*
* ****************************************************************/
- void FreeMibPdu(BCCH_BCH_Message_t *bcchMsg)
- {
- if(!bcchMsg)
- {
- if(!bcchMsg->message.choice.mib)
- {
- if(!(bcchMsg->message.choice.mib->systemFrameNumber.buf))
- {
- if(!bcchMsg->message.choice.mib->spare.buf)
- {
- DU_FREE(bcchMsg->message.choice.mib->spare.buf,\
- bcchMsg->message.choice.mib->spare.size);
- }
- DU_FREE(bcchMsg->message.choice.mib->systemFrameNumber.buf,
- bcchMsg->message.choice.mib->systemFrameNumber.size);
- }
- DU_FREE(bcchMsg->message.choice.mib, sizeof(MIB_t));
- }
- DU_FREE(bcchMsg, sizeof(BCCH_BCH_Message_t));
- }
- }
+void FreeMibPdu(BCCH_BCH_Message_t *bcchMsg)
+{
+ if(!bcchMsg)
+ {
+ if(!bcchMsg->message.choice.mib)
+ {
+ if(!(bcchMsg->message.choice.mib->systemFrameNumber.buf))
+ {
+ if(!bcchMsg->message.choice.mib->spare.buf)
+ {
+ DU_FREE(bcchMsg->message.choice.mib->spare.buf,\
+ bcchMsg->message.choice.mib->spare.size);
+ }
+ DU_FREE(bcchMsg->message.choice.mib->systemFrameNumber.buf,
+ bcchMsg->message.choice.mib->systemFrameNumber.size);
+ }
+ DU_FREE(bcchMsg->message.choice.mib, sizeof(MIB_t));
+ }
+ DU_FREE(bcchMsg, sizeof(BCCH_BCH_Message_t));
+ }
+}
/*******************************************************************
*
* @brief Builds MIB PDU for broadcast
uint8_t BuildMibPdu()
{
uint8_t BuildMibret;
- uint8_t ret = RFAILED;
- BCCH_BCH_Message_t *bcchMsg;
- asn_enc_rval_t encRetVal; /* Encoder return value */
+ uint8_t ret = RFAILED;
+ BCCH_BCH_Message_t *bcchMsg;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
while(true)
- {
- DU_ALLOC(bcchMsg, sizeof(BCCH_BCH_Message_t));
- if(!bcchMsg)
- {
- DU_LOG("\nMemory allocation failure in BuildMibPdu");
- break;
- }
-
- bcchMsg->message.present = BCCH_BCH_MessageType_PR_mib;
- DU_ALLOC(bcchMsg->message.choice.mib, sizeof(MIB_t));
- if(!bcchMsg->message.choice.mib)
- {
- DU_LOG("\nMemory allocation failure in BuildMibPdu");
- break;
- }
- BuildMibret = BuildMib(bcchMsg->message.choice.mib);
- if(BuildMibret != ROK)
- {
- break;
- }
- xer_fprint(stdout, &asn_DEF_BCCH_BCH_Message, bcchMsg);
- memset(encBuf, 0, ENC_BUF_MAX_LEN);
- encBufSize = 0;
- encRetVal = aper_encode(&asn_DEF_BCCH_BCH_Message, 0,
- bcchMsg, PrepFinalEncBuf, encBuf);
- printf("\nencbufSize:%d\n", encBufSize);
- if(encRetVal.encoded == -1)
- {
- DU_LOG("\nDU APP: Could not encode BCCH BCH Message Type structure(at %s)\n",
- encRetVal.failed_type?\
- encRetVal.failed_type->name
- :"unknown");
- break;
- }
+ {
+ DU_ALLOC(bcchMsg, sizeof(BCCH_BCH_Message_t));
+ if(!bcchMsg)
+ {
+ DU_LOG("\nMemory allocation failure in BuildMibPdu");
+ break;
+ }
- /* Print encoded buffer */
- for(int i=0; i< encBufSize; i++)
- {
- printf("%x\t",encBuf[i]);
- }
- printf("\n");
+ bcchMsg->message.present = BCCH_BCH_MessageType_PR_mib;
+ DU_ALLOC(bcchMsg->message.choice.mib, sizeof(MIB_t));
+ if(!bcchMsg->message.choice.mib)
+ {
+ DU_LOG("\nMemory allocation failure in BuildMibPdu");
+ break;
+ }
+ BuildMibret = BuildMib(bcchMsg->message.choice.mib);
+ if(BuildMibret != ROK)
+ {
+ break;
+ }
+ xer_fprint(stdout, &asn_DEF_BCCH_BCH_Message, bcchMsg);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_BCCH_BCH_Message, 0,
+ bcchMsg, PrepFinalEncBuf, encBuf);
+ printf("\nencbufSize:%d\n", encBufSize);
+ if(encRetVal.encoded == -1)
+ {
+ DU_LOG("\nDU APP: Could not encode BCCH BCH Message Type structure(at %s)\n",
+ encRetVal.failed_type?\
+ encRetVal.failed_type->name
+ :"unknown");
+ break;
+ }
+
+ /* Print encoded buffer */
+ for(int i=0; i< encBufSize; i++)
+ {
+ printf("%x\t",encBuf[i]);
+ }
+ printf("\n");
- ret = ROK;
- break;
- }
- /* Free allocated memory */
- FreeMibPdu(bcchMsg);
+ ret = ROK;
+ break;
+ }
+ /* Free allocated memory */
+ FreeMibPdu(bcchMsg);
- return ret;
+ return ret;
}
- /*******************************************************************
+/*******************************************************************
*
* @brief free MIB message in Served Cell Info
*
* ****************************************************************/
void FreeMibMsg( MIB_t *mibMsg)
{
- if(!mibMsg)
+ if(!mibMsg)
+ {
+ if(!(mibMsg->systemFrameNumber.buf))
+ {
+ if(!mibMsg->spare.buf)
{
- if(!(mibMsg->systemFrameNumber.buf))
- {
- if(!mibMsg->spare.buf)
- {
- DU_FREE(mibMsg->spare.buf, mibMsg->spare.size);
- }
- DU_FREE(mibMsg->systemFrameNumber.buf,
- mibMsg->systemFrameNumber.size);
- }
- DU_FREE(mibMsg, sizeof(MIB_t));
+ DU_FREE(mibMsg->spare.buf, mibMsg->spare.size);
}
+ DU_FREE(mibMsg->systemFrameNumber.buf,
+ mibMsg->systemFrameNumber.size);
+ }
+ DU_FREE(mibMsg, sizeof(MIB_t));
+ }
}
/*******************************************************************
*
* ****************************************************************/
uint8_t BuildMibMsg()
{
- MIB_t *mibMsg;
- asn_enc_rval_t encRetVal; /* Encoder return value */
+ MIB_t *mibMsg;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
uint8_t ret = RFAILED;
- uint8_t BuildMibret;
+ uint8_t BuildMibret;
while(true)
- {
- DU_ALLOC(mibMsg, sizeof(MIB_t));
- if(!mibMsg)
- {
- DU_LOG("DU APP: MIB msg memory allocation failure");
- break;
- }
- BuildMibret = BuildMib(mibMsg);
- if(BuildMibret != ROK)
- {
- break;
- }
- xer_fprint(stdout, &asn_DEF_MIB, mibMsg);
- memset(encBuf, 0, ENC_BUF_MAX_LEN);
- encBufSize = 0;
- encRetVal = aper_encode(&asn_DEF_MIB, 0,
- mibMsg, PrepFinalEncBuf, encBuf);
- printf("\nencbufSize:%d\n", encBufSize);
- if(encRetVal.encoded == -1)
- {
- DU_LOG("\nDU APP: Could not encode MIB structure(at %s)\n",
- encRetVal.failed_type?\
- encRetVal.failed_type->name
- :"unknown");
- break;
- }
+ {
+ DU_ALLOC(mibMsg, sizeof(MIB_t));
+ if(!mibMsg)
+ {
+ DU_LOG("DU APP: MIB msg memory allocation failure");
+ break;
+ }
+ BuildMibret = BuildMib(mibMsg);
+ if(BuildMibret != ROK)
+ {
+ break;
+ }
+ xer_fprint(stdout, &asn_DEF_MIB, mibMsg);
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_MIB, 0,
+ mibMsg, PrepFinalEncBuf, encBuf);
+ printf("\nencbufSize:%d\n", encBufSize);
+ if(encRetVal.encoded == -1)
+ {
+ DU_LOG("\nDU APP: Could not encode MIB structure(at %s)\n",
+ encRetVal.failed_type?\
+ encRetVal.failed_type->name
+ :"unknown");
+ break;
+ }
+
+ /* Print encoded buffer */
+ for(int i=0; i< encBufSize; i++)
+ {
+ printf("%x\t",encBuf[i]);
+ }
+ printf("\n");
- /* Print encoded buffer */
- for(int i=0; i< encBufSize; i++)
- {
- printf("%x\t",encBuf[i]);
- }
- printf("\n");
+ /* Free allocated memory */
+ ret = ROK;
+ break;
+ }
- /* Free allocated memory */
- ret = ROK;
- break;
- }
+ FreeMibMsg(mibMsg);
- FreeMibMsg(mibMsg);
-
- return ret;
+ return ret;
}
uint8_t BuildCellIdentity(CellIdentity_t *cellIdentity)
{
cellIdentity->size = ODU_VALUE_FIVE*sizeof(uint8_t);
- cellIdentity->bits_unused = ODU_VALUE_FOUR;
-
- DU_ALLOC(cellIdentity->buf, cellIdentity->size);
- if(!cellIdentity->buf)
- {
- DU_LOG("DU APP: CellIdentity memory allocation failure");
- return RFAILED;
- }
+ cellIdentity->bits_unused = ODU_VALUE_FOUR;
+
+ DU_ALLOC(cellIdentity->buf, cellIdentity->size);
+ if(!cellIdentity->buf)
+ {
+ DU_LOG("DU APP: CellIdentity memory allocation failure");
+ return RFAILED;
+ }
*cellIdentity->buf = duCfgParam.sib1Params.cellIdentity;
return ROK;
{
RAN_AreaCode_t *ranac;
DU_ALLOC(ranac, sizeof(RAN_AreaCode_t));
- if(!ranac)
- {
- DU_LOG("DU APP: RANAC memory allocation failure");
- return RFAILED;
- }
+ if(!ranac)
+ {
+ DU_LOG("DU APP: RANAC memory allocation failure");
+ return RFAILED;
+ }
*ranac = duCfgParam.sib1Params.ranac;
- *ranAreaCode = ranac;
+ *ranAreaCode = ranac;
return ROK;
}
/*******************************************************************
uint8_t BuildTac(TrackingAreaCode_t **trackAreaCode)
{
TrackingAreaCode_t *tac;
-
+
DU_ALLOC(tac, sizeof(TrackingAreaCode_t));
- if(!tac)
- {
- DU_LOG("DU APP: TAC memory allocation failure");
- return RFAILED;
- }
-
- tac->size = ODU_VALUE_THREE*sizeof(uint8_t);
- DU_ALLOC(tac->buf, tac->size);
- if(!tac->buf)
- {
- DU_LOG("DU APP: TAC memory allocation failure");
- return RFAILED;
- }
- *(tac->buf) = duCfgParam.sib1Params.tac;
- tac->bits_unused = ODU_VALUE_ZERO;
- *trackAreaCode = tac;
+ if(!tac)
+ {
+ DU_LOG("DU APP: TAC memory allocation failure");
+ return RFAILED;
+ }
+
+ tac->size = ODU_VALUE_THREE*sizeof(uint8_t);
+ DU_ALLOC(tac->buf, tac->size);
+ if(!tac->buf)
+ {
+ DU_LOG("DU APP: TAC memory allocation failure");
+ return RFAILED;
+ }
+ *(tac->buf) = duCfgParam.sib1Params.tac;
+ tac->bits_unused = ODU_VALUE_ZERO;
+ *trackAreaCode = tac;
return ROK;
}
* ****************************************************************/
uint8_t BuildPlmnList(CellAccessRelatedInfo_t *cellAccessInfo)
{
- uint8_t idx;
- uint8_t idx1;
- uint8_t idx2;
- uint8_t elementCnt;
- TrackingAreaCode_t **tac;
- RAN_AreaCode_t **ranac;
- CellIdentity_t *cellIdentity;
+ uint8_t idx;
+ uint8_t idx1;
+ uint8_t idx2;
+ uint8_t elementCnt;
+ TrackingAreaCode_t **tac;
+ RAN_AreaCode_t **ranac;
+ CellIdentity_t *cellIdentity;
uint8_t ret;
- struct PLMN_IdentityInfo__plmn_IdentityList
- *plmnIdInfo;
-
- DU_ALLOC(cellAccessInfo->plmn_IdentityList.list.array,
- cellAccessInfo->plmn_IdentityList.list.size);
- if(!cellAccessInfo->plmn_IdentityList.list.array)
- {
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
- return RFAILED;
- }
+ struct PLMN_IdentityInfo__plmn_IdentityList
+ *plmnIdInfo;
+
+ DU_ALLOC(cellAccessInfo->plmn_IdentityList.list.array,
+ cellAccessInfo->plmn_IdentityList.list.size);
+ if(!cellAccessInfo->plmn_IdentityList.list.array)
+ {
+ DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ return RFAILED;
+ }
elementCnt = cellAccessInfo->plmn_IdentityList.list.count;
- for(idx=0; idx<elementCnt; idx++)
- {
- DU_ALLOC(cellAccessInfo->plmn_IdentityList.list.array[idx],
- sizeof(PLMN_IdentityInfo_t));
- if(!cellAccessInfo->plmn_IdentityList.list.array[idx])
- {
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
- return RFAILED;
- }
- }
-
- idx = 0;
- /* PLMN list */
- elementCnt = ODU_VALUE_ONE;
-
- plmnIdInfo = &cellAccessInfo->plmn_IdentityList.list.array[idx]->\
- plmn_IdentityList;
- plmnIdInfo->list.count = elementCnt;
- plmnIdInfo->list.size = elementCnt * sizeof(PLMN_IdentitY_t *);
- DU_ALLOC(plmnIdInfo->list.array, plmnIdInfo->list.size);
- if(!plmnIdInfo->list.array)
- {
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
- return RFAILED;
- }
-
- for(idx1=0; idx1<elementCnt; idx1++)
- {
- DU_ALLOC(plmnIdInfo->list.array[idx1],
- sizeof(PLMN_IdentitY_t));
- if(!(plmnIdInfo->list.array[idx1]))
- {
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
- return RFAILED;
- }
- }
- idx1 = 0;
- DU_ALLOC(plmnIdInfo->list.array[idx1]->mcc,
- sizeof(MCC_t));
- if(!plmnIdInfo->list.array[idx1]->mcc)
- {
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
- return RFAILED;
- }
+ for(idx=0; idx<elementCnt; idx++)
+ {
+ DU_ALLOC(cellAccessInfo->plmn_IdentityList.list.array[idx],
+ sizeof(PLMN_IdentityInfo_t));
+ if(!cellAccessInfo->plmn_IdentityList.list.array[idx])
+ {
+ DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ return RFAILED;
+ }
+ }
+
+ idx = 0;
+ /* PLMN list */
+ elementCnt = ODU_VALUE_ONE;
+
+ plmnIdInfo = &cellAccessInfo->plmn_IdentityList.list.array[idx]->\
+ plmn_IdentityList;
+ plmnIdInfo->list.count = elementCnt;
+ plmnIdInfo->list.size = elementCnt * sizeof(PLMN_IdentitY_t *);
+ DU_ALLOC(plmnIdInfo->list.array, plmnIdInfo->list.size);
+ if(!plmnIdInfo->list.array)
+ {
+ DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ return RFAILED;
+ }
+
+ for(idx1=0; idx1<elementCnt; idx1++)
+ {
+ DU_ALLOC(plmnIdInfo->list.array[idx1],
+ sizeof(PLMN_IdentitY_t));
+ if(!(plmnIdInfo->list.array[idx1]))
+ {
+ DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ return RFAILED;
+ }
+ }
+ idx1 = 0;
+ DU_ALLOC(plmnIdInfo->list.array[idx1]->mcc,
+ sizeof(MCC_t));
+ if(!plmnIdInfo->list.array[idx1]->mcc)
+ {
+ DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ return RFAILED;
+ }
elementCnt = ODU_VALUE_THREE;
- plmnIdInfo->list.array[idx1]->mcc->list.count = elementCnt;
- plmnIdInfo->list.array[idx1]->mcc->list.size =\
- elementCnt * sizeof(MCC_MNC_Digit_t *);
- DU_ALLOC(plmnIdInfo->list.array[idx1]->mcc->list.array,
- plmnIdInfo->list.array[idx1]->mcc->list.size)
- if(!(plmnIdInfo->list.array[idx1]->mcc->list.array))
- {
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
- return RFAILED;
- }
- for(idx2=0; idx2<elementCnt; idx2++)
- {
- DU_ALLOC(plmnIdInfo->list.array[idx1]->mcc->list.array[idx2],
- sizeof(MCC_MNC_Digit_t));
- if(!plmnIdInfo->list.array[idx1]->mcc->list.array[idx2])
- {
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
- return RFAILED;
- }
- *(plmnIdInfo->list.array[idx1]->mcc->list.array[idx2])=\
- duCfgParam.sib1Params.plmn.mcc[idx2];
- }
- idx2 = 0;
- plmnIdInfo->list.array[idx1]->mnc.list.count = elementCnt;
- plmnIdInfo->list.array[idx1]->mnc.list.size =\
- elementCnt * sizeof(MCC_MNC_Digit_t *);
- DU_ALLOC(plmnIdInfo->list.array[idx1]->mnc.list.array,
- plmnIdInfo->list.array[idx1]->mnc.list.size);
- if(!plmnIdInfo->list.array[idx1]->mnc.list.array)
- {
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
- return RFAILED;
- }
- for(idx2=0; idx2<elementCnt; idx2++)
- {
- DU_ALLOC(plmnIdInfo->list.array[idx1]->mnc.list.array[idx2],
- sizeof(MCC_MNC_Digit_t));
- if(!plmnIdInfo->list.array[idx1]->mnc.list.array[idx2])
- {
- DU_LOG("DU APP: BuildPlmnList memory allocation failure");
- return RFAILED;
- }
- *(plmnIdInfo->list.array[idx1]->mnc.list.array[idx2])=\
- duCfgParam.sib1Params.plmn.mnc[idx2];
- }
+ plmnIdInfo->list.array[idx1]->mcc->list.count = elementCnt;
+ plmnIdInfo->list.array[idx1]->mcc->list.size =\
+ elementCnt * sizeof(MCC_MNC_Digit_t *);
+ DU_ALLOC(plmnIdInfo->list.array[idx1]->mcc->list.array,
+ plmnIdInfo->list.array[idx1]->mcc->list.size)
+ if(!(plmnIdInfo->list.array[idx1]->mcc->list.array))
+ {
+ DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ return RFAILED;
+ }
+ for(idx2=0; idx2<elementCnt; idx2++)
+ {
+ DU_ALLOC(plmnIdInfo->list.array[idx1]->mcc->list.array[idx2],
+ sizeof(MCC_MNC_Digit_t));
+ if(!plmnIdInfo->list.array[idx1]->mcc->list.array[idx2])
+ {
+ DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ return RFAILED;
+ }
+ *(plmnIdInfo->list.array[idx1]->mcc->list.array[idx2])=\
+ duCfgParam.sib1Params.plmn.mcc[idx2];
+ }
+ idx2 = 0;
+ plmnIdInfo->list.array[idx1]->mnc.list.count = elementCnt;
+ plmnIdInfo->list.array[idx1]->mnc.list.size =\
+ elementCnt * sizeof(MCC_MNC_Digit_t *);
+ DU_ALLOC(plmnIdInfo->list.array[idx1]->mnc.list.array,\
+ plmnIdInfo->list.array[idx1]->mnc.list.size);
+ if(!plmnIdInfo->list.array[idx1]->mnc.list.array)
+ {
+ DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ return RFAILED;
+ }
+ for(idx2=0; idx2<elementCnt; idx2++)
+ {
+ DU_ALLOC(plmnIdInfo->list.array[idx1]->mnc.list.array[idx2],
+ sizeof(MCC_MNC_Digit_t));
+ if(!plmnIdInfo->list.array[idx1]->mnc.list.array[idx2])
+ {
+ DU_LOG("DU APP: BuildPlmnList memory allocation failure");
+ return RFAILED;
+ }
+ *(plmnIdInfo->list.array[idx1]->mnc.list.array[idx2])=\
+ duCfgParam.sib1Params.plmn.mnc[idx2];
+ }
/* Tracking Area Code */
tac = &cellAccessInfo->plmn_IdentityList.list.array[idx]->trackingAreaCode;
- ret = BuildTac(tac);
- if(ret != ROK)
- {
- return RFAILED;
- }
+ ret = BuildTac(tac);
+ if(ret != ROK)
+ {
+ return RFAILED;
+ }
/* RANAC */
- ranac = &cellAccessInfo->plmn_IdentityList.list.array[idx]->ranac;
- ret=BuildRanac(ranac);
- if(ret != ROK)
- {
- return RFAILED;
- }
+ ranac = &cellAccessInfo->plmn_IdentityList.list.array[idx]->ranac;
+ ret=BuildRanac(ranac);
+ if(ret != ROK)
+ {
+ return RFAILED;
+ }
/* CellIdentity */
- cellIdentity =\
- &cellAccessInfo->plmn_IdentityList.list.array[idx]->cellIdentity;
- ret=BuildCellIdentity(cellIdentity);
- if(ret != ROK)
- {
- return RFAILED;
- }
+ cellIdentity = &cellAccessInfo->plmn_IdentityList.list.array[idx]->cellIdentity;
+ ret=BuildCellIdentity(cellIdentity);
+ if(ret != ROK)
+ {
+ return RFAILED;
+ }
+
+ /* cellReservedForOperatorUse */
+ cellAccessInfo->plmn_IdentityList.list.array[idx]->\
+ cellReservedForOperatorUse = duCfgParam.sib1Params.cellResvdForOpUse;
- /* cellReservedForOperatorUse */
- cellAccessInfo->plmn_IdentityList.list.array[idx]->\
- cellReservedForOperatorUse = \
- duCfgParam.sib1Params.cellResvdForOpUse;
-
return ROK;
}
DU_ALLOC(sibMapInfo->list.array[itr], sizeof(SIB_TypeInfo_t));
if(!sibMapInfo->list.array[itr])
{
- DU_LOG("DU APP: BuildSibMapInfoList memory allocation failure");
- return RFAILED;
+ DU_LOG("DU APP: BuildSibMapInfoList memory allocation failure");
+ return RFAILED;
}
}
-
+
itr = 0;
sibTypeInfo = sibMapInfo->list.array[itr];
sibTypeInfo->type = duCfgParam.sib1Params.siSchedInfo.sibType;
uint8_t itr; /* List iterator */
uint8_t elementCnt; /* Number of elements in list */
uint8_t ret;
- SchedulingInfo_t *schedInfo; /* Scheduling info */
+ SchedulingInfo_t *schedInfo; /* Scheduling info */
/* SI scheduling info list */
DU_ALLOC(si_SchedulingInfoList->list.array, si_SchedulingInfoList->list.size);
DU_LOG("DU APP: BuildSiSchedInfoList memory allocation failure");
return RFAILED;
}
-
+
elementCnt = si_SchedulingInfoList->list.count;
for(itr = 0; itr < elementCnt; itr++)
{
DU_ALLOC(si_SchedulingInfoList->list.array[itr], sizeof(struct SchedulingInfo));
if(!si_SchedulingInfoList->list.array[itr])
{
- DU_LOG("DU APP: BuildSiSchedInfoList memory allocation failure");
- return RFAILED;
+ DU_LOG("DU APP: BuildSiSchedInfoList memory allocation failure");
+ return RFAILED;
}
}
elementCnt = ODU_VALUE_ONE;
schedInfo->sib_MappingInfo.list.count = elementCnt;
schedInfo->sib_MappingInfo.list.size = elementCnt * sizeof(SIB_TypeInfo_t *);
-
+
ret = BuildSibMapInfoList(&schedInfo->sib_MappingInfo);
- if(ret != ROK)
- {
- return RFAILED;
- }
+ if(ret != ROK)
+ {
+ return RFAILED;
+ }
return ROK;
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildScsSpecificCarrierListDl
-(
-struct FrequencyInfoDL_SIB__scs_SpecificCarrierList *scsCarrierList
-)
+uint8_t BuildScsSpecificCarrierListDl( struct FrequencyInfoDL_SIB__scs_SpecificCarrierList *scsCarrierList)
{
uint8_t idx;
ScsSpecCarrier duScsSpecCarrier;
DU_ALLOC(scsCarrierList->list.array[idx], sizeof(SCS_SpecificCarrier_t));
if(!scsCarrierList->list.array[idx])
{
- DU_LOG("\nDU APP : SCS Specific Carrier list memory allocation failed");
- return RFAILED;
+ DU_LOG("\nDU APP : SCS Specific Carrier list memory allocation failed");
+ return RFAILED;
}
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t BuildCommonSerachSpaceList
-(
-struct PDCCH_ConfigCommon__commonSearchSpaceList *searchSpclist
-)
+uint8_t BuildCommonSerachSpaceList( struct PDCCH_ConfigCommon__commonSearchSpaceList *searchSpclist)
{
uint8_t idx;
SearchSpace_t *searchSpace;
DU_ALLOC(searchSpclist->list.array[idx], sizeof(SearchSpace_t));
if(!searchSpclist->list.array[idx])
{
- DU_LOG("\nDU APP : Common search space list memory alloc failed");
- return RFAILED;
+ DU_LOG("\nDU APP : Common search space list memory alloc failed");
+ return RFAILED;
}
}
/* Monitoring Slot periodicity and offset */
DU_ALLOC(searchSpace->monitoringSlotPeriodicityAndOffset,\
- sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
+ sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
if(!searchSpace->monitoringSlotPeriodicityAndOffset)
{
DU_LOG("\nDU APP : Common search space list memory alloc failed");
return RFAILED;
}
searchSpace->monitoringSlotPeriodicityAndOffset->present = \
- duPdcchCfg.monitorSlotPrdAndOffPresent;
+ duPdcchCfg.monitorSlotPrdAndOffPresent;
switch(searchSpace->monitoringSlotPeriodicityAndOffset->present)
{
case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1:
{
- //searchSpace->monitoringSlotPeriodicityAndOffset->choice.s11 = \
- duPdcchCfg.monitorSlotPrdAndOff;
- break;
+ //searchSpace->monitoringSlotPeriodicityAndOffset->choice.s11 = duPdcchCfg.monitorSlotPrdAndOff;
+ break;
}
case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl2:
{
- //TODO
+ //TODO
break;
}
case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl4:
{
- //TODO
- break;
+ //TODO
+ break;
}
case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl5:
{
}
case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl8:
{
- //TODO
- break;
+ //TODO
+ break;
}
case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl10:
{
- //TODO
- break;
+ //TODO
+ break;
}
case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl16:
{
}
case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl320:
{
- break;
+ //TODO
+ break;
}
case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl640:
{
}
case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl1280:
{
- //TODO
- break;
+ //TODO
+ break;
}
case SearchSpace__monitoringSlotPeriodicityAndOffset_PR_sl2560:
{
- //TODO
- break;
+ //TODO
+ break;
}
default:
{
- DU_LOG("\nDU APP : Invalid value:Montoring slot periodicity and offset");
- return RFAILED;
+ DU_LOG("\nDU APP : Invalid value:Montoring slot periodicity and offset");
+ return RFAILED;
}
}
-
+
/* Monitoring Symbols Within Slot */
DU_ALLOC(searchSpace->monitoringSymbolsWithinSlot,\
- sizeof(BIT_STRING_t));
+ sizeof(BIT_STRING_t));
if(!searchSpace->monitoringSymbolsWithinSlot)
{
- DU_LOG("\nDU APP : Common search space list memory alloc failed");
- return RFAILED;
+ DU_LOG("\nDU APP : Common search space list memory alloc failed");
+ return RFAILED;
}
searchSpace->monitoringSymbolsWithinSlot->size = 2*sizeof(uint8_t);
DU_ALLOC(searchSpace->monitoringSymbolsWithinSlot->buf, \
- searchSpace->monitoringSymbolsWithinSlot->size );
+ searchSpace->monitoringSymbolsWithinSlot->size );
if(!searchSpace->monitoringSymbolsWithinSlot->buf)
{
DU_LOG("\nDU APP : Common search space list memory alloc failed");
/* Number of candidates per aggregation level */
DU_ALLOC(searchSpace->nrofCandidates,\
- sizeof(struct SearchSpace__nrofCandidates));
+ sizeof(struct SearchSpace__nrofCandidates));
if(!searchSpace->nrofCandidates)
{
DU_LOG("\nDU APP : Common search space list memory alloc failed");
/* Search Space type and DCI Format */
DU_ALLOC(searchSpace->searchSpaceType,\
- sizeof( struct SearchSpace__searchSpaceType));
+ sizeof( struct SearchSpace__searchSpaceType));
if(!searchSpace->searchSpaceType)
{
DU_LOG("\nDU APP : Common search space list memory alloc failed");
{
case SearchSpace__searchSpaceType_PR_NOTHING:
{
- //TODO
- break;
+ //TODO
+ break;
}
case SearchSpace__searchSpaceType_PR_common:
{
- DU_ALLOC(searchSpace->searchSpaceType->choice.common,\
- sizeof(struct SearchSpace__searchSpaceType__common));
- if(!searchSpace->searchSpaceType->choice.common)
- {
- DU_LOG("\nDU APP : Common search space list memory alloc failed");
- return RFAILED;
- }
-
- DU_ALLOC(searchSpace->searchSpaceType->choice.common->\
- dci_Format0_0_AndFormat1_0, sizeof(struct \
- SearchSpace__searchSpaceType__common__dci_Format0_0_AndFormat1_0));
- if(!searchSpace->searchSpaceType->choice.common->dci_Format0_0_AndFormat1_0)
- {
- DU_LOG("\nDU APP : Common search space list memory alloc failed");
- return RFAILED;
- }
- break;
+ DU_ALLOC(searchSpace->searchSpaceType->choice.common, sizeof(struct SearchSpace__searchSpaceType__common));
+ if(!searchSpace->searchSpaceType->choice.common)
+ {
+ DU_LOG("\nDU APP : Common search space list memory alloc failed");
+ return RFAILED;
+ }
+
+ DU_ALLOC(searchSpace->searchSpaceType->choice.common->\
+ dci_Format0_0_AndFormat1_0, sizeof(struct \
+ SearchSpace__searchSpaceType__common__dci_Format0_0_AndFormat1_0));
+ if(!searchSpace->searchSpaceType->choice.common->dci_Format0_0_AndFormat1_0)
+ {
+ DU_LOG("\nDU APP : Common search space list memory alloc failed");
+ return RFAILED;
+ }
+ break;
}
case SearchSpace__searchSpaceType_PR_ue_Specific:
{
- break;
+ break;
}
default:
{
- DU_LOG("\nDU_APP: Invalid Search Space type");
- return RFAILED;
+ DU_LOG("\nDU_APP: Invalid Search Space type");
+ return RFAILED;
}
-
}
return ROK;
{
case BWP_DownlinkCommon__pdcch_ConfigCommon_PR_NOTHING:
{
- //TODO
- break;
+ //TODO
+ break;
}
case BWP_DownlinkCommon__pdcch_ConfigCommon_PR_release:
{
//TODO
- break;
+ break;
}
case BWP_DownlinkCommon__pdcch_ConfigCommon_PR_setup:
{
- DU_ALLOC(pdcchCfg->choice.setup, sizeof(PDCCH_ConfigCommon_t));
- if(!pdcchCfg->choice.setup)
- {
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
- return RFAILED;
- }
- pdcchSetup = pdcchCfg->choice.setup;
-
- /* Control Resource Set Zero */
- DU_ALLOC(pdcchSetup->controlResourceSetZero,
- sizeof(ControlResourceSetZero_t));
- if(!pdcchSetup->controlResourceSetZero)
- {
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
- return RFAILED;
- }
- *pdcchSetup->controlResourceSetZero = duPdcchCfg.ctrlRsrcSetZero;
-
- /* Search space zero */
- DU_ALLOC(pdcchSetup->searchSpaceZero, sizeof(SearchSpaceZero_t));
- if(!pdcchSetup->searchSpaceZero)
- {
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
- return RFAILED;
- }
- *pdcchSetup->searchSpaceZero = duPdcchCfg.searchSpcZero;
-
- /* Common Search Space List */
- DU_ALLOC(pdcchSetup->commonSearchSpaceList,\
- sizeof(struct PDCCH_ConfigCommon__commonSearchSpaceList));
- if(!pdcchSetup->commonSearchSpaceList)
- {
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
- return RFAILED;
- }
- elementCnt = ODU_VALUE_ONE;
- pdcchSetup->commonSearchSpaceList->list.count = elementCnt;
- pdcchSetup->commonSearchSpaceList->list.size = \
- elementCnt * sizeof(SearchSpace_t *);
- ret = BuildCommonSerachSpaceList(pdcchSetup->commonSearchSpaceList);
- if(ret != ROK)
- {
- return RFAILED;
- }
- CommonSerachSpaceListret=ROK;
-
- /* Search Space for SIB1 */
- DU_ALLOC(pdcchSetup->searchSpaceSIB1, sizeof(SearchSpaceId_t));
- if(!pdcchSetup->searchSpaceSIB1)
- {
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
- return RFAILED;
- }
- *pdcchSetup->searchSpaceSIB1 = duPdcchCfg.searchSpcSib1;
-
- /* Serach Space for Paging */
- DU_ALLOC(pdcchSetup->pagingSearchSpace, sizeof(SearchSpaceId_t));
- if(!pdcchSetup->pagingSearchSpace)
- {
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
- return RFAILED;
- }
- *pdcchSetup->pagingSearchSpace = duPdcchCfg.pagingSearchSpc;
-
- /* Search space for Random Access */
- DU_ALLOC(pdcchSetup->ra_SearchSpace, sizeof(SearchSpaceId_t));
- if(!pdcchSetup->ra_SearchSpace)
- {
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
- return RFAILED;
- }
- *pdcchSetup->ra_SearchSpace = duPdcchCfg.raSearchSpc;
+ DU_ALLOC(pdcchCfg->choice.setup, sizeof(PDCCH_ConfigCommon_t));
+ if(!pdcchCfg->choice.setup)
+ {
+ DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ return RFAILED;
+ }
+ pdcchSetup = pdcchCfg->choice.setup;
- break;
+ /* Control Resource Set Zero */
+ DU_ALLOC(pdcchSetup->controlResourceSetZero, sizeof(ControlResourceSetZero_t));
+ if(!pdcchSetup->controlResourceSetZero)
+ {
+ DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ return RFAILED;
+ }
+ *pdcchSetup->controlResourceSetZero = duPdcchCfg.ctrlRsrcSetZero;
+
+ /* Search space zero */
+ DU_ALLOC(pdcchSetup->searchSpaceZero, sizeof(SearchSpaceZero_t));
+ if(!pdcchSetup->searchSpaceZero)
+ {
+ DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ return RFAILED;
+ }
+ *pdcchSetup->searchSpaceZero = duPdcchCfg.searchSpcZero;
+
+ /* Common Search Space List */
+ DU_ALLOC(pdcchSetup->commonSearchSpaceList,\
+ sizeof(struct PDCCH_ConfigCommon__commonSearchSpaceList));
+ if(!pdcchSetup->commonSearchSpaceList)
+ {
+ DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ return RFAILED;
+ }
+ elementCnt = ODU_VALUE_ONE;
+ pdcchSetup->commonSearchSpaceList->list.count = elementCnt;
+ pdcchSetup->commonSearchSpaceList->list.size = elementCnt * sizeof(SearchSpace_t *);
+ ret = BuildCommonSerachSpaceList(pdcchSetup->commonSearchSpaceList);
+ if(ret != ROK)
+ {
+ return RFAILED;
+ }
+ CommonSerachSpaceListret=ROK;
+
+ /* Search Space for SIB1 */
+ DU_ALLOC(pdcchSetup->searchSpaceSIB1, sizeof(SearchSpaceId_t));
+ if(!pdcchSetup->searchSpaceSIB1)
+ {
+ DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ return RFAILED;
+ }
+ *pdcchSetup->searchSpaceSIB1 = duPdcchCfg.searchSpcSib1;
+
+ /* Serach Space for Paging */
+ DU_ALLOC(pdcchSetup->pagingSearchSpace, sizeof(SearchSpaceId_t));
+ if(!pdcchSetup->pagingSearchSpace)
+ {
+ DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ return RFAILED;
+ }
+ *pdcchSetup->pagingSearchSpace = duPdcchCfg.pagingSearchSpc;
+
+ /* Search space for Random Access */
+ DU_ALLOC(pdcchSetup->ra_SearchSpace, sizeof(SearchSpaceId_t));
+ if(!pdcchSetup->ra_SearchSpace)
+ {
+ DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ return RFAILED;
+ }
+ *pdcchSetup->ra_SearchSpace = duPdcchCfg.raSearchSpc;
+
+ break;
}
default :
{
- DU_LOG("\nDU APP : Invalid PDCCH Config type");
- return RFAILED;
+ DU_LOG("\nDU APP : Invalid PDCCH Config type");
+ return RFAILED;
}
}
PdschCfgCommon duPdschCfg;
PDSCH_ConfigCommon_t *pdschSetup;
PDSCH_TimeDomainResourceAllocation_t *timeDomRsrcAllocInfo;
-
+
duPdschCfg = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pdschCfg;
-
+
pdschCfg->present = duPdschCfg.present;
switch(pdschCfg->present)
case BWP_DownlinkCommon__pdsch_ConfigCommon_PR_NOTHING:
{
//TODO
- break;
+ break;
}
case BWP_DownlinkCommon__pdsch_ConfigCommon_PR_release:
{
- //TODO
- break;
+ //TODO
+ break;
}
case BWP_DownlinkCommon__pdsch_ConfigCommon_PR_setup:
{
- DU_ALLOC(pdschCfg->choice.setup, sizeof(PDSCH_ConfigCommon_t));
- if(!pdschCfg->choice.setup)
- {
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
- return RFAILED;
- }
- pdschSetup = pdschCfg->choice.setup;
-
- /* Time Domain Allocation List */
- DU_ALLOC(pdschSetup->pdsch_TimeDomainAllocationList, \
- sizeof(PDSCH_TimeDomainResourceAllocationList_t));
- if(!pdschSetup->pdsch_TimeDomainAllocationList)
- {
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
- return RFAILED;
- }
- elementCnt = ODU_VALUE_ONE;
- pdschSetup->pdsch_TimeDomainAllocationList->list.count = elementCnt;
- pdschSetup->pdsch_TimeDomainAllocationList->list.size = \
- elementCnt * sizeof(PDSCH_TimeDomainResourceAllocation_t *);
-
- DU_ALLOC(pdschSetup->pdsch_TimeDomainAllocationList->list.array,\
- pdschSetup->pdsch_TimeDomainAllocationList->list.size);
- if(!pdschSetup->pdsch_TimeDomainAllocationList->list.array)
- {
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
- return RFAILED;
- }
-
- for(idx=0; idx<elementCnt; idx++)
- {
- DU_ALLOC(pdschSetup->pdsch_TimeDomainAllocationList->list.array[idx],\
- sizeof(PDSCH_TimeDomainResourceAllocation_t));
- if(!pdschSetup->pdsch_TimeDomainAllocationList->list.array[idx])
- {
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
- return RFAILED;
- }
- }
-
- idx = 0;
- timeDomRsrcAllocInfo = pdschSetup->pdsch_TimeDomainAllocationList->list.array[idx];
-
- /* K0 */
- DU_ALLOC(timeDomRsrcAllocInfo->k0, sizeof(long));
- if(!timeDomRsrcAllocInfo->k0)
- {
- DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
- return RFAILED;
- }
- *timeDomRsrcAllocInfo->k0 = duPdschCfg.k0;
-
- timeDomRsrcAllocInfo->mappingType = duPdschCfg.mapType;
- timeDomRsrcAllocInfo->startSymbolAndLength = duPdschCfg.sliv;
+ DU_ALLOC(pdschCfg->choice.setup, sizeof(PDSCH_ConfigCommon_t));
+ if(!pdschCfg->choice.setup)
+ {
+ DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ return RFAILED;
+ }
+ pdschSetup = pdschCfg->choice.setup;
- break;
+ /* Time Domain Allocation List */
+ DU_ALLOC(pdschSetup->pdsch_TimeDomainAllocationList, \
+ sizeof(PDSCH_TimeDomainResourceAllocationList_t));
+ if(!pdschSetup->pdsch_TimeDomainAllocationList)
+ {
+ DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ return RFAILED;
+ }
+ elementCnt = ODU_VALUE_ONE;
+ pdschSetup->pdsch_TimeDomainAllocationList->list.count = elementCnt;
+ pdschSetup->pdsch_TimeDomainAllocationList->list.size = elementCnt * sizeof(PDSCH_TimeDomainResourceAllocation_t *);
+
+ DU_ALLOC(pdschSetup->pdsch_TimeDomainAllocationList->list.array,\
+ pdschSetup->pdsch_TimeDomainAllocationList->list.size);
+ if(!pdschSetup->pdsch_TimeDomainAllocationList->list.array)
+ {
+ DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ return RFAILED;
+ }
+
+ for(idx=0; idx<elementCnt; idx++)
+ {
+ DU_ALLOC(pdschSetup->pdsch_TimeDomainAllocationList->list.array[idx],\
+ sizeof(PDSCH_TimeDomainResourceAllocation_t));
+ if(!pdschSetup->pdsch_TimeDomainAllocationList->list.array[idx])
+ {
+ DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ return RFAILED;
+ }
+ }
+
+ idx = 0;
+ timeDomRsrcAllocInfo = pdschSetup->pdsch_TimeDomainAllocationList->list.array[idx];
+
+ /* K0 */
+ DU_ALLOC(timeDomRsrcAllocInfo->k0, sizeof(long));
+ if(!timeDomRsrcAllocInfo->k0)
+ {
+ DU_LOG("\nDU APP : PDCCH Config memory alloc failed");
+ return RFAILED;
+ }
+ *timeDomRsrcAllocInfo->k0 = duPdschCfg.k0;
+
+ timeDomRsrcAllocInfo->mappingType = duPdschCfg.mapType;
+ timeDomRsrcAllocInfo->startSymbolAndLength = duPdschCfg.sliv;
+
+ break;
}
default:
{
DU_LOG("\nDU APP: Invalid PDSCH Configuration type");
- return RFAILED;
+ return RFAILED;
}
}
{
uint8_t ret;
DlCfgCommon duDlCfg;
-
+
duDlCfg = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg;
bwp->genericParameters.locationAndBandwidth = duDlCfg.locAndBw;
/* PDCCH Config Common */
DU_ALLOC(bwp->pdcch_ConfigCommon, \
- sizeof(struct BWP_DownlinkCommon__pdcch_ConfigCommon));
+ sizeof(struct BWP_DownlinkCommon__pdcch_ConfigCommon));
if(!bwp->pdcch_ConfigCommon)
{
DU_LOG("\nDU APP : DL BWP memory allocation failed");
}
ret=BuildPdcchCfgCommon(bwp->pdcch_ConfigCommon);
if(ret != ROK)
- {
- return RFAILED;
- }
+ {
+ return RFAILED;
+ }
/* PDSCH Config Common */
DU_ALLOC(bwp->pdsch_ConfigCommon, \
- sizeof(struct BWP_DownlinkCommon__pdsch_ConfigCommon));
+ sizeof(struct BWP_DownlinkCommon__pdsch_ConfigCommon));
if(!bwp->pdsch_ConfigCommon)
{
DU_LOG("\nDU APP : DL BWP memory allocation failed");
}
ret=BuildPdschCfgCommon(bwp->pdsch_ConfigCommon);
if(ret != ROK)
- {
- return RFAILED;
- }
+ {
+ return RFAILED;
+ }
return ROK;
} /* BuildBwpDlCommon */
duBcchCfg = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.bcchCfg;
bcchCfg->modificationPeriodCoeff = duBcchCfg.modPrdCoeff;
-
+
return ROK;
}/* BuildBcchConfig */
uint8_t BuildPcchConfig(PCCH_Config_t *pcchCfg)
{
PcchCfg duPcchCfg;
-
+
duPcchCfg = duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pcchCfg;
-
+
pcchCfg->defaultPagingCycle = duPcchCfg.dfltPagingCycle;
pcchCfg->nAndPagingFrameOffset.present = duPcchCfg.nAndPagingFrmOffPresent;
switch(pcchCfg->nAndPagingFrameOffset.present)
}
case PCCH_Config__nAndPagingFrameOffset_PR_oneT:
{
- break;
+ //TODO
+ break;
}
case PCCH_Config__nAndPagingFrameOffset_PR_halfT:
{
- //TODO
- break;
+ //TODO
+ break;
}
case PCCH_Config__nAndPagingFrameOffset_PR_quarterT:
{
- //TODO
- break;
+ //TODO
+ break;
}
case PCCH_Config__nAndPagingFrameOffset_PR_oneEighthT:
{
- //TODO
- break;
+ //TODO
+ break;
}
case PCCH_Config__nAndPagingFrameOffset_PR_oneSixteenthT:
{
- //TODO
- break;
+ //TODO
+ break;
}
default:
{
- DU_LOG("\nDU APP : Invalid nAndPagingFrameOffset configuration");
- return RFAILED;
+ DU_LOG("\nDU APP : Invalid nAndPagingFrameOffset configuration");
+ return RFAILED;
}
}
pcchCfg->ns = duPcchCfg.numPagingOcc;
uint8_t BuildFreqInfoDl(FrequencyInfoDL_SIB_t *frequencyInfoDL)
{
- uint8_t ret;
- uint8_t idx;
+ uint8_t ret;
+ uint8_t idx;
uint8_t elementCnt;
DlCfgCommon dlCfg;
NR_MultiBandInfo_t *multiBandInfo;
elementCnt = ODU_VALUE_ONE;
frequencyInfoDL->frequencyBandList.list.count = elementCnt;
frequencyInfoDL->frequencyBandList.list.size = \
- elementCnt * sizeof(NR_MultiBandInfo_t *);
+ elementCnt * sizeof(NR_MultiBandInfo_t *);
DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array, \
- frequencyInfoDL->frequencyBandList.list.size);
+ frequencyInfoDL->frequencyBandList.list.size);
if(!frequencyInfoDL->frequencyBandList.list.array)
{
DU_LOG("\nDU APP : SIB1 DL Configuration memory allocation failed");
for(idx = 0; idx < elementCnt; idx++)
{
DU_ALLOC(frequencyInfoDL->frequencyBandList.list.array[idx],\
- sizeof(NR_MultiBandInfo_t));
+ sizeof(NR_MultiBandInfo_t));
if(!frequencyInfoDL->frequencyBandList.list.array[idx])
{
- DU_LOG("\nDU APP : SIB1 DL Configuration memory allocation failed");
- return RFAILED;
+ DU_LOG("\nDU APP : SIB1 DL Configuration memory allocation failed");
+ return RFAILED;
}
}
elementCnt = ODU_VALUE_ONE;
frequencyInfoDL->scs_SpecificCarrierList.list.count = elementCnt;
frequencyInfoDL->scs_SpecificCarrierList.list.size = \
- elementCnt * sizeof(SCS_SpecificCarrier_t *);
+ elementCnt * sizeof(SCS_SpecificCarrier_t *);
ret= BuildScsSpecificCarrierListDl(&frequencyInfoDL->scs_SpecificCarrierList);
if(ret != ROK)
- {
- return RFAILED;
- }
+ {
+ return RFAILED;
+ }
return ROK;
}/* BuildFreqInfoDl */
uint8_t BuildDlCfgCommSib(DownlinkConfigCommonSIB_t *dlCfg)
{
/* DL frequency info */
- uint8_t ret;
+ uint8_t ret;
ret = BuildFreqInfoDl(&dlCfg->frequencyInfoDL);
if(ret != ROK)
- {
- return RFAILED;
- }
- FreqInfoDlret=ROK;
+ {
+ return RFAILED;
+ }
+ FreqInfoDlret=ROK;
/* BWP Downlink Common */
ret = BuildBwpDlCommon(&dlCfg->initialDownlinkBWP);
if(ret != ROK)
- {
- return RFAILED;
- }
+ {
+ return RFAILED;
+ }
/* BCCH Config */
ret = BuildBcchConfig(&dlCfg->bcch_Config);
if(ret != ROK)
- {
- return RFAILED;
- }
+ {
+ return RFAILED;
+ }
/* PCCH Config */
ret = BuildPcchConfig(&dlCfg->pcch_Config);
if(ret != ROK)
- {
- return RFAILED;
- }
- return ROK;
+ {
+ return RFAILED;
+ }
+ return ROK;
} /* BuildDlCfgCommSib */
/*******************************************************************
{
uint8_t idx;
ScsSpecCarrier duScsSpecCarrier;
-
+
duScsSpecCarrier = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.ulScsCarrier;
-
+
DU_ALLOC(scsCarrierList->list.array, scsCarrierList->list.size);
if(!scsCarrierList->list.array)
{
- DU_LOG("\nDU APP : SCS Specific Carrier list memory allocation failed");
- return RFAILED;
+ DU_LOG("\nDU APP : SCS Specific Carrier list memory allocation failed");
+ return RFAILED;
}
-
+
for(idx = 0; idx < scsCarrierList->list.count; idx++)
{
DU_ALLOC(scsCarrierList->list.array[idx], sizeof(SCS_SpecificCarrier_t));
if(!scsCarrierList->list.array[idx])
{
- DU_LOG("\nDU APP : SCS Specific Carrier list memory allocation failed");
- return RFAILED;
+ DU_LOG("\nDU APP : SCS Specific Carrier list memory allocation failed");
+ return RFAILED;
}
}
idx = 0;
scsCarrierList->list.array[idx]->offsetToCarrier = duScsSpecCarrier.scsOffset;
scsCarrierList->list.array[idx]->subcarrierSpacing = duScsSpecCarrier.scs;
scsCarrierList->list.array[idx]->carrierBandwidth = duScsSpecCarrier.scsBw;
-
+
return ROK;
} /* End of BuildScsSpecificCarrierListUl */
{
uint8_t elementCnt;
UlCfgCommon ulCfg;
- uint8_t ret;
+ uint8_t ret;
ulCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg;
-
+
/* Subcarrier Spacing specifc carrier */
elementCnt = ODU_VALUE_ONE;
frequencyInfoUL->scs_SpecificCarrierList.list.count = elementCnt;
frequencyInfoUL->scs_SpecificCarrierList.list.size = \
- elementCnt * sizeof(SCS_SpecificCarrier_t *);
+ elementCnt * sizeof(SCS_SpecificCarrier_t *);
ret=BuildScsSpecificCarrierListUl(&frequencyInfoUL->scs_SpecificCarrierList);
if(ret != ROK)
- {
- return RFAILED;
- }
+ {
+ return RFAILED;
+ }
/* P-MAX */
DU_ALLOC(frequencyInfoUL->p_Max, sizeof(P_Max_t));
if(!frequencyInfoUL->p_Max)
{
case BWP_UplinkCommon__rach_ConfigCommon_PR_NOTHING:
{
- //TODO
- break;
+ //TODO
+ break;
}
case BWP_UplinkCommon__rach_ConfigCommon_PR_release:
{
//TODO
- break;
+ break;
}
case BWP_UplinkCommon__rach_ConfigCommon_PR_setup:
{
- DU_ALLOC(rachCfg->choice.setup, sizeof(RACH_ConfigCommon_t));
- if(!rachCfg->choice.setup)
- {
- DU_LOG("\nDU APP : Rach Config memory alloc failed");
- return RFAILED;
- }
- setup = rachCfg->choice.setup;
-
- /* Generic RACH Configuration */
- setup->rach_ConfigGeneric.prach_ConfigurationIndex = duRachCfg.prachCfgIdx;
- setup->rach_ConfigGeneric.msg1_FDM = duRachCfg.msg1Fdm;
- setup->rach_ConfigGeneric.msg1_FrequencyStart = duRachCfg.msg1FreqStart;
- setup->rach_ConfigGeneric.zeroCorrelationZoneConfig = duRachCfg.zeroCorrZoneCfg;
- setup->rach_ConfigGeneric.preambleReceivedTargetPower = duRachCfg.preambleRcvdTgtPwr;
- setup->rach_ConfigGeneric.preambleTransMax = duRachCfg.preambleTransMax;
- setup->rach_ConfigGeneric.powerRampingStep = duRachCfg.pwrRampingStep;
- setup->rach_ConfigGeneric.ra_ResponseWindow = duRachCfg.raRspWindow;
-
- /* Total number of RA preambles */
- DU_ALLOC(setup->totalNumberOfRA_Preambles, sizeof(long));
- if(!setup->totalNumberOfRA_Preambles)
- {
- DU_LOG("\nDU APP : Rach Config memory alloc failed");
- return RFAILED;
- }
- *setup->totalNumberOfRA_Preambles = duRachCfg.numRaPreamble;
-
- /* SSB per RACH occassion and CB Preambles per SSB */
- DU_ALLOC(setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB,\
- sizeof(struct RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB));
- if(!setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB)
- {
- DU_LOG("\nDU APP : Rach Config memory alloc failed");
- return RFAILED;
- }
- setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB->present = \
- duRachCfg.ssbPerRachOccPresent;
- switch(setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB->present)
- {
- case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_NOTHING:
- {
- //TODO
- break;
- }
- case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_oneEighth:
- {
- //TODO
- break;
- }
- case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_oneFourth:
- {
- //TODO
- break;
- }
- case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_oneHalf:
- {
- //TODO
- break;
- }
- case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_one:
- {
- setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB->choice.one =\
- duRachCfg.numSsbPerRachOcc;
- }
- case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_two:
- {
- //TODO
- break;
- }
- case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_four:
- {
- //TODO
- break;
- }
- case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_eight:
- {
- //TODO
- break;
- }
- case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_sixteen:
- {
- //TODO
- break;
- }
- default:
- {
- DU_LOG("\nDU APP: Invalid value for \
- ssb_PerRach_OccassionAndCB_PreamblesPerSSB");
- return RFAILED;
- }
- }
-
- /* RA Contention Resolution Timer */
- setup->ra_ContentionResolutionTimer = duRachCfg.contResTimer;
-
- /* RSRP Threshold SSB */
- DU_ALLOC(setup->rsrp_ThresholdSSB, sizeof(RSRP_Range_t));
- if(!setup->rsrp_ThresholdSSB)
- {
- DU_LOG("\nDU APP : Rach Config memory alloc failed");
- return RFAILED;
- }
- *setup->rsrp_ThresholdSSB = duRachCfg.rsrpThreshSsb;
-
- /* Root Sequence index */
- setup->prach_RootSequenceIndex.present = duRachCfg.rootSeqIdxPresent;
- switch(setup->prach_RootSequenceIndex.present)
- {
- case RACH_ConfigCommon__prach_RootSequenceIndex_PR_NOTHING:
- {
- //TODO
- break;
- }
- case RACH_ConfigCommon__prach_RootSequenceIndex_PR_l839:
- {
- //TODO
- break;;
- }
- case RACH_ConfigCommon__prach_RootSequenceIndex_PR_l139:
- {
- setup->prach_RootSequenceIndex.choice.l139 = duRachCfg.rootSeqIdx;
- break;
- }
- default:
- {
- DU_LOG("\nDU APP: Inavlid PRACH root sequence index type");
- return RFAILED;
- }
- }
-
- /* Msg 1 Subcarrier spacing */
- DU_ALLOC(setup->msg1_SubcarrierSpacing, sizeof(SubcarrierSpacing_t));
- if(!setup->msg1_SubcarrierSpacing)
- {
- DU_LOG("\nDU APP : Rach Config memory alloc failed");
- return RFAILED;
- }
- *setup->msg1_SubcarrierSpacing = duRachCfg.msg1Scs;
-
- /* Restricted Set Config */
- setup->restrictedSetConfig = duRachCfg.restrictedSetCfg;
+ DU_ALLOC(rachCfg->choice.setup, sizeof(RACH_ConfigCommon_t));
+ if(!rachCfg->choice.setup)
+ {
+ DU_LOG("\nDU APP : Rach Config memory alloc failed");
+ return RFAILED;
+ }
+ setup = rachCfg->choice.setup;
+
+ /* Generic RACH Configuration */
+ setup->rach_ConfigGeneric.prach_ConfigurationIndex = duRachCfg.prachCfgIdx;
+ setup->rach_ConfigGeneric.msg1_FDM = duRachCfg.msg1Fdm;
+ setup->rach_ConfigGeneric.msg1_FrequencyStart = duRachCfg.msg1FreqStart;
+ setup->rach_ConfigGeneric.zeroCorrelationZoneConfig = duRachCfg.zeroCorrZoneCfg;
+ setup->rach_ConfigGeneric.preambleReceivedTargetPower = duRachCfg.preambleRcvdTgtPwr;
+ setup->rach_ConfigGeneric.preambleTransMax = duRachCfg.preambleTransMax;
+ setup->rach_ConfigGeneric.powerRampingStep = duRachCfg.pwrRampingStep;
+ setup->rach_ConfigGeneric.ra_ResponseWindow = duRachCfg.raRspWindow;
+
+ /* Total number of RA preambles */
+ DU_ALLOC(setup->totalNumberOfRA_Preambles, sizeof(long));
+ if(!setup->totalNumberOfRA_Preambles)
+ {
+ DU_LOG("\nDU APP : Rach Config memory alloc failed");
+ return RFAILED;
+ }
+ *setup->totalNumberOfRA_Preambles = duRachCfg.numRaPreamble;
- break;
+ /* SSB per RACH occassion and CB Preambles per SSB */
+ DU_ALLOC(setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB,\
+ sizeof(struct RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB));
+ if(!setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB)
+ {
+ DU_LOG("\nDU APP : Rach Config memory alloc failed");
+ return RFAILED;
+ }
+ setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB->present = \
+ duRachCfg.ssbPerRachOccPresent;
+ switch(setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB->present)
+ {
+ case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_NOTHING:
+ {
+ //TODO
+ break;
+ }
+ case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_oneEighth:
+ {
+ //TODO
+ break;
+ }
+ case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_oneFourth:
+ {
+ //TODO
+ break;
+ }
+ case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_oneHalf:
+ {
+ //TODO
+ break;
+ }
+ case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_one:
+ {
+ setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB->choice.one =\
+ duRachCfg.numSsbPerRachOcc;
+ }
+ case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_two:
+ {
+ //TODO
+ break;
+ }
+ case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_four:
+ {
+ //TODO
+ break;
+ }
+ case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_eight:
+ {
+ //TODO
+ break;
+ }
+ case RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB_PR_sixteen:
+ {
+ //TODO
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nDU APP: Invalid value for \
+ ssb_PerRach_OccassionAndCB_PreamblesPerSSB");
+ return RFAILED;
+ }
+ }
+
+ /* RA Contention Resolution Timer */
+ setup->ra_ContentionResolutionTimer = duRachCfg.contResTimer;
+
+ /* RSRP Threshold SSB */
+ DU_ALLOC(setup->rsrp_ThresholdSSB, sizeof(RSRP_Range_t));
+ if(!setup->rsrp_ThresholdSSB)
+ {
+ DU_LOG("\nDU APP : Rach Config memory alloc failed");
+ return RFAILED;
+ }
+ *setup->rsrp_ThresholdSSB = duRachCfg.rsrpThreshSsb;
+
+ /* Root Sequence index */
+ setup->prach_RootSequenceIndex.present = duRachCfg.rootSeqIdxPresent;
+ switch(setup->prach_RootSequenceIndex.present)
+ {
+ case RACH_ConfigCommon__prach_RootSequenceIndex_PR_NOTHING:
+ {
+ //TODO
+ break;
+ }
+ case RACH_ConfigCommon__prach_RootSequenceIndex_PR_l839:
+ {
+ //TODO
+ break;
+ }
+ case RACH_ConfigCommon__prach_RootSequenceIndex_PR_l139:
+ {
+ setup->prach_RootSequenceIndex.choice.l139 = duRachCfg.rootSeqIdx;
+ break;
+ }
+ default:
+ {
+ DU_LOG("\nDU APP: Inavlid PRACH root sequence index type");
+ return RFAILED;
+ }
+ }
+
+ /* Msg 1 Subcarrier spacing */
+ DU_ALLOC(setup->msg1_SubcarrierSpacing, sizeof(SubcarrierSpacing_t));
+ if(!setup->msg1_SubcarrierSpacing)
+ {
+ DU_LOG("\nDU APP : Rach Config memory alloc failed");
+ return RFAILED;
+ }
+ *setup->msg1_SubcarrierSpacing = duRachCfg.msg1Scs;
+
+ /* Restricted Set Config */
+ setup->restrictedSetConfig = duRachCfg.restrictedSetCfg;
+
+ break;
}
default:
{
- DU_LOG("\nDU APP : Invalid RACH Config type ");
- return RFAILED;
+ DU_LOG("\nDU APP : Invalid RACH Config type ");
+ return RFAILED;
}
}
- return ROK;
+ return ROK;
}/* BuildRachCfgCommon */
/*******************************************************************
PuschCfgCommon duPuschCfg;
PUSCH_ConfigCommon_t *setup;
PUSCH_TimeDomainResourceAllocation_t *timeDomRsrcAllocInfo;
-
+
duPuschCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.puschCfg;
-
+
puschCfg->present = duPuschCfg.present;
switch(puschCfg->present)
{
case BWP_UplinkCommon__pusch_ConfigCommon_PR_NOTHING:
{
//TODO
- break;
+ break;
}
case BWP_UplinkCommon__pusch_ConfigCommon_PR_release:
{
//TODO
- break;
+ break;
}
case BWP_UplinkCommon__pusch_ConfigCommon_PR_setup:
{
- DU_ALLOC(puschCfg->choice.setup, sizeof(PUSCH_ConfigCommon_t));
- if(!puschCfg->choice.setup)
- {
- DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
- return RFAILED;
- }
- setup = puschCfg->choice.setup;
-
- /* Time Domain Resource Allocation List */
- DU_ALLOC(setup->pusch_TimeDomainAllocationList,\
- sizeof(PUSCH_TimeDomainResourceAllocationList_t));
- if(!setup->pusch_TimeDomainAllocationList)
- {
- DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
- return RFAILED;
- }
- elementCnt = ODU_VALUE_ONE;
- setup->pusch_TimeDomainAllocationList->list.count = elementCnt;
- setup->pusch_TimeDomainAllocationList->list.size = \
- elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
-
- DU_ALLOC(setup->pusch_TimeDomainAllocationList->list.array, \
- setup->pusch_TimeDomainAllocationList->list.size);
- if(!setup->pusch_TimeDomainAllocationList->list.array)
- {
- DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
- return RFAILED;
- }
-
- for(idx=0; idx<elementCnt; idx++)
- {
- DU_ALLOC(setup->pusch_TimeDomainAllocationList->list.array[idx],\
- sizeof(PUSCH_TimeDomainResourceAllocation_t));
- if(!setup->pusch_TimeDomainAllocationList->list.array[idx])
- {
- DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
- return RFAILED;
- }
- }
-
- idx = 0;
- timeDomRsrcAllocInfo = setup->pusch_TimeDomainAllocationList->list.array[idx];
-
- /* K2 */
- DU_ALLOC(timeDomRsrcAllocInfo->k2, sizeof(long));
- if(!timeDomRsrcAllocInfo->k2)
- {
- DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
- return RFAILED;
- }
- *timeDomRsrcAllocInfo->k2 = duPuschCfg.k2;
-
- timeDomRsrcAllocInfo->mappingType = duPuschCfg.mapType;
- timeDomRsrcAllocInfo->startSymbolAndLength = duPuschCfg.sliv;
-
- /* Msg3 Delta Preamble */
- DU_ALLOC(setup->msg3_DeltaPreamble, sizeof(long));
- if(!setup->msg3_DeltaPreamble)
- {
- DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
- return RFAILED;
- }
- *setup->msg3_DeltaPreamble = duPuschCfg.msg3DeltaPreamble;
-
- /* P0 Nominal with grnat */
- DU_ALLOC(setup->p0_NominalWithGrant, sizeof(long));
- if(!setup->p0_NominalWithGrant)
- {
- DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
- return RFAILED;
- }
- *setup->p0_NominalWithGrant = duPuschCfg.p0NominalWithGrant;
+ DU_ALLOC(puschCfg->choice.setup, sizeof(PUSCH_ConfigCommon_t));
+ if(!puschCfg->choice.setup)
+ {
+ DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
+ return RFAILED;
+ }
+ setup = puschCfg->choice.setup;
- break;
+ /* Time Domain Resource Allocation List */
+ DU_ALLOC(setup->pusch_TimeDomainAllocationList,\
+ sizeof(PUSCH_TimeDomainResourceAllocationList_t));
+ if(!setup->pusch_TimeDomainAllocationList)
+ {
+ DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
+ return RFAILED;
+ }
+ elementCnt = ODU_VALUE_ONE;
+ setup->pusch_TimeDomainAllocationList->list.count = elementCnt;
+ setup->pusch_TimeDomainAllocationList->list.size = \
+ elementCnt * sizeof(PUSCH_TimeDomainResourceAllocation_t *);
+
+ DU_ALLOC(setup->pusch_TimeDomainAllocationList->list.array, \
+ setup->pusch_TimeDomainAllocationList->list.size);
+ if(!setup->pusch_TimeDomainAllocationList->list.array)
+ {
+ DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
+ return RFAILED;
+ }
+
+ for(idx=0; idx<elementCnt; idx++)
+ {
+ DU_ALLOC(setup->pusch_TimeDomainAllocationList->list.array[idx],\
+ sizeof(PUSCH_TimeDomainResourceAllocation_t));
+ if(!setup->pusch_TimeDomainAllocationList->list.array[idx])
+ {
+ DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
+ return RFAILED;
+ }
+ }
+
+ idx = 0;
+ timeDomRsrcAllocInfo = setup->pusch_TimeDomainAllocationList->list.array[idx];
+
+ /* K2 */
+ DU_ALLOC(timeDomRsrcAllocInfo->k2, sizeof(long));
+ if(!timeDomRsrcAllocInfo->k2)
+ {
+ DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
+ return RFAILED;
+ }
+ *timeDomRsrcAllocInfo->k2 = duPuschCfg.k2;
+
+ timeDomRsrcAllocInfo->mappingType = duPuschCfg.mapType;
+ timeDomRsrcAllocInfo->startSymbolAndLength = duPuschCfg.sliv;
+
+ /* Msg3 Delta Preamble */
+ DU_ALLOC(setup->msg3_DeltaPreamble, sizeof(long));
+ if(!setup->msg3_DeltaPreamble)
+ {
+ DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
+ return RFAILED;
+ }
+ *setup->msg3_DeltaPreamble = duPuschCfg.msg3DeltaPreamble;
+
+ /* P0 Nominal with grnat */
+ DU_ALLOC(setup->p0_NominalWithGrant, sizeof(long));
+ if(!setup->p0_NominalWithGrant)
+ {
+ DU_LOG("\nDU APP : PUSCH Config memory alloc failed");
+ return RFAILED;
+ }
+ *setup->p0_NominalWithGrant = duPuschCfg.p0NominalWithGrant;
+
+ break;
}
default:
{
PUCCH_ConfigCommon_t *setup;
duPucchCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.pucchCfg;
-
+
pucchCfg->present = duPucchCfg.present;
switch(pucchCfg->present)
{
case BWP_UplinkCommon__pucch_ConfigCommon_PR_NOTHING:
{
- //TODO
- break;
+ //TODO
+ break;
}
case BWP_UplinkCommon__pucch_ConfigCommon_PR_release:
{
//TODO
- break;
+ break;
}
case BWP_UplinkCommon__pucch_ConfigCommon_PR_setup:
{
- DU_ALLOC(pucchCfg->choice.setup, sizeof(PUCCH_ConfigCommon_t));
- if(!pucchCfg->choice.setup)
- {
- DU_LOG("\nDU APP : PUCCH Config memory alloc failed");
- return RFAILED;
- }
- setup = pucchCfg->choice.setup;
-
- /* Resource Common */
- DU_ALLOC(setup->pucch_ResourceCommon, sizeof(long));
- if(!setup->pucch_ResourceCommon)
- {
- DU_LOG("\nDU APP : PUCCH Config memory alloc failed");
- return RFAILED;
- }
- *setup->pucch_ResourceCommon = duPucchCfg.rsrcComm;
-
- /* Group hopping */
- setup->pucch_GroupHopping = duPucchCfg.grpHop;
-
- /* P0 nominal */
- DU_ALLOC(setup->p0_nominal, sizeof(long));
- if(!setup->p0_nominal)
- {
- DU_LOG("\nDU APP : PUCCH Config memory alloc failed");
- return RFAILED;
- }
- *setup->p0_nominal = duPucchCfg.p0Nominal;
+ DU_ALLOC(pucchCfg->choice.setup, sizeof(PUCCH_ConfigCommon_t));
+ if(!pucchCfg->choice.setup)
+ {
+ DU_LOG("\nDU APP : PUCCH Config memory alloc failed");
+ return RFAILED;
+ }
+ setup = pucchCfg->choice.setup;
- break;
+ /* Resource Common */
+ DU_ALLOC(setup->pucch_ResourceCommon, sizeof(long));
+ if(!setup->pucch_ResourceCommon)
+ {
+ DU_LOG("\nDU APP : PUCCH Config memory alloc failed");
+ return RFAILED;
+ }
+ *setup->pucch_ResourceCommon = duPucchCfg.rsrcComm;
+
+ /* Group hopping */
+ setup->pucch_GroupHopping = duPucchCfg.grpHop;
+
+ /* P0 nominal */
+ DU_ALLOC(setup->p0_nominal, sizeof(long));
+ if(!setup->p0_nominal)
+ {
+ DU_LOG("\nDU APP : PUCCH Config memory alloc failed");
+ return RFAILED;
+ }
+ *setup->p0_nominal = duPucchCfg.p0Nominal;
+
+ break;
}
default:
{
DU_LOG("\nDU APP : Invalid PUCCH Config type");
- return RFAILED;
+ return RFAILED;
}
}
return ROK;
uint8_t BuildBwpUlCommon(BWP_UplinkCommon_t *bwp)
{
- uint8_t ret;
- UlCfgCommon duUlCfg;
-
+ uint8_t ret;
+ UlCfgCommon duUlCfg;
+
duUlCfg = duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg;
-
+
bwp->genericParameters.locationAndBandwidth = duUlCfg.locAndBw;
bwp->genericParameters.subcarrierSpacing = duUlCfg.ulScsCarrier.scs;
-
+
/* RACH Config Common */
DU_ALLOC(bwp->rach_ConfigCommon,\
- sizeof(struct BWP_UplinkCommon__rach_ConfigCommon));
+ sizeof(struct BWP_UplinkCommon__rach_ConfigCommon));
if(!bwp->rach_ConfigCommon)
{
DU_LOG("\nDU APP : UL BWP memory allocation failed");
}
ret = BuildRachCfgCommon(bwp->rach_ConfigCommon);
if(ret != ROK)
- {
- return RFAILED;
- }
- RachCfgCommonret=ROK;
-
- /* PUSCH Config Common */
+ {
+ return RFAILED;
+ }
+ RachCfgCommonret=ROK;
+
+ /* PUSCH Config Common */
DU_ALLOC(bwp->pusch_ConfigCommon,\
- sizeof(struct BWP_UplinkCommon__pusch_ConfigCommon));
+ sizeof(struct BWP_UplinkCommon__pusch_ConfigCommon));
if(!bwp->pusch_ConfigCommon)
{
DU_LOG("\nDU APP : UL BWP memory allocation failed");
return RFAILED;
}
ret = BuildPuschCfgCommon(bwp->pusch_ConfigCommon);
- if(ret != ROK)
- {
- return RFAILED;
- }
+ if(ret != ROK)
+ {
+ return RFAILED;
+ }
PuschCfgCommonret = ROK;
-
- /* PUCCH Config Common */
+
+ /* PUCCH Config Common */
DU_ALLOC(bwp->pucch_ConfigCommon,\
- sizeof(struct BWP_UplinkCommon__pucch_ConfigCommon));
+ sizeof(struct BWP_UplinkCommon__pucch_ConfigCommon));
if(!bwp->pucch_ConfigCommon)
{
DU_LOG("\nDU APP : UL BWP memory allocation failed");
}
ret = BuildPucchCfgCommon(bwp->pucch_ConfigCommon);
if(ret != ROK)
- {
- return RFAILED;
- }
+ {
+ return RFAILED;
+ }
return ROK;
}/* BuildBwpUlCommon */
uint8_t BuildUlCfgCommSib(UplinkConfigCommonSIB_t *ulCfg)
{
uint8_t ret;
- /* UL frequency info */
+ /* UL frequency info */
ret = BuildFreqInfoUl(&ulCfg->frequencyInfoUL);
if(ret != ROK)
- {
- return RFAILED;
- }
+ {
+ return RFAILED;
+ }
/* BWP Uplink Common */
ret = BuildBwpUlCommon(&ulCfg->initialUplinkBWP);
if(ret != ROK)
- {
- return RFAILED;
- }
+ {
+ return RFAILED;
+ }
/* Time Alignment timer */
ulCfg->timeAlignmentTimerCommon = \
- duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.timeAlignTimerComm;
+ duCfgParam.sib1Params.srvCellCfgCommSib.ulCfg.timeAlignTimerComm;
return ROK;
}/* BuildUlCfgCommSib */
tddCfg->pattern1.nrofDownlinkSymbols = duTddCfg.numDlSymbols;
tddCfg->pattern1.nrofUplinkSlots = duTddCfg.numUlSlots;
tddCfg->pattern1.nrofUplinkSymbols = duTddCfg.numUlSymbols;
-
+
return ROK;
}/* BuildTddUlDlCfgComm */
-
+
/*******************************************************************
*
* @brief Builds Serving cell config common in SIB1 message
{
SrvCellCfgCommSib duSrvCellCfg;
BIT_STRING_t *ssbPosInBurst;
- uint8_t ret;
+ uint8_t ret;
duSrvCellCfg = duCfgParam.sib1Params.srvCellCfgCommSib;
/* SSB Position in Burst */
ssbPosInBurst->buf[0] = duSrvCellCfg.ssbPosInBurst;
ssbPosInBurst->bits_unused = 0;
- switch(duSrvCellCfg.ssbPrdServingCell)
- {
- case SSB_PERIODICITY_5MS:
- srvCellCfg->ssb_PeriodicityServingCell = \
- ServingCellConfigCommonSIB__ssb_PeriodicityServingCell_ms5;
- break;
- case SSB_PERIODICITY_10MS:
- srvCellCfg->ssb_PeriodicityServingCell = \
- ServingCellConfigCommonSIB__ssb_PeriodicityServingCell_ms10;
- break;
- case SSB_PERIODICITY_20MS:
- srvCellCfg->ssb_PeriodicityServingCell = \
- ServingCellConfigCommonSIB__ssb_PeriodicityServingCell_ms20;
- break;
- case SSB_PERIODICITY_40MS:
- srvCellCfg->ssb_PeriodicityServingCell = \
- ServingCellConfigCommonSIB__ssb_PeriodicityServingCell_ms40;
- break;
- case SSB_PERIODICITY_80MS:
- srvCellCfg->ssb_PeriodicityServingCell = \
- ServingCellConfigCommonSIB__ssb_PeriodicityServingCell_ms80;
- break;
- case SSB_PERIODICITY_160MS:
- srvCellCfg->ssb_PeriodicityServingCell = \
- ServingCellConfigCommonSIB__ssb_PeriodicityServingCell_ms160;
- break;
- }
+ switch(duSrvCellCfg.ssbPrdServingCell)
+ {
+ case SSB_PERIODICITY_5MS:
+ srvCellCfg->ssb_PeriodicityServingCell = \
+ ServingCellConfigCommonSIB__ssb_PeriodicityServingCell_ms5;
+ break;
+ case SSB_PERIODICITY_10MS:
+ srvCellCfg->ssb_PeriodicityServingCell = \
+ ServingCellConfigCommonSIB__ssb_PeriodicityServingCell_ms10;
+ break;
+ case SSB_PERIODICITY_20MS:
+ srvCellCfg->ssb_PeriodicityServingCell = \
+ ServingCellConfigCommonSIB__ssb_PeriodicityServingCell_ms20;
+ break;
+ case SSB_PERIODICITY_40MS:
+ srvCellCfg->ssb_PeriodicityServingCell = \
+ ServingCellConfigCommonSIB__ssb_PeriodicityServingCell_ms40;
+ break;
+ case SSB_PERIODICITY_80MS:
+ srvCellCfg->ssb_PeriodicityServingCell = \
+ ServingCellConfigCommonSIB__ssb_PeriodicityServingCell_ms80;
+ break;
+ case SSB_PERIODICITY_160MS:
+ srvCellCfg->ssb_PeriodicityServingCell = \
+ ServingCellConfigCommonSIB__ssb_PeriodicityServingCell_ms160;
+ break;
+ }
srvCellCfg->ss_PBCH_BlockPower = duSrvCellCfg.ssPbchBlockPwr;
/* Downlink config common */
ret = BuildDlCfgCommSib(&srvCellCfg->downlinkConfigCommon);
- if(ret != ROK)
- {
- return RFAILED;
- }
+ if(ret != ROK)
+ {
+ return RFAILED;
+ }
DlCfgCommSibret = ROK;
/* Uplink Config Comm */
return RFAILED;
}
ret = BuildUlCfgCommSib(srvCellCfg->uplinkConfigCommon);
- if(ret != ROK)
- {
- return RFAILED;
- }
+ if(ret != ROK)
+ {
+ return RFAILED;
+ }
UlCfgCommSibret=ROK;
-
+
/* TDD UL DL Config Comm */
DU_ALLOC(srvCellCfg->tdd_UL_DL_ConfigurationCommon, sizeof(TDD_UL_DL_ConfigCommon_t));
if(!srvCellCfg->tdd_UL_DL_ConfigurationCommon)
}
ret = BuildTddUlDlCfgComm(srvCellCfg->tdd_UL_DL_ConfigurationCommon);
if(ret != ROK)
- {
- return RFAILED;
- }
+ {
+ return RFAILED;
+ }
return ROK;
}
* ****************************************************************/
uint8_t BuildSib1Msg()
{
- SIB1_t *sib1Msg;
- CellAccessRelatedInfo_t *cellAccessInfo;
- uint8_t elementCnt;
- uint8_t ret1;
- asn_enc_rval_t encRetVal;
+ SIB1_t *sib1Msg;
+ CellAccessRelatedInfo_t *cellAccessInfo;
+ uint8_t elementCnt;
+ uint8_t ret1;
+ asn_enc_rval_t encRetVal;
uint8_t ret = RFAILED;
- do
- {
- DU_ALLOC(sib1Msg, sizeof(SIB1_t));
- if(!sib1Msg)
- {
- DU_LOG("DU APP: SIB1 msg memory allocation failure");
- break;
- }
-
- elementCnt = ODU_VALUE_ONE;
-
- /* PLMN list */
- cellAccessInfo = &sib1Msg->cellAccessRelatedInfo;
- cellAccessInfo->plmn_IdentityList.list.count =
- elementCnt;
- cellAccessInfo->plmn_IdentityList.list.size
- = elementCnt * sizeof(PLMN_IdentityInfo_t *);
-
- ret1 = BuildPlmnList(cellAccessInfo);
- if(ret1 != ROK)
- {
- break;
- }
- /* Connection Establish Failure Control */
- DU_ALLOC(sib1Msg->connEstFailureControl, sizeof(ConnEstFailureControl_t));
- if(!sib1Msg->connEstFailureControl)
- {
- DU_LOG("DU APP: sib1Msg->connEstFailureControl memory allocation failure");
- break;
- }
- sib1Msg->connEstFailureControl->connEstFailCount =\
- duCfgParam.sib1Params.connEstFailCnt;
- sib1Msg->connEstFailureControl->connEstFailOffsetValidity =\
- duCfgParam.sib1Params.connEstFailOffValidity;
-
- /* SI Scheduling Info */
- DU_ALLOC(sib1Msg->si_SchedulingInfo, sizeof(SI_SchedulingInfo_t));
- if(!sib1Msg->si_SchedulingInfo)
- {
- DU_LOG("DU APP: sib1Msg->si_SchedulingInfo memory allocation failure");
- break;
- }
- elementCnt = ODU_VALUE_ONE;
- sib1Msg->si_SchedulingInfo->schedulingInfoList.list.count = elementCnt;
- sib1Msg->si_SchedulingInfo->schedulingInfoList.list.size = elementCnt *
- sizeof(struct SchedulingInfo *);
- ret1 = BuildSiSchedInfoList(&sib1Msg->si_SchedulingInfo->schedulingInfoList);
- if(ret1 != ROK)
- {
- break;
- }
- sib1Msg->si_SchedulingInfo->si_WindowLength = duCfgParam.sib1Params.siSchedInfo.winLen;
-
- /* Serving Cell Config Common */
- DU_ALLOC(sib1Msg->servingCellConfigCommon, sizeof(ServingCellConfigCommonSIB_t));
- if(!sib1Msg->servingCellConfigCommon)
- {
- DU_LOG("DU APP: sib1Msg->servingCellConfigCommon memory allocation failure");
- break;
- }
- ret1 = BuildServCellCfgCommonSib(sib1Msg->servingCellConfigCommon);
- if(ret1 != ROK)
- {
- break;
- }
+ do
+ {
+ DU_ALLOC(sib1Msg, sizeof(SIB1_t));
+ if(!sib1Msg)
+ {
+ DU_LOG("DU APP: SIB1 msg memory allocation failure");
+ break;
+ }
+
+ elementCnt = ODU_VALUE_ONE;
+
+ /* PLMN list */
+ cellAccessInfo = &sib1Msg->cellAccessRelatedInfo;
+ cellAccessInfo->plmn_IdentityList.list.count = elementCnt;
+ cellAccessInfo->plmn_IdentityList.list.size = elementCnt * sizeof(PLMN_IdentityInfo_t *);
+
+ ret1 = BuildPlmnList(cellAccessInfo);
+ if(ret1 != ROK)
+ {
+ break;
+ }
+ /* Connection Establish Failure Control */
+ DU_ALLOC(sib1Msg->connEstFailureControl, sizeof(ConnEstFailureControl_t));
+ if(!sib1Msg->connEstFailureControl)
+ {
+ DU_LOG("DU APP: sib1Msg->connEstFailureControl memory allocation failure");
+ break;
+ }
+ sib1Msg->connEstFailureControl->connEstFailCount =\
+ duCfgParam.sib1Params.connEstFailCnt;
+ sib1Msg->connEstFailureControl->connEstFailOffsetValidity =\
+ duCfgParam.sib1Params.connEstFailOffValidity;
+
+ /* SI Scheduling Info */
+ DU_ALLOC(sib1Msg->si_SchedulingInfo, sizeof(SI_SchedulingInfo_t));
+ if(!sib1Msg->si_SchedulingInfo)
+ {
+ DU_LOG("DU APP: sib1Msg->si_SchedulingInfo memory allocation failure");
+ break;
+ }
+ elementCnt = ODU_VALUE_ONE;
+ sib1Msg->si_SchedulingInfo->schedulingInfoList.list.count = elementCnt;
+ sib1Msg->si_SchedulingInfo->schedulingInfoList.list.size = elementCnt *
+ sizeof(struct SchedulingInfo *);
+ ret1 = BuildSiSchedInfoList(&sib1Msg->si_SchedulingInfo->schedulingInfoList);
+ if(ret1 != ROK)
+ {
+ break;
+ }
+ sib1Msg->si_SchedulingInfo->si_WindowLength = duCfgParam.sib1Params.siSchedInfo.winLen;
+
+ /* Serving Cell Config Common */
+ DU_ALLOC(sib1Msg->servingCellConfigCommon, sizeof(ServingCellConfigCommonSIB_t));
+ if(!sib1Msg->servingCellConfigCommon)
+ {
+ DU_LOG("DU APP: sib1Msg->servingCellConfigCommon memory allocation failure");
+ break;
+ }
+ ret1 = BuildServCellCfgCommonSib(sib1Msg->servingCellConfigCommon);
+ if(ret1 != ROK)
+ {
+ break;
+ }
- xer_fprint(stdout, &asn_DEF_SIB1, sib1Msg);
+ xer_fprint(stdout, &asn_DEF_SIB1, sib1Msg);
- /* Encode the F1SetupRequest type as APER */
- memset(encBuf, 0, ENC_BUF_MAX_LEN);
- encBufSize = 0;
- encRetVal = aper_encode(&asn_DEF_SIB1, 0, sib1Msg, PrepFinalEncBuf,\
- encBuf);
- printf("\nencbufSize: %d\n", encBufSize);
- if(encRetVal.encoded == -1)
- {
- DU_LOG("\nDU APP : Could not encode SIB1 structure (at %s)\n",\
- encRetVal.failed_type ?
- encRetVal.failed_type->name :
- "unknown");
- break;
- }
- for(int i=0; i< encBufSize; i++)
- {
- printf("%x\t",encBuf[i]);
- }
- printf("\n");
-
- ret = ROK;
- break;
+ /* Encode the F1SetupRequest type as APER */
+ memset(encBuf, 0, ENC_BUF_MAX_LEN);
+ encBufSize = 0;
+ encRetVal = aper_encode(&asn_DEF_SIB1, 0, sib1Msg, PrepFinalEncBuf,\
+ encBuf);
+ printf("\nencbufSize: %d\n", encBufSize);
+ if(encRetVal.encoded == -1)
+ {
+ DU_LOG("\nDU APP : Could not encode SIB1 structure (at %s)\n",\
+ encRetVal.failed_type ?
+ encRetVal.failed_type->name :
+ "unknown");
+ break;
+ }
+ for(int i=0; i< encBufSize; i++)
+ {
+ printf("%x\t",encBuf[i]);
+ }
+ printf("\n");
+
+ ret = ROK;
+ break;
}while(true);
- FreeSib1Msg(sib1Msg);
-
- return ret;
+ FreeSib1Msg(sib1Msg);
+
+ return ret;
+
-
}
/*******************************************************************
*
*******************************************************************/
void FreeFreqInfoDl(FrequencyInfoDL_SIB_t *frequencyInfoDL)
{
- uint8_t idx=0;
- uint8_t idx1=0;
-
- /* Free DL frequency info */
- if(!frequencyInfoDL->frequencyBandList.list.array)
- {
- /*Free Frequency band indicator */
- if(!frequencyInfoDL->frequencyBandList.list.array[idx])
- {
- if(!frequencyInfoDL->frequencyBandList.list.array[idx]->\
- freqBandIndicatorNR)
- {
- if(!frequencyInfoDL->scs_SpecificCarrierList.list.array)
- {
- for(idx1 = 0;idx1<frequencyInfoDL->scs_SpecificCarrierList.list.count;idx1++)
- {
- if(!frequencyInfoDL->scs_SpecificCarrierList.list.array[idx1])
- {
- DU_FREE(frequencyInfoDL->scs_SpecificCarrierList.list.\
- array[idx1], sizeof(SCS_SpecificCarrier_t));
- }
- }
- DU_FREE(frequencyInfoDL->scs_SpecificCarrierList.list.array,
- frequencyInfoDL->scs_SpecificCarrierList.list.size);
- }
- DU_FREE(frequencyInfoDL->frequencyBandList.list.\
- array[idx]->freqBandIndicatorNR, sizeof(FreqBandIndicatorNR_t));
- }
- }
- for(idx = 0; idx <frequencyInfoDL->frequencyBandList.list.count; idx++)
- {
- if(!frequencyInfoDL->frequencyBandList.list.array[idx])
- {
- DU_FREE(frequencyInfoDL->frequencyBandList.list.array[idx],\
- sizeof(NR_MultiBandInfo_t));
- }
- }
- DU_FREE(frequencyInfoDL->frequencyBandList.list.array,\
- frequencyInfoDL->frequencyBandList.list.size);
- }
+ uint8_t idx=0;
+ uint8_t idx1=0;
+
+ /* Free DL frequency info */
+ if(!frequencyInfoDL->frequencyBandList.list.array)
+ {
+ /*Free Frequency band indicator */
+ if(!frequencyInfoDL->frequencyBandList.list.array[idx])
+ {
+ if(!frequencyInfoDL->frequencyBandList.list.array[idx]->\
+ freqBandIndicatorNR)
+ {
+ if(!frequencyInfoDL->scs_SpecificCarrierList.list.array)
+ {
+ for(idx1 = 0;idx1<frequencyInfoDL->scs_SpecificCarrierList.list.count;idx1++)
+ {
+ if(!frequencyInfoDL->scs_SpecificCarrierList.list.array[idx1])
+ {
+ DU_FREE(frequencyInfoDL->scs_SpecificCarrierList.list.\
+ array[idx1], sizeof(SCS_SpecificCarrier_t));
+ }
+ }
+ DU_FREE(frequencyInfoDL->scs_SpecificCarrierList.list.array,
+ frequencyInfoDL->scs_SpecificCarrierList.list.size);
+ }
+ DU_FREE(frequencyInfoDL->frequencyBandList.list.\
+ array[idx]->freqBandIndicatorNR, sizeof(FreqBandIndicatorNR_t));
+ }
+ }
+ for(idx = 0; idx <frequencyInfoDL->frequencyBandList.list.count; idx++)
+ {
+ if(!frequencyInfoDL->frequencyBandList.list.array[idx])
+ {
+ DU_FREE(frequencyInfoDL->frequencyBandList.list.array[idx],\
+ sizeof(NR_MultiBandInfo_t));
+ }
+ }
+ DU_FREE(frequencyInfoDL->frequencyBandList.list.array,\
+ frequencyInfoDL->frequencyBandList.list.size);
+ }
}
/*******************************************************************
*
*
*******************************************************************/
void FreeCommonSerachSpaceList( struct PDCCH_ConfigCommon__commonSearchSpaceList
-*searchSpclist)
+ *searchSpclist)
{
- uint8_t idx=0;
- SearchSpace_t *searchSpace= NULLP;
-
- if(!searchSpclist->list.array)
- {
- if( searchSpclist->list.array[idx] != NULLP)
- {
- searchSpace= searchSpclist->list.array[idx];
- if(!searchSpace->controlResourceSetId)
- {
- if(!searchSpace->monitoringSlotPeriodicityAndOffset)
- {
- if(!searchSpace->monitoringSymbolsWithinSlot)
- {
- if(!searchSpace->monitoringSymbolsWithinSlot->buf)
- {
- if(!searchSpace->nrofCandidates)
- {
- if(!searchSpace->searchSpaceType)
- {
- switch(searchSpace->searchSpaceType->present)
- {
- case SearchSpace__searchSpaceType_PR_NOTHING:
- break;
- case SearchSpace__searchSpaceType_PR_common:
- {
- if(!searchSpace->searchSpaceType->choice.common)
- {
- if(!searchSpace->searchSpaceType->choice.\
- common->dci_Format0_0_AndFormat1_0)
- {
- DU_FREE(searchSpace->searchSpaceType->choice.\
- common->dci_Format0_0_AndFormat1_0,sizeof(struct\
- SearchSpace__searchSpaceType__common__dci_Format0_0_AndFormat1_0));
- }
- DU_FREE(searchSpace->searchSpaceType->choice.common,\
- sizeof(struct SearchSpace__searchSpaceType__common));
- }
- break;
- }
- case SearchSpace__searchSpaceType_PR_ue_Specific:
- break;
- default:
- break;
- }
- DU_FREE(searchSpace->searchSpaceType,\
- sizeof( struct SearchSpace__searchSpaceType));
- }
- DU_FREE(searchSpace->nrofCandidates,\
- sizeof(struct SearchSpace__nrofCandidates));
- }
- DU_FREE(searchSpace->monitoringSymbolsWithinSlot->buf,\
- searchSpace->monitoringSymbolsWithinSlot->size);
- }
- DU_FREE(searchSpace->monitoringSymbolsWithinSlot,\
- sizeof(BIT_STRING_t));
- }
- DU_FREE(searchSpace->monitoringSlotPeriodicityAndOffset,\
- sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
+ uint8_t idx=0;
+ SearchSpace_t *searchSpace= NULLP;
+
+ if(!searchSpclist->list.array)
+ {
+ if( searchSpclist->list.array[idx] != NULLP)
+ {
+ searchSpace= searchSpclist->list.array[idx];
+ if(!searchSpace->controlResourceSetId)
+ {
+ if(!searchSpace->monitoringSlotPeriodicityAndOffset)
+ {
+ if(!searchSpace->monitoringSymbolsWithinSlot)
+ {
+ if(!searchSpace->monitoringSymbolsWithinSlot->buf)
+ {
+ if(!searchSpace->nrofCandidates)
+ {
+ if(!searchSpace->searchSpaceType)
+ {
+ switch(searchSpace->searchSpaceType->present)
+ {
+ case SearchSpace__searchSpaceType_PR_NOTHING:
+ break;
+ case SearchSpace__searchSpaceType_PR_common:
+ {
+ if(!searchSpace->searchSpaceType->choice.common)
+ {
+ if(!searchSpace->searchSpaceType->choice.\
+ common->dci_Format0_0_AndFormat1_0)
+ {
+ DU_FREE(searchSpace->searchSpaceType->choice.\
+ common->dci_Format0_0_AndFormat1_0,sizeof(struct\
+ SearchSpace__searchSpaceType__common__dci_Format0_0_AndFormat1_0));
}
- DU_FREE(searchSpace->controlResourceSetId,sizeof(ControlResourceSetId_t));
- }
- }
- for(idx = 0; idx < searchSpclist->list.count; idx++)
- {
- if(!searchSpclist->list.array[idx])
- {
- DU_FREE(searchSpclist->list.array[idx], sizeof(SearchSpace_t));
+ DU_FREE(searchSpace->searchSpaceType->choice.common,\
+ sizeof(struct SearchSpace__searchSpaceType__common));
}
+ break;
+ }
+ case SearchSpace__searchSpaceType_PR_ue_Specific:
+ break;
+ default:
+ break;
+ }
+ DU_FREE(searchSpace->searchSpaceType,\
+ sizeof( struct SearchSpace__searchSpaceType));
+ }
+ DU_FREE(searchSpace->nrofCandidates,\
+ sizeof(struct SearchSpace__nrofCandidates));
+ }
+ DU_FREE(searchSpace->monitoringSymbolsWithinSlot->buf,\
+ searchSpace->monitoringSymbolsWithinSlot->size);
}
- DU_FREE(searchSpclist->list.array, searchSpclist->list.size)
+ DU_FREE(searchSpace->monitoringSymbolsWithinSlot,\
+ sizeof(BIT_STRING_t));
+ }
+ DU_FREE(searchSpace->monitoringSlotPeriodicityAndOffset,\
+ sizeof(struct SearchSpace__monitoringSlotPeriodicityAndOffset));
+ }
+ DU_FREE(searchSpace->controlResourceSetId,sizeof(ControlResourceSetId_t));
}
+ }
+ for(idx = 0; idx < searchSpclist->list.count; idx++)
+ {
+ if(!searchSpclist->list.array[idx])
+ {
+ DU_FREE(searchSpclist->list.array[idx], sizeof(SearchSpace_t));
+ }
+ }
+ DU_FREE(searchSpclist->list.array, searchSpclist->list.size)
+ }
}
/*******************************************************************
*
*******************************************************************/
void FreeBwpDlCommon(BWP_DownlinkCommon_t *bwp)
{
- uint8_t idx =0;
- struct BWP_DownlinkCommon__pdsch_ConfigCommon *pdschCfg=bwp->pdsch_ConfigCommon;
- struct BWP_DownlinkCommon__pdcch_ConfigCommon *pdcchCfg=bwp->pdcch_ConfigCommon;
- pdcchCfg->present=duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pdcchCfg.present;
- pdschCfg->present=duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pdschCfg.present;
+ uint8_t idx =0;
+ struct BWP_DownlinkCommon__pdsch_ConfigCommon *pdschCfg=bwp->pdsch_ConfigCommon;
+ struct BWP_DownlinkCommon__pdcch_ConfigCommon *pdcchCfg=bwp->pdcch_ConfigCommon;
+ pdcchCfg->present=duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pdcchCfg.present;
+ pdschCfg->present=duCfgParam.sib1Params.srvCellCfgCommSib.dlCfg.pdschCfg.present;
- if(!bwp->pdcch_ConfigCommon)
+ if(!bwp->pdcch_ConfigCommon)
+ {
+ if(!bwp->pdsch_ConfigCommon)
+ {
+ switch( pdschCfg->present)
{
- if(!bwp->pdsch_ConfigCommon)
+ case BWP_DownlinkCommon__pdsch_ConfigCommon_PR_NOTHING:
+ {
+ //TODO
+ break;
+ }
+ case BWP_DownlinkCommon__pdsch_ConfigCommon_PR_release:
+ {
+ //TODO
+ break;
+ }
+ case BWP_DownlinkCommon__pdsch_ConfigCommon_PR_setup:
+ {
+ if(!pdschCfg->choice.setup)
+ {
+ if(!pdschCfg->choice.setup->pdsch_TimeDomainAllocationList)
{
- switch( pdschCfg->present)
- {
- case BWP_DownlinkCommon__pdsch_ConfigCommon_PR_NOTHING:
- {
- //TODO
- break;
- }
- case BWP_DownlinkCommon__pdsch_ConfigCommon_PR_release:
- {
- //TODO
- break;
- }
- case BWP_DownlinkCommon__pdsch_ConfigCommon_PR_setup:
- {
- if(!pdschCfg->choice.setup)
- {
- if(!pdschCfg->choice.setup->pdsch_TimeDomainAllocationList)
- {
- if(!pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.array)
- {
- if(pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.array[idx]!= NULLP)
- {
- if(!pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.array[idx]->k0)
- {
- DU_FREE(pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.array[idx]->k0,\
- sizeof(long));
- }
- }
- for(idx=0; idx<pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.count ; idx++)
- {
- if(pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.array[idx]!=
- NULLP)
- {
- DU_FREE(pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.array[idx],\
- sizeof(PDSCH_TimeDomainResourceAllocation_t));
- }
- }
- DU_FREE(pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.array,\
- pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.size);
- }
- DU_FREE(pdschCfg->choice.setup->pdsch_TimeDomainAllocationList,\
- sizeof(PDSCH_TimeDomainResourceAllocationList_t));
- }
- DU_FREE(pdschCfg->choice.setup,
- sizeof(PDSCH_ConfigCommon_t));
- }
- }
- default:
- break;
- }
- DU_FREE(bwp->pdsch_ConfigCommon,\
- sizeof(struct BWP_DownlinkCommon__pdsch_ConfigCommon));
+ if(!pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.array)
+ {
+ if(pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.array[idx]!= NULLP)
+ {
+ if(!pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.array[idx]->k0)
+ {
+ DU_FREE(pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.array[idx]->k0,\
+ sizeof(long));
+ }
+ }
+ for(idx=0; idx<pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.count ; idx++)
+ {
+ if(pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.array[idx]!=
+ NULLP)
+ {
+ DU_FREE(pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.array[idx],\
+ sizeof(PDSCH_TimeDomainResourceAllocation_t));
+ }
+ }
+ DU_FREE(pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.array,\
+ pdschCfg->choice.setup->pdsch_TimeDomainAllocationList->list.size);
+ }
+ DU_FREE(pdschCfg->choice.setup->pdsch_TimeDomainAllocationList,\
+ sizeof(PDSCH_TimeDomainResourceAllocationList_t));
}
-
- switch(pdcchCfg->present)
+ DU_FREE(pdschCfg->choice.setup,
+ sizeof(PDSCH_ConfigCommon_t));
+ }
+ }
+ default:
+ break;
+ }
+ DU_FREE(bwp->pdsch_ConfigCommon,\
+ sizeof(struct BWP_DownlinkCommon__pdsch_ConfigCommon));
+ }
+
+ switch(pdcchCfg->present)
+ {
+ case BWP_DownlinkCommon__pdcch_ConfigCommon_PR_NOTHING:
+ {
+ //TODO
+ break;
+ }
+ case BWP_DownlinkCommon__pdcch_ConfigCommon_PR_release:
+ {
+ //TODO
+ break;
+ }
+ case BWP_DownlinkCommon__pdcch_ConfigCommon_PR_setup:
+ {
+ if(!pdcchCfg->choice.setup)
+ {
+ /* Control Resource Set Zero */
+ if(! pdcchCfg->choice.setup->controlResourceSetZero)
+ {
+ /* Search space zero */
+ if(! pdcchCfg->choice.setup->searchSpaceZero)
{
- case BWP_DownlinkCommon__pdcch_ConfigCommon_PR_NOTHING:
- {
- //TODO
- break;
- }
- case BWP_DownlinkCommon__pdcch_ConfigCommon_PR_release:
- {
- //TODO
- break;
- }
- case BWP_DownlinkCommon__pdcch_ConfigCommon_PR_setup:
+ /* Common Search Space List */
+ if(! pdcchCfg->choice.setup->commonSearchSpaceList)
+ {
+ if(CommonSerachSpaceListret==ROK)
+ {
+ if(!pdcchCfg->choice.setup->searchSpaceSIB1)
+ {
+ if(!pdcchCfg->choice.setup->pagingSearchSpace)
+ {
+ if(!pdcchCfg->choice.setup->ra_SearchSpace)
{
- if(!pdcchCfg->choice.setup)
- {
- /* Control Resource Set Zero */
- if(! pdcchCfg->choice.setup->controlResourceSetZero)
- {
- /* Search space zero */
- if(! pdcchCfg->choice.setup->searchSpaceZero)
- {
- /* Common Search Space List */
- if(! pdcchCfg->choice.setup->commonSearchSpaceList)
- {
- if(CommonSerachSpaceListret==ROK)
- {
- if(!pdcchCfg->choice.setup->searchSpaceSIB1)
- {
- if(!pdcchCfg->choice.setup->pagingSearchSpace)
- {
- if(!pdcchCfg->choice.setup->ra_SearchSpace)
- {
- DU_FREE(pdcchCfg->choice.setup->ra_SearchSpace,
- sizeof(SearchSpaceId_t));
- }
- DU_FREE( pdcchCfg->choice.setup->pagingSearchSpace,
- sizeof(SearchSpaceId_t));
- }
- DU_FREE( pdcchCfg->choice.setup->searchSpaceSIB1,
- sizeof(SearchSpaceId_t));
- }
- }
-
- FreeCommonSerachSpaceList(pdcchCfg->choice.setup->commonSearchSpaceList);
-
- DU_FREE( pdcchCfg->choice.setup->commonSearchSpaceList,\
- sizeof(struct
- PDCCH_ConfigCommon__commonSearchSpaceList));
- }
- DU_FREE( pdcchCfg->choice.setup->searchSpaceZero,
- sizeof(SearchSpaceZero_t));
- }
- DU_FREE( pdcchCfg->choice.setup->controlResourceSetZero,
- sizeof(ControlResourceSetZero_t));
- }
- DU_FREE(pdcchCfg->choice.setup,
- sizeof(PDCCH_ConfigCommon_t));
- }
- break;
+ DU_FREE(pdcchCfg->choice.setup->ra_SearchSpace,
+ sizeof(SearchSpaceId_t));
}
- default:
- break;
+ DU_FREE( pdcchCfg->choice.setup->pagingSearchSpace,
+ sizeof(SearchSpaceId_t));
+ }
+ DU_FREE( pdcchCfg->choice.setup->searchSpaceSIB1,
+ sizeof(SearchSpaceId_t));
+ }
+ }
+
+ FreeCommonSerachSpaceList(pdcchCfg->choice.setup->commonSearchSpaceList);
+
+ DU_FREE( pdcchCfg->choice.setup->commonSearchSpaceList,\
+ sizeof(struct
+ PDCCH_ConfigCommon__commonSearchSpaceList));
+ }
+ DU_FREE( pdcchCfg->choice.setup->searchSpaceZero,
+ sizeof(SearchSpaceZero_t));
}
- DU_FREE(bwp->pdcch_ConfigCommon,sizeof(struct BWP_DownlinkCommon__pdcch_ConfigCommon));
+ DU_FREE( pdcchCfg->choice.setup->controlResourceSetZero,
+ sizeof(ControlResourceSetZero_t));
+ }
+ DU_FREE(pdcchCfg->choice.setup,
+ sizeof(PDCCH_ConfigCommon_t));
+ }
+ break;
}
+ default:
+ break;
+ }
+ DU_FREE(bwp->pdcch_ConfigCommon,sizeof(struct BWP_DownlinkCommon__pdcch_ConfigCommon));
+ }
}
/*******************************************************************
*
*******************************************************************/
void FreeUlCfgCommSib(UplinkConfigCommonSIB_t *ulCfg)
{
- uint8_t idx=0;
- RACH_ConfigCommon_t *setup;
- BWP_UplinkCommon_t *bwp=&ulCfg->initialUplinkBWP;
- struct FrequencyInfoUL_SIB__scs_SpecificCarrierList *scsCarrierList;
- struct BWP_UplinkCommon__rach_ConfigCommon *rachCfg;
- struct BWP_UplinkCommon__pucch_ConfigCommon *pucchCfg;
- struct BWP_UplinkCommon__pusch_ConfigCommon *puschCfg;
- puschCfg=ulCfg->initialUplinkBWP.pusch_ConfigCommon;
- rachCfg =bwp->rach_ConfigCommon;
- scsCarrierList = &ulCfg->frequencyInfoUL.scs_SpecificCarrierList;
-
- if(!scsCarrierList->list.array)
+ uint8_t idx=0;
+ RACH_ConfigCommon_t *setup;
+ BWP_UplinkCommon_t *bwp=&ulCfg->initialUplinkBWP;
+ struct FrequencyInfoUL_SIB__scs_SpecificCarrierList *scsCarrierList;
+ struct BWP_UplinkCommon__rach_ConfigCommon *rachCfg;
+ struct BWP_UplinkCommon__pucch_ConfigCommon *pucchCfg;
+ struct BWP_UplinkCommon__pusch_ConfigCommon *puschCfg;
+ puschCfg=ulCfg->initialUplinkBWP.pusch_ConfigCommon;
+ rachCfg =bwp->rach_ConfigCommon;
+ scsCarrierList = &ulCfg->frequencyInfoUL.scs_SpecificCarrierList;
+
+ if(!scsCarrierList->list.array)
+ {
+ if(!ulCfg->frequencyInfoUL.p_Max)
+ {
+ if(FreqInfoUlret == ROK)
{
- if(!ulCfg->frequencyInfoUL.p_Max)
- {
- if(FreqInfoUlret == ROK)
+ if(!bwp->rach_ConfigCommon)
+ {
+ if(RachCfgCommonret== ROK)
+ {
+ if(!bwp->pusch_ConfigCommon)
+ {
+
+ if(PuschCfgCommonret==ROK)
+ {
+ if(!bwp->pucch_ConfigCommon)
+ {
+ pucchCfg=bwp->pucch_ConfigCommon;
+ switch(pucchCfg->present)
+ {
+ case BWP_UplinkCommon__pucch_ConfigCommon_PR_NOTHING:
+ break;
+ case BWP_UplinkCommon__pucch_ConfigCommon_PR_release:
+ break;
+ case BWP_UplinkCommon__pucch_ConfigCommon_PR_setup:
+ {
+ if(!pucchCfg->choice.setup)
+ {
+
+ if(!pucchCfg->choice.setup->pucch_ResourceCommon)
+ {
+ if(!pucchCfg->choice.setup->p0_nominal)
+ {
+ DU_FREE(pucchCfg->choice.setup->p0_nominal,
+ sizeof(long));
+ }
+ DU_FREE(pucchCfg->choice.setup->pucch_ResourceCommon,
+ sizeof(long));
+ }
+ DU_FREE(pucchCfg->choice.setup,
+ sizeof(PUCCH_ConfigCommon_t));
+ }
+ }
+ default:
+ break;
+ }
+ DU_FREE(bwp->pucch_ConfigCommon,\
+ sizeof(struct BWP_UplinkCommon__pucch_ConfigCommon));
+ }
+ }
+ switch(puschCfg->present)
+ {
+ case BWP_UplinkCommon__pusch_ConfigCommon_PR_NOTHING:
+ break;
+ case BWP_UplinkCommon__pusch_ConfigCommon_PR_release:
+ break;
+ case BWP_UplinkCommon__pusch_ConfigCommon_PR_setup:
+ {
+ if(!puschCfg->choice.setup)
+ {
+
+ if(! puschCfg->choice.setup->pusch_TimeDomainAllocationList)
+ {
+ if(! puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.array)
{
- if(!bwp->rach_ConfigCommon)
- {
- if(RachCfgCommonret== ROK)
- {
- if(!bwp->pusch_ConfigCommon)
- {
-
- if(PuschCfgCommonret==ROK)
- {
- if(!bwp->pucch_ConfigCommon)
- {
- pucchCfg=bwp->pucch_ConfigCommon;
- switch(pucchCfg->present)
- {
- case BWP_UplinkCommon__pucch_ConfigCommon_PR_NOTHING:
- break;
- case BWP_UplinkCommon__pucch_ConfigCommon_PR_release:
- break;
- case BWP_UplinkCommon__pucch_ConfigCommon_PR_setup:
- {
- if(!pucchCfg->choice.setup)
- {
-
- if(!pucchCfg->choice.setup->pucch_ResourceCommon)
- {
- if(!pucchCfg->choice.setup->p0_nominal)
- {
- DU_FREE(pucchCfg->choice.setup->p0_nominal,
- sizeof(long));
- }
- DU_FREE(pucchCfg->choice.setup->pucch_ResourceCommon,
- sizeof(long));
- }
- DU_FREE(pucchCfg->choice.setup,
- sizeof(PUCCH_ConfigCommon_t));
- }
- }
- default:
- break;
- }
- DU_FREE(bwp->pucch_ConfigCommon,\
- sizeof(struct
- BWP_UplinkCommon__pucch_ConfigCommon));
- }
- }
- switch(puschCfg->present)
- {
- case BWP_UplinkCommon__pusch_ConfigCommon_PR_NOTHING:
- break;
- case BWP_UplinkCommon__pusch_ConfigCommon_PR_release:
- break;
- case BWP_UplinkCommon__pusch_ConfigCommon_PR_setup:
- {
- if(!puschCfg->choice.setup)
- {
-
- if(! puschCfg->choice.setup->pusch_TimeDomainAllocationList)
- {
- if(! puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.array)
- {
- if(!puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.array[idx])
- {
- if(!puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.array[idx]->k2)
- {
- if(! puschCfg->choice.setup->msg3_DeltaPreamble)
- {
- if(!puschCfg->choice.setup->p0_NominalWithGrant)
- {
- DU_FREE(puschCfg->choice.setup->p0_NominalWithGrant,
- sizeof(long));
- }
- DU_FREE(puschCfg->choice.setup->msg3_DeltaPreamble,
- sizeof(long));
- }
- DU_FREE(puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.\
- array[idx]->k2, sizeof(long));
- }
- }
- for(idx=0;
- idx<puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.count;
- idx++)
- {
- if(!puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.array[idx])
- {
- DU_FREE(puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.array[idx],\
- sizeof(PUSCH_TimeDomainResourceAllocation_t));
- }
- }
- DU_FREE(puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.array,\
- puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.size);
- }
- DU_FREE(puschCfg->choice.setup->pusch_TimeDomainAllocationList,\
- sizeof(PUSCH_TimeDomainResourceAllocationList_t));
- }
- DU_FREE(puschCfg->choice.setup,
- sizeof(PUSCH_ConfigCommon_t));
- }
- }
- default :
- break;
- }
-
- DU_FREE(bwp->pusch_ConfigCommon,\
- sizeof(struct BWP_UplinkCommon__pusch_ConfigCommon));
- }
- }
- switch(rachCfg->present)
- {
- case BWP_UplinkCommon__rach_ConfigCommon_PR_NOTHING:
- break;
- case BWP_UplinkCommon__rach_ConfigCommon_PR_release:
- break;
- case BWP_UplinkCommon__rach_ConfigCommon_PR_setup:
- {
- if(!rachCfg->choice.setup)
- {
- setup = rachCfg->choice.setup;
- if(!setup->totalNumberOfRA_Preambles)
- {
- if(!setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB)
- {
- if(!setup->rsrp_ThresholdSSB)
- {
- if(!setup->msg1_SubcarrierSpacing)
- {
- DU_FREE(setup->msg1_SubcarrierSpacing,
- sizeof(SubcarrierSpacing_t));
- }
- DU_FREE(setup->rsrp_ThresholdSSB,
- sizeof(RSRP_Range_t));
- }
- DU_FREE(setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB,\
- sizeof(struct
- RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB));
- }
- DU_FREE(setup->totalNumberOfRA_Preambles,
- sizeof(long));
- }
-
- DU_FREE(rachCfg->choice.setup,
- sizeof(RACH_ConfigCommon_t));
- }
- }
- default:
- break;
- }
- DU_FREE(bwp->rach_ConfigCommon,\
- sizeof(struct BWP_UplinkCommon__rach_ConfigCommon));
- }
+ if(!puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.array[idx])
+ {
+ if(!puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.array[idx]->k2)
+ {
+ if(! puschCfg->choice.setup->msg3_DeltaPreamble)
+ {
+ if(!puschCfg->choice.setup->p0_NominalWithGrant)
+ {
+ DU_FREE(puschCfg->choice.setup->p0_NominalWithGrant,
+ sizeof(long));
+ }
+ DU_FREE(puschCfg->choice.setup->msg3_DeltaPreamble,
+ sizeof(long));
+ }
+ DU_FREE(puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.\
+ array[idx]->k2, sizeof(long));
+ }
+ }
+ for(idx=0;
+ idx<puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.count;
+ idx++)
+ {
+ if(!puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.array[idx])
+ {
+ DU_FREE(puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.array[idx],\
+ sizeof(PUSCH_TimeDomainResourceAllocation_t));
+ }
+ }
+ DU_FREE(puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.array,\
+ puschCfg->choice.setup->pusch_TimeDomainAllocationList->list.size);
}
- DU_FREE(ulCfg->frequencyInfoUL.p_Max, sizeof(P_Max_t));
- }
- for(idx = 0; idx < scsCarrierList->list.count; idx++)
+ DU_FREE(puschCfg->choice.setup->pusch_TimeDomainAllocationList,\
+ sizeof(PUSCH_TimeDomainResourceAllocationList_t));
+ }
+ DU_FREE(puschCfg->choice.setup,
+ sizeof(PUSCH_ConfigCommon_t));
+ }
+ }
+ default :
+ break;
+ }
+
+ DU_FREE(bwp->pusch_ConfigCommon,\
+ sizeof(struct BWP_UplinkCommon__pusch_ConfigCommon));
+ }
+ }
+ switch(rachCfg->present)
+ {
+ case BWP_UplinkCommon__rach_ConfigCommon_PR_NOTHING:
+ break;
+ case BWP_UplinkCommon__rach_ConfigCommon_PR_release:
+ break;
+ case BWP_UplinkCommon__rach_ConfigCommon_PR_setup:
+ {
+ if(!rachCfg->choice.setup)
+ {
+ setup = rachCfg->choice.setup;
+ if(!setup->totalNumberOfRA_Preambles)
{
- if(!scsCarrierList->list.array[idx])
+ if(!setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB)
+ {
+ if(!setup->rsrp_ThresholdSSB)
+ {
+ if(!setup->msg1_SubcarrierSpacing)
{
- DU_FREE(scsCarrierList->list.array[idx],
- sizeof(SCS_SpecificCarrier_t));
+ DU_FREE(setup->msg1_SubcarrierSpacing,
+ sizeof(SubcarrierSpacing_t));
}
+ DU_FREE(setup->rsrp_ThresholdSSB,
+ sizeof(RSRP_Range_t));
+ }
+ DU_FREE(setup->ssb_perRACH_OccasionAndCB_PreamblesPerSSB,\
+ sizeof(struct
+ RACH_ConfigCommon__ssb_perRACH_OccasionAndCB_PreamblesPerSSB));
+ }
+ DU_FREE(setup->totalNumberOfRA_Preambles,
+ sizeof(long));
}
- DU_FREE(scsCarrierList->list.array, scsCarrierList->list.size);
+
+ DU_FREE(rachCfg->choice.setup,
+ sizeof(RACH_ConfigCommon_t));
+ }
+ }
+ default:
+ break;
+ }
+ DU_FREE(bwp->rach_ConfigCommon,\
+ sizeof(struct BWP_UplinkCommon__rach_ConfigCommon));
+ }
+ }
+ DU_FREE(ulCfg->frequencyInfoUL.p_Max, sizeof(P_Max_t));
+ }
+ for(idx = 0; idx < scsCarrierList->list.count; idx++)
+ {
+ if(!scsCarrierList->list.array[idx])
+ {
+ DU_FREE(scsCarrierList->list.array[idx],
+ sizeof(SCS_SpecificCarrier_t));
}
+ }
+ DU_FREE(scsCarrierList->list.array, scsCarrierList->list.size);
+ }
}
/*******************************************************************
*
*******************************************************************/
void FreeServCellCfgCommonSib(ServingCellConfigCommonSIB_t *srvCellCfg)
{
- BIT_STRING_t *ssbPosInBurst;
- ssbPosInBurst = &srvCellCfg->ssb_PositionsInBurst.inOneGroup;
- DownlinkConfigCommonSIB_t *dlCfg=&srvCellCfg->downlinkConfigCommon;
-
- if(!ssbPosInBurst->buf)
- {
- /* Free DL frequency info */
- if(FreqInfoDlret == ROK)
- {
- if(DlCfgCommSibret == ROK)
- {
- /* Uplink Config Comm */
- if(!srvCellCfg->uplinkConfigCommon)
- {
- if(UlCfgCommSibret==ROK)
- {
- /* TDD UL DL Config Comm */
- if(!srvCellCfg->tdd_UL_DL_ConfigurationCommon)
- {
- DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationCommon,
- sizeof(TDD_UL_DL_ConfigCommon_t));
- }
- }
- FreeUlCfgCommSib(srvCellCfg->uplinkConfigCommon);
- DU_FREE(srvCellCfg->uplinkConfigCommon,
- sizeof(UplinkConfigCommonSIB_t));
- }
- }
- FreeBwpDlCommon(&dlCfg->initialDownlinkBWP);
- }
- FreeFreqInfoDl(&dlCfg->frequencyInfoDL);
- DU_FREE(ssbPosInBurst->buf, ssbPosInBurst->size * sizeof(uint8_t));
- }
+ BIT_STRING_t *ssbPosInBurst;
+ ssbPosInBurst = &srvCellCfg->ssb_PositionsInBurst.inOneGroup;
+ DownlinkConfigCommonSIB_t *dlCfg=&srvCellCfg->downlinkConfigCommon;
+
+ if(!ssbPosInBurst->buf)
+ {
+ /* Free DL frequency info */
+ if(FreqInfoDlret == ROK)
+ {
+ if(DlCfgCommSibret == ROK)
+ {
+ /* Uplink Config Comm */
+ if(!srvCellCfg->uplinkConfigCommon)
+ {
+ if(UlCfgCommSibret==ROK)
+ {
+ /* TDD UL DL Config Comm */
+ if(!srvCellCfg->tdd_UL_DL_ConfigurationCommon)
+ {
+ DU_FREE(srvCellCfg->tdd_UL_DL_ConfigurationCommon,
+ sizeof(TDD_UL_DL_ConfigCommon_t));
+ }
+ }
+ FreeUlCfgCommSib(srvCellCfg->uplinkConfigCommon);
+ DU_FREE(srvCellCfg->uplinkConfigCommon,
+ sizeof(UplinkConfigCommonSIB_t));
+ }
+ }
+ FreeBwpDlCommon(&dlCfg->initialDownlinkBWP);
+ }
+ FreeFreqInfoDl(&dlCfg->frequencyInfoDL);
+ DU_FREE(ssbPosInBurst->buf, ssbPosInBurst->size * sizeof(uint8_t));
+ }
}
/*******************************************************************
*
*******************************************************************/
void FreeSib1Msg(SIB1_t *sib1Msg)
{
- uint8_t idx=0;
+ uint8_t idx=0;
uint8_t idx1=0;
- uint8_t idx2=0;
+ uint8_t idx2=0;
CellIdentity_t *cellIdentity = NULLP;
- CellAccessRelatedInfo_t *cellAccessInfo ;
- struct PLMN_IdentityInfo__plmn_IdentityList *plmnIdInfo;
-
-
- if(sib1Msg != NULLP)
- {
- cellAccessInfo = &sib1Msg->cellAccessRelatedInfo;
- if(cellAccessInfo->plmn_IdentityList.list.array !=NULLP)
- {
- if(cellAccessInfo->plmn_IdentityList.list.array[idx]!=NULLP)
- {
- plmnIdInfo =
- &cellAccessInfo->plmn_IdentityList.list.array[idx]->plmn_IdentityList;
-
- if(plmnIdInfo->list.array !=NULLP)
- {
- if(!plmnIdInfo->list.array[idx])
- {
- if(!plmnIdInfo->list.array[idx]->mcc)
- {
- if(!(plmnIdInfo->list.array[idx]->mcc->list.array))
- {
- if(!plmnIdInfo->list.array[idx]->mnc.list.array)
- {
- /*Free Tracking Area Code */
- if(!cellAccessInfo->plmn_IdentityList.list.array[idx]->trackingAreaCode)
- {
- /*Free RANAC */
- if(!cellAccessInfo->plmn_IdentityList.list.array[idx]->trackingAreaCode->buf)
- {
- /* Free CellIdentity */
- if(!cellAccessInfo->plmn_IdentityList.list.array[idx]->ranac)
- {
- cellIdentity
- =&cellAccessInfo->plmn_IdentityList.\
- list.array[idx]->cellIdentity;
- if(!cellIdentity->buf)
- {
- /*Free Connection Establish Failure Control */
- if(!sib1Msg->connEstFailureControl)
- {
- /*Free Serving Cell Config Common */
- if(!sib1Msg->si_SchedulingInfo)
- {
- /* Free Serving Cell Config Common* */
- if(!sib1Msg->servingCellConfigCommon)
- {
- /*Free BuildServCellCfgCommonSib*/
- FreeServCellCfgCommonSib(\
- sib1Msg->servingCellConfigCommon);
-
- DU_FREE(sib1Msg->servingCellConfigCommon,
- sizeof(ServingCellConfigCommonSIB_t));
- }
-
- DU_FREE(sib1Msg->si_SchedulingInfo,
- sizeof(SI_SchedulingInfo_t));
- }
-
- DU_FREE(sib1Msg->connEstFailureControl,
- sizeof(ConnEstFailureControl_t));
- }
- DU_FREE(cellIdentity->buf,cellIdentity->size);
-
- }
- DU_FREE(cellAccessInfo->plmn_IdentityList.list.array[idx]->ranac, sizeof(RAN_AreaCode_t));
-
- }
- DU_FREE(cellAccessInfo->plmn_IdentityList.list.array[idx]->trackingAreaCode->buf,\
- cellAccessInfo->plmn_IdentityList.list.array[idx]->trackingAreaCode->size);
-
- }
- DU_FREE(cellAccessInfo->plmn_IdentityList.list.array[idx]->trackingAreaCode\
- , sizeof(TrackingAreaCode_t));
- }
-
- for(idx2=0; idx2<plmnIdInfo->list.array[idx1]->mnc.list.count; idx2++)
- {
- if(!plmnIdInfo->list.array[idx2]->mnc.list.array[idx2])
- {
- DU_FREE(plmnIdInfo->list.array[idx2]->mnc.list.array[idx2],
- sizeof(MCC_MNC_Digit_t));
- }
- }
- DU_FREE(plmnIdInfo->list.array[idx]->mnc.list.array,
- plmnIdInfo->list.array[idx1]->mnc.list.size);
- }
-
- for(idx1=0; idx1<plmnIdInfo->list.array[idx]->mcc->list.count; idx1++)
- {
- if(plmnIdInfo->list.array[idx]->mcc->list.array[idx1]!=NULLP)
- {
- DU_FREE(plmnIdInfo->list.array[idx]->mcc->list.array[idx1],\
- sizeof(MCC_MNC_Digit_t));
- }
-
- }
- DU_FREE(plmnIdInfo->list.array[idx]->mcc->list.array,\
- plmnIdInfo->list.array[idx]->mcc->list.size)
- }
- DU_FREE(plmnIdInfo->list.array[idx]->mcc,sizeof(MCC_t));
- }
- }
- for(idx1=0; idx1<plmnIdInfo->list.count; idx1++)
- {
- if(!(plmnIdInfo->list.array[idx1]))
- {
- DU_FREE(plmnIdInfo->list.array[idx1],
- sizeof(PLMN_IdentitY_t));
- }
- }
- DU_FREE(plmnIdInfo->list.array, plmnIdInfo->list.size);
+ CellAccessRelatedInfo_t *cellAccessInfo ;
+ struct PLMN_IdentityInfo__plmn_IdentityList *plmnIdInfo;
+
+
+ if(sib1Msg != NULLP)
+ {
+ cellAccessInfo = &sib1Msg->cellAccessRelatedInfo;
+ if(cellAccessInfo->plmn_IdentityList.list.array !=NULLP)
+ {
+ if(cellAccessInfo->plmn_IdentityList.list.array[idx]!=NULLP)
+ {
+ plmnIdInfo =
+ &cellAccessInfo->plmn_IdentityList.list.array[idx]->plmn_IdentityList;
+
+ if(plmnIdInfo->list.array !=NULLP)
+ {
+ if(!plmnIdInfo->list.array[idx])
+ {
+ if(!plmnIdInfo->list.array[idx]->mcc)
+ {
+ if(!(plmnIdInfo->list.array[idx]->mcc->list.array))
+ {
+ if(!plmnIdInfo->list.array[idx]->mnc.list.array)
+ {
+ /*Free Tracking Area Code */
+ if(!cellAccessInfo->plmn_IdentityList.list.array[idx]->trackingAreaCode)
+ {
+ /*Free RANAC */
+ if(!cellAccessInfo->plmn_IdentityList.list.array[idx]->trackingAreaCode->buf)
+ {
+ /* Free CellIdentity */
+ if(!cellAccessInfo->plmn_IdentityList.list.array[idx]->ranac)
+ {
+ cellIdentity
+ =&cellAccessInfo->plmn_IdentityList.\
+ list.array[idx]->cellIdentity;
+ if(!cellIdentity->buf)
+ {
+ /*Free Connection Establish Failure Control */
+ if(!sib1Msg->connEstFailureControl)
+ {
+ /*Free Serving Cell Config Common */
+ if(!sib1Msg->si_SchedulingInfo)
+ {
+ /* Free Serving Cell Config Common* */
+ if(!sib1Msg->servingCellConfigCommon)
+ {
+ /*Free BuildServCellCfgCommonSib*/
+ FreeServCellCfgCommonSib(\
+ sib1Msg->servingCellConfigCommon);
+
+ DU_FREE(sib1Msg->servingCellConfigCommon,
+ sizeof(ServingCellConfigCommonSIB_t));
+ }
+
+ DU_FREE(sib1Msg->si_SchedulingInfo,
+ sizeof(SI_SchedulingInfo_t));
+ }
+
+ DU_FREE(sib1Msg->connEstFailureControl,
+ sizeof(ConnEstFailureControl_t));
+ }
+ DU_FREE(cellIdentity->buf,cellIdentity->size);
+
+ }
+ DU_FREE(cellAccessInfo->plmn_IdentityList.list.array[idx]->ranac, sizeof(RAN_AreaCode_t));
+
+ }
+ DU_FREE(cellAccessInfo->plmn_IdentityList.list.array[idx]->trackingAreaCode->buf,\
+ cellAccessInfo->plmn_IdentityList.list.array[idx]->trackingAreaCode->size);
+
}
- }
- for(idx=0; idx<cellAccessInfo->plmn_IdentityList.list.count; idx++)
- {
- if(cellAccessInfo->plmn_IdentityList.list.array[idx]!=NULLP)
- {
- DU_FREE(cellAccessInfo->plmn_IdentityList.list.array[idx],
- sizeof(PLMN_IdentityInfo_t));
- }
- }
- DU_FREE(cellAccessInfo->plmn_IdentityList.list.array,
- cellAccessInfo->plmn_IdentityList.list.size);
- }
- DU_FREE(sib1Msg, sizeof(SIB1_t));
- }
+ DU_FREE(cellAccessInfo->plmn_IdentityList.list.array[idx]->trackingAreaCode\
+ , sizeof(TrackingAreaCode_t));
+ }
+
+ for(idx2=0; idx2<plmnIdInfo->list.array[idx1]->mnc.list.count; idx2++)
+ {
+ if(!plmnIdInfo->list.array[idx2]->mnc.list.array[idx2])
+ {
+ DU_FREE(plmnIdInfo->list.array[idx2]->mnc.list.array[idx2],
+ sizeof(MCC_MNC_Digit_t));
+ }
+ }
+ DU_FREE(plmnIdInfo->list.array[idx]->mnc.list.array,
+ plmnIdInfo->list.array[idx1]->mnc.list.size);
+ }
+
+ for(idx1=0; idx1<plmnIdInfo->list.array[idx]->mcc->list.count; idx1++)
+ {
+ if(plmnIdInfo->list.array[idx]->mcc->list.array[idx1]!=NULLP)
+ {
+ DU_FREE(plmnIdInfo->list.array[idx]->mcc->list.array[idx1],\
+ sizeof(MCC_MNC_Digit_t));
+ }
+
+ }
+ DU_FREE(plmnIdInfo->list.array[idx]->mcc->list.array,\
+ plmnIdInfo->list.array[idx]->mcc->list.size)
+ }
+ DU_FREE(plmnIdInfo->list.array[idx]->mcc,sizeof(MCC_t));
+ }
+ }
+ for(idx1=0; idx1<plmnIdInfo->list.count; idx1++)
+ {
+ if(!(plmnIdInfo->list.array[idx1]))
+ {
+ DU_FREE(plmnIdInfo->list.array[idx1],
+ sizeof(PLMN_IdentitY_t));
+ }
+ }
+ DU_FREE(plmnIdInfo->list.array, plmnIdInfo->list.size);
+ }
+ }
+ for(idx=0; idx<cellAccessInfo->plmn_IdentityList.list.count; idx++)
+ {
+ if(cellAccessInfo->plmn_IdentityList.list.array[idx]!=NULLP)
+ {
+ DU_FREE(cellAccessInfo->plmn_IdentityList.list.array[idx],
+ sizeof(PLMN_IdentityInfo_t));
+ }
+ }
+ DU_FREE(cellAccessInfo->plmn_IdentityList.list.array,
+ cellAccessInfo->plmn_IdentityList.list.size);
+ }
+ DU_FREE(sib1Msg, sizeof(SIB1_t));
+ }
}
#include "du_ue_mgr.h"
#ifdef EGTP_TEST
-U32 sduId = 0;
+uint32_t sduId = 0;
#endif
DuMacDlCcchInd packMacDlCcchIndOpts[] =
uint8_t duBuildAndSendDlCcchInd(uint16_t *cellId, uint16_t *crnti, \
DlCcchMsgType msgType, uint16_t dlCcchMsgSize, uint8_t *dlCcchMsg)
{
- uint8_t ret = ROK;
+ uint8_t ret = ROK;
uint16_t idx2;
DlCcchIndInfo *dlCcchIndInfo = NULLP;
Pst pst;
uint8_t duBuildAndSendDlRrcMsgToRlc(uint16_t cellId, RlcUeCfg ueCfg, \
uint8_t lcId, bool execDup, bool deliveryStaReq, uint16_t rrcMsgLen, uint8_t *rrcMsg)
{
- Pst pst;
+ Pst pst;
uint8_t ret;
uint8_t lcIdx;
RlcDlRrcMsgInfo *dlRrcMsgInfo;
uint8_t duBuildAndSendUeCreateReqToMac(uint16_t cellId, uint8_t ueIdx,\
uint16_t crnti, MacUeCfg *duMacUeCfg)
{
- uint8_t ret = ROK;
- Pst pst;
+ uint8_t ret = ROK;
MacUeCfg *macUeCfg = NULLP;
+ Pst pst;
+ memset(&pst, 0, sizeof(Pst));
+
ret = fillMacUeCfg(cellId, ueIdx, crnti, NULL, duMacUeCfg);
if(ret == RFAILED)
uint8_t duBuildAndSendUeCreateReqToRlc(uint16_t cellId, uint8_t ueIdx,\
RlcUeCfg *duRlcUeCfg)
{
- uint8_t ret = ROK;
+ uint8_t ret = ROK;
RlcUeCfg *rlcUeCfg = NULLP;
- Pst pst;
+ Pst pst;
ret = fillRlcUeCfg(cellId, ueIdx, NULL, duRlcUeCfg);
if(ret == RFAILED)
sa.sa_handler = SIG_DFL;
sigaction(SIGILL, &sa, NULL);
- RETVOID;
+ return;
}
static void signal_segv(int signum, siginfo_t * info, void *ptr)
{
Buffer *mtTskBuffer2;
EXTERN pthread_t tmpRegTidMap[20];
-EXTERN U8 stopBtInfo;
+EXTERN uint8_t stopBtInfo;
EXTERN S16 SGlobMemInfoShow(void);
#endif /* SS_LOCKLESS_MEMORY */
\f
#ifdef SS_MULTICORE_SUPPORT
PRIVATE SsSTskEntry* ssdAddTmrSTsk(Void);
-PRIVATE SsSTskEntry* ssdReAddTmrSTsk ARGS((U8 idx));
+PRIVATE SsSTskEntry* ssdReAddTmrSTsk ARGS((uint8_t idx));
#ifndef SS_LOCKLESS_MEMORY
#ifndef RGL_SPECIFIC_CHANGES
PRIVATE S16 ssdInitMemInfo ARGS((void));
#ifdef SS_DRVR_SUPPORT
typedef struct mtIsFlag
{
- U16 id;
- U8 action;
+ uint16_t id;
+ uint8_t action;
} MtIsFlag;
#endif
#ifdef INTEL_WLS
typedef struct _MtRegMemSz
{
- U32 reqdSz;
- U8 *startAddr;
+ uint32_t reqdSz;
+ uint8_t *startAddr;
}MtRegMemSz;
PRIVATE MtRegMemSz mtRegMemSz[MT_MAX_BKTS+1];
sem_destroy(&osCp.dep.ssStarted);
- RETVOID;
+ return;
}
#ifdef SS_LOCKLESS_MEMORY
#ifdef USE_MALLOC
#ifdef ANSI
S16 ssPutDynMemBlkSet
(
-U8 bktIdx, /* Index to bucket list */
+uint8_t bktIdx, /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem /* Memory set element which is needs to be
added to global region */
)
#else
S16 ssPutDynMemBlkSet(bktIdx, dynMemSetElem)
-U8 bktIdx; /* Index to bucket list */
+uint8_t bktIdx; /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem; /* Memory set element which is needs to be
added to global region */
#endif
CmMmGlobRegCb *globReg;
CmMmGlobalBktCb *bktCb;
Data *blkPtr;
- U8 blkCnt;
+ uint8_t blkCnt;
globReg = osCp.globRegCb;
#ifdef ANSI
S16 ssGetDynMemBlkSet
(
-U8 bktIdx, /* Index to bucket list */
+uint8_t bktIdx, /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem /* Memory set element which is updated
with new set values */
)
#else
S16 ssGetDynMemBlkSet(bktIdx, dynMemSetElem)
-U8 bktIdx; /* Index to bucket list */
+uint8_t bktIdx; /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem; /* Memory set element which is updated
with new set values */
#endif
CmMmGlobalBktCb *bktCb;
Data **basePtr;
Data *blkPtr;
- U8 blkCnt;
+ uint8_t blkCnt;
globReg = osCp.globRegCb;
#ifdef ANSI
S16 ssPutDynMemBlkSet
(
-U8 bktIdx, /* Index to bucket list */
+uint8_t bktIdx, /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem, /* Memory set element which is needs to be
added to global region */
-U32 doNotBlockForLock /* Boolean whether to block for lock or not */
+uint32_t doNotBlockForLock /* Boolean whether to block for lock or not */
)
#else
S16 ssPutDynMemBlkSet(bktIdx, dynMemSetElem)
-U8 bktIdx; /* Index to bucket list */
+uint8_t bktIdx; /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem; /* Memory set element which is needs to be
added to global region */
-U32 doNotBlockForLock; /* Boolean whether to block for lock or not */
+uint32_t doNotBlockForLock; /* Boolean whether to block for lock or not */
#endif
{
CmMmGlobRegCb *globReg;
#ifdef ANSI
S16 ssGetDynMemBlkSet
(
-U8 bktIdx, /* Index to bucket list */
+uint8_t bktIdx, /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem, /* Memory set element which is updated
with new set values */
-U32 doNotBlockForLock /* Boolean whether to block for lock or not */
+uint32_t doNotBlockForLock /* Boolean whether to block for lock or not */
)
#else
S16 ssGetDynMemBlkSet(bktIdx, dynMemSetElem)
-U8 bktIdx; /* Index to bucket list */
+uint8_t bktIdx; /* Index to bucket list */
CmMmBlkSetElement *dynMemSetElem; /* Memory set element which is updated
with new set values */
-U32 doNotBlockForLock; /* Boolean whether to block for lock or not */
+uint32_t doNotBlockForLock; /* Boolean whether to block for lock or not */
#endif
{
CmMmGlobRegCb *globReg;
#define NUM_CALLS_TO_CHECK_MEM_DYN_AGAIN 100
-U32 gDynMemAlrm[4];
-PRIVATE U32 memoryCheckCounter;
+uint32_t gDynMemAlrm[4];
+PRIVATE uint32_t memoryCheckCounter;
#ifdef ANSI
-U32 isMemThreshReached(
+uint32_t isMemThreshReached(
Region reg
)
#else
-U32 isMemThreshReached(reg)
+uint32_t isMemThreshReached(reg)
Region reg;
#endif
{
CmMmGlobRegCb *globReg;
CmMmGlobalBktCb *bktCb;
- U8 bktIdx= reg;
+ uint8_t bktIdx= reg;
globReg = osCp.globRegCb;
S16 SPartitionWlsMemory()
{
- U32 i;
+ uint32_t i;
#ifndef ALIGN_64BIT
- U64 reqdSz;
- U64 pageSize[1], hugePageSize;
+ uint64_t reqdSz;
+ uint64_t pageSize[1], hugePageSize;
#else
long int reqdSz;
long int pageSize[1], hugePageSize;
#endif
- U32 numHugePg;
+ uint32_t numHugePg;
#define DIV_ROUND_OFFSET(X,Y) ( X/Y + ((X%Y)?1:0) )
- U8 *regMemStrtAddr = (U8 *)osCp.wls.allocAddr;
+ uint8_t *regMemStrtAddr = (uint8_t *)osCp.wls.allocAddr;
gethugepagesizes(pageSize,1);
hugePageSize = pageSize[0];
regMemStrtAddr += reqdSz;
#ifdef T2K_MEM_LEAK_DBG
/* Since wls is region 0 */
- regMemLeakInfo.regStartAddr[i] = (U64)mtRegMemSz[i].startAddr;
+ regMemLeakInfo.regStartAddr[i] = (uint64_t)mtRegMemSz[i].startAddr;
regMemLeakInfo.numActvRegions++;
#endif /* T2K_MEM_LEAK_DBG */
}
}
#endif /* SS_MEM_WL_DEBUG */
-S16 SPartitionStaticMemory(U8 *startAddr)
+S16 SPartitionStaticMemory(uint8_t *startAddr)
{
int i;
- U32 reqdSz;
+ uint32_t reqdSz;
- U8 *regMemStrtAddr = (U8 *)startAddr;
+ uint8_t *regMemStrtAddr = (uint8_t *)startAddr;
//for (i = 0; i < mtMemoCfg.numRegions; i++)
regMemStrtAddr += reqdSz;
#ifdef T2K_MEM_LEAK_DBG
{ /* Since region 1 onwards are used for non wls */
- regMemLeakInfo.regStartAddr[i] = (U64)mtRegMemSz[i].startAddr;
+ regMemLeakInfo.regStartAddr[i] = (uint64_t)mtRegMemSz[i].startAddr;
regMemLeakInfo.numActvRegions++;
}
#endif /* T2K_MEM_LEAK_DBG */
S16 SAllocateWlsMem()
{
- U32 reqdMemSz;
- U32 i, j;
+ uint32_t reqdMemSz;
+ uint32_t i, j;
MtRegCfg *region;
reqdMemSz = 0;
S16 SAllocateStaticMem()
{
- U32 reqdMemSz;
+ uint32_t reqdMemSz;
int i, j;
MtRegCfg *region;
- U8 *startAddr;
+ uint8_t *startAddr;
reqdMemSz = 0;
//memset(&mtRegMemSz[0], sizeof(mtRegMemSz), 0);
#endif
{
/* mt018.201 - added local variable */
- U8 i;
- U16 j;
- U8 k;
+ uint8_t i;
+ uint16_t j;
+ uint8_t k;
MtRegCfg *region;
Txt errMsg[256] = {'\0'};
#ifdef SS_LOCKLESS_MEMORY
#endif /* SS_LOCKLESS_MEMORY */
#ifdef T2K_MEM_LEAK_DBG
- U8 reg;
+ uint8_t reg;
/* Initailize mem leak tool memorys for debguing */
regMemLeakInfo.numActvRegions=0;
for(reg=0; reg <SS_MAX_REGS; reg++)
#endif
{
/* mt018.201 - added local variables */
- U8 i;
+ uint8_t i;
/* mt008.301 Additions */
#ifdef SS_MEM_LEAK_STS
free(mtCMMRegCfg[i]);
}
- RETVOID;
+ return;
}
\f
/* mt001.301 : Additions */
/*mt013.301 :Added SS_AFFINITY_SUPPORT */
#if defined(SS_MULTICORE_SUPPORT) ||defined(SS_AFFINITY_SUPPORT)
- U32 tskInd = 0;
+ uint32_t tskInd = 0;
#endif /* SS_MULTICORE_SUPPORT || SS_AFFINITY_SUPPORT */
#endif
{
- RETVOID;
+ return;
}
\f
}
#endif
- RETVOID;
+ return;
}
#endif /* SS_DRVR_SUPPORT */
SsSTskEntry *sTsk;
#endif /* SS_MULTICORE_SUPPORT */
#ifdef SS_THR_REG_MAP
- U32 threadCreated = FALSE;
+ uint32_t threadCreated = FALSE;
#endif /* SS_THR_REG_MAP */
MTLOGERROR(ERRCLS_DEBUG, EMT008, (ErrVal) ret,
"Could not lock system task table");
#endif
- RETVOID;
+ return;
}
sTsk = &osCp.sTskTbl[0]; /* first entry is timer entry always */
/* clean up the system task entry */
#endif /* SS_MULTICORE_SUPPORT */
/* mt008.301: Terminate the timer thread on exit */
while(pthread_cancel(osCp.dep.tmrHdlrTID));
- RETVOID;
+ return;
}
#endif /* CONRD */
#endif /* CONVAL */
- RETVOID;
+ return;
}
/* mt001.301 : Additions */
#ifdef SS_WATCHDOG
#ifdef ANSI
S16 ssdInitWatchDog
(
-U16 port
+uint16_t port
)
#else
S16 ssdInitWatchDog(port)
-U16 port;
+uint16_t port;
#endif
{
- U8 idx;
+ uint8_t idx;
Txt prntBuf[PRNTSZE];
Pst pst;
Buffer *mBuf;
ssdInitWatchDgPst(&(osCp.wdCp.watchDgPst));
/* Initialize the watch dog timer resolution default is 1 sec */
- cmInitTimers(osCp.wdCp.watchDgTmr, (U8)1);
+ cmInitTimers(osCp.wdCp.watchDgTmr, (uint8_t)1);
osCp.wdCp.watchDgTqCp.nxtEnt = 0;
osCp.wdCp.watchDgTqCp.tmrLen = 1;
for(idx = 0; idx < 1; idx++)
(
void *cb,
S16 event,
-U16 wait
+uint16_t wait
)
#else
Void ssdStartWatchDgTmr(cb, event, wait)
void *cb;
S16 event;
-U16 wait;
+uint16_t wait;
#endif
{
CmTmrArg arg;
arg.max = 1;
cmPlcCbTq(&arg);
- RETVOID;
+ return;
}
#ifdef ANSI
arg.max = 1;
cmRmvCbTq(&arg);
- RETVOID;
+ return;
}
#ifdef ANSI
S16 ssdSndHrtBtMsg
(
Bool restart,
-U32 type
+uint32_t type
)
#else
S16 ssdSndHrtBtMsg(restart, type)
Bool restart;
-U32 type;
+uint32_t type;
#endif
{
S16 ret = ROK;
#ifndef NOFILESYS
FILE *memOpt; /* memory options file pointer */
Txt pBuf[128];
- U8 i;
+ uint8_t i;
/* mt007.301 : Fix related to file based mem config on 64 bit machine */
PTR numReg;
PTR numBkts;
msOptInd = 1;
- RETVOID;
+ return;
}
#endif
}
- RETVOID;
+ return;
}
\f
/* struct sched_param param_sched;*/
#ifdef SS_THR_REG_MAP
- U32 threadCreated = FALSE;
+ uint32_t threadCreated = FALSE;
#endif
/*mt013.301 :Added SS_AFFINITY_SUPPORT */
#if defined(SS_MULTICORE_SUPPORT) ||defined(SS_AFFINITY_SUPPORT)
{
- static U32 stLwpId = 3;
+ static uint32_t stLwpId = 3;
sTsk->dep.lwpId = ++stLwpId;
}
#endif /* SS_MULTICORE_SUPPORT || SS_AFFINITY_SUPPORT */
{
int retVal = 0;
#ifdef SS_THR_REG_MAP
- U32 threadCreated = FALSE;
+ uint32_t threadCreated = FALSE;
#endif
SPThreadCreateArg* threadArg = (SPThreadCreateArg*)malloc(sizeof(SPThreadCreateArg));
S16 ssdGetAffinity
(
SSTskId *tskId, /* filled in with system task ID */
-U32 *coreId /* the core/processor id to which the affinity is set */
+uint32_t *coreId /* the core/processor id to which the affinity is set */
)
#else
S16 ssdGetAffinity(tskId, coreId)
SSTskId *tskId; /* filled in with system task ID */
-U32 *coreId; /* the core/processor id to which the affinity is set */
+uint32_t *coreId; /* the core/processor id to which the affinity is set */
#endif
{
- U32 tskInd;
+ uint32_t tskInd;
#ifdef SS_LINUX
pthread_t tId =0;
cpu_set_t cpuSet;
- U32 cpuInd = 0;
+ uint32_t cpuInd = 0;
/*mt013.301 :Fix for TRACE5 feature crash due to missing TRC MACRO*/
#else
#ifdef SUNOS
- U32 lwpId = *tskId;
+ uint32_t lwpId = *tskId;
#endif /*SUNOS*/
#endif /*SS_LINUX*/
#ifdef SS_LINUX
S16 ssdSetAffinity
(
SSTskId *tskId, /* filled in with system task ID */
-U32 coreId /* the core/processor id to which the affinity has to be set */
+uint32_t coreId /* the core/processor id to which the affinity has to be set */
)
#else
S16 ssdSetAffinity(tskId, coreId)
SSTskId *tskId; /* filled in with system task ID */
-U32 coreId; /* the core/processor id to which the affinity has to be set */
+uint32_t coreId; /* the core/processor id to which the affinity has to be set */
#endif
{
- U32 tskInd = 0;
+ uint32_t tskInd = 0;
#ifdef SS_LINUX
pthread_t tId = 0;
/*mt013.301 :Fix for TRACE5 feature crash due to missing TRC MACRO*/
#else
#ifdef SUNOS
- U32 lwpId = *tskId;
+ uint32_t lwpId = *tskId;
#endif /*SUNOS*/
#endif /*SS_LINUX*/
/* set up the message to display */
sprintf(errBuf, "\n\nFATAL ERROR - taskid = %x, errno = %d,"
- "reason = %d\n\n", (U8)tId, seq, reason);
+ "reason = %d\n\n", (uint8_t)tId, seq, reason);
SPrint(errBuf);
#endif
- RETVOID;
+ return;
}
#ifdef ENB_RELAY
#ifdef TENB_T2K3K_SPECIFIC_CHANGES
#if defined (L2_L3_SPLIT) && defined(SPLIT_RLC_DL_TASK)
EXTERN Void ysMtTskHdlr(Void);
-EXTERN Void ysMtPollPhyMsg(U8 region);
+EXTERN Void ysMtPollPhyMsg(uint8_t region);
EXTERN Void ysMtRcvPhyMsg(Void);
#ifdef ANSI
Void *mtTskHdlrT2kL2
PFS16 tmrActvFn = NULLP;
#else
PAIFTMRS16 tmrActvFn;
- U16 procIdIdx;
+ uint16_t procIdIdx;
#endif /* SS_MULTIPLE_PROCS */
/* mt003.301 Modifications */
#ifdef SS_THREAD_PROFILE
/* copy the Pst structure into a local duplicate */
for (i = 0; i < (S16) sizeof(Pst); i++)
- *(((U8 *)(&nPst)) + i) = *(((U8 *)&mInfo->pst) + i);
+ *(((uint8_t *)(&nPst)) + i) = *(((uint8_t *)&mInfo->pst) + i);
/* Give the message to the task activation function. If
* its a normal data message, we pass it, if this is a
{
#ifndef RGL_SPECIFIC_CHANGES
#ifdef SS_TSKLOG_ENABLE
- U32 t = MacGetTick();
+ uint32_t t = MacGetTick();
#endif
#endif
/* mt003.301 Modifications */
#endif
#if SS_THREAD_PROFILE
SGetEpcTime(&et2);
- tTsk->curEvtTime = (U32)(et2 - et1);
- tTsk->totTime += (U64)tTsk->curEvtTime;
+ tTsk->curEvtTime = (uint32_t)(et2 - et1);
+ tTsk->totTime += (uint64_t)tTsk->curEvtTime;
#endif /* SS_THREAD_PROFILE */
}
else
* enabled oroginal code in function mtTmrHdlr */
struct timespec ts;
- U32 time_int;
- U32 i, cnt, oldTicks, newTicks;
+ uint32_t time_int;
+ uint32_t i, cnt, oldTicks, newTicks;
struct timeval tv1,tv2;
/* mt038.201 added return */
S16 ret;
/* mt039.201 changes for nanosleep */
struct timespec tsN;
- PRIVATE U32 err_in_usec;
+ PRIVATE uint32_t err_in_usec;
/*mt013.301 : doesn't need TRC macro ,as this will never return*/
#endif
/* mt028.201: modification: multiple procs support related changes */
#ifdef SS_MULTIPLE_PROCS
- U16 procIdIdx;
+ uint16_t procIdIdx;
#endif /* SS_MULTIPLE_PROCS */
#ifdef RGL_SPECIFIC_CHANGES
#ifdef MSPD_MLOG_NEW
- U32 t = GetTIMETICK();
+ uint32_t t = GetTIMETICK();
#endif
#endif
/* if the timer was deleted, this will be NULL, so drop it */
if (tEnt == NULL)
{
- RETVOID;
+ return;
}
/* mt008.301 Deletion: tmrTbl Lock is moved to mtTmrHdlr */
*/
if (tEnt->used == FALSE)
{
- RETVOID;
+ return;
}
MTLOGERROR(ERRCLS_DEBUG, EMT017, ERRZERO, "Could not get message");
#endif
- RETVOID;
+ return;
}
mInfo = (SsMsgInfo *)mBuf->b_rptr;
MTLOGERROR(ERRCLS_DEBUG, EMT018, ret, "Could not lock TAPA task table");
#endif
- RETVOID;
+ return;
}
#endif
SS_RELEASE_SEMA(&osCp.tTskTblSem);
#endif
SPutMsg(mBuf);
- RETVOID;
+ return;
}
SS_RELEASE_SEMA(&osCp.tTskTblSem);
#endif
SPutMsg(mBuf);
- RETVOID;
+ return;
}
/* Klock work fix ccpu00148484 */
/* write the timer message to the queue of the destination task */
"Could not write to demand queue");
#endif
- RETVOID;
+ return;
}
#ifdef SS_LOCKLESS_MEMORY
mInfo->pst.region = tTsk->sTsk->region;
"Could not write to demand queue");
#endif
- RETVOID;
+ return;
}
/* Fix for ccpu00130657 */
#ifdef TENB_T2K3K_SPECIFIC_CHANGES
MLogTask(131313, RESOURCE_LARM, t, GetTIMETICK());
#endif
#endif
- RETVOID;
+ return;
}
\f
#endif
#endif
- RETVOID;
+ return;
}
/*mt010.301 Fix for core when run with -o option and when killed with SIGINT*/
#endif
localtime_r(&ptime.tv_sec, &tme);
- dt->month = (U8) tme.tm_mon + 1;
- dt->day = (U8) tme.tm_mday;
- dt->year = (U8) tme.tm_year;
- dt->hour = (U8) tme.tm_hour;
- dt->min = (U8) tme.tm_min;
- dt->sec = (U8) tme.tm_sec;
+ dt->month = (uint8_t) tme.tm_mon + 1;
+ dt->day = (uint8_t) tme.tm_mday;
+ dt->year = (uint8_t) tme.tm_year;
+ dt->hour = (uint8_t) tme.tm_hour;
+ dt->min = (uint8_t) tme.tm_min;
+ dt->sec = (uint8_t) tme.tm_sec;
dt->tenths = 0;
#ifdef SS_DATETIME_USEC
#endif
{
/* mt003.301 Modifications */
-PRIVATE U64 now;
- U64 to_sec = 1000000;
- U64 to_nsec = 1000;
+PRIVATE uint64_t now;
+ uint64_t to_sec = 1000000;
+ uint64_t to_nsec = 1000;
#ifndef SS_LINUX
struct timespec ptime;
#else
#ifdef ANSI
S16 SGetRefTime
(
-U32 refTime, /* reference time */
-U32 *sec,
-U32 *usec
+uint32_t refTime, /* reference time */
+uint32_t *sec,
+uint32_t *usec
)
#else
S16 SGetRefTime(refTime, sec, usec)
-U32 refTime; /* reference time */
-U32 *sec;
-U32 *usec;
+uint32_t refTime; /* reference time */
+uint32_t *sec;
+uint32_t *usec;
#endif
{
return RFAILED;
}
/* mt022.201 - Modification to fix compile warning */
- if (refTime > (U32)(ptime.tv_sec))
+ if (refTime > (uint32_t)(ptime.tv_sec))
{
MTLOGERROR(ERRCLS_INT_PAR, EMT026, ERRZERO, "Reference time exceeds present time");
return RFAILED;
#ifdef ANSI
INLINE S16 SSetIntPend
(
-U16 id, /* driver task identifier */
+uint16_t id, /* driver task identifier */
Bool flag /* flag */
)
#else
INLINE S16 SSetIntPend(id, flag)
-U16 id; /* driver task identifier */
+uint16_t id; /* driver task identifier */
Bool flag; /* flag */
#endif
{
S16 SGlobMemInfoShow()
#endif
{
- U16 idx;
+ uint16_t idx;
Txt prntBuf[100];
CmMmGlobRegCb *globReg;
S16 SRegInfoShow
(
Region region,
-U32 *availmem
+uint32_t *availmem
)
#else
S16 SRegInfoShow(region, availmem)
Region region;
-U32 *availmem;
+uint32_t *availmem;
#endif
{
- U16 idx;
+ uint16_t idx;
Txt prntBuf[100];
#ifdef XEON_SPECIFIC_CHANGES
#define SSI_MAX_BKT_THRESHOLD 6
#define SSI_MAX_REG_THRESHOLD 2
-U32 SMemMaxThreshold[SSI_MAX_REG_THRESHOLD][SSI_MAX_BKT_THRESHOLD] = {{0}};
-U32 SMemMidThreshold[SSI_MAX_REG_THRESHOLD][SSI_MAX_BKT_THRESHOLD] = {{0}};
-U32 SMemLowThreshold[SSI_MAX_REG_THRESHOLD][SSI_MAX_BKT_THRESHOLD] = {{0}};
+uint32_t SMemMaxThreshold[SSI_MAX_REG_THRESHOLD][SSI_MAX_BKT_THRESHOLD] = {{0}};
+uint32_t SMemMidThreshold[SSI_MAX_REG_THRESHOLD][SSI_MAX_BKT_THRESHOLD] = {{0}};
+uint32_t SMemLowThreshold[SSI_MAX_REG_THRESHOLD][SSI_MAX_BKT_THRESHOLD] = {{0}};
#ifdef ANSI
PRIVATE Void SInitMemThreshold
(
Region region,
-U8 maxBkt
+uint8_t maxBkt
)
#else
PRIVATE Void SInitMemThreshold(region, maxBkt)
Region region;
-U8 maxBkt;
+uint8_t maxBkt;
#endif
{
- U8 idx = 0;
+ uint8_t idx = 0;
for (idx = 0; (idx < maxBkt && idx < mtCMMRegCb[region]->numBkts); idx++)
{
SMemMaxThreshold[region][idx] = (mtCMMRegCb[region]->bktTbl[idx].numBlks*95)/100;
S16 SRegReachedMemThreshold
(
Region region,
-U8 maxBkt
+uint8_t maxBkt
)
#else
S16 SRegReachedMemThreshold(region, maxBkt)
Region region;
-U8 maxBkt;
+uint8_t maxBkt;
#endif
{
- U8 idx = 0;
- U8 memStatus = 3;
- PRIVATE U8 initFlag = 1;
+ uint8_t idx = 0;
+ uint8_t memStatus = 3;
+ PRIVATE uint8_t initFlag = 1;
if(initFlag)
{
initFlag = 0;
SsMemDbgInfo *dbgInfo;
#endif
{
- U32 idx;
+ uint32_t idx;
#if (ERRCLASS & ERRCLS_INT_PAR)
#ifdef ANSI
S16 SGetRegPoolInfo
(
-U8 *numRegion,
-U8 *numPool
+uint8_t *numRegion,
+uint8_t *numPool
)
#else
S16 SGetRegPoolInfo(numRegion, numPool)
-U8 *numRegion;
-U8 *numPool;
+uint8_t *numRegion;
+uint8_t *numPool;
#endif
{
/* Send number of Region available */
S16 SPrintRegMemStatusInfo
(
Region region,
-U8 typeFlag
+uint8_t typeFlag
)
#else
S16 SPrintRegMemStatusInfo(region, typeFlag)
Region region;
-U8 typeFlag;
+uint8_t typeFlag;
#endif
{
Txt prntBuf[150];
- U32 idx;
- U32 statMemSize;
- U32 dynMemSize;
+ uint32_t idx;
+ uint32_t statMemSize;
+ uint32_t dynMemSize;
#if (ERRCLASS & ERRCLS_INT_PAR)
{
CmMmHashListCp *hashListCp;
Txt prntBuf[150];
- U32 idx;
- U32 cntEnt;
+ uint32_t idx;
+ uint32_t cntEnt;
hashListCp = &mtCMMRegCb[region]->hashListCp;
SDisplay(0, prntBuf);
}
- RETVOID;
+ return;
}
/*
Size offsetToNxtBlk;
Size hdrSize;
Txt prntBuf[250];
- U32 idx;
- U32 blkCnt;
+ uint32_t idx;
+ uint32_t blkCnt;
*
--*/
#ifdef ANSI
-U32 SGetSystemTsk
+uint32_t SGetSystemTsk
(
Void
)
#else
-U32 SGetSystemTsk()
+uint32_t SGetSystemTsk()
#endif
{
S16 ssdInitLockNew
(
SLockInfo *lockId,
-U8 lockType
+uint8_t lockType
)
#else
S16 ssdInitLockNew(lockId, lockType)
SLockInfo *lockId;
-U8 lockType;
+uint8_t lockType;
#endif
{
S16 ssdLockNew
(
SLockInfo *lockId,
-U8 lockType
+uint8_t lockType
)
#else
S16 ssdLockNew(lockId, lockType)
SLockInfo *lockId;
-U8 lockType;
+uint8_t lockType;
#endif
{
S16 ssdUnlockNew
(
SLockInfo *lockId,
-U8 lockType
+uint8_t lockType
)
#else
S16 ssdUnlockNew(lockId, lockType)
SLockInfo *lockId;
-U8 lockType;
+uint8_t lockType;
#endif
{
S16 ssdDestroyLockNew
(
SLockInfo *lockId,
-U8 lockType
+uint8_t lockType
)
#else
S16 ssdDestroyLockNew(lockId, lockType)
SLockInfo *lockId;
-U8 lockType;
+uint8_t lockType;
#endif
{
Txt prntBuf[PRNTSZE];
#endif /* SS_SEUM_CAVIUM */
#ifdef TENB_RTLIN_CHANGES
-S16 SInitLock(SLockId *l, U8 t)
+S16 SInitLock(SLockId *l, uint8_t t)
{
S16 r = 0;
pthread_mutexattr_t prior;
Region region /* Region associated with thread */
)
{
- PRIVATE U32 createdThreads;
+ PRIVATE uint32_t createdThreads;
PRIVATE pthread_t createdThreadIds[SS_MAX_THREAD_CREATE_RETRY];
- U32 indx;
+ uint32_t indx;
/* Here 0xFF is considered as invalid region and if the mapping table
osCp.threadMemoryRegionMap[((threadId >> SS_MEM_THREAD_ID_SHIFT) % SS_MAX_THREAD_REGION_MAP)])
{
#ifndef ALIGN_64BIT
- printf("Invalid Thread ID (%ld)\n", (U32)threadId);
+ printf("Invalid Thread ID (%ld)\n", (uint32_t)threadId);
#else
- printf("Invalid Thread ID (%d)\n", (U32)threadId);
+ printf("Invalid Thread ID (%d)\n", (uint32_t)threadId);
#endif
return RFAILED;
}
#ifdef ANSI
S16 SStartTask
(
-VOLATILE U32 *startTime,
-U32 taskId
+VOLATILE uint32_t *startTime,
+uint32_t taskId
)
#else
S16 SStartTask(startTime, taskId)
-VOLATILE U32 *startTime;
-U32 taskId;
+VOLATILE uint32_t *startTime;
+uint32_t taskId;
#endif
{
#ifdef MSPD_MLOG_NEW
#ifdef ANSI
S16 SStopTask
(
-VOLATILE U32 startTime,
-U32 taskId
+VOLATILE uint32_t startTime,
+uint32_t taskId
)
#else
S16 SStopTask(startTime, taskId)
-VOLATILE U32 startTime;
-U32 taskId;
+VOLATILE uint32_t startTime;
+uint32_t taskId;
#endif
{
- /*U32 stopTime;*/
+ /*uint32_t stopTime;*/
switch(taskId)
{
case PID_MAC_HARQ_IND:
#ifdef ANSI
S16 SStartTask
(
-VOLATILE U32 * startTime,
-U32 taskId
+VOLATILE uint32_t *startTime,
+uint32_t taskId
)
#else
S16 SStartTask(startTime, taskId)
-VOLATILE U32 * startTime;
-U32 taskId;
+VOLATILE uint32_t *startTime;
+uint32_t taskId;
#endif
{
*startTime = 0;
#ifdef ANSI
S16 SStopTask
(
-VOLATILE U32 startTime,
-U32 taskId
+VOLATILE uint32_t startTime,
+uint32_t taskId
)
#else
S16 SStopTask(startTime, taskId)
-VOLATILE U32 startTime;
-U32 taskId;
+VOLATILE uint32_t startTime;
+uint32_t taskId;
#endif
{
return ROK;
Void UpdateSocCpuInfo
(
CmCpuStatsInfo *cpuInfo,
-U8 idx
+uint8_t idx
)
#else
Void UpdateSocCpuInfo(*cpuInfo, idx)
CmCpuStatsInfo *cpuInfo;
-U8 idx;
+uint8_t idx;
#endif
{
FILE *mipsFd;
- S8 mipsStr[MIPS_STRING_LEN];
+ S8 mipsStr[MIPS_STRING_LEN];
S8 *strPart;
- U32 l2FreeCpu;
- U32 l2CpuUsed;
- U32 l3FreeCpu;
- U32 l3CpuUsed;
+ uint32_t l2FreeCpu;
+ uint32_t l2CpuUsed;
+ uint32_t l3FreeCpu;
+ uint32_t l3CpuUsed;
/* Open the file which holds the MIPS available value */
mipsFd = fopen(MIPS_FILE, "r");
if(mipsFd == NULLP)
{
- RETVOID;
+ return;
}
/* Get the free mips available value from the file */
{
printf("fgets to get the free mips available failed\n");
fclose(mipsFd);
- RETVOID;
+ return;
}
strtok(mipsStr, " ");
l2FreeCpu = atoi(strPart);
l2CpuUsed = 100 - l2FreeCpu;
cpuInfo->cpuUtil[0].totCpuUtil += l2CpuUsed;
- cpuInfo->cpuUtil[0].maxCpuUtil = GET_CPU_MAX((cpuInfo->cpuUtil[0].maxCpuUtil), l2CpuUsed);;
+ cpuInfo->cpuUtil[0].maxCpuUtil = GET_CPU_MAX((cpuInfo->cpuUtil[0].maxCpuUtil), l2CpuUsed);
cpuInfo->cpuUtil[0].numSamples++;
}
}
l3FreeCpu = atoi(strPart);
l3CpuUsed = 100 - l3FreeCpu;
cpuInfo->cpuUtil[0].totCpuUtil += l3CpuUsed;
- cpuInfo->cpuUtil[0].maxCpuUtil = GET_CPU_MAX((cpuInfo->cpuUtil[0].maxCpuUtil), l3CpuUsed);;
+ cpuInfo->cpuUtil[0].maxCpuUtil = GET_CPU_MAX((cpuInfo->cpuUtil[0].maxCpuUtil), l3CpuUsed);
cpuInfo->cpuUtil[0].numSamples++;
}
}
}
fclose(mipsFd);
- RETVOID;
+ return;
}
#endif /* TENB_T2K3K_SPECIFIC_CHANGES */
#ifdef SS_MULTICORE_SUPPORT
--*/
#ifdef ANSI
PRIVATE SsSTskEntry* ssdReAddTmrSTsk(
-U8 idx
+uint8_t idx
)
#else
PRIVATE SsSTskEntry* ssdReAddTmrSTsk(idx)
-U8 idx;
+uint8_t idx;
#endif
{
SsSTskEntry *sTsk;
pthread_attr_t attr;
struct sched_param param_sched;
#ifndef XEON_SPECIFIC_CHANGES
- U8 ret = ROK;
+ uint8_t ret = ROK;
#endif
#ifdef SS_MULTICORE_SUPPORT
SsSTskEntry *sTsk;
#endif /* SS_MULTICORE_SUPPORT */
#ifdef SS_THR_REG_MAP
- U32 threadCreated = FALSE;
+ uint32_t threadCreated = FALSE;
#endif /* SS_THR_REG_MAP */
#ifndef TENB_RTLIN_CHANGES
#define SInitLock(l, t) pthread_mutex_init(l, NULL)
#endif
-/*extern U32 gt[128]; */
-/*#define SLock(l) (((gt[0x000000FF &((U32)pthread_self())]=MacGetTick())&&pthread_mutex_lock(l)&&MLogTask(30340, RESOURCE_LINL2, gt[0x000000FF &((U32)pthread_self())], MacGetTick()))?0:0)*/
+/*extern uint32_t gt[128]; */
+/*#define SLock(l) (((gt[0x000000FF &((uint32_t)pthread_self())]=MacGetTick())&&pthread_mutex_lock(l)&&MLogTask(30340, RESOURCE_LINL2, gt[0x000000FF &((uint32_t)pthread_self())], MacGetTick()))?0:0)*/
#define SLock(l) pthread_mutex_lock(l)
#define SUnlock(l) pthread_mutex_unlock(l)
#define SDestroyLock(l) pthread_mutex_destroy(l)
/*mt041.201 Value of MT_TICK_CNT changed*/
/*mt004.301- defining the MT_TICK_CNT in Micro seconds (usecs) */
/* mt010.301 Removed #ifdef SS_FAP portion and enabled oroginal code */
-#define MT_TICK_CNT (((U32)0x0F4240)/SS_TICKS_SEC)
+#define MT_TICK_CNT (((uint32_t)0x0F4240)/SS_TICKS_SEC)
#define MT_MAX_TICK_CNT_VAL 35
#define MT_MIN_TICK_CNT_VAL 1
SLockId lock;
#ifdef SS_MULTICORE_SUPPORT
- U32 lwpId;
+ uint32_t lwpId;
#endif /* SS_MULTICORE_SUPPORT */
} SsdSTskEntry;
typedef struct mtBktCfg
{
Size blkSize; /* bucket quantum size */
- U32 numBlks; /* the total blocks in the bucket */
+ uint32_t numBlks; /* the total blocks in the bucket */
} MtBktCfg;
typedef struct mtRegCfg
{
Region regionId;
- U16 numBkts;
+ uint16_t numBkts;
Size heapsize;
MtBktCfg bkt[SS_MAX_POOLS_PER_REG];
} MtRegCfg;
typedef struct mtMemCfg
{
- U8 numRegions;
+ uint8_t numRegions;
MtRegCfg region[SS_MAX_REGS];
} MtMemCfg;
}SLockInfo;
#endif /* SS_LOCK_SUPPORT */
-extern U32 gt[128];
+extern uint32_t gt[128];
#endif /* __MTSSX__ */
typedef struct mtDynBktCfg
{
- U16 blkSetRelThreshold; /* threshold value for releasing memory blocks */
- U16 blkSetAcquireThreshold; /* threshold for requesting additional memory blocks */
+ uint16_t blkSetRelThreshold; /* threshold value for releasing memory blocks */
+ uint16_t blkSetAcquireThreshold; /* threshold for requesting additional memory blocks */
} MtDynBktCfg;
/* The number of blocks in the buckets and size of bloks must be
typedef struct mtDynRegCfg
{
Region regionId; /* Region Id */
- U16 numBkts; /* Number of buckets */
+ uint16_t numBkts; /* Number of buckets */
MtDynBktCfg bkt[SS_MAX_POOLS_PER_REG]; /* Threshold value configuration for each buckets */
} MtDynRegCfg;
* as of the one configured in the gloabl region */
typedef struct mtDynMemCfg
{
- U8 numRegions; /* Number of regions */
+ uint8_t numRegions; /* Number of regions */
MtDynRegCfg region[SS_MAX_REGS]; /* Configuration details of each region */
} MtDynMemCfg;
typedef struct mtGlobBktCfg
{
Size blkSize; /* bucket quantum size */
- U32 numBlks; /* the total blocks in the bucket */
- U16 bucketSetSize; /* Size of each bucket set */
+ uint32_t numBlks; /* the total blocks in the bucket */
+ uint16_t bucketSetSize; /* Size of each bucket set */
} MtGlobBktCfg;
typedef struct mtGlobMemCfg
{
- U16 numBkts;
+ uint16_t numBkts;
#ifdef XEON_SPECIFIC_CHANGES
Size heapSize;
#endif
/* ss029.103: modification: multiple procId related changes */
#ifdef SS_MULTIPLE_PROCS
- U16 count;
- U16 i;
+ uint16_t count;
+ uint16_t i;
ProcId procIdLst[SS_MAX_PROCS];
#endif /* SS_MULTIPLE_PROCS */
#ifdef SSI_STATIC_MEM_LEAK_DETECTION
PRIVATE void InitializeForStaticMemLeak ARGS((void));
PRIVATE void InitializeStaticMemAllocInfo ARGS((StaticMemAllocInfo* memAllocInfo));
-U32 GetNextFreeIdx ARGS((StaticMemAllocInfo * memAllocInfo));
-void FreeIdx ARGS((U8* ptr, U32 idx, StaticMemAllocInfo* memAllocInfo,U32 size, char*
- file, U32 line));
+uint32_t GetNextFreeIdx ARGS((StaticMemAllocInfo * memAllocInfo));
+void FreeIdx ARGS((uint8_t* ptr, uint32_t idx, StaticMemAllocInfo* memAllocInfo,uint32_t size, char*
+ file, uint32_t line));
void LogForStaticMemLeak ARGS((StaticMemAllocInfo* memAllocInfo, char* file,
- U32 line, U32 size, void* ptr, U32 idx));
+ uint32_t line, uint32_t size, void* ptr, uint32_t idx));
PRIVATE void PrintStaticMemAllocInfo ARGS((StaticMemAllocInfo* memAllocInfo, FILE
*opFile));
#endif
void DumpSSIDemandQDebugInformation()
{
- U32 i,j;
+ uint32_t i,j;
RTLIN_DUMP_DEBUG("Demand Q Information\n");
RTLIN_DUMP_DEBUG("====================\n");
for(i = 0; i < osCp.numSTsks; i++)
#ifdef SS_FBSED_TSK_REG
/* Configure task registration based on the configuration */
/*ss013.301 : Fixed warnings for 32/64 bit compilation*/
- cmCfgrTskReg((U8 *)"task_info.t");
+ cmCfgrTskReg((uint8_t *)"task_info.t");
#endif /* SS_FBSED_TSK_REG */
/*ss011.301 : RMIOS release related changes*/
#endif
{
/* ss007.301 */
- U16 regCnt;
+ uint16_t regCnt;
ssdDeinitTmr();
{
S16 bufSz;
/* buffer synchronisation*/
- bufSz = cmStrlen((U8 *)buf);
+ bufSz = cmStrlen((uint8_t *)buf);
SLock(&osCp.logger.bufLock);
if(osCp.logger.started == FALSE)
{
errCls, errCode, errVal, errDesc);
- RETVOID;
+ return;
}
/* ss029.103: modification:
osCp.procId = procId;
- RETVOID;
+ return;
}
#endif /* SS_MULTIPLE_PROCS */
*
*/
#ifdef ANSI
-U16 SGetProcIdIdx
+uint16_t SGetProcIdIdx
(
ProcId proc
)
#else
-U16 SGetProcIdIdx(proc)
+uint16_t SGetProcIdIdx(proc)
ProcId proc;
#endif
{
- U16 i;
- U16 idx;
+ uint16_t i;
+ uint16_t idx;
idx = SS_HASH_IDX(proc);
ProcId proc;
#endif
{
- U16 i;
- U16 idx;
+ uint16_t i;
+ uint16_t idx;
idx = SS_HASH_IDX(proc);
ProcId proc;
#endif
{
- U16 i;
- U16 idx;
+ uint16_t i;
+ uint16_t idx;
idx = SS_HASH_IDX(proc);
#ifdef ANSI
S16 SAddProcIdLst
(
-U16 numPIds,
+uint16_t numPIds,
ProcId *pIdLst
)
#else
S16 SAddProcIdLst(numPIds, pIdLst)
-U16 numPIds;
+uint16_t numPIds;
ProcId *pIdLst;
#endif
{
- U16 i;
+ uint16_t i;
S16 ret;
#ifdef ANSI
S16 SRemProcIdLst
(
-U16 numPIds,
+uint16_t numPIds,
ProcId *pIdLst
)
#else
S16 SRemProcIdLst(numPIds, pIdLst)
-U16 numPIds;
+uint16_t numPIds;
ProcId *pIdLst;
#endif
{
- U16 i;
+ uint16_t i;
#if (ERRCLASS & ERRCLS_INT_PAR)
#ifdef ANSI
S16 SGetProcIdLst
(
-U16 *numPIds,
+uint16_t *numPIds,
ProcId *pIdLst
)
#else
S16 SGetProcIdLst(numPIds, pIdLst)
-U16 *numPIds;
+uint16_t *numPIds;
ProcId *pIdLst;
#endif
{
- U16 i;
- U16 count = 0;
+ uint16_t i;
+ uint16_t count = 0;
#if (ERRCLASS & ERRCLS_INT_PAR)
Void **xxCb;
#endif
{
- U16 procIdIdx;
+ uint16_t procIdIdx;
SsIdx idx;
#endif
{
- U8 entInfo[26][26] = {
+ uint8_t entInfo[26][26] = {
/* A B C D E F G H I J K *
L M N O P Q R S T U V *
W X Y Z */
};
/*ss013.301 :Adding TRC MACRO*/
- memcpy((U8*)osCp.entId, (U8*)entInfo, sizeof(entInfo));
+ memcpy(osCp.entId, entInfo, sizeof(entInfo));
return ROK;
} /* SFillEntIds */
S16 SGetEntInd
(
Ent *entId,
-U8 *fileName
+uint8_t *fileName
)
#else
S16 SGetEntInd(entId, fileName)
Ent *entId;
-U8 *fileName;
+uint8_t *fileName;
#endif
{
- U8 *letter = NULLP;
+ uint8_t *letter = NULLP;
/* ss002.301 Additions */
S8 *strippedName = NULLP;
- U8 count = 0;
- U8 tempIdx = 0;
- U8 firstIdx = 0;
- U8 secondIdx = 0;
+ uint8_t count = 0;
+ uint8_t tempIdx = 0;
+ uint8_t firstIdx = 0;
+ uint8_t secondIdx = 0;
/* ss002.301 Additions */
if ((strippedName = strrchr((const char *)fileName, '/')))
{
- fileName = (U8 *)strippedName + 1;
+ fileName = (uint8_t *)strippedName + 1;
}
if(fileName[0] =='l' && fileName[3] == '.')
S16 SLockNew
(
SLockInfo *lockId,
-U8 lockType
+uint8_t lockType
)
#else
S16 SLockNew(lockId, lockType)
SLockInfo *lockId;
-U8 lockType;
+uint8_t lockType;
#endif
{
S16 retVal = ROK;
S16 SInitLockNew
(
SLockInfo *lockId,
-U8 lockType
+uint8_t lockType
)
#else
S16 SInitLockNew(lockId, lockType)
SLockInfo *lockId;
-U8 lockType;
+uint8_t lockType;
#endif
{
S16 retVal = ROK;
S16 SUnlockNew
(
SLockInfo *lockId,
-U8 lockType
+uint8_t lockType
)
#else
S16 SUnlockNew(lockId, lockType)
SLockInfo *lockId;
-U8 lockType;
+uint8_t lockType;
#endif
{
S16 retVal = ROK;
S16 SDestroyLockNew
(
SLockInfo *lockId,
-U8 lockType
+uint8_t lockType
)
#else
S16 SDestroyLockNew(lockId, lockType)
SLockInfo *lockId;
-U8 lockType;
+uint8_t lockType;
#endif
{
S16 retVal = ROK;
#ifdef SSI_STATIC_MEM_LEAK_DETECTION
/* Static memory leak detection changes */
-static U32 StaticMemLeakAge;
-static U32 StaticMemLeakIntCount = 1;
+static uint32_t StaticMemLeakAge;
+static uint32_t StaticMemLeakIntCount = 1;
void PrintStaticMemAllocInfo(StaticMemAllocInfo* memAllocInfo, FILE *opFile)
{
void InitializeStaticMemAllocInfo(StaticMemAllocInfo* memAllocInfo)
{
- U32 i;
+ uint32_t i;
/* index 0 is not used; nextIdx as 0 means end of list */
memAllocInfo->nextFreeIdx = 1;
memAllocInfo->allocations[MAX_MEM_ALLOCATIONS - 1].listInfo.nextIdx = 0;
}
-U32 GetNextFreeIdx(StaticMemAllocInfo * memAllocInfo)
+uint32_t GetNextFreeIdx(StaticMemAllocInfo * memAllocInfo)
{
- U32 toBeReturned = memAllocInfo->nextFreeIdx;
+ uint32_t toBeReturned = memAllocInfo->nextFreeIdx;
- U32 newNextFreeIdx = memAllocInfo->allocations[memAllocInfo->nextFreeIdx].listInfo.nextIdx;
+ uint32_t newNextFreeIdx = memAllocInfo->allocations[memAllocInfo->nextFreeIdx].listInfo.nextIdx;
if(newNextFreeIdx == 0 || newNextFreeIdx >= MAX_MEM_ALLOCATIONS)
{
}
#define CRASH_ENB {int *p = 0; *p = 100;}
-void FreeIdx(U8* ptr, U32 idx, StaticMemAllocInfo* memAllocInfo,U32 size, char* file, U32 line)
+void FreeIdx(uint8_t* ptr, uint32_t idx, StaticMemAllocInfo* memAllocInfo,uint32_t size, char* file, uint32_t line)
{
if(idx == 0 || idx >= MAX_MEM_ALLOCATIONS)
{
}
-void LogForStaticMemLeak(StaticMemAllocInfo* memAllocInfo, char* file, U32 line, U32 size, void* ptr, U32 idx)
+void LogForStaticMemLeak(StaticMemAllocInfo* memAllocInfo, char* file, uint32_t line, uint32_t size, void* ptr, uint32_t idx)
{
memAllocInfo->allocations[idx].file = file;
S16 SReInitTmr()
#endif
{
- U8 ret = ROK;
+ uint8_t ret = ROK;
Txt prntBuf[PRNTSZE];
sprintf(prntBuf, "\n SReInitTmr(): ReStarting the Tmr\n");
/* ss029.103: addition: multiple procIds related changes */
#ifdef SS_MULTIPLE_PROCS
typedef struct {
- U16 free;
+ uint16_t free;
ProcId procId[SS_MAX_PROCS];
} ProcIdLst;
#endif /* SS_MULTIPLE_PROCS */
/* the currently used core */
- U32 currentCore;
+ uint32_t currentCore;
/*COMMENT: add the thread id for use on hyperthreading machines */
struct {
- U32 thrs; /* available no. of threads per core */
+ uint32_t thrs; /* available no. of threads per core */
S8 exclusive; /* exclusive flag */
SSTskId tskPerCoreLst[SS_MAX_THREADS_PER_CORE]; /* System tasks running on this core */
} coreInfo[SS_MAX_CORES];
/* ss002.301: Modifications */
#ifdef SS_THREAD_PROFILE
#ifdef SS_MULTIPLE_PROCS
-EXTERN S16 SGetThrdProf(SSTskId *sTskId,ProcId procId,Ent ent,Inst inst,Event *curEvent,U32 *curEvtTime,U64 *totTime);
+EXTERN S16 SGetThrdProf(SSTskId *sTskId,ProcId procId,Ent ent,Inst inst,Event *curEvent,uint32_t *curEvtTime,uint64_t *totTime);
#else
-EXTERN S16 SGetThrdProf(SSTskId *sTskId,Ent ent,Inst inst,Event *curEvent,U32 *curEvtTime,U64 *totTime);
+EXTERN S16 SGetThrdProf(SSTskId *sTskId,Ent ent,Inst inst,Event *curEvent,uint32_t *curEvtTime,uint64_t *totTime);
#endif /* SS_MULTIPLE_PROCS */
#endif /* SS_THERAD_PROFILE */
#else
struct in_addr addr; /* configured node addr */
#endif /* SS_WATCHDOG_IPV6 */
- U16 port; /* configured watchdog port */
- U8 status; /* HB ACK status */
+ uint16_t port; /* configured watchdog port */
+ uint8_t status; /* HB ACK status */
} watchDogStatus;
typedef struct ssWd {
- U32 timeout; /* configured HB timer */
- U8 watchdogStop; /* watchdog stop flag */
+ uint32_t timeout; /* configured HB timer */
+ uint8_t watchdogStop; /* watchdog stop flag */
int numNodes; /* configured nodes */
#ifdef SS_WIN
unsigned int sock; /* HB socket descriptor */
SsWd globWd;
SLockId wdLock;
} SsWdCp;
-EXTERN S16 SInitWatchdog(U16 port);
-EXTERN S16 SRegCfgWd(U32 numNodes, U8 *addr[], U16 port[], U32 timeout, WdUserCallback callback, void *data);
+EXTERN S16 SInitWatchdog(uint16_t port);
+EXTERN S16 SRegCfgWd(uint32_t numNodes, uint8_t *addr[], uint16_t port[], uint32_t timeout, WdUserCallback callback, void *data);
EXTERN S16 SDeregCfgWd(void);
-EXTERN S16 SStartHrtBt(U8 timeInterval);
+EXTERN S16 SStartHrtBt(uint8_t timeInterval);
EXTERN S16 SStopHrtBt(void);
#endif /* SS_WATCHDOG */
S32 socketdes;
struct sockaddr_in remoteAddr;
- U16 curNumFlush;
- U16 maxNumFlush;
+ uint16_t curNumFlush;
+ uint16_t maxNumFlush;
S8 buffer[SS_MAX_LOGBUF_SIZE];
- U32 maxBufSiz; /*The size of this is determined by the
+ uint32_t maxBufSiz; /*The size of this is determined by the
system on which its running.*/
- U32 curBufSiz;
+ uint32_t curBufSiz;
SLockId bufLock; /* lock for global buffer access */
} SLoggerInfo;
#endif /* SS_LOGGER_SUPPORT */
#ifdef NTL_LIB
typedef struct _MtNtl
{
- U32 hdl;
+ uint32_t hdl;
}SsMtNtl;
#endif /* NTL_LIB */
SLockId sTskTblLock; /* lock for table access */
- U8 dmndQLookupTbl[256]; /* demand queue lookup table */
+ uint8_t dmndQLookupTbl[256]; /* demand queue lookup table */
#ifdef SS_DRVR_SUPPORT
#endif /* SS_WATCHDOG */
#ifdef SS_HISTOGRAM_SUPPORT
- U8 entId[26][26];
+ uint8_t entId[26][26];
#endif /* SS_HISTOGRAM_SUPPORT */
#ifdef SS_LOGGER_SUPPORT
/* ss029.103: addition: support function to implement multiple procIds */
#ifdef SS_MULTIPLE_PROCS
-EXTERN U16 SGetProcIdIdx ARGS((ProcId proc));
+EXTERN uint16_t SGetProcIdIdx ARGS((ProcId proc));
#endif /* SS_MULTIPLE_PROCS */
/* multi-core support */
/*ss013.301 : changes for SS_AFFINITY_SUPPORT*/
#if defined(SS_MULTICORE_SUPPORT) || defined(SS_AFFINITY_SUPPORT)
-EXTERN S16 ssdSetAffinity ARGS((SSTskId *tskId, U32 coreId));
-EXTERN S16 ssdGetAffinity ARGS((SSTskId *tskId, U32 *coreId));
+EXTERN S16 ssdSetAffinity ARGS((SSTskId *tskId, uint32_t coreId));
+EXTERN S16 ssdGetAffinity ARGS((SSTskId *tskId, uint32_t *coreId));
#endif /* SS_MULTICORE_SUPPORT || SS_AFFINITY_SUPPORT */
/* ss001.301: additions */
EXTERN Void ssdWatchDgTmrEvt ARGS(( PTR cb, S16 event ));
EXTERN S16 watchDgActvTsk ARGS(( Pst *pst, Buffer *mBuf));
EXTERN S16 watchDgRcvrActvTsk ARGS(( Pst *pst, Buffer *mBuf ));
-EXTERN S16 ssdSndHrtBtMsg ARGS(( Bool restart, U32 type));
-EXTERN Void ssdStartWatchDgTmr ARGS(( void *cb, S16 event, U16 wait));
+EXTERN S16 ssdSndHrtBtMsg ARGS(( Bool restart, uint32_t type));
+EXTERN Void ssdStartWatchDgTmr ARGS(( void *cb, S16 event, uint16_t wait));
EXTERN Void ssdStopWatchDgTmr ARGS(( void *cb, S16 event));
EXTERN S16 ssdInitWatchDgPst ARGS((Pst *pst));
-EXTERN S16 ssdInitWatchDog ARGS((U16 port));
+EXTERN S16 ssdInitWatchDog ARGS((uint16_t port));
#endif
#ifdef SS_FBSED_TSK_REG
-EXTERN S16 SRegTskInfo ARGS((U8 *cfgFile));
+EXTERN S16 SRegTskInfo ARGS((uint8_t *cfgFile));
#endif
/* ss002.301 Readwrite lock additions */
#ifdef SS_LOCK_SUPPORT
-EXTERN S16 ssdLockNew ARGS((SLockInfo *LockId, U8 locktype));
-EXTERN S16 ssdInitLockNew ARGS((SLockInfo *LockId, U8 lockType));
-EXTERN S16 ssdUnlockNew ARGS((SLockInfo *LockId, U8 lockType));
-EXTERN S16 ssdDestroyLockNew ARGS((SLockInfo *LockId, U8 lockType));
+EXTERN S16 ssdLockNew ARGS((SLockInfo *LockId, uint8_t locktype));
+EXTERN S16 ssdInitLockNew ARGS((SLockInfo *LockId, uint8_t lockType));
+EXTERN S16 ssdUnlockNew ARGS((SLockInfo *LockId, uint8_t lockType));
+EXTERN S16 ssdDestroyLockNew ARGS((SLockInfo *LockId, uint8_t lockType));
#endif /* SS_LOCK_SUPPORT */
#ifdef SSI_STATIC_MEM_LEAK_DETECTION
typedef struct _listInfo
{
- U32 nextIdx;
+ uint32_t nextIdx;
}ListInfo;
typedef struct _eachAllocInfo
ListInfo listInfo;
/* other info should come here */
char *file;
- U32 lineNo;
- U32 age;
+ uint32_t lineNo;
+ uint32_t age;
void *ptr;
- U32 size;
+ uint32_t size;
/* end of other info */
}EachAllocInfo;
typedef struct _staticMemAllocationInfo
{
- U32 nextFreeIdx;
+ uint32_t nextFreeIdx;
EachAllocInfo allocations[MAX_MEM_ALLOCATIONS];
}StaticMemAllocInfo;
(
Region region, /* region ID */
Size *size, /* size of block required/allocated */
-U32 flags, /* allocation flags */
+uint32_t flags, /* allocation flags */
Data **ptr, /* filled with pointer to block */
-U32 line,
-U8 *fileName,
-U8 entId
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId
)
#else
S16 SAlloc(region, size, flags, ptr, line, fileName, entId)
Region region; /* region ID */
Size *size; /* size of block required/allocated */
-U32 flags; /* allocation flags */
+uint32_t flags; /* allocation flags */
Data **ptr; /* filled with pointer to block */
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
#endif
#else
#ifdef T2K_MEM_LEAK_DBG
(
Region region, /* region ID */
Size *size, /* size of block required/allocated */
-U32 flags, /* allocation flags */
+uint32_t flags, /* allocation flags */
Data **ptr, /* filled with pointer to block */
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
(
Region region, /* region ID */
Size *size, /* size of block required/allocated */
-U32 flags, /* allocation flags */
+uint32_t flags, /* allocation flags */
Data **ptr /* filled with pointer to block */
)
#else
S16 SAlloc(region, size, flags, ptr)
Region region; /* region ID */
Size *size; /* size of block required/allocated */
-U32 flags; /* allocation flags */
+uint32_t flags; /* allocation flags */
Data **ptr; /* filled with pointer to block */
#endif
#endif
Region region, /* region ID */
Data *ptr, /* pointer to the allocated block */
Size size, /* size of block */
-U32 line,
-U8 *fileName,
-U8 entId
+uint32_t line,
+uint8_t *fileName,
+uint8_t entId
)
#else
S16 SFree(region, ptr, size, line, fileName, entId)
Region region; /* region ID */
Data *ptr; /* pointer to the allocated block */
Size size; /* size of block */
-U32 line;
-U8 *fileName;
-U8 entId;
+uint32_t line;
+uint8_t *fileName;
+uint8_t entId;
#endif
#else
#ifdef ANSI
Data *ptr, /* pointer to the allocated block */
Size size, /* size of block */
char* file,
-U32 line
+uint32_t line
)
#else
S16 SFree
{
/*ss012.301 : Increased Buffer size to fix segmentation fault*/
Txt prntBuf[511]; /* Buffer to print on the console */
- U16 ret = ROK; /* return value */
+ uint16_t ret = ROK; /* return value */
Ent tapaTsk[SS_MAX_TTSKS]; /* List of tapa task */
- U32 tskCnt = 0; /* Tapa task Count */
- U32 regCnt = 0; /* Region count */
- U32 bktCnt = 0; /* Bucket count in each region */
+ uint32_t tskCnt = 0; /* Tapa task Count */
+ uint32_t regCnt = 0; /* Region count */
+ uint32_t bktCnt = 0; /* Bucket count in each region */
CmHstGrmHashListCp *hashListCp = NULLP; /* Hash List ponter of bucket */
- U32 binCnt = 0;
- U32 entCnt = 0;
+ uint32_t binCnt = 0;
+ uint32_t entCnt = 0;
CmMemEntries *entry = NULLP;
- U32 blkSize = 0;
+ uint32_t blkSize = 0;
memset(tapaTsk, ENTNC, sizeof(tapaTsk));
Void *regCb; /* control block */
- U32 flags; /* flags */
+ uint32_t flags; /* flags */
SsPoolEntry poolTbl[SS_MAX_POOLS_PER_REG]; /* pool table */
SsCntr numPools; /* count of pools */
typedef struct ssMemBktDbgInfo
{
Size size; /* Size of the block */
- U32 numBlks; /* Total number of blocks in the bucket */
- U32 numAlloc; /* Number of blocks allocated */
+ uint32_t numBlks; /* Total number of blocks in the bucket */
+ uint32_t numAlloc; /* Number of blocks allocated */
}SsMemBktDbgInfo;
typedef struct ssMemDbgInfo
{
Region region; /* Region Id of the memory */
- U16 numBkts; /* Number of buckets in bktDbgTbl */
+ uint16_t numBkts; /* Number of buckets in bktDbgTbl */
SsMemBktDbgInfo bktDbgTbl[SS_MAX_BKT_PER_DBGTBL];
Size heapSize; /* Size of the heap pool */
Size heapAlloc; /* Total allocated memory */
- U32 availmem;
+ uint32_t availmem;
#if (ERRCLASS & ERRCLS_DEBUG)
- U16 numFragBlk; /* Number of fragmented block */
+ uint16_t numFragBlk; /* Number of fragmented block */
#endif /* ERRCLASS & ERRCLS_DEBUG */
}SsMemDbgInfo;
/* ss036.103 - Addition of prototypes for memory statistics */
-EXTERN S16 SRegInfoShow ARGS((Region region, U32 *availmem));
+EXTERN S16 SRegInfoShow ARGS((Region region, uint32_t *availmem));
EXTERN S16 SGetRegInfo ARGS((Region region, SsMemDbgInfo *dbgInfo));
#ifdef XEON_SPECIFIC_CHANGES
-EXTERN S16 SRegReachedMemThreshold ARGS((Region region, U8 maxBkt));
+EXTERN S16 SRegReachedMemThreshold ARGS((Region region, uint8_t maxBkt));
#endif
#ifdef SSI_DEBUG_LEVEL1
-EXTERN S16 SPrintRegMemStatusInfo ARGS((Region region, U8 typeFlag));
+EXTERN S16 SPrintRegMemStatusInfo ARGS((Region region, uint8_t typeFlag));
EXTERN Void SRegMemErrHdlr ARGS((Region region, Data *ptr, S16 errCode));
EXTERN S16 SPrintRegMemProfile ARGS((Region region));
#endif /* SSI_DEBUG_LEVEL1 */
#endif /* SS_SEUM_CAVIUM */
#include <pthread.h>
#ifdef XEON_SPECIFIC_CHANGES
-U32 startMemLeak=0;
+uint32_t startMemLeak=0;
extern pthread_mutex_t memLock;
#endif
S16 ssGetDBufOfSize ARGS((Region region, Size size, Buffer **dBuf));
S16 SIncMsgRef(Buffer *srcBuf,Region dstRegion, Pool dstPool,Buffer **dstBuf);
#ifdef SSI_STATIC_MEM_LEAK_DETECTION
-EXTERN U32 GetNextFreeIdx ARGS((StaticMemAllocInfo * memAllocInfo));
+EXTERN uint32_t GetNextFreeIdx ARGS((StaticMemAllocInfo * memAllocInfo));
EXTERN void LogForStaticMemLeak ARGS((StaticMemAllocInfo* memAllocInfo, char*
- file, U32 line, U32 size, void* ptr, U32 idx));
-EXTERN void FreeIdx ARGS((U8* ptr, U32 idx, StaticMemAllocInfo*
- memAllocInfo,U32 size, char* file, U32 line));
+ file, uint32_t line, uint32_t size, void* ptr, uint32_t idx));
+EXTERN void FreeIdx ARGS((uint8_t* ptr, uint32_t idx, StaticMemAllocInfo*
+ memAllocInfo,uint32_t size, char* file, uint32_t line));
#endif
#ifdef SS_USE_ZBC_MEMORY
#ifdef T2K_MEM_LEAK_DBG
-PRIVATE S16 SPutZbcDBufNew ARGS((Region region, Buffer *buf,char*,U32));
+PRIVATE S16 SPutZbcDBufNew ARGS((Region region, Buffer *buf,char*,uint32_t));
#else
PRIVATE S16 SPutZbcDBuf ARGS((Region region, Buffer *buf));
#ifdef SS_M_PROTO_REGION
#ifdef T2K_MEM_LEAK_DBG
#define DupMsg(region,buffer) DupMsgNew(region,buffer,file,line)
-PRIVATE Buffer *DupMsgNew ARGS((Region region, Buffer *buffer,char*,U32));
+PRIVATE Buffer *DupMsgNew ARGS((Region region, Buffer *buffer,char*,uint32_t));
#else
#ifdef INTEL_WLS
#ifdef T2K_MEM_LEAK_DBG
S16 SAttachPtrToMBuf1 ARGS(( Region region, Pool pool, Data *ptr, MsgLen totalLen,
- MsgLen ptrLen, Buffer** mBuf, char* file, U32 line));
+ MsgLen ptrLen, Buffer** mBuf, char* file, uint32_t line));
#else
S16 SAttachPtrToMBuf ARGS(( Region region, Pool pool, Data *ptr, MsgLen totalLen,
MsgLen ptrLen, Buffer** mBuf));
#ifdef T2K_MEM_LEAK_DBG
S16 SAttachWlsPtrToMBuf1 ARGS(( Region region, Pool pool, Data *ptr,
Data *readPtr, MsgLen totalLen,
- MsgLen ptrLen, Buffer** mBuf, char* file, U32 line));
+ MsgLen ptrLen, Buffer** mBuf, char* file, uint32_t line));
S16 SAttachWlsPtrToMBuf ARGS(( Region region, Pool pool, Data *ptr,
Data *readPtr, MsgLen totalLen,
EXTERN pthread_t tmpRegTidMap[20];
#define CM_MEM_GET_REGION(_region) \
{ \
- U8 _regCnt; \
+ uint8_t _regCnt; \
_region = 0xFF; \
\
for(_regCnt = 0; _regCnt < 12; _regCnt++) \
Size size,
Buffer **dBuf,
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
/* ss006.301 : optmized this function */
mdsize = MDBSIZE + size;
#ifdef SS_HISTOGRAM_SUPPORT
- if (SAlloc(region, &mdsize, 0, (Data **) dBuf, __LINE__, (U8*) __FILE__, ENTNC) != ROK)
+ if (SAlloc(region, &mdsize, 0, (Data **) dBuf, __LINE__, (uint8_t*) __FILE__, ENTNC) != ROK)
#else
if (SAlloc(region, &mdsize, 0, (Data **) dBuf) != ROK)
#endif /* SS_HISTOGRAM_SUPPORT */
Region region, /* region id */
Pool pool, /* pool id */
Buffer **mBuf, /* pointer to message buffer */
-U32 line,
-U8 *fileName
+uint32_t line,
+uint8_t *fileName
)
#else
S16 SGetMsgNew(region, pool, mBuf, line, fileName)
Region region; /* region id */
Pool pool; /* pool id */
Buffer **mBuf; /* pointer to message buffer */
-U32 line;
-U8 *fileName;
+uint32_t line;
+uint8_t *fileName;
#endif
#else /* SS_HISTOGRAM_SUPPORT */
#ifdef T2K_MEM_LEAK_DBG
Pool pool, /* pool id */
Buffer **mBuf, /* pointer to message buffer */
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
S16 SPutMsgNew
(
Buffer *mBuf,
-U32 line,
-U8 *fileName
+uint32_t line,
+uint8_t *fileName
)
#else
S16 SPutMsgNew(mBuf, line, fileName)
Buffer *mBuf;
-U32 line;
-U8 *fileName;
+uint32_t line;
+uint8_t *fileName;
#endif
#else /* SS_HISTOGRAM_SUPPORT */
#ifdef T2K_MEM_LEAK_DBG
(
Buffer *mBuf,
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
Buffer *tmp;
SsMsgInfo *minfo;
#ifdef SS_MEM_WL_DEBUG
- U8 tmpThrReg;
+ uint8_t tmpThrReg;
#endif
/* ss001.301: additions */
Pool pool, /* pool ID */
Data *ptr, /* pointer to buffer */
Size size, /* size */
-U8 memType, /* memory type used if shareable or not */
+uint8_t memType, /* memory type used if shareable or not */
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
Pool pool, /* pool ID */
Data *ptr, /* pointer to buffer */
Size size, /* size */
-U8 memType /* memory type used if shareable or not */
+uint8_t memType /* memory type used if shareable or not */
)
#else
S16 SPutStaticBuffer(region, pool, ptr, size)
Pool pool; /* pool ID */
Data *ptr; /* pointer to buffer */
Size size; /* size */
-U8 memType; /* memory type used if shareable or not */
+uint8_t memType; /* memory type used if shareable or not */
#endif
#endif
{
Pool pool, /* pool ID */
Data **ptr, /* pointer to buffer */
Size size, /* size requested */
-U8 memType, /* memory type used if shareable or not */
+uint8_t memType, /* memory type used if shareable or not */
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
Pool pool, /* pool ID */
Data **ptr, /* pointer to buffer */
Size size, /* size requested */
-U8 memType /* memory type used if shareable or not */
+uint8_t memType /* memory type used if shareable or not */
)
#else
S16 SGetStaticBuffer(region, pool, ptr, size)
Pool pool; /* pool ID */
Data **ptr; /* pointer to buffer */
Size size; /* size requested */
-U8 memType; /* memory type used if shareable or not */
+uint8_t memType; /* memory type used if shareable or not */
#endif
#endif
{
S16 ret = RFAILED;
- U32 flags;
+ uint32_t flags;
#if (ERRCLASS & ERRCLS_INT_PAR)
/* validate region ID */
Pool pool, /* pool ID */
Data **ptr, /* pointer to buffer */
Size size, /* size requested */
-U8 memType /* memory type used if shareable or not */
+uint8_t memType /* memory type used if shareable or not */
)
#else
S16 SGetStaticBuffer(region, pool, ptr, size)
Pool pool; /* pool ID */
Data **ptr; /* pointer to buffer */
Size size; /* size requested */
-U8 memType; /* memory type used if shareable or not */
+uint8_t memType; /* memory type used if shareable or not */
#endif
{
S16 ret;
Pool pool, /* pool ID */
Data *ptr, /* pointer to buffer */
Size size, /* size */
-U8 memType /* memory type used if shareable or not */
+uint8_t memType /* memory type used if shareable or not */
)
#else
S16 SPutStaticBuffer(region, pool, ptr, size)
Pool pool; /* pool ID */
Data *ptr; /* pointer to buffer */
Size size; /* size */
-U8 memType; /* memory type used if shareable or not */
+uint8_t memType; /* memory type used if shareable or not */
#endif
{
Data **ptr, /* pointer to buffer */
Size size, /* size requested */
char* file,
-U32 line
+uint32_t line
)
#else
S16 SGetSBufWls
{
S16 ret;
#ifndef SS_LOCKLESS_MEMORY
- U32 flags = 0;
+ uint32_t flags = 0;
#endif
#ifdef SS_LOCKLESS_MEMORY
Data *ptr, /* pointer to buffer */
Size size, /* size */
char* file,
-U32 line
+uint32_t line
)
#else
S16 SPutSBufWls
Pool pool, /* pool ID */
Data **ptr, /* pointer to buffer */
Size size, /* size requested */
-U32 line,
-U8 *fileName
+uint32_t line,
+uint8_t *fileName
)
#else
S16 SGetSBufNew(region, pool, ptr, size, line, fileName)
Pool pool; /* pool ID */
Data **ptr; /* pointer to buffer */
Size size; /* size requested */
-U32 line;
-U8 *fileName;
+uint32_t line;
+uint8_t *fileName;
#endif
#else /* SS_HISTOGRAM_SUPPORT */
#if (defined(SSI_STATIC_MEM_LEAK_DETECTION) || defined(T2K_MEM_LEAK_DBG))
Data **ptr, /* pointer to buffer */
Size size, /* size requested */
char* file,
-U32 line
+uint32_t line
)
#else
S16 SGetSBuf1(region, pool, ptr, size, file, line)
Data **ptr; /* pointer to buffer */
Size size; /* size requested */
char* file;
-U32 line;
+uint32_t line;
#endif
#else
#ifdef ANSI
#endif /* SS_HISTOGRAM_SUPPORT */
{
S16 ret;
- U32 flags;
+ uint32_t flags;
#ifdef SSI_STATIC_MEM_LEAK_DETECTION
Size tmpSize;
#endif
#ifdef XEON_SPECIFIC_CHANGES
pthread_mutex_lock(&(memLock));
#endif
- U32 idx = GetNextFreeIdx(&SMemLeakInfo[region]);
- U8* allocatedPtr = *ptr;
+ uint32_t idx = GetNextFreeIdx(&SMemLeakInfo[region]);
+ uint8_t* allocatedPtr = *ptr;
void* actualPtr = allocatedPtr + 4;
*ptr = actualPtr;
/* store the index in the memory allocated itself */
- /**((U32*)*((U32*)allocatedPtr)) = idx;*/
- *((U32*)allocatedPtr) = idx;
- /*printf("region = %d idx = %d ptr = %p *ptr = %p actual = %p allocated = %p content = %d\n",region, idx, ptr, *ptr, actualPtr, allocatedPtr, *((U32*)allocatedPtr));*/
+ /**((uint32_t*)*((uint32_t*)allocatedPtr)) = idx;*/
+ *((uint32_t*)allocatedPtr) = idx;
+ /*printf("region = %d idx = %d ptr = %p *ptr = %p actual = %p allocated = %p content = %d\n",region, idx, ptr, *ptr, actualPtr, allocatedPtr, *((uint32_t*)allocatedPtr));*/
LogForStaticMemLeak(&SMemLeakInfo[region],
file,
Pool pool, /* pool ID */
Data *ptr, /* pointer to buffer */
Size size, /* size */
-U32 line,
-U8 *fileName
+uint32_t line,
+uint8_t *fileName
)
#else
S16 SPutSBufNew(region, pool, ptr, size, line, fileName)
Pool pool; /* pool ID */
Data *ptr; /* pointer to buffer */
Size size; /* size */
-U32 line;
-U8 *fileName;
+uint32_t line;
+uint8_t *fileName;
#endif
#else /* SS_HISTOGRAM_SUPPORT */
#if (defined(SSI_STATIC_MEM_LEAK_DETECTION) || defined(T2K_MEM_LEAK_DBG))
Data *ptr, /* pointer to buffer */
Size size, /* size */
char* file,
-U32 line
+uint32_t line
)
#else
S16 SPutSBuf1(region, pool, ptr, size, file, line)
Data *ptr; /* pointer to buffer */
Size size; /* size */
char* file;
-U32 line;
+uint32_t line;
#endif
#else
#ifdef ANSI
#ifdef XEON_SPECIFIC_CHANGES
pthread_mutex_lock(&(memLock));
#endif
- U32 idx = *((U32*)((U8 *)ptr - 4));
+ uint32_t idx = *((uint32_t*)((uint8_t *)ptr - 4));
FreeIdx(ptr,idx,&SMemLeakInfo[region],size,file,line);
#ifdef XEON_SPECIFIC_CHANGES
pthread_mutex_unlock(&(memLock));
{
SsMsgInfo *minfo;
Buffer *tmp;
- U8 tmpRegId;
+ uint8_t tmpRegId;
#if (ERRCLASS & ERRCLS_INT_PAR)
/* check message buffer */
#if 1
#ifdef T2K_MEM_LEAK_DBG
char * file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
#endif
(Void) SPutDBuf(tmpRegId, minfo->pool, tmp);
prevblk = prevblk->b_cont;
#ifdef T2K_MEM_LEAK_DBG
char * file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
#endif
(Void) SPutDBuf(minfo->region, minfo->pool, curblk);
MsgLen cnt,
Buffer *mBuf,
char *file,
-U32 line
+uint32_t line
)
#else
MsgLen cnt,
Buffer *mBuf,
char *file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
Buffer *tmp;
#ifdef T2K_MEM_LEAK_DBG
char* file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
Buffer *last;
#ifdef T2K_MEM_LEAK_DBG
char* file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
MsgLen numBytes;
#ifdef T2K_MEM_LEAK_DBG
char* file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
#endif
Data *cptr;
#ifdef T2K_MEM_LEAK_DBG
char* file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
#endif
MsgLen idx, /* index */
Buffer **mBuf2,
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
Pool dstPool,
Buffer **dstBuf,
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
Pool dstPool,
Buffer **dstBuf,
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
Region region, /* region id */
Buffer *mp, /* message block */
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
#endif /* SS_MULTICORE_SUPPORT */
/* ss001.301: additions */
#ifdef SS_HISTOGRAM_SUPPORT
- r = SAlloc(region, &m, 0, (Data **)&bp, __LINE__, (U8*) __FILE__, ENTNC);
+ r = SAlloc(region, &m, 0, (Data **)&bp, __LINE__, (uint8_t*) __FILE__, ENTNC);
#else
r = SAlloc(region, &m, 0, (Data **)&bp);
#endif /* SS_HISTOGRAM_SUPPORT */
/* generic set-up-message function */
#if 1
#ifndef SS_DBUF_REFLOCK_DISABLE
- SS_STRM_INITB(bp, (SsDblk *)(((U8 *)bp) + sizeof(SsMblk)), NULLP, 0, NULLP);
+ SS_STRM_INITB(bp, (SsDblk *)(((uint8_t *)bp) + sizeof(SsMblk)), NULLP, 0, NULLP);
#endif
#else
data = (Data *) (bp) + MDBSIZE;
- SS_STRM_INITB(bp,(SsDblk *)(((U8 *)bp) + sizeof(SsMblk)), data, numBytes, NULLP);
+ SS_STRM_INITB(bp,(SsDblk *)(((uint8_t *)bp) + sizeof(SsMblk)), data, numBytes, NULLP);
#endif /* SS_MULTICORE_SUPPORT */
Pool pool, /* pool id */
Buffer **bufPtr,
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
/* ss006.301 : optimized this function */
/* ss001.301: additions */
#ifdef SS_HISTOGRAM_SUPPORT
- if (SAlloc(region, &mdsize, 0, (Data **) bufPtr, __LINE__, (U8*) __FILE__, ENTNC) != ROK)
+ if (SAlloc(region, &mdsize, 0, (Data **) bufPtr, __LINE__, (uint8_t*) __FILE__, ENTNC) != ROK)
#else
if (SAlloc(region, &mdsize, 0, (Data **) bufPtr) != ROK)
#endif /* SS_HISTOGRAM_SUPPORT */
Pool pool,
Buffer *buf,
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
/* if the data block is not shared, free the buffer, checks not reqd */
#ifdef SS_HISTOGRAM_SUPPORT
ret = SFree(region, (Data *) buf, MDBSIZE + dptr->db_lim - dptr->db_base
- , __LINE__, (U8*) __FILE__, ENTNC);
+ , __LINE__, (uint8_t*) __FILE__, ENTNC);
#else
ret = SFree(region, (Data *) buf, MDBSIZE + dptr->db_lim - dptr->db_base);
#endif /* SS_HISTOGRAM_SUPPORT */
if (buf != (SsMblk *) (((Data*) dptr) - MBSIZE))
{
- SsDblk* dupdptr = (SsDblk *)((U8 *)buf + MBSIZE);
+ SsDblk* dupdptr = (SsDblk *)((uint8_t *)buf + MBSIZE);
dupdptr->db_ref--;
if(dupdptr->db_ref == 0)
{
#ifdef SS_HISTOGRAM_SUPPORT
- ret = SFree(region, (Data *) buf, MDBSIZE, __LINE__, (U8*) __FILE__, ENTNC);
+ ret = SFree(region, (Data *) buf, MDBSIZE, __LINE__, (uint8_t*) __FILE__, ENTNC);
#else
ret = SFree(region, (Data *) buf, MDBSIZE);
/* free buffer to region */
#ifdef SS_HISTOGRAM_SUPPORT
ret = SFree(region, (Data *) buf, MDBSIZE + dptr->db_lim - dptr->db_base
- , __LINE__, (U8*) __FILE__, ENTNC);
+ , __LINE__, (uint8_t*) __FILE__, ENTNC);
#else
ret = SFree(region, (Data *) buf, MDBSIZE + dptr->db_lim - dptr->db_base);
#endif /* SS_HISTOGRAM_SUPPORT */
/* If MultiCore Support enabled, Dblk never be shared */
#ifdef SS_HISTOGRAM_SUPPORT
ret = SFree(region, (Data *) buf, MDBSIZE + dptr->db_lim - dptr->db_base
- , __LINE__, (U8*) __FILE__, ENTNC);
+ , __LINE__, (uint8_t*) __FILE__, ENTNC);
#else
ret = SFree(region, (Data *) buf, MDBSIZE + dptr->db_lim - dptr->db_base);
#endif /* SS_HISTOGRAM_SUPPORT */
#ifdef T2K_MEM_LEAK_DBG
char* file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
#endif
#if ( ERRCLASS & ERRCLS_INT_PAR)
/* check message buffer */
#ifdef T2K_MEM_LEAK_DBG
char* file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
MsgLen i; /* counter */
S16 j; /* counter */
S16 k; /* counter */
- U8 data; /* data */
- U8 tdata[16] = {0}; /* temporary data */
+ uint8_t data; /* data */
+ uint8_t tdata[16] = {0}; /* temporary data */
S8 prntBuf[256]; /* print buffer */
Buffer *tmp; /* buffer ptr */
Data *cptr;
reg = ((SsMsgInfo*)(mBuf->b_rptr))->region;
/*ss013.301: Fixed Warnings for 32/64 bit compilation*/
sprintf(prntBuf,"\nmsg: qlen: %04d mlen: %04d %02d-->%02d region: %02d\n",
- (U16)qlen,(U16)mlen,src,dst,reg);
+ (uint16_t)qlen,(uint16_t)mlen,src,dst,reg);
SPrint( prntBuf);
#ifdef XEON_SPECIFIC_CHANGES
printf("%s\n", prntBuf);
{
/* print hex */
tdata[j]=data;
- sprintf( prntBuf,"%02x ",(U16) data);
+ sprintf( prntBuf,"%02x ",(uint16_t) data);
SPrint( prntBuf);
#ifdef XEON_SPECIFIC_CHANGES
printf("%s\n", prntBuf);
S16 SAlignDBuf
(
Buffer *dBuf, /* data buffer */
-U32 align /* alignemnt required */
+uint32_t align /* alignemnt required */
)
#else
S16 SAlignDBuf(dBuf, align)
Buffer *dBuf; /* data buffer */
-U32 align; /* alignemnt required */
+uint32_t align; /* alignemnt required */
#endif
{
MsgLen len;
Data *src;
- U32 upShift; /* no. of bytes to be shifted up */
- U32 downShift; /* no. of bytes to be shifted down */
+ uint32_t upShift; /* no. of bytes to be shifted up */
+ uint32_t downShift; /* no. of bytes to be shifted down */
#if (ERRCLASS & ERRCLS_INT_PAR)
if (!dBuf)
SsMsgInfo *minfo2;
#endif
Buffer *tmp;
- U8 tmp2;
+ uint8_t tmp2;
#if (ERRCLASS & ERRCLS_INT_PAR)
minfoPtr->next = (Buffer*)cvmx_ptr_to_phys (minfoPtr->next);
}
- curPtr->b_rptr = (U8*)cvmx_ptr_to_phys (curPtr->b_rptr);
+ curPtr->b_rptr = (uint8_t*)cvmx_ptr_to_phys (curPtr->b_rptr);
- curPtr->b_wptr = (U8*)cvmx_ptr_to_phys (curPtr->b_wptr);
+ curPtr->b_wptr = (uint8_t*)cvmx_ptr_to_phys (curPtr->b_wptr);
/* Convert the pointers of Dblock to Physical addr */
dblkPtr = (SsDblk*)curPtr->b_datap;
}
#endif
- dblkPtr->db_base = (U8*)cvmx_ptr_to_phys (dblkPtr->db_base);
- dblkPtr->db_lim = (U8*)cvmx_ptr_to_phys (dblkPtr->db_lim);
+ dblkPtr->db_base = (uint8_t*)cvmx_ptr_to_phys (dblkPtr->db_base);
+ dblkPtr->db_lim = (uint8_t*)cvmx_ptr_to_phys (dblkPtr->db_lim);
curPtr->b_datap = (SsDblk*)cvmx_ptr_to_phys (curPtr->b_datap);
curPtr->b_cont = (Buffer*)cvmx_ptr_to_phys (curPtr->b_cont);
}
- curPtr->b_rptr = (U8*)cvmx_ptr_to_phys (curPtr->b_rptr);
- curPtr->b_wptr = (U8*)cvmx_ptr_to_phys (curPtr->b_wptr);
+ curPtr->b_rptr = (uint8_t*)cvmx_ptr_to_phys (curPtr->b_rptr);
+ curPtr->b_wptr = (uint8_t*)cvmx_ptr_to_phys (curPtr->b_wptr);
/* Convert the pointers of Dblock to Physical addr */
dblkPtr = (SsDblk*)curPtr->b_datap;
}
#endif
- dblkPtr->db_base = (U8*)cvmx_ptr_to_phys (dblkPtr->db_base);
- dblkPtr->db_lim = (U8*)cvmx_ptr_to_phys (dblkPtr->db_lim);
+ dblkPtr->db_base = (uint8_t*)cvmx_ptr_to_phys (dblkPtr->db_base);
+ dblkPtr->db_lim = (uint8_t*)cvmx_ptr_to_phys (dblkPtr->db_lim);
curPtr->b_datap = (SsDblk*)cvmx_ptr_to_phys (curPtr->b_datap);
}
/* Convert the buffer address to pointer */
- mBuf = (Buffer*)cvmx_phys_to_ptr ((U64)(*workPtr));
+ mBuf = (Buffer*)cvmx_phys_to_ptr ((uint64_t)(*workPtr));
curPtr = mBuf;
/* first block is mblk */
if (curPtr->b_next)
{
- curPtr->b_next = (Buffer*)cvmx_phys_to_ptr ((U64)curPtr->b_next);
+ curPtr->b_next = (Buffer*)cvmx_phys_to_ptr ((uint64_t)curPtr->b_next);
}
if (curPtr->b_prev)
{
- curPtr->b_prev = (Buffer*)cvmx_phys_to_ptr ((U64)curPtr->b_prev);
+ curPtr->b_prev = (Buffer*)cvmx_phys_to_ptr ((uint64_t)curPtr->b_prev);
}
if(curPtr->b_cont)
{
- curPtr->b_cont = (Buffer*)cvmx_phys_to_ptr ((U64)curPtr->b_cont);
+ curPtr->b_cont = (Buffer*)cvmx_phys_to_ptr ((uint64_t)curPtr->b_cont);
}
- curPtr->b_rptr = (U8*)cvmx_phys_to_ptr ((U64)curPtr->b_rptr);
+ curPtr->b_rptr = (uint8_t*)cvmx_phys_to_ptr ((uint64_t)curPtr->b_rptr);
/* Get the pointer for minfo */
minfoPtr = (SsMsgInfo*)curPtr->b_rptr;
if (minfoPtr->endptr)
{
- minfoPtr->endptr = (Buffer*)cvmx_phys_to_ptr ((U64)minfoPtr->endptr);
+ minfoPtr->endptr = (Buffer*)cvmx_phys_to_ptr ((uint64_t)minfoPtr->endptr);
}
if (minfoPtr->next)
{
- minfoPtr->next = (Buffer*)cvmx_phys_to_ptr ((U64)minfoPtr->next);
+ minfoPtr->next = (Buffer*)cvmx_phys_to_ptr ((uint64_t)minfoPtr->next);
}
- curPtr->b_wptr = (U8*)cvmx_phys_to_ptr ((U64)curPtr->b_wptr);
+ curPtr->b_wptr = (uint8_t*)cvmx_phys_to_ptr ((uint64_t)curPtr->b_wptr);
- curPtr->b_datap = (SsDblk*)cvmx_phys_to_ptr ((U64)curPtr->b_datap);
+ curPtr->b_datap = (SsDblk*)cvmx_phys_to_ptr ((uint64_t)curPtr->b_datap);
/* Get the Dblock pointers */
dblkPtr = (SsDblk*)curPtr->b_datap;
#ifdef SS_DBLK_FREE_RTN
if (dblkPtr->db_frtnp)
{
- dblkPtr->db_frtnp = (SsFrtn*)cvmx_phys_to_ptr ((U64)dblkPtr->db_frtnp);
+ dblkPtr->db_frtnp = (SsFrtn*)cvmx_phys_to_ptr ((uint64_t)dblkPtr->db_frtnp);
frtnPtr = dblkPtr->db_frtnp;
if (frtnPtr->free_func)
{
- frtnPtr->free_func = cvmx_phys_to_ptr ((U64)frtnPtr->free_func);
+ frtnPtr->free_func = cvmx_phys_to_ptr ((uint64_t)frtnPtr->free_func);
}
if (frtnPtr->free_arg)
{
- frtnPtr->free_arg = (S8*)cvmx_phys_to_ptr ((U64)frtnPtr->free_arg);
+ frtnPtr->free_arg = (S8*)cvmx_phys_to_ptr ((uint64_t)frtnPtr->free_arg);
}
}
#endif
- dblkPtr->db_base = (U8*)cvmx_phys_to_ptr ((U64)dblkPtr->db_base);
- dblkPtr->db_lim = (U8*)cvmx_phys_to_ptr ((U64)dblkPtr->db_lim);
+ dblkPtr->db_base = (uint8_t*)cvmx_phys_to_ptr ((uint64_t)dblkPtr->db_base);
+ dblkPtr->db_lim = (uint8_t*)cvmx_phys_to_ptr ((uint64_t)dblkPtr->db_lim);
curPtr = curPtr->b_cont;
{
if(curPtr->b_cont)
{
- curPtr->b_cont = (Buffer*)cvmx_phys_to_ptr ((U64)curPtr->b_cont);
+ curPtr->b_cont = (Buffer*)cvmx_phys_to_ptr ((uint64_t)curPtr->b_cont);
}
- curPtr->b_rptr = (U8*)cvmx_phys_to_ptr ((U64)curPtr->b_rptr);
+ curPtr->b_rptr = (uint8_t*)cvmx_phys_to_ptr ((uint64_t)curPtr->b_rptr);
- curPtr->b_wptr = (U8*)cvmx_phys_to_ptr ((U64)curPtr->b_wptr);
+ curPtr->b_wptr = (uint8_t*)cvmx_phys_to_ptr ((uint64_t)curPtr->b_wptr);
- curPtr->b_datap = (SsDblk*)cvmx_phys_to_ptr ((U64)curPtr->b_datap);
+ curPtr->b_datap = (SsDblk*)cvmx_phys_to_ptr ((uint64_t)curPtr->b_datap);
/* Get the Dblock pointers */
dblkPtr = (SsDblk*)curPtr->b_datap;
#ifdef SS_DBLK_FREE_RTN
if (dblkPtr->db_frtnp)
{
- dblkPtr->db_frtnp = (SsFrtn*)cvmx_phys_to_ptr ((U64)dblkPtr->db_frtnp);
+ dblkPtr->db_frtnp = (SsFrtn*)cvmx_phys_to_ptr ((uint64_t)dblkPtr->db_frtnp);
frtnPtr = dblkPtr->db_frtnp;
if (frtnPtr->free_func)
{
- frtnPtr->free_func = cvmx_phys_to_ptr ((U64)frtnPtr->free_func);
+ frtnPtr->free_func = cvmx_phys_to_ptr ((uint64_t)frtnPtr->free_func);
}
if (frtnPtr->free_arg)
{
- frtnPtr->free_arg = (S8*)cvmx_phys_to_ptr ((U64)frtnPtr->free_arg);
+ frtnPtr->free_arg = (S8*)cvmx_phys_to_ptr ((uint64_t)frtnPtr->free_arg);
}
}
#endif
- dblkPtr->db_base = (U8*)cvmx_phys_to_ptr ((U64)dblkPtr->db_base);
- dblkPtr->db_lim = (U8*)cvmx_phys_to_ptr ((U64)dblkPtr->db_lim);
+ dblkPtr->db_base = (uint8_t*)cvmx_phys_to_ptr ((uint64_t)dblkPtr->db_base);
+ dblkPtr->db_lim = (uint8_t*)cvmx_phys_to_ptr ((uint64_t)dblkPtr->db_lim);
curPtr = curPtr->b_cont;
}
SsMsgInfo *minfoDst = NULLP;
SsDblk *dblkPtr = NULLP;
SsDblk *dptr = NULLP;
- U32 numBytes;
+ uint32_t numBytes;
Pool pool;
Buffer *fpaBuf;
#endif
{
- U16 size;
+ uint16_t size;
Buffer *curBlk;
Buffer *nextBlk;
SsDblk *dblkPtr;
SsMsgInfo *dMinfo;
#ifdef T2K_MEM_LEAK_DBG
char* file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
#endif
/* update the read ptr */
tmp->b_rptr -= numBytes;
/* copy data */
- memcpy((U8*)tmp->b_rptr, (src + cnt), numBytes);
+ memcpy(tmp->b_rptr, (src + cnt), numBytes);
minfo->len += numBytes;
if (!cnt)
{
newblk->b_datap->db_type = SS_M_DATA;
newblk->b_rptr = newblk->b_datap->db_lim - cnt;
newblk->b_wptr = newblk->b_datap->db_lim;
- memcpy((U8*)newblk->b_rptr, src, cnt);
+ memcpy(newblk->b_rptr, src, cnt);
/* attach the newblk chain into mBuf */
newblk->b_cont = tmp;
mBuf->b_cont = newblk;
S16 SGetReadPtr
(
Buffer *mBuf,
- U8** data,
+ uint8_t** data,
MsgLen *len
)
#else
S16 SGetReadPtr (mBuf, data, len)
Buffer *mBuf;
-U8** data;
+uint8_t** data;
MsgLen *len;
#endif
{
MsgLen totalLen,
Buffer** mBuf,
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
mdsize = MDBSIZE;
#ifdef SS_HISTOGRAM_SUPPORT
- if (SAlloc(region, &mdsize, 0, (Data **) &newblk, __LINE__, (U8*) __FILE__, ENTNC) != ROK)
+ if (SAlloc(region, &mdsize, 0, (Data **) &newblk, __LINE__, (uint8_t*) __FILE__, ENTNC) != ROK)
#else
if (SAlloc(region, &mdsize, 0, (Data **) &newblk) != ROK)
#endif /* SS_HISTOGRAM_SUPPORT */
Region region,
Buffer *buf,
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
#ifdef SS_HISTOGRAM_SUPPORT
ret = SFree(region, (Data *) buf->b_datap->db_base, bufLen, __LINE__,
- (U8*) __FILE__, ENTNC);
+ (uint8_t*) __FILE__, ENTNC);
#else
ret = SFree(region, (Data *) buf->b_datap->db_base, bufLen);
#endif /* SS_HISTOGRAM_SUPPORT */
/* if the data block is not shared, free the buffer, checks not reqd */
#ifdef SS_HISTOGRAM_SUPPORT
- ret = SFree(region, (Data *) buf, MDBSIZE, __LINE__, (U8*) __FILE__,
+ ret = SFree(region, (Data *) buf, MDBSIZE, __LINE__, (uint8_t*) __FILE__,
ENTNC);
#else
ret = SFree(region, (Data *) buf, MDBSIZE);
if (buf != (SsMblk *) (((Data*) dptr) - MBSIZE))
{
#ifdef SS_HISTOGRAM_SUPPORT
- ret = SFree(region, (Data *) buf, MDBSIZE, __LINE__, (U8*) __FILE__, ENTNC);
+ ret = SFree(region, (Data *) buf, MDBSIZE, __LINE__, (uint8_t*) __FILE__, ENTNC);
#else
ret = SFree(region, (Data *) buf, MDBSIZE);
#endif /* SS_HISTOGRAM_SUPPORT */
#endif
#ifdef SS_HISTOGRAM_SUPPORT
ret = SFree(region, (Data *) buf->b_datap->db_base, bufLen, __LINE__,
- (U8*) __FILE__, ENTNC);
+ (uint8_t*) __FILE__, ENTNC);
#else
ret = SFree(region, (Data *) buf->b_datap->db_base, bufLen);
#endif /* SS_HISTOGRAM_SUPPORT */
#ifdef SS_HISTOGRAM_SUPPORT
- ret = SFree(region, (Data *) buf, MDBSIZE, __LINE__, (U8*) __FILE__,
+ ret = SFree(region, (Data *) buf, MDBSIZE, __LINE__, (uint8_t*) __FILE__,
ENTNC);
#else
ret = SFree(region, (Data *) buf, MDBSIZE);
MsgLen ptrLen,
Buffer** mBuf,
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
mdsize = MDBSIZE;
#ifdef SS_HISTOGRAM_SUPPORT
- if (SAlloc(region, &mdsize, 0, (Data **) &newblk, __LINE__, (U8*) __FILE__, ENTNC) != ROK)
+ if (SAlloc(region, &mdsize, 0, (Data **) &newblk, __LINE__, (uint8_t*) __FILE__, ENTNC) != ROK)
#else
if (SAlloc(region, &mdsize, 0, (Data **) &newblk) != ROK)
#endif /* SS_HISTOGRAM_SUPPORT */
#endif
- RETVOID;
+ return;
}
#endif
MsgLen ptrLen,
Buffer** mBuf,
char* file,
-U32 line
+uint32_t line
)
#else
#ifdef ANSI
mdsize = MDBSIZE;
#ifdef SS_HISTOGRAM_SUPPORT
- if (SAlloc(region, &mdsize, 0, (Data **) &newblk, __LINE__, (U8*) __FILE__, ENTNC) != ROK)
+ if (SAlloc(region, &mdsize, 0, (Data **) &newblk, __LINE__, (uint8_t*) __FILE__, ENTNC) != ROK)
#else
if (SAlloc(region, &mdsize, 0, (Data **) &newblk) != ROK)
#endif /* SS_HISTOGRAM_SUPPORT */
#ifdef TENB_DPDK_BUF
-extern U32 numeTti;
+extern uint32_t numeTti;
S16 SGetSBufDpdk
(
)
{
S16 ret;
- U32 flags = 0;
+ uint32_t flags = 0;
ntl_free(mtGetNtlHdl(), ptr);
SsMsgInfo *minfo;
//msgBlk = mBuf->b_cont;
- //*ptr = msgBlk->b_rptr;;
- *ptr = mBuf->b_datap->db_base;;
+ //*ptr = msgBlk->b_rptr;
+ *ptr = mBuf->b_datap->db_base;
mBuf->b_cont = NULL;
return RFAILED;
}
- *ptr = msgBlk->b_rptr;;
+ *ptr = msgBlk->b_rptr;
mBuf->b_cont = NULL;
/* pool type -- dynamic or static */
-typedef U8 SsPoolType;
+typedef uint8_t SsPoolType;
/* event information--what kind of message is this */
typedef struct ssEventInfo
{
- U8 event; /* event type */
+ uint8_t event; /* event type */
union
{
struct
#ifdef ANSI
S16 oduUnpackUInt8
(
-U8 val, /* value */
+uint8_t val, /* value */
Buffer *mBuf /* message buffer */
)
#else
S16 oduUnpackUInt8(val, mBuf)
-U8 val; /* value */
+uint8_t val; /* value */
Buffer *mBuf; /* message buffer */
#endif
{
#ifdef ANSI
S16 oduUnpackUInt16
(
-U16 val, /* value */
+uint16_t val, /* value */
Buffer *mBuf /* message buffer */
)
#else
S16 oduUnpackUInt16(val, mBuf)
-U16 val; /* value */
+uint16_t val; /* value */
Buffer *mBuf; /* message buffer */
#endif
{
Buffer *mBuf; /* message buffer */
#endif
{
- U16 tmp; /* temporary value */
+ uint16_t tmp; /* temporary value */
Data pkArray[4]; /* packing array */
S16 ret; /* return code */
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp = (U16) GetHiWord(val);
+ tmp = (uint16_t) GetHiWord(val);
pkArray[0] = (Data) GetHiByte(tmp);
pkArray[1] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(val);
+ tmp = (uint16_t) GetLoWord(val);
pkArray[2] = (Data) GetHiByte(tmp);
pkArray[3] = (Data) GetLoByte(tmp);
#else /* forward compatibility, packing order */
- tmp = (U16) GetHiWord(val);
+ tmp = (uint16_t) GetHiWord(val);
pkArray[3] = (Data) GetHiByte(tmp);
pkArray[2] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(val);
+ tmp = (uint16_t) GetLoWord(val);
pkArray[1] = (Data) GetHiByte(tmp);
pkArray[0] = (Data) GetLoByte(tmp);
#endif
#ifdef ANSI
S16 oduUnpackUInt32
(
-U32 val, /* value */
+uint32_t val, /* value */
Buffer *mBuf /* message buffer */
)
#else
S16 oduUnpackUInt32(val, mBuf)
-U32 val; /* value */
+uint32_t val; /* value */
Buffer *mBuf; /* message buffer */
#endif
{
- U16 tmp; /* temporary value */
+ uint16_t tmp; /* temporary value */
Data pkArray[4]; /* packing array */
S16 ret; /* return code */
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp = (U16) GetHiWord(val);
+ tmp = (uint16_t) GetHiWord(val);
pkArray[0] = (Data) GetHiByte(tmp);
pkArray[1] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(val);
+ tmp = (uint16_t) GetLoWord(val);
pkArray[2] = (Data) GetHiByte(tmp);
pkArray[3] = (Data) GetLoByte(tmp);
#else /* forward compatibility, packing order */
- tmp = (U16) GetHiWord(val);
+ tmp = (uint16_t) GetHiWord(val);
pkArray[3] = (Data) GetHiByte(tmp);
pkArray[2] = (Data) GetLoByte(tmp);
- tmp = (U16) GetLoWord(val);
+ tmp = (uint16_t) GetLoWord(val);
pkArray[1] = (Data) GetHiByte(tmp);
pkArray[0] = (Data) GetLoByte(tmp);
#endif
#ifdef ANSI
S16 oduPackUInt8
(
-U8 *val, /* pointer to value */
+uint8_t *val, /* pointer to value */
Buffer *mBuf /* message buffer */
)
#else
S16 oduPackUInt8(val, mBuf)
-U8 *val; /* pointer to value */
+uint8_t *val; /* pointer to value */
Buffer *mBuf; /* message buffer */
#endif
{
if (ret != ROK)
SSLOGERROR(ERRCLS_DEBUG, ESS253, (ErrVal)ret, "SRemPreMsg() failed");
#endif
- *val = (U8) tmp;
+ *val = (uint8_t) tmp;
return (ret);
} /* end of oduPackUInt8 */
\f
Buffer *mBuf; /* message buffer */
#endif
{
- U16 tmp16; /* temporary value */
+ uint16_t tmp16; /* temporary value */
Data unpkArray[2]; /* unpacking array */
S16 ret; /* return code */
#endif
tmp16 = 0;
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
#else /* forward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
#endif
*val = (S16) tmp16;
return (ret);
#ifdef ANSI
S16 oduPackUInt16
(
-U16 *val, /* pointer to value */
+uint16_t *val, /* pointer to value */
Buffer *mBuf /* message buffer */
)
#else
S16 oduPackUInt16(val, mBuf)
-U16 *val; /* pointer to value */
+uint16_t *val; /* pointer to value */
Buffer *mBuf; /* message buffer */
#endif
{
- U16 tmp16; /* temporary value */
+ uint16_t tmp16; /* temporary value */
Data unpkArray[2]; /* unpacking array */
S16 ret; /* return code */
#endif
tmp16 = 0;
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
#else /* forward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
#endif
*val = tmp16;
return (ret);
Buffer *mBuf; /* message buffer */
#endif
{
- U16 tmp16; /* temporary value */
- U32 tmp32; /* temporary value */
+ uint16_t tmp16; /* temporary value */
+ uint32_t tmp32; /* temporary value */
Data unpkArray[4]; /* unpacking array */
S16 ret; /* return code */
tmp16 = 0;
tmp32 = 0;
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[3]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[2]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[3]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[2]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
#else /* forward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[2]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[3]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[2]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[3]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
#endif
*val = (S32) tmp32;
return (ret);
#ifdef ANSI
S16 oduPackUInt32
(
-U32 *val, /* pointer to value */
+uint32_t *val, /* pointer to value */
Buffer *mBuf /* message buffer */
)
#else
S16 oduPackUInt32(val, mBuf)
-U32 *val; /* pointer to value */
+uint32_t *val; /* pointer to value */
Buffer *mBuf; /* message buffer */
#endif
{
- U16 tmp16; /* temporary value */
- U32 tmp32; /* temporary value */
+ uint16_t tmp16; /* temporary value */
+ uint32_t tmp32; /* temporary value */
Data unpkArray[4]; /* unpacking array */
#ifdef ERRCLASS
S16 ret; /* return code */
tmp16 = 0;
tmp32 = 0;
#ifndef FCSPKINT /* backward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[3]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[2]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[1]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[0]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[3]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[2]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
#else /* forward compatibility, packing order */
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[0]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[1]);
- tmp32 = (U32) PutHiWord(tmp32, (U16) tmp16);
- tmp16 = (U16) PutHiByte(tmp16, (U8) unpkArray[2]);
- tmp16 = (U16) PutLoByte(tmp16, (U8) unpkArray[3]);
- tmp32 = (U32) PutLoWord(tmp32, (U16) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[0]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[1]);
+ tmp32 = (uint32_t) PutHiWord(tmp32, (uint16_t) tmp16);
+ tmp16 = (uint16_t) PutHiByte(tmp16, (uint8_t) unpkArray[2]);
+ tmp16 = (uint16_t) PutLoByte(tmp16, (uint8_t) unpkArray[3]);
+ tmp32 = (uint32_t) PutLoWord(tmp32, (uint16_t) tmp16);
#endif
*val = tmp32;
return (ret);
#ifdef T2K_MEM_LEAK_DBG
char* file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
#endif
SsDmndQ *dQueue; /* Demand Queue */
#endif
{
- U8 i;
+ uint8_t i;
S16 ret;
SsDmndQ *dQueue; /* demand Queue */
#endif
{
- U8 i;
+ uint8_t i;
Buffer *tBuf;
S16 ret;
#endif
{
#ifndef TENB_RTLIN_CHANGES
- U8 maskIndex; /* mask Index */
- U8 bitPosition; /* bit position in index */
+ uint8_t maskIndex; /* mask Index */
+ uint8_t bitPosition; /* bit position in index */
#else
- U8 qIndex;
+ uint8_t qIndex;
#endif
Queue *queue; /* queue in demand queue */
S16 ret; /* return value */
#ifdef SS_PERF
int value;
- U32 size;
+ uint32_t size;
#endif
#ifdef MSPD_MLOG_NEW
- U32 t = MacGetTick();
+ uint32_t t = MacGetTick();
#endif
S16 ret;
S16 i;
#ifndef TENB_RTLIN_CHANGES
- U8 bitPosition;
- U8 qIndex;
+ uint8_t bitPosition;
+ uint8_t qIndex;
#endif
{
S16 ret; /* return value */
- U8 i;
+ uint8_t i;
#if (ERRCLASS & ERRCLS_INT_PAR)
* bitmask */
Queue queue[SS_MAX_NUM_DQ]; /* the queues */
#ifndef TENB_RTLIN_CHANGES
- U8 bitMask[SS_DQ_BIT_MASK_LEN]; /* bit mask */
+ uint8_t bitMask[SS_DQ_BIT_MASK_LEN]; /* bit mask */
#endif
} SsDmndQ;
#include "ss_rbuf.h"
#include "ss_rbuf.x"
-U32 ssRngBufStatus = 0;
+uint32_t ssRngBufStatus = 0;
/* Global Ring Loop Up Table */
SsRngBufTbl SsRngInfoTbl[SS_RNG_BUF_MAX];
#ifdef ANSI
S16 SCreateSRngBuf
(
-U32 id,
+uint32_t id,
Region region,
Pool pool,
-U32 elmSize,
-U32 rngSize
+uint32_t elmSize,
+uint32_t rngSize
)
#else
S16 SCreateSRngBuf (id, region, pool, elmSize, rngSize)
-U32 id;
+uint32_t id;
Region region;
Pool pool;
-U32 elmSize;
-U32 rngSize;
+uint32_t elmSize;
+uint32_t rngSize;
#endif
{
SsRngBuf* ring;
#ifdef ANSI
S16 SAttachSRngBuf
(
-U32 id,
-U32 ent,
-U32 txRx
+uint32_t id,
+uint32_t ent,
+uint32_t txRx
)
#else
S16 SAttachSRngBuf (id, ent, txRx)
-U32 id;
-U32 ent;
-U32 txRx;
+uint32_t id;
+uint32_t ent;
+uint32_t txRx;
#endif
{
/* Retrive Buffer from Global Info Table */
#ifdef ANSI
S16 SConnectSRngBuf
(
-U32 id,
-U32 rxEnt
+uint32_t id,
+uint32_t rxEnt
)
#else
S16 SConnectSRngBuf (id, rxEnt)
-U32 id;
-U32 rxEnt;
+uint32_t id;
+uint32_t rxEnt;
#endif
{
/* Send to Reciever ENT*/
return (rBuf->write == rBuf->read);
}
-S16 isRngEmpty(U32 id)
+S16 isRngEmpty(uint32_t id)
{
return (IsEmpty(SsRngInfoTbl[id].r_addr));
}
#ifdef ANSI
S16 SEnqSRngBuf
(
-U32 id,
+uint32_t id,
Void* elem
)
#else
S16 SEnqSRngBuf(id,elem)
-U32 id;
+uint32_t id;
Void* elem;
#endif
{
- U8* w_ptr;
- U8 i=0;
- U8 *element = (U8 *)elem;
- U32 wrIndex;
+ uint8_t* w_ptr;
+ uint8_t i=0;
+ uint8_t *element = (uint8_t *)elem;
+ uint32_t wrIndex;
/* TBD To replace id with ring addr when SAttachSRngBuf is used*/
/* Retrive Buffer from Id */
SsRngBuf* ring = SsRngInfoTbl[id].r_addr;
return RFAILED;
}
/* TBD Avoid multiplication for optimisation */
- w_ptr = (U8*)ring->elem + (ring->write * ring->type);
+ w_ptr = (uint8_t*)ring->elem + (ring->write * ring->type);
/* TBD Avoid for loop - use memcpy */
for( i=0; i < ring->type; i++)
{
- *(U8*)w_ptr = *(U8*)element;
+ *(uint8_t*)w_ptr = *(uint8_t*)element;
w_ptr++;
- (U8*)element++;
+ (uint8_t*)element++;
}
/* Increment write index */
wrIndex = ring->write + 1 ;
#ifdef ANSI
S16 SGetNumElemInRng
(
-U32 id
+uint32_t id
)
#else
S16 SGetNumElemInRng (id)
-U32 id;
+uint32_t id;
#endif
{
#ifdef ANSI
S16 SDeqSRngBuf
(
-U32 id,
+uint32_t id,
Void *elem
)
#else
S16 SDeqSRngBuf (id,elem)
-U8 id;
+uint8_t id;
Void *elem;
#endif
{
- U8* r_ptr;
- U8 i=0;
- U8 *element = (U8 *)elem;
- U32 rdIndex;
+ uint8_t* r_ptr;
+ uint8_t i=0;
+ uint8_t *element = (uint8_t *)elem;
+ uint32_t rdIndex;
/* Retrive Buffer from Id*/
SsRngBuf* ring = SsRngInfoTbl[id].r_addr;
if(IsEmpty(ring))
SsRngInfoTbl[id].nReadFail++;
return RFAILED;
}
- r_ptr = (U8*)ring->elem + (ring->read * ring->type);
+ r_ptr = (uint8_t*)ring->elem + (ring->read * ring->type);
for(i=0; i<ring->type; i++)
{
- *(U8*)element = *r_ptr;
- (U8*)element++;
+ *(uint8_t*)element = *r_ptr;
+ (uint8_t*)element++;
r_ptr++;
}
// Avoiding % operation for wrap around
#ifdef ANSI
S16 SDestroySRngBuf
(
-U32 id,
+uint32_t id,
Region region,
Pool pool
)
#else
S16 SDestroySRngBuf(id, region, pool)
-U32 id;
+uint32_t id;
Region region;
Pool pool;
#endif
Void;
#endif
{
-U32 i;
+uint32_t i;
Txt prntBuf[100];
#ifdef ANSI
Void* SRngGetWIndx
(
-U32 rngId
+uint32_t rngId
)
#else
Void* SRngGetWIndx (rngId)
-U32 rngId;
+uint32_t rngId;
#endif
{
/* Retrive Buffer from Id*/
}
else
{
- return (((U8 *)ring->elem) + (ring->type * ring->write));
+ return (((uint8_t *)ring->elem) + (ring->type * ring->write));
}
}
#ifdef ANSI
Void* SRngGetRIndx
(
-U32 rngId
+uint32_t rngId
)
#else
Void* SRngGetRIndx (rngId)
-U32 rngId;
+uint32_t rngId;
#endif
{
/* Retrive Buffer from Id*/
}
else
{
- return (((U8 *)ring->elem) + (ring->type * ring->read));
+ return (((uint8_t *)ring->elem) + (ring->type * ring->read));
}
}
#ifdef ANSI
Void SRngIncrWIndx
(
-U32 rngId
+uint32_t rngId
)
#else
Void SRngIncrWIndx (rngId)
-U32 rngId;
+uint32_t rngId;
#endif
{
- U32 wrIndex;
+ uint32_t wrIndex;
/* Retrive Buffer from Id*/
SsRngBuf* ring = SsRngInfoTbl[rngId].r_addr;
wrIndex = ring->write + 1;
#ifdef ANSI
Void SRngIncrRIndx
(
-U32 rngId
+uint32_t rngId
)
#else
Void SRngIncrRIndx (rngId)
-U32 rngId;
+uint32_t rngId;
#endif
{
- U32 rdIndex;
+ uint32_t rdIndex;
/* Retrive Buffer from Id*/
SsRngBuf* ring = SsRngInfoTbl[rngId].r_addr;
rdIndex = ring->read + 1;
}
#ifdef XEON_SPECIFIC_CHANGES
#if (defined (MAC_FREE_RING_BUF) || defined (RLC_FREE_RING_BUF))
-S16 mtAddBufToRing(SsRngBufId ringId,void *bufPtr,U8 freeType)
+S16 mtAddBufToRing(SsRngBufId ringId,void *bufPtr,uint8_t freeType)
{
S16 ret1 = ROK;
#endif
extern Void SsRngBufEnable ARGS((Void));
extern Void SsRngBufDisable ARGS((Void));
-extern S16 SCreateSRngBuf ARGS((U32 id, Region region, Pool pool, U32 elmSize, U32 rngSize));
-extern S16 SDestroySRngBuf ARGS((U32 id, Region region, Pool pool));
-extern S16 SAttachSRngBuf ARGS((U32 id, U32 ent, U32 txRx));
-extern S16 SEnqSRngBuf ARGS((U32 id, Void* elem));
-extern S16 SDeqSRngBuf ARGS((U32 id, Void* elem));
-extern Void* SRngGetWIndx ARGS((U32 rngId));
-extern Void* SRngGetRIndx ARGS((U32 rngId));
-extern Void SRngIncrRIndx ARGS((U32 rngId));
-extern Void SRngIncrWIndx ARGS((U32 rngId));
-extern S16 isRngEmpty ARGS((U32 rngId));
-extern S16 SConnectSRngBuf ARGS((U32 id, U32 rxEnt));
-EXTERN S16 SGetNumElemInRng ARGS(( U32 id));
+extern S16 SCreateSRngBuf ARGS((uint32_t id, Region region, Pool pool, uint32_t elmSize, uint32_t rngSize));
+extern S16 SDestroySRngBuf ARGS((uint32_t id, Region region, Pool pool));
+extern S16 SAttachSRngBuf ARGS((uint32_t id, uint32_t ent, uint32_t txRx));
+extern S16 SEnqSRngBuf ARGS((uint32_t id, Void* elem));
+extern S16 SDeqSRngBuf ARGS((uint32_t id, Void* elem));
+extern Void* SRngGetWIndx ARGS((uint32_t rngId));
+extern Void* SRngGetRIndx ARGS((uint32_t rngId));
+extern Void SRngIncrRIndx ARGS((uint32_t rngId));
+extern Void SRngIncrWIndx ARGS((uint32_t rngId));
+extern S16 isRngEmpty ARGS((uint32_t rngId));
+extern S16 SConnectSRngBuf ARGS((uint32_t id, uint32_t rxEnt));
+EXTERN S16 SGetNumElemInRng ARGS(( uint32_t id));
extern S16 SPrintSRngStats ARGS((Void));
extern S16 pjBatchProc ARGS((Void));
-extern U32 ssRngBufStatus;
+extern uint32_t ssRngBufStatus;
#define SS_RNG_BUF_STATUS() ssRngBufStatus
/* Ring Buffer Structure */
typedef struct
{
- U32 size; /* Number of elements in a ring */
- U32 read; /* Read Index incremented by Deque operation */
- U32 write; /* Write index incremented by Enque operation */
- U32 type; /* sizeof user specified ring element structure */
+ uint32_t size; /* Number of elements in a ring */
+ uint32_t read; /* Read Index incremented by Deque operation */
+ uint32_t write; /* Write index incremented by Enque operation */
+ uint32_t type; /* sizeof user specified ring element structure */
Void* elem; /* pointer to the allocated ring Elements */
}SsRngBuf;
/* Ring Cfg Table */
typedef struct
{
- U32 rngSize;
- U32 elemSize;
+ uint32_t rngSize;
+ uint32_t elemSize;
} SsRngCfg;
/* Global Ring Buffer Info structure */
typedef struct
{
SsRngBuf* r_addr; // Address of allocated ring
- U32 txEnt; // Tx Entity id
- U32 rxEnt; // Rx Entity id
- U32 n_write; // Number of Enque operations
- U32 n_read; // Number of Deque operations
- U32 nReadFail; // Number of Deque failures due to ring empty
- U32 nWriteFail; // Number of Enque failures due to ring full
- U32 rngState; /* Ring Buffer State */
- U32 pktDrop; // Number of pkts dropped due to buffer full
- U32 nPktProc; // Debug counter for pkts processed per tti
- U32 pktRate; // Debug counter for icpu pkt rate
+ uint32_t txEnt; // Tx Entity id
+ uint32_t rxEnt; // Rx Entity id
+ uint32_t n_write; // Number of Enque operations
+ uint32_t n_read; // Number of Deque operations
+ uint32_t nReadFail; // Number of Deque failures due to ring empty
+ uint32_t nWriteFail; // Number of Enque failures due to ring full
+ uint32_t rngState; /* Ring Buffer State */
+ uint32_t pktDrop; // Number of pkts dropped due to buffer full
+ uint32_t nPktProc; // Debug counter for pkts processed per tti
+ uint32_t pktRate; // Debug counter for icpu pkt rate
} SsRngBufTbl;
/* Global Structure for updating Ring buffer for Flow Control */
typedef struct
{
- U16 dlRngBuffCnt; /* Dl Ring Buffer Count */
- U16 ulRngBuffCnt; /* Ul Ring Buffer Count */
+ uint16_t dlRngBuffCnt; /* Dl Ring Buffer Count */
+ uint16_t ulRngBuffCnt; /* Ul Ring Buffer Count */
}SsRngBufCnt;
/* Ring Buffer Id Enum */
EXTERN SsRngBufTbl SsRngInfoTbl[SS_RNG_BUF_MAX];
#if (defined (MAC_FREE_RING_BUF) || defined (RLC_FREE_RING_BUF))
-extern S16 mtAddBufToRing(SsRngBufId ringId,void *bufPtr,U8 freeType);
+extern S16 mtAddBufToRing(SsRngBufId ringId,void *bufPtr,uint8_t freeType);
#ifdef XEON_SPECIFIC_CHANGES
typedef struct rgKwBufFreeInfo
{
Void *bufToFree;
- U8 freeType; /* 0- SPutMsg, 1->SPutStaticBuffer*/
+ uint8_t freeType; /* 0- SPutMsg, 1->SPutStaticBuffer*/
}RgKwFreeInfo;
#endif
#endif
{
S32 n; /* counter */
S32 size; /* size of mblks of same type as head/tail */
- U8 type; /* message type */
+ uint8_t type; /* message type */
SsMblk *bp; /* mblk for iteration */
SsMblk *first; /* first mblk to be adjusted */
SsMblk *ssAllocB
(
S32 size, /* required size */
-U32 pri /* message priority */
+uint32_t pri /* message priority */
)
#else
SsMblk *ssAllocB(size, pri)
S32 size; /* required size */
-U32 pri; /* message priority */
+uint32_t pri; /* message priority */
#endif
{
SsMblk *bp; /* mblk for iteration */
#ifdef T2K_MEM_LEAK_DBG
char* file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
#endif
UNUSED(pri);
m = (sizeof(SsMblk) + sizeof(SsDblk));
/* ss001.301: additions */
#ifdef SS_HISTOGRAM_SUPPORT
- r = SAlloc(strmCfg.mdRegion, &m, 0, (Data **)&bp, __LINE__, (U8*)__FILE__, ENTNC);
+ r = SAlloc(strmCfg.mdRegion, &m, 0, (Data **)&bp, __LINE__, (uint8_t*)__FILE__, ENTNC);
#else
r = SAlloc(strmCfg.mdRegion, &m, 0, (Data **)&bp);
#endif /* SS_HISTOGRAM_SUPPORT */
n = size;
/* ss001.301: additions */
#ifdef SS_HISTOGRAM_SUPPORT
- r = SAlloc(strmCfg.datRegion, &n, 0, &dat, __LINE__, (U8*)__FILE__, ENTNC);
+ r = SAlloc(strmCfg.datRegion, &n, 0, &dat, __LINE__, (uint8_t*)__FILE__, ENTNC);
#else
r = SAlloc(strmCfg.datRegion, &n, 0, &dat);
#endif /* SS_HISTOGRAM_SUPPORT */
/* ss001.301: additions */
#ifdef SS_HISTOGRAM_SUPPORT
- SFree(strmCfg.mdRegion, (Data *)bp, m, __LINE__, (U8*)__FILE__, ENTNC);
+ SFree(strmCfg.mdRegion, (Data *)bp, m, __LINE__, (uint8_t*)__FILE__, ENTNC);
#else
SFree(strmCfg.mdRegion, (Data *)bp, m);
#endif /* SS_HISTOGRAM_SUPPORT */
}
/* generic set-up-message function */
- SS_STRM_INITB(bp, (SsDblk *)(((U8 *)bp) + sizeof(SsMblk)), dat, size, NULLP);
+ SS_STRM_INITB(bp, (SsDblk *)(((uint8_t *)bp) + sizeof(SsMblk)), dat, size, NULLP);
return (bp);
#endif
{
SsMblk *bp; /* mblk for iteration */
- U8 *ptr; /* pointer to data */
- U32 size; /* size of data content */
+ uint8_t *ptr; /* pointer to data */
+ uint32_t size; /* size of data content */
#if (ERRCLASS & ERRCLS_INT_PAR)
#ifdef ANSI
SsMblk *ssESBAlloc
(
-U8 *base, /* client supplied data buffer */
+uint8_t *base, /* client supplied data buffer */
S32 size, /* size of data buffer */
S32 pri, /* message priority */
SsFrtn *fr_rtn /* free routine */
)
#else
SsMblk *ssESBAlloc(base, size, pri, fr_rtn)
-U8 *base; /* client supplied data buffer */
+uint8_t *base; /* client supplied data buffer */
S32 size; /* size of data buffer */
S32 pri; /* message priority */
SsFrtn *fr_rtn; /* free routine */
m = (sizeof(SsMblk) + sizeof(SsDblk));
/* ss001.301: additions */
#ifdef SS_HISTOGRAM_SUPPORT
- r = SAlloc(strmCfg.mdRegion, &m, 0, (Data **)&bp, __LINE__, (U8*)__FILE__, ENTNC);
+ r = SAlloc(strmCfg.mdRegion, &m, 0, (Data **)&bp, __LINE__, (uint8_t*)__FILE__, ENTNC);
#else
#ifdef T2K_MEM_LEAK_DBG
char* file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
#endif
r = SAlloc(strmCfg.mdRegion, &m, 0, (Data **)&bp);
#endif /* SS_HISTOGRAM_SUPPORT */
/* use the generic set-up-message function to initialize everything */
- SS_STRM_INITB(bp, (SsDblk *)(((U8 *)bp) + sizeof(SsMblk)),
+ SS_STRM_INITB(bp, (SsDblk *)(((uint8_t *)bp) + sizeof(SsMblk)),
base, size, fr_rtn);
#ifdef T2K_MEM_LEAK_DBG
char* file = __FILE__;
- U32 line = __LINE__;
+ uint32_t line = __LINE__;
#endif
#if (ERRCLASS & ERRCLS_INT_PAR)
if (mp == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS341, ERRZERO, "Null pointer");
- RETVOID;
+ return;
}
#endif
if (mp->b_datap == NULLP)
{
- RETVOID;
+ return;
}
/* ss001.301: additions */
#ifdef SS_HISTOGRAM_SUPPORT
- SFree(strmCfg.mdRegion, (Data *)mp, size, __LINE__, (U8*)__FILE__, ENTNC);
+ SFree(strmCfg.mdRegion, (Data *)mp, size, __LINE__, (uint8_t*)__FILE__, ENTNC);
#else
#ifdef T2K_MEM_LEAK_DBG
SFree(strmCfg.mdRegion, (Data *)mp, size);
SFree(strmCfg.mdRegion, (Data *)mp, size);
#endif
#endif /* SS_HISTOGRAM_SUPPORT */
- RETVOID;
+ return;
}
/* ss028.103 - Addition of lock for mBuf reference count */
{
SSLOGERROR(ERRCLS_DEBUG, ESS343, ERRZERO,
"Could not lock the mBuf Ref Lock");
- RETVOID;
+ return;
}
#endif
#if (ERRCLASS & ERRCLS_DEBUG)
SSLOGERROR(ERRCLS_DEBUG, ESS344, ERRZERO,
"Could not give the Semaphore");
- RETVOID;
+ return;
#endif
}
#endif
#ifdef SS_HISTOGRAM_SUPPORT
SFree(strmCfg.datRegion, mp->b_datap->db_base,
(Size)(mp->b_datap->db_lim - mp->b_datap->db_base),
- __LINE__, (U8*)__FILE__, ENTNC);
+ __LINE__, (uint8_t*)__FILE__, ENTNC);
#else
SFree(strmCfg.datRegion, mp->b_datap->db_base,
(Size)(mp->b_datap->db_lim - mp->b_datap->db_base));
bp = (SsMblk *)(mp->b_datap - sizeof (SsMblk));
/* ss001.301: additions */
#ifdef SS_HISTOGRAM_SUPPORT
- SFree(strmCfg.mdRegion, (Data *)bp, size, __LINE__, (U8*)__FILE__, ENTNC);
+ SFree(strmCfg.mdRegion, (Data *)bp, size, __LINE__, (uint8_t*)__FILE__, ENTNC);
#else
SFree(strmCfg.mdRegion, (Data *)bp, size);
#endif /* SS_HISTOGRAM_SUPPORT */
/* ss001.301: additions */
#ifdef SS_HISTOGRAM_SUPPORT
- SFree(strmCfg.mdRegion, (Data *)mp, size, __LINE__, (U8*)__FILE__, ENTNC);
+ SFree(strmCfg.mdRegion, (Data *)mp, size, __LINE__, (uint8_t*)__FILE__, ENTNC);
#else
SFree(strmCfg.mdRegion, (Data *)mp, size);
#endif /* SS_HISTOGRAM_SUPPORT */
{
/* ss001.301: additions */
#ifdef SS_HISTOGRAM_SUPPORT
- SFree(strmCfg.mdRegion, (Data *)mp, size, __LINE__, (U8*)__FILE__, ENTNC);
+ SFree(strmCfg.mdRegion, (Data *)mp, size, __LINE__, (uint8_t*)__FILE__, ENTNC);
#else
SFree(strmCfg.mdRegion, (Data *)mp, size);
#endif /* SS_HISTOGRAM_SUPPORT */
}
}
- RETVOID;
+ return;
} /* ssFreeB */
\f
ssFreeB(bp);
}
- RETVOID;
+ return;
} /* ssFreeMsg */
\f
if (mp == NULLP || bp == NULLP)
{
SSLOGERROR(ERRCLS_INT_PAR, ESS345, ERRZERO, "Null pointer");
- RETVOID;
+ return;
}
#endif
/* link in the passed mblock */
mp->b_cont = bp;
- RETVOID;
+ return;
} /* ssLinkB */
\f
SsMblk *bp; /* mblk for iteration */
SsMblk *newbp; /* the new mblk */
SsMblk *prev; /* mblk of same type */
- U8 *base; /* for swapping data buffers */
- U8 *lim; /* for swapping data buffers */
- U8 *rptr; /* for swapping data buffers */
- U8 *wptr; /* for swapping data buffers */
+ uint8_t *base; /* for swapping data buffers */
+ uint8_t *lim; /* for swapping data buffers */
+ uint8_t *rptr; /* for swapping data buffers */
+ uint8_t *wptr; /* for swapping data buffers */
/* ss008.301 */
#ifdef SS_DBLK_FREE_RTN
SsFrtn *frtn; /* for swapping data buffers */
S32 mLen; /* number of bytes in all blocks of same type */
S32 m; /* temporary */
S32 n; /* temporary */
- U8 type; /* message type */
+ uint8_t type; /* message type */
#if (ERRCLASS & ERRCLS_INT_PAR)
if (mp == NULLP)
S32 ssTestB
(
S32 size, /* size required */
-U32 pri /* priority of the message buffer */
+uint32_t pri /* priority of the message buffer */
)
#else
S32 ssTestB(size, pri)
S32 size; /* size required */
-U32 pri; /* priority of the message buffer */
+uint32_t pri; /* priority of the message buffer */
#endif
{
SsMblk *bp; /* mblk for iteration */
/* data block */
struct ssdatab
{
- U8 db_ref; /* reference count */
- U8 db_type; /* type of data block */
+ uint8_t db_ref; /* reference count */
+ uint8_t db_type; /* type of data block */
/* ss006.301 */
Bool shared; /* is this data block shared ? */
#ifndef SS_DBUF_REFLOCK_DISABLE
SLockId dBufLock; /* Lock per Dbuf */
#endif
- U8 *db_base; /* base of data buffer */
- U8 *db_lim; /* limit of data buffer */
+ uint8_t *db_base; /* base of data buffer */
+ uint8_t *db_lim; /* limit of data buffer */
/* ss008.301 - deprecating for normal OS, useful for Cavium/RMI OS*/
#ifdef SS_DBLK_FREE_RTN
struct ssfree_rtn *db_frtnp; /* free routine */
/* STREAMS functions prototypes */
S16 ssStrmCfg ARGS((Region, Region));
S32 ssAdjMsg ARGS((SsMblk *, S32));
-SsMblk *ssAllocB ARGS((S32, U32));
+SsMblk *ssAllocB ARGS((S32, uint32_t));
SsMblk *ssCopyB ARGS((SsMblk *));
SsMblk *ssCopyMsg ARGS((SsMblk *));
SsMblk *ssDupB ARGS((SsMblk *));
SsMblk *ssDupMsg ARGS((SsMblk *));
-SsMblk *ssESBAlloc ARGS((U8 *, S32, S32, SsFrtn *));
+SsMblk *ssESBAlloc ARGS((uint8_t *, S32, S32, SsFrtn *));
void ssFreeB ARGS((SsMblk *));
void ssFreeMsg ARGS((SsMblk *));
void ssLinkB ARGS((SsMblk *, SsMblk *));
S32 ssMsgDSize ARGS((SsMblk *));
S32 ssPullupMsg ARGS((SsMblk *, S32));
SsMblk *ssRmvB ARGS((SsMblk *, SsMblk *));
-S32 ssTestB ARGS((S32, U32));
+S32 ssTestB ARGS((S32, uint32_t));
SsMblk *ssUnlinkB ARGS((SsMblk *));
SsTTskEntry *tTsk;
/* ss029.103: addition: multiple procIds related changes */
#ifdef SS_MULTIPLE_PROCS
- U16 procIdIdx;
+ uint16_t procIdIdx;
#endif
SsIdx idx;
S16 ret = ROK;
#ifdef SS_MULTIPLE_PROCS
- U16 procIdIdx;
+ uint16_t procIdIdx;
#endif /* SS_MULTIPLE_PROCS */
SsTmrEntry *tmr;
/* ss029.103: addition: multiple procIds related changes */
#ifdef SS_MULTIPLE_PROCS
- U16 procIdIdx;
+ uint16_t procIdIdx;
#endif /* SS_MULTIPLE_PROCS */
/* ss002.301 Additions */
Buffer *mBuf;
#ifdef ANSI
S16 SRegLogCfg
(
-U8 mode,
+uint8_t mode,
S8 *path,
-U32 size,
+uint32_t size,
S8 *IPA,
-U16 port
+uint16_t port
)
#else
S16 SRegLogCfg(mode, path, size, IPA, port)
-U8 mode;
+uint8_t mode;
S8 *path;
-U32 size;
+uint32_t size;
S8 *IPA;
-U16 port
+uint16_t port
#endif
{
#ifdef WIN32
WSADATA wsaData;
- U32 iRes;
+ uint32_t iRes;
#endif
/*ss013.301: Fixed Warnings for 32/64 bit compilation*/
#endif
{
S8 *buffer;
- PRIVATE U16 logFileCnt = 0;
+ PRIVATE uint16_t logFileCnt = 0;
S8 newFileName[SS_MAX_PATH];
#ifdef WIN32
size_t writeNum;
if (osCp.logger.opt & 0x01)
{
- writeNum = fwrite(buffer, sizeof(U8), cmStrlen((U8 *)buffer),
+ writeNum = fwrite(buffer, sizeof(uint8_t), cmStrlen((uint8_t *)buffer),
osCp.logger.filep);
}
if (osCp.logger.opt & 0x02)
{
- writeNum = sendto(osCp.logger.socketdes, buffer, cmStrlen((U8 *)buffer), 0, (struct sockaddr*)&osCp.logger.remoteAddr, sizeof(osCp.logger.remoteAddr));
+ writeNum = sendto(osCp.logger.socketdes, buffer, cmStrlen((uint8_t *)buffer), 0, (struct sockaddr*)&osCp.logger.remoteAddr, sizeof(osCp.logger.remoteAddr));
/*ss013.301 : Returned after sending to socket*/
return ROK;
}
SCpuInfo *cpuInfo; /* Information about the cores/threads per core */
#endif
{
- U32 coreCount = 0;
+ uint32_t coreCount = 0;
/*ss013.301 :Fix for TRACE5 feature crash due to missing TRC MACRO*/
/* check the number of cores */
/* if the cpu register is supplied then use it */
for (; coreCount < cpuInfo->numCores; coreCount++)
{
- U32 thrCnt = 0;
+ uint32_t thrCnt = 0;
for (;thrCnt < SS_MAX_THREADS_PER_CORE;thrCnt++)
{
osCp.mCInfo.coreInfo[coreCount].tskPerCoreLst[thrCnt] = -1;
S16 SGetAffinity
(
SSTskId *tskId, /* filled in with system task ID */
-U32 *coreId /* the core/processor id to which the affinity is set */
+uint32_t *coreId /* the core/processor id to which the affinity is set */
)
#else
S16 SGetAffinity(tskId, coreId)
SSTskId *tskId; /* filled in with system task ID */
-U32 *coreId; /* the core/processor id to which the affinity is set */
+uint32_t *coreId; /* the core/processor id to which the affinity is set */
#endif
{
S16 ret;
(
SSTskId *tskId, /* filled in with system task ID */
SsAffinityMode mode, /* the mode according to which the affinty is set */
-U32 coreId, /* the core/processor id to which the affinity has to be set */
+uint32_t coreId, /* the core/processor id to which the affinity has to be set */
SSTskId *tskAssociatedTskId /* filled in with system task ID of the associated layer */
)
#else
S16 SSetAffinity(tskId, mode, coreId, tskAssociatedTskId)
SSTskId *tskId; /* filled in with system task ID */
SsAffinityMode mode; /* the mode according to which the affinty is set */
-U32 coreId; /* the core/processor id to which the affinity has to be set */
+uint32_t coreId; /* the core/processor id to which the affinity has to be set */
SSTskId *tskAssociatedTskId; /* filled in with system task ID of the associated layer */
#endif
{
{
case SS_AFFINITY_MODE_DEFAULT:
{
- U32 coreCounter = 0, coreIndex = 0;
+ uint32_t coreCounter = 0, coreIndex = 0;
S8 repeatFlag = 1;
SEARCH_FOR_CORE:
/*ss013.301: Fixed Warnings for 32/64 bit compilation*/
case SS_AFFINITY_MODE_ASSOC:
{
/* search for the associated tsk id in osCp */
- U32 coreIndex = 0, threadIndex = 0;
+ uint32_t coreIndex = 0, threadIndex = 0;
Bool tskNotFound = TRUE;
for (;tskNotFound && coreIndex < SS_MAX_CORES; coreIndex++)
{
} /* end if */
else if (coreId == SS_DEFAULT_CORE)
{
- U32 coreCounter = 0;
- U32 coreIndex = 0;
+ uint32_t coreCounter = 0;
+ uint32_t coreIndex = 0;
/*ss013.301: Fixed Warnings for 32/64 bit compilation*/
for (coreIndex = osCp.mCInfo.currentCore;
coreCounter < osCp.mCInfo.cpuInfo.numCores;
/* ss002.301 Additions */
/*ss013.301 : changes related to SS_AFFINITY_SUPPORT*/
#if defined(SS_MULTICORE_SUPPORT) || defined(SS_AFFINITY_SUPPORT)
- U32 tskInd = 0;
+ uint32_t tskInd = 0;
#endif /* SS_MULTICORE_SUPPORT || SS_AFFINITY_SUPPORT*/
if (osCp.sTskTbl[tskInd].tskId == sTsk->tskId)
{
/* search for the tskId in coreInfo */
- U32 coreId = 0;
+ uint32_t coreId = 0;
for (coreId = 0; coreId < SS_MAX_CORES; coreId++)
{
- U32 thrId = 0;
+ uint32_t thrId = 0;
for (thrId = 0; thrId < SS_MAX_THREADS_PER_CORE; thrId++)
{
if (sTsk->tskId == osCp.mCInfo.coreInfo[coreId].tskPerCoreLst[thrId])
SsSTskEntry *sTsk;
/* ss029.103: addition: multiple procIds related changes */
#ifdef SS_MULTIPLE_PROCS
- U16 procIdIdx;
+ uint16_t procIdIdx;
#endif /* SS_MULTIPLE_PROCS */
#ifdef SS_MULTICORE_SUPPORT
SsTTskEntry *tTsk;
SsSTskEntry *sTsk;
/* ss029.103: addition: multiple procIds related changes */
#ifdef SS_MULTIPLE_PROCS
- U16 procIdIdx;
+ uint16_t procIdIdx;
#endif /* SS_MULTIPLE_PROCS */
#endif
/* ss029.103: addition: multiple procIds related changes */
#ifdef SS_MULTIPLE_PROCS
- U16 srcProcIdIdx;
- U16 dstProcIdIdx;
+ uint16_t srcProcIdIdx;
+ uint16_t dstProcIdIdx;
#endif /* SS_MULTIPLE_PROCS */
/*ss004.301: Cavium changes */
#ifdef SS_SEUM_CAVIUM
Pst tempPst;
#ifdef MSPD_MLOG_NEW
- U32 t = MacGetTick();
+ uint32_t t = MacGetTick();
#endif
/* copy the Pst structure into a local duplicate */
for (i = 0; i < (S16)sizeof(Pst); i++)
{
- *(((U8 *)(&nPst)) + i) = *(((U8 *) pst) + i);
+ *(((uint8_t *)(&nPst)) + i) = *(((uint8_t *) pst) + i);
}
pst = &nPst;
#ifdef SS_DRVR_SUPPORT
{
for (j = 0; j < (S16)sizeof(Pst); j++)
{
- *(((U8 *)(&nPst)) + j) = *(((U8 *) pst) + j);
+ *(((uint8_t *)(&nPst)) + j) = *(((uint8_t *) pst) + j);
}
pst = &nPst;
nPstUsed = TRUE;
/* plug the Pst structure into the message information portion */
msgInfo = (SsMsgInfo *) (mBuf->b_rptr);
for (i = 0; i < (S16 )sizeof(Pst); i++)
- *(((U8 *)(&msgInfo->pst)) + i) = *(((U8 *) &(tempPst)) + i);
+ *(((uint8_t *)(&msgInfo->pst)) + i) = *(((uint8_t *) &(tempPst)) + i);
/* ss004.301 : Cavium cahnges */
#ifdef SS_SEUM_CAVIUM
#endif
{
- U32 tskCnt = 0;
+ uint32_t tskCnt = 0;
/* Get the tapa task entity Ids from the osCp structure */
for(tskCnt = 0; tskCnt < osCp.numTTsks; tskCnt++)
#endif
{
- U32 tskCnt = 0;
+ uint32_t tskCnt = 0;
S16 r = 0;
#endif
{
- U32 tskCnt = 0;
+ uint32_t tskCnt = 0;
Bool found = FALSE;
*hstReg = 0;
#ifdef ANSI
S16 SInitWatchdog
(
-U16 port
+uint16_t port
)
#else
S16 SInitWatchdog(port)
-U16 port;
+uint16_t port;
#endif
{
return ssdInitWatchDog(port);
#ifdef ANSI
S16 SRegCfgWd
(
-U32 numNodes,
-U8 *addr[],
-U16 port[],
-U32 timeout,
+uint32_t numNodes,
+uint8_t *addr[],
+uint16_t port[],
+uint32_t timeout,
WdUserCallback callback,
void *data
)
#else
S16 SRegCfgWd(numNodes, addr, port, timeout, callback, data)
-U32 numNodes;
-U8 *addr[];
-U16 port[];
-U32 timeout;
+uint32_t numNodes;
+uint8_t *addr[];
+uint16_t port[];
+uint32_t timeout;
WdUserCallback callback;
void *data;
#endif
#ifdef ANSI
S16 SStartHrtBt
(
-U8 timeInterval /* time interval */
+uint8_t timeInterval /* time interval */
)
#else
S16 SStartHrtBt(timeInterval)
-U8 timeInterval;
+uint8_t timeInterval;
#endif
{
DateTime dt;
#endif /* DEBUGP */
Txt prntBuf[PRNTSZE];
- U16 n;
+ uint16_t n;
S16 err;
struct sockaddr_in tmpaddr;
Txt hbMsg[SS_WD_HB_MSG_SIZE];
Ent ent, /* entity */
Inst inst,
Event *curEvent,
-U32 *curEvtTime,
-U64 *totTime
+uint32_t *curEvtTime,
+uint64_t *totTime
)
#else
S16 SGetThrdProf(sTskId, procId, ent, inst, evnt, curEvent, curEvtTime, totTime)
Ent ent; /* entity */
Inst inst;
Event *curEvent;
-U32 *curEvtTime;
-U64 *totTime;
+uint32_t *curEvtTime;
+uint64_t *totTime;
#endif
#else
#ifdef ANSI
Ent ent, /* entity */
Inst inst,
Event *curEvent,
-U32 *curEvtTime,
-U64 *totTime
+uint32_t *curEvtTime,
+uint64_t *totTime
)
#else
S16 SGetThrdProf(sTskId, ent, inst, curEvent,curEvtTime, totTime)
Ent ent; /* entity */
Inst inst;
Event *curEvent;
-U32 *curEvtTime;
-U64 *totTime;
+uint32_t *curEvtTime;
+uint64_t *totTime;
#endif
#endif /* SS_MULTIPLE_PROCS */
{
SsIdx idx;
SsTTskEntry *tTsk;
#ifdef SS_MULTIPLE_PROCS
- U16 procIdIdx;
+ uint16_t procIdIdx;
#endif
#ifdef ANSI
S16 SRegTskInfo
(
-U8 *cfgFile
+uint8_t *cfgFile
)
#else
S16 SRegTskInfo(cfgFile)
-U8 *cfgFile;
+uint8_t *cfgFile;
#endif
{
return cmCfgrTskReg(cfgFile);
/* ss029.103: modification:
data type changed to allow more number of TAPA tasks */
#ifndef SS_MULTIPLE_PROCS
-typedef U8 SsCntr;
-typedef U8 SsIdx;
+typedef uint8_t SsCntr;
+typedef uint8_t SsIdx;
#else /* SS_MULTIPLE_PROCS */
-typedef U16 SsCntr;
-typedef U16 SsIdx;
+typedef uint16_t SsCntr;
+typedef uint16_t SsIdx;
#endif /* SS_MULTIPLE_PROCS */
#ifdef SS_THREAD_PROFILE
Bool updated;
Event curEvent;
- U32 curEvtTime;
- U64 totTime;
+ uint32_t curEvtTime;
+ uint64_t totTime;
#endif /* SS_THREAD_PROFILE */
/* ss02.301 */
- ActvTsk cbTsk; /* call back function pointer */
+ ActvTsk cbTsk; /* call back function pointer */
} SsTTskEntry;
struct ssSTskEntry
{
SsdSTskEntry dep; /* implementation specific */
-
-
Bool used; /* entry is used or not */
Bool termPend; /* termination pending */
SSTskId tskId; /* system task ID */
PFS16 tmrFnct; /* timer function, typically SActvTmr */
#endif
{
- S16 ret;
- /* ss015.301 - Enclosed all timer activation functions in a union. */
- SsTmrActvFn ssTmrActvFn;
- /* ss041.103 - Moved handling to STmrRegHndlr */
+ S16 ret;
+ /* ss015.301 - Enclosed all timer activation functions in a union. */
+ SsTmrActvFn ssTmrActvFn;
+ /* ss041.103 - Moved handling to STmrRegHndlr */
ssTmrActvFn.mtFlag = FALSE;
ssTmrActvFn.actvFnc.tmrActvFn = tmrFnct;
#endif /* SS_MULTIPLE_PROCS */
{
#if (ERRCLASS & ERRCLS_INT_PAR)
- U8 i;
+ uint8_t i;
#endif
S16 ret;
SsTmrEntry *tmr;
#ifdef SS_MULTIPLE_PROCS
#if (ERRCLASS & ERRCLS_INT_PAR)
- U16 procIdIdx;
+ uint16_t procIdIdx;
#endif /* ERRCLASS & ERRCLS_INT_PAR */
#endif /* SS_MULTPLE_PROCS */
#else
&& (osCp.tmrTbl[i].ssTmrActvFn.actvFnc.tmrActvFn == ssTmrActvFn.actvFnc.tmrActvFn)
#endif
- && (osCp.tmrTbl[i].interval == (U32) ((period * SS_TICKS_SEC) / units)))
+ && (osCp.tmrTbl[i].interval == (uint32_t) ((period * SS_TICKS_SEC) / units)))
{
/* is this timer in use ? (unexpired) */
if (osCp.tmrTbl[i].used == TRUE)
#endif /* SS_MULTIPLE_PROCS */
tmr->ownerEnt = ent;
tmr->ownerInst = inst;
- tmr->interval = (U32) ((period * SS_TICKS_SEC) / units);
+ tmr->interval = (uint32_t) ((period * SS_TICKS_SEC) / units);
tmr->ssTmrActvFn.mtFlag = ssTmrActvFn.mtFlag;
/* ss041.103 */
SsTmrEntry *tmr;
#ifdef SS_MULTIPLE_PROCS
#if (ERRCLASS & ERRCLS_INT_PAR)
- U16 procIdIdx;
+ uint16_t procIdIdx;
#endif /* ERRCLASS & ERRCLS_INT_PAR */
#endif /* SS_MULTIPLE_PROCS */
#else
&& osCp.tmrTbl[idx].ssTmrActvFn.actvFnc.tmrActvFn == ssTmrActvFn.actvFnc.tmrActvFn
#endif
- && osCp.tmrTbl[idx].interval == (U32) ((period * SS_TICKS_SEC) / units))
+ && osCp.tmrTbl[idx].interval == (uint32_t) ((period * SS_TICKS_SEC) / units))
{
break;
}
Ent ownerEnt; /* owner task entity ID */
Inst ownerInst; /* owner task instance ID */
/* ss028.103 - Modification for SRegCfgTmr support */
- U32 interval; /* timer interval */
+ uint32_t interval; /* timer interval */
/* ss029.103: modification: timer function type modified */
/* ss015.301 Enclosed all timer activation functions in a union. */
SsTmrActvFn ssTmrActvFn;
S16 BuildGlobalRicId(GlobalRIC_ID_t *ricId)
{
- U8 unused = 4;
- U8 byteSize = 3;
- U8 val = 1;
+ uint8_t unused = 4;
+ uint8_t byteSize = 3;
+ uint8_t val = 1;
if(ricId != NULLP)
{
- ricId->pLMN_Identity.size = byteSize * sizeof(U8);
+ ricId->pLMN_Identity.size = byteSize * sizeof(uint8_t);
RIC_ALLOC(ricId->pLMN_Identity.buf, ricId->pLMN_Identity.size);
buildPlmnId(ricCfgParams.plmn , ricId->pLMN_Identity.buf);
/* fill ric Id */
- ricId->ric_ID.size = byteSize * sizeof(U8);
+ ricId->ric_ID.size = byteSize * sizeof(uint8_t);
RIC_ALLOC(ricId->ric_ID.buf, ricId->ric_ID.size);
fillBitString(&ricId->ric_ID, unused, byteSize, val);
}
E2AP_PDU_t *e2apMsg = NULL;
E2setupResponse_t *e2SetupRsp;
asn_enc_rval_t encRetVal;
- U8 idx;
- U8 elementCnt;
+ uint8_t idx;
+ uint8_t elementCnt;
DU_LOG("\nE2AP : Building E2 Setup Response\n");
S16 BuildRicSubsDetails(RICsubscriptionDetails_t *subsDetails)
{
- U8 elementCnt;
+ uint8_t elementCnt;
if(subsDetails != NULLP)
{
/* Octet string to be build here */
/* Sending PLMN as Octect string */
- U8 byteSize = 3;
- subsDetails->ricEventTriggerDefinition.size = byteSize * sizeof(U8);
+ uint8_t byteSize = 3;
+ subsDetails->ricEventTriggerDefinition.size = byteSize * sizeof(uint8_t);
RIC_ALLOC(subsDetails->ricEventTriggerDefinition.buf, subsDetails->ricEventTriggerDefinition.size);
buildPlmnId(ricCfgParams.plmn, subsDetails->ricEventTriggerDefinition.buf);
elementCnt = 1;
S16 BuildAndSendRicSubscriptionReq()
{
- E2AP_PDU_t *e2apRicMsg = NULL;
+ E2AP_PDU_t *e2apRicMsg = NULL;
RICsubscriptionRequest_t *ricSubscriptionReq;
- U8 elementCnt;
- U8 idx;
- U8 ieId;
- S16 ret;
- asn_enc_rval_t encRetVal; /* Encoder return value */
+ uint8_t elementCnt;
+ uint8_t idx;
+ uint8_t ieId;
+ S16 ret;
+ asn_enc_rval_t encRetVal; /* Encoder return value */
ricSubsStatus = TRUE;
DU_LOG("\nE2AP : Building RIC Subscription Request\n");
* ****************************************************************/
void E2APMsgHdlr(Buffer *mBuf)
{
- int i;
- char *recvBuf;
- MsgLen copyCnt;
- MsgLen recvBufLen;
- E2AP_PDU_t *e2apMsg;
- asn_dec_rval_t rval; /* Decoder return value */
- E2AP_PDU_t e2apasnmsg ;
+ int i;
+ char *recvBuf;
+ MsgLen copyCnt;
+ MsgLen recvBufLen;
+ E2AP_PDU_t *e2apMsg;
+ asn_dec_rval_t rval; /* Decoder return value */
+ E2AP_PDU_t e2apasnmsg ;
DU_LOG("\nE2AP : Received E2AP message buffer");
ODU_PRINT_MSG(mBuf, 0,0);
/* allocate and zero out a static buffer */
#define RIC_ALLOC(_datPtr, _size) \
{ \
- S16 _ret; \
+ uint8_t _ret; \
_ret = SGetSBuf(RIC_APP_MEM_REG, RIC_POOL, \
(Data **)&_datPtr, _size); \
if(_ret == ROK) \
void readRicCfg()
{
- U32 ipv4_du, ipv4_ric;
+ uint32_t ipv4_du, ipv4_ric;
DU_LOG("\nReading RIC configurations");
{
addrLstPtr->count++;
addrLstPtr->addrs[(addrLstPtr->count - 1)].type = CM_INET_IPV4ADDR_TYPE;
- addrLstPtr->addrs[(addrLstPtr->count - 1)].u.ipv4NetAddr = CM_INET_NTOH_U32(ipAddr->ipV4Addr);
+ addrLstPtr->addrs[(addrLstPtr->count - 1)].u.ipv4NetAddr = CM_INET_NTOH_UINT32(ipAddr->ipV4Addr);
return ROK;
}
{
/* Filling destination address */
destAddrPtr->type = CM_INET_IPV4ADDR_TYPE;
- destAddrPtr->u.ipv4NetAddr = CM_INET_NTOH_U32(dstIpPtr->ipV4Addr);
+ destAddrPtr->u.ipv4NetAddr = CM_INET_NTOH_UINT32(dstIpPtr->ipV4Addr);
return ROK;
}
* ****************************************************************/
S16 sctpAccept(CmInetFd *lstnSock_Fd, CmInetAddr *peerAddr, CmInetFd *sock_Fd)
{
- U8 ret;
+ uint8_t ret;
ret = cmInetListen(lstnSock_Fd, 1);
if (ret != ROK)
* ****************************************************************/
S16 sctpSockPoll()
{
- U16 ret = ROK;
- U32 timeout;
- U32 *timeoutPtr;
- CmInetMemInfo memInfo;
+ uint16_t ret = ROK;
+ uint32_t timeout;
+ uint32_t *timeoutPtr;
+ CmInetMemInfo memInfo;
sctpSockPollParams e2PollParams;
memset(&e2PollParams, 0, sizeof(sctpSockPollParams));
* ****************************************************************/
-S16 processPolling(sctpSockPollParams *pollParams, CmInetFd *sockFd, U32 *timeoutPtr, CmInetMemInfo *memInfo)
+S16 processPolling(sctpSockPollParams *pollParams, CmInetFd *sockFd, uint32_t *timeoutPtr, CmInetMemInfo *memInfo)
{
- U16 ret = ROK;
+ uint16_t ret = ROK;
CM_INET_FD_SET(sockFd, &pollParams->readFd);
ret = cmInetSelect(&pollParams->readFd, NULLP, timeoutPtr, &pollParams->numFd);
if(CM_INET_FD_ISSET(sockFd, &pollParams->readFd))
* ****************************************************************/
S16 sctpSend(Buffer *mBuf)
{
- U8 ret;
+ uint8_t ret;
MsgLen len; /* number of actually sent octets */
CmInetMemInfo memInfo;
#define MAX_RETRY 5
/* Global variable declaration */
-U8 socket_type; /* Socket type */
-bool nonblocking; /* Blocking/Non-blocking socket */
-bool connUp; /* Is connection up */
-int assocId; /* Assoc Id of connected assoc */
+uint8_t socket_type; /* Socket type */
+bool nonblocking; /* Blocking/Non-blocking socket */
+bool connUp; /* Is connection up */
+int assocId; /* Assoc Id of connected assoc */
typedef struct
{
S16 sctpSetSockOpts(CmInetFd *sock_Fd);
S16 sctpAccept(CmInetFd *lstnSock_Fd, CmInetAddr *peerAddr, CmInetFd *sock_Fd);
S16 sctpSockPoll();
-S16 processPolling(sctpSockPollParams *pollParams, CmInetFd *sockFd, U32 *timeoutPtr, CmInetMemInfo *memInfo);
+S16 processPolling(sctpSockPollParams *pollParams, CmInetFd *sockFd, uint32_t *timeoutPtr, CmInetMemInfo *memInfo);
#endif
*****************************************************************************/
#include <stdio.h>
+#include "stdint.h"
#include "rl_common.h"
-
/* String representation of Log Levels */
const char* g_logStr[L_MAX_LOG_LEVEL] =
{
file should not be cirectly included by any other application although it is
common file to logging framework and LOG MACROs used by any applicatoin.
***************************************************************************/
-
#ifndef __RL_COMMON_H__
#define __RL_COMMON_H__
#ifdef USE_RLOG_DATA_TYPES
typedef const char* PSTR;
-typedef unsigned char U8;
-typedef unsigned short U16;
-typedef unsigned int U32;
typedef int S32;
typedef signed short S16;
#else
typedef const char* PSTR;
#endif
-typedef U32 LOGID;
+typedef uint32_t LOGID;
#ifdef RLOG_ENABLE_TEXT_LOGGING
#include <stdio.h>
extern FILE* g_fp;
void logLev0(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, ...);
-void logLev1(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, U32 arg1, ...);
-void logLev2(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, U32 arg1, U32 arg2, ...);
-void logLev3(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, U32, U32, U32, ...);
-void logLev4(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, U32, U32, U32, U32, ...);
+void logLev1(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, uint32_t arg1, ...);
+void logLev2(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, uint32_t arg1, uint32_t arg2, ...);
+void logLev3(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, uint32_t, uint32_t, uint32_t, ...);
+void logLev4(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, uint32_t, uint32_t, uint32_t, uint32_t, ...);
void logLevN(int logLevel, const char* modName, const char* file, int lineno, const char* fmtStr, ...);
void logLevE(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, R_SPL_ARG splType,
- U32 splVal, U32 arg1, U32 arg2, U32 arg3, U32 arg4, ...);
+ uint32_t splVal, uint32_t arg1, uint32_t arg2, uint32_t arg3, uint32_t arg4, ...);
void logLevH(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, PSTR hexdump, int hexlen, ...);
void logLevS(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, PSTR str, ...);
#else
void logLevH( LOGID logId, R_LOG_LEVEL logLevel, PSTR hex, int hexlen, ...);
void logLev0( LOGID logId, R_LOG_LEVEL logLevel, ...);
-void logLev1( LOGID logId, R_LOG_LEVEL logLevel, U32 arg1, ...);
-void logLev2( LOGID logId, R_LOG_LEVEL logLevel, U32 arg1, U32 arg2, ...);
-void logLev3( LOGID logId, R_LOG_LEVEL logLevel, U32 arg1, U32 arg2, U32 arg3, ...);
-void logLev4( LOGID logId, R_LOG_LEVEL logLevel, U32 arg1, U32 arg2, U32 arg3, U32 arg4, ...);
-void logLevE(LOGID logId, R_LOG_LEVEL logLevel, R_SPL_ARG splType, U32 splVal,
-U32 arg1, U32 arg2, U32 arg3, U32 arg4, ...);
+void logLev1( LOGID logId, R_LOG_LEVEL logLevel, uint32_t arg1, ...);
+void logLev2( LOGID logId, R_LOG_LEVEL logLevel, uint32_t arg1, uint32_t arg2, ...);
+void logLev3( LOGID logId, R_LOG_LEVEL logLevel, uint32_t arg1, uint32_t arg2, uint32_t arg3, ...);
+void logLev4( LOGID logId, R_LOG_LEVEL logLevel, uint32_t arg1, uint32_t arg2, uint32_t arg3, uint32_t arg4, ...);
+void logLevE(LOGID logId, R_LOG_LEVEL logLevel, R_SPL_ARG splType, uint32_t splVal,
+uint32_t arg1, uint32_t arg2, uint32_t arg3, uint32_t arg4, ...);
void logLevS( LOGID logId, R_LOG_LEVEL logLevel, const char* str, ...);
#endif
void hextostr(char* p, PSTR h, int hexlen);
extern int g_logLevel;
-extern U32 g_modMask;
+extern uint32_t g_modMask;
extern const char* g_logStr[L_MAX_LOG_LEVEL];
extern const char* g_splStr[DBG_MAX_IDs];
// This API needs to be called after configuring all the required parameters
// by using below APIs. This API initializes logging framework.
// Log MACRO's should be used only after calling this API.
-void rlInitLog(U8 type);
+void rlInitLog(uint8_t type);
///////////////////////////////////////////////////////////////////////////////
// This initializes log file name. Log file name should be exclusive of
// This API is used to set remote logging port, where post-processor application
// (rlogapp) is used to connect on this port in order to receive live binary logs.
// This API can be used only during initialization time.
-void rlSetLogPort(U32 port);
+void rlSetLogPort(uint32_t port);
///////////////////////////////////////////////////////////////////////////////
// Use this API to set log level. This API supports run time modification of
// This API toggles the module mask. If logging for this module is already
// enabled, it will be disabled. If it's not enabled, it will enable. Zero
// input will disable logging mask for all modules.
-void rlSetModuleMask(U32 modMask);
+void rlSetModuleMask(uint32_t modMask);
///////////////////////////////////////////////////////////////////////////////
// This API is used to set log file size limit for single file.
-void rlSetLogFileSizeLimit(U32 maxFileSize);
+void rlSetLogFileSizeLimit(uint32_t maxFileSize);
///////////////////////////////////////////////////////////////////////////////
// This API sets the limit of number of log files that can be created by
// logging framework.
-void rlSetNumOfLogFiles(U8 nMaxFiles);
+void rlSetNumOfLogFiles(uint8_t nMaxFiles);
///////////////////////////////////////////////////////////////////////////////
// This API is used to set circular buffer size for each thread. Based on the
// number of threads in the system this size needs to be chosen. Recommended
// minimum 100Kb buffer size.
-void rlSetCircularBufferSize(U32 bufSize);
+void rlSetCircularBufferSize(uint32_t bufSize);
///////////////////////////////////////////////////////////////////////////////
// This API enables or disables remote logging application connection to see
framework.
****************************************************************************/
+#include"stdint.h"
#include "rl_interface.h"
-
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
std::map<unsigned short, std::string> g_mFileInfo;
std::map<LOGID, LOG_INFO> g_mLogInfo;
FILE* g_fp=stderr;
-U32 g_ttiCount = 0;
+uint32_t g_ttiCount = 0;
time_t g_basetimeSec;
void readCmdLineArgs(int argc,char **argv);
return y;
}
-void print_hex(const char* str, const U8 *p, int len)
+void print_hex(const char* str, const uint8_t *p, int len)
{
fprintf(stderr, "%s HEX \n", str);
for(int i=0; i<len; i++ ) fprintf(stderr, "%d ", p[i]);
return false;
}
#else
- U16 size = RLOG_FIXED_LENGTH_BUFFER_SIZE - sizeof(LOGDATA);
+ uint16_t size = RLOG_FIXED_LENGTH_BUFFER_SIZE - sizeof(LOGDATA);
// if( log.logData.len && read(fd, (void*)log.buf, size) <= 0 ) {
if( read(fd, (void*)log.buf, size) <= 0 ) {
return false;
{
struct tm* tm;
time_t curTimeSec;
- U32 secElapsedFromBeg;
- U32 ttiNum;
- U32 miliseconds;
+ uint32_t secElapsedFromBeg;
+ uint32_t ttiNum;
+ uint32_t miliseconds;
ttiNum = ltime.ms_tti;
secElapsedFromBeg = ttiNum/1000;
#include "envopt.h"
#include "envdep.h"
+#include "stdint.h"
#include "rl_interface.h"
-
#include <stdio.h>
#include <unistd.h>
#include <sys/socket.h>
char g_fileList[RLOG_MAX_FILES][MAX_FILENAME_LEN];
#ifdef RLOG_USE_CIRCULAR_BUFFER
static THREAD_DATA *g_pSingCirBuff = NULL;
-static U16 g_prevLogOffset=0;
+static uint16_t g_prevLogOffset=0;
#endif
#ifndef RLOG_ENABLE_TEXT_LOGGING
-static volatile U32 g_rlogPositionIndex=0;
-U32 gIpType = CM_IPV4ADDR_TYPE;
+static volatile uint32_t g_rlogPositionIndex=0;
+uint32_t gIpType = CM_IPV4ADDR_TYPE;
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////
Data *g_l2LogBufBasePtr = NULLP;
Data *g_logBufRcvdFromL2 = NULLP;
Data *g_l2LogBaseBuff = NULLP;
-U32 g_logBufLenRcvdFromL2 = 0;
-U32 g_l2LogBufLen = 0;
-U32 startL2Logging = 0;
-U32 g_l2logBuffPos = 0;
+uint32_t g_logBufLenRcvdFromL2 = 0;
+uint32_t g_l2LogBufLen = 0;
+uint32_t startL2Logging = 0;
+uint32_t g_l2logBuffPos = 0;
/* end */
#endif /* Binary Logging */
int g_logLevel = L_MAX_LOG_LEVEL;
#endif
/* MAX Log Files 1 */
-U8 g_nMaxLogFiles = 1;
+uint8_t g_nMaxLogFiles = 1;
/* Max File Size limit for each log file */
-U32 g_uiMaxFileSizeLimit = MAX_FILE_SIZE;
+uint32_t g_uiMaxFileSizeLimit = MAX_FILE_SIZE;
/* Default circular buffer size 100Kb*/
-U32 g_cirMaxBufferSize = RLOG_MAX_CIRBUF_SIZE;
+uint32_t g_cirMaxBufferSize = RLOG_MAX_CIRBUF_SIZE;
/* Default mask for each module is disabled */
-U32 g_modMask = 0;
-
+uint32_t g_modMask = 0;
/* Remote Logging port */
-static U32 g_nLogPort = RLOG_REMOTE_LOGGING_PORT;
+static uint32_t g_nLogPort = RLOG_REMOTE_LOGGING_PORT;
/* Current File Number index */
int g_nCurrFileIdx = 0;
/* Remote logging flag */
-static U8 g_bRemoteLoggingDisabled=1;
+static uint8_t g_bRemoteLoggingDisabled=1;
/* Global file descriptor for L2 & L3 */
static int g_fd;
pthread_mutex_t g_logmutex, g_condmutex;
pthread_cond_t g_cond;
-U8 g_writeCirBuf = 0;
+uint8_t g_writeCirBuf = 0;
static int thread_signalled;
#endif
/* TTI Count */
-static U32 numTtiTicks;
+static uint32_t numTtiTicks;
/* Console input handling parameters */
static int g_kIdx, g_action, g_storeKeys;
static char g_keyBuf[32];
extern void (*rlSigHandler)(int);
/* L2 Logging */
void rlInitL2Log(void);
-U32 g_rlogWriteCount = 0;
-U32 g_maxRlogCount = 50;
-U32 g_logsDropCnt = 0;
+uint32_t g_rlogWriteCount = 0;
+uint32_t g_maxRlogCount = 50;
+uint32_t g_logsDropCnt = 0;
RLLogCntLmt g_rlLogCntLimit = RL_LOG_COUNT_LIMIT_STOP;
#ifndef RLOG_ENABLE_TEXT_LOGGING
void readL2LogBuff(void);
S16 rlValidateL2LogBuf(void);
-void rlSetL2LogBuf(U8 *l2LogBuf,U32 l2logLen);
+void rlSetL2LogBuf(uint8_t *l2LogBuf,uint32_t l2logLen);
void rlResetL2LogBuf(void);
#endif
#ifndef RLOG_ENABLE_TEXT_LOGGING
EndianType getCPU_Endian(Void);
void storeFileHeader(FILE* fp);
-void saveLogDataFromCpul(const void* buf, U16 len);
-void saveLogData(const void* buf, U16 len, U32 g_rlogWritePosIndex);
-void sendToPostProcessor(const void* buf, U16 len);
+void saveLogDataFromCpul(const void* buf, uint16_t len);
+void saveLogData(const void* buf, uint16_t len, uint32_t g_rlogWritePosIndex);
+void sendToPostProcessor(const void* buf, uint16_t len);
void getLogTimeStr(char* ts);
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////
// @param[in] modMask - bit mask for any particular module.
// Sets or clears bit for the particular module. If mask value is zero all bits are cleared.
///////////////////////////////////////////////////////////////////////////////////////////////////
-void rlSetModuleMask(U32 modMask)
+void rlSetModuleMask(uint32_t modMask)
{
g_modMask = (modMask == 0 ) ? 0 : (g_modMask ^ modMask);
}
// @param[in] - maxFileSize - Maximum file size in MB.
// @brief This function sets the limit to log file size.
///////////////////////////////////////////////////////////////////////////////////////////////////
-void rlSetLogFileSizeLimit(U32 maxFileSize)
+void rlSetLogFileSizeLimit(uint32_t maxFileSize)
{
g_uiMaxFileSizeLimit = (maxFileSize == 0) ? MAX_FILE_SIZE : maxFileSize*1048576;
}
//
//
///////////////////////////////////////////////////////////////////////////////////////////////////
-void rlSetNumOfLogFiles(U8 nMaxFiles)
+void rlSetNumOfLogFiles(uint8_t nMaxFiles)
{
if( nMaxFiles > RLOG_MAX_FILES || nMaxFiles == 0 ) {
g_nMaxLogFiles = RLOG_MAX_FILES;
// @param[in] port - Server port
// @brief Use this API to configure port for remote logging application.
///////////////////////////////////////////////////////////////////////////////////////////////////
-void rlSetLogPort(U32 port)
+void rlSetLogPort(uint32_t port)
{
g_nLogPort = port;
}
// @param[in] bufSize - Circulaer buffer size in multiples of 1Kb or 1024 bytes.
// This function is called to set circular buffer size for each thread.
///////////////////////////////////////////////////////////////////////////////////////////////////
-void rlSetCircularBufferSize(U32 bufSize)
+void rlSetCircularBufferSize(uint32_t bufSize)
{
g_cirMaxBufferSize = bufSize*1024;
g_cirMaxBufferSize = (g_cirMaxBufferSize/50) * 50;
#define CHECK_FILE_SIZE if( ++g_nWrites == 200 ) \
{ \
g_nWrites = 0; \
- logLev1(L_TIME_REFERENCE, L_ALWAYS, (U32)time(NULL));\
+ logLev1(L_TIME_REFERENCE, L_ALWAYS, (uint32_t)time(NULL));\
}
#else
#define CHECK_FILE_SIZE
createNewLogFile(); \
}\
g_nWrites = 0; \
- logLev1(L_TIME_REFERENCE, L_ALWAYS, (U32)time(NULL));\
+ logLev1(L_TIME_REFERENCE, L_ALWAYS, (uint32_t)time(NULL));\
}
#else
#define CHECK_FILE_SIZE if( ++g_nWrites == 200 ) \
{ \
- if( g_fp && ( (U32)(ftell(g_fp)) > g_uiMaxFileSizeLimit) ) { \
+ if( g_fp && ( (uint32_t)(ftell(g_fp)) > g_uiMaxFileSizeLimit) ) { \
createNewLogFile(); \
}\
g_nWrites = 0; \
pthread_mutex_lock(&g_logmutex);
/* Allocate circular buffer */
- pThrData->logBuff = (U8*) rlAlloc(g_cirMaxBufferSize);
+ pThrData->logBuff = (uint8_t*) rlAlloc(g_cirMaxBufferSize);
if( pThrData->logBuff == NULL ) {
#ifndef ALIGN_64BIT
///////////////////////////////////////////////////////////////////////////////////////////////////
void readCircularBuffers()
{
- U32 i, writerPos;
+ uint32_t i, writerPos;
/* Check if process is L2. If L2 then return from here */
if (SFndProcId() == TENB_L2_PROC_ID)
unsigned short x;
unsigned char c;
- x = 0x0001;;
+ x = 0x0001;
c = *(unsigned char *)(&x);
return ( c == 0x01 ) ? little_endian : big_endian;
// remote application can connect & receive binary logs. If circular buffer is enabled, it creates
// thread key, which is used to store & retrieve thread specific buffers and data.
///////////////////////////////////////////////////////////////////////////////////////////////////
-void rlInitLog(U8 type)
+void rlInitLog(uint8_t type)
{
#ifdef SS_RBUF
/* Initilize the signal handler */
//
///////////////////////////////////////////////////////////////////////////////////////////////////
void logLevE(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, R_SPL_ARG splType,
- U32 splVal, U32 arg1, U32 arg2, U32 arg3, U32 arg4, ...)
+ uint32_t splVal, uint32_t arg1, uint32_t arg2, uint32_t arg3, uint32_t arg4, ...)
{
int microseconds=0;
//
//
///////////////////////////////////////////////////////////////////////////////////////////////////
-void logLev1(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, U32 arg1, ...)
+void logLev1(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, uint32_t arg1, ...)
{
int microseconds=0;
//
//
///////////////////////////////////////////////////////////////////////////////////////////////////
-void logLev2(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, U32 arg1, U32 arg2, ...)
+void logLev2(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr, uint32_t arg1, uint32_t arg2, ...)
{
int microseconds=0;
//
///////////////////////////////////////////////////////////////////////////////////////////////////
void logLev3(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr,
- U32 arg1, U32 arg2, U32 arg3, ...)
+ uint32_t arg1, uint32_t arg2, uint32_t arg3, ...)
{
int microseconds=0;
//
///////////////////////////////////////////////////////////////////////////////////////////////////
void logLev4(PSTR strLogLevel, PSTR modName, PSTR file, int lineno, PSTR fmtStr,
- U32 arg1, U32 arg2, U32 arg3, U32 arg4, ...)
+ uint32_t arg1, uint32_t arg2, uint32_t arg3, uint32_t arg4, ...)
{
int microseconds=0;
#define RLOG_SAVE_TIME(_logTime) _logTime.ms_tti=numTtiTicks;
-void saveLogDataFromCpul(const void* buf, U16 len)
+void saveLogDataFromCpul(const void* buf, uint16_t len)
{
#ifdef RLOG_USE_CIRCULAR_BUFFER
THREAD_DATA* p = (THREAD_DATA*) g_pSingCirBuff;
S32 remlen = len-tempLen;
if ((tempLen < 0) || (remlen < 0))
{
- RETVOID;
+ return;
}
if(remlen == 0)
{
/* Copy data till end of the buffer */
memcpy(p->logBuff+p->logBufLen, buf, tempLen);
/* Copy remaining data from the start of buffer */
- memcpy(p->logBuff, ((const U8 *)buf)+tempLen, remlen);
+ memcpy(p->logBuff, ((const uint8_t *)buf)+tempLen, remlen);
/* Store buffer length position */
p->logBufLen = len-tempLen;
}
}
-void saveLogData(const void* buf, U16 len, U32 g_rlogWritePosIndex)
+void saveLogData(const void* buf, uint16_t len, uint32_t g_rlogWritePosIndex)
{
++g_rlogWriteCount ;
return;
}
#ifdef RLOG_USE_CIRCULAR_BUFFER
- U32 logWritePointerPosition;
+ uint32_t logWritePointerPosition;
THREAD_DATA* p = (THREAD_DATA*) g_pSingCirBuff;
/* if buffer is about to full, write till end and continue writing from begining */
}
-void sendToPostProcessor(const void* buf, U16 len)
+void sendToPostProcessor(const void* buf, uint16_t len)
{
if( send(g_nCliSocket, buf, len, 0 ) == -1 ) {
perror("ERROR Sending");
}
void logLevS( LOGID logId, R_LOG_LEVEL logLevel, const char* str, ...)
{
- ARGDATA arg; U16 bufsize;
+ ARGDATA arg; uint16_t bufsize;
RLOG_SAVE_TIME(arg.logData.logTime);
saveLogData((const void*)&arg, bufsize,g_rlogPositionIndex++);
}
-void logLevE(LOGID logId, R_LOG_LEVEL logLevel, R_SPL_ARG splType, U32 splVal, U32 arg1, U32 arg2,
- U32 arg3, U32 arg4, ...)
+void logLevE(LOGID logId, R_LOG_LEVEL logLevel, R_SPL_ARG splType, uint32_t splVal, uint32_t arg1, uint32_t arg2,
+ uint32_t arg3, uint32_t arg4, ...)
{
SPL_ARGDATA arg;
int bufsize;
arg.logData.numOfArgs = 0;
}
- arg.logData.len = sizeof(u_int8_t) + sizeof(U32) + (sizeof(U32)*arg.logData.numOfArgs);
+ arg.logData.len = sizeof(u_int8_t) + sizeof(uint32_t) + (sizeof(uint32_t)*arg.logData.numOfArgs);
arg.splEnum = splType;
arg.splArg = splVal;
saveLogData((const void*)&arg, sizeof(LOGDATA),g_rlogPositionIndex++);
}
-void logLev1( LOGID logId, R_LOG_LEVEL logLevel, U32 arg1, ...)
+void logLev1( LOGID logId, R_LOG_LEVEL logLevel, uint32_t arg1, ...)
{
ARG4DATA arg;
int bufsize;
arg.logData.argType = LOG_ARG_INT;
arg.logData.logLevel = logLevel;
arg.logData.numOfArgs = 1;
- arg.logData.len = sizeof(U32);
+ arg.logData.len = sizeof(uint32_t);
arg.arg1 = arg1;
bufsize = sizeof(LOGDATA)+arg.logData.len;
saveLogData((const void*)&arg, bufsize,g_rlogPositionIndex++);
}
-void logLev2( LOGID logId, R_LOG_LEVEL logLevel, U32 arg1, U32 arg2, ...)
+void logLev2( LOGID logId, R_LOG_LEVEL logLevel, uint32_t arg1, uint32_t arg2, ...)
{
ARG4DATA arg;
int bufsize;
arg.logData.argType = LOG_ARG_INT;
arg.logData.logLevel = logLevel;
arg.logData.numOfArgs = 2;
- arg.logData.len = 2 * sizeof(U32);
+ arg.logData.len = 2 * sizeof(uint32_t);
arg.arg1 = arg1;
arg.arg2 = arg2;
saveLogData((const void*)&arg, bufsize,g_rlogPositionIndex++);
}
-void logLev3( LOGID logId, R_LOG_LEVEL logLevel, U32 arg1, U32 arg2, U32 arg3, ...)
+void logLev3( LOGID logId, R_LOG_LEVEL logLevel, uint32_t arg1, uint32_t arg2, uint32_t arg3, ...)
{
ARG4DATA arg;
int bufsize;
arg.logData.argType = LOG_ARG_INT;
arg.logData.logLevel = logLevel;
arg.logData.numOfArgs = 3;
- arg.logData.len = 3 * sizeof(U32);
+ arg.logData.len = 3 * sizeof(uint32_t);
arg.arg1 = arg1;
arg.arg2 = arg2;
saveLogData((const void*)&arg, bufsize,g_rlogPositionIndex++);
}
-void logLev4( LOGID logId, R_LOG_LEVEL logLevel, U32 arg1, U32 arg2, U32 arg3, U32 arg4, ...)
+void logLev4( LOGID logId, R_LOG_LEVEL logLevel, uint32_t arg1, uint32_t arg2, uint32_t arg3, uint32_t arg4, ...)
{
ARG4DATA arg;
arg.logData.argType = LOG_ARG_INT;
arg.logData.logLevel = logLevel;
arg.logData.numOfArgs = 4;
- arg.logData.len = 4 * sizeof(U32);
+ arg.logData.len = 4 * sizeof(uint32_t);
arg.arg1 = arg1;
arg.arg2 = arg2;
#ifndef RLOG_ENABLE_TEXT_LOGGING
#ifdef RLOG_USE_TTI_LOGGING
- logLev1(L_TIME_REFERENCE, L_ALWAYS, (U32)time(NULL));
+ logLev1(L_TIME_REFERENCE, L_ALWAYS, (uint32_t)time(NULL));
#endif
#endif
}
{
#ifndef RLOG_ENABLE_TEXT_LOGGING
#ifdef RLOG_USE_TTI_LOGGING
- logLev1(L_TIME_TTI_UPDT, L_ALWAYS, (U32)time(NULL));
+ logLev1(L_TIME_TTI_UPDT, L_ALWAYS, (uint32_t)time(NULL));
#endif
#endif
}
#endif
{
#ifndef RLOG_ENABLE_TEXT_LOGGING
- U32 logLength;
+ uint32_t logLength;
Data* logPtr;
startL2Logging = 1;
if(mBuf == NULL)
{
printf("NULL MBUF received \n");
- RETVOID;
+ return;
}
/* Get Buffer pointer and length. This is SOC specific function which
will extract Log-Buffer pointer and length from mBuf */
rlSetL2LogBuf(logPtr,logLength);
readL2LogBuff();
#endif
- RETVOID;
+ return;
}
/* This function will get tick from RLC/CL and will process logs
according to tick threshold. Tick threshold is SOC specific */
Void rlProcessTicks(void)
{
- static U32 rlogTickCount;
+ static uint32_t rlogTickCount;
numTtiTicks++;
if(++rlogTickCount >= RLOGTICKSCNTTOPRCL2LOGS)
{
/* L3 specific functions */
}
}
- RETVOID;
+ return;
}
#ifndef RLOG_ENABLE_TEXT_LOGGING
Void readL2LogBuff(void)
{
/* Validate global buffer pointer and length */
- U8 ret;
+ uint8_t ret;
ret = rlValidateL2LogBuf();
if(ret != ROK)
{
rlInvalidateL2LogsInCache(g_logBufRcvdFromL2 - sizeof(g_logBufLenRcvdFromL2) , (g_logBufLenRcvdFromL2 + sizeof(g_logBufLenRcvdFromL2)));
rlResetL2LogBuf();
g_writeCirBuf = 0;
- RETVOID;
+ return;
}
//////////////////////////////////////////////////////////////////////////
#ifdef ANSI
void rlSetL2LogBuf
(
-U8 *l2LogBuf,
-U32 l2logLen
+uint8_t *l2LogBuf,
+uint32_t l2logLen
)
#else
void rlSetL2LogBuf(l2LogBuf,l2logLen)
-U8 *l2LogBuf;
-U32 l2logLen;
+uint8_t *l2LogBuf;
+uint32_t l2logLen;
#endif
{
g_logBufRcvdFromL2 = l2LogBuf;
typedef struct
{
time_t tv_sec;
- U32 ms_tti;
+ uint32_t ms_tti;
} __attribute__ ((__packed__)) LOGTIME;
typedef struct
unsigned int argType :2;
unsigned int logLevel :3;
unsigned int numOfArgs :3;
- U16 len;
+ uint16_t len;
} __attribute__ ((__packed__)) LOGDATA;
typedef struct
typedef struct
{
LOGDATA logData;
- U32 arg1;
- U32 arg2;
- U32 arg3;
- U32 arg4;
+ uint32_t arg1;
+ uint32_t arg2;
+ uint32_t arg3;
+ uint32_t arg4;
char unusedByte[19]; /* To make it as 50 byte */
} __attribute__ ((__packed__)) ARG4DATA;
typedef struct
{
LOGDATA logData;
- U8 splEnum;
- U32 splArg;
- U32 arg1;
- U32 arg2;
- U32 arg3;
- U32 arg4;
+ uint8_t splEnum;
+ uint32_t splArg;
+ uint32_t arg1;
+ uint32_t arg2;
+ uint32_t arg3;
+ uint32_t arg4;
char unusedByte[14]; /* To make it as 50 byte */
} __attribute__ ((__packed__)) SPL_ARGDATA;
typedef struct
{
- U16 version;
- U32 dummy32;
- U8 endianType;
+ uint16_t version;
+ uint32_t dummy32;
+ uint8_t endianType;
char szTimeZone[RLOG_TIME_ZONE_LEN+1];
- U16 END_MARKER;
+ uint16_t END_MARKER;
time_t time_sec;
} __attribute__ ((__packed__)) FILE_HEADER;
typedef struct {
char szTaskName[RLOG_MAX_TAX_NAME];
- U8* logBuff; /* LOG Buffer */
- U32 logBufLen; /* Data Written till now */
- U32 logReadPos; /* Reader thread position */
- U8 listIndex; /* Index to global list */
+ uint8_t* logBuff; /* LOG Buffer */
+ uint32_t logBufLen; /* Data Written till now */
+ uint32_t logReadPos; /* Reader thread position */
+ uint8_t listIndex; /* Index to global list */
} THREAD_DATA;
extern void rlInitL2SocSpecific(void);
//extern void processL2LogBuff(void);
extern void rlProcessTicks(void);
-extern void rlGetL2LogBufPtr (void *mBuf, U32 *logLen,U8 **logPtr);
-extern void rlInvalidateL2LogsInCache(U8 *ptr,U32 len);
-
-extern U8 *g_l2rlogBuf; /* buffer pointer for shared memory allocation */
-extern U8 *g_l2LogBufStartPtr; /* buffer pointer where logs has to be written */
-extern U8 *g_l2LogBufBasePtr; /* Base pointer for log buffer */
-extern U8 *g_logBufRcvdFromL2; /* Buffer pointer received from L2 at L3*/
-extern U8 *g_l2LogBaseBuff; /* Base log buffer received at L3 */
-extern U32 g_l2LogBufLen; /* Log Buffer length written at L2 */
-extern U32 startL2Logging; /* flag to start processing of L2 logs */
-extern U32 g_l2logBuffPos; /* Log Buffer block which is in use for L2 logging */
-extern U8 g_writeCirBuf; /* Flag to indicate whether to write logs or not */
+extern void rlGetL2LogBufPtr (void *mBuf, uint32_t *logLen,uint8_t **logPtr);
+extern void rlInvalidateL2LogsInCache(uint8_t *ptr,uint32_t len);
+
+extern uint8_t *g_l2rlogBuf; /* buffer pointer for shared memory allocation */
+extern uint8_t *g_l2LogBufStartPtr; /* buffer pointer where logs has to be written */
+extern uint8_t *g_l2LogBufBasePtr; /* Base pointer for log buffer */
+extern uint8_t *g_logBufRcvdFromL2; /* Buffer pointer received from L2 at L3*/
+extern uint8_t *g_l2LogBaseBuff; /* Base log buffer received at L3 */
+extern uint32_t g_l2LogBufLen; /* Log Buffer length written at L2 */
+extern uint32_t startL2Logging; /* flag to start processing of L2 logs */
+extern uint32_t g_l2logBuffPos; /* Log Buffer block which is in use for L2 logging */
+extern uint8_t g_writeCirBuf; /* Flag to indicate whether to write logs or not */
//extern Pst g_rlog_pst;
#endif /* __RL_H__*/
************************************************************************/
#include "envopt.h"
#include "envdep.h"
-
+#include"stdint.h"
#include "rl_interface.h"
#include "rl_rlog.h"
#include "rl_platform.h"
g_l2LogBufStartPtr = g_l2rlogBuf + sizeof(g_l2LogBufLen);
#endif
- RETVOID;
+ return;
}
//////////////////////////////////////////////////////////////////////////
l2rlogBuf_post = g_l2LogBufBasePtr; /* copy logBufferPointer for later use */
/* Set L2 Log Buffer length in first 4 bytes of flat buffer */
- *((U32*) g_l2LogBufBasePtr) = g_l2LogBufLen; /* Set L2 Log Buffer length in
+ *((uint32_t*) g_l2LogBufBasePtr) = g_l2LogBufLen; /* Set L2 Log Buffer length in
first 4 bytes of flat buffer */
/* Re-setting pointer so that L2 will use this to write logs */
}
#endif
- RETVOID;
+ return;
}
//////////////////////////////////////////////////////////////////////////
void rlGetL2LogBufPtr
(
void *mBuf,
- U32 *logLen,
+ uint32_t *logLen,
Data **logPtr
)
{
/* Get Buffer pointer and length */
*logPtr = ((Data *)mBuf) + sizeof(logLen);
- *logLen = *((U32 *) mBuf);
+ *logLen = *((uint32_t *) mBuf);
}
//////////////////////////////////////////////////////////////////////////
void rlInvalidateL2LogsInCache
(
Data *ptr,
- U32 len
+ uint32_t len
)
{
- RETVOID;
+ return;
}
/**********************************************************************
void rlInitL2SocSpecific(void);
void processL2LogBuff(void);
-void rlGetL2LogBufPtr(void *mBuf,U32 *logLen,Data **logPtr);
-void rlInvalidateL2LogsInCache(Data *ptr,U32 len);
+void rlGetL2LogBufPtr(void *mBuf,uint32_t *logLen,Data **logPtr);
+void rlInvalidateL2LogsInCache(Data *ptr,uint32_t len);
extern void rlInitL2SocSpecific(void);
extern void processL2LogBuff(void);
-extern void rlGetL2LogBufPtr(void *mBuf,U32 *logLen,Data **logPtr);
+extern void rlGetL2LogBufPtr(void *mBuf,uint32_t *logLen,Data **logPtr);
/**********************************************************************
End of file
Code Review / o-du / l2.git / commitdiff