src/5gnrmac/rg_mux.c

   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:     C source file
  24
  25      Desc:     C source code for Entry point fucntions
  26
  27      File:     rg_mux.c
  28
  29 **********************************************************************/
  30
  31 /** @file rg_mux.c
  32 @brief MAC Multiplexing API.
  33 */
  34
  35 static const char* RLOG_MODULE_NAME="MAC";
  36 static int RLOG_FILE_ID=229;
  37 static int RLOG_MODULE_ID=4096;
  38
  39 /* header include files -- defines (.h) */
  40 #include "common_def.h"
  41 #include "rg_env.h"        /* MAC Environment Defines */
  42 #include "tfu.h"           /* TFU Interface defines */
  43 #include "crg.h"           /* CRG Interface defines */
  44 #include "rg_sch_inf.h"           /* RGR Interface defines */
  45 #include "rgu.h"           /* RGU Interface defines */
  46 #include "lrg.h"           /* LRG Interface defines */
  47
  48 #include "rg_err.h"        /* MAC error defines */
  49 #include "rg.h"            /* MAC defines */
  50
  51 /* header/extern include files (.x) */
  52
  53 #include "rgu.x"           /* RGU Interface includes */
  54 #include "tfu.x"           /* CRG Interface includes */
  55 #include "crg.x"           /* CRG Interface includes */
  56 #include "rg_sch_inf.x"    /* SCH Interface includes */
  57 #include "rg_prg.x"        /* PRG Interface includes */
  58 #include "rgu.x"           /* RGU Interface includes */
  59 #include "lrg.x"           /* LRG Interface includes */
  60
  61 #include "du_app_mac_inf.h"
  62 #include "rg.x"            /* MAC includes */
  63 #include "ss_queue.h"
  64 #include "ss_queue.x"
  65 #include "ss_task.x"
  66 #include "ss_msg.x"            /* MAC includes */
  67 /* local defines */
  68 #ifndef T2K_MEM_LEAK_DBG
  69 EXTERN  S16 ssGetDBufOfSize(Region region,Size size,Buffer **dBuf);
  70 #else
  71 char* file = __FILE__;
  72 U32 line = __LINE__;
  73 #endif
  74
  75 /* local typedefs */
  76
  77 /* global variables */
  78 U32 rgDlrate_rgu;
  79
  80 /* local externs */
  81
  82 PRIVATE Void rgMUXGet20bitRarGrnt ARGS((U8 ulBw,
  83                                         RgInfRarUlGrnt *msg3Grnt,
  84                                         U8 *grnt));
  85 EXTERN U16 rgMUXCalcRiv ARGS((U8 bw,
  86                                 U8 rbStart,
  87                                 U8 numRb));
  88
  89 #ifndef MS_MBUF_CORRUPTION
  90 #define MS_BUF_ADD_ALLOC_CALLER()
  91 #endif
  92 /* forward references */
  93
  94 #define RG_PACK_SHDR_FIXD_SZ(_subHdr, _lcId, _mBuf, _ret) {\
  95    _subHdr.shLen = RG_FIXDSZ_CE_SHDR_LEN;\
  96    _subHdr.shData[0] = (0x3F & _lcId);\
  97    MS_BUF_ADD_ALLOC_CALLER(); \
  98    _ret = SAddPstMsgMult(&_subHdr.shData[0], _subHdr.shLen, _mBuf);\
  99 }
 100
 101 #define RG_PACK_CE(_ce, _len, _ceBuf, _ret) {\
 102    MS_BUF_ADD_ALLOC_CALLER(); \
 103    _ret = SAddPstMsgMult((U8 *)(&(_ce)), _len, _ceBuf);\
 104 }
 105
 106 #define RG_MUX_CALC_LEN(_len,_lenBytes,_elmTotLen) {\
 107    U8 _hdrLen;\
 108    _lenBytes    = (_len <= 255) ? 1 : 2;\
 109    _hdrLen      = _lenBytes + RG_SDU_SHDR_LEN;\
 110    _elmTotLen   = _hdrLen + _len;\
 111 }
 112
 113 #define RG_PACK_VAR_SZ_CE_SDU_SHDR(_subHdr, _lcId, _len,_mBuf, _ret) {\
 114    _ret = ROK;\
 115    if(_len <= 255)\
 116    {\
 117       _subHdr.shData[0] = (0x3F & _lcId);\
 118       _subHdr.shLen = 2;\
 119       _subHdr.shData[1] = (0xFF & _len);\
 120       _subHdr.shData[2] = 0;\
 121    }\
 122    else\
 123    {\
 124    _subHdr.shData[0] = (0x7F & ((0x40) | _lcId));\
 125       _subHdr.shLen = 3;\
 126       _subHdr.shData[1] = (0xFF & (_len >> 8));\
 127       _subHdr.shData[2] = (0xFF & _len);\
 128    }\
 129    MS_BUF_ADD_ALLOC_CALLER(); \
 130    _ret = SAddPstMsgMult(&_subHdr.shData[0], _subHdr.shLen, _mBuf);\
 131 }
 132
 133 #define RG_PACK_PAD_SHDR(_mBuf, _ret) {\
 134       _ret = SAddPreMsg(0x3F, _mBuf);\
 135 }
 136
 137 #define RG_PACK_RAR_SHDR(_byte, _mBuf, _ret) {\
 138    _ret = SAddPstMsg(_byte, _mBuf);\
 139 }
 140
 141
 142 /**
 143  * @brief Function to add ces along with subhdrs.
 144  * This function packs first CE sub-hdr and then CE in ceBuf pointer
 145  *
 146  * @details
 147  *
 148  *     Function : rgMUXAddCes
 149  *
 150  *  @param[in]  Inst        inst
 151  *  @param[in] RgBldPduInfo   *pdu
 152  *  @param[in] Buffer        *ceBuf
 153  *  @param[in] RgErrInfo     *err
 154  *  @return    S16
 155  *      -# ROK
 156  *      -# RFAILED
 157  **/
 158 #ifdef ANSI
 159 PRIVATE S16 rgMUXAddCes
 160 (
 161 Inst           inst,
 162 RgBldPduInfo   *pdu,
 163 Buffer         *ceBuf,
 164 RgErrInfo      *err
 165 )
 166 #else
 167 PRIVATE S16 rgMUXAddCes(inst,pdu, ceShdrBuf, ceBuf, err)
 168 Inst           inst;
 169 RgBldPduInfo   *pdu;
 170 Buffer         *ceBuf;
 171 RgErrInfo      *err;
 172 #endif
 173 {
 174    S16            ret;
 175    RgMUXSubHdr    subHdr;
 176
 177    TRC2(rgMUXAddCes)
 178
 179    if (NULLP != pdu->contResId)
 180    {
 181       if(pdu->schdTbSz >= RG_CRES_ELM_LEN)
 182       {
 183          RG_PACK_SHDR_FIXD_SZ(subHdr, RG_CRES_LCID_IDX, ceBuf, ret);
 184
 185          if(ret != ROK)
 186          {
 187             err->errCause = RGERR_MUX_BLD_CEHDR_FAIL;
 188             RLOG0(L_ERROR, "Muxing of Contention Resolution CE sub-header is failed");
 189             RETVALUE(RFAILED);
 190          }
 191
 192          RG_PACK_CE(pdu->contResId->resId[0], RG_CRES_LEN, ceBuf, ret);
 193
 194          if(ret != ROK)
 195          {
 196             err->errCause = RGERR_MUX_BLD_CE_FAIL;
 197             RLOG0(L_ERROR, "Muxing of Contention Resolution CE is failed")
 198             RETVALUE(RFAILED);
 199          }
 200          pdu->schdTbSz -= RG_CRES_ELM_LEN;
 201       }
 202    }
 203    if (TRUE == pdu->ta.pres)
 204    {
 205       if(pdu->schdTbSz >= RG_TA_ELM_LEN)
 206       {
 207          U8 taVal; /* Moving from outer scope to available scope */
 208          RG_PACK_SHDR_FIXD_SZ(subHdr, RG_TA_LCID_IDX, ceBuf, ret);
 209
 210          if(ret != ROK)
 211          {
 212             err->errCause = RGERR_MUX_BLD_CEHDR_FAIL;
 213             RLOG0(L_ERROR, "Muxing of TA CE sub-hdr is failed")
 214             RETVALUE(RFAILED);
 215          }
 216
 217          taVal = pdu->ta.val;
 218          RG_PACK_CE(taVal, RG_TA_LEN, ceBuf, ret);
 219
 220          if(ret != ROK)
 221          {
 222             err->errCause = RGERR_MUX_BLD_CE_FAIL;
 223             RLOG0(L_ERROR, "Muxing of TA CE is failed")
 224             RETVALUE(RFAILED);
 225          }
 226          pdu->schdTbSz -= RG_TA_ELM_LEN;
 227          RLOG1(L_DEBUG,"TA muxed by MAC: %u", pdu->ta.val);
 228       }
 229    }
 230 #ifdef LTE_ADV
 231    if(TRUE == pdu->sCellActCe.pres)
 232    {
 233       if(pdu->schdTbSz >= RG_SCELL_CE_ELM_LEN)
 234       {
 235          /* Adding the subheader for ACT CE */
 236          RG_PACK_SHDR_FIXD_SZ(subHdr, RG_SCELL_LCID_IDX, ceBuf, ret);
 237
 238          if(ret != ROK)
 239          {
 240             err->errCause = RGERR_MUX_BLD_CEHDR_FAIL;
 241             RLOG0(L_ERROR, "Muxing of SCELL Activation CE sub-hdr is failed")
 242             RETVALUE(RFAILED);
 243          }
 244
 245          /* Adding the ACT CE */
 246          RG_PACK_CE(pdu->sCellActCe.val, RG_SCELL_ACT_CE_LEN, ceBuf, ret);
 247
 248          if(ret != ROK)
 249          {
 250             err->errCause = RGERR_MUX_BLD_CE_FAIL;
 251             RLOG0(L_ERROR, "Muxing of SCELL Activation CE is failed")
 252             RETVALUE(RFAILED);
 253          }
 254          pdu->schdTbSz -= RG_SCELL_CE_ELM_LEN;
 255
 256       }
 257    }
 258 #endif
 259
 260   /*LcId is not yet decided in 5G-NR spec for MAC CEs Hence, not writing code
 261    * new MAC CEs. */
 262
 263    RETVALUE(ROK);
 264 } /* rgMUXAddCes */
 265
 266 /**
 267  * @brief Function to insert SDU along with sub headers.
 268  *
 269  * @details
 270  *
 271  *     Function : rgMUXInsSdu
 272  *
 273  *  @param[in]       Inst        inst
 274  *  @param[in]       MsgLen      *schdTbSz
 275  *  @param[in]       U8          lcId
 276  *  @param[in]       Buffer      *sdu
 277  *  @param[out]      Buffer      *sduBuf
 278  *  @param[out]      RgErrInfo   *err
 279  *  @return    S16
 280  *      -# ROK
 281  *      -# RFAILED
 282  **/
 283 #ifdef ANSI
 284 PRIVATE S16 rgMUXInsSdu
 285 (
 286 Inst           inst,
 287 MsgLen         *schdTbSz,
 288 U8             lcId,
 289 Buffer         *sdu,
 290 Buffer         *sduBuf,
 291 RgErrInfo      *err
 292 )
 293 #else
 294 PRIVATE S16 rgMUXInsSdu(inst,schdTbSz, lcId, sdu, sduBuf, err)
 295 Inst           inst;
 296 MsgLen         *schdTbSz;
 297 U8             lcId;
 298 Buffer         *sdu;
 299 Buffer         *sduBuf;
 300 RgErrInfo      *err;
 301 #endif
 302 {
 303    S16            ret;
 304    MsgLen         msgLen = 0;
 305    U8             lenBytes;
 306    MsgLen         elmTotLen;
 307
 308    TRC2(rgMUXInsSdu)
 309    SFndLenMsg(sdu, &msgLen);
 310
 311    RG_MUX_CALC_LEN(msgLen,lenBytes,elmTotLen);
 312
 313    if (lcId == 3)
 314    {
 315      rgDlrate_rgu += msgLen;
 316    }
 317    if (*schdTbSz >= elmTotLen)
 318    {
 319       RgMUXSubHdr    subHdr;
 320       RG_PACK_VAR_SZ_CE_SDU_SHDR(subHdr, lcId, msgLen,sduBuf, ret);
 321       if(ret != ROK)
 322       {
 323          err->errCause = RGERR_MUX_BLD_SDUHDR_FAIL;
 324          RLOG1(L_ERROR, "RGERR_MUX_BLD_SDUHDR_FAIL for LCID:%d",lcId);
 325          RETVALUE(RFAILED);
 326       }
 327
 328 #ifndef L2_OPTMZ /* no need to pack as passing not muxing all LCs PDUs to 1*/
 329       RG_PACK_SDU(sduBuf, sdu, ret);
 330 #else
 331   //UDAY
 332       ret = ROK;
 333       UNUSED(sduBuf);
 334 #endif
 335
 336       if(ret != ROK)
 337       {
 338          err->errCause = RGERR_MUX_BLD_SDU_FAIL;
 339          RLOG1(L_ERROR, "RGERR_MUX_BLD_SDU_FAIL for LCID:%d",lcId);
 340          RETVALUE(RFAILED);
 341       }
 342
 343       *schdTbSz -= elmTotLen;
 344    }
 345    else
 346    {
 347       /* This Sub-PDU can not be accodmodated at all */
 348       RLOG4(L_ERROR, "Failed lcId %u, elmTotLen %d lenBytes %d LCID:%d",
 349                lcId, ((S16)elmTotLen), lenBytes,lcId);
 350       RLOG3(L_ERROR, "msglen %d schdTbSz %d LCID:%d",
 351                ((S16)msgLen), ((S16)*schdTbSz),lcId);
 352       RETVALUE(RFAILED);
 353    }
 354    RETVALUE(ROK);
 355 }
 356
 357 /**
 358  * @brief Function to insert SDU along with sub headers.
 359  *
 360  * @details
 361  *
 362  *     Function : rgMUXAddPadd
 363  *
 364  *  @param[in]  Inst        inst
 365  *  @param[in]       RgBldPduInfo   *pdu
 366  *  @param[out]      Buffer        *mBuf
 367  *  @param[out]      Buffer        *sduBuf
 368  *  @return    S16
 369  *      -# ROK
 370  *      -# RFAILED
 371  **/
 372 #ifdef L2_OPTMZ
 373 U32 padSize = 0;
 374 #endif
 375 #ifdef ANSI
 376 PUBLIC S16 rgMUXAddPadd
 377 (
 378 Inst           inst,
 379 MsgLen         *schdTbSz,
 380 Buffer         *sduBuf,
 381 Bool           isRar,
 382 RgErrInfo      *err
 383 )
 384 #else
 385 PUBLIC S16 rgMUXAddPadd(inst,schdTbSz, sduBuf, isRar, err)
 386 Inst           inst;
 387 MsgLen         *schdTbSz;
 388 Buffer         *sduBuf;
 389 Bool           isRar;
 390 RgErrInfo      *err;
 391 #endif
 392 {
 393    S16     ret = ROK;
 394    Buffer         *padBuf = NULLP;
 395    RgMUXSubHdr    subHdr;
 396    TRC2(rgMUXAddPadd)
 397
 398 #ifdef L2_OPTMZ
 399    padSize = 0;
 400 #endif
 401    if(*schdTbSz)
 402    {
 403 #ifndef L2_OPTMZ
 404       if(FALSE == isRar)
 405 #else
 406       if((FALSE == isRar) && (NULL != sHdrBuf))
 407 #endif
 408
 409       {
 410          RG_PACK_SHDR_FIXD_SZ(subHdr, RG_PAD_LCID_IDX, sduBuf, ret);
 411
 412          if(ret != ROK)
 413          {
 414             err->errCause = RGERR_MUX_BLD_PADHDR_FAIL;
 415             RLOG0(L_ERROR, "RGERR_MUX_BLD_PADHDR_FAIL");
 416             RETVALUE(RFAILED);
 417          }
 418
 419          *schdTbSz -= 1;
 420       }
 421
 422       if (*schdTbSz)
 423       {
 424          if (*schdTbSz <= RG_MAX_PAD_ARR_SZ)
 425          {
 426 #ifndef L2_OPTMZ
 427             RG_PACK_PAD(padBuf,*schdTbSz,sduBuf);
 428 #else
 429             if(sduBuf)
 430             {
 431                RG_PACK_PAD(padBuf,*schdTbSz,sduBuf);
 432             }
 433             else
 434                padSize += *schdTbSz;
 435 #endif
 436             if(ret != ROK)
 437             {
 438                err->errCause = RGERR_MUX_BLD_PAD_FAIL;
 439                RLOG0(L_ERROR, "RGERR_MUX_BLD_PAD_FAIL");
 440                RETVALUE(RFAILED);
 441             }
 442             *schdTbSz = 0;
 443          }
 444          else
 445          {
 446             while (*schdTbSz)
 447             {
 448                if (*schdTbSz > RG_MAX_PAD_ARR_SZ)
 449                {
 450 #ifndef L2_OPTMZ
 451                   RG_PACK_PAD(padBuf,RG_MAX_PAD_ARR_SZ,sduBuf);
 452 #else
 453                   if(sduBuf)
 454                   {
 455                      RG_PACK_PAD(padBuf,RG_MAX_PAD_ARR_SZ,sduBuf);
 456                   }
 457                   else
 458                      padSize += RG_MAX_PAD_ARR_SZ;
 459 #endif
 460
 461                   if(ret != ROK)
 462                   {
 463                      err->errCause = RGERR_MUX_BLD_PAD_FAIL;
 464                      RLOG0(L_ERROR, "RGERR_MUX_BLD_PAD_FAIL");
 465                      RETVALUE(RFAILED);
 466                   }
 467
 468                   *schdTbSz -= RG_MAX_PAD_ARR_SZ;
 469                }
 470                else
 471                {
 472 #ifndef L2_OPTMZ
 473                   RG_PACK_PAD(padBuf,*schdTbSz,sduBuf);
 474 #else
 475                   if(sduBuf)
 476                   {
 477                      RG_PACK_PAD(padBuf,*schdTbSz,sduBuf);
 478                   }
 479                   else
 480                      padSize += *schdTbSz;
 481 #endif
 482
 483                   if(ret != ROK)
 484                   {
 485                      err->errCause = RGERR_MUX_BLD_PAD_FAIL;
 486                      RLOG0(L_ERROR, "RGERR_MUX_BLD_PAD_FAIL");
 487                      RETVALUE(RFAILED);
 488
 489                   }
 490                   *schdTbSz = 0;
 491                }
 492             }
 493          }
 494       }
 495    }
 496
 497    RETVALUE(ROK);
 498 } /* rgMUXAddPadd */
 499
 500 #ifndef L2_OPTMZ
 501 /**
 502  * @brief Function to add SDU along with sub headers.
 503  *
 504  * @details
 505  *
 506  *     Function : rgMUXAddSdus
 507  *
 508  *  @param[in]  Inst        inst
 509  *  @param[in]       RgBldPduInfo   *pdu
 510  *  @param[out]      Buffer        *mBuf
 511  *  @param[out]      Buffer        *sduBuf
 512  *  @return    S16
 513  *      -# ROK
 514  *      -# RFAILED
 515  **/
 516 #ifdef ANSI
 517 PRIVATE S16 rgMUXAddSdus
 518 (
 519 Inst           inst,
 520 RgBldPduInfo   *pdu,
 521 Buffer         *sduBuf,
 522 RgErrInfo      *err
 523 )
 524 #else
 525 PRIVATE S16 rgMUXAddSdus(inst,pdu, sduBuf, err)
 526 Inst           inst;
 527 RgBldPduInfo   *pdu;
 528 Buffer         *sduBuf;
 529 RgErrInfo      *err;
 530 #endif
 531 {
 532    RgRguDDatReqPerUe *dDatReq;
 533    RgRguCmnDatReq    *cDatReq;
 534
 535    TRC2(rgMUXAddSdus)
 536
 537    switch(pdu->reqType)
 538    {
 539       case EVTRGUCDATREQ:
 540          cDatReq = (RgRguCmnDatReq *)(pdu->datReq);
 541          /* Add sdu(s) to the Message Buffer */
 542          if (NULLP != cDatReq)
 543          {
 544             if(rgMUXInsSdu(inst,&pdu->schdTbSz,
 545                      RG_CCCH_LCID, cDatReq->pdu, sduBuf, err) != ROK)
 546             {
 547                RETVALUE(RFAILED);
 548             }
 549             RG_FREE_MSG(cDatReq->pdu);
 550          }
 551          break;
 552
 553       case EVTRGUDDATREQ:
 554          dDatReq = (RgRguDDatReqPerUe *)(pdu->datReq);
 555          /* Add sdu(s) to the Message Buffer */
 556          if (NULLP != dDatReq)
 557          {
 558             if(pdu->tbIndex == 1)
 559             {
 560                U16 idx1, idx2;
 561                /* Adding this temporary variable for optimization */
 562                RguDatReqTb *datReqTb = &dDatReq->datReqTb[0];
 563
 564                for (idx1=0; (idx1 < datReqTb->nmbLch); idx1++)
 565                {
 566                   for(idx2=0;
 567                      (idx2 < datReqTb->lchData[idx1].pdu.numPdu);
 568                      idx2++)
 569                   {
 570                      if(pdu->schdTbSz)
 571                      {
 572                         if(rgMUXInsSdu(inst,&pdu->schdTbSz,
 573                            datReqTb->lchData[idx1].lcId,
 574                            datReqTb->lchData[idx1].pdu.mBuf[idx2],
 575                            sduBuf, err) != ROK)
 576                         {
 577                            RLOG1(L_ERROR, "FAILED for LCID:%d",datReqTb->lchData[idx1].lcId);
 578                            RETVALUE(RFAILED);
 579                         }
 580                      }
 581                      RG_FREE_MSG(datReqTb->lchData[idx1].pdu.mBuf[idx2]);
 582                   }
 583                }
 584             }
 585             else if(pdu->tbIndex == 2)
 586             {
 587                U16 idx1, idx2;
 588                RguDatReqTb *datReqTb = &dDatReq->datReqTb[1];
 589                for (idx1=0; (idx1 < datReqTb->nmbLch); idx1++)
 590                {
 591                   for(idx2=0;
 592                      (idx2 < datReqTb->lchData[idx1].pdu.numPdu);
 593                      idx2++)
 594                   {
 595                      if(pdu->schdTbSz)
 596                      {
 597                         if(rgMUXInsSdu(inst,&pdu->schdTbSz,
 598                            datReqTb->lchData[idx1].lcId,
 599                            datReqTb->lchData[idx1].pdu.mBuf[idx2],
 600                            sduBuf, err) != ROK)
 601                         {
 602                            RLOG2(L_ERROR, "FAILED TB Size %d LCID:%d",
 603                                     ((S16)pdu->schdTbSz),datReqTb->lchData[idx1].lcId);
 604                            RETVALUE(RFAILED);
 605                         }
 606                      }
 607                      RG_FREE_MSG(datReqTb->lchData[idx1].pdu.mBuf[idx2]);
 608                   }
 609                }
 610             }
 611          }
 612          break;
 613
 614       default:
 615          break;
 616    } /* End of switch(reqType) */
 617    if(rgMUXAddPadd(inst,&pdu->schdTbSz, sduBuf, FALSE, err) != ROK)
 618    {
 619       RLOG1(L_ERROR, "FAILED for TB Size:%d",(S16)pdu->schdTbSz);
 620       RETVALUE(RFAILED);
 621    }
 622    RETVALUE(ROK);
 623 }
 624
 625 /**
 626  * @brief Function to create MAC PDU from RLC SDUs and control elements, if any.
 627  *
 628  * @details
 629  *
 630  *     Function : rgMUXBldPdu
 631  *
 632  *     -# This function shall be invoked by Downlink Harq Module as soon as a
 633  *        Data request is received from RLC for a UE along with its stored
 634  *        control elements to create a MAC PDU.
 635  *     -# It shall create subheaders for the control elements (timing advance
 636  *        and contention resolution ID) and pack sub-header before each CE,
 637  *        if given, and then shall run through all the logical channels and
 638  *        create subheader for each of the SDUs given on that logical channel
 639  *        and pack corresponding sub-header before the each SDU
 640  *     -# It shall invoke rgMUXPadPdu if the total length of the created
 641  *        buffer is less than the scheduled TB size.
 642  *
 643  *
 644  *  @param[in]  Inst           *inst
 645  *  @param[in]  RgBldPduInfo   *bldPdu
 646  *  @param[in]  Buffer         **txPdu
 647  *  @param[out] RgErrInfo      *err
 648  *  @return  S16
 649  *      -# ROK
 650  *      -# RFAILED
 651  **/
 652 #ifdef ANSI
 653 PUBLIC S16 rgMUXBldPdu
 654 (
 655 Inst           inst,
 656 RgBldPduInfo   *pdu,
 657 Buffer         **txPdu,
 658 RgErrInfo      *err
 659 )
 660 #else
 661 PUBLIC S16 rgMUXBldPdu(inst, pdu, txPdu, err)
 662 Inst           inst;
 663 RgBldPduInfo   *pdu;
 664 Buffer         **txPdu;
 665 RgErrInfo      *err;
 666 #endif
 667 {
 668    Buffer         *mBuf = NULLP;
 669
 670    TRC2(rgMUXBldPdu)
 671
 672
 673    if (rgGetMsg(inst, &mBuf) != ROK)
 674    {
 675       /* Buffer couldnt get allocated. Return a failure */
 676       err->errCause = RGERR_MUX_MEM_ALLOC_FAIL;
 677       err->errType = RGERR_MUX_BLD_PDU;
 678       RLOG1(L_FATAL, "Memory allocation failed during MUXing of MAC TB: MacInst %d", inst);
 679       RETVALUE(RFAILED);
 680    }
 681
 682    if(rgMUXAddCes(inst, pdu, mBuf, err) != ROK)
 683    {
 684       RG_FREE_MSG(mBuf);
 685       err->errType = RGERR_MUX_BLD_PDU;
 686       RLOG1(L_ERROR, "Failed to Multiplex MAC CEs: MacInst %d", inst);
 687       RETVALUE(RFAILED);
 688    }
 689
 690    if(rgMUXAddSdus(inst, pdu, mBuf, err) != ROK)
 691    {
 692       RG_FREE_MSG(mBuf);
 693       err->errType = RGERR_MUX_BLD_PDU;
 694       RLOG1(L_ERROR, "FAILED to Multiplex MAC SDU: MacInst %d", inst);
 695       RETVALUE(RFAILED);
 696    }
 697
 698    *txPdu = mBuf;
 699
 700    RETVALUE(ROK);
 701
 702 }  /* rgMUXBldPdu */
 703
 704 #else /* else of ifndef L2_OPTMZ */
 705
 706 /**
 707  * @brief Function to add SDU along with sub headers.
 708  *
 709  * @details
 710  *
 711  *     Function : rgMUXAddSdus
 712  *
 713  *  @param[in]       RgBldPduInfo   *pdu
 714  *  @param[out]      Buffer        *mBuf
 715  *  @param[out]      Buffer        *sduBuf
 716  *  @return    S16
 717  *      -# ROK
 718  *      -# RFAILED
 719  **/
 720 #ifdef ANSI
 721 PRIVATE S16 rgMUXAddSdus
 722 (
 723 Inst                inst,
 724 RgBldPduInfo        *pdu,
 725 Buffer              *sHdrBuf,
 726 RgTfuDatReqTbInfo   *tb,
 727 RgErrInfo           *err
 728 )
 729 #else
 730 PRIVATE S16 rgMUXAddSdus(pdu, sHdrBuf, tb, err)
 731 Inst                inst;
 732 RgBldPduInfo        *pdu;
 733 Buffer              *sHdrBuf;
 734 RgTfuDatReqTbInfo   *tb;
 735 RgErrInfo           *err;
 736 #endif
 737 {
 738    RgRguDDatReqPerUe  *dDatReq;
 739    RgRguCmnDatReq     *cDatReq;
 740    U32 lchIdx, pduIdx;
 741
 742    TRC2(rgMUXAddSdus)
 743
 744    switch(pdu->reqType)
 745    {
 746       case EVTRGUCDATREQ:
 747          cDatReq = (RgRguCmnDatReq *)(pdu->datReq);
 748          /* Add sdu(s) to the Message Buffer */
 749          if (NULLP != cDatReq)
 750          {
 751             if(rgMUXInsSdu(inst, &pdu->schdTbSz,
 752                      RG_CCCH_LCID, cDatReq->pdu,
 753                      sHdrBuf, NULLP, err) != ROK)
 754             {
 755                RETVALUE(RFAILED);
 756             }
 757             /* L2 Optimization for mUe/Tti: RLC pdu mbuf pointer will be passed
 758              * to CL it is stored in DlHqProc->TbInfo and it will be used in
 759              * case of harq retransmission. Store CCCH data at 0th index of
 760              * lch array*/
 761             tb->lchInfo[tb->numLch].mBuf[(tb->lchInfo[tb->numLch].numPdu)]\
 762                = cDatReq->pdu;
 763             tb->lchInfo[tb->numLch].numPdu++;
 764             tb->numLch++;
 765            RLOG3(L_INFO,"MSG4 is muxed  numLch=%ld numPdu=%ld tbaddr =%p", tb->numLch,tb->lchInfo[tb->numLch-1].numPdu, (U32)tb);
 766          }
 767          break;
 768
 769       case EVTRGUDDATREQ:
 770          dDatReq = (RgRguDDatReqPerUe *)(pdu->datReq);
 771          /* Add sdu(s) to the Message Buffer */
 772          if (NULLP != dDatReq)
 773          {
 774             if(pdu->tbIndex == 1)
 775             {
 776                U16 idx1, idx2;
 777                /* Adding this temporary variable for optimization */
 778                RguDatReqTb *datReqTb = &dDatReq->datReqTb[0];
 779
 780                tb->numLch = lchIdx = 0;
 781
 782                for (idx1=0; (idx1 < datReqTb->nmbLch); idx1++)
 783                {
 784                   tb->lchInfo[lchIdx].numPdu = pduIdx = 0;
 785
 786                   for(idx2=0;
 787                      (idx2 < datReqTb->lchData[idx1].pdu.numPdu);
 788                      idx2++)
 789                   {
 790                      if(pdu->schdTbSz)
 791                      {
 792                         if(rgMUXInsSdu(inst, &pdu->schdTbSz,
 793                            datReqTb->lchData[idx1].lcId,
 794                            datReqTb->lchData[idx1].pdu.mBuf[idx2],
 795                            sHdrBuf, NULLP, err) != ROK)
 796                         {
 797                            RGDBGERRNEW(inst,(rgPBuf(inst), "FAILED\n"));
 798                            RETVALUE(RFAILED);
 799                         }
 800
 801                         /* L2 Optimization for mUe/Tti:Increment numPdu by 1
 802                          * Store pdu buffer in tb to send it to CL/PHY. Increment
 803                          * numPdu by 1*/
 804                         tb->lchInfo[lchIdx].mBuf[pduIdx] = datReqTb->lchData[idx1].pdu.mBuf[idx2];
 805
 806 #ifdef L2_OPTMZ
 807                         if(datReqTb->lchData[idx1].freeBuff == FALSE)
 808                         {/* Not incrementing refCnt for UM Mode. */
 809                            tb->lchInfo[lchIdx].mBuf[pduIdx]->refCnt++;
 810                         }
 811 #endif
 812 //UDAY
 813                         if(NULL != datReqTb->lchData[idx1].pdu.mBuf[idx2]->b_cont)
 814                         {
 815                              Buffer *tmp;
 816                              tmp = datReqTb->lchData[idx1].pdu.mBuf[idx2]->b_cont;
 817                              if(NULL == tmp->b_rptr)
 818                              {
 819                                 RLOG0(L_INFO,"11111Its Null here only ");
 820                              }
 821                         }
 822                         else
 823                         {
 824                             RLOG0(L_INFO,"222222Its Null here only \n");
 825                         }
 826                         pduIdx++;
 827                         //tb->lchInfo[tb->numLch].numPdu++;
 828                         //tb->numLch++;
 829
 830                     }
 831                   }
 832
 833                   if(pduIdx)
 834                   {
 835                     tb->lchInfo[lchIdx].numPdu = pduIdx;
 836                     /* If Bearer is UM then MBUF to be free by MAC layer */
 837                     tb->lchInfo[lchIdx].freeBuff = datReqTb->lchData[idx1].freeBuff;
 838                     lchIdx++;
 839                   }
 840                }
 841                tb->numLch = lchIdx;
 842             }
 843             else if(pdu->tbIndex == 2)
 844             {
 845                U16 idx1, idx2;
 846                RguDatReqTb *datReqTb = &dDatReq->datReqTb[1];
 847                tb->numLch = lchIdx = 0;
 848          //      prc_trace_format_string(0x40,3,": AddSdus: numOfLch=%d numOfPdu=%d, schdSz=%d", datReqTb->nmbLch, datReqTb->lchData[0].pdu.numPdu, pdu->schdTbSz);
 849               for (idx1=0; (idx1 < datReqTb->nmbLch); idx1++)
 850                {
 851                  tb->lchInfo[lchIdx].numPdu = pduIdx = 0;
 852                  for(idx2=0;
 853                      (idx2 < datReqTb->lchData[idx1].pdu.numPdu);
 854                      idx2++)
 855                   {
 856                      if(pdu->schdTbSz)
 857                      {
 858                         if(rgMUXInsSdu(inst, &pdu->schdTbSz,
 859                            datReqTb->lchData[idx1].lcId,
 860                            datReqTb->lchData[idx1].pdu.mBuf[idx2],
 861                            sHdrBuf, NULLP, err) != ROK)
 862                         {
 863                            RGDBGERRNEW(inst,(rgPBuf(inst), "FAILED TB Size %d\n",
 864                                     ((S16)pdu->schdTbSz)));
 865                            RETVALUE(RFAILED);
 866                         }
 867                          /* L2 Optimization for mUe/Tti:Increment numPdu by 1
 868                          * Store pdu buffer in tb to send it to CL/PHY. Increment
 869                          * numPdu by 1*/
 870                         tb->lchInfo[lchIdx].mBuf[pduIdx] = datReqTb->lchData[idx1].pdu.mBuf[idx2];
 871 #ifdef L2_OPTMZ
 872                         if(datReqTb->lchData[idx1].freeBuff == FALSE)
 873                         {/* Not incrementing refCnt for UM Mode. */
 874                            tb->lchInfo[lchIdx].mBuf[pduIdx]->refCnt++;
 875                         }
 876 #endif
 877                         if(NULL != datReqTb->lchData[idx1].pdu.mBuf[idx2]->b_cont)
 878                         {
 879                              Buffer *tmp;
 880                              tmp = datReqTb->lchData[idx1].pdu.mBuf[idx2]->b_cont;
 881                              if(NULL == tmp->b_rptr)
 882                              {
 883                                 RLOG0(L_INFO,"2212121Its Null here only \n");
 884                              }
 885                         }
 886                         else
 887                         {
 888                             RLOG0(L_INFO,"343343433ts Null here only \n");
 889                         }
 890                         pduIdx++;
 891                        // tb->lchInfo[tb->numLch].numPdu++;
 892                        // tb->numLch++;
 893
 894                      }
 895                   }
 896
 897                   if(pduIdx)
 898                   {
 899                     tb->lchInfo[lchIdx].numPdu = pduIdx;
 900                     /* If Bearer is UM then MBUF to be free by MAC layer */
 901                     tb->lchInfo[lchIdx].freeBuff = datReqTb->lchData[idx1].freeBuff;
 902                     lchIdx++;
 903                   }
 904                }
 905
 906                tb->numLch = lchIdx;
 907            }
 908          }
 909          break;
 910
 911       case EVENT_SLOT_IND_TO_MAC:
 912          break;
 913       default:
 914          break;
 915    } /* End of switch(reqType) */
 916
 917
 918    if(rgMUXAddPadd(inst, &pdu->schdTbSz, sduBuf, NULLP, FALSE, err) != ROK)
 919    {
 920       //RGDBGERRNEW((rgPBuf, "FAILED"));
 921       RETVALUE(RFAILED);
 922    }
 923    tb->padSize = padSize;
 924
 925    RETVALUE(ROK);
 926 }
 927
 928 /**
 929  * @brief Function to create MAC PDU from RLC SDUs and control elements, if any.
 930  *
 931  * @details
 932  *
 933  *     Function : rgMUXBldPdu
 934  *     -# This function shall be invoked by Downlink Harq Module as soon as a
 935  *        Data request is received from RLC for a UE along with its stored
 936  *        control elements to create a MAC PDU.
 937  *     -# It shall create subheaders for the control elements (timing advance
 938  *        and contention resolution ID), if given, and then shall run through
 939  *        all the logical channels and create subheader for each of the SDUs
 940  *        given on that logical channel.
 941  *     -# L2 Optimization for mUe/Tti: Avoiding muxing to reduce overhead of
 942  *           additional Mbuf allocation memory related operation.
 943        -# MAC header, MAC CEs, MAC PDUs and MAC padding are stored in pre-
 944             allocated mBufs. These pointers will not be freed by CL
 945  *     -# It shall invoke rgMUXPadPdu if the total length of the created
 946  *        buffer is less than the scheduled TB size.
 947  *     -# At successfull operation of this function tb->macHdr, will have
 948  *        complete MAC Header. tb->macCes will have MAC CEs if any. tb->
 949  *        lchInfo[idx].mBuf[idx] will have MAC SDU per LCH per TB per UE
 950  *
 951  *
 952  *  @param[in]  RgBldPduInfo   *bldPdu
 953  *  @param[out] RgTbInfo       *tb
 954  *  @param[out] RgErrInfo      *err
 955  *  @return  S16
 956  *      -# ROK
 957  *      -# RFAILED
 958  **/
 959 #ifdef ANSI
 960 PUBLIC S16 rgMUXBldPdu
 961 (
 962 Inst               inst,
 963 RgBldPduInfo       *pdu,
 964 RgTfuDatReqTbInfo  *tb,
 965 RgErrInfo          *err
 966 )
 967 #else
 968 PUBLIC S16 rgMUXBldPdu(inst, pdu, tb, err)
 969 Inst               inst;
 970 RgBldPduInfo       *pdu;
 971 RgTfuDatReqTbInfo  *tb;
 972 RgErrInfo          *err;
 973 #endif
 974 {
 975    Buffer         *mBuf1; /* MAC hearder */
 976    Buffer         *mBuf2; /* MAC CEs */
 977    //U32            lchIdx, pduIdx;
 978
 979    TRC2(rgMUXBldPdu)
 980
 981   /* Reseting macHdr and macCes pointers */
 982   if(tb->macHdr)
 983    SResetMBuf(tb->macHdr);
 984    if(tb->macCes)
 985    SResetMBuf(tb->macCes);
 986
 987    mBuf1 = tb->macHdr; /* MAC hearder */
 988    mBuf2 = tb->macCes; /* MAC CEs */
 989    tb->tbSize  = pdu->schdTbSz;
 990
 991    if(rgMUXAddCes(inst, pdu, mBuf1, mBuf2, err) != ROK)
 992    {
 993       /* Reset rPtr and wPtr to the base of data buffer(db_base)*/
 994       RLOG0(L_INFO,"rgMUXBldPdu: rgMUXAddCes is Failed \n");
 995       RG_FREE_TB(tb);
 996       err->errType = RGERR_MUX_BLD_PDU;
 997       //RGDBGERRNEW((rgPBuf, "FAILED"));
 998       RETVALUE(RFAILED);
 999    }
1000    if(rgMUXAddSdus(inst, pdu, mBuf1, tb, err) != ROK)
1001    {
1002       /*TODO:MP Reset rPtr and wPtr to the base of data buffer(db_base)
1003        * Reset numLch and numPdu to zero and set MAC SDU buf to NULLP */
1004       RLOG0(L_INFO, "rgMUXBldPdu: rgMUXAddSdus is Failed \n");
1005       RG_FREE_TB(tb);
1006
1007       err->errType = RGERR_MUX_BLD_PDU;
1008       //RGDBGERRNEW((rgPBuf, "FAILED"));
1009       RETVALUE(RFAILED);
1010    }
1011 // UDAY
1012 //      SPrntMsg(tb->macHdr, 0, 0);
1013 //   prc_trace_format_string(0x40,3,": padSize=%ld", tb->padSize);
1014
1015    tb->tbPres = TRUE;
1016    RETVALUE(ROK);
1017
1018 }  /* rgMUXBldPdu */
1019
1020 #endif /* end of L2_OPTMZ */
1021
1022 /**
1023  * @brief Function to create RAR PDU.
1024  *
1025  * @details
1026  *
1027  *     Function : rgMUXBldRarPdu
1028  *                This function is used to build RAR PDUs and is being
1029  *                invoked by the scheduler.
1030  *
1031  *  @param[out]RgCellCb       *cellCb
1032  *  @param[in] RgRaRspAlloc   *bldPdu
1033  *  @param[in] Buffer         **txPdu
1034  *  @param[out] RgErrInfo     *err
1035  *  @return    S16
1036  *      -# ROK
1037  *      -# RFAILED
1038  **/
1039 #ifdef ANSI
1040 PUBLIC S16 rgMUXBldRarPdu
1041 (
1042 RgCellCb        *cell,
1043 RgInfRaRntiInfo *alloc,
1044 Buffer          **txPdu,
1045 RgErrInfo       *err
1046 )
1047 #else
1048 PUBLIC S16 rgMUXBldRarPdu(cell, alloc, txPdu, err)
1049 RgCellCb        *cell;
1050 RgInfRaRntiInfo *alloc;
1051 Buffer          **txPdu;
1052 RgErrInfo       *err;
1053 #endif
1054 {
1055    Buffer      *datBuf = NULLP;
1056    S16         ret;
1057    U8          data[RG_RAR_ELEM_LEN];
1058    U8          hdrByte;
1059    MsgLen      schdTbSz;
1060    U8          idx;
1061    Inst        inst = cell->macInst - RG_INST_START;
1062
1063    TRC2(rgMUXBldRarPdu)
1064
1065    schdTbSz = alloc->schdTbSz;
1066    /* RAR PDU Requirements */
1067    /*
1068    1. SubHeader - R/T/RAPID. //5GNR, changed E to R
1069    2. TA ( if applicable)
1070    3. Ul Grant:
1071          a. Hopping Flag - 1 Bit.
1072          b. Fixed Size RB Assignment. - 10 Bits.
1073          c. Truncated Modulation and coding scheme - 4 Bits.
1074          d. TPC command for scheduled PUSCH. - 3 Bits.
1075          e. UL Delay - 1 Bit.
1076          f. CQI Request - 1 Bit.
1077    4. Temporary Crnti.
1078    */
1079
1080    /* Initialize the error type */
1081    err->errType = RGERR_MUX_BLD_RAR_PDU;
1082
1083    if ((ret = rgGetMsg(inst,&datBuf)) != ROK)
1084    {
1085       /* Buffer couldnt get allocated. Return a failure */
1086       err->errCause = RGERR_MUX_MEM_ALLOC_FAIL;
1087       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "FAILED to getMsg");
1088       RETVALUE(RFAILED);
1089    }
1090
1091    if (TRUE == alloc->backOffInd.pres)
1092    {
1093       /*Set T Bit , NO E bit Required */
1094       hdrByte = 0x00;
1095       /* Add the bi */
1096       hdrByte |= (0x0F & (alloc->backOffInd.val));
1097
1098       /* Add the header */
1099       RG_PACK_RAR_SHDR(hdrByte, datBuf, ret);
1100       if(ret != ROK)
1101       {
1102          err->errCause = RGERR_MUX_BLD_BI_FAIL;
1103          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"RGERR_MUX_BLD_BI_FAIL");
1104          RG_FREE_MSG(datBuf);
1105          RETVALUE(RFAILED);
1106       }
1107       schdTbSz--;
1108    }
1109
1110    for (idx=0; idx < (alloc->numCrnti) &&
1111          (schdTbSz >= RG_RAR_ELEM_LEN+RG_RAR_SHDR_LEN); idx++)
1112    {
1113       /* Add the tBit */
1114       hdrByte = 0x40;
1115       /* Add the rapId */
1116       hdrByte |= (0x3F & (alloc->crntiInfo[idx].rapId));
1117
1118          /* Add the header */
1119          RG_PACK_RAR_SHDR(hdrByte, datBuf, ret);
1120          if(ret != ROK)
1121          {
1122             err->errCause = RGERR_MUX_BLD_RAPIDHDR_FAIL;
1123             RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"RGERR_MUX_BLD_RAPIDHDR_FAIL");
1124             RG_FREE_MSG(datBuf);
1125             RETVALUE(RFAILED);
1126          }
1127
1128       /* Prepare the data */
1129       data[0]  =  0x7F & ((alloc->crntiInfo[idx].ta.val) >> 4);
1130       data[1] = 0;
1131       data[2] = 0;
1132       data[3] = 0;
1133       {
1134          rgMUXGet20bitRarGrnt(cell->bwCfg.ulTotalBw, &(alloc->crntiInfo[idx].grnt), &data[1]);
1135       }
1136       data[1] |=  ((U8)((alloc->crntiInfo[idx].ta.val) << 4));
1137       data[4]  =  (alloc->crntiInfo[idx].tmpCrnti) >> 8;
1138       data[5]  =  (U8) (alloc->crntiInfo[idx].tmpCrnti);
1139
1140       RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
1141                         "Rar,Rapid=%d, Temp CRNTI:%d",
1142                 alloc->crntiInfo[idx].rapId,
1143                 alloc->crntiInfo[idx].tmpCrnti);
1144      MS_BUF_ADD_ALLOC_CALLER();
1145       if(SAddPstMsgMult(&data[0], RG_RAR_ELEM_LEN, datBuf) != ROK)
1146       {
1147          err->errCause = RGERR_MUX_BLD_RAPID_FAIL;
1148          RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"RGERR_MUX_BLD_RAPID_FAIL");
1149          RG_FREE_MSG(datBuf);
1150          RETVALUE(RFAILED);
1151       }
1152       schdTbSz -= RG_RAR_ELEM_LEN+RG_RAR_SHDR_LEN;
1153    }
1154
1155    if(rgMUXAddPadd(inst,&schdTbSz, datBuf, TRUE, err) != ROK)
1156    {
1157       RG_FREE_MSG(datBuf);
1158       RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"FAILED to mux add padding");
1159       RETVALUE(RFAILED);
1160    }
1161
1162    *txPdu = datBuf;
1163
1164    RETVALUE(ROK);
1165 } /* rgMUXBldRarPdu */
1166
1167 /***********************************************************
1168  *
1169  *     Func : rgMUXGet20bitRarGrnt
1170  *
1171  *     Desc : This function fills up the 20-bit grant
1172  *            for RA response.
1173  *
1174  *     Ret  : None.
1175  *
1176  *     Notes: None.
1177  *
1178  *     File : rg_mux.c
1179  *
1180  **********************************************************/
1181 #ifdef ANSI
1182 PRIVATE Void rgMUXGet20bitRarGrnt
1183 (
1184 U8             ulBw,
1185 RgInfRarUlGrnt *msg3Grnt,
1186 U8             *grnt
1187 )
1188 #else
1189 PRIVATE Void rgMUXGet20bitRarGrnt(ulBw, msg3Grnt, grnt)
1190 U8             ulBw;
1191 RgInfRarUlGrnt *msg3Grnt;
1192 U8             *grnt;
1193 #endif
1194 {
1195    U16       riv = rgMUXCalcRiv(ulBw, msg3Grnt->rbStart, msg3Grnt->numRb);
1196
1197    TRC2(rgMUXGet20bitRarGrnt);
1198
1199    grnt[2]  = msg3Grnt->cqiBit;   /* cqi bit is 0, output from sched */
1200    grnt[2] |= (msg3Grnt->delayBit << 1);
1201    grnt[2] |= (msg3Grnt->tpc << 2);
1202    grnt[2] |= (msg3Grnt->iMcsCrnt << 5);
1203
1204    grnt[1]  = (msg3Grnt->iMcsCrnt >> 3);
1205    /* Forcing right shift to insert 0 as the LSB:
1206     * since this is assumed in the computation */
1207    grnt[1] |= (U8)((riv << 1) & 0xFE);
1208
1209    grnt[0]  = (U8)((riv >> 7) & 0x07);
1210    grnt[0] |= ((msg3Grnt->hop & 0x01) << 3);
1211
1212    RETVOID;
1213 } /* rgMUXGet20bitRarGrnt */
1214
1215 /***********************************************************
1216  *
1217  *     Func : rgMUXCalcRiv
1218  *
1219  *     Desc : This function calculates RIV.
1220  *
1221  *     Ret  : None.
1222  *
1223  *     Notes: None.
1224  *
1225  *     File : rg_mux.c
1226  *
1227  **********************************************************/
1228 #ifdef ANSI
1229 PUBLIC U16 rgMUXCalcRiv
1230 (
1231 U8           bw,
1232 U8           rbStart,
1233 U8           numRb
1234 )
1235 #else
1236 PUBLIC U16 rgMUXCalcRiv(bw, rbStart, numRb)
1237 U8           bw;
1238 U8           rbStart;
1239 U8           numRb;
1240 #endif
1241 {
1242    U8           numRbMinus1 = numRb - 1;
1243    U16          riv;
1244
1245    TRC2(rgMUXCalcRiv);
1246
1247    if (numRbMinus1 <= bw/2)
1248    {
1249       riv = bw * numRbMinus1 + rbStart;
1250    }
1251    else
1252    {
1253       riv = bw * (bw - numRbMinus1) + (bw - rbStart - 1);
1254    }
1255    RETVALUE(riv);
1256 } /* rgMUXCalcRiv */
1257
1258
1259
1260 /**********************************************************************
1261
1262          End of file
1263 **********************************************************************/