1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
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 #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
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 *******************************************************************************/
19 /************************************************************************
25 Desc: C source code for Entry point fucntions
29 **********************************************************************/
32 @brief MAC Multiplexing API.
35 static const char* RLOG_MODULE_NAME="MAC";
36 static int RLOG_FILE_ID=229;
37 static int RLOG_MODULE_ID=4096;
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 */
48 #include "rg_err.h" /* MAC error defines */
49 #include "rg.h" /* MAC defines */
51 /* header/extern include files (.x) */
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 */
61 #include "du_app_mac_inf.h"
62 #include "rg.x" /* MAC includes */
66 #include "ss_msg.x" /* MAC includes */
68 #ifndef T2K_MEM_LEAK_DBG
69 S16 ssGetDBufOfSize(Region region,Size size,Buffer **dBuf);
71 char* file = __FILE__;
72 uint32_t line = __LINE__;
77 /* global variables */
78 uint32_t rgDlrate_rgu;
82 static Void rgMUXGet20bitRarGrnt ARGS((uint8_t ulBw,
83 RgInfRarUlGrnt *msg3Grnt,
85 uint16_t rgMUXCalcRiv ARGS((uint8_t bw,
89 #ifndef MS_MBUF_CORRUPTION
90 #define MS_BUF_ADD_ALLOC_CALLER()
92 /* forward references */
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);\
101 #define RG_PACK_CE(_ce, _len, _ceBuf, _ret) {\
102 MS_BUF_ADD_ALLOC_CALLER(); \
103 _ret = SAddPstMsgMult((uint8_t *)(&(_ce)), _len, _ceBuf);\
106 #define RG_MUX_CALC_LEN(_len,_lenBytes,_elmTotLen) {\
108 _lenBytes = (_len <= 255) ? 1 : 2;\
109 _hdrLen = _lenBytes + RG_SDU_SHDR_LEN;\
110 _elmTotLen = _hdrLen + _len;\
113 #define RG_PACK_VAR_SZ_CE_SDU_SHDR(_subHdr, _lcId, _len,_mBuf, _ret) {\
117 _subHdr.shData[0] = (0x3F & _lcId);\
119 _subHdr.shData[1] = (0xFF & _len);\
120 _subHdr.shData[2] = 0;\
124 _subHdr.shData[0] = (0x7F & ((0x40) | _lcId));\
126 _subHdr.shData[1] = (0xFF & (_len >> 8));\
127 _subHdr.shData[2] = (0xFF & _len);\
129 MS_BUF_ADD_ALLOC_CALLER(); \
130 _ret = SAddPstMsgMult(&_subHdr.shData[0], _subHdr.shLen, _mBuf);\
133 #define RG_PACK_PAD_SHDR(_mBuf, _ret) {\
134 _ret = SAddPreMsg(0x3F, _mBuf);\
137 #define RG_PACK_RAR_SHDR(_byte, _mBuf, _ret) {\
138 _ret = SAddPstMsg(_byte, _mBuf);\
143 * @brief Function to add ces along with subhdrs.
144 * This function packs first CE sub-hdr and then CE in ceBuf pointer
148 * Function : rgMUXAddCes
150 * @param[in] Inst inst
151 * @param[in] RgBldPduInfo *pdu
152 * @param[in] Buffer *ceBuf
153 * @param[in] RgErrInfo *err
158 static S16 rgMUXAddCes
169 if (NULLP != pdu->contResId)
171 if(pdu->schdTbSz >= RG_CRES_ELM_LEN)
173 RG_PACK_SHDR_FIXD_SZ(subHdr, RG_CRES_LCID_IDX, ceBuf, ret);
177 err->errCause = RGERR_MUX_BLD_CEHDR_FAIL;
178 RLOG0(L_ERROR, "Muxing of Contention Resolution CE sub-header is failed");
182 RG_PACK_CE(pdu->contResId->resId[0], RG_CRES_LEN, ceBuf, ret);
186 err->errCause = RGERR_MUX_BLD_CE_FAIL;
187 RLOG0(L_ERROR, "Muxing of Contention Resolution CE is failed")
190 pdu->schdTbSz -= RG_CRES_ELM_LEN;
193 if (TRUE == pdu->ta.pres)
195 if(pdu->schdTbSz >= RG_TA_ELM_LEN)
197 uint8_t taVal; /* Moving from outer scope to available scope */
198 RG_PACK_SHDR_FIXD_SZ(subHdr, RG_TA_LCID_IDX, ceBuf, ret);
202 err->errCause = RGERR_MUX_BLD_CEHDR_FAIL;
203 RLOG0(L_ERROR, "Muxing of TA CE sub-hdr is failed")
208 RG_PACK_CE(taVal, RG_TA_LEN, ceBuf, ret);
212 err->errCause = RGERR_MUX_BLD_CE_FAIL;
213 RLOG0(L_ERROR, "Muxing of TA CE is failed")
216 pdu->schdTbSz -= RG_TA_ELM_LEN;
217 RLOG1(L_DEBUG,"TA muxed by MAC: %u", pdu->ta.val);
221 if(TRUE == pdu->sCellActCe.pres)
223 if(pdu->schdTbSz >= RG_SCELL_CE_ELM_LEN)
225 /* Adding the subheader for ACT CE */
226 RG_PACK_SHDR_FIXD_SZ(subHdr, RG_SCELL_LCID_IDX, ceBuf, ret);
230 err->errCause = RGERR_MUX_BLD_CEHDR_FAIL;
231 RLOG0(L_ERROR, "Muxing of SCELL Activation CE sub-hdr is failed")
235 /* Adding the ACT CE */
236 RG_PACK_CE(pdu->sCellActCe.val, RG_SCELL_ACT_CE_LEN, ceBuf, ret);
240 err->errCause = RGERR_MUX_BLD_CE_FAIL;
241 RLOG0(L_ERROR, "Muxing of SCELL Activation CE is failed")
244 pdu->schdTbSz -= RG_SCELL_CE_ELM_LEN;
250 /*LcId is not yet decided in 5G-NR spec for MAC CEs Hence, not writing code
257 * @brief Function to insert SDU along with sub headers.
261 * Function : rgMUXInsSdu
263 * @param[in] Inst inst
264 * @param[in] MsgLen *schdTbSz
265 * @param[in] uint8_t lcId
266 * @param[in] Buffer *sdu
267 * @param[out] Buffer *sduBuf
268 * @param[out] RgErrInfo *err
273 static S16 rgMUXInsSdu
288 SFndLenMsg(sdu, &msgLen);
290 RG_MUX_CALC_LEN(msgLen,lenBytes,elmTotLen);
294 rgDlrate_rgu += msgLen;
296 if (*schdTbSz >= elmTotLen)
299 RG_PACK_VAR_SZ_CE_SDU_SHDR(subHdr, lcId, msgLen,sduBuf, ret);
302 err->errCause = RGERR_MUX_BLD_SDUHDR_FAIL;
303 RLOG1(L_ERROR, "RGERR_MUX_BLD_SDUHDR_FAIL for LCID:%d",lcId);
307 #ifndef L2_OPTMZ /* no need to pack as passing not muxing all LCs PDUs to 1*/
308 RG_PACK_SDU(sduBuf, sdu, ret);
317 err->errCause = RGERR_MUX_BLD_SDU_FAIL;
318 RLOG1(L_ERROR, "RGERR_MUX_BLD_SDU_FAIL for LCID:%d",lcId);
322 *schdTbSz -= elmTotLen;
326 /* This Sub-PDU can not be accodmodated at all */
327 RLOG4(L_ERROR, "Failed lcId %u, elmTotLen %d lenBytes %d LCID:%d",
328 lcId, ((S16)elmTotLen), lenBytes,lcId);
329 RLOG3(L_ERROR, "msglen %d schdTbSz %d LCID:%d",
330 ((S16)msgLen), ((S16)*schdTbSz),lcId);
337 * @brief Function to insert SDU along with sub headers.
341 * Function : rgMUXAddPadd
343 * @param[in] Inst inst
344 * @param[in] RgBldPduInfo *pdu
345 * @param[out] Buffer *mBuf
346 * @param[out] Buffer *sduBuf
352 uint32_t padSize = 0;
364 Buffer *padBuf = NULLP;
375 if((FALSE == isRar) && (NULL != sHdrBuf))
379 RG_PACK_SHDR_FIXD_SZ(subHdr, RG_PAD_LCID_IDX, sduBuf, ret);
383 err->errCause = RGERR_MUX_BLD_PADHDR_FAIL;
384 RLOG0(L_ERROR, "RGERR_MUX_BLD_PADHDR_FAIL");
393 if (*schdTbSz <= RG_MAX_PAD_ARR_SZ)
396 RG_PACK_PAD(padBuf,*schdTbSz,sduBuf);
400 RG_PACK_PAD(padBuf,*schdTbSz,sduBuf);
403 padSize += *schdTbSz;
407 err->errCause = RGERR_MUX_BLD_PAD_FAIL;
408 RLOG0(L_ERROR, "RGERR_MUX_BLD_PAD_FAIL");
417 if (*schdTbSz > RG_MAX_PAD_ARR_SZ)
420 RG_PACK_PAD(padBuf,RG_MAX_PAD_ARR_SZ,sduBuf);
424 RG_PACK_PAD(padBuf,RG_MAX_PAD_ARR_SZ,sduBuf);
427 padSize += RG_MAX_PAD_ARR_SZ;
432 err->errCause = RGERR_MUX_BLD_PAD_FAIL;
433 RLOG0(L_ERROR, "RGERR_MUX_BLD_PAD_FAIL");
437 *schdTbSz -= RG_MAX_PAD_ARR_SZ;
442 RG_PACK_PAD(padBuf,*schdTbSz,sduBuf);
446 RG_PACK_PAD(padBuf,*schdTbSz,sduBuf);
449 padSize += *schdTbSz;
454 err->errCause = RGERR_MUX_BLD_PAD_FAIL;
455 RLOG0(L_ERROR, "RGERR_MUX_BLD_PAD_FAIL");
471 * @brief Function to add SDU along with sub headers.
475 * Function : rgMUXAddSdus
477 * @param[in] Inst inst
478 * @param[in] RgBldPduInfo *pdu
479 * @param[out] Buffer *mBuf
480 * @param[out] Buffer *sduBuf
485 static S16 rgMUXAddSdus
493 RgRguDDatReqPerUe *dDatReq;
494 RgRguCmnDatReq *cDatReq;
499 cDatReq = (RgRguCmnDatReq *)(pdu->datReq);
500 /* Add sdu(s) to the Message Buffer */
501 if (NULLP != cDatReq)
503 if(rgMUXInsSdu(inst,&pdu->schdTbSz,
504 RG_CCCH_LCID, cDatReq->pdu, sduBuf, err) != ROK)
508 RG_FREE_MSG(cDatReq->pdu);
513 dDatReq = (RgRguDDatReqPerUe *)(pdu->datReq);
514 /* Add sdu(s) to the Message Buffer */
515 if (NULLP != dDatReq)
517 if(pdu->tbIndex == 1)
520 /* Adding this temporary variable for optimization */
521 RguDatReqTb *datReqTb = &dDatReq->datReqTb[0];
523 for (idx1=0; (idx1 < datReqTb->nmbLch); idx1++)
526 (idx2 < datReqTb->lchData[idx1].pdu.numPdu);
531 if(rgMUXInsSdu(inst,&pdu->schdTbSz,
532 datReqTb->lchData[idx1].lcId,
533 datReqTb->lchData[idx1].pdu.mBuf[idx2],
536 RLOG1(L_ERROR, "FAILED for LCID:%d",datReqTb->lchData[idx1].lcId);
540 RG_FREE_MSG(datReqTb->lchData[idx1].pdu.mBuf[idx2]);
544 else if(pdu->tbIndex == 2)
547 RguDatReqTb *datReqTb = &dDatReq->datReqTb[1];
548 for (idx1=0; (idx1 < datReqTb->nmbLch); idx1++)
551 (idx2 < datReqTb->lchData[idx1].pdu.numPdu);
556 if(rgMUXInsSdu(inst,&pdu->schdTbSz,
557 datReqTb->lchData[idx1].lcId,
558 datReqTb->lchData[idx1].pdu.mBuf[idx2],
561 RLOG2(L_ERROR, "FAILED TB Size %d LCID:%d",
562 ((S16)pdu->schdTbSz),datReqTb->lchData[idx1].lcId);
566 RG_FREE_MSG(datReqTb->lchData[idx1].pdu.mBuf[idx2]);
575 } /* End of switch(reqType) */
576 if(rgMUXAddPadd(inst,&pdu->schdTbSz, sduBuf, FALSE, err) != ROK)
578 RLOG1(L_ERROR, "FAILED for TB Size:%d",(S16)pdu->schdTbSz);
585 * @brief Function to create MAC PDU from RLC SDUs and control elements, if any.
589 * Function : rgMUXBldPdu
591 * -# This function shall be invoked by Downlink Harq Module as soon as a
592 * Data request is received from RLC for a UE along with its stored
593 * control elements to create a MAC PDU.
594 * -# It shall create subheaders for the control elements (timing advance
595 * and contention resolution ID) and pack sub-header before each CE,
596 * if given, and then shall run through all the logical channels and
597 * create subheader for each of the SDUs given on that logical channel
598 * and pack corresponding sub-header before the each SDU
599 * -# It shall invoke rgMUXPadPdu if the total length of the created
600 * buffer is less than the scheduled TB size.
603 * @param[in] Inst *inst
604 * @param[in] RgBldPduInfo *bldPdu
605 * @param[in] Buffer **txPdu
606 * @param[out] RgErrInfo *err
619 Buffer *mBuf = NULLP;
621 if (rgGetMsg(inst, &mBuf) != ROK)
623 /* Buffer couldnt get allocated. Return a failure */
624 err->errCause = RGERR_MUX_MEM_ALLOC_FAIL;
625 err->errType = RGERR_MUX_BLD_PDU;
626 RLOG1(L_FATAL, "Memory allocation failed during MUXing of MAC TB: MacInst %d", inst);
630 if(rgMUXAddCes(inst, pdu, mBuf, err) != ROK)
633 err->errType = RGERR_MUX_BLD_PDU;
634 RLOG1(L_ERROR, "Failed to Multiplex MAC CEs: MacInst %d", inst);
638 if(rgMUXAddSdus(inst, pdu, mBuf, err) != ROK)
641 err->errType = RGERR_MUX_BLD_PDU;
642 RLOG1(L_ERROR, "FAILED to Multiplex MAC SDU: MacInst %d", inst);
652 #else /* else of ifndef L2_OPTMZ */
655 * @brief Function to add SDU along with sub headers.
659 * Function : rgMUXAddSdus
661 * @param[in] RgBldPduInfo *pdu
662 * @param[out] Buffer *mBuf
663 * @param[out] Buffer *sduBuf
668 static S16 rgMUXAddSdus
673 RgTfuDatReqTbInfo *tb,
677 RgRguDDatReqPerUe *dDatReq;
678 RgRguCmnDatReq *cDatReq;
679 uint32_t lchIdx, pduIdx;
684 cDatReq = (RgRguCmnDatReq *)(pdu->datReq);
685 /* Add sdu(s) to the Message Buffer */
686 if (NULLP != cDatReq)
688 if(rgMUXInsSdu(inst, &pdu->schdTbSz,
689 RG_CCCH_LCID, cDatReq->pdu,
690 sHdrBuf, NULLP, err) != ROK)
694 /* L2 Optimization for mUe/Tti: RLC pdu mbuf pointer will be passed
695 * to CL it is stored in DlHqProc->TbInfo and it will be used in
696 * case of harq retransmission. Store CCCH data at 0th index of
698 tb->lchInfo[tb->numLch].mBuf[(tb->lchInfo[tb->numLch].numPdu)]\
700 tb->lchInfo[tb->numLch].numPdu++;
702 RLOG3(L_INFO,"MSG4 is muxed numLch=%ld numPdu=%ld tbaddr =%p", tb->numLch,tb->lchInfo[tb->numLch-1].numPdu, (uint32_t)tb);
707 dDatReq = (RgRguDDatReqPerUe *)(pdu->datReq);
708 /* Add sdu(s) to the Message Buffer */
709 if (NULLP != dDatReq)
711 if(pdu->tbIndex == 1)
714 /* Adding this temporary variable for optimization */
715 RguDatReqTb *datReqTb = &dDatReq->datReqTb[0];
717 tb->numLch = lchIdx = 0;
719 for (idx1=0; (idx1 < datReqTb->nmbLch); idx1++)
721 tb->lchInfo[lchIdx].numPdu = pduIdx = 0;
724 (idx2 < datReqTb->lchData[idx1].pdu.numPdu);
729 if(rgMUXInsSdu(inst, &pdu->schdTbSz,
730 datReqTb->lchData[idx1].lcId,
731 datReqTb->lchData[idx1].pdu.mBuf[idx2],
732 sHdrBuf, NULLP, err) != ROK)
734 RGDBGERRNEW(inst,(rgPBuf(inst), "FAILED\n"));
738 /* L2 Optimization for mUe/Tti:Increment numPdu by 1
739 * Store pdu buffer in tb to send it to CL/PHY. Increment
741 tb->lchInfo[lchIdx].mBuf[pduIdx] = datReqTb->lchData[idx1].pdu.mBuf[idx2];
744 if(datReqTb->lchData[idx1].freeBuff == FALSE)
745 {/* Not incrementing refCnt for UM Mode. */
746 tb->lchInfo[lchIdx].mBuf[pduIdx]->refCnt++;
750 if(NULL != datReqTb->lchData[idx1].pdu.mBuf[idx2]->b_cont)
753 tmp = datReqTb->lchData[idx1].pdu.mBuf[idx2]->b_cont;
754 if(NULL == tmp->b_rptr)
756 RLOG0(L_INFO,"11111Its Null here only ");
761 RLOG0(L_INFO,"222222Its Null here only \n");
764 //tb->lchInfo[tb->numLch].numPdu++;
772 tb->lchInfo[lchIdx].numPdu = pduIdx;
773 /* If Bearer is UM then MBUF to be free by MAC layer */
774 tb->lchInfo[lchIdx].freeBuff = datReqTb->lchData[idx1].freeBuff;
780 else if(pdu->tbIndex == 2)
783 RguDatReqTb *datReqTb = &dDatReq->datReqTb[1];
784 tb->numLch = lchIdx = 0;
785 // prc_trace_format_string(0x40,3,": AddSdus: numOfLch=%d numOfPdu=%d, schdSz=%d", datReqTb->nmbLch, datReqTb->lchData[0].pdu.numPdu, pdu->schdTbSz);
786 for (idx1=0; (idx1 < datReqTb->nmbLch); idx1++)
788 tb->lchInfo[lchIdx].numPdu = pduIdx = 0;
790 (idx2 < datReqTb->lchData[idx1].pdu.numPdu);
795 if(rgMUXInsSdu(inst, &pdu->schdTbSz,
796 datReqTb->lchData[idx1].lcId,
797 datReqTb->lchData[idx1].pdu.mBuf[idx2],
798 sHdrBuf, NULLP, err) != ROK)
800 RGDBGERRNEW(inst,(rgPBuf(inst), "FAILED TB Size %d\n",
801 ((S16)pdu->schdTbSz)));
804 /* L2 Optimization for mUe/Tti:Increment numPdu by 1
805 * Store pdu buffer in tb to send it to CL/PHY. Increment
807 tb->lchInfo[lchIdx].mBuf[pduIdx] = datReqTb->lchData[idx1].pdu.mBuf[idx2];
809 if(datReqTb->lchData[idx1].freeBuff == FALSE)
810 {/* Not incrementing refCnt for UM Mode. */
811 tb->lchInfo[lchIdx].mBuf[pduIdx]->refCnt++;
814 if(NULL != datReqTb->lchData[idx1].pdu.mBuf[idx2]->b_cont)
817 tmp = datReqTb->lchData[idx1].pdu.mBuf[idx2]->b_cont;
818 if(NULL == tmp->b_rptr)
820 RLOG0(L_INFO,"2212121Its Null here only \n");
825 RLOG0(L_INFO,"343343433ts Null here only \n");
828 // tb->lchInfo[tb->numLch].numPdu++;
836 tb->lchInfo[lchIdx].numPdu = pduIdx;
837 /* If Bearer is UM then MBUF to be free by MAC layer */
838 tb->lchInfo[lchIdx].freeBuff = datReqTb->lchData[idx1].freeBuff;
848 case EVENT_SLOT_IND_TO_MAC:
852 } /* End of switch(reqType) */
855 if(rgMUXAddPadd(inst, &pdu->schdTbSz, sduBuf, NULLP, FALSE, err) != ROK)
857 //RGDBGERRNEW((rgPBuf, "FAILED"));
860 tb->padSize = padSize;
866 * @brief Function to create MAC PDU from RLC SDUs and control elements, if any.
870 * Function : rgMUXBldPdu
871 * -# This function shall be invoked by Downlink Harq Module as soon as a
872 * Data request is received from RLC for a UE along with its stored
873 * control elements to create a MAC PDU.
874 * -# It shall create subheaders for the control elements (timing advance
875 * and contention resolution ID), if given, and then shall run through
876 * all the logical channels and create subheader for each of the SDUs
877 * given on that logical channel.
878 * -# L2 Optimization for mUe/Tti: Avoiding muxing to reduce overhead of
879 * additional Mbuf allocation memory related operation.
880 -# MAC header, MAC CEs, MAC PDUs and MAC padding are stored in pre-
881 allocated mBufs. These pointers will not be freed by CL
882 * -# It shall invoke rgMUXPadPdu if the total length of the created
883 * buffer is less than the scheduled TB size.
884 * -# At successfull operation of this function tb->macHdr, will have
885 * complete MAC Header. tb->macCes will have MAC CEs if any. tb->
886 * lchInfo[idx].mBuf[idx] will have MAC SDU per LCH per TB per UE
889 * @param[in] RgBldPduInfo *bldPdu
890 * @param[out] RgTbInfo *tb
891 * @param[out] RgErrInfo *err
900 RgTfuDatReqTbInfo *tb,
904 Buffer *mBuf1; /* MAC hearder */
905 Buffer *mBuf2; /* MAC CEs */
906 //uint32_t lchIdx, pduIdx;
908 /* Reseting macHdr and macCes pointers */
910 SResetMBuf(tb->macHdr);
912 SResetMBuf(tb->macCes);
914 mBuf1 = tb->macHdr; /* MAC hearder */
915 mBuf2 = tb->macCes; /* MAC CEs */
916 tb->tbSize = pdu->schdTbSz;
918 if(rgMUXAddCes(inst, pdu, mBuf1, mBuf2, err) != ROK)
920 /* Reset rPtr and wPtr to the base of data buffer(db_base)*/
921 RLOG0(L_INFO,"rgMUXBldPdu: rgMUXAddCes is Failed \n");
923 err->errType = RGERR_MUX_BLD_PDU;
924 //RGDBGERRNEW((rgPBuf, "FAILED"));
927 if(rgMUXAddSdus(inst, pdu, mBuf1, tb, err) != ROK)
929 /*TODO:MP Reset rPtr and wPtr to the base of data buffer(db_base)
930 * Reset numLch and numPdu to zero and set MAC SDU buf to NULLP */
931 RLOG0(L_INFO, "rgMUXBldPdu: rgMUXAddSdus is Failed \n");
934 err->errType = RGERR_MUX_BLD_PDU;
935 //RGDBGERRNEW((rgPBuf, "FAILED"));
939 // SPrntMsg(tb->macHdr, 0, 0);
940 // prc_trace_format_string(0x40,3,": padSize=%ld", tb->padSize);
947 #endif /* end of L2_OPTMZ */
950 * @brief Function to create RAR PDU.
954 * Function : rgMUXBldRarPdu
955 * This function is used to build RAR PDUs and is being
956 * invoked by the scheduler.
958 * @param[out]RgCellCb *cellCb
959 * @param[in] RgRaRspAlloc *bldPdu
960 * @param[in] Buffer **txPdu
961 * @param[out] RgErrInfo *err
969 RgInfRaRntiInfo *alloc,
974 Buffer *datBuf = NULLP;
976 uint8_t data[RG_RAR_ELEM_LEN];
980 Inst inst = cell->macInst - RG_INST_START;
982 schdTbSz = alloc->schdTbSz;
983 /* RAR PDU Requirements */
985 1. SubHeader - R/T/RAPID. //5GNR, changed E to R
986 2. TA ( if applicable)
988 a. Hopping Flag - 1 Bit.
989 b. Fixed Size RB Assignment. - 10 Bits.
990 c. Truncated Modulation and coding scheme - 4 Bits.
991 d. TPC command for scheduled PUSCH. - 3 Bits.
993 f. CQI Request - 1 Bit.
997 /* Initialize the error type */
998 err->errType = RGERR_MUX_BLD_RAR_PDU;
1000 if ((ret = rgGetMsg(inst,&datBuf)) != ROK)
1002 /* Buffer couldnt get allocated. Return a failure */
1003 err->errCause = RGERR_MUX_MEM_ALLOC_FAIL;
1004 RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId, "FAILED to getMsg");
1008 if (TRUE == alloc->backOffInd.pres)
1010 /*Set T Bit , NO E bit Required */
1013 hdrByte |= (0x0F & (alloc->backOffInd.val));
1015 /* Add the header */
1016 RG_PACK_RAR_SHDR(hdrByte, datBuf, ret);
1019 err->errCause = RGERR_MUX_BLD_BI_FAIL;
1020 RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"RGERR_MUX_BLD_BI_FAIL");
1021 RG_FREE_MSG(datBuf);
1027 for (idx=0; idx < (alloc->numCrnti) &&
1028 (schdTbSz >= RG_RAR_ELEM_LEN+RG_RAR_SHDR_LEN); idx++)
1033 hdrByte |= (0x3F & (alloc->crntiInfo[idx].rapId));
1035 /* Add the header */
1036 RG_PACK_RAR_SHDR(hdrByte, datBuf, ret);
1039 err->errCause = RGERR_MUX_BLD_RAPIDHDR_FAIL;
1040 RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"RGERR_MUX_BLD_RAPIDHDR_FAIL");
1041 RG_FREE_MSG(datBuf);
1045 /* Prepare the data */
1046 data[0] = 0x7F & ((alloc->crntiInfo[idx].ta.val) >> 4);
1051 rgMUXGet20bitRarGrnt(cell->bwCfg.ulTotalBw, &(alloc->crntiInfo[idx].grnt), &data[1]);
1053 data[1] |= ((uint8_t)((alloc->crntiInfo[idx].ta.val) << 4));
1054 data[4] = (alloc->crntiInfo[idx].tmpCrnti) >> 8;
1055 data[5] = (uint8_t) (alloc->crntiInfo[idx].tmpCrnti);
1057 RLOG_ARG2(L_DEBUG,DBG_CELLID,cell->cellId,
1058 "Rar,Rapid=%d, Temp CRNTI:%d",
1059 alloc->crntiInfo[idx].rapId,
1060 alloc->crntiInfo[idx].tmpCrnti);
1061 MS_BUF_ADD_ALLOC_CALLER();
1062 if(SAddPstMsgMult(&data[0], RG_RAR_ELEM_LEN, datBuf) != ROK)
1064 err->errCause = RGERR_MUX_BLD_RAPID_FAIL;
1065 RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"RGERR_MUX_BLD_RAPID_FAIL");
1066 RG_FREE_MSG(datBuf);
1069 schdTbSz -= RG_RAR_ELEM_LEN+RG_RAR_SHDR_LEN;
1072 if(rgMUXAddPadd(inst,&schdTbSz, datBuf, TRUE, err) != ROK)
1074 RG_FREE_MSG(datBuf);
1075 RLOG_ARG0(L_ERROR,DBG_CELLID,cell->cellId,"FAILED to mux add padding");
1082 } /* rgMUXBldRarPdu */
1084 /***********************************************************
1086 * Func : rgMUXGet20bitRarGrnt
1088 * Desc : This function fills up the 20-bit grant
1097 **********************************************************/
1098 static Void rgMUXGet20bitRarGrnt
1101 RgInfRarUlGrnt *msg3Grnt,
1105 uint16_t riv = rgMUXCalcRiv(ulBw, msg3Grnt->rbStart, msg3Grnt->numRb);
1107 grnt[2] = msg3Grnt->cqiBit; /* cqi bit is 0, output from sched */
1108 grnt[2] |= (msg3Grnt->delayBit << 1);
1109 grnt[2] |= (msg3Grnt->tpc << 2);
1110 grnt[2] |= (msg3Grnt->iMcsCrnt << 5);
1112 grnt[1] = (msg3Grnt->iMcsCrnt >> 3);
1113 /* Forcing right shift to insert 0 as the LSB:
1114 * since this is assumed in the computation */
1115 grnt[1] |= (uint8_t)((riv << 1) & 0xFE);
1117 grnt[0] = (uint8_t)((riv >> 7) & 0x07);
1118 grnt[0] |= ((msg3Grnt->hop & 0x01) << 3);
1121 } /* rgMUXGet20bitRarGrnt */
1123 /***********************************************************
1125 * Func : rgMUXCalcRiv
1127 * Desc : This function calculates RIV.
1135 **********************************************************/
1136 uint16_t rgMUXCalcRiv
1143 uint8_t numRbMinus1 = numRb - 1;
1146 if (numRbMinus1 <= bw/2)
1148 riv = bw * numRbMinus1 + rbStart;
1152 riv = bw * (bw - numRbMinus1) + (bw - rbStart - 1);
1155 } /* rgMUXCalcRiv */
1159 /**********************************************************************
1162 **********************************************************************/