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