Muxing mac pdu and lower mac changes for Msg4
[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 "envopt.h"        /* environment options */
37 #include "envdep.h"        /* environment dependent */
38 #include "envind.h"        /* environment independent */
39 #include "gen.h"           /* general layer */
40 #include "ssi.h"           /* system service interface */
41 #include "cm_hash.h"       /* common hash list */
42 #include "cm_mblk.h"       /* common memory link list library */
43 #include "cm_llist.h"      /* common linked list library */
44 #include "cm_err.h"        /* common error */
45 #include "cm_lte.h"        /* common LTE */
46 #include "lrg.h"
47 #include "crg.h"
48 #include "rgu.h"
49 #include "tfu.h"
50 #include "rg_sch_inf.h"
51 #include "rg_env.h"
52 #include "rg.h"
53
54 /* header/extern include files (.x) */
55 #include "gen.x"           /* general layer */
56 #include "ssi.x"           /* system service interface */
57 #include "cm5.x"           /* common timers */
58 #include "cm_lib.x"        /* common library */
59 #include "cm_hash.x"       /* common hash list */
60 #include "cm_mblk.x"       /* common memory link list library */
61 #include "cm_llist.x"      /* common linked list library */
62 #include "cm_tkns.x"       /* common tokens */
63 #include "cm_lte.x"        /* common LTE */
64 #include "lrg.x"
65 #include "crg.x"
66 #include "rgu.x"
67 #include "tfu.x"
68 #include "rg_sch_inf.x"
69 #include "rg_prg.x"       /* PRG interface typedefs*/
70 #include "du_app_mac_inf.h"
71 #include "rg.x"
72
73
74 /* local defines */
75 PRIVATE S16 rgDBMInitUeCbLst ARGS(( RgCellCb *cellCb, U16 numBins));
76 PRIVATE Void rgDBMInitDedLcLst ARGS((RgUeCb *ueCb));
77 PRIVATE Void rgDBMInitCmnLcLst ARGS((RgCellCb *cellCb));
78 PRIVATE Void rgDBMInitRachLst ARGS((RgCellCb *cellCb));
79 #ifdef LTEMAC_SPS
80 PRIVATE S16 rgDBMInitSpsUeCbLst ARGS((
81 RgCellCb       *cellCb,
82 U16            numBins
83 ));
84 #endif
85
86 /* local typedefs */
87  
88 /* local externs */
89  
90 /* forward references */
91
92 /**
93  * @brief Handler for Initializing the cell.
94  *
95  * @details
96  *
97  *     Function : rgDBMInitCell
98  *     
99  *   Initializes the lists belonging to the cell.
100  *     
101  *           
102  *  @param[in]  RgCellCb *cellCb
103  *  @return  S16
104  *      -# ROK 
105  *      -# RFAILED
106  **/
107 #ifdef ANSI
108 PUBLIC S16 rgDBMInitCell
109 (
110 RgCellCb       *cellCb
111 )
112 #else
113 PUBLIC S16 rgDBMInitCell(cellCb)
114 RgCellCb       *cellCb;
115 #endif
116 {
117    S16 ret;
118    
119    TRC2(rgDBMInitCell);
120
121    /* Initialize ue list */
122    if ((ret = rgDBMInitUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
123       RETVALUE(ret);
124
125 #ifdef LTEMAC_SPS
126    /* Initialize SPS Ue list */
127    if ((ret = rgDBMInitSpsUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
128       RETVALUE(ret);
129 #endif /* LTEMAC_SPS */
130
131    /* Initialize BCCH/PCCH logical channels */
132    rgDBMInitCmnLcLst(cellCb);
133
134
135    /* Initialize rach ue list */
136    rgDBMInitRachLst(cellCb);
137
138    RETVALUE(ret);
139
140 } /* rgDBMInitCell */
141
142 /**
143  * @brief Handler for initializing the ueCbLst under the cellCb.
144  *
145  * @details
146  *
147  *     Function : rgDBMInitUeCbLst
148  *     
149  *           
150  *  @param[in] *cellCb 
151  *  @param[in] numBins 
152  *  @return  S16
153  *      -# ROK 
154  *      -# RFAILED 
155  **/
156 #ifdef ANSI
157 PRIVATE S16 rgDBMInitUeCbLst
158 (
159 RgCellCb       *cellCb,
160 U16            numBins
161 )
162 #else
163 PRIVATE S16 rgDBMInitUeCbLst(cellCb, numBins)
164 RgCellCb       *cellCb;
165 U16            numBins;
166 #endif
167 {
168    Inst inst = cellCb->macInst - RG_INST_START;
169    RgUeCb ue;  
170    TRC2(rgDBMInitUeCbLst)
171
172    RETVALUE(cmHashListInit(&cellCb->ueLst, numBins, (U16)((PTR)&(ue.ueLstEnt) - (PTR)&ue), FALSE, 
173                CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
174
175 }  /* rgDBMInitUeCbLst */
176
177 /**
178  * @brief Handler for de-initializing the ueCbLst under the cellCb.
179  *
180  * @details
181  *
182  *     Function : rgDBMDeInitUeCbLst
183  *     
184  *           
185  *  @param[in] *cellCb 
186  *  @return  S16
187  *      -# ROK 
188  *      -# RFAILED 
189  **/
190 #ifdef ANSI
191 PUBLIC S16 rgDBMDeInitUeCbLst
192 (
193 RgCellCb       *cellCb
194 )
195 #else
196 PUBLIC S16 rgDBMDeInitUeCbLst(cellCb)
197 RgCellCb       *cellCb;
198 #endif
199 {
200    TRC2(rgDBMDeInitUeCbLst)
201
202    RETVALUE(cmHashListDeinit(&cellCb->ueLst));
203
204 }  /* rgDBMDeInitUeCbLst */
205
206 #ifdef LTEMAC_SPS
207 /**
208  * @brief Handler for initializing the spsUeCbLst under the cellCb.
209  *
210  * @details
211  *
212  *     Function : rgDBMInitSpsUeCbLst
213  *     
214  *           
215  *  @param[in] *cellCb 
216  *  @param[in] numBins 
217  *  @return  S16
218  *      -# ROK 
219  *      -# RFAILED 
220  **/
221 #ifdef ANSI
222 PRIVATE S16 rgDBMInitSpsUeCbLst
223 (
224 RgCellCb       *cellCb,
225 U16            numBins
226 )
227 #else
228 PRIVATE S16 rgDBMInitSpsUeCbLst(cellCb, numBins)
229 RgCellCb       *cellCb;
230 U16            numBins;
231 #endif
232 {
233    Inst inst = cellCb->macInst - RG_INST_START;
234    RgUeCb ue;
235    TRC2(rgDBMInitSpsUeCbLst)
236
237    RETVALUE(cmHashListInit(&cellCb->spsUeLst, numBins, (U16) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE, 
238                CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
239
240 }  /* rgDBMInitSpsUeCbLst */
241
242 /**
243  * @brief Handler for de-initializing the spsUeCbLst under the cellCb.
244  *
245  * @details
246  *
247  *     Function : rgDBMDeInitSpsUeCbLst
248  *     
249  *           
250  *  @param[in] *cellCb 
251  *  @return  S16
252  *      -# ROK 
253  *      -# RFAILED 
254  **/
255 #ifdef ANSI
256 PUBLIC S16 rgDBMDeInitSpsUeCbLst
257 (
258 RgCellCb       *cellCb
259 )
260 #else
261 PUBLIC S16 rgDBMDeInitSpsUeCbLst(cellCb)
262 RgCellCb       *cellCb;
263 #endif
264 {
265    TRC2(rgDBMDeInitSpsUeCbLst)
266
267    RETVALUE(cmHashListDeinit(&cellCb->spsUeLst));
268
269 }  /* rgDBMDeInitSpsUeCbLst */
270
271 #endif /* LTEMAC_SPS */
272
273 /**
274  * @brief Handler for inserting the ueCb in to the ueCbLst under the cellCb.
275  *
276  * @details
277  *
278  *     Function : rgDBMInsUeCb
279  *     
280  *           
281  *  @param[in] *cellCb 
282  *  @param[in] *ueCb 
283  *  @return  S16
284  *      -# ROK 
285  *      -# RFAILED 
286  **/
287 #ifdef ANSI
288 PUBLIC S16 rgDBMInsUeCb
289 (
290 RgCellCb       *cellCb,
291 RgUeCb         *ueCb
292 )
293 #else
294 PUBLIC S16 rgDBMInsUeCb(cellCb, ueCb)
295 RgCellCb       *cellCb;
296 RgUeCb         *ueCb;
297 #endif
298 {
299    TRC2(rgDBMInsUeCb)
300
301    RETVALUE(cmHashListInsert(&cellCb->ueLst, (PTR)ueCb, 
302       (U8 *)&ueCb->ueId, (U16)sizeof(ueCb->ueId)));
303
304 }  /* rgDBMInsUeCb */
305
306 #ifdef LTEMAC_SPS
307 /**
308  * @brief Handler for inserting the ueCb in to the spsUeCbLst under the cellCb.
309  *
310  * @details
311  *
312  *     Function : rgDBMInsSpsUeCb
313  *     
314  *           
315  *  @param[in] *cellCb 
316  *  @param[in] *ueCb 
317  *  @return  S16
318  *      -# ROK 
319  *      -# RFAILED 
320  **/
321 #ifdef ANSI
322 PUBLIC S16 rgDBMInsSpsUeCb
323 (
324 RgCellCb       *cellCb,
325 RgUeCb         *ueCb
326 )
327 #else
328 PUBLIC S16 rgDBMInsSpsUeCb(cellCb, ueCb)
329 RgCellCb       *cellCb;
330 RgUeCb         *ueCb;
331 #endif
332 {
333    TRC2(rgDBMInsSpsUeCb)
334
335    RETVALUE(cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb, 
336       (U8 *)&ueCb->spsRnti, (U16)sizeof(ueCb->spsRnti)));
337
338 }  /* end of rgDBMInsSpsUeCb */
339
340 #endif /* LTEMAC_SPS */
341
342 /**
343  * @brief Handler for accessing the existing ueCb identified by the key ueId
344  * in the ueCbLst under the cellCb.
345  *
346  * @details
347  *
348  *     Function : rgDBMGetUeCb
349  *     
350  *           
351  *  @param[in]  *cellCb
352  *  @param[in]  ueId
353  *  @return  RgUeCb*
354  **/
355 #ifdef ANSI
356 PUBLIC RgUeCb* rgDBMGetUeCb
357 (
358 RgCellCb       *cellCb, 
359 CmLteRnti      ueId
360 )
361 #else
362 PUBLIC RgUeCb* rgDBMGetUeCb(cellCb, ueId)
363 RgCellCb       *cellCb;
364 CmLteRnti      ueId;
365 #endif
366 {
367    RgUeCb *ueCb = NULLP; 
368
369    TRC2(rgDBMGetUeCb)
370
371    cmHashListFind(&cellCb->ueLst, (U8 *)&ueId,
372       sizeof(ueId), 0, (PTR *)&ueCb);
373    RETVALUE(ueCb);
374 }  /* rgDBMGetUeCb */
375
376 #ifdef LTEMAC_SPS
377 /**
378  * @brief Handler for accessing the ueCb identified by the key sps-rnti
379  * in the spsUeLst under the cellCb.
380  *
381  * @details
382  *
383  *     Function : rgDBMGetSpsUeCb
384  *     
385  *           
386  *  @param[in]  *cellCb
387  *  @param[in]  ueId
388  *  @return  RgUeCb*
389  **/
390 #ifdef ANSI
391 PUBLIC RgUeCb* rgDBMGetSpsUeCb
392 (
393 RgCellCb       *cellCb, 
394 CmLteRnti      spsRnti
395 )
396 #else
397 PUBLIC RgUeCb* rgDBMGetSpsUeCb(cellCb, spsRnti)
398 RgCellCb       *cellCb;
399 CmLteRnti      spsRnti;
400 #endif
401 {
402    RgUeCb *ueCb = NULLP; 
403
404    TRC2(rgDBMGetSpsUeCb)
405
406    cmHashListFind(&cellCb->spsUeLst, (U8 *)&spsRnti,
407       sizeof(spsRnti), 0, (PTR *)&ueCb);
408    RETVALUE(ueCb);
409 }  /* rgDBMGetSpsUeCb */
410
411 #endif /* LTEMAC_SPS */
412
413 /**
414  * @brief Handler for accessing the existing next ueCb in the ueCbLst under the
415  *  cellCb.
416  *
417  * @details
418  *
419  *     Function : rgDBMGetNextUeCb
420  *     
421  *           
422  *  @param[in]  *cellCb
423  *  @param[in]  *ueCb
424  *  @return  RgUeCb*
425  **/
426 #ifdef ANSI
427 PUBLIC RgUeCb* rgDBMGetNextUeCb
428 (
429 RgCellCb       *cellCb, 
430 RgUeCb         *ueCb
431 )
432 #else
433 PUBLIC RgUeCb* rgDBMGetNextUeCb(cellCb, ueCb)
434 RgCellCb       *cellCb;
435 RgUeCb         *ueCb;
436 #endif
437 {
438    RgUeCb *nextUeCb = NULLP; 
439
440    TRC2(rgDBMGetNextUeCb)
441
442    cmHashListGetNext(&cellCb->ueLst, (PTR) ueCb, (PTR *)&nextUeCb);
443    RETVALUE(nextUeCb);
444 }  /* rgDBMGetNextUeCb */
445
446 #ifdef LTEMAC_SPS
447 /**
448  * @brief Handler for accessing the existing next ueCb stored in the spsUeCbLst
449  *         using SPS-Rnti under the cellCb.
450  *
451  * @details
452  *
453  *     Function : rgDBMGetNextSpsUeCb
454  *     
455  *           
456  *  @param[in]  *cellCb
457  *  @param[in]  *ueCb
458  *  @return  RgUeCb*
459  **/
460 #ifdef ANSI
461 PUBLIC RgUeCb* rgDBMGetNextSpsUeCb
462 (
463 RgCellCb       *cellCb, 
464 RgUeCb         *ueCb
465 )
466 #else
467 PUBLIC RgUeCb* rgDBMGetNextSpsUeCb(cellCb, ueCb)
468 RgCellCb       *cellCb;
469 RgUeCb         *ueCb;
470 #endif
471 {
472    RgUeCb *nextUeCb = NULLP; 
473
474    TRC2(rgDBMGetNextSpsUeCb)
475
476    cmHashListGetNext(&cellCb->spsUeLst, (PTR) ueCb, (PTR *)&nextUeCb);
477    RETVALUE(nextUeCb);
478 }  /* end of rgDBMGetNextSpsUeCb */
479
480 #endif /* LTEMAC_SPS */
481
482
483 /**
484  * @brief Handler for deleting the existing ueCb from the ueCbLst under the
485  * cellCb.
486  *
487  * @details
488  *
489  *     Function : rgDBMDelUeCb
490  *     
491  *           
492  *  @param[in]  *cellCb 
493  *  @param[in]  *ueCb 
494  *  @return  S16
495  *      -# ROK 
496  *      -# RFAILED 
497  **/
498 #ifdef ANSI
499 PUBLIC S16 rgDBMDelUeCb
500 (
501 RgCellCb       *cellCb,
502 RgUeCb         *ueCb
503 )
504 #else
505 PUBLIC S16 rgDBMDelUeCb(cellCb, ueCb)
506 RgCellCb       *cellCb;
507 RgUeCb         *ueCb;
508 #endif
509 {
510    TRC2(rgDBMDelUeCb)
511
512    RETVALUE(cmHashListDelete(&cellCb->ueLst, (PTR)ueCb));
513 }  /* rgDBMDelUeCb */
514
515 #ifdef LTEMAC_SPS
516 /**
517  * @brief Handler for deleting the existing ueCb from the spsUeCbLst under the
518  * cellCb.
519  *
520  * @details
521  *
522  *     Function : rgDBMDelSpsUeCb
523  *     
524  *           
525  *  @param[in]  *cellCb 
526  *  @param[in]  *ueCb 
527  *  @return  S16
528  *      -# ROK 
529  *      -# RFAILED 
530  **/
531 #ifdef ANSI
532 PUBLIC S16 rgDBMDelSpsUeCb
533 (
534 RgCellCb       *cellCb,
535 RgUeCb         *ueCb
536 )
537 #else
538 PUBLIC S16 rgDBMDelSpsUeCb(cellCb, ueCb)
539 RgCellCb       *cellCb;
540 RgUeCb         *ueCb;
541 #endif
542 {
543    TRC2(rgDBMDelSpsUeCb)
544
545    RETVALUE(cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
546 }  /* end of rgDBMDelSpsUeCb */
547
548 #endif /* LTEMAC_SPS */
549
550 /**
551  * @brief Handler for Initializing the UE.
552  *
553  * @details
554  *
555  *     Function : rgDBMInitUe
556  *     
557  *   Initializes the lists belonging to the UE.
558  *     
559  *           
560  *  @param[in]  RgUeCb  *ueCb
561  *  @return  S16
562  *      -# ROK 
563  *      -# RFAILED
564  **/
565 #ifdef ANSI
566 PUBLIC Void rgDBMInitUe
567 (
568 RgUeCb       *ueCb
569 )
570 #else
571 PUBLIC Void rgDBMInitUe(ueCb)
572 RgUeCb       *ueCb;
573 #endif
574 {
575 #ifdef LTEMAC_SPS
576    U8        idx;
577 #endif
578
579    TRC2(rgDBMInitUe);
580
581    /* Initialize Dedicated logical channels */
582    rgDBMInitDedLcLst(ueCb);
583
584 #ifdef LTEMAC_SPS
585    /* Initialize the SPS LC Ids */
586    for (idx=0; idx < RG_MAX_LC_PER_UE; idx++)
587    {
588       ueCb->ul.spsLcId[idx] = FALSE;
589    }
590 #endif
591
592
593    RETVOID;
594 } /* rgDBMInitUe */
595
596 /**
597  * @brief Handler for Initializing the dedicated logical channels.
598  *
599  * @details
600  *
601  *     Function : rgDBMInitDedLcLst
602  *     
603  *   Initializes dedicated logical channels.
604  *           
605  *  @param[in]  RgUeCb *ueCb
606  *  @return     Void 
607  **/
608 #ifdef ANSI
609 PRIVATE Void rgDBMInitDedLcLst
610 (
611 RgUeCb       *ueCb
612 )
613 #else
614 PRIVATE Void rgDBMInitDedLcLst(ueCb)
615 RgUeCb       *ueCb;
616 #endif
617 {
618    U8 idx;
619    
620    TRC2(rgDBMInitDedLcLst);
621
622    for (idx = 0; idx < RG_MAX_LC_PER_UE; ++idx)
623    {
624       /* Set Dedicated LCs as not configured */
625       ueCb->ul.lcCb[idx].lcId = RG_INVALID_LC_ID;
626       ueCb->ul.lcCb[idx].lcgId = RG_INVALID_LCG_ID;
627       ueCb->dl.lcCb[idx].lcId = RG_INVALID_LC_ID;
628    }
629
630    for (idx = 0; idx < RG_MAX_LCG_PER_UE; ++idx)
631    {
632       /* Set LCGs as not configured */
633       ueCb->ul.lcgArr[idx].lcgId = RG_INVALID_LCG_ID;
634       ueCb->ul.lcgArr[idx].lcCount = 0;
635    }
636
637    /* Stack Crash problem for TRACE5 Changes. Added the return below */
638   RETVOID;
639 } /* rgDBMInitDedLcLst */
640
641 /**
642  * @brief Handler for Initializing the common logical channel list of the cell.
643  *
644  * @details
645  *
646  *     Function : rgDBMInitCmnLcLst
647  *     
648  *   Initializes following common logical channels belonging to the cell.
649  *     - BCCH on BCH
650  *     - BCCH on DLSCH
651  *     - PCCH
652  *           
653  *  @param[in]  RgCellCb *cellCb
654  *  @return  Void
655  **/
656 #ifdef ANSI
657 PRIVATE Void rgDBMInitCmnLcLst
658 (
659 RgCellCb       *cellCb
660 )
661 #else
662 PRIVATE Void rgDBMInitCmnLcLst(cellCb)
663 RgCellCb       *cellCb;
664 #endif
665 {
666    U8 idx;
667    
668    TRC2(rgDBMInitCmnLcLst);
669    
670    cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
671    cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
672
673    cellCb->numBcchDlschInfo = 0;
674    for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
675    {
676       cellCb->bcchDlschInfo[idx].lcId = RG_INVALID_LC_ID;
677       cellCb->bcchDlschInfo[idx].tb = NULLP;
678    }
679
680    /* Stack Crash problem for TRACE5 Changes. Added the return below */
681   RETVOID;
682 } /* rgDBMInitCmnLcLst */
683
684 /**
685  * @brief Handler for Initializing the common logical channel list of the cell.
686  *
687  * @details
688  *
689  *     Function : rgDBMFreeCmnLcLst
690  *     
691  *   Initializes following common logical channels belonging to the cell.
692  *     - BCCH on BCH
693  *     - BCCH on DLSCH
694  *     - PCCH
695  *           
696  *  @param[in]  RgCellCb *cellCb
697  *  @return  Void
698  **/
699 #ifdef ANSI
700 PUBLIC Void rgDBMFreeCmnLcLst
701 (
702 RgCellCb       *cellCb
703 )
704 #else
705 PUBLIC Void rgDBMFreeCmnLcLst(cellCb)
706 RgCellCb       *cellCb;
707 #endif
708 {
709    U8 idx;
710    
711    TRC2(rgDBMFreeCmnLcLst);
712    
713    cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
714    cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
715
716    for (idx = 0; idx < cellCb->numBcchDlschInfo; idx++)
717    {
718       cellCb->bcchDlschInfo[idx].lcId = RG_INVALID_LC_ID;
719       RG_FREE_MSG(cellCb->bcchDlschInfo[idx].tb);
720    }
721    cellCb->numBcchDlschInfo = 0;
722
723    /* Stack Crash problem for TRACE5 Changes. Added the return below */
724   RETVOID;
725 } /* rgDBMFreeCmnLcLst */
726
727 /**
728  * @brief Handler for inserting dedicated DL logical channel.
729  *
730  * @details
731  *
732  *     Function : rgDBMInsDlDedLcCb
733  *     
734  *  @param[in]  RgUeCb *ueCb
735  *  @param[in]  RgDlLcCb* dlLcCb
736  *  @return  Void
737  **/
738 #ifdef ANSI
739 PUBLIC Void rgDBMInsDlDedLcCb
740 (
741 RgUeCb         *ueCb, 
742 CmLteLcId        idx
743 )
744 #else
745 PUBLIC Void rgDBMInsDlDedLcCb(ueCb, idx)
746 RgUeCb         *ueCb; 
747 CmLteLcId        idx;
748 #endif
749 {
750    TRC2(rgDBMInsDlDedLcCb);
751    if( idx >= RG_DEDLC_MIN_LCID )
752    {
753       ueCb->dl.lcCb[idx-1].lcId = idx;
754    }
755   /* Stack Crash problem for TRACE5 Changes. Added the return below */
756   RETVOID;
757 }  /* rgDBMInsDlDedLcCb */
758
759 /**
760  * @brief Handler for deleting dedicated DL logical channel.
761  *
762  * @details
763  *
764  *     Function : rgDBMDelDlDedLcCb
765  *     
766  *  @param[in]  RgUeCb *ueCb
767  *  @param[in]  RgDlLcCb* dlLcCb
768  *  @return  Void
769  **/
770 #ifdef ANSI
771 PUBLIC Void rgDBMDelDlDedLcCb
772 (
773 RgUeCb         *ueCb, 
774 RgDlLcCb       *dlLcCb 
775 )
776 #else
777 PUBLIC Void rgDBMDelDlDedLcCb(ueCb, dlLcCb)
778 RgUeCb         *ueCb; 
779 RgDlLcCb       *dlLcCb; 
780 #endif
781 {
782    TRC2(rgDBMDelDlDedLcCb);
783
784    ueCb->dl.lcCb[dlLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
785
786   /* Stack Crash problem for TRACE5 Changes. Added the return below */
787   RETVOID;
788   
789 }  /* rgDBMDelDlDedLcCb */
790
791 /**
792  * @brief Handler for accessing the existing DL dedicated lcCb at idx in the 
793  * lcCbLst of the ueCb.
794  *
795  * @details
796  *
797  *     Function : rgDBMGetDlDedLcCb
798  *     
799  *  @param[in]  *ueCb
800  *  @param[in]  idx
801  *  @return  RgDlLcCb*
802  **/
803 #ifdef ANSI
804 PUBLIC RgDlLcCb* rgDBMGetDlDedLcCb
805 (
806 RgUeCb         *ueCb, 
807 CmLteLcId        idx
808 )
809 #else
810 PUBLIC RgDlLcCb* rgDBMGetDlDedLcCb(ueCb, idx)
811 RgUeCb         *ueCb; 
812 CmLteLcId        idx;
813 #endif
814 {
815    TRC2(rgDBMGetDlDedLcCb);
816
817    if (idx > RG_DEDLC_MAX_LCID || idx <= 0)
818    {
819       RETVALUE(NULLP);
820    }
821    if(ueCb->dl.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
822    {
823       RETVALUE(NULLP);
824    }
825
826    RETVALUE(&ueCb->dl.lcCb[idx-1]);
827
828 }  /* rgDBMGetDlDedLcCb */
829
830 /**
831  * @brief Handler for inserting dedicated UL logical channel.
832  *
833  * @details
834  *
835  *     Function : rgDBMInsUlDedLcCb
836  *     
837  *           
838  *  @param[in]  RgUeCb *ueCb
839  *  @param[in]  CmLteLcId idx
840  *  @param[in]  LteLcgId gId
841  *  @return  Void
842  **/
843 #ifdef LTE_L2_MEAS
844 #ifdef ANSI
845 PUBLIC Void rgDBMInsUlDedLcCb
846 (
847 RgUeCb         *ueCb, 
848 CmLteLcId      idx,
849 LteLcgId       gId,
850 U8             qci
851 )
852 #else
853 PUBLIC Void rgDBMInsUlDedLcCb(ueCb, idx, gId, qci)
854 RgUeCb         *ueCb; 
855 CmLteLcId      idx;
856 LteLcgId       gId;
857 U8             qci;
858 #endif
859 #else
860 #ifdef ANSI
861 PUBLIC Void rgDBMInsUlDedLcCb
862 (
863 RgUeCb         *ueCb, 
864 CmLteLcId      idx,
865 LteLcgId       gId
866 )
867 #else
868 PUBLIC Void rgDBMInsUlDedLcCb(ueCb, idx, gId)
869 RgUeCb         *ueCb; 
870 CmLteLcId      idx;
871 LteLcgId       gId;
872 #endif
873 #endif
874 {
875    TRC2(rgDBMInsUlDedLcCb);
876    if ( idx >= RG_DEDLC_MIN_LCID)
877    {
878       ueCb->ul.lcCb[idx - 1].lcId = idx;
879       ueCb->ul.lcCb[idx - 1].lcgId = gId;
880 #ifdef LTE_L2_MEAS
881       ueCb->ul.lcCb[idx - 1].qci = qci;
882 #endif
883    }
884    if(ueCb->ul.lcgArr[gId].lcgId == RG_INVALID_LCG_ID)
885    {
886       ueCb->ul.lcgArr[gId].lcgId = gId;
887    }
888    ueCb->ul.lcgArr[gId].lcCount = ueCb->ul.lcgArr[gId].lcCount + 1;
889
890
891   /* Stack Crash problem for TRACE5 Changes. Added the return below */
892   RETVOID;
893
894 }  /* rgDBMInsUlDedLcCb */
895
896 /**
897  * @brief Handler for deleting the dedicated UL logical channel.
898  *
899  * @details
900  *
901  *     Function : rgDBMUpdUlDedLcCb
902  *     
903  *           
904  *  @param[in]  RgUeCb *ueCb
905  *  @param[in]  RgUlLcCb* ulLcCb
906  *  @param[in]  LteLcgId gId
907  *  @return  Void
908  **/
909 #ifdef ANSI
910 PUBLIC Void rgDBMUpdUlDedLcCb
911 (
912 RgUeCb         *ueCb, 
913 RgUlLcCb       *ulLcCb,
914 LteLcgId       gId
915 )
916 #else
917 PUBLIC Void rgDBMUpdUlDedLcCb(ueCb, ulLcCb, gId)
918 RgUeCb         *ueCb; 
919 RgUlLcCb       *ulLcCb; 
920 LteLcgId       gId;
921 #endif
922 {
923    TRC2(rgDBMUpdUlDedLcCb);
924
925    ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount = 
926                ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
927    if(ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount == 0)
928    {
929       ueCb->ul.lcgArr[ulLcCb->lcgId].lcgId = RG_INVALID_LCG_ID;
930    }
931    ueCb->ul.lcCb[ulLcCb->lcId - 1].lcgId = gId;
932
933    if(ueCb->ul.lcgArr[gId].lcgId == RG_INVALID_LCG_ID)
934    {
935       ueCb->ul.lcgArr[gId].lcgId = gId;
936    }
937    ueCb->ul.lcgArr[gId].lcCount = ueCb->ul.lcgArr[gId].lcCount + 1;
938
939   /* Stack Crash problem for TRACE5 Changes. Added the return below */
940   RETVOID;
941 }  /* rgDBMUpdUlDedLcCb */
942
943 /**
944  * @brief Handler for updating the dedicated UL logical channel.
945  *
946  * @details
947  *
948  *     Function : rgDBMDelUlDedLcCb
949  *     
950  *           
951  *  @param[in]  RgUeCb *ueCb
952  *  @param[in]  RgUlLcCb* ulLcCb
953  *  @return  Void
954  **/
955 #ifdef ANSI
956 PUBLIC Void rgDBMDelUlDedLcCb
957 (
958 RgUeCb         *ueCb, 
959 RgUlLcCb       *ulLcCb 
960 )
961 #else
962 PUBLIC Void rgDBMDelUlDedLcCb(ueCb, ulLcCb)
963 RgUeCb         *ueCb; 
964 RgUlLcCb       *ulLcCb; 
965 #endif
966 {
967    TRC2(rgDBMDelUlDedLcCb);
968
969    ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount = 
970                ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
971    if(ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount == 0)
972    {
973       ueCb->ul.lcgArr[ulLcCb->lcgId].lcgId = RG_INVALID_LCG_ID;
974    }
975    ueCb->ul.lcCb[ulLcCb->lcId - 1].lcgId = RG_INVALID_LCG_ID;
976    ueCb->ul.lcCb[ulLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
977
978   /* Stack Crash problem for TRACE5 Changes. Added the return below */
979   RETVOID;
980 }  /* rgDBMDelUlDedLcCb */
981
982 /**
983  * @brief Handler for accessing the existing UL dedicated lcCb at idx in the
984  * lcCbLst of the ueCb.
985  *
986  * @details
987  *
988  *     Function : rgDBMGetUlDedLcCb
989  *     
990  *           
991  *  @param[in]  *ueCb
992  *  @param[in]  idx
993  *  @return  RgUlLcCb*
994  **/
995 #ifdef ANSI
996 PUBLIC RgUlLcCb* rgDBMGetUlDedLcCb
997 (
998 RgUeCb         *ueCb, 
999 CmLteLcId        idx
1000 )
1001 #else
1002 PUBLIC RgUlLcCb* rgDBMGetUlDedLcCb(ueCb, idx)
1003 RgUeCb         *ueCb; 
1004 CmLteLcId        idx;
1005 #endif
1006 {
1007    TRC2(rgDBMGetUlDedLcCb)
1008
1009    if (idx > RG_DEDLC_MAX_LCID || idx < RG_DEDLC_MIN_LCID)
1010    {
1011       RETVALUE(NULLP);
1012    }
1013    if(ueCb->ul.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
1014    {
1015       RETVALUE(NULLP);
1016    }
1017
1018    RETVALUE(&ueCb->ul.lcCb[idx-1]);
1019 }  /* rgDBMGetDlDedLcCb */
1020
1021 /**
1022  * @brief Handler for accessing the existing DL common lcCb identified by the key lcId
1023  * in the lcCbLst of the ueCb.
1024  *
1025  * @details
1026  *
1027  *     Function : rgDBMChkCmnLcCb
1028  *     
1029  *           
1030  *  @param[in]  *cellCb
1031  *  @param[in]  lcId
1032  *  @return  S16
1033  *      -# ROK
1034  *      -# RFAILED
1035  **/
1036 #ifdef ANSI
1037 PUBLIC S16 rgDBMChkCmnLcCb
1038 (
1039 RgCellCb       *cellCb, 
1040 CmLteLcId        lcId
1041 )
1042 #else
1043 PUBLIC S16 rgDBMChkCmnLcCb(cellCb, lcId)
1044 RgCellCb       *cellCb;
1045 CmLteLcId        lcId;
1046 #endif
1047 {
1048    U8 idx;
1049
1050    TRC2(rgDBMChkCmnLcCb)
1051
1052    if(cellCb->bcchBchInfo.lcId == lcId)
1053    {
1054       RETVALUE(ROK);
1055    } 
1056    if(cellCb->pcchInfo.lcId == lcId)
1057    {
1058       RETVALUE(ROK);
1059    }
1060
1061    for (idx = 0; idx < cellCb->numBcchDlschInfo; idx++)
1062    {
1063       if(cellCb->bcchDlschInfo[idx].lcId == lcId)
1064       {
1065          RETVALUE(ROK);
1066       } 
1067    }
1068    RETVALUE(RFAILED);
1069 }  /* rgDBMChkCmnLcCb */
1070
1071 /**
1072  * @brief Handler for accessing the existing BCCH mapped on to BCH in the 
1073  * lcCbLst of the ueCb.
1074  *
1075  * @details
1076  *
1077  *     Function : rgDBMGetBcchOnBch
1078  *     
1079  *           
1080  *  @param[in]  *cellCb
1081  *  @return  RgBcchBchLcCb*
1082  **/
1083 #ifdef ANSI
1084 PUBLIC RgBcchBchLcCb* rgDBMGetBcchOnBch
1085 (
1086 RgCellCb       *cellCb 
1087 )
1088 #else
1089 PUBLIC RgBcchBchLcCb* rgDBMGetBcchOnBch(cellCb)
1090 RgCellCb       *cellCb;
1091 #endif
1092 {
1093    TRC2(rgDBMGetBcchOnBch)
1094
1095    if(cellCb->bcchBchInfo.lcId != RG_INVALID_LC_ID)
1096    {
1097       RETVALUE(&(cellCb->bcchBchInfo));
1098    }
1099    RETVALUE(NULLP);
1100 }  /* rgDBMGetBcchOnBch */
1101
1102 /**
1103  * @brief Handler for accessing the existing BCCH mapped on to DLSCH in the 
1104  * lcCbLst of the ueCb.
1105  *
1106  * @details
1107  *
1108  *     Function : rgDBMGetBcchOnDlsch
1109  *     
1110  *           
1111  *  @param[in]  *cellCb
1112  *  @param[in]  lcId
1113  *  @return  RgBcchDlschLcCb*
1114  **/
1115 #ifdef ANSI
1116 PUBLIC RgBcchDlschLcCb* rgDBMGetBcchOnDlsch
1117 (
1118 RgCellCb       *cellCb,
1119 CmLteLcId      lcId
1120 )
1121 #else
1122 PUBLIC RgBcchDlschLcCb* rgDBMGetBcchOnDlsch(cellCb,lcId)
1123 RgCellCb       *cellCb;
1124 CmLteLcId      lcId;
1125 #endif
1126 {
1127    U8 idx;
1128
1129    TRC2(rgDBMGetBcchOnDlsch)
1130
1131    for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
1132    {
1133       if(cellCb->bcchDlschInfo[idx].lcId == lcId)
1134       {
1135          RETVALUE(&(cellCb->bcchDlschInfo[idx]));
1136       }
1137    }
1138    RETVALUE(NULLP);
1139 }  /* rgDBMGetBcchOnDlsch */
1140
1141 /**
1142  * @brief Handler for accessing the existing PCCH in the lcCbLst of the ueCb.
1143  *
1144  * @details
1145  *
1146  *     Function : rgDBMGetPcch
1147  *     
1148  *           
1149  *  @param[in]  *cellCb
1150  *  @return  RgPcchLcCb*
1151  **/
1152 #ifdef ANSI
1153 PUBLIC RgPcchLcCb* rgDBMGetPcch
1154 (
1155 RgCellCb       *cellCb
1156 )
1157 #else
1158 PUBLIC RgPcchLcCb* rgDBMGetPcch(cellCb)
1159 RgCellCb       *cellCb;
1160 #endif
1161 {
1162    TRC2(rgDBMGetPcch)
1163  
1164    if(cellCb->pcchInfo.lcId != RG_INVALID_LC_ID)
1165    {
1166       RETVALUE(&(cellCb->pcchInfo));
1167    }
1168    RETVALUE(NULLP);
1169 }  /* rgDBMGetPcch */
1170
1171 /**
1172  * @brief Handler for inserting the BCCH mapped on to BCH in the 
1173  * lcCbLst of the ueCb.
1174  *
1175  * @details
1176  *
1177  *     Function : rgDBMInsBcchOnBch
1178  *     
1179  *           
1180  *  @param[in]  *cellCb
1181  *  @return  Void
1182  **/
1183 #ifdef ANSI
1184 PUBLIC Void rgDBMInsBcchOnBch
1185 (
1186 RgCellCb       *cellCb, 
1187 CmLteLcId      idx
1188 )
1189 #else
1190 PUBLIC Void rgDBMInsBcchOnBch(cellCb, idx)
1191 RgCellCb       *cellCb;
1192 CmLteLcId      idx;
1193 #endif
1194 {
1195    TRC2(rgDBMInsBcchOnBch)
1196
1197    cellCb->bcchBchInfo.lcId = idx;
1198
1199   /* Stack Crash problem for TRACE5 Changes. Added the return below */
1200   RETVOID;
1201 }  /* rgDBMInsBcchOnBch */
1202
1203 /**
1204  * @brief Handler for inserting the BCCH mapped on to DLSCH in the 
1205  * lcCbLst of the ueCb.
1206  *
1207  * @details
1208  *
1209  *     Function : rgDBMInsBcchOnDlsch
1210  *     
1211  *           
1212  *  @param[in]  *cellCb
1213  *  @return  Void
1214  **/
1215 #ifdef ANSI
1216 PUBLIC Void rgDBMInsBcchOnDlsch
1217 (
1218 RgCellCb       *cellCb, 
1219 CmLteLcId      idx
1220 )
1221 #else
1222 PUBLIC Void rgDBMInsBcchOnDlsch(cellCb, idx)
1223 RgCellCb       *cellCb;
1224 CmLteLcId      idx;
1225 #endif
1226 {
1227    TRC2(rgDBMInsBcchOnDlsch)
1228
1229    cellCb->bcchDlschInfo[cellCb->numBcchDlschInfo].lcId = idx;
1230    cellCb->numBcchDlschInfo++;
1231
1232   /* Stack Crash problem for TRACE5 Changes. Added the return below */
1233   RETVOID;
1234 }  /* rgDBMInsBcchOnDlsch */
1235
1236
1237 /**
1238  * @brief Handler for inserting the PCCH in the lcCbLst of the ueCb.
1239  *
1240  * @details
1241  *
1242  *     Function : rgDBMInsPcch
1243  *     
1244  *           
1245  *  @param[in]  *cellCb
1246  *  @return  Void
1247  **/
1248 #ifdef ANSI
1249 PUBLIC Void rgDBMInsPcch
1250 (
1251 RgCellCb       *cellCb, 
1252 CmLteLcId      idx
1253 )
1254 #else
1255 PUBLIC Void rgDBMInsPcch(cellCb, idx)
1256 RgCellCb       *cellCb;
1257 CmLteLcId      idx;
1258 #endif
1259 {
1260    TRC2(rgDBMInsPcch)
1261
1262    cellCb->pcchInfo.lcId = idx;
1263
1264   /* Stack Crash problem for TRACE5 Changes. Added the return below */
1265   RETVOID;
1266 }  /* rgDBMInsPcch */
1267
1268 /**
1269  * @brief Handler for initializing the rachLst
1270  *
1271  * @details
1272  *
1273  *     Function : rgDBMInitRachLst
1274  *     
1275  *           
1276  *  @param[in] *cellCb 
1277  *  @return  Void
1278  **/
1279 #ifdef ANSI
1280 PRIVATE Void rgDBMInitRachLst
1281 (
1282 RgCellCb       *cellCb
1283 )
1284 #else
1285 PRIVATE Void rgDBMInitRachLst(cellCb)
1286 RgCellCb       *cellCb;
1287 #endif
1288 {
1289    TRC2(rgDBMInitRachLst)
1290
1291    cmLListInit(&cellCb->raInfo.ueRachLst);
1292    RETVOID;
1293 }  /* rgDBMInitRachLst */
1294
1295 /**
1296  * @brief Handler for inserting the ueCb in the rachLst.
1297  *
1298  * @details
1299  *
1300  *     Function : rgDBMInsUeCbInRachLst
1301  *     
1302  *           
1303  *  @param[in]  *cellCb
1304  *  @param[in]  *ueCb
1305  *  @return  Void
1306  **/
1307 #ifdef ANSI
1308 PUBLIC Void rgDBMInsUeCbInRachLst
1309 (
1310 RgCellCb       *cellCb, 
1311 RgUeCb         *ueCb
1312 )
1313 #else
1314 PUBLIC Void rgDBMInsUeCbInRachLst(cellCb, ueCb)
1315 RgCellCb       *cellCb; 
1316 RgUeCb         *ueCb;
1317 #endif
1318 {
1319    TRC2(rgDBMInsUeCbInRachLst)
1320
1321    cmLListAdd2Tail(&cellCb->raInfo.ueRachLst,&ueCb->rachLstEnt);
1322
1323    RETVOID;
1324 }  /* rgDBMInsUeCbInRachLst */
1325
1326 /**
1327  * @brief Handler for accessing the existing raCb in the rachLst.
1328  *
1329  * @details
1330  *
1331  *     Function : rgDBMGetUeCbFromRachLst
1332  *     
1333  *           
1334  *  @param[in]  *cellCb
1335  *  @param[in]  key
1336  *  @return  RgUeCb*
1337  **/
1338 #ifdef ANSI
1339 PUBLIC RgUeCb* rgDBMGetUeCbFromRachLst
1340 (
1341 RgCellCb       *cellCb, 
1342 CmLteRnti      key
1343 )
1344 #else
1345 PUBLIC RgUeCb* rgDBMGetUeCbFromRachLst(cellCb, key)
1346 RgCellCb       *cellCb; 
1347 CmLteRnti      key;
1348 #endif
1349 {
1350    CmLList *tmpNode;
1351
1352    TRC2(rgDBMGetUeCbFromRachLst)
1353
1354    CM_LLIST_FIRST_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
1355    while(tmpNode)
1356    {
1357       if(((RgUeCb *)tmpNode->node)->ueId == key)
1358       {
1359          RETVALUE((RgUeCb *)(tmpNode->node));
1360       }
1361       CM_LLIST_NEXT_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
1362    }
1363    RETVALUE(NULLP);
1364 }  /* rgDBMGetUeCbFromRachLst */
1365
1366 /**
1367  * @brief Handler for accessing the existing ueCb from rachLst.
1368  *
1369  * @details
1370  *
1371  *     Function : rgDBMGetNextUeCbFromRachLst
1372  *     
1373  *           
1374  *  @param[in]  *cellCb
1375  *  @param[in]  *ueCb
1376  *  @return  RgUeCb*
1377  **/
1378 #ifdef ANSI
1379 PUBLIC RgUeCb* rgDBMGetNextUeCbFromRachLst
1380 (
1381 RgCellCb       *cellCb,
1382 RgUeCb         *ueCb
1383 )
1384 #else
1385 PUBLIC RgUeCb* rgDBMGetNextUeCbFromRachLst(cellCb, ueCb)
1386 RgCellCb       *cellCb; 
1387 RgUeCb         *ueCb;
1388 #endif
1389 {
1390    TRC2(rgDBMGetNextUeCbFromRachLst)
1391
1392    if(!ueCb)
1393    {
1394       RETVALUE( cellCb->raInfo.ueRachLst.first ? 
1395                (RgUeCb *)(cellCb->raInfo.ueRachLst.first->node) : NULLP );
1396    }
1397    RETVALUE( ueCb->rachLstEnt.next ? 
1398                (RgUeCb *)(ueCb->rachLstEnt.next->node) : NULLP );
1399 }  /* rgDBMGetNextUeCbFromRachLst */
1400
1401 /**
1402  * @brief Handler for deleting the existing ueCb in the rachLst.
1403  *
1404  * @details
1405  *
1406  *     Function : rgDBMDelUeCbFromRachLst
1407  *     
1408  *           
1409  *  @param[in]  *cellCb
1410  *  @param[in]  key
1411  *  @return  RgUeCb*
1412  **/
1413 #ifdef ANSI
1414 PUBLIC Void rgDBMDelUeCbFromRachLst
1415 (
1416 RgCellCb       *cellCb, 
1417 RgUeCb         *ueCb 
1418 )
1419 #else
1420 PUBLIC Void rgDBMDelUeCbFromRachLst(cellCb, ueCb)
1421 RgCellCb       *cellCb; 
1422 RgUeCb         *ueCb;
1423 #endif
1424 {
1425    TRC2(rgDBMDelUeCbFromRachLst)
1426
1427    cmLListDelFrm(&cellCb->raInfo.ueRachLst, &ueCb->rachLstEnt);
1428    RETVOID;
1429 }  /* rgDBMDelUeCbFromRachLst */
1430
1431 /**********************************************************************
1432  
1433          End of file
1434 **********************************************************************/