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