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 "common_def.h"
38 #include "du_app_mac_inf.h"
42 #include "rg_sch_inf.h"
46 /* header/extern include files (.x) */
51 #include "rg_sch_inf.x"
52 #include "rg_prg.x" /* PRG interface typedefs*/
56 PRIVATE S16 rgDBMInitUeCbLst ARGS(( RgCellCb *cellCb, U16 numBins));
57 PRIVATE Void rgDBMInitDedLcLst ARGS((RgUeCb *ueCb));
58 PRIVATE Void rgDBMInitCmnLcLst ARGS((RgCellCb *cellCb));
59 PRIVATE Void rgDBMInitRachLst ARGS((RgCellCb *cellCb));
61 PRIVATE S16 rgDBMInitSpsUeCbLst ARGS((
71 /* forward references */
74 * @brief Handler for Initializing the cell.
78 * Function : rgDBMInitCell
80 * Initializes the lists belonging to the cell.
83 * @param[in] RgCellCb *cellCb
89 PUBLIC S16 rgDBMInitCell
94 PUBLIC S16 rgDBMInitCell(cellCb)
102 /* Initialize ue list */
103 if ((ret = rgDBMInitUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
107 /* Initialize SPS Ue list */
108 if ((ret = rgDBMInitSpsUeCbLst(cellCb, RG_MAX_UE_BIN_PER_CELL)) != ROK)
110 #endif /* LTEMAC_SPS */
112 /* Initialize BCCH/PCCH logical channels */
113 rgDBMInitCmnLcLst(cellCb);
116 /* Initialize rach ue list */
117 rgDBMInitRachLst(cellCb);
121 } /* rgDBMInitCell */
124 * @brief Handler for initializing the ueCbLst under the cellCb.
128 * Function : rgDBMInitUeCbLst
138 PRIVATE S16 rgDBMInitUeCbLst
144 PRIVATE S16 rgDBMInitUeCbLst(cellCb, numBins)
149 Inst inst = cellCb->macInst - RG_INST_START;
151 TRC2(rgDBMInitUeCbLst)
153 RETVALUE(cmHashListInit(&cellCb->ueLst, numBins, (U16)((PTR)&(ue.ueLstEnt) - (PTR)&ue), FALSE,
154 CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
156 } /* rgDBMInitUeCbLst */
159 * @brief Handler for de-initializing the ueCbLst under the cellCb.
163 * Function : rgDBMDeInitUeCbLst
172 PUBLIC S16 rgDBMDeInitUeCbLst
177 PUBLIC S16 rgDBMDeInitUeCbLst(cellCb)
181 TRC2(rgDBMDeInitUeCbLst)
183 RETVALUE(cmHashListDeinit(&cellCb->ueLst));
185 } /* rgDBMDeInitUeCbLst */
189 * @brief Handler for initializing the spsUeCbLst under the cellCb.
193 * Function : rgDBMInitSpsUeCbLst
203 PRIVATE S16 rgDBMInitSpsUeCbLst
209 PRIVATE S16 rgDBMInitSpsUeCbLst(cellCb, numBins)
214 Inst inst = cellCb->macInst - RG_INST_START;
216 TRC2(rgDBMInitSpsUeCbLst)
218 RETVALUE(cmHashListInit(&cellCb->spsUeLst, numBins, (U16) ((PTR) &(ue.spsUeLstEnt) - (PTR) &ue), FALSE,
219 CM_HASH_KEYTYPE_CONID, rgCb[inst].rgInit.region, rgCb[inst].rgInit.pool));
221 } /* rgDBMInitSpsUeCbLst */
224 * @brief Handler for de-initializing the spsUeCbLst under the cellCb.
228 * Function : rgDBMDeInitSpsUeCbLst
237 PUBLIC S16 rgDBMDeInitSpsUeCbLst
242 PUBLIC S16 rgDBMDeInitSpsUeCbLst(cellCb)
246 TRC2(rgDBMDeInitSpsUeCbLst)
248 RETVALUE(cmHashListDeinit(&cellCb->spsUeLst));
250 } /* rgDBMDeInitSpsUeCbLst */
252 #endif /* LTEMAC_SPS */
255 * @brief Handler for inserting the ueCb in to the ueCbLst under the cellCb.
259 * Function : rgDBMInsUeCb
269 PUBLIC S16 rgDBMInsUeCb
275 PUBLIC S16 rgDBMInsUeCb(cellCb, ueCb)
282 RETVALUE(cmHashListInsert(&cellCb->ueLst, (PTR)ueCb,
283 (U8 *)&ueCb->ueId, (U16)sizeof(ueCb->ueId)));
289 * @brief Handler for inserting the ueCb in to the spsUeCbLst under the cellCb.
293 * Function : rgDBMInsSpsUeCb
303 PUBLIC S16 rgDBMInsSpsUeCb
309 PUBLIC S16 rgDBMInsSpsUeCb(cellCb, ueCb)
314 TRC2(rgDBMInsSpsUeCb)
316 RETVALUE(cmHashListInsert(&cellCb->spsUeLst, (PTR)ueCb,
317 (U8 *)&ueCb->spsRnti, (U16)sizeof(ueCb->spsRnti)));
319 } /* end of rgDBMInsSpsUeCb */
321 #endif /* LTEMAC_SPS */
324 * @brief Handler for accessing the existing ueCb identified by the key ueId
325 * in the ueCbLst under the cellCb.
329 * Function : rgDBMGetUeCb
337 PUBLIC RgUeCb* rgDBMGetUeCb
343 PUBLIC RgUeCb* rgDBMGetUeCb(cellCb, ueId)
348 RgUeCb *ueCb = NULLP;
352 cmHashListFind(&cellCb->ueLst, (U8 *)&ueId,
353 sizeof(ueId), 0, (PTR *)&ueCb);
359 * @brief Handler for accessing the ueCb identified by the key sps-rnti
360 * in the spsUeLst under the cellCb.
364 * Function : rgDBMGetSpsUeCb
372 PUBLIC RgUeCb* rgDBMGetSpsUeCb
378 PUBLIC RgUeCb* rgDBMGetSpsUeCb(cellCb, spsRnti)
383 RgUeCb *ueCb = NULLP;
385 TRC2(rgDBMGetSpsUeCb)
387 cmHashListFind(&cellCb->spsUeLst, (U8 *)&spsRnti,
388 sizeof(spsRnti), 0, (PTR *)&ueCb);
390 } /* rgDBMGetSpsUeCb */
392 #endif /* LTEMAC_SPS */
395 * @brief Handler for accessing the existing next ueCb in the ueCbLst under the
400 * Function : rgDBMGetNextUeCb
408 PUBLIC RgUeCb* rgDBMGetNextUeCb
414 PUBLIC RgUeCb* rgDBMGetNextUeCb(cellCb, ueCb)
419 RgUeCb *nextUeCb = NULLP;
421 TRC2(rgDBMGetNextUeCb)
423 cmHashListGetNext(&cellCb->ueLst, (PTR) ueCb, (PTR *)&nextUeCb);
425 } /* rgDBMGetNextUeCb */
429 * @brief Handler for accessing the existing next ueCb stored in the spsUeCbLst
430 * using SPS-Rnti under the cellCb.
434 * Function : rgDBMGetNextSpsUeCb
442 PUBLIC RgUeCb* rgDBMGetNextSpsUeCb
448 PUBLIC RgUeCb* rgDBMGetNextSpsUeCb(cellCb, ueCb)
453 RgUeCb *nextUeCb = NULLP;
455 TRC2(rgDBMGetNextSpsUeCb)
457 cmHashListGetNext(&cellCb->spsUeLst, (PTR) ueCb, (PTR *)&nextUeCb);
459 } /* end of rgDBMGetNextSpsUeCb */
461 #endif /* LTEMAC_SPS */
465 * @brief Handler for deleting the existing ueCb from the ueCbLst under the
470 * Function : rgDBMDelUeCb
480 PUBLIC S16 rgDBMDelUeCb
486 PUBLIC S16 rgDBMDelUeCb(cellCb, ueCb)
493 RETVALUE(cmHashListDelete(&cellCb->ueLst, (PTR)ueCb));
498 * @brief Handler for deleting the existing ueCb from the spsUeCbLst under the
503 * Function : rgDBMDelSpsUeCb
513 PUBLIC S16 rgDBMDelSpsUeCb
519 PUBLIC S16 rgDBMDelSpsUeCb(cellCb, ueCb)
524 TRC2(rgDBMDelSpsUeCb)
526 RETVALUE(cmHashListDelete(&cellCb->spsUeLst, (PTR)ueCb));
527 } /* end of rgDBMDelSpsUeCb */
529 #endif /* LTEMAC_SPS */
532 * @brief Handler for Initializing the UE.
536 * Function : rgDBMInitUe
538 * Initializes the lists belonging to the UE.
541 * @param[in] RgUeCb *ueCb
547 PUBLIC Void rgDBMInitUe
552 PUBLIC Void rgDBMInitUe(ueCb)
562 /* Initialize Dedicated logical channels */
563 rgDBMInitDedLcLst(ueCb);
566 /* Initialize the SPS LC Ids */
567 for (idx=0; idx < RG_MAX_LC_PER_UE; idx++)
569 ueCb->ul.spsLcId[idx] = FALSE;
578 * @brief Handler for Initializing the dedicated logical channels.
582 * Function : rgDBMInitDedLcLst
584 * Initializes dedicated logical channels.
586 * @param[in] RgUeCb *ueCb
590 PRIVATE Void rgDBMInitDedLcLst
595 PRIVATE Void rgDBMInitDedLcLst(ueCb)
601 TRC2(rgDBMInitDedLcLst);
603 for (idx = 0; idx < RG_MAX_LC_PER_UE; ++idx)
605 /* Set Dedicated LCs as not configured */
606 ueCb->ul.lcCb[idx].lcId = RG_INVALID_LC_ID;
607 ueCb->ul.lcCb[idx].lcgId = RG_INVALID_LCG_ID;
608 ueCb->dl.lcCb[idx].lcId = RG_INVALID_LC_ID;
611 for (idx = 0; idx < RG_MAX_LCG_PER_UE; ++idx)
613 /* Set LCGs as not configured */
614 ueCb->ul.lcgArr[idx].lcgId = RG_INVALID_LCG_ID;
615 ueCb->ul.lcgArr[idx].lcCount = 0;
618 /* Stack Crash problem for TRACE5 Changes. Added the return below */
620 } /* rgDBMInitDedLcLst */
623 * @brief Handler for Initializing the common logical channel list of the cell.
627 * Function : rgDBMInitCmnLcLst
629 * Initializes following common logical channels belonging to the cell.
634 * @param[in] RgCellCb *cellCb
638 PRIVATE Void rgDBMInitCmnLcLst
643 PRIVATE Void rgDBMInitCmnLcLst(cellCb)
649 TRC2(rgDBMInitCmnLcLst);
651 cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
652 cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
654 cellCb->numBcchDlschInfo = 0;
655 for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
657 cellCb->bcchDlschInfo[idx].lcId = RG_INVALID_LC_ID;
658 cellCb->bcchDlschInfo[idx].tb = NULLP;
661 /* Stack Crash problem for TRACE5 Changes. Added the return below */
663 } /* rgDBMInitCmnLcLst */
666 * @brief Handler for Initializing the common logical channel list of the cell.
670 * Function : rgDBMFreeCmnLcLst
672 * Initializes following common logical channels belonging to the cell.
677 * @param[in] RgCellCb *cellCb
681 PUBLIC Void rgDBMFreeCmnLcLst
686 PUBLIC Void rgDBMFreeCmnLcLst(cellCb)
692 TRC2(rgDBMFreeCmnLcLst);
694 cellCb->bcchBchInfo.lcId = RG_INVALID_LC_ID;
695 cellCb->pcchInfo.lcId = RG_INVALID_LC_ID;
697 for (idx = 0; idx < cellCb->numBcchDlschInfo; idx++)
699 cellCb->bcchDlschInfo[idx].lcId = RG_INVALID_LC_ID;
700 RG_FREE_MSG(cellCb->bcchDlschInfo[idx].tb);
702 cellCb->numBcchDlschInfo = 0;
704 /* Stack Crash problem for TRACE5 Changes. Added the return below */
706 } /* rgDBMFreeCmnLcLst */
709 * @brief Handler for inserting dedicated DL logical channel.
713 * Function : rgDBMInsDlDedLcCb
715 * @param[in] RgUeCb *ueCb
716 * @param[in] RgDlLcCb* dlLcCb
720 PUBLIC Void rgDBMInsDlDedLcCb
726 PUBLIC Void rgDBMInsDlDedLcCb(ueCb, idx)
731 TRC2(rgDBMInsDlDedLcCb);
732 if( idx >= RG_DEDLC_MIN_LCID )
734 ueCb->dl.lcCb[idx-1].lcId = idx;
736 /* Stack Crash problem for TRACE5 Changes. Added the return below */
738 } /* rgDBMInsDlDedLcCb */
741 * @brief Handler for deleting dedicated DL logical channel.
745 * Function : rgDBMDelDlDedLcCb
747 * @param[in] RgUeCb *ueCb
748 * @param[in] RgDlLcCb* dlLcCb
752 PUBLIC Void rgDBMDelDlDedLcCb
758 PUBLIC Void rgDBMDelDlDedLcCb(ueCb, dlLcCb)
763 TRC2(rgDBMDelDlDedLcCb);
765 ueCb->dl.lcCb[dlLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
767 /* Stack Crash problem for TRACE5 Changes. Added the return below */
770 } /* rgDBMDelDlDedLcCb */
773 * @brief Handler for accessing the existing DL dedicated lcCb at idx in the
774 * lcCbLst of the ueCb.
778 * Function : rgDBMGetDlDedLcCb
785 PUBLIC RgDlLcCb* rgDBMGetDlDedLcCb
791 PUBLIC RgDlLcCb* rgDBMGetDlDedLcCb(ueCb, idx)
796 TRC2(rgDBMGetDlDedLcCb);
798 if (idx > RG_DEDLC_MAX_LCID || idx <= 0)
802 if(ueCb->dl.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
807 RETVALUE(&ueCb->dl.lcCb[idx-1]);
809 } /* rgDBMGetDlDedLcCb */
812 * @brief Handler for inserting dedicated UL logical channel.
816 * Function : rgDBMInsUlDedLcCb
819 * @param[in] RgUeCb *ueCb
820 * @param[in] CmLteLcId idx
821 * @param[in] LteLcgId gId
826 PUBLIC Void rgDBMInsUlDedLcCb
834 PUBLIC Void rgDBMInsUlDedLcCb(ueCb, idx, gId, qci)
842 PUBLIC Void rgDBMInsUlDedLcCb
849 PUBLIC Void rgDBMInsUlDedLcCb(ueCb, idx, gId)
856 TRC2(rgDBMInsUlDedLcCb);
857 if ( idx >= RG_DEDLC_MIN_LCID)
859 ueCb->ul.lcCb[idx - 1].lcId = idx;
860 ueCb->ul.lcCb[idx - 1].lcgId = gId;
862 ueCb->ul.lcCb[idx - 1].qci = qci;
865 if(ueCb->ul.lcgArr[gId].lcgId == RG_INVALID_LCG_ID)
867 ueCb->ul.lcgArr[gId].lcgId = gId;
869 ueCb->ul.lcgArr[gId].lcCount = ueCb->ul.lcgArr[gId].lcCount + 1;
872 /* Stack Crash problem for TRACE5 Changes. Added the return below */
875 } /* rgDBMInsUlDedLcCb */
878 * @brief Handler for deleting the dedicated UL logical channel.
882 * Function : rgDBMUpdUlDedLcCb
885 * @param[in] RgUeCb *ueCb
886 * @param[in] RgUlLcCb* ulLcCb
887 * @param[in] LteLcgId gId
891 PUBLIC Void rgDBMUpdUlDedLcCb
898 PUBLIC Void rgDBMUpdUlDedLcCb(ueCb, ulLcCb, gId)
904 TRC2(rgDBMUpdUlDedLcCb);
906 ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount =
907 ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
908 if(ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount == 0)
910 ueCb->ul.lcgArr[ulLcCb->lcgId].lcgId = RG_INVALID_LCG_ID;
912 ueCb->ul.lcCb[ulLcCb->lcId - 1].lcgId = gId;
914 if(ueCb->ul.lcgArr[gId].lcgId == RG_INVALID_LCG_ID)
916 ueCb->ul.lcgArr[gId].lcgId = gId;
918 ueCb->ul.lcgArr[gId].lcCount = ueCb->ul.lcgArr[gId].lcCount + 1;
920 /* Stack Crash problem for TRACE5 Changes. Added the return below */
922 } /* rgDBMUpdUlDedLcCb */
925 * @brief Handler for updating the dedicated UL logical channel.
929 * Function : rgDBMDelUlDedLcCb
932 * @param[in] RgUeCb *ueCb
933 * @param[in] RgUlLcCb* ulLcCb
937 PUBLIC Void rgDBMDelUlDedLcCb
943 PUBLIC Void rgDBMDelUlDedLcCb(ueCb, ulLcCb)
948 TRC2(rgDBMDelUlDedLcCb);
950 ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount =
951 ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount - 1;
952 if(ueCb->ul.lcgArr[ulLcCb->lcgId].lcCount == 0)
954 ueCb->ul.lcgArr[ulLcCb->lcgId].lcgId = RG_INVALID_LCG_ID;
956 ueCb->ul.lcCb[ulLcCb->lcId - 1].lcgId = RG_INVALID_LCG_ID;
957 ueCb->ul.lcCb[ulLcCb->lcId - 1].lcId = RG_INVALID_LC_ID;
959 /* Stack Crash problem for TRACE5 Changes. Added the return below */
961 } /* rgDBMDelUlDedLcCb */
964 * @brief Handler for accessing the existing UL dedicated lcCb at idx in the
965 * lcCbLst of the ueCb.
969 * Function : rgDBMGetUlDedLcCb
977 PUBLIC RgUlLcCb* rgDBMGetUlDedLcCb
983 PUBLIC RgUlLcCb* rgDBMGetUlDedLcCb(ueCb, idx)
988 TRC2(rgDBMGetUlDedLcCb)
990 if (idx > RG_DEDLC_MAX_LCID || idx < RG_DEDLC_MIN_LCID)
994 if(ueCb->ul.lcCb[idx-1].lcId == RG_INVALID_LC_ID)
999 RETVALUE(&ueCb->ul.lcCb[idx-1]);
1000 } /* rgDBMGetDlDedLcCb */
1003 * @brief Handler for accessing the existing DL common lcCb identified by the key lcId
1004 * in the lcCbLst of the ueCb.
1008 * Function : rgDBMChkCmnLcCb
1011 * @param[in] *cellCb
1018 PUBLIC S16 rgDBMChkCmnLcCb
1024 PUBLIC S16 rgDBMChkCmnLcCb(cellCb, lcId)
1031 TRC2(rgDBMChkCmnLcCb)
1033 if(cellCb->bcchBchInfo.lcId == lcId)
1037 if(cellCb->pcchInfo.lcId == lcId)
1042 for (idx = 0; idx < cellCb->numBcchDlschInfo; idx++)
1044 if(cellCb->bcchDlschInfo[idx].lcId == lcId)
1050 } /* rgDBMChkCmnLcCb */
1053 * @brief Handler for accessing the existing BCCH mapped on to BCH in the
1054 * lcCbLst of the ueCb.
1058 * Function : rgDBMGetBcchOnBch
1061 * @param[in] *cellCb
1062 * @return RgBcchBchLcCb*
1065 PUBLIC RgBcchBchLcCb* rgDBMGetBcchOnBch
1070 PUBLIC RgBcchBchLcCb* rgDBMGetBcchOnBch(cellCb)
1074 TRC2(rgDBMGetBcchOnBch)
1076 if(cellCb->bcchBchInfo.lcId != RG_INVALID_LC_ID)
1078 RETVALUE(&(cellCb->bcchBchInfo));
1081 } /* rgDBMGetBcchOnBch */
1084 * @brief Handler for accessing the existing BCCH mapped on to DLSCH in the
1085 * lcCbLst of the ueCb.
1089 * Function : rgDBMGetBcchOnDlsch
1092 * @param[in] *cellCb
1094 * @return RgBcchDlschLcCb*
1097 PUBLIC RgBcchDlschLcCb* rgDBMGetBcchOnDlsch
1103 PUBLIC RgBcchDlschLcCb* rgDBMGetBcchOnDlsch(cellCb,lcId)
1110 TRC2(rgDBMGetBcchOnDlsch)
1112 for (idx = 0; idx < RG_MAX_BCCH_DLSCH; idx++)
1114 if(cellCb->bcchDlschInfo[idx].lcId == lcId)
1116 RETVALUE(&(cellCb->bcchDlschInfo[idx]));
1120 } /* rgDBMGetBcchOnDlsch */
1123 * @brief Handler for accessing the existing PCCH in the lcCbLst of the ueCb.
1127 * Function : rgDBMGetPcch
1130 * @param[in] *cellCb
1131 * @return RgPcchLcCb*
1134 PUBLIC RgPcchLcCb* rgDBMGetPcch
1139 PUBLIC RgPcchLcCb* rgDBMGetPcch(cellCb)
1145 if(cellCb->pcchInfo.lcId != RG_INVALID_LC_ID)
1147 RETVALUE(&(cellCb->pcchInfo));
1150 } /* rgDBMGetPcch */
1153 * @brief Handler for inserting the BCCH mapped on to BCH in the
1154 * lcCbLst of the ueCb.
1158 * Function : rgDBMInsBcchOnBch
1161 * @param[in] *cellCb
1165 PUBLIC Void rgDBMInsBcchOnBch
1171 PUBLIC Void rgDBMInsBcchOnBch(cellCb, idx)
1176 TRC2(rgDBMInsBcchOnBch)
1178 cellCb->bcchBchInfo.lcId = idx;
1180 /* Stack Crash problem for TRACE5 Changes. Added the return below */
1182 } /* rgDBMInsBcchOnBch */
1185 * @brief Handler for inserting the BCCH mapped on to DLSCH in the
1186 * lcCbLst of the ueCb.
1190 * Function : rgDBMInsBcchOnDlsch
1193 * @param[in] *cellCb
1197 PUBLIC Void rgDBMInsBcchOnDlsch
1203 PUBLIC Void rgDBMInsBcchOnDlsch(cellCb, idx)
1208 TRC2(rgDBMInsBcchOnDlsch)
1210 cellCb->bcchDlschInfo[cellCb->numBcchDlschInfo].lcId = idx;
1211 cellCb->numBcchDlschInfo++;
1213 /* Stack Crash problem for TRACE5 Changes. Added the return below */
1215 } /* rgDBMInsBcchOnDlsch */
1219 * @brief Handler for inserting the PCCH in the lcCbLst of the ueCb.
1223 * Function : rgDBMInsPcch
1226 * @param[in] *cellCb
1230 PUBLIC Void rgDBMInsPcch
1236 PUBLIC Void rgDBMInsPcch(cellCb, idx)
1243 cellCb->pcchInfo.lcId = idx;
1245 /* Stack Crash problem for TRACE5 Changes. Added the return below */
1247 } /* rgDBMInsPcch */
1250 * @brief Handler for initializing the rachLst
1254 * Function : rgDBMInitRachLst
1257 * @param[in] *cellCb
1261 PRIVATE Void rgDBMInitRachLst
1266 PRIVATE Void rgDBMInitRachLst(cellCb)
1270 TRC2(rgDBMInitRachLst)
1272 cmLListInit(&cellCb->raInfo.ueRachLst);
1274 } /* rgDBMInitRachLst */
1277 * @brief Handler for inserting the ueCb in the rachLst.
1281 * Function : rgDBMInsUeCbInRachLst
1284 * @param[in] *cellCb
1289 PUBLIC Void rgDBMInsUeCbInRachLst
1295 PUBLIC Void rgDBMInsUeCbInRachLst(cellCb, ueCb)
1300 TRC2(rgDBMInsUeCbInRachLst)
1302 cmLListAdd2Tail(&cellCb->raInfo.ueRachLst,&ueCb->rachLstEnt);
1305 } /* rgDBMInsUeCbInRachLst */
1308 * @brief Handler for accessing the existing raCb in the rachLst.
1312 * Function : rgDBMGetUeCbFromRachLst
1315 * @param[in] *cellCb
1320 PUBLIC RgUeCb* rgDBMGetUeCbFromRachLst
1326 PUBLIC RgUeCb* rgDBMGetUeCbFromRachLst(cellCb, key)
1333 TRC2(rgDBMGetUeCbFromRachLst)
1335 CM_LLIST_FIRST_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
1338 if(((RgUeCb *)tmpNode->node)->ueId == key)
1340 RETVALUE((RgUeCb *)(tmpNode->node));
1342 CM_LLIST_NEXT_NODE(&cellCb->raInfo.ueRachLst,tmpNode);
1345 } /* rgDBMGetUeCbFromRachLst */
1348 * @brief Handler for accessing the existing ueCb from rachLst.
1352 * Function : rgDBMGetNextUeCbFromRachLst
1355 * @param[in] *cellCb
1360 PUBLIC RgUeCb* rgDBMGetNextUeCbFromRachLst
1366 PUBLIC RgUeCb* rgDBMGetNextUeCbFromRachLst(cellCb, ueCb)
1371 TRC2(rgDBMGetNextUeCbFromRachLst)
1375 RETVALUE( cellCb->raInfo.ueRachLst.first ?
1376 (RgUeCb *)(cellCb->raInfo.ueRachLst.first->node) : NULLP );
1378 RETVALUE( ueCb->rachLstEnt.next ?
1379 (RgUeCb *)(ueCb->rachLstEnt.next->node) : NULLP );
1380 } /* rgDBMGetNextUeCbFromRachLst */
1383 * @brief Handler for deleting the existing ueCb in the rachLst.
1387 * Function : rgDBMDelUeCbFromRachLst
1390 * @param[in] *cellCb
1395 PUBLIC Void rgDBMDelUeCbFromRachLst
1401 PUBLIC Void rgDBMDelUeCbFromRachLst(cellCb, ueCb)
1406 TRC2(rgDBMDelUeCbFromRachLst)
1408 cmLListDelFrm(&cellCb->raInfo.ueRachLst, &ueCb->rachLstEnt);
1410 } /* rgDBMDelUeCbFromRachLst */
1412 /**********************************************************************
1415 **********************************************************************/