[Epic-ID: ODUHIGH-462][Task-ID: ODUHIGH-472] Changes in handling of slot indication...
[o-du/l2.git] / src / 5gnrmac / rg_dbm.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_dbm.c
28   
29 **********************************************************************/
30
31 /** @file rg_dbm.c
32 @brief This file contains the APIs exposed for the insertion/fetching/deletion of cellCb/ueCb and traversal of LcCbLst.
33 */
34
35 /* header include files -- defines (.h) */
36 #include "common_def.h"
37 #include "tfu.h"
38 #include "du_app_mac_inf.h"
39 #include "lrg.h"
40 #include "crg.h"
41 #include "rgu.h"
42 #include "rg_sch_inf.h"
43 #include "rg_env.h"
44 #include "rg.h"
45
46 /* header/extern include files (.x) */
47 #include "tfu.x"
48 #include "lrg.x"
49 #include "crg.x"
50 #include "rgu.x"
51 #include "rg_sch_inf.x"
52 #include "rg_prg.x"       /* PRG interface typedefs*/
53 #include "rg.x"
54
55 /* local defines */
56 static S16 rgDBMInitUeCbLst ARGS(( RgCellCb *cellCb, uint16_t numBins));
57 static Void rgDBMInitDedLcLst ARGS((RgUeCb *ueCb));
58 static Void rgDBMInitCmnLcLst ARGS((RgCellCb *cellCb));
59 static Void rgDBMInitRachLst ARGS((RgCellCb *cellCb));
60 #ifdef LTEMAC_SPS
61 static S16 rgDBMInitSpsUeCbLst ARGS((
62 RgCellCb       *cellCb,
63 uint16_t       numBins
64 ));
65 #endif
66
67 /* local typedefs */
68  
69 /* local externs */
70  
71 /* forward references */
72
73 /**
74  * @brief Handler for Initializing the cell.
75  *
76  * @details
77  *
78  *     Function : rgDBMInitCell
79  *     
80  *   Initializes the lists belonging to the cell.
81  *     
82  *           
83  *  @param[in]  RgCellCb *cellCb
84  *  @return  S16
85  *      -# ROK 
86  *      -# RFAILED
87  **/
88 S16 rgDBMInitCell
89 (
90 RgCellCb       *cellCb
91 )
92 {
93    S16 ret;
94    
95    /* Initialize ue list */
96    if ((ret = rgDBMInitUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
97       return (ret);
98
99 #ifdef LTEMAC_SPS
100    /* Initialize SPS Ue list */
101    if ((ret = rgDBMInitSpsUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
102       return (ret);
103 #endif /* LTEMAC_SPS */
104
105    /* Initialize BCCH/PCCH logical channels */
106    rgDBMInitCmnLcLst(cellCb);
107
108
109    /* Initialize rach ue list */
110    rgDBMInitRachLst(cellCb);
111
112    return (ret);
113
114 } /* rgDBMInitCell */
115
116 /**
117  * @brief Handler for initializing the ueCbLst under the cellCb.
118  *
119  * @details
120  *
121  *     Function : rgDBMInitUeCbLst
122  *     
123  *           
124  *  @param[in] *cellCb 
125  *  @param[in] numBins 
126  *  @return  S16
127  *      -# ROK 
128  *      -# RFAILED 
129  **/
130 static S16 rgDBMInitUeCbLst
131 (
132 RgCellCb       *cellCb,
133 uint16_t       numBins
134 )
135 {
136    Inst inst = cellCb->macInst - RG_INST_START;
137    RgUeCb ue;  
138
139    return (cmHashListInit(&cellCb->ueLst, numBins, (uint16_t)((PTR)&(ue.ueLstEnt) - (PTR)&ue), FALSE, 
140                CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
141
142 }  /* rgDBMInitUeCbLst */
143
144 /**
145  * @brief Handler for de-initializing the ueCbLst under the cellCb.
146  *
147  * @details
148  *
149  *     Function : rgDBMDeInitUeCbLst
150  *     
151  *           
152  *  @param[in] *cellCb 
153  *  @return  S16
154  *      -# ROK 
155  *      -# RFAILED 
156  **/
157 S16 rgDBMDeInitUeCbLst(RgCellCb *cellCb)
158 {
159
160    return (cmHashListDeinit(&cellCb->ueLst));
161
162 }  /* rgDBMDeInitUeCbLst */
163
164 #ifdef LTEMAC_SPS
165 /**
166  * @brief Handler for initializing the spsUeCbLst under the cellCb.
167  *
168  * @details
169  *
170  *     Function : rgDBMInitSpsUeCbLst
171  *     
172  *           
173  *  @param[in] *cellCb 
174  *  @param[in] numBins 
175  *  @return  S16
176  *      -# ROK 
177  *      -# RFAILED 
178  **/
179 static S16 rgDBMInitSpsUeCbLst(RgCellCb *cellCb,uint16_t numBins)
180 {
181    Inst inst = cellCb->macInst - RG_INST_START;
182    RgUeCb ue;
183
184    return (cmHashListInit(&cellCb->spsUeLst, numBins, (uint16_t) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE, 
185                CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
186
187 }  /* rgDBMInitSpsUeCbLst */
188
189 /**
190  * @brief Handler for de-initializing the spsUeCbLst under the cellCb.
191  *
192  * @details
193  *
194  *     Function : rgDBMDeInitSpsUeCbLst
195  *     
196  *           
197  *  @param[in] *cellCb 
198  *  @return  S16
199  *      -# ROK 
200  *      -# RFAILED 
201  **/
202 S16 rgDBMDeInitSpsUeCbLst(RgCellCb *cellCb)
203 {
204
205    return (cmHashListDeinit(&cellCb->spsUeLst));
206
207 }  /* rgDBMDeInitSpsUeCbLst */
208
209 #endif /* LTEMAC_SPS */
210
211 /**
212  * @brief Handler for inserting the ueCb in to the ueCbLst under the cellCb.
213  *
214  * @details
215  *
216  *     Function : rgDBMInsUeCb
217  *     
218  *           
219  *  @param[in] *cellCb 
220  *  @param[in] *ueCb 
221  *  @return  S16
222  *      -# ROK 
223  *      -# RFAILED 
224  **/
225 S16 rgDBMInsUeCb(RgCellCb *cellCb,RgUeCb *ueCb)
226 {
227    return (cmHashListInsert(&cellCb->ueLst, (PTR)ueCb, 
228       (uint8_t *)&ueCb->ueId, (uint16_t)sizeof(ueCb->ueId)));
229
230 }  /* rgDBMInsUeCb */
231
232 #ifdef LTEMAC_SPS
233 /**
234  * @brief Handler for inserting the ueCb in to the spsUeCbLst under the cellCb.
235  *
236  * @details
237  *
238  *     Function : rgDBMInsSpsUeCb
239  *     
240  *           
241  *  @param[in] *cellCb 
242  *  @param[in] *ueCb 
243  *  @return  S16
244  *      -# ROK 
245  *      -# RFAILED 
246  **/
247 S16 rgDBMInsSpsUeCb(RgCellCb *cellCb,RgUeCb  *ueCb)
248 {
249
250    return (cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb, 
251       (uint8_t *)&ueCb->spsRnti, (uint16_t)sizeof(ueCb->spsRnti)));
252
253 }  /* end of rgDBMInsSpsUeCb */
254
255 #endif /* LTEMAC_SPS */
256
257 /**
258  * @brief Handler for accessing the existing ueCb identified by the key ueId
259  * in the ueCbLst under the cellCb.
260  *
261  * @details
262  *
263  *     Function : rgDBMGetUeCb
264  *     
265  *           
266  *  @param[in]  *cellCb
267  *  @param[in]  ueId
268  *  @return  RgUeCb*
269  **/
270 RgUeCb* rgDBMGetUeCb(RgCellCb *cellCb, CmLteRnti ueId)
271 {
272    RgUeCb *ueCb = NULLP; 
273
274    cmHashListFind(&cellCb->ueLst, (uint8_t *)&ueId,
275       sizeof(ueId), 0, (PTR *)&ueCb);
276    return (ueCb);
277 }  /* rgDBMGetUeCb */
278
279 #ifdef LTEMAC_SPS
280 /**
281  * @brief Handler for accessing the ueCb identified by the key sps-rnti
282  * in the spsUeLst under the cellCb.
283  *
284  * @details
285  *
286  *     Function : rgDBMGetSpsUeCb
287  *     
288  *           
289  *  @param[in]  *cellCb
290  *  @param[in]  ueId
291  *  @return  RgUeCb*
292  **/
293 RgUeCb* rgDBMGetSpsUeCb(RgCellCb  *cellCb, CmLteRnti spsRnti)
294 {
295    RgUeCb *ueCb = NULLP; 
296
297    cmHashListFind(&cellCb->spsUeLst, (uint8_t *)&spsRnti,
298       sizeof(spsRnti), 0, (PTR *)&ueCb);
299    return (ueCb);
300 }  /* rgDBMGetSpsUeCb */
301
302 #endif /* LTEMAC_SPS */
303
304 /**
305  * @brief Handler for accessing the existing next ueCb in the ueCbLst under the
306  *  cellCb.
307  *
308  * @details
309  *
310  *     Function : rgDBMGetNextUeCb
311  *     
312  *           
313  *  @param[in]  *cellCb
314  *  @param[in]  *ueCb
315  *  @return  RgUeCb*
316  **/
317 RgUeCb* rgDBMGetNextUeCb(RgCellCb *cellCb, RgUeCb *ueCb)
318 {
319    RgUeCb *nextUeCb = NULLP; 
320
321    cmHashListGetNext(&cellCb->ueLst, (PTR) ueCb, (PTR *)&nextUeCb);
322    return (nextUeCb);
323 }  /* rgDBMGetNextUeCb */
324
325 #ifdef LTEMAC_SPS
326 /**
327  * @brief Handler for accessing the existing next ueCb stored in the spsUeCbLst
328  *         using SPS-Rnti under the cellCb.
329  *
330  * @details
331  *
332  *     Function : rgDBMGetNextSpsUeCb
333  *     
334  *           
335  *  @param[in]  *cellCb
336  *  @param[in]  *ueCb
337  *  @return  RgUeCb*
338  **/
339 RgUeCb* rgDBMGetNextSpsUeCb(RgCellCb *cellCb, RgUeCb *ueCb)
340 {
341    RgUeCb *nextUeCb = NULLP; 
342
343    cmHashListGetNext(&cellCb->spsUeLst, (PTR) ueCb, (PTR *)&nextUeCb);
344    return (nextUeCb);
345 }  /* end of rgDBMGetNextSpsUeCb */
346
347 #endif /* LTEMAC_SPS */
348
349
350 /**
351  * @brief Handler for deleting the existing ueCb from the ueCbLst under the
352  * cellCb.
353  *
354  * @details
355  *
356  *     Function : rgDBMDelUeCb
357  *     
358  *           
359  *  @param[in]  *cellCb 
360  *  @param[in]  *ueCb 
361  *  @return  S16
362  *      -# ROK 
363  *      -# RFAILED 
364  **/
365 S16 rgDBMDelUeCb(RgCellCb *cellCb, RgUeCb *ueCb)
366 {
367    return (cmHashListDelete(&cellCb->ueLst, (PTR)ueCb));
368 }  /* rgDBMDelUeCb */
369
370 #ifdef LTEMAC_SPS
371 /**
372  * @brief Handler for deleting the existing ueCb from the spsUeCbLst under the
373  * cellCb.
374  *
375  * @details
376  *
377  *     Function : rgDBMDelSpsUeCb
378  *     
379  *           
380  *  @param[in]  *cellCb 
381  *  @param[in]  *ueCb 
382  *  @return  S16
383  *      -# ROK 
384  *      -# RFAILED 
385  **/
386 S16 rgDBMDelSpsUeCb(RgCellCb  *cellCb, RgUeCb *ueCb)
387 {
388
389    return (cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
390 }  /* end of rgDBMDelSpsUeCb */
391
392 #endif /* LTEMAC_SPS */
393
394 /**
395  * @brief Handler for Initializing the UE.
396  *
397  * @details
398  *
399  *     Function : rgDBMInitUe
400  *     
401  *   Initializes the lists belonging to the UE.
402  *     
403  *           
404  *  @param[in]  RgUeCb  *ueCb
405  *  @return  S16
406  *      -# ROK 
407  *      -# RFAILED
408  **/
409 Void rgDBMInitUe(RgUeCb *ueCb)
410 {
411 #ifdef LTEMAC_SPS
412    uint8_t        idx;
413 #endif
414
415    /* Initialize Dedicated logical channels */
416    rgDBMInitDedLcLst(ueCb);
417
418 #ifdef LTEMAC_SPS
419    /* Initialize the SPS LC Ids */
420    for (idx=0; idx < RG_MAX_LC_PER_UE; idx++)
421    {
422       ueCb->ul.spsLcId[idx] = FALSE;
423    }
424 #endif
425
426
427    return;
428 } /* rgDBMInitUe */
429
430 /**
431  * @brief Handler for Initializing the dedicated logical channels.
432  *
433  * @details
434  *
435  *     Function : rgDBMInitDedLcLst
436  *     
437  *   Initializes dedicated logical channels.
438  *           
439  *  @param[in]  RgUeCb *ueCb
440  *  @return     Void 
441  **/
442 static Void rgDBMInitDedLcLst(RgUeCb *ueCb)
443 {
444    uint8_t idx;
445    
446    for (idx = 0; idx < RG_MAX_LC_PER_UE; ++idx)
447    {
448       /* Set Dedicated LCs as not configured */
449       ueCb->ul.lcCb[idx].lcId = RG_INVALID_LC_ID;
450       ueCb->ul.lcCb[idx].lcgId = RG_INVALID_LCG_ID;
451       ueCb->dl.lcCb[idx].lcId = RG_INVALID_LC_ID;
452    }
453
454    for (idx = 0; idx < RG_MAX_LCG_PER_UE; ++idx)
455    {
456       /* Set LCGs as not configured */
457       ueCb->ul.lcgArr[idx].lcgId = RG_INVALID_LCG_ID;
458       ueCb->ul.lcgArr[idx].lcCount = 0;
459    }
460
461    /* Stack Crash problem for TRACE5 Changes. Added the return below */
462   return;
463 } /* rgDBMInitDedLcLst */
464
465 /**
466  * @brief Handler for Initializing the common logical channel list of the cell.
467  *
468  * @details
469  *
470  *     Function : rgDBMInitCmnLcLst
471  *     
472  *   Initializes following common logical channels belonging to the cell.
473  *     - BCCH on BCH
474  *     - BCCH on DLSCH
475  *     - PCCH
476  *           
477  *  @param[in]  RgCellCb *cellCb
478  *  @return  Void
479  **/
480 static Void rgDBMInitCmnLcLst(RgCellCb *cellCb)
481 {
482    uint8_t idx;
483    
484    cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
485    cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
486
487    cellCb->numBcchDlschInfo = 0;
488    for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
489    {
490       cellCb->bcchDlschInfo[idx].lcId = RG_INVALID_LC_ID;
491       cellCb->bcchDlschInfo[idx].tb = NULLP;
492    }
493
494    /* Stack Crash problem for TRACE5 Changes. Added the return below */
495   return;
496 } /* rgDBMInitCmnLcLst */
497
498 /**
499  * @brief Handler for Initializing the common logical channel list of the cell.
500  *
501  * @details
502  *
503  *     Function : rgDBMFreeCmnLcLst
504  *     
505  *   Initializes following common logical channels belonging to the cell.
506  *     - BCCH on BCH
507  *     - BCCH on DLSCH
508  *     - PCCH
509  *           
510  *  @param[in]  RgCellCb *cellCb
511  *  @return  Void
512  **/
513 Void rgDBMFreeCmnLcLst(RgCellCb *cellCb)
514 {
515    uint8_t idx;
516    
517    cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
518    cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
519
520    for (idx = 0; idx < cellCb->numBcchDlschInfo; idx++)
521    {
522       cellCb->bcchDlschInfo[idx].lcId = RG_INVALID_LC_ID;
523       RG_FREE_MSG(cellCb->bcchDlschInfo[idx].tb);
524    }
525    cellCb->numBcchDlschInfo = 0;
526
527    /* Stack Crash problem for TRACE5 Changes. Added the return below */
528   return;
529 } /* rgDBMFreeCmnLcLst */
530
531 /**
532  * @brief Handler for inserting dedicated DL logical channel.
533  *
534  * @details
535  *
536  *     Function : rgDBMInsDlDedLcCb
537  *     
538  *  @param[in]  RgUeCb *ueCb
539  *  @param[in]  RgDlLcCb* dlLcCb
540  *  @return  Void
541  **/
542 Void rgDBMInsDlDedLcCb(RgUeCb  *ueCb, CmLteLcId idx)
543 {
544    if( idx >= RG_DEDLC_MIN_LCID )
545    {
546       ueCb->dl.lcCb[idx-1].lcId = idx;
547    }
548   /* Stack Crash problem for TRACE5 Changes. Added the return below */
549   return;
550 }  /* rgDBMInsDlDedLcCb */
551
552 /**
553  * @brief Handler for deleting dedicated DL logical channel.
554  *
555  * @details
556  *
557  *     Function : rgDBMDelDlDedLcCb
558  *     
559  *  @param[in]  RgUeCb *ueCb
560  *  @param[in]  RgDlLcCb* dlLcCb
561  *  @return  Void
562  **/
563 Void rgDBMDelDlDedLcCb(RgUeCb  *ueCb, RgDlLcCb *dlLcCb)
564 {
565    ueCb->dl.lcCb[dlLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
566
567   /* Stack Crash problem for TRACE5 Changes. Added the return below */
568   return;
569   
570 }  /* rgDBMDelDlDedLcCb */
571
572 /**
573  * @brief Handler for accessing the existing DL dedicated lcCb at idx in the 
574  * lcCbLst of the ueCb.
575  *
576  * @details
577  *
578  *     Function : rgDBMGetDlDedLcCb
579  *     
580  *  @param[in]  *ueCb
581  *  @param[in]  idx
582  *  @return  RgDlLcCb*
583  **/
584 RgDlLcCb* rgDBMGetDlDedLcCb(RgUeCb *ueCb, CmLteLcId idx)
585 {
586    if (idx > RG_DEDLC_MAX_LCID || idx <= 0)
587    {
588       return (NULLP);
589    }
590    if(ueCb->dl.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
591    {
592       return (NULLP);
593    }
594
595    return (&ueCb->dl.lcCb[idx-1]);
596
597 }  /* rgDBMGetDlDedLcCb */
598
599 /**
600  * @brief Handler for inserting dedicated UL logical channel.
601  *
602  * @details
603  *
604  *     Function : rgDBMInsUlDedLcCb
605  *     
606  *           
607  *  @param[in]  RgUeCb *ueCb
608  *  @param[in]  CmLteLcId idx
609  *  @param[in]  LteLcgId gId
610  *  @return  Void
611  **/
612 #ifdef LTE_L2_MEAS
613 Void rgDBMInsUlDedLcCb
614 (
615 RgUeCb         *ueCb, 
616 CmLteLcId      idx,
617 LteLcgId       gId,
618 uint8_t        qci
619 )
620 #else
621 Void rgDBMInsUlDedLcCb
622 (
623 RgUeCb         *ueCb, 
624 CmLteLcId      idx,
625 LteLcgId       gId
626 )
627 #endif
628 {
629    if ( idx >= RG_DEDLC_MIN_LCID)
630    {
631       ueCb->ul.lcCb[idx - 1].lcId = idx;
632       ueCb->ul.lcCb[idx - 1].lcgId = gId;
633 #ifdef LTE_L2_MEAS
634       ueCb->ul.lcCb[idx - 1].qci = qci;
635 #endif
636    }
637    if(ueCb->ul.lcgArr[gId].lcgId == RG_INVALID_LCG_ID)
638    {
639       ueCb->ul.lcgArr[gId].lcgId = gId;
640    }
641    ueCb->ul.lcgArr[gId].lcCount = ueCb->ul.lcgArr[gId].lcCount + 1;
642
643
644   /* Stack Crash problem for TRACE5 Changes. Added the return below */
645   return;
646
647 }  /* rgDBMInsUlDedLcCb */
648
649 /**
650  * @brief Handler for deleting the dedicated UL logical channel.
651  *
652  * @details
653  *
654  *     Function : rgDBMUpdUlDedLcCb
655  *     
656  *           
657  *  @param[in]  RgUeCb *ueCb
658  *  @param[in]  RgUlLcCb* ulLcCb
659  *  @param[in]  LteLcgId gId
660  *  @return  Void
661  **/
662 Void rgDBMUpdUlDedLcCb
663 (
664 RgUeCb         *ueCb, 
665 RgUlLcCb       *ulLcCb,
666 LteLcgId       gId
667 )
668 {
669    ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount = 
670                ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
671    if(ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount == 0)
672    {
673       ueCb->ul.lcgArr[ulLcCb->lcgId].lcgId = RG_INVALID_LCG_ID;
674    }
675    ueCb->ul.lcCb[ulLcCb->lcId - 1].lcgId = gId;
676
677    if(ueCb->ul.lcgArr[gId].lcgId == RG_INVALID_LCG_ID)
678    {
679       ueCb->ul.lcgArr[gId].lcgId = gId;
680    }
681    ueCb->ul.lcgArr[gId].lcCount = ueCb->ul.lcgArr[gId].lcCount + 1;
682
683   /* Stack Crash problem for TRACE5 Changes. Added the return below */
684   return;
685 }  /* rgDBMUpdUlDedLcCb */
686
687 /**
688  * @brief Handler for updating the dedicated UL logical channel.
689  *
690  * @details
691  *
692  *     Function : rgDBMDelUlDedLcCb
693  *     
694  *           
695  *  @param[in]  RgUeCb *ueCb
696  *  @param[in]  RgUlLcCb* ulLcCb
697  *  @return  Void
698  **/
699 Void rgDBMDelUlDedLcCb(RgUeCb *ueCb, RgUlLcCb *ulLcCb)
700 {
701
702    ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount = 
703                ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
704    if(ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount == 0)
705    {
706       ueCb->ul.lcgArr[ulLcCb->lcgId].lcgId = RG_INVALID_LCG_ID;
707    }
708    ueCb->ul.lcCb[ulLcCb->lcId - 1].lcgId = RG_INVALID_LCG_ID;
709    ueCb->ul.lcCb[ulLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
710
711   /* Stack Crash problem for TRACE5 Changes. Added the return below */
712   return;
713 }  /* rgDBMDelUlDedLcCb */
714
715 /**
716  * @brief Handler for accessing the existing UL dedicated lcCb at idx in the
717  * lcCbLst of the ueCb.
718  *
719  * @details
720  *
721  *     Function : rgDBMGetUlDedLcCb
722  *     
723  *           
724  *  @param[in]  *ueCb
725  *  @param[in]  idx
726  *  @return  RgUlLcCb*
727  **/
728 RgUlLcCb* rgDBMGetUlDedLcCb(RgUeCb *ueCb, CmLteLcId  idx)
729 {
730
731    if (idx > RG_DEDLC_MAX_LCID || idx < RG_DEDLC_MIN_LCID)
732    {
733       return (NULLP);
734    }
735    if(ueCb->ul.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
736    {
737       return (NULLP);
738    }
739
740    return (&ueCb->ul.lcCb[idx-1]);
741 }  /* rgDBMGetDlDedLcCb */
742
743 /**
744  * @brief Handler for accessing the existing DL common lcCb identified by the key lcId
745  * in the lcCbLst of the ueCb.
746  *
747  * @details
748  *
749  *     Function : rgDBMChkCmnLcCb
750  *     
751  *           
752  *  @param[in]  *cellCb
753  *  @param[in]  lcId
754  *  @return  S16
755  *      -# ROK
756  *      -# RFAILED
757  **/
758 S16 rgDBMChkCmnLcCb(RgCellCb *cellCb, CmLteLcId lcId)
759 {
760    uint8_t idx;
761
762    if(cellCb->bcchBchInfo.lcId == lcId)
763    {
764       return ROK;
765    } 
766    if(cellCb->pcchInfo.lcId == lcId)
767    {
768       return ROK;
769    }
770
771    for (idx = 0; idx < cellCb->numBcchDlschInfo; idx++)
772    {
773       if(cellCb->bcchDlschInfo[idx].lcId == lcId)
774       {
775          return ROK;
776       } 
777    }
778    return RFAILED;
779 }  /* rgDBMChkCmnLcCb */
780
781 /**
782  * @brief Handler for accessing the existing BCCH mapped on to BCH in the 
783  * lcCbLst of the ueCb.
784  *
785  * @details
786  *
787  *     Function : rgDBMGetBcchOnBch
788  *     
789  *           
790  *  @param[in]  *cellCb
791  *  @return  RgBcchBchLcCb*
792  **/
793 RgBcchBchLcCb* rgDBMGetBcchOnBch(RgCellCb *cellCb)
794 {
795
796    if(cellCb->bcchBchInfo.lcId != RG_INVALID_LC_ID)
797    {
798       return (&(cellCb->bcchBchInfo));
799    }
800    return (NULLP);
801 }  /* rgDBMGetBcchOnBch */
802
803 /**
804  * @brief Handler for accessing the existing BCCH mapped on to DLSCH in the 
805  * lcCbLst of the ueCb.
806  *
807  * @details
808  *
809  *     Function : rgDBMGetBcchOnDlsch
810  *     
811  *           
812  *  @param[in]  *cellCb
813  *  @param[in]  lcId
814  *  @return  RgBcchDlschLcCb*
815  **/
816 RgBcchDlschLcCb* rgDBMGetBcchOnDlsch(RgCellCb *cellCb,CmLteLcId lcId)
817 {
818    uint8_t idx;
819
820    for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
821    {
822       if(cellCb->bcchDlschInfo[idx].lcId == lcId)
823       {
824          return (&(cellCb->bcchDlschInfo[idx]));
825       }
826    }
827    return (NULLP);
828 }  /* rgDBMGetBcchOnDlsch */
829
830 /**
831  * @brief Handler for accessing the existing PCCH in the lcCbLst of the ueCb.
832  *
833  * @details
834  *
835  *     Function : rgDBMGetPcch
836  *     
837  *           
838  *  @param[in]  *cellCb
839  *  @return  RgPcchLcCb*
840  **/
841 RgPcchLcCb* rgDBMGetPcch(RgCellCb *cellCb)
842 {
843  
844    if(cellCb->pcchInfo.lcId != RG_INVALID_LC_ID)
845    {
846       return (&(cellCb->pcchInfo));
847    }
848    return (NULLP);
849 }  /* rgDBMGetPcch */
850
851 /**
852  * @brief Handler for inserting the BCCH mapped on to BCH in the 
853  * lcCbLst of the ueCb.
854  *
855  * @details
856  *
857  *     Function : rgDBMInsBcchOnBch
858  *     
859  *           
860  *  @param[in]  *cellCb
861  *  @return  Void
862  **/
863 Void rgDBMInsBcchOnBch(RgCellCb *cellCb, CmLteLcId idx)
864 {
865
866    cellCb->bcchBchInfo.lcId = idx;
867
868   /* Stack Crash problem for TRACE5 Changes. Added the return below */
869   return;
870 }  /* rgDBMInsBcchOnBch */
871
872 /**
873  * @brief Handler for inserting the BCCH mapped on to DLSCH in the 
874  * lcCbLst of the ueCb.
875  *
876  * @details
877  *
878  *     Function : rgDBMInsBcchOnDlsch
879  *     
880  *           
881  *  @param[in]  *cellCb
882  *  @return  Void
883  **/
884 Void rgDBMInsBcchOnDlsch(RgCellCb *cellCb, CmLteLcId idx)
885 {
886
887    cellCb->bcchDlschInfo[cellCb->numBcchDlschInfo].lcId = idx;
888    cellCb->numBcchDlschInfo++;
889
890   /* Stack Crash problem for TRACE5 Changes. Added the return below */
891   return;
892 }  /* rgDBMInsBcchOnDlsch */
893
894
895 /**
896  * @brief Handler for inserting the PCCH in the lcCbLst of the ueCb.
897  *
898  * @details
899  *
900  *     Function : rgDBMInsPcch
901  *     
902  *           
903  *  @param[in]  *cellCb
904  *  @return  Void
905  **/
906 Void rgDBMInsPcch(RgCellCb *cellCb, CmLteLcId idx)
907 {
908
909    cellCb->pcchInfo.lcId = idx;
910
911   /* Stack Crash problem for TRACE5 Changes. Added the return below */
912   return;
913 }  /* rgDBMInsPcch */
914
915 /**
916  * @brief Handler for initializing the rachLst
917  *
918  * @details
919  *
920  *     Function : rgDBMInitRachLst
921  *     
922  *           
923  *  @param[in] *cellCb 
924  *  @return  Void
925  **/
926 static Void rgDBMInitRachLst(RgCellCb *cellCb)
927 {
928
929    cmLListInit(&cellCb->raInfo.ueRachLst);
930    return;
931 }  /* rgDBMInitRachLst */
932
933 /**
934  * @brief Handler for inserting the ueCb in the rachLst.
935  *
936  * @details
937  *
938  *     Function : rgDBMInsUeCbInRachLst
939  *     
940  *           
941  *  @param[in]  *cellCb
942  *  @param[in]  *ueCb
943  *  @return  Void
944  **/
945 Void rgDBMInsUeCbInRachLst(RgCellCb *cellCb, RgUeCb *ueCb)
946 {
947
948    cmLListAdd2Tail(&cellCb->raInfo.ueRachLst,&ueCb->rachLstEnt);
949
950    return;
951 }  /* rgDBMInsUeCbInRachLst */
952
953 /**
954  * @brief Handler for accessing the existing raCb in the rachLst.
955  *
956  * @details
957  *
958  *     Function : rgDBMGetUeCbFromRachLst
959  *     
960  *           
961  *  @param[in]  *cellCb
962  *  @param[in]  key
963  *  @return  RgUeCb*
964  **/
965 RgUeCb* rgDBMGetUeCbFromRachLst(RgCellCb *cellCb, CmLteRnti key)
966 {
967    CmLList *tmpNode;
968
969    CM_LLIST_FIRST_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
970    while(tmpNode)
971    {
972       if(((RgUeCb *)tmpNode->node)->ueId == key)
973       {
974          return ((RgUeCb *)(tmpNode->node));
975       }
976       CM_LLIST_NEXT_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
977    }
978    return (NULLP);
979 }  /* rgDBMGetUeCbFromRachLst */
980
981 /**
982  * @brief Handler for accessing the existing ueCb from rachLst.
983  *
984  * @details
985  *
986  *     Function : rgDBMGetNextUeCbFromRachLst
987  *     
988  *           
989  *  @param[in]  *cellCb
990  *  @param[in]  *ueCb
991  *  @return  RgUeCb*
992  **/
993 RgUeCb* rgDBMGetNextUeCbFromRachLst(RgCellCb *cellCb,RgUeCb *ueCb)
994 {
995
996    if(!ueCb)
997    {
998       return ( cellCb->raInfo.ueRachLst.first ? 
999                (RgUeCb *)(cellCb->raInfo.ueRachLst.first->node) : NULLP );
1000    }
1001    return ( ueCb->rachLstEnt.next ? 
1002                (RgUeCb *)(ueCb->rachLstEnt.next->node) : NULLP );
1003 }  /* rgDBMGetNextUeCbFromRachLst */
1004
1005 /**
1006  * @brief Handler for deleting the existing ueCb in the rachLst.
1007  *
1008  * @details
1009  *
1010  *     Function : rgDBMDelUeCbFromRachLst
1011  *     
1012  *           
1013  *  @param[in]  *cellCb
1014  *  @param[in]  key
1015  *  @return  RgUeCb*
1016  **/
1017 Void rgDBMDelUeCbFromRachLst(RgCellCb *cellCb, RgUeCb *ueCb)
1018 {
1019
1020    cmLListDelFrm(&cellCb->raInfo.ueRachLst, &ueCb->rachLstEnt);
1021    return;
1022 }  /* rgDBMDelUeCbFromRachLst */
1023
1024 /**********************************************************************
1025  
1026          End of file
1027 **********************************************************************/