src/5gnrmac/rg.x

   1 /*******************************************************************************
   2 ################################################################################
   3 #   Copyright (c) [2017-2019] [Radisys]                                        #
   4 #                                                                              #
   5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
   6 #   you may not use this file except in compliance with the License.           #
   7 #   You may obtain a copy of the License at                                    #
   8 #                                                                              #
   9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
  10 #                                                                              #
  11 #   Unless required by applicable law or agreed to in writing, software        #
  12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
  13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
  14 #   See the License for the specific language governing permissions and        #
  15 #   limitations under the License.                                             #
  16 ################################################################################
  17 *******************************************************************************/
  18
  19 /**********************************************************************
  20
  21     Name:   LTE MAC layer
  22
  23     Type:   X include file
  24
  25     Desc:   Defines required by LTE MAC
  26
  27     File:  rg.x
  28
  29 **********************************************************************/
  30
  31 /** @file rg.x
  32 @brief This file contains basic data structures for the Mac.
  33 */
  34
  35 #ifndef __RGX__
  36 #define __RGX__
  37
  38 #ifdef __cplusplus
  39 extern "C" {
  40 #endif /* __cplusplus */
  41
  42 #ifdef EMTC_ENABLE
  43 #include "rg_emtc.x"            /* typedefs for MAC */
  44 #endif
  45
  46 /** @brief Logical Channel Id */
  47 typedef RgPrgLteLcgId      LteLcgId;
  48 typedef RguDDatReqInfo     RgRguDedDatReq;
  49 typedef RguCDatReqInfo     RgRguCmnDatReq;
  50 typedef RguDStaRspInfo     RgRguDedStaRsp;
  51 typedef RguCStaRspInfo     RgRguCmnStaRsp;
  52 typedef RguDStaIndInfo     RgRguDedStaInd;
  53 typedef RguCStaIndInfo     RgRguCmnStaInd;
  54 typedef RguDDatIndInfo     RgRguDedDatInd;
  55 typedef RguCDatIndInfo     RgRguCmnDatInd;
  56 typedef RguLchStaInd       RgRguLcStaInd;
  57 typedef TfuPdschDciInfo    RgTfuPdschDciInfo;
  58 typedef TfuDatReqInfo      RgTfuDatReqInfo;
  59 typedef TfuDatReqPduInfo   RgTfuDatReqPduInfo;
  60 typedef RguDDatReqPerUe    RgRguDDatReqPerUe;
  61 #ifdef L2_OPTMZ
  62 typedef TfuDatReqTbInfo    RgTfuDatReqTbInfo;
  63 #endif
  64
  65 #ifdef LTE_L2_MEAS
  66 typedef struct rgL2MeasCb     RgL2MeasCb;
  67 typedef struct rgQciCb        RgQciCb;
  68
  69 typedef RguL2MUlThrpMeasReqInfo RgRguL2MUlThrpMeasReq;
  70
  71 #endif /* LTE_L2_MEAS */
  72 /* Forward declarations for some structures */
  73 typedef struct rgUeCb         RgUeCb;
  74 typedef struct rgErrInfo      RgErrInfo;
  75 typedef struct rgCellCb       RgCellCb;
  76 typedef struct rgUlHqProcCb   RgUlHqProcCb;
  77 typedef struct rgDlHqProcCb   RgDlHqProcCb;
  78 typedef struct rgLcgCb        RgLcgCb;
  79 typedef struct rgDlHqEnt      RgDlHqEnt;
  80 typedef struct _rgCb          RgCb;
  81 typedef RgPrgUlLcInfo         RgUlLcCb;
  82 typedef RgPrgDlLcInfo         RgDlLcCb;
  83
  84
  85 #ifdef LTE_L2_MEAS
  86 /* @brief UE Specific Uplink allocation info needed for measurements */
  87 typedef struct rgUeUlAlloc
  88 {
  89    CmLteRnti        rnti;      /*!< Ue Id */
  90    uint8_t          numPrb;    /*!< Number of total PRB's allocated for this UE */
  91 } RgUeUlAlloc;
  92 /**
  93  * @brief Structure hold uplink allocation information for sub frames.
  94  * */
  95 typedef struct rgUlSf
  96 {
  97    CmLteTimingInfo schdTime;       /*!< scheduled frame and subframe number */
  98    uint8_t         numUe;          /*!< Number of UE's allocated in this uplink  subframe */
  99    RgUeUlAlloc     *ueUlAllocInfo; /*!< Uplink alloc infor for this subframe */
 100 } RgUlSf;
 101
 102 /** @brief
 103  *  L2 measurement control block.
 104  *  */
 105 struct rgL2MeasCb
 106 {
 107    CmLList            measLnk;        /*!< MeasCb node */
 108    RgInfL2MeasReq     measReq;        /*!< Request received for measurement */
 109    CmLteTimingInfo    startTime;      /*!< Time at which measurement started */
 110    uint32_t           sfnCycle;       /*!< Count of Num of SFN wraps */
 111 };
 112 /** @brief
 113  *  Control block to store Logical Channels with Qci.
 114  *  */
 115 struct rgQciCb
 116 {
 117    uint8_t          qci;      /*< QCI for measurement */
 118    uint32_t         prbCount; /*!< Cummulative PRB count */
 119    uint8_t          mask;     /*!< Measurement Active or Not*/
 120    CmLteTimingInfo  startTime;/*!< Time at which measurement started */
 121 };
 122 #endif /* LTE_L2_MEAS */
 123 /**
 124   * @brief
 125   * Information about one PDCCH.
 126   */
 127 typedef struct rgPdcch {
 128    CmLteRnti         rnti;    /*!< RNTI to who the PDCCH is allocated */
 129    RgTfuPdschDciInfo dci;     /*!< PDCCH format */
 130 } RgPdcch;
 131
 132 typedef struct rgBcchTb
 133 {
 134    RgPdcch        pdcch;
 135    Buffer         *tb;
 136    uint16_t       txPwrOffset; /*!< PDSCH Tx Pwr offset */
 137 } RgBcchTb;
 138
 139 typedef struct rgPcchTb
 140 {
 141    RgPdcch        pdcch;
 142    Buffer         *tb;
 143    uint16_t       txPwrOffset; /*!< PDSCH Tx Pwr offset */
 144 } RgPcchTb;
 145
 146 typedef struct rgRaRspAlloc
 147 {
 148    RgPdcch        pdcch;     /*!< NULLP if no Rsp allocation done for raRnti*/
 149    Buffer         *rar;
 150    uint16_t       txPwrOffset; /*!< PDSCH Tx Pwr offset */
 151 }RgRaRspAlloc;
 152
 153 typedef struct rgBchTb
 154 {
 155    Buffer         *tb;    /*!< BCH data for this frame */
 156 }RgBchTb;
 157
 158
 159 typedef struct rgDlSf
 160 {
 161    CmLteTimingInfo schdTime;  /*!< scheduled frame and subframe number */
 162    Bool            txDone;     /*!< Flag to indicate transmission done */
 163 /* ADD Changes for Downlink UE Timing Optimization */
 164 #ifdef LTEMAC_DLUE_TMGOPTMZ
 165    uint8_t         remDatReqCnt; /*!< Counter to maintain count of Ded data received.*/
 166    /* Fix [ccpu00126310]: Tracks Data Requests from RLC for both loosely and tight coupled
 167       RLC-MAC */
 168    Bool            statIndDone; /*!< Marks sending of all status indication done */
 169 #endif
 170    RgBchTb         bch;        /*!< BCH data for this frame */
 171    RgBcchTb        bcch;       /*!< BCCH allocation for this frame */
 172 #ifdef EMTC_ENABLE
 173    RgEmtcBcchTb    emtcBcch;   /*!< EMTC BCCH allocation for this frame */
 174 #endif
 175    RgPcchTb        pcch;       /*!< PCCH allocation for this frame */
 176    CmLListCp       tbs;        /*!< TBs or DL HARQ processes */
 177    uint8_t         numRaRsp;   /*!< No.of RaRsp */
 178    RgRaRspAlloc    raRsp[RG_MAX_RA_RNTI]; /* Array of list of Ra Rsp
 179                                        Allocations for each rarnti */
 180    uint8_t         numTbReqsSent;        /*!< Number of TB requests sent towards SMAC.
 181    Total numTbReqsSent will be equal to maximum secondary cells */
 182 } RgDlSf;
 183
 184 /**
 185   * @brief
 186   * Logical channel control block for BCCH and PCCH channels.
 187   */
 188 typedef struct rgBcchDlschLcCb
 189 {
 190    CmLteLcId       lcId;                     /*!< Logical channel ID */
 191    Buffer          *tb;
 192 } RgBcchDlschLcCb;
 193
 194 typedef struct rgBcchBchLcCb
 195 {
 196    CmLteLcId       lcId;                     /*!< Logical channel ID */
 197 } RgBcchBchLcCb;
 198
 199 typedef struct rgPcchLcCb
 200 {
 201    CmLteLcId       lcId;                     /*!< Logical channel ID */
 202 } RgPcchLcCb;
 203
 204 /**
 205   * @brief
 206   * Random access information per cell.
 207   */
 208 typedef struct rgRaInfoCb
 209 {
 210    CmLListCp       ueRachLst;                   /*!< List of RaCbs */
 211 } RgRaInfoCb;
 212
 213 typedef struct rgSchInstMap
 214 {
 215    S16          cellSapId; /*!< SAP ID of the cell in scheduler instance */
 216    Inst          schInst;  /*!< Scheduler instance that is serving this cell*/
 217 } RgSchInstMap;
 218
 219 /**
 220   * @brief
 221   * Configuration Information for Upper SAPs at RGU,CRG and RGR interfaces.
 222   */
 223 typedef struct rgUpSapCfgInfo
 224 {
 225    Pst  sapPst;              /*!< Post information associated with SAP */
 226    SpId spId;                /*!< SpId associated with SAP */
 227    SuId suId;                /*!< SuId associated with SAP */
 228 }RgUpSapCfgInfo;
 229
 230 /**
 231   * @brief
 232   * Configuration Information for Lower SAP at TFU interface
 233   */
 234 typedef struct rgLowSapCfgInfo
 235 {
 236    Pst    sapPst;            /*!< Post information associated with SAP */
 237    SpId   spId;              /*!< SpId associated with SAP */
 238    SuId   suId;              /*!< SuId associated with SAP */
 239    TmrCfg bndTmr;            /*!< Bind Timer Value */
 240 }RgLowSapCfgInfo;
 241
 242 /**
 243   * @brief
 244   * Control Block structure for Upper SAPs at RGU,CRG and RGR interfaces.
 245   */
 246 typedef struct rgUpSapCb
 247 {
 248    RgUpSapCfgInfo sapCfg;    /*!< Configuration information */
 249    RgSapSts     sapSts;      /*!< Statistics related to SAP */
 250    RgSapSta     sapSta;      /*!< SAP Status */
 251 }RgUpSapCb;
 252
 253 /**
 254   * @brief
 255   * Control Block structure for Lower SAP at TFU interface.
 256   */
 257 typedef struct rgLowSapCb
 258 {
 259    RgLowSapCfgInfo sapCfg;          /*!< SAP configuration information */
 260    RgSapSts        sapSts;          /*!< Statistics related to SAP */
 261    RgSapSta        sapSta;          /*!< SAP Status */
 262    uint8_t         numBndRetries;   /*!< Number of Bind Retries */
 263 }RgLowSapCb;
 264
 265 /**
 266   * @brief
 267   * MAC sub-header control block for 5G-NR MAC
 268   * sub-hdr for fixed size MAC CE - 1 octat(R/R/LCID)
 269   * sub-hdr for variable size MAC CE or MAC SDU -2/3 octat(R/F/LCID/L(8/16 bits))
 270   *
 271   */
 272 typedef struct RgMUXSubHdr
 273 {
 274    uint8_t shLen;
 275    uint8_t shData[RG_MAX_SDU_SUB_HDR_LEN]; /* RRLCID/RFLCID + F-L (O) + L (O) */
 276 } RgMUXSubHdr;
 277
 278
 279 /**
 280   * @brief
 281   * Cell Control block per cell
 282   */
 283 struct rgCellCb
 284 {
 285    CmHashListEnt   cellLstEnt;       /*!< Hash list Entity for cell list */
 286    RgSchInstMap    schInstMap;      /*!< Sch Inst Info */
 287    CmLteCellId     cellId;           /*!< Cell ID */
 288    CmLteTimingInfo crntTime;
 289    uint8_t         maxDlHqProcPerUe;  /*!< Store based on FDD/TDD(UL/DL Index) */
 290    CrgBwCfg        bwCfg;            /*!< Bandwidth Configuration */
 291    CrgRachCfg      rachCfg;          /*!< RACH Configuration */
 292
 293    RgUpSapCb       *rguDlSap;            /*!< RGU SAP Control Block for RLC DL  */
 294    RgUpSapCb       *rguUlSap;           /*!< RGU SAP Control Block  for RLC UL*/
 295    Inst            macInst;            /*!< MAC Instance id for this cell */
 296    uint8_t         cellActvState;      /*!< Bitmask indicating if cell is active:
 297                                        Cell is active only after BCCH, PCCH, DL
 298                                        CCCH, UL CCCH and scheduler config */
 299    CmLteLcId       ulCcchId;         /*!< LcId for uplink CCCH */
 300    CmLteLcId       dlCcchId;         /*!< LcId for downlink CCCH */
 301    RgBcchBchLcCb   bcchBchInfo;      /*!< BCCH mapped on BCH
 302                                        logical channel control block */
 303    RgPcchLcCb      pcchInfo;        /*!< PCCH logical channel control block */
 304    uint8_t         numBcchDlschInfo;
 305    RgBcchDlschLcCb bcchDlschInfo[RG_MAX_BCCH_DLSCH]; /*!< BCCH mapped on DLSCH
 306                                              logical channel control block */
 307    CmHashListCp    ueLst;            /*!< Hash list of UE control
 308                                                    blocks: RgUeCb */
 309    /*Added support for SPS*/
 310 #ifdef LTEMAC_SPS
 311    CmHashListCp    spsUeLst;         /*!< Hash list of UECbs with SPS-Rnti
 312                                                   : Element is RgUeCb */
 313 #endif
 314    RgRaInfoCb      raInfo;           /*!< Random access related information for
 315                                           cell */
 316    RgDlSf          subFrms[RG_NUM_SUB_FRAMES];
 317 #ifdef LTE_L2_MEAS
 318    CmLListCp       l2mList;                     /*!< List of all L2M requests
 319                                                      rgSchL2MeasCb */
 320    RgQciCb         qciArray[LRG_MAX_QCI];       /*!< List of all qci's configured
 321                                                       rgQciCb */
 322    RgUlSf          ulSf[RG_NUM_UL_SUB_FRAMES];  /*!< UL Sub frame */
 323    Bool            sndL2Meas;                   /*!< Send L2 Meas when No L2 Measuremnt timer is running*/
 324
 325    uint32_t        ttiCycle;             /*!< Count of Number of 10240 Cycles
 326                                              completed */
 327
 328 #endif /* LTE_L2_MEAS */
 329    RguFlowCntrlInd  *flowCntrlInd;        /*!<Pre Alloced buffer for flow control */
 330    /* RRM_SP1_START */
 331    uint32_t             qcisUlPrbCnt[RG_MAX_QCI_REPORTS];         /*!< GBR Lc PRB count */
 332    /* RRM_SP1_END */
 333 #ifdef LTE_ADV
 334   //RgLaaTbReq  *laaCellHqPLst[RG_MAX_SCELL_PER_UE]; /*!< LAA: List containing of TBs requested per
 335                                             //SCELL*/
 336   Void * laaCb;
 337 #endif
 338 #ifdef EMTC_ENABLE
 339     uint8_t               emtcEnable;
 340 #endif
 341 };
 342
 343 /**
 344   * @brief
 345   * Uplink HARQ entity information per UE.
 346   */
 347 typedef struct rgUlHqEnt
 348 {
 349    uint8_t           maxHqRetx;        /*!< Maximum number of harq
 350                                    * re-transmissions */
 351 } RgUlHqEnt;
 352 #ifdef LTE_L2_MEAS
 353
 354 /**
 355   * @brief Structure to hold Uplink throughtput info for L2 measurement.
 356   *
 357   * @details
 358   *   - outStndngBs     : outstanding buffer status
 359   *   - firstDatSegRcvd : first dat req seg recvd
 360   *   - frstSegTimInfo  : fisrt seg time information
 361   *   - nextSegTimInfo  : next seg time information
 362   *   - segInd          : UL thrgouthput indication
 363   *   - fSegTtiCycNum   : First Seg tti cycles
 364   *   - nSegTtiCycNum   : next seg tti cycles
 365   */
 366 typedef struct rgL2MeasUlThrP
 367 {
 368    S32 outStndngBs;                 /*!< outstanding buffer status*/
 369    Bool firstDatSegRcvd;            /*!< first dat req seg recvd*/
 370    CmLteTimingInfo frstSegTimInfo;  /*!< fisrt seg time information*/
 371    CmLteTimingInfo nextSegTimInfo;  /*!< next seg time information*/
 372    RguL2MUlThrpSegInd segInd;       /*!< UL thrgouthput indication*/
 373    uint32_t fSegTtiCycNum;               /*!< First Seg tti cycles*/
 374    uint32_t nSegTtiCycNum;               /*!< next seg tti cycles*/
 375 } RgL2MeasUlThrP;
 376 #endif
 377
 378 /**
 379   * @brief
 380   * Logical channel group
 381   */
 382 struct rgLcgCb
 383 {
 384    /* Right now not keeping associated logical channels, searching for
 385     * associated channels needed only during config */
 386    LteLcgId    lcgId;  /*!< Group ID */
 387    uint8_t     lcCount;
 388 #ifdef LTE_L2_MEAS
 389
 390    RgL2MeasUlThrP lcgBsInfo;
 391
 392 #endif
 393    Bool        isGbr;  /*!< Indicate if LCG is GBR LCG */
 394 };
 395
 396
 397
 398
 399 /**
 400   * @brief
 401   * Uplink control block for UE specific information
 402   */
 403 typedef struct rgUeUlCb
 404 {
 405    RgUlHqEnt  hqEnt;      /*!< Uplink HARQ information for the UE */
 406    RgUlLcCb   lcCb[RG_MAX_LC_PER_UE]; /*!< Dedicated Uplink logical channel
 407                                            information */
 408    RgLcgCb    lcgArr[RG_MAX_LCG_PER_UE]; /*!< Logical channel groups */
 409    /* Added support for SPS*/
 410 #ifdef LTEMAC_SPS
 411    Bool                 spsLcId[RG_MAX_LC_PER_UE];  /*!< Set to TRUE for SPS LCs */
 412    uint8_t              implRelCntr;    /*!< Number of empty sps transmissions for
 413                                     implicit(?) release */
 414    uint8_t              implRelCnt; /*!< Configured value of implicitRelAfter +
 415                                     RG_ADDL_SPS_OCC_FOR_EXP_REL */
 416    uint8_t              explRelCntr;/*!< Counter to track explicit release */
 417    uint8_t              explRelCnt; /*!< Count to trigger explicit release */
 418 /*Added for explicit release - start*/
 419    uint8_t              spsDatRcvd; /*!< Count to track SPS data for explicit
 420                      release*/
 421    uint32_t             totSpsDatRcvd; /*!< total number of SPS data recieved
 422                      from activation*/
 423 #endif
 424 } RgUeUlCb;
 425
 426 /**
 427   * @brief
 428   * Logical channel data as being scheduled by the scheduler.
 429   */
 430 typedef struct rgLchSchdData
 431 {
 432    CmLteLcId       lcId;       /*!< Logical channel ID */
 433    uint32_t        schdSz;   /*!< Scheduled logical channel data */
 434 } RgLchSchdData;
 435
 436 /**
 437   * @brief
 438   * Contention Resolution ID.
 439   */
 440 typedef struct RgContResId
 441 {
 442    uint8_t        resId[RG_CRES_LEN];
 443 }RgContResId;
 444
 445 /**
 446   * @brief
 447   * Used to keep sf and SfLnk in Tb.
 448   */
 449 typedef struct rgTbSfLnkInfo
 450 {
 451    RgDlSf          *sf;   /*!< Sf pointer to check if SfAlloc came for Tb in a SF */
 452    CmLList         sfLnk; /*!< Used to queue it up on a subfrm */
 453 }RgTbSfLnkInfo;
 454
 455 /**
 456   * @brief
 457   * Transport Block Info scheduled by the scheduler.
 458   */
 459 typedef struct rgTbInfo{
 460    uint8_t              numSchLch;
 461    RgLchSchdData        schdData[RG_MAX_NUM_DED_LC];
 462    TknUInt8             schdTa;  /*!< TA scheduled to be sent */
 463    /* Changed as a result of CR timer implementation*/
 464    uint8_t              contResCe;   /*!< Contention Resolution CE scheduled
 465                                    to be sent */
 466    RgContResId          *contResId;  /*!< Contention Resolution Identity */
 467 #ifndef L2_OPTMZ
 468    Buffer               *tb;    /*!< Multiplexed Pdu */
 469 #else
 470    /* L2 Optimization for mUe/Tti:Pre-allocated MAC Hdr, MAC CEs and padding
 471     * will be used to store and send to CL. These pointer will be allocated
 472     * during Harq Proc creation. CL shall not free these pointers.
 473     * These pointers will be freed duing harq proc deletion
 474     */
 475     RgTfuDatReqTbInfo     tb;   /* TB to be sent to CL/PHY*/
 476 #endif
 477 /* Changes for MIMO feature addition */
 478 /* Removed dependency on MIMO compile-time flag */
 479    uint32_t             tbSz;   /*!< TB size scheduled for the hqP */
 480    RgPdcch              pdcch;  /*!< PDCCH allocated for this HQ Proc */
 481    /* Adding Array of sfLnk in case of repetitions because same lnk in mutiple
 482     * list causing issues*/
 483    RgTbSfLnkInfo   sfLnkInfo[2]; /*!< Used to queue it up on a subfrm */
 484    RgDlSf          *sf;
 485    CmLteTimingInfo timingInfo; /*!<This field holds the scheduled time */
 486    TknUInt32       doa;
 487    TfuTxMode       txMode;
 488    Bool            puschRptUsd; /*!< True if Precoding Info in PDCCH has to be
 489                                    in-accordance with the latest PUSCH report */
 490    TfuDlCqiPuschInfo puschPmiInfo;/*!< PUSCH report details for explicit PMI
 491                                        * information to PHY during a PDSCH */
 492    /* LTE_ADV_FLAG_REMOVED_START */
 493 #ifdef TFU_UPGRADE
 494    uint8_t            pa;                 /* DL Power control paramter P_A
 495                                      configured by higher layers
 496                                      Ref: RRC 36.331, 6.3.2,
 497                                      PDSCH-Config*/
 498 #endif
 499    uint8_t isEnbSFR;
 500 #ifdef LTE_ADV
 501    TknUInt8           sCellActCe;     /*!< SCell Act ce scheduled to be sent */
 502 #endif
 503    /* LTE_ADV_FLAG_REMOVED_END */
 504 }RgTbInfo;
 505
 506 /**
 507   * @brief`
 508   * Downlink HARQ process information per UE.
 509   */
 510 struct rgDlHqProcCb
 511 {
 512    uint8_t         procId;    /*!< HARQ process ID */
 513 /* Changes for MIMO feature addition */
 514 /* Removed dependency on MIMO compile-time flag */
 515    uint8_t         numOfTBs;
 516    RgTbInfo        tbInfo[RG_MAX_TB_PER_UE];
 517    uint16_t             saveId; // laa
 518 #ifdef LTE_L2_MEAS
 519
 520    uint32_t        tbId[RGU_MAX_TB];          /*!< RLC's internal tbId */
 521    uint16_t        status[RGU_MAX_TB];        /*!< Status back to RLC ACK/NACK*/
 522 #endif /* LTE_L2_MEAS */
 523 /* Changes for MIMO feature addition */
 524 /* Removed dependency on MIMO compile-time flag */
 525 };
 526
 527
 528 /**
 529   * @brief
 530   * Downlink HARQ entity information per UE.
 531   */
 532 struct rgDlHqEnt
 533 {
 534    uint8_t       numHqProcs;
 535    RgDlHqProcCb  *procs[RG_MAX_DL_HARQ_NUM]; /*!< Downlink harq processes */
 536    CmLListCp     savedProcLst[RG_MAX_DL_HARQ_NUM]; /*!< laa: Saved TBs for the release Hq Procs*/
 537 };
 538
 539
 540
 541 /**
 542   * @brief
 543   * Downlink control block for UE specific information.
 544   */
 545 typedef struct rgUeDlCb
 546 {
 547    RgDlHqEnt  hqEnt;        /*!< Downlink HARQ information for the UE */
 548    RgDlLcCb   lcCb[RG_MAX_LC_PER_UE];/*!< Dedicated Downlink logical channels in
 549 UE */
 550 } RgUeDlCb;
 551
 552 #ifdef LTE_ADV
 553 typedef struct rgSCellAddCfgCfmInfo
 554 {
 555    CrgCfgTransId   transId;   /*!< Scell add transaction id*/
 556    uint8_t         numSCells; /*!< Used to check if config cfm rcvd from all Scells*/
 557    uint8_t         cfgCfgCount; /*!< Keep count of cfg confirms recvd */
 558    uint8_t         mask; /*!< Cfg cfm mask */
 559 }RgSCellAddCfgCfmInfo;
 560
 561 typedef struct rgSCelInfo
 562 {
 563    Bool           isSCellAdded;     /*!< is Cell Added TRUE/FALSE */
 564    Inst           macInst;          /*!< MAC Instance of that
 565                                          Cell Added */
 566    CmLteCellId    sCellId;          /*!< Secondary Cell ID */
 567 }RgSCelInfo;
 568
 569 #endif
 570
 571 /**
 572   * @brief
 573   * UE control block for UE specific information
 574   */
 575 struct rgUeCb
 576 {
 577    CmHashListEnt     ueLstEnt;   /*!< Hash List entity for UE List */
 578    /* Added suport for SPS*/
 579 #ifdef LTEMAC_SPS
 580    CmHashListEnt     spsUeLstEnt;/*!< Hash List entity for SPS Rnti */
 581 #endif
 582    CmLList           rachLstEnt; /*!< Link List entity for RACH UE List*/
 583    CmLteRnti         ueId;       /*!< UE identifier */
 584    /* Added suport for SPS*/
 585 #ifdef LTEMAC_SPS
 586    CmLteRnti         spsRnti;    /*!< SPS-Rnti for the UE */
 587 #endif
 588    RgContResId       contResId;  /*!< Contention Resolution Identity */
 589    RgUeUlCb          ul;        /*!< UE Specific Uplink information */
 590    RgUeDlCb          dl;        /*!< UE Specific Downlink information */
 591 /* Changes for MIMO feature addition */
 592 /* Removed dependency on MIMO compile-time flag */
 593    CrgTxMode         txMode;      /*!< UE Transmission mode Cfg */
 594    RgUpSapCb        *rguDlSap;    /*!< RGU SAP Control Block for RLC DL  */
 595    RgUpSapCb        *rguUlSap;    /*!< RGU SAP Control Block  for RLC UL*/
 596 #ifdef LTE_ADV
 597    RgSCelInfo        sCelInfo[RG_MAX_SCELL_PER_UE]; /*!<sCell Information */
 598    RgSCellAddCfgCfmInfo cfgCfmInfo; /*!< Scell add cfg cfm info*/
 599 #endif /* LTE_ADV */
 600 };
 601
 602 /**
 603   * @brief
 604   * structure holding Layer Manager Response information cached from control
 605   * request.
 606   */
 607 typedef struct rgLmResponse
 608 {
 609    TranId transId;           /*!< Transaction ID */
 610    Resp   response;          /*!< Response */
 611 }RgLmResponse;
 612
 613 /**
 614   * @brief
 615   * Structure holding LTE MAC's General Configuration Information.
 616   */
 617 typedef struct rgGenCb
 618 {
 619    uint8_t      tmrRes;           /*!< Timer resolution */
 620    RgLmResponse trcResp;          /*!< Response value for Trace Indication */
 621    RgLmResponse ustaResp;         /*!< Respones value for Alarms */
 622    RgLmResponse bndCfmResp;       /*!< Respones value for Bind Confirm */
 623    Status       memUpperThr;      /*!< upper threshold of the memory pool */
 624    Status       memLowerThr;      /*!< lower threshold of the memory pool */
 625 }RgGenCb;
 626
 627
 628
 629 /**
 630   * @brief
 631   * Global Control block for LTE-MAC.
 632   */
 633 struct _rgCb
 634 {
 635    TskInit      rgInit;                    /*!< Task Init information */
 636    S16          trcLen;                    /*!< trace length */
 637    RgGenCb      genCfg;                    /*!< General Config information */
 638    uint8_t      numRguSaps;                /*!< Numb of RGU SAP Control Block */
 639    RgUpSapCb    *rguSap;                     /*!< RGU SAP Control Block */
 640    RgUpSapCb    crgSap;                    /*!< CRG SAP Control Block */
 641    RgLowSapCb   tfuSap;                    /*!< TFU SAP Control Block */
 642    RgGenSts     genSts;                    /*!< General Statistics */
 643    CmTqCp       tmrTqCp;                   /*!< Timer Task Queue Cntrl Point */
 644    CmTqType     tmrTq[RG_TQ_SIZE];         /*!< Timer Task Queue */
 645    CmTimer      tmrBlk[RG_MAX_TIMER];      /*!< Timer Block */
 646    RgCellCb *inactiveCell;                     /*!< Reference of last accessed cellCb*/
 647    RgCellCb *cell;                     /*!< Reference of last accessed cellCb*/
 648    RgCellCb *prevCell;                     /*!< Reference of last accessed cellCb*/
 649    uint8_t bufCnt;                              /*!< Count of buffers in buffersToFree[] */
 650    Buffer *bufToFree[RG_MAX_DFRD_FREE_BUFS];/*!< List of Shared Buffers to be freed */
 651 };
 652
 653 /* Declaration for RgCb */
 654 RgCb rgCb[RG_MAX_INST];
 655
 656 /**
 657   * @brief
 658   * Subheader of MAC SDU.
 659   */
 660 typedef struct rgMacSdu
 661 {
 662    CmLList    sduLstEnt;  /*!< List entry for MAC SDU subheader */
 663    CmLteLcId  lcId;       /*!< Logical channel ID */
 664    uint16_t   len;        /*!< Length of the SDU */
 665    Buffer     *mBuf;      /*!< SDU Buffer */
 666 } RgMacSdu;
 667
 668 /**
 669   * @brief
 670   * MAC PDU Contents.
 671   */
 672 typedef struct rgMacPdu
 673 {
 674    CmMemListCp memCp;     /*!< Memory control point */
 675    CmLListCp   sduLst;    /*!< List of SDUs */
 676 } RgMacPdu;
 677
 678 /**
 679   * @brief
 680   * Carries the Error Information.
 681   */
 682 struct rgErrInfo
 683 {
 684    uint8_t    errType;    /*!< Error Type */
 685    uint16_t   errCause;   /*!< Cause of Error */
 686 };
 687
 688 /**
 689   * @brief
 690   * Carries the Information to build PDU.
 691   */
 692 typedef struct rgBldPduInfo
 693 {
 694    Void           *datReq;    /*!< Common/Dedicated Dat Request */
 695    uint8_t        reqType;    /*!< EVTRGUCDATREQ/EVTRGUDDATREQ */
 696    MsgLen         schdTbSz;   /*!< Schedule TB size */
 697    uint8_t        tbIndex;    /*!< Transport Block Index */
 698    TknUInt8       ta;         /*!< Timing Advance */
 699    RgContResId    *contResId; /*!< Contention Resolution ID */
 700 #ifdef LTE_ADV
 701    TknUInt8       sCellActCe; /*!< SCell Act CE info */
 702 #endif
 703 } RgBldPduInfo;
 704
 705
 706
 707 /* APIs exposed by LIM */
 708
 709 #ifdef LTE_L2_MEAS /*LTE_L2_MEAS_PHASE2*/
 710 S16 rgAddToL2MeasPerQci ARGS ((RgCellCb  *cell,uint8_t qci));
 711 #endif
 712 S16 rgLIMTfuBndReq ARGS((
 713          Inst                 inst,
 714          SuId                 suId,
 715          SpId                 spId));
 716
 717 S16 rgLIMTfuUbndReq ARGS((
 718          Inst                 inst,
 719          SuId                 suId,
 720          Reason               reason));
 721
 722 S16 rgLIMTfuDatReq ARGS((
 723          Inst          inst,
 724          TfuDatReqInfo *datReq));
 725 #ifdef L2_OPTMZ
 726 S16 rgLIMTfuDelDatReq ARGS((
 727          Inst          inst,
 728          TfuDelDatReqInfo *datReq));
 729 #endif /*L2_OPTMZ */
 730 /* APIs exposed by TOM */
 731
 732 S16 rgTOMDatInd ARGS((
 733          Inst          inst,
 734          TfuDatIndInfo *datInd));
 735
 736 Void rgTOMRlsSf ARGS((Inst inst,RgDlSf *dlSf));
 737
 738 S16 rgSchMacSfAllocReq ARGS((Pst *pst, RgInfSfAlloc *sfInfo));
 739
 740 /*
 741  * APIs exposed by LMM
 742  */
 743 S16 rgLMMStartTmr ARGS((Inst inst,S16 tmrEvnt, uint32_t tmrVal, PTR cb));
 744 S16 rgLMMStopTmr ARGS((Inst inst,S16 tmrEvnt, PTR cb));
 745 S16 rgLMMTmrExpiry ARGS((PTR cb, S16 tmrEvnt));
 746 /* To send a Unsolicited Status Indication to Layer Manager */
 747 S16 rgLMMStaInd ARGS((Inst inst,uint16_t category, uint16_t event, uint16_t cause, RgUstaDgn *dgn));
 748 /* To send a Trace Indication to Layer Manager.
 749  * srcMbuf is not freed. caller has to take care. */
 750 Void rgLMMTrcInd ARGS((Inst inst,Buffer *srcMbuf, uint8_t event));
 751 /* LIM uses this to forward the BndCfm to LMM. This function invokes a
 752  * Control Confirmation to the LM. */
 753 S16 rgLMMBndCfm ARGS((Pst *pst, SuId suId, uint8_t status));
 754 S16 rgActvTmr ARGS((Ent ent, Inst inst ));
 755 S16 rgActvInit ARGS((Ent entity, Inst inst, Region
 756        region, Reason reason));
 757 S16 rgActvTsk ARGS((Pst *pst, Buffer *mBuf));
 758
 759 /*
 760  * APIs exposed by CFG module
 761  */
 762 S16 rgCFGVldtCrgCellCfg ARGS((Inst inst,CrgCellCfg *cellCfg, RgErrInfo *errInfo));
 763 S16 rgCFGVldtCrgUeCfg ARGS((Inst inst,CrgUeCfg  *ueCfg, RgCellCb  **cell, RgErrInfo
 764       *errInfo));
 765 S16 rgCFGVldtCrgLcCfg ARGS((Inst inst,CrgLchCfg *lcCfg, RgCellCb **cell, RgUeCb
 766       **ue, RgErrInfo  *errInfo));
 767 S16 rgCFGVldtCrgCellRecfg ARGS((Inst inst,CrgCellRecfg *cellRecfg, RgCellCb **cell,
 768       RgErrInfo *errInfo));
 769 S16 rgCFGVldtCrgUeRecfg ARGS((Inst inst,CrgUeRecfg *ueRecfg, RgCellCb **cell,
 770       RgUeCb **ue, RgErrInfo *errInfo));
 771 S16 rgCFGVldtCrgLcRecfg ARGS((Inst inst,CrgLchRecfg *lcRecfg, RgCellCb **cell,
 772       RgUeCb **ue, RgUlLcCb **ulLc, RgErrInfo *errInfo));
 773 S16 rgCFGVldtCrgUeReset ARGS ((Inst inst,CrgRst *reset,RgCellCb **cell,RgUeCb **ue,
 774          RgErrInfo   *errInfo));
 775
 776 S16 rgCFGCrgCellCfg ARGS((Inst inst,CrgCellCfg *cellCfg, RgErrInfo *errInfo));
 777 S16 rgCFGCrgUeCfg ARGS((Inst inst,RgCellCb  *cell, CrgUeCfg  *ueCfg, RgErrInfo
 778       *errInfo));
 779
 780 #ifdef LTE_ADV
 781 S16 rgFillAndAddSCellCfg ARGS((Inst inst, RgCellCb  *cell,
 782          CrgUeRecfg *ueRecfg, CrgCfgTransId transId, Bool *isCfmRqrd));
 783 S16 rgDelUeFrmAllSCell ARGS(( RgCellCb       *cell, RgUeCb         *ue));
 784 S16 rgUtlVltdAddSCellCfg ARGS ((RgPrgUeSCellCfgInfo *ueSCellCb,
 785                                        RgCellCb    *cell,
 786                                        Inst        inst
 787                                      ));
 788 S16 rgCfgAddUeSCellCfg ARGS ((Inst        dstMacInst,
 789                                     RgPrgUeSCellCfgInfo *ueSCellCb,
 790                                     RgCellCb    *cell
 791                                   ));
 792 #endif /* LTE_ADV */
 793
 794 S16 rgCFGCrgLcCfg ARGS((Inst inst,RgCellCb *cell, RgUeCb *ue, CrgLchCfg
 795       *lcCfg, RgErrInfo *errInfo,Bool *isCfmRqrd,CrgCfgTransId   transId));
 796 S16 rgCFGCrgCellRecfg ARGS((Inst inst,RgCellCb *cell, CrgCellRecfg *cellRecfg,
 797       RgErrInfo *errInfo));
 798 S16 rgCFGCrgUeRecfg ARGS((Inst inst,RgCellCb *cell, RgUeCb *ue, CrgUeRecfg
 799       *ueRecfg, RgErrInfo *errInfo));
 800 S16 rgCFGCrgLcRecfg ARGS((Inst inst,RgCellCb *cell, RgUeCb *ue, RgUlLcCb
 801       *ulLc, CrgLchRecfg *lcRecfg, RgErrInfo *errInfo, Bool *isCfmRqrd));
 802 S16 rgCFGCrgCellDel ARGS((Inst inst,CrgDel *cellDelInfo, RgErrInfo *errInfo));
 803 S16 rgCFGCrgUeDel ARGS((Inst inst,CrgDel *ueDelInfo, RgErrInfo *errInfo));
 804 S16 rgCFGCrgLcDel ARGS((Inst inst,CrgDel *lcDelInfo, RgErrInfo
 805          *errInfo,Bool *isCfmRqrd,CrgCfgTransId transId));
 806 Void rgCFGFreeCellCb ARGS((RgCellCb *cell));
 807 Void rgCFGFreeInactvCellCb ARGS((RgCellCb *cell));
 808 S16 rgSchMacCellRegReq ARGS((Pst* pst,RgInfCellReg* regReq));
 809 S16 rgCFGCrgUeReset ARGS((RgCellCb *cell,RgUeCb *ue,CrgRst *reset,
 810          RgErrInfo *errInfo));
 811
 812 /*
 813  * APIs exposed by COM module
 814  */
 815 S16 rgCOMCfgReq ARGS((Inst inst,CrgCfgTransId transId, CrgCfgReqInfo
 816          *cfgReqInfo));
 817
 818 /* APIs Exposed by UIM */
 819 S16 rgUIMRguBndCfm ARGS ((Inst inst,SuId suId, uint8_t status));
 820 S16 rgUIMSndDedStaInd ARGS ((Inst inst,RgUpSapCb *rguDlSap,RgRguDedStaInd  *staInd));
 821 S16 rgUIMSndCmnStaInd ARGS ((Inst inst,RgUpSapCb *rguDlSap,RgRguCmnStaInd  *staInd));
 822 S16 rgUIMSndDedDatInd ARGS ((Inst inst,RgUpSapCb *rguDlSap,RgRguDedDatInd  *datInd));
 823 #ifdef LTE_L2_MEAS
 824 S16 rgL2mCreateMeasCb ARGS((
 825          RgCellCb       *cell,
 826          RgInfL2MeasReq *measInfo,
 827          uint8_t         measType,
 828          RgErrInfo      *err
 829 ));
 830  S16 rgL2mMeasReq ARGS((
 831          RgCellCb       *cell,
 832          RgInfL2MeasReq *measInfo,
 833          RgErrInfo      *err
 834 ));
 835 S16 rgL2Meas ARGS ((
 836          RgCellCb  *cell
 837 ));
 838 #endif /* LTE_L2_MEAS */
 839 S16 rgUIMSndCmnDatInd ARGS ((Inst inst,RgUpSapCb *rguSap,RgRguCmnDatInd  *datInd));
 840 S16 rgUIMCrgBndCfm ARGS ((Inst inst,SuId suId,uint8_t status));
 841 S16 rgUIMCrgCfgCfm ARGS ((Inst inst,CrgCfgTransId transId,uint8_t status));
 842
 843
 844 /*
 845  * APIs exposed by ROM module
 846  */
 847 S16 rgROMDedDatReq ARGS((Inst inst,RgRguDedDatReq *datReq));
 848 S16 rgROMCmnDatReq ARGS((Inst inst,RgRguCmnDatReq *datReq));
 849 S16 rgROMDedStaRsp ARGS((Inst inst,RgRguDedStaRsp *staRsp));
 850 S16 rgROMCmnStaRsp ARGS((Inst inst,RgRguCmnStaRsp *staRsp));
 851 #ifdef LTE_L2_MEAS
 852
 853 S16 rgROML2MUlThrpMeasReq ARGS((Inst inst,RgRguL2MUlThrpMeasReq *measReq));
 854
 855 #endif
 856
 857 /*
 858  * APIs exposed by RAM module
 859  */
 860 RgUeCb* rgRAMCreateUeCb ARGS((RgCellCb *cell,
 861                      CmLteRnti tmpCrnti,Bool insert, RgErrInfo *err));
 862 S16 rgRAMFreeCell ARGS((RgCellCb    *cell));
 863 Void rgRAMFreeUeCb ARGS((Inst inst,RgUeCb *ueCb));
 864 S16 rgHndlRaResp ARGS((RgCellCb *cell,CmLteTimingInfo timingInfo,
 865             RgInfRarInfo  *rarInfo,RgErrInfo *err));
 866 S16 rgSchMacRlsRntiReq ARGS((Pst *pst,RgInfRlsRnti* rlsRnti));
 867 /*
 868  * APIs exposed by UHM module
 869  */
 870 Void rgUHMCrgUeCfg ARGS(( RgCellCb *cellCb, RgUeCb *ueCb,
 871                                  CrgUeCfg *ueCfg));
 872 Void rgUHMCrgUeRecfg ARGS(( RgCellCb *cellCb, RgUeCb *ueCb,
 873                               CrgUeRecfg *ueRecfg));
 874 /*
 875  * APIs exposed by DUX module
 876  */
 877 S16 rgDUXDemuxData ARGS((Inst inst,RgMacPdu *pdu, RgInfCeInfo   *ceInfo,
 878                                 Buffer **mBuf, RgErrInfo *err));
 879 S16 rgDUXExtSduLen ARGS
 880 ((
 881 Inst        inst,
 882 Buffer      *mBuf,
 883 uint16_t    *sduLen,
 884 RgErrInfo   *err
 885 ));
 886
 887 /*
 888  * APIs exposed by DBM module
 889  */
 890
 891 S16 rgDBMInitInactvCellLst ARGS((uint16_t numBins));
 892 S16 rgDBMDeInitInactvCellLst ARGS((Void));
 893 S16 rgDBMInsInactvCellCb ARGS(( RgCellCb *cellCb));
 894 RgCellCb* rgDBMGetInactvCellCb ARGS(( CmLteCellId cellId));
 895 S16 rgDBMDelInactvCellCb ARGS(( RgCellCb *cellCb));
 896 RgCellCb* rgDBMGetNextInactvCellCb ARGS((RgCellCb *cellCb));
 897
 898 S16 rgDBMInitCellLst ARGS(( uint16_t numBins));
 899 S16 rgDBMDeInitCellLst ARGS((Void));
 900 S16 rgDBMInsCellCb ARGS(( RgCellCb *cellCb));
 901 RgCellCb* rgDBMGetCellCb ARGS(( CmLteCellId cellId));
 902 S16 rgDBMDelCellCb ARGS(( RgCellCb *cellCb));
 903 RgCellCb* rgDBMGetNextCellCb ARGS((RgCellCb *cellCb));
 904 S16 rgDBMInitCell ARGS((RgCellCb *cellCb));
 905
 906 S16 rgDBMDeInitUeCbLst ARGS(( RgCellCb *cellCb));
 907 S16 rgDBMInsUeCb ARGS(( RgCellCb *cellCb, RgUeCb *ueCb));
 908 RgUeCb* rgDBMGetUeCb ARGS(( RgCellCb *cellCb, CmLteRnti ueId));
 909 RgUeCb* rgDBMGetNextUeCb ( RgCellCb *cellCb, RgUeCb *ueCb);
 910 S16 rgDBMDelUeCb ARGS(( RgCellCb *cellCb, RgUeCb *ueCb));
 911 Void rgDBMInitUe ARGS((RgUeCb *ueCb));
 912
 913 #ifdef LTE_L2_MEAS
 914 Void rgDBMInsUlDedLcCb ARGS((RgUeCb *ueCb, CmLteLcId idx, LteLcgId  gId,
 915                         uint8_t  qci));
 916 #else
 917 Void rgDBMInsUlDedLcCb ARGS((RgUeCb *ueCb,
 918                   CmLteLcId idx, LteLcgId gId));
 919 #endif
 920 Void rgDBMUpdUlDedLcCb ARGS((RgUeCb *ueCb,
 921                RgUlLcCb *ulLcCb, LteLcgId gId));
 922
 923 Void rgDBMInsDlDedLcCb ARGS((RgUeCb *ueCb, CmLteLcId idx));
 924 Void rgDBMDelUlDedLcCb ARGS((RgUeCb *ueCb, RgUlLcCb *ulLcCb));
 925 Void rgDBMDelDlDedLcCb ARGS((RgUeCb *ueCb, RgDlLcCb *dlLcCb));
 926 RgDlLcCb* rgDBMGetDlDedLcCb ARGS(( RgUeCb *ueCb, CmLteLcId idx));
 927 RgUlLcCb* rgDBMGetUlDedLcCb ARGS(( RgUeCb *ueCb, CmLteLcId idx));
 928 Void rgDBMFreeCmnLcLst ARGS((RgCellCb *cellCb));
 929 S16 rgDBMChkCmnLcCb ARGS(( RgCellCb *cellCb, CmLteLcId lcId));
 930 RgBcchBchLcCb* rgDBMGetBcchOnBch ARGS(( RgCellCb *cellCb ));
 931 RgBcchDlschLcCb* rgDBMGetBcchOnDlsch ARGS(( RgCellCb *cellCb,
 932                                                    CmLteLcId lcId));
 933 RgPcchLcCb* rgDBMGetPcch ARGS(( RgCellCb *cellCb));
 934 Void rgDBMInsBcchOnBch ARGS(( RgCellCb *cellCb, CmLteLcId idx));
 935 Void rgDBMInsBcchOnDlsch ARGS(( RgCellCb *cellCb, CmLteLcId idx));
 936 Void rgDBMInsPcch ARGS(( RgCellCb *cellCb, CmLteLcId idx));
 937
 938 Void rgDBMInsUeCbInRachLst ARGS((RgCellCb *cellCb,RgUeCb *ueCb));
 939 RgUeCb* rgDBMGetUeCbFromRachLst ARGS((RgCellCb *cellCb,CmLteRnti key));
 940 RgUeCb* rgDBMGetNextUeCbFromRachLst ARGS((RgCellCb *cellCb,
 941                                                       RgUeCb *ueCb));
 942 Void rgDBMDelUeCbFromRachLst ARGS((RgCellCb *cellCb,RgUeCb *ueCb));
 943 /* Added support for SPS*/
 944 #ifdef LTEMAC_SPS
 945 S16 rgDBMDeInitSpsUeCbLst ARGS((RgCellCb *cellCb));
 946 S16 rgDBMInsSpsUeCb ARGS((RgCellCb *cellCb, RgUeCb *ueCb));
 947 RgUeCb* rgDBMGetSpsUeCb ARGS((RgCellCb *cellCb, CmLteRnti ueId));
 948 RgUeCb* rgDBMGetNextSpsUeCb ARGS((RgCellCb *cellCb, RgUeCb *ueCb));
 949 S16 rgDBMDelSpsUeCb ARGS((RgCellCb *cellCb,RgUeCb *ueCb));
 950 #endif /* LTEMAC_SPS */
 951
 952 /*
 953  * APIs exposed by DHM module
 954  */
 955 Void rgCFGFreeUeCb ARGS((RgCellCb *cell, RgUeCb *ue));
 956 S16 rgDHMHqEntInit ARGS((Inst inst,RgDlHqEnt *hqE, uint8_t maxHqProcs));
 957 Void rgDHMRlsHqProc ARGS((RgDlHqProcCb *hqP));
 958 Void rgDHMUeReset ARGS ((RgCellCb *cell, RgDlHqEnt *hqE));
 959 Void rgDHMHdlBufFree ARGS((Inst inst, Buffer **mBuf));
 960 Void rgDHMFreeTbBufs ARGS((Inst inst));
 961 S16 rgDHMRlsHqProcTB ARGS((RgCellCb *cell, RgDlHqProcCb *hqP,uint8_t tbIndex));
 962 S16 rgDHMGetHqProcFrmId ARGS((RgUeCb *ue, uint8_t idx, RgDlHqProcCb **hqP));
 963 /* Changes for MIMO feature addition */
 964 /* Removed dependency on MIMO compile-time flag */
 965 S16 rgDHMSndDatReq ARGS((RgCellCb *cellCb, RgDlSf *dlSf, RgTfuDatReqInfo *datInfo,
 966                                 RgDlHqProcCb *hqProc, RgErrInfo *err));
 967 S16 rgDHMHndlDedDatReq ARGS((Inst inst,RgDlHqProcCb *hqProc,
 968                               RgRguDDatReqPerUe *datReq, RgDlSf *dlSf, RgErrInfo *err));
 969 /* Changed for contention resolution timer implementation*/
 970 S16 rgDHMHndlCmnDatReq ARGS((Inst inst,RgDlHqProcCb *hqProc,
 971                 RgRguCmnDatReq *datReq, RgErrInfo *err));
 972 /* Changes for MIMO feature addition */
 973 /* Removed dependency on MIMO compile-time flag */
 974
 975 S16 rgDHMSndConsolidatedStaInd ARGS ((RgCellCb *cell,RgInfUeInfo *ueInfo,
 976       CmLteTimingInfo timingInfo, RgErrInfo *err));
 977
 978 Void rgDHMFreeUe ARGS((Inst inst,RgDlHqEnt *hqE));
 979 S16 rgSchMacRlsHqReq ARGS((Pst *pst, RgInfRlsHqInfo *rlshqUeInfo));
 980
 981 /*
 982  * APIs exposed by MUX module
 983  */
 984 #ifndef L2_OPTMZ
 985 S16 rgMUXBldPdu ARGS((Inst inst, RgBldPduInfo *bldPdu, Buffer **txPdu,
 986          RgErrInfo *err));
 987 #else
 988 S16 rgMUXBldPdu ARGS((Inst inst, RgBldPduInfo *bldPdu, RgTfuDatReqTbInfo *tb,
 989          RgErrInfo *err));
 990 Bool RgUtlIsTbMuxed ARGS((TfuDatReqTbInfo *tb));
 991 #endif
 992 S16 rgMUXBldRarPdu ARGS((RgCellCb *cell, RgInfRaRntiInfo *alloc,
 993          Buffer **txPdu, RgErrInfo *err));
 994
 995 /*
 996  * Utility APIs
 997  */
 998 S16  rgAllocSBuf     ARGS((Inst inst,Data **pData, Size size));
 999 S16  rgGetMsg        ARGS((Inst inst,Buffer **mBuf));
1000 /*ccpu00117052 - MOD  Passing double pointer for proper NULLP
1001                       assignment */
1002 Void rgFreeSBuf      ARGS((Inst inst,Data **data, Size size));
1003 Void rgFillDgnParams ARGS((Inst inst,RgUstaDgn *dgn,uint8_t dgnType));
1004 Void rgUpdtRguDedSts ARGS((Inst inst,RgUpSapCb *rguSap,uint8_t stsType, RgRguDedDatReq *datReq));
1005 Void rgUpdtRguCmnSts ARGS((Inst inst,RgUpSapCb *rguSap,uint8_t stsType));
1006 Void rgUpdtCellCnt   ARGS((Inst inst,uint8_t updtType));
1007 Void rgUpdtUeCnt     ARGS((Inst inst,uint8_t updtType));
1008 Void rgGetPstToInst ARGS((Pst *pst,Inst srcInst, Inst dstInst));
1009 S16 rgAllocEventMem ARGS((Inst inst,Ptr *memPtr,Size memSize));
1010 S16 rgGetEventMem ARGS((Inst inst,Ptr *ptr,Size len,Ptr memCp));
1011 S16 rgAllocShrablSBuf ARGS((Inst inst,Data **pData, Size size));
1012 Void rgPrintfSubFrameInfo ARGS((RgDlSf *dlSf));
1013 Void printMacCellInfo ARGS((Void));
1014 Void rgFreeSharableSBuf ARGS((Inst inst,Data **data, Size size));
1015 void MacSendCellCfgCfm(uint8_t response);
1016
1017
1018 Void rgDHMFreeAllTbBufs ARGS
1019 ((
1020 Inst inst
1021 ));
1022
1023 S16 rgMUXAddPadd ARGS((
1024 Inst           inst,
1025 MsgLen         *schdTbSz,
1026 Buffer         *sduBuf,
1027 Bool           isRar,
1028 RgErrInfo      *err
1029 ));
1030 uint16_t rgMUXCalcRiv ARGS
1031 ((
1032 uint8_t           bw,
1033 uint8_t           rbStart,
1034 uint8_t           numRb
1035 ));
1036
1037
1038
1039 #ifdef __cplusplus
1040 }
1041 #endif /* __cplusplus */
1042 #endif /* __RGX__ */
1043
1044
1045 /**********************************************************************
1046          End of file
1047 **********************************************************************/