[Epic-ID: ODUHIGH-462][Task-ID: ODUHIGH-472] Changes in handling of slot indication...
[o-du/l2.git] / src / 5gnrmac / rg_utl.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_utl.c
28   
29 **********************************************************************/
30
31 /** @file rg_utl.c
32 @brief This file implements utility functions for LTE MAC
33 */
34
35
36 /* header include files (.h) */
37 #include "common_def.h"
38 #include "rg_env.h"        /* MAC Environment Defines */
39 #include "crg.h"           /* CRG Interface defines */
40 #include "rgu.h"           /* RGU Interface defines */
41 #include "tfu.h"           /* TFU Interface defines */
42 #include "rg_sch_inf.h"    /* RGR Interface defines */
43 #include "lrg.h"           /* LRG Interface defines */
44 #include  "mac_utils.h"
45
46 #include "rg_prg.h"        /* PRG(MAC-MAC) Interface includes */
47 #include "rg.h"            /* MAC defines */
48 #include "rg_err.h"        /* MAC error defines */
49
50 /* header/extern include files (.x) */
51 #include "cm5.x"           /* Timer */
52
53 #include "crg.x"           /* CRG Interface includes */
54 #include "rgu.x"           /* RGU Interface includes */
55 #include "tfu.x"           /* TFU Interface includes */
56 #include "rg_sch_inf.x"    /* RGR Interface includes */
57 #include "lrg.x"           /* LRG Interface includes */
58 #include "rg_prg.x"        /* PRG(MAC-MAC) Interface includes */
59
60 #include "du_app_mac_inf.h"
61 #include "rg.x"            /* MAC includes */
62
63 /* local defines */
64 #define RG_NON_MIMO_IDX 0
65
66 /* local typedefs */
67  
68 /* local externs */
69  
70 /* forward references */
71 static S16 rgUtlHndlCrntiChng ARGS((
72          Inst            inst,
73          RgCellCb        *cell,
74          CmLteRnti       rnti,
75          CmLteRnti       newRnti
76          ));
77 static Void rgUtlHndlCrntiRls ARGS((
78          RgCellCb        *cell,
79          RgInfRlsRnti    *rlsRnti
80          ));
81
82 S16 rgDelUeFrmAllSCell ARGS((
83          RgCellCb       *cell,
84          RgUeCb         *ue
85          ));
86
87 #ifdef LTE_ADV
88 static S16 rgUtlSndCrntiChngReq2AllSMacs ARGS((
89          RgCellCb        *cell,
90          CmLteRnti       rnti,
91          CmLteRnti       newRnti
92          ));
93 #endif
94 /***********************************************************
95  *
96  *     Func : rgAllocShrablSBuf
97  *
98  *     Desc : Utility Function to Allocate static buffer which is 
99  *            sharable among different layers if YYYY flag is enabled. 
100  *            else it allocates from normal static region
101  *            Memory allocated is assumed contiguous.
102  *            
103  *
104  *     Ret  : ROK
105  *            RFAILED
106  *
107  *     Notes: Caller doesnt need to raise the alarm in case of memory
108  *            allocation gets failed. 
109  *
110  *     File : rg_utl.c
111  *
112  **********************************************************/
113 S16 rgAllocShrablSBuf
114 (
115 Inst    inst,
116 Data    **pData,            /* Pointer of the data to be returned */
117 Size    size                /* size */
118 )
119 {
120    RgUstaDgn dgn;      /* Alarm diagnostics structure */
121
122    /* Initialize the param to NULLP */
123    *pData = NULLP;
124
125    if (size == 0)
126    {
127       return RFAILED;
128    }
129
130    /* allocate buffer */
131    MAC_ALLOC_SHRABL_BUF(pData, size);
132    if(pData == NULLP)
133    {
134      dgn.type = LRG_USTA_DGNVAL_MEM;
135      dgn.u.mem.region = rgCb[inst].rgInit.region;
136      dgn.u.mem.pool = rgCb[inst].rgInit.pool;
137      /*  Send an alarm to Layer Manager */
138      rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_SMEM_ALLOC_FAIL,
139                                        LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
140       DU_LOG("\nERROR  -->  MAC : Unable to Allocate Buffer");
141       return RFAILED;
142    }
143
144 #ifndef ALIGN_64BIT
145    DU_LOG("\nDEBUG  -->  MAC : MAC_ALLOC(Region (%d), Pool (%d), Size (%ld)), Data (0x%p))\n",
146              rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool, size, *pData);
147 #else
148    DU_LOG("\nDEBUG  -->  MAC : MAC_ALLOC(Region (%d), Pool (%d), Size (%d)), Data (0x%p))\n",
149              rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool, size, *pData);
150 #endif
151
152    /* zero out the allocated memory */
153    memset(*pData, 0x00, size);
154
155    return ROK;
156
157 } /* end of rgAllocSBuf */
158
159
160 /***********************************************************
161  *
162  *     Func : rgAllocSBuf
163  *
164  *     Desc : Utility Function to Allocate static buffer. 
165  *            Memory allocated is assumed contiguous.
166  *            
167  *
168  *     Ret  : ROK
169  *            RFAILED
170  *
171  *     Notes: Caller doesnt need to raise the alarm in case of memory
172  *            allocation gets failed. 
173  *
174  *     File : rg_utl.c
175  *
176  **********************************************************/
177 S16 rgAllocSBuf
178 (
179 Inst    inst,
180 Data    **pData,            /* Pointer of the data to be returned */
181 Size    size                /* size */
182 )
183 {
184    RgUstaDgn dgn;      /* Alarm diagnostics structure */
185
186    /* Initialize the param to NULLP */
187    *pData = NULLP;
188
189    if (size == 0)
190    {
191       return RFAILED;
192    }
193
194    /* allocate buffer */
195 #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
196    MS_BUF_ADD_ALLOC_CALLER();
197 #endif /* */
198    MAC_ALLOC(pData, size);
199    if(pData == NULLP)
200    {
201      dgn.type = LRG_USTA_DGNVAL_MEM;
202      dgn.u.mem.region = rgCb[inst].rgInit.region;
203      dgn.u.mem.pool = rgCb[inst].rgInit.pool;
204      /*  Send an alarm to Layer Manager */
205      rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_SMEM_ALLOC_FAIL,
206                                        LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
207       DU_LOG("\nERROR  -->  MAC : Unable to Allocate Buffer");
208       return RFAILED;
209    }
210
211    /* zero out the allocated memory */
212    memset(*pData, 0x00, size);
213
214    return ROK;
215
216 } /* end of rgAllocSBuf */
217
218 /*
219 *
220 *       Fun:   rgFreeSharableSBuf
221 *
222 *       Desc:  The argument to rgFreeSBuf() is a pointer to a block
223 *              previously allocated by rgAllocSBuf() and size. It 
224 *              deallocates the memory. 
225 *
226 *       Ret:   void
227 *
228 *       Notes: ccpu00117052 - MOD- changed the Data parameter from 
229 *                             pointer to address of pointer so that
230 *                             the freed memory could be set to NULLP
231 *
232 *       File:  rg_utl.c
233 */
234 Void rgFreeSharableSBuf
235 (
236 Inst inst,
237 Data **data,         /* address of pointer to data */
238 Size size            /* size */
239 )
240 {
241
242    if ((data == NULLP) || (*data == NULLP) || (size == 0))
243    {
244       return;
245    }
246
247    /* Deallocate buffer */
248    MAC_FREE_SHRABL_BUF(rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool, *data, size);
249    
250    if (data != NULLP)
251    {
252       return;
253    }
254
255    *data = NULLP;
256
257    return;
258
259 } /* end of rgFreeSharableBuf */
260
261
262
263 /*
264 *
265 *       Fun:   rgFreeSBuf
266 *
267 *       Desc:  The argument to rgFreeSBuf() is a pointer to a block
268 *              previously allocated by rgAllocSBuf() and size. It 
269 *              deallocates the memory. 
270 *
271 *       Ret:   void
272 *
273 *       Notes: ccpu00117052 - MOD- changed the Data parameter from 
274 *                             pointer to address of pointer so that
275 *                             the freed memory could be set to NULLP
276 *
277 *       File:  rg_utl.c
278 */
279 Void rgFreeSBuf
280 (
281 Inst inst,
282 Data **data,         /* address of pointer to data */
283 Size size            /* size */
284 )
285 {
286
287    if ((data == NULLP) || (*data == NULLP) || (size == 0))
288    {
289       return;
290    }
291
292
293 #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
294    MS_BUF_ADD_CALLER();
295 #endif /* */
296    /* Deallocate buffer */
297    MAC_FREE(data, size);
298
299    if (data != NULLP)
300    {
301       DU_LOG("\nERROR  -->  MAC : rgFreeSBuf failed.\n");
302       return;
303    }
304
305    *data = NULLP;
306
307    return;
308
309 } /* end of rgFreeSBuf */
310
311
312 /***********************************************************
313  *
314  *     Func : rgGetMsg
315  *
316  *     Desc : Utility Function to Allocate message buffer. 
317  *            
318  *
319  *     Ret  : ROK
320  *            RFAILED
321  *
322  *     Notes: Caller doesnt need to raise the alarm in case of memory
323  *            allocation gets failed. 
324  *
325  *     File : rg_utl.c
326  *
327  **********************************************************/
328 S16 rgGetMsg
329 (
330 Inst    inst,
331 Buffer  **mBuf            /* Message Buffer pointer be returned */
332 )
333 {
334    S16         ret;
335
336 #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
337    MS_BUF_ADD_ALLOC_CALLER();
338 #endif /* */
339    ret = ODU_GET_MSG_BUF(RG_GET_MEM_REGION(rgCb[inst]), RG_GET_MEM_POOL(rgCb[inst]), mBuf);
340
341    if (ROK != ret) 
342    {
343       /* Moving diagnostics structure to limited scope for optimization */
344       RgUstaDgn   dgn;      /* Alarm diagnostics structure */
345
346       rgFillDgnParams(inst,&dgn, LRG_USTA_DGNVAL_MEM);
347
348       /*  Send an alarm to Layer Manager */
349       rgLMMStaInd(inst,LCM_CATEGORY_RESOURCE, LCM_EVENT_DMEM_ALLOC_FAIL,
350                                        LCM_CAUSE_MEM_ALLOC_FAIL, &dgn);
351       DU_LOG("\nERROR  -->  MAC : Unable to Allocate Buffer");
352       return RFAILED;
353    }
354
355    return ROK;
356
357 } /* end of rgGetMsg */
358
359
360 /***********************************************************
361  *
362  *     Func : rgFillDgnParams
363  *
364  *     Desc : Utility Function to Fill Diagonostic params. 
365  *
366  *     Ret  : None.
367  *
368  *     Notes: None.
369  *
370  *     File : rg_utl.c
371  *
372  **********************************************************/
373 Void rgFillDgnParams
374 (
375 Inst        inst,
376 RgUstaDgn   *dgn,
377 uint8_t     dgnType
378 )
379 {
380
381    switch(dgnType)
382    {
383       case LRG_USTA_DGNVAL_MEM:
384          dgn->type = (uint8_t) LRG_USTA_DGNVAL_MEM;
385          dgn->u.mem.region  = rgCb[inst].rgInit.region;
386          dgn->u.mem.pool    = rgCb[inst].rgInit.pool;
387       break;
388
389       default:
390       break;
391    }
392
393    return;
394 } /* end of rgFillDgnParams */
395
396
397 /***********************************************************
398  *
399  *     Func : rgUpdtRguDedSts
400  *
401  *     Desc : Utility Function to update rgu sap statistics for dedicated
402  *            DatReqs.
403  *            
404  *
405  *     Ret  : ROK
406  *            RFAILED
407  *
408  *     Notes: 
409  *
410  *     File : rg_utl.c
411  *
412  **********************************************************/
413 Void rgUpdtRguDedSts
414 (
415 Inst           inst,
416 RgUpSapCb      *rguDlSap,
417 uint8_t        stsType,   /* Statistics type to update */
418 RgRguDedDatReq *datReq    /* DatReq pointer */
419 )
420 {
421    uint8_t idx1,idx2;
422    uint32_t idx;
423
424    switch(stsType)
425    {
426       case RG_RGU_SDU_RCVD:
427       for(idx = 0; idx < datReq->nmbOfUeGrantPerTti; idx++)
428       {
429          RguDDatReqPerUe *datReqPerUe = &datReq->datReq[idx];
430          for (idx1 = 0; idx1 < datReqPerUe->nmbOfTbs; idx1++) 
431          {
432             for(idx2 = 0; idx2 < datReqPerUe->datReqTb[idx1].nmbLch; idx2++) 
433             {
434                rguDlSap->sapSts.numPduRcvd +=
435                   datReqPerUe->datReqTb[idx1].lchData[idx2].pdu.numPdu;
436             }
437          }
438       }
439
440          break;
441       case RG_RGU_SDU_DROP:
442       for(idx = 0; idx < datReq->nmbOfUeGrantPerTti; idx++)
443       {
444          RguDDatReqPerUe *datReqPerUe = &datReq->datReq[idx];
445          for (idx1 = 0; idx1 < datReqPerUe->nmbOfTbs; idx1++) 
446          {
447             for(idx2 = 0; idx2 < datReqPerUe->datReqTb[idx1].nmbLch; idx2++) 
448             {
449                rguDlSap->sapSts.numPduRcvd +=
450                   datReqPerUe->datReqTb[idx1].lchData[idx2].pdu.numPdu;
451                rguDlSap->sapSts.numPduDrop +=
452                   datReqPerUe->datReqTb[idx1].lchData[idx2].pdu.numPdu;
453             }
454          }
455       }
456
457          break;
458    }
459    
460    return;
461 } /* rgUpdtRguDedSts */
462
463
464 /***********************************************************
465  *
466  *     Func : rgUpdtRguCmnSts
467  *
468  *     Desc : Utility Function to update rgu sap statistics for common
469  *            DatReqs.
470  *            
471  *
472  *     Ret  : ROK
473  *            RFAILED
474  *
475  *     Notes: 
476  *
477  *     File : rg_utl.c
478  *
479  **********************************************************/
480 Void rgUpdtRguCmnSts
481 (
482 Inst           inst,
483 RgUpSapCb     *rguDlSap,
484 uint8_t       stsType   /* Statistics type to update */
485 )
486 {
487
488    switch(stsType)
489    {
490       case RG_RGU_SDU_RCVD:
491          rguDlSap->sapSts.numPduRcvd ++;
492          break;
493       case RG_RGU_SDU_DROP:
494          rguDlSap->sapSts.numPduRcvd ++;
495          rguDlSap->sapSts.numPduDrop ++;
496          break;
497    }
498    
499    return;
500 } /* rgUpdtRguCmnSts */
501
502
503 /***********************************************************
504  *
505  *     Func : rgUpdtCellCnt
506  *
507  *     Desc : Utility Function to update cell count. It gives number of active
508  *     cells
509  *            
510  *
511  *     Ret  : ROK
512  *            RFAILED
513  *
514  *     Notes: This function should be called only after cell is added/deleted 
515  *     from the globlal hashlist
516  *
517  *     File : rg_utl.c
518  *
519  **********************************************************/
520 Void rgUpdtCellCnt(Inst inst,uint8_t updtType)
521 {
522
523    switch (updtType)
524    {
525       case RG_CFG_ADD:
526          rgCb[inst].genSts.numCellCfg++;
527          break;
528       case RG_CFG_DEL:
529          rgCb[inst].genSts.numCellCfg--;
530          break;
531       default:
532          break;
533    }
534
535    return;
536 } /* rgUpdtCellCnt */
537
538
539 /***********************************************************
540  *
541  *     Func : rgUpdtUeCnt
542  *
543  *     Desc : Utility Function to update ue count. It gives number of active
544  *     Ues.
545  *            
546  *
547  *     Ret  : ROK
548  *            RFAILED
549  *
550  *     Notes: This function should be called only after ue is added/deleted 
551  *     from the globlal hashlist
552  *
553  *     File : rg_utl.c
554  *
555  **********************************************************/
556 Void rgUpdtUeCnt(Inst inst,uint8_t updtType)
557 {
558    switch (updtType)
559    {
560       case RG_CFG_ADD:
561          rgCb[inst].genSts.numUeCfg++;
562          break;
563       case RG_CFG_DEL:
564          rgCb[inst].genSts.numUeCfg--;
565          break;
566       default:
567          break;
568    }
569    return;
570 } /* rgUpdtUeCnt */
571
572 /*
573 *
574 *       Fun:   rgAllocEventMem
575 *
576 *       Desc:  This function allocates event memory 
577 *
578 *       Ret:   ROK      - on success
579 *              RFAILED  - on failure
580 *
581 *       Notes: None
582 *
583 *       File:  rg_utl.c
584 *
585 */
586 S16 rgAllocEventMem
587 (
588 Inst     inst,
589 Ptr       *memPtr,
590 Size      memSize
591 )
592 {
593    Mem               sMem;
594    volatile uint32_t startTime=0;
595
596
597    sMem.region = rgCb[inst].rgInit.region;
598    sMem.pool = rgCb[inst].rgInit.pool;
599
600 #if (ERRCLASS & ERRCLS_DEBUG)
601    if (memSize<= 0)
602    {
603       DU_LOG("\nERROR  -->  MAC : rgAllocEventMem(): memSize invalid\n");
604       return  (RFAILED);
605    }
606 #endif /* ERRCLASS & ERRCLS_DEBUG */
607
608
609    /*starting Task*/
610    SStartTask(&startTime, PID_MACUTL_CMALLCEVT);
611
612 #ifdef MS_MBUF_CORRUPTION /* Should be enabled when debugging mbuf corruption */
613    MS_BUF_ADD_ALLOC_CALLER();
614 #endif /* */
615 #ifdef TFU_ALLOC_EVENT_NO_INIT
616    if(ROK != cmAllocEvntNoInit(memSize, TFU_MAX_MEMBLK_SIZE, &sMem, memPtr))
617 #else
618    if(ROK != cmAllocEvnt(memSize, TFU_MAX_MEMBLK_SIZE, &sMem, memPtr))
619 #endif /* */
620    {
621       DU_LOG("\nERROR  -->  MAC : cmAllocEvnt Failed"); 
622       return RFAILED;
623    }
624
625    /*stoping Task*/
626    SStopTask(startTime, PID_MACUTL_CMALLCEVT);
627
628    return ROK;
629 } /* end of rgAllocEventMem*/
630
631 /*
632 *
633 *       Fun:   rgGetEventMem
634 *
635 *       Desc:  This function allocates event memory 
636 *
637 *       Ret:   ROK      - on success
638 *              RFAILED  - on failure
639 *
640 *       Notes: None
641 *
642 *       File:  rg_utl.c
643 *
644 */
645 S16 rgGetEventMem
646 (
647 Inst      inst,
648 Ptr       *ptr,
649 Size      len,
650 Ptr       memCp
651 )
652 {
653    S16   ret;
654
655 #ifdef TFU_ALLOC_EVENT_NO_INIT
656    ret = cmGetMemNoInit(memCp, len, (Ptr *)ptr);
657 #else
658    ret = cmGetMem(memCp, len, (Ptr *)ptr);
659 #endif /* */
660    return (ret);
661 } /* end of rgGetEventMem*/
662
663 /***********************************************************
664  *
665  *     Func : rgGetPstToInst
666  *
667  *     Desc : Utility Function to get the pst structure to post a message to
668  *     scheduler instance
669  *            
670  *
671  *     Ret  : ROK
672  *            RFAILED
673  *
674  *     Notes: This function should be called while sending a msg from 
675  *     MAC to a scheduler instance
676  *
677  *     File : rg_utl.c
678  *
679  **********************************************************/
680 Void rgGetPstToInst
681 (
682 Pst           *pst,
683 Inst          srcInst,
684 Inst          dstInst
685 )
686 {
687
688    pst->srcEnt = rgCb[srcInst].rgInit.ent; 
689    pst->srcInst = rgCb[srcInst].rgInit.inst;
690    pst->srcProcId = rgCb[srcInst].rgInit.procId;
691    pst->region = rgCb[srcInst].rgInit.region;
692    pst->pool = rgCb[srcInst].rgInit.pool;
693
694    pst->dstProcId = rgCb[dstInst].rgInit.procId;
695    pst->dstEnt = rgCb[dstInst].rgInit.ent; 
696    pst->dstInst = dstInst;
697    pst->selector = 0;
698    pst->prior     = PRIOR0;
699    pst->intfVer   = 0;
700    pst->route   = RTESPEC;
701
702    return; 
703 } /* end of rgGetPstToInst */
704
705 /***********************************************************
706  *
707  *     Func : RgSchMacLcgRegReq
708  *
709  *     Desc : Utility Function to register the set of GBR LCG.
710  *        Invoked at the time of LCG configuration/Reconfiguration at Schedular.
711  * 
712  *     Processing Steps: 
713  *           - Fetch the ueCb using the crnti given in lcInfo            
714  *           - Store the if LCG is GBR or not.
715  *
716  *     Ret  : ROK
717  *            RFAILED
718  *
719  *     Notes: This function should be called at the time of LCG 
720  *     configuration/Reconfiguration at Schedular. 
721  *     
722  *
723  *     File : rg_utl.c
724  *
725  **********************************************************/
726 S16 RgSchMacLcgRegReq(Pst *pst,RgInfLcgRegReq *lcgRegReq)
727 {
728    Inst       inst;
729    RgCellCb   *cell = NULLP;
730    RgUeCb     *ue;
731
732    RG_IS_INST_VALID(pst->dstInst);
733    inst   = pst->dstInst - RG_INST_START;
734    cell   = rgCb[inst].cell;
735    /* Fetch the cell and then the UE */
736    if((cell == NULLP) ||
737       (cell->cellId != lcgRegReq->cellId))
738    {
739       
740       DU_LOG("\nERROR  -->  MAC : Cell does not exist ");
741       return RFAILED;
742    }
743
744    if ((ue = rgDBMGetUeCb(cell, lcgRegReq->crnti)) == NULLP)
745    {
746      DU_LOG("\nERROR  -->  MAC : CRNTI:%d does not exist", 
747                          lcgRegReq->crnti);
748       return RFAILED;
749    }
750    ue->ul.lcgArr[lcgRegReq->lcgId].isGbr = lcgRegReq->isGbr;
751
752    return ROK; 
753 } /* end of RgSchMacLcgRegReq */
754
755 #ifdef LTEMAC_SPS
756
757 /***********************************************************
758  *
759  *     Func : RgSchMacUlSpsResetReq
760  *
761  *     Desc : Utility Function to reset SPS params for a UE
762  * 
763  *     Processing Steps: 
764  *           - Fetch the ueCb using the crnti 
765  *           - reset implRelCnt and explRelCnt
766  *
767  *     Ret  : ROK
768  *            RFAILED
769  *
770  *     File : rg_utl.c
771  *
772  **********************************************************/
773 S16 RgSchMacUlSpsResetReq(Pst *pst,RgInfUlSpsReset *ulSpsResetInfo)
774 {
775    Inst       inst;
776    RgCellCb   *cell = NULLP;
777    RgUeCb     *ue;
778
779    RG_IS_INST_VALID(pst->dstInst);
780    inst   = pst->dstInst - RG_INST_START;
781    cell   = rgCb[inst].cell;
782    /* Fetch the cell and then the UE */
783    if((cell == NULLP)||
784       (cell->cellId != ulSpsResetInfo->cellId))
785    {
786       
787       DU_LOG("\nERROR  -->  MAC : Cell does not exist ");
788       return RFAILED;
789    }
790
791    if ((ue = rgDBMGetUeCb(cell, ulSpsResetInfo->crnti)) == NULLP)
792    {
793       DU_LOG("\nERROR  -->  MAC : CRNTI:%d does not exist", 
794                       ulSpsResetInfo->crnti);
795       return RFAILED;
796    }
797
798    ue->ul.implRelCntr = 0;
799    ue->ul.explRelCntr = 0;
800
801    return ROK; 
802 } /* end of RgSchMacUlSpsResetReq */
803
804
805
806
807 /***********************************************************
808  *
809  *     Func : RgSchMacSpsLcRegReq
810  *
811  *     Desc : Utility Function to register the set of uplink SPS logical
812  *        channels for a SPS UE.
813  *        Invoked at the time of activation of a UE for UL-SPS.
814  *        Whenever there is data on these LCs MAC shall inform scheduler
815  * 
816  *     Processing Steps: 
817  *           - Fetch the ueCb using the crnti given in lcInfo            
818  *           - Store the sps-rnti and set the bits corresponding to the
819  *             logical channel ids in ueUlCb->spsLcMask.
820  *
821  *     Ret  : ROK
822  *            RFAILED
823  *
824  *     Notes: This function should be called at the time UL SPS is activated 
825  *     for a UE at scheduler
826  *     
827  *
828  *     File : rg_utl.c
829  *
830  **********************************************************/
831 S16 RgSchMacSpsLcRegReq(Pst *pst,RgInfSpsLcInfo *lcInfo)
832 {
833    Inst       inst;
834    RgCellCb   *cell= NULLP;
835    RgUeCb     *ue;
836    uint8_t    idx;
837
838    RG_IS_INST_VALID(pst->dstInst);
839    inst   = pst->dstInst - RG_INST_START;
840    cell   = rgCb[inst].cell;
841    /* Fetch the cell and then the UE */
842    if((cell == NULLP) ||
843       (cell->cellId != lcInfo->cellId))
844    {
845       
846       DU_LOG("\nERROR  -->  MAC : Cell does not exist ");
847       return RFAILED;
848    }
849
850    if ((ue = rgDBMGetUeCb(cell, lcInfo->crnti)) == NULLP)
851    {
852       DU_LOG("\nERROR  -->  MAC : CRNTI:%d does not exist", 
853                       lcInfo->crnti);
854       return RFAILED;
855    }
856
857    /* Store the sps-rnti and SPS LC information in the UE */ 
858    ue->spsRnti = lcInfo->spsRnti;
859    for (idx=0; idx < lcInfo->spsLcCnt; idx++)
860    {
861       /* KWORK_FIX: Modified the index from lcId to lcId-1 for handling lcId 10 properly */
862       ue->ul.spsLcId[(lcInfo->spsLcId[idx])-1] = TRUE;
863    }
864    ue->ul.implRelCnt = lcInfo->implRelCnt;
865    ue->ul.explRelCnt = ue->ul.implRelCnt + 1; /*(lcInfo->implRelCnt * lcInfo->spsPrd);*/
866
867    /* Insert the UE into SPS UE List */
868    if (rgDBMInsSpsUeCb(cell, ue) == RFAILED)
869    {
870       DU_LOG("\nERROR  -->  MAC : Ue insertion into SPS list failed SPS CRNTI:%d", ue->spsRnti);
871       return RFAILED;
872    } 
873
874    return ROK; 
875 } /* end of RgSchMacSpsLcRegReq */
876
877
878 /***********************************************************
879  *
880  *     Func : RgSchMacSpsLcDeregReq
881  *
882  *     Desc : Utility Function to deregister the set of uplink SPS 
883  *        logical channels for a UE.
884  *        Invoked at the time of release of UL-SPS for an activated UE.
885  * 
886  *     Processing Steps: 
887  *           - Fetch the ueCb using the crnti given
888  *           - Reset the bits corresponding to the logical channel ids in
889  *             ueUlCb->spsLcMask.
890  *
891  *     Ret  : ROK
892  *            RFAILED
893  *
894  *     Notes: This function should be called at the time UL SPS is released 
895  *     for a UE at scheduler
896  *     
897  *
898  *     File : rg_utl.c
899  *
900  **********************************************************/
901 S16 RgSchMacSpsLcDeregReq(Pst  *pst,CmLteCellId cellId,CmLteRnti crnti)
902 {
903    Inst       inst;
904    RgCellCb   *cell = NULLP;
905    RgUeCb      *ue;
906
907    RG_IS_INST_VALID(pst->dstInst);
908    inst   = pst->dstInst - RG_INST_START;
909    cell   = rgCb[inst].cell;
910    /* Fetch the cell and then the UE */
911    if((cell == NULLP) ||
912       (cell->cellId != cellId))
913    {
914       
915       DU_LOG("\nERROR  -->  MAC : Cell does not exist ");
916       return RFAILED;
917    }
918
919    if ((ue = rgDBMGetUeCb(cell, crnti)) == NULLP)
920    {
921       DU_LOG("\nERROR  -->  MAC : CRNTI:%d Ue does not exist", crnti);
922       return RFAILED;
923    }
924
925    /* No need to reset the SPS LC Ids as they will not be looked at*/
926
927    /* Delete UE from the SPS UE List */
928    rgDBMDelSpsUeCb(cell, ue);
929    
930    return ROK; 
931 } /* end of RgSchMacSpsLcDeregReq */
932
933 #endif /* LTEMAC_SPS */
934
935 /**
936  * @brief Function for handling CRNTI change request 
937  * received from scheduler to MAC.
938  *
939  * @details
940  *
941  *     Function : rgUtlHndlCrntiChng
942  *     
943  *        - Delete old UE from the list.
944  *        - Update the new rnti and re-insert the UE in the list.
945  *     
946  *           
947  *  @param[in] Inst        inst
948  *  @param[in] RgCellCb      *cell,
949  *  @param[in] CmLteRnti     rnti,
950  *  @param[in] CmLteRnti     newRnti
951  *  @return  S16
952  *      -# ROK 
953  *      -# RFAILED
954  **/
955 static S16 rgUtlHndlCrntiChng 
956 (
957 Inst            inst,
958 RgCellCb        *cell,
959 CmLteRnti       rnti,
960 CmLteRnti       newRnti
961 )
962 {
963    RgUeCb         *ue = NULLP;
964    RgUeCb         *newUe = NULLP;
965
966    ue = rgDBMGetUeCb(cell, rnti);
967    newUe = rgDBMGetUeCbFromRachLst(cell, newRnti);
968    if ((ue == NULLP) || (newUe == NULLP))
969    {
970       DU_LOG("\nERROR  -->  MAC : RNTI:%d Failed to get UECB[%lu:%lu] or NEW RNTI:%d", 
971                rnti, ((PTR)ue), ((PTR)newUe), newRnti);
972       return RFAILED;
973    }
974 #ifdef XEON_SPECIFIC_CHANGES
975    DU_LOG("\nDEBUG  -->  MAC : MAC:UE[%d] id changed to %d\n", rnti, newRnti);
976 #endif
977    rgDBMDelUeCb(cell, ue);
978
979    ue->ueId = newRnti;
980
981    memcpy(&(ue->contResId), &(newUe->contResId), 
982                    sizeof(newUe->contResId));
983    /* Fix : syed MSG4 might be RETXing need to store the
984     * HARQ context. */
985    rgDHMFreeUe(inst,&ue->dl.hqEnt);
986    ue->dl.hqEnt = newUe->dl.hqEnt;
987        
988    rgDBMInsUeCb(cell, ue);
989
990    rgDBMDelUeCbFromRachLst(cell, newUe);
991    rgFreeSBuf(inst,(Data **)&newUe, sizeof(*newUe));
992
993    return ROK;
994 } /* end of rgUtlHndlCrntiChng */
995
996 #ifdef LTE_ADV
997 /**
998  * @brief Function for handling UE  release for SCELL
999  * triggered from SCH to MAC.
1000  *
1001  * @details
1002  *
1003  *     Function : rgDelUeFrmAllSCell
1004  *     
1005  *        - This Function should be invoked by PCell of UE
1006  *        - Remove the UE context from SCELL corresponding to rnti.
1007  *           
1008  *  @param[in] Inst      *macInst,
1009  *  @param[in] RgUeCb    *ue
1010  *  @return  ROK is SUCCESS 
1011  **/
1012 S16 rgDelUeFrmAllSCell(RgCellCb *cell,RgUeCb *ue)
1013 {
1014    Inst        inst     = cell->macInst - RG_INST_START;
1015    uint8_t     idx      = 0;
1016    Inst        sCellInstIdx;
1017    Pst         dstInstPst;
1018    RgPrgUeSCellDelInfo ueSCellDelInfo;
1019
1020    /* To Delete the SCells if exisits for that UE */
1021    for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
1022    {
1023       if(TRUE == ue->sCelInfo[idx].isSCellAdded)
1024       {
1025          sCellInstIdx = ue->sCelInfo[idx].macInst - RG_INST_START;
1026
1027          rgGetPstToInst(&dstInstPst, inst, sCellInstIdx);
1028          ueSCellDelInfo.ueId = ue->ueId;
1029          ueSCellDelInfo.sCellId = ue->sCelInfo[idx].sCellId;
1030
1031          /* Filling same ueId in newRnti so that SMAC will check if newRnti
1032           *and old UeId is same that means its a UeSCell delete request*/
1033          ueSCellDelInfo.newRnti = ue->ueId;
1034
1035          RgPrgPMacSMacUeSCellDel(&dstInstPst, &ueSCellDelInfo);
1036          ue->sCelInfo[idx].isSCellAdded = FALSE;
1037       } /* loop of if */
1038    } /* loop of for */
1039
1040    return ROK;
1041 } /* rgDelUeFrmAllSCell */
1042
1043 /**
1044  * @brief Function to validate AddSCellCfg.
1045  *
1046  * @details
1047  *
1048  *     Function : rgUtlVltdAddSCellCfg
1049  *     
1050  *           
1051  *  @param[in] ueSCellCb   secondary cell CB for validation
1052  *  @param[in] cell        cell control block
1053  *  @param[in] inst        instance number to fetch rgCb instance
1054  *  @return  S16
1055  *      -# ROK 
1056  **/
1057 S16 rgUtlVltdAddSCellCfg(RgPrgUeSCellCfgInfo *ueSCellCb,RgCellCb *cell,Inst inst)
1058 {
1059   S16 ret = ROK; 
1060   
1061   /* To Validate the CellID presence */
1062   if((cell == NULLP) ||
1063         (cell->cellId != ueSCellCb->cellId))
1064   {
1065      DU_LOG("\nERROR  -->  MAC : [%d]Sec Cell does not exit %d\n",
1066               ueSCellCb->ueId, ueSCellCb->cellId);
1067      ret = RFAILED;
1068   }
1069 #ifdef TENB_MULT_CELL_SUPPRT
1070    if((ueSCellCb->rguDlSapId > rgCb[inst].numRguSaps) ||
1071       (ueSCellCb->rguUlSapId > rgCb[inst].numRguSaps))
1072    {
1073       DU_LOG("\nERROR  -->  MAC : Invald Sap Id: DL %d UL %d for ueId %d failed\n",
1074                ueSCellCb->rguDlSapId,
1075                ueSCellCb->rguUlSapId,
1076                ueSCellCb->cellId);
1077      ret = RFAILED;
1078    }
1079 #endif
1080    return (ret);
1081 } /* rgUtlVltdAddSCellCfg */
1082
1083 /**
1084  * @brief Function to build CrntiChangeReq and send to all SMACs.
1085  *
1086  * @details
1087  *
1088  *     Function : rgUtlSndCrntiChngReq2AllSMacs
1089  *     
1090  *        - This Function should be invoked by PCell of UE
1091  *        - It sends RgPrgPMacSMacUeSCellDelReq to all SMACs with newRnti sent
1092  *          by SCH. SMAC will check if newRnti is not equal to old UeId then it
1093  *          do only UeId change else it will delete the UeScell context
1094  *           
1095  *  @param[in] cell    Cell CB to get Ue control block
1096  *  @param[in] rnti    Ue Identifier used to fill in UeId Change req
1097  *  @param[in] newRnti UE new identifier, to be used in UeId Change req
1098  *  @return  S16
1099  *      -# ROK 
1100  **/
1101 static S16 rgUtlSndCrntiChngReq2AllSMacs
1102 (
1103 RgCellCb        *cell,
1104 CmLteRnti       rnti,
1105 CmLteRnti       newRnti
1106 )
1107 {
1108    Inst                inst = cell->macInst - RG_INST_START;
1109    Inst                sCellInstIdx;
1110    Pst                 dstInstPst;
1111    RgPrgUeSCellDelInfo ueIdChngReq;
1112    RgUeCb              *ue;
1113    uint8_t                  idx;
1114 #ifdef L2_OPTMZ
1115 TfuDelDatReqInfo delDatReq;
1116 #endif
1117
1118    /* use newRnti to get UeCb in PMac because rnti is already changed in PMac*/
1119    ue = rgDBMGetUeCb(cell, newRnti);
1120    if (ue == NULLP)
1121    {
1122       DU_LOG("\nERROR  -->  MAC : [%d]RNTI:Failed to get ueCb \
1123                newRnti=%d\n", rnti, newRnti);
1124       return RFAILED;
1125    }
1126    /* For all added SCells, prepare and send ueIdChngReq */
1127    for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
1128    {
1129       if(TRUE == ue->sCelInfo[idx].isSCellAdded)
1130       {
1131          sCellInstIdx = ue->sCelInfo[idx].macInst - RG_INST_START;
1132
1133          rgGetPstToInst(&dstInstPst, inst, sCellInstIdx);
1134          /* fill old rnti*/
1135          ueIdChngReq.ueId = rnti;
1136          ueIdChngReq.sCellId = ue->sCelInfo[idx].sCellId;
1137          
1138          /* Filling newRnti so that SMAC can check if old ueId and new UeId
1139           *(newRnti) is different then its a UeId change request from PMAC.
1140           * RgPrgPMacSMacUeSCellDelReq is being reused for UeId change req
1141           * from PMAC to SMAC*/
1142          ueIdChngReq.newRnti = newRnti;
1143          
1144          /* Re-using UeSCellDelReq API for UeId change*/
1145          RgPrgPMacSMacUeSCellDel(&dstInstPst, &ueIdChngReq);
1146 #ifdef L2_OPTMZ
1147       /* Sending delDatReq to CL to clear the Pdus for old UeId present in CL*/
1148       delDatReq.cellId = ueIdChngReq.sCellId;
1149       delDatReq.ueId = ueIdChngReq.ueId;
1150       rgLIMTfuDelDatReq(sCellInstIdx, &delDatReq);
1151 #endif
1152
1153       } /* loop of if */
1154    } /* loop of for */
1155
1156    return ROK;
1157 } /* rgUtlSndCrntiChngReq2AllSMacs */
1158
1159 #endif /* LTE_ADV */
1160
1161 /**
1162  * @brief Function for handling CRNTI Context release 
1163  * triggered from SCH to MAC.
1164  *
1165  * @details
1166  *
1167  *     Function : rgUtlHndlCrntiRls
1168  *     
1169  *        - Remove the UE context from MAC corresponding to rnti.
1170  *     
1171  *           
1172  *  @param[in] RgCellCb      *cell,
1173  *  @param[in] CmLteRnti     rnti
1174  *  @return  Void 
1175  **/
1176 static Void rgUtlHndlCrntiRls(RgCellCb *cell,RgInfRlsRnti *rlsRnti)
1177 {
1178    Inst           inst = cell->macInst - RG_INST_START;
1179    RgUeCb        *ue = NULLP;
1180 #ifdef LTEMAC_SPS
1181    RgUeCb         *spsUeCb = NULLP;
1182 #endif
1183
1184    if ((ue = rgDBMGetUeCb(cell, rlsRnti->rnti)) == NULLP)
1185    {
1186       /* Check in RachLst */
1187       if((ue=rgDBMGetUeCbFromRachLst (cell, rlsRnti->rnti)) != NULLP)
1188       {
1189          /* Delete Ue from the UE list */
1190          rgDBMDelUeCbFromRachLst(cell, ue);
1191
1192          /* Free Ue */
1193          rgRAMFreeUeCb(inst,ue);
1194       }
1195       else
1196       {
1197           DU_LOG("\nERROR  -->  MAC : RNTI:%d No ueCb found in RachLst",rlsRnti->rnti);
1198       }
1199    }
1200    else
1201    {
1202 #ifdef LTE_ADV
1203       if(FALSE == rlsRnti->isUeSCellDel)
1204       {
1205          rgDelUeFrmAllSCell(cell, ue);
1206       }
1207 #endif /* LTE_ADV */
1208
1209       /* Delete Ue from the UE list */
1210       rgDBMDelUeCb(cell, ue);
1211 #ifdef LTEMAC_SPS
1212       spsUeCb = rgDBMGetSpsUeCb (cell, ue->spsRnti);
1213       if (spsUeCb)
1214       {
1215          rgDBMDelSpsUeCb(cell, spsUeCb);
1216       }
1217 #endif
1218
1219       /* Free Ue */
1220       rgCFGFreeUeCb(cell, ue);     
1221       /* MS_REMOVE : syed Check in RachLst */
1222       {
1223          if((ue=rgDBMGetUeCbFromRachLst (cell, rlsRnti->rnti)) != NULLP)
1224          {
1225              DU_LOG("\nERROR  -->  MAC : RNTI:%d STALE UE is still present", rlsRnti->rnti);         
1226          }
1227       }
1228    }
1229
1230    return;
1231 } /* end of rgUtlHndlCrntiRls */
1232
1233 /**
1234  * @brief Function for handling RaResp request received from scheduler to MAC.
1235  *
1236  * @details
1237  *
1238  *     Function : RgSchMacRlsRntiReq
1239  *     
1240  *     This function shall be invoked whenever scheduler is done with the
1241  *     allocations of random access responses for a subframe.
1242  *     This shall invoke RAM to create ueCbs for all the rapIds allocated and 
1243  *     shall invoke MUX to create RAR PDUs for raRntis allocated.
1244  *     
1245  *           
1246  *  @param[in] CmLteCellId         cellId,
1247  *  @param[in] CmLteTimingInfo     timingInfo,
1248  *  @param[in] RaRespInfo          *rarInfo
1249  *  @return  S16
1250  *      -# ROK 
1251  **/
1252 S16 RgSchMacRlsRntiReq(Pst *pst,RgInfRlsRnti *rlsRnti)
1253 {
1254 //   Pst            schPst;
1255 //   RgInfUeDelInd  ueDelInd;
1256    Inst           macInst;
1257    RgCellCb       *cell;
1258 #ifdef L2_OPTMZ
1259 TfuDelDatReqInfo delDatReq;
1260 #endif
1261
1262    RG_IS_INST_VALID(pst->dstInst);
1263    macInst   = pst->dstInst - RG_INST_START;
1264    cell   = rgCb[macInst].cell;
1265
1266    if(NULLP == rlsRnti)
1267    {
1268       return RFAILED;
1269    }
1270
1271    if((cell == NULLP) ||
1272       (cell->cellId != rlsRnti->cellId))
1273    {
1274       
1275       DU_LOG("\nERROR  -->  MAC : No cellCb found with cellId for RNTI:%d", 
1276                          rlsRnti->rnti);
1277       return RFAILED;
1278    }
1279    /* Fix : syed Clearing UE context when SCH indicates to do so
1280     * UE DEL from CRG interface is now dummy. */
1281    if (rlsRnti->ueIdChng)
1282    {
1283       /* Fix : syed ueId change as part of reestablishment.
1284        * Now SCH to trigger this. CRG ueRecfg for ueId change 
1285        * is dummy */       
1286       if (rgUtlHndlCrntiChng(macInst,cell, rlsRnti->rnti, rlsRnti->newRnti) != ROK)        
1287       {
1288           DU_LOG("\nERROR  -->  MAC : CRNTI change failed for RNTI:%d new RNTI:%d",
1289                    rlsRnti->rnti,rlsRnti->newRnti);
1290          return RFAILED;
1291       }
1292
1293 #ifdef LTE_ADV
1294       /*PMAC_Reest: Prepare CrntiChngReq and then send to all SMACs to change
1295        *rnti in all Scells
1296        */
1297       if(rgUtlSndCrntiChngReq2AllSMacs(cell, rlsRnti->rnti, rlsRnti->newRnti) != ROK)
1298       {
1299          /* TODO: do we need to send DelInd to SCH in failure case*/ 
1300          return RFAILED;
1301       }
1302 #endif
1303 #ifdef L2_OPTMZ
1304       /* Sending delDatReq to CL to clear the Pdus for old UeId present in CL*/
1305       delDatReq.cellId = cell->cellId;
1306       delDatReq.ueId = rlsRnti->rnti;
1307       rgLIMTfuDelDatReq(macInst, &delDatReq);
1308 #endif
1309    }
1310    else
1311    {
1312       rgUtlHndlCrntiRls(cell, rlsRnti);
1313    }
1314    /* Fix : syed Send delete confirmation to SCH */
1315    /* Send RgMacSchUeDelInd to SCH only if it is Rnti release to PMAC.
1316     * Basically dont send DelInd to SCH incase of Ue SCell Del*/
1317 #ifdef LTE_ADV
1318    if(FALSE == rlsRnti->isUeSCellDel)
1319 #endif
1320    {
1321       //TODO: commented for compilation without SCH 
1322 #if 0
1323       ueDelInd.cellSapId  = cell->schInstMap.cellSapId;
1324       ueDelInd.cellId  = rlsRnti->cellId;
1325       ueDelInd.rnti    = rlsRnti->rnti; 
1326       rgGetPstToInst(&schPst,macInst, cell->schInstMap.schInst);
1327       RgMacSchUeDel(&schPst, &ueDelInd);
1328 #endif
1329    }
1330
1331    return ROK;
1332 } /* end of RgSchMacRlsRntiReq */
1333
1334 #ifdef L2_OPTMZ
1335 Bool RgUtlIsTbMuxed(TfuDatReqTbInfo *tb)
1336 {
1337    MsgLen len = 0;
1338    SFndLenMsg(tb->macHdr, &len);
1339    return (len?TRUE : FALSE);
1340 }
1341 #endif
1342
1343 /**********************************************************************
1344  
1345          End of file
1346 **********************************************************************/