1 /*******************************************************************************
2 ################################################################################
3 # Copyright (c) [2017-2019] [Radisys] #
5 # Licensed under the Apache License, Version 2.0 (the "License"); #
6 # you may not use this file except in compliance with the License. #
7 # You may obtain a copy of the License at #
9 # http://www.apache.org/licenses/LICENSE-2.0 #
11 # Unless required by applicable law or agreed to in writing, software #
12 # distributed under the License is distributed on an "AS IS" BASIS, #
13 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
14 # See the License for the specific language governing permissions and #
15 # limitations under the License. #
16 ################################################################################
17 *******************************************************************************/
19 /************************************************************************
25 Desc: C source code for Entry point fucntions
29 **********************************************************************/
32 @brief This file contains the APIs exposed for the insertion/fetching/deletion of cellCb/ueCb and traversal of LcCbLst.
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 */
50 #include "rg_sch_inf.h"
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 */
68 #include "rg_sch_inf.x"
69 #include "rg_prg.x" /* PRG interface typedefs*/
74 PRIVATE S16 rgDBMInitUeCbLst ARGS(( RgCellCb *cellCb, U16 numBins));
75 PRIVATE Void rgDBMInitDedLcLst ARGS((RgUeCb *ueCb));
76 PRIVATE Void rgDBMInitCmnLcLst ARGS((RgCellCb *cellCb));
77 PRIVATE Void rgDBMInitRachLst ARGS((RgCellCb *cellCb));
79 PRIVATE S16 rgDBMInitSpsUeCbLst ARGS((
89 /* forward references */
92 * @brief Handler for Initializing the cell.
96 * Function : rgDBMInitCell
98 * Initializes the lists belonging to the cell.
101 * @param[in] RgCellCb *cellCb
107 PUBLIC S16 rgDBMInitCell
112 PUBLIC S16 rgDBMInitCell(cellCb)
120 /* Initialize ue list */
121 if ((ret = rgDBMInitUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
125 /* Initialize SPS Ue list */
126 if ((ret = rgDBMInitSpsUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
128 #endif /* LTEMAC_SPS */
130 /* Initialize BCCH/PCCH logical channels */
131 rgDBMInitCmnLcLst(cellCb);
134 /* Initialize rach ue list */
135 rgDBMInitRachLst(cellCb);
139 } /* rgDBMInitCell */
142 * @brief Handler for initializing the ueCbLst under the cellCb.
146 * Function : rgDBMInitUeCbLst
156 PRIVATE S16 rgDBMInitUeCbLst
162 PRIVATE S16 rgDBMInitUeCbLst(cellCb, numBins)
167 Inst inst = cellCb->macInst - RG_INST_START;
169 TRC2(rgDBMInitUeCbLst)
171 RETVALUE(cmHashListInit(&cellCb->ueLst, numBins, (U16)((PTR)&(ue.ueLstEnt) - (PTR)&ue), FALSE,
172 CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
174 } /* rgDBMInitUeCbLst */
177 * @brief Handler for de-initializing the ueCbLst under the cellCb.
181 * Function : rgDBMDeInitUeCbLst
190 PUBLIC S16 rgDBMDeInitUeCbLst
195 PUBLIC S16 rgDBMDeInitUeCbLst(cellCb)
199 TRC2(rgDBMDeInitUeCbLst)
201 RETVALUE(cmHashListDeinit(&cellCb->ueLst));
203 } /* rgDBMDeInitUeCbLst */
207 * @brief Handler for initializing the spsUeCbLst under the cellCb.
211 * Function : rgDBMInitSpsUeCbLst
221 PRIVATE S16 rgDBMInitSpsUeCbLst
227 PRIVATE S16 rgDBMInitSpsUeCbLst(cellCb, numBins)
232 Inst inst = cellCb->macInst - RG_INST_START;
234 TRC2(rgDBMInitSpsUeCbLst)
236 RETVALUE(cmHashListInit(&cellCb->spsUeLst, numBins, (U16) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
237 CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
239 } /* rgDBMInitSpsUeCbLst */
242 * @brief Handler for de-initializing the spsUeCbLst under the cellCb.
246 * Function : rgDBMDeInitSpsUeCbLst
255 PUBLIC S16 rgDBMDeInitSpsUeCbLst
260 PUBLIC S16 rgDBMDeInitSpsUeCbLst(cellCb)
264 TRC2(rgDBMDeInitSpsUeCbLst)
266 RETVALUE(cmHashListDeinit(&cellCb->spsUeLst));
268 } /* rgDBMDeInitSpsUeCbLst */
270 #endif /* LTEMAC_SPS */
273 * @brief Handler for inserting the ueCb in to the ueCbLst under the cellCb.
277 * Function : rgDBMInsUeCb
287 PUBLIC S16 rgDBMInsUeCb
293 PUBLIC S16 rgDBMInsUeCb(cellCb, ueCb)
300 RETVALUE(cmHashListInsert(&cellCb->ueLst, (PTR)ueCb,
301 (U8 *)&ueCb->ueId, (U16)sizeof(ueCb->ueId)));
307 * @brief Handler for inserting the ueCb in to the spsUeCbLst under the cellCb.
311 * Function : rgDBMInsSpsUeCb
321 PUBLIC S16 rgDBMInsSpsUeCb
327 PUBLIC S16 rgDBMInsSpsUeCb(cellCb, ueCb)
332 TRC2(rgDBMInsSpsUeCb)
334 RETVALUE(cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
335 (U8 *)&ueCb->spsRnti, (U16)sizeof(ueCb->spsRnti)));
337 } /* end of rgDBMInsSpsUeCb */
339 #endif /* LTEMAC_SPS */
342 * @brief Handler for accessing the existing ueCb identified by the key ueId
343 * in the ueCbLst under the cellCb.
347 * Function : rgDBMGetUeCb
355 PUBLIC RgUeCb* rgDBMGetUeCb
361 PUBLIC RgUeCb* rgDBMGetUeCb(cellCb, ueId)
366 RgUeCb *ueCb = NULLP;
370 cmHashListFind(&cellCb->ueLst, (U8 *)&ueId,
371 sizeof(ueId), 0, (PTR *)&ueCb);
377 * @brief Handler for accessing the ueCb identified by the key sps-rnti
378 * in the spsUeLst under the cellCb.
382 * Function : rgDBMGetSpsUeCb
390 PUBLIC RgUeCb* rgDBMGetSpsUeCb
396 PUBLIC RgUeCb* rgDBMGetSpsUeCb(cellCb, spsRnti)
401 RgUeCb *ueCb = NULLP;
403 TRC2(rgDBMGetSpsUeCb)
405 cmHashListFind(&cellCb->spsUeLst, (U8 *)&spsRnti,
406 sizeof(spsRnti), 0, (PTR *)&ueCb);
408 } /* rgDBMGetSpsUeCb */
410 #endif /* LTEMAC_SPS */
413 * @brief Handler for accessing the existing next ueCb in the ueCbLst under the
418 * Function : rgDBMGetNextUeCb
426 PUBLIC RgUeCb* rgDBMGetNextUeCb
432 PUBLIC RgUeCb* rgDBMGetNextUeCb(cellCb, ueCb)
437 RgUeCb *nextUeCb = NULLP;
439 TRC2(rgDBMGetNextUeCb)
441 cmHashListGetNext(&cellCb->ueLst, (PTR) ueCb, (PTR *)&nextUeCb);
443 } /* rgDBMGetNextUeCb */
447 * @brief Handler for accessing the existing next ueCb stored in the spsUeCbLst
448 * using SPS-Rnti under the cellCb.
452 * Function : rgDBMGetNextSpsUeCb
460 PUBLIC RgUeCb* rgDBMGetNextSpsUeCb
466 PUBLIC RgUeCb* rgDBMGetNextSpsUeCb(cellCb, ueCb)
471 RgUeCb *nextUeCb = NULLP;
473 TRC2(rgDBMGetNextSpsUeCb)
475 cmHashListGetNext(&cellCb->spsUeLst, (PTR) ueCb, (PTR *)&nextUeCb);
477 } /* end of rgDBMGetNextSpsUeCb */
479 #endif /* LTEMAC_SPS */
483 * @brief Handler for deleting the existing ueCb from the ueCbLst under the
488 * Function : rgDBMDelUeCb
498 PUBLIC S16 rgDBMDelUeCb
504 PUBLIC S16 rgDBMDelUeCb(cellCb, ueCb)
511 RETVALUE(cmHashListDelete(&cellCb->ueLst, (PTR)ueCb));
516 * @brief Handler for deleting the existing ueCb from the spsUeCbLst under the
521 * Function : rgDBMDelSpsUeCb
531 PUBLIC S16 rgDBMDelSpsUeCb
537 PUBLIC S16 rgDBMDelSpsUeCb(cellCb, ueCb)
542 TRC2(rgDBMDelSpsUeCb)
544 RETVALUE(cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
545 } /* end of rgDBMDelSpsUeCb */
547 #endif /* LTEMAC_SPS */
550 * @brief Handler for Initializing the UE.
554 * Function : rgDBMInitUe
556 * Initializes the lists belonging to the UE.
559 * @param[in] RgUeCb *ueCb
565 PUBLIC Void rgDBMInitUe
570 PUBLIC Void rgDBMInitUe(ueCb)
580 /* Initialize Dedicated logical channels */
581 rgDBMInitDedLcLst(ueCb);
584 /* Initialize the SPS LC Ids */
585 for (idx=0; idx < RG_MAX_LC_PER_UE; idx++)
587 ueCb->ul.spsLcId[idx] = FALSE;
596 * @brief Handler for Initializing the dedicated logical channels.
600 * Function : rgDBMInitDedLcLst
602 * Initializes dedicated logical channels.
604 * @param[in] RgUeCb *ueCb
608 PRIVATE Void rgDBMInitDedLcLst
613 PRIVATE Void rgDBMInitDedLcLst(ueCb)
619 TRC2(rgDBMInitDedLcLst);
621 for (idx = 0; idx < RG_MAX_LC_PER_UE; ++idx)
623 /* Set Dedicated LCs as not configured */
624 ueCb->ul.lcCb[idx].lcId = RG_INVALID_LC_ID;
625 ueCb->ul.lcCb[idx].lcgId = RG_INVALID_LCG_ID;
626 ueCb->dl.lcCb[idx].lcId = RG_INVALID_LC_ID;
629 for (idx = 0; idx < RG_MAX_LCG_PER_UE; ++idx)
631 /* Set LCGs as not configured */
632 ueCb->ul.lcgArr[idx].lcgId = RG_INVALID_LCG_ID;
633 ueCb->ul.lcgArr[idx].lcCount = 0;
636 /* Stack Crash problem for TRACE5 Changes. Added the return below */
638 } /* rgDBMInitDedLcLst */
641 * @brief Handler for Initializing the common logical channel list of the cell.
645 * Function : rgDBMInitCmnLcLst
647 * Initializes following common logical channels belonging to the cell.
652 * @param[in] RgCellCb *cellCb
656 PRIVATE Void rgDBMInitCmnLcLst
661 PRIVATE Void rgDBMInitCmnLcLst(cellCb)
667 TRC2(rgDBMInitCmnLcLst);
669 cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
670 cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
672 cellCb->numBcchDlschInfo = 0;
673 for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
675 cellCb->bcchDlschInfo[idx].lcId = RG_INVALID_LC_ID;
676 cellCb->bcchDlschInfo[idx].tb = NULLP;
679 /* Stack Crash problem for TRACE5 Changes. Added the return below */
681 } /* rgDBMInitCmnLcLst */
684 * @brief Handler for Initializing the common logical channel list of the cell.
688 * Function : rgDBMFreeCmnLcLst
690 * Initializes following common logical channels belonging to the cell.
695 * @param[in] RgCellCb *cellCb
699 PUBLIC Void rgDBMFreeCmnLcLst
704 PUBLIC Void rgDBMFreeCmnLcLst(cellCb)
710 TRC2(rgDBMFreeCmnLcLst);
712 cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
713 cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
715 for (idx = 0; idx < cellCb->numBcchDlschInfo; idx++)
717 cellCb->bcchDlschInfo[idx].lcId = RG_INVALID_LC_ID;
718 RG_FREE_MSG(cellCb->bcchDlschInfo[idx].tb);
720 cellCb->numBcchDlschInfo = 0;
722 /* Stack Crash problem for TRACE5 Changes. Added the return below */
724 } /* rgDBMFreeCmnLcLst */
727 * @brief Handler for inserting dedicated DL logical channel.
731 * Function : rgDBMInsDlDedLcCb
733 * @param[in] RgUeCb *ueCb
734 * @param[in] RgDlLcCb* dlLcCb
738 PUBLIC Void rgDBMInsDlDedLcCb
744 PUBLIC Void rgDBMInsDlDedLcCb(ueCb, idx)
749 TRC2(rgDBMInsDlDedLcCb);
750 if( idx >= RG_DEDLC_MIN_LCID )
752 ueCb->dl.lcCb[idx-1].lcId = idx;
754 /* Stack Crash problem for TRACE5 Changes. Added the return below */
756 } /* rgDBMInsDlDedLcCb */
759 * @brief Handler for deleting dedicated DL logical channel.
763 * Function : rgDBMDelDlDedLcCb
765 * @param[in] RgUeCb *ueCb
766 * @param[in] RgDlLcCb* dlLcCb
770 PUBLIC Void rgDBMDelDlDedLcCb
776 PUBLIC Void rgDBMDelDlDedLcCb(ueCb, dlLcCb)
781 TRC2(rgDBMDelDlDedLcCb);
783 ueCb->dl.lcCb[dlLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
785 /* Stack Crash problem for TRACE5 Changes. Added the return below */
788 } /* rgDBMDelDlDedLcCb */
791 * @brief Handler for accessing the existing DL dedicated lcCb at idx in the
792 * lcCbLst of the ueCb.
796 * Function : rgDBMGetDlDedLcCb
803 PUBLIC RgDlLcCb* rgDBMGetDlDedLcCb
809 PUBLIC RgDlLcCb* rgDBMGetDlDedLcCb(ueCb, idx)
814 TRC2(rgDBMGetDlDedLcCb);
816 if (idx > RG_DEDLC_MAX_LCID || idx <= 0)
820 if(ueCb->dl.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
825 RETVALUE(&ueCb->dl.lcCb[idx-1]);
827 } /* rgDBMGetDlDedLcCb */
830 * @brief Handler for inserting dedicated UL logical channel.
834 * Function : rgDBMInsUlDedLcCb
837 * @param[in] RgUeCb *ueCb
838 * @param[in] CmLteLcId idx
839 * @param[in] LteLcgId gId
844 PUBLIC Void rgDBMInsUlDedLcCb
852 PUBLIC Void rgDBMInsUlDedLcCb(ueCb, idx, gId, qci)
860 PUBLIC Void rgDBMInsUlDedLcCb
867 PUBLIC Void rgDBMInsUlDedLcCb(ueCb, idx, gId)
874 TRC2(rgDBMInsUlDedLcCb);
875 if ( idx >= RG_DEDLC_MIN_LCID)
877 ueCb->ul.lcCb[idx - 1].lcId = idx;
878 ueCb->ul.lcCb[idx - 1].lcgId = gId;
880 ueCb->ul.lcCb[idx - 1].qci = qci;
883 if(ueCb->ul.lcgArr[gId].lcgId == RG_INVALID_LCG_ID)
885 ueCb->ul.lcgArr[gId].lcgId = gId;
887 ueCb->ul.lcgArr[gId].lcCount = ueCb->ul.lcgArr[gId].lcCount + 1;
890 /* Stack Crash problem for TRACE5 Changes. Added the return below */
893 } /* rgDBMInsUlDedLcCb */
896 * @brief Handler for deleting the dedicated UL logical channel.
900 * Function : rgDBMUpdUlDedLcCb
903 * @param[in] RgUeCb *ueCb
904 * @param[in] RgUlLcCb* ulLcCb
905 * @param[in] LteLcgId gId
909 PUBLIC Void rgDBMUpdUlDedLcCb
916 PUBLIC Void rgDBMUpdUlDedLcCb(ueCb, ulLcCb, gId)
922 TRC2(rgDBMUpdUlDedLcCb);
924 ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount =
925 ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
926 if(ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount == 0)
928 ueCb->ul.lcgArr[ulLcCb->lcgId].lcgId = RG_INVALID_LCG_ID;
930 ueCb->ul.lcCb[ulLcCb->lcId - 1].lcgId = gId;
932 if(ueCb->ul.lcgArr[gId].lcgId == RG_INVALID_LCG_ID)
934 ueCb->ul.lcgArr[gId].lcgId = gId;
936 ueCb->ul.lcgArr[gId].lcCount = ueCb->ul.lcgArr[gId].lcCount + 1;
938 /* Stack Crash problem for TRACE5 Changes. Added the return below */
940 } /* rgDBMUpdUlDedLcCb */
943 * @brief Handler for updating the dedicated UL logical channel.
947 * Function : rgDBMDelUlDedLcCb
950 * @param[in] RgUeCb *ueCb
951 * @param[in] RgUlLcCb* ulLcCb
955 PUBLIC Void rgDBMDelUlDedLcCb
961 PUBLIC Void rgDBMDelUlDedLcCb(ueCb, ulLcCb)
966 TRC2(rgDBMDelUlDedLcCb);
968 ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount =
969 ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
970 if(ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount == 0)
972 ueCb->ul.lcgArr[ulLcCb->lcgId].lcgId = RG_INVALID_LCG_ID;
974 ueCb->ul.lcCb[ulLcCb->lcId - 1].lcgId = RG_INVALID_LCG_ID;
975 ueCb->ul.lcCb[ulLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
977 /* Stack Crash problem for TRACE5 Changes. Added the return below */
979 } /* rgDBMDelUlDedLcCb */
982 * @brief Handler for accessing the existing UL dedicated lcCb at idx in the
983 * lcCbLst of the ueCb.
987 * Function : rgDBMGetUlDedLcCb
995 PUBLIC RgUlLcCb* rgDBMGetUlDedLcCb
1001 PUBLIC RgUlLcCb* rgDBMGetUlDedLcCb(ueCb, idx)
1006 TRC2(rgDBMGetUlDedLcCb)
1008 if (idx > RG_DEDLC_MAX_LCID || idx < RG_DEDLC_MIN_LCID)
1012 if(ueCb->ul.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
1017 RETVALUE(&ueCb->ul.lcCb[idx-1]);
1018 } /* rgDBMGetDlDedLcCb */
1021 * @brief Handler for accessing the existing DL common lcCb identified by the key lcId
1022 * in the lcCbLst of the ueCb.
1026 * Function : rgDBMChkCmnLcCb
1029 * @param[in] *cellCb
1036 PUBLIC S16 rgDBMChkCmnLcCb
1042 PUBLIC S16 rgDBMChkCmnLcCb(cellCb, lcId)
1049 TRC2(rgDBMChkCmnLcCb)
1051 if(cellCb->bcchBchInfo.lcId == lcId)
1055 if(cellCb->pcchInfo.lcId == lcId)
1060 for (idx = 0; idx < cellCb->numBcchDlschInfo; idx++)
1062 if(cellCb->bcchDlschInfo[idx].lcId == lcId)
1068 } /* rgDBMChkCmnLcCb */
1071 * @brief Handler for accessing the existing BCCH mapped on to BCH in the
1072 * lcCbLst of the ueCb.
1076 * Function : rgDBMGetBcchOnBch
1079 * @param[in] *cellCb
1080 * @return RgBcchBchLcCb*
1083 PUBLIC RgBcchBchLcCb* rgDBMGetBcchOnBch
1088 PUBLIC RgBcchBchLcCb* rgDBMGetBcchOnBch(cellCb)
1092 TRC2(rgDBMGetBcchOnBch)
1094 if(cellCb->bcchBchInfo.lcId != RG_INVALID_LC_ID)
1096 RETVALUE(&(cellCb->bcchBchInfo));
1099 } /* rgDBMGetBcchOnBch */
1102 * @brief Handler for accessing the existing BCCH mapped on to DLSCH in the
1103 * lcCbLst of the ueCb.
1107 * Function : rgDBMGetBcchOnDlsch
1110 * @param[in] *cellCb
1112 * @return RgBcchDlschLcCb*
1115 PUBLIC RgBcchDlschLcCb* rgDBMGetBcchOnDlsch
1121 PUBLIC RgBcchDlschLcCb* rgDBMGetBcchOnDlsch(cellCb,lcId)
1128 TRC2(rgDBMGetBcchOnDlsch)
1130 for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
1132 if(cellCb->bcchDlschInfo[idx].lcId == lcId)
1134 RETVALUE(&(cellCb->bcchDlschInfo[idx]));
1138 } /* rgDBMGetBcchOnDlsch */
1141 * @brief Handler for accessing the existing PCCH in the lcCbLst of the ueCb.
1145 * Function : rgDBMGetPcch
1148 * @param[in] *cellCb
1149 * @return RgPcchLcCb*
1152 PUBLIC RgPcchLcCb* rgDBMGetPcch
1157 PUBLIC RgPcchLcCb* rgDBMGetPcch(cellCb)
1163 if(cellCb->pcchInfo.lcId != RG_INVALID_LC_ID)
1165 RETVALUE(&(cellCb->pcchInfo));
1168 } /* rgDBMGetPcch */
1171 * @brief Handler for inserting the BCCH mapped on to BCH in the
1172 * lcCbLst of the ueCb.
1176 * Function : rgDBMInsBcchOnBch
1179 * @param[in] *cellCb
1183 PUBLIC Void rgDBMInsBcchOnBch
1189 PUBLIC Void rgDBMInsBcchOnBch(cellCb, idx)
1194 TRC2(rgDBMInsBcchOnBch)
1196 cellCb->bcchBchInfo.lcId = idx;
1198 /* Stack Crash problem for TRACE5 Changes. Added the return below */
1200 } /* rgDBMInsBcchOnBch */
1203 * @brief Handler for inserting the BCCH mapped on to DLSCH in the
1204 * lcCbLst of the ueCb.
1208 * Function : rgDBMInsBcchOnDlsch
1211 * @param[in] *cellCb
1215 PUBLIC Void rgDBMInsBcchOnDlsch
1221 PUBLIC Void rgDBMInsBcchOnDlsch(cellCb, idx)
1226 TRC2(rgDBMInsBcchOnDlsch)
1228 cellCb->bcchDlschInfo[cellCb->numBcchDlschInfo].lcId = idx;
1229 cellCb->numBcchDlschInfo++;
1231 /* Stack Crash problem for TRACE5 Changes. Added the return below */
1233 } /* rgDBMInsBcchOnDlsch */
1237 * @brief Handler for inserting the PCCH in the lcCbLst of the ueCb.
1241 * Function : rgDBMInsPcch
1244 * @param[in] *cellCb
1248 PUBLIC Void rgDBMInsPcch
1254 PUBLIC Void rgDBMInsPcch(cellCb, idx)
1261 cellCb->pcchInfo.lcId = idx;
1263 /* Stack Crash problem for TRACE5 Changes. Added the return below */
1265 } /* rgDBMInsPcch */
1268 * @brief Handler for initializing the rachLst
1272 * Function : rgDBMInitRachLst
1275 * @param[in] *cellCb
1279 PRIVATE Void rgDBMInitRachLst
1284 PRIVATE Void rgDBMInitRachLst(cellCb)
1288 TRC2(rgDBMInitRachLst)
1290 cmLListInit(&cellCb->raInfo.ueRachLst);
1292 } /* rgDBMInitRachLst */
1295 * @brief Handler for inserting the ueCb in the rachLst.
1299 * Function : rgDBMInsUeCbInRachLst
1302 * @param[in] *cellCb
1307 PUBLIC Void rgDBMInsUeCbInRachLst
1313 PUBLIC Void rgDBMInsUeCbInRachLst(cellCb, ueCb)
1318 TRC2(rgDBMInsUeCbInRachLst)
1320 cmLListAdd2Tail(&cellCb->raInfo.ueRachLst,&ueCb->rachLstEnt);
1323 } /* rgDBMInsUeCbInRachLst */
1326 * @brief Handler for accessing the existing raCb in the rachLst.
1330 * Function : rgDBMGetUeCbFromRachLst
1333 * @param[in] *cellCb
1338 PUBLIC RgUeCb* rgDBMGetUeCbFromRachLst
1344 PUBLIC RgUeCb* rgDBMGetUeCbFromRachLst(cellCb, key)
1351 TRC2(rgDBMGetUeCbFromRachLst)
1353 CM_LLIST_FIRST_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
1356 if(((RgUeCb *)tmpNode->node)->ueId == key)
1358 RETVALUE((RgUeCb *)(tmpNode->node));
1360 CM_LLIST_NEXT_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
1363 } /* rgDBMGetUeCbFromRachLst */
1366 * @brief Handler for accessing the existing ueCb from rachLst.
1370 * Function : rgDBMGetNextUeCbFromRachLst
1373 * @param[in] *cellCb
1378 PUBLIC RgUeCb* rgDBMGetNextUeCbFromRachLst
1384 PUBLIC RgUeCb* rgDBMGetNextUeCbFromRachLst(cellCb, ueCb)
1389 TRC2(rgDBMGetNextUeCbFromRachLst)
1393 RETVALUE( cellCb->raInfo.ueRachLst.first ?
1394 (RgUeCb *)(cellCb->raInfo.ueRachLst.first->node) : NULLP );
1396 RETVALUE( ueCb->rachLstEnt.next ?
1397 (RgUeCb *)(ueCb->rachLstEnt.next->node) : NULLP );
1398 } /* rgDBMGetNextUeCbFromRachLst */
1401 * @brief Handler for deleting the existing ueCb in the rachLst.
1405 * Function : rgDBMDelUeCbFromRachLst
1408 * @param[in] *cellCb
1413 PUBLIC Void rgDBMDelUeCbFromRachLst
1419 PUBLIC Void rgDBMDelUeCbFromRachLst(cellCb, ueCb)
1424 TRC2(rgDBMDelUeCbFromRachLst)
1426 cmLListDelFrm(&cellCb->raInfo.ueRachLst, &ueCb->rachLstEnt);
1428 } /* rgDBMDelUeCbFromRachLst */
1430 /**********************************************************************
1433 **********************************************************************/