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 functions
29 **********************************************************************/
31 /** @file rg_pom_scell.c
32 @brief This module does processing related to handling of SCell related function.
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"
51 #include "rg_prg.h" /* PRG interface includes*/
56 /* header/extern include files (.x) */
57 #include "gen.x" /* general layer */
58 #include "ssi.x" /* system service interface */
59 #include "cm5.x" /* common timers */
60 #include "cm_lib.x" /* common library */
61 #include "cm_hash.x" /* common hash list */
62 #include "cm_mblk.x" /* common memory link list library */
63 #include "cm_llist.x" /* common linked list library */
64 #include "cm_tkns.x" /* common tokens */
65 #include "cm_lte.x" /* common LTE */
70 #include "rg_sch_inf.x"
71 #include "rg_prg.x" /* PRG interface typedefs*/
72 #include "du_app_mac_inf.h"
75 #include "rg_pom_scell.x"
76 PRIVATE S16 rgPomVldtSCellDedLchCfg ARGS((
78 RgPrgUeSCellLchAddInfo *lcCfg,
82 PRIVATE S16 rgPomUeSCellDedLcCfg ARGS((RgCellCb *cell,
84 RgPrgUeSCellLchAddInfo *lcCfg
87 * @brief Handler for the Lch reconfiguration request from PMAC to SMAC.
91 * Function : RgPrgPMacSMacUeSCellLchModReq
94 * - calls the function for validating cell, uecb and lch sent by PMAC
95 * - Updates the lch recfg into ueCb.
96 * - If successful, add the control block to hash list of UEs for the cell
97 * else Rollback and FAIL.
100 * @param[in] RgPrgUeSCellLchModInfo *lchCfgCb
106 PUBLIC S16 RgPrgPMacSMacUeSCellLchModReq
109 RgPrgUeSCellLchModInfo *lchCfgCb
112 PUBLIC S16 RgPrgPMacSMacUeSCellLchModReq(pst, lchCfgCb)
114 RgPrgUeSCellLchModInfo *lchCfgCb;
117 RgPrgCfgCfmInfo cfgCfm;
118 Inst inst = pst->dstInst;
125 TRC2(RgPrgPMacSMacUeSCellLchModReq);
127 RGDBGPRM(inst,(rgPBuf(inst),
128 "APPLYING CRG UE SCELL CONFIG: cellId %d ueId %d lcId %d lcgId %d\n",
129 lchCfgCb->cellId, lchCfgCb->crnti,lchCfgCb->lcId,lchCfgCb->ulLchRecfg.lcgId));
131 cfgCfm.ueId = lchCfgCb->crnti;
132 cfgCfm.sCellId = lchCfgCb->cellId;
133 cfgCfm.status = PRG_CFG_CFM_OK;
134 cfgCfm.event = EVTPRGUESCELLLCHMODCFM;
135 rgGetPstToInst(&cfmPst, inst, pst->srcInst);
137 ret = rgPomVltdModLch(inst,lchCfgCb, &cell, &ue,&ulLc);
140 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMAC SCell Lc Cfg failed:\
141 cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
142 /* Set status as Not OK*/
143 cfgCfm.status = PRG_CFG_CFM_NOK;
147 ret = rgPomUeSCellLcMod(inst, ue, ulLc, lchCfgCb);
150 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMac SCell lc cfg failed:\
151 cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
152 /* Set status as Not OK*/
153 cfgCfm.status = PRG_CFG_CFM_NOK;
157 RGDBGINFONEW(inst,(rgPBuf(inst), "[%d] Scell Lch Config done:\
158 cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
160 /* Send positive confirmation to primary cell*/
161 RgPrgSMacPMacCfg(&cfmPst, &cfgCfm);
163 } /* RgPrgPMacSMacUeSCellLchModReq */
167 * @brief A wrapper class to send the LCH Del req from PMAC to SMAC
171 * Function : rgPomSndUeSCellLchDelToSmac
174 * - Retrieve the cell control block.
176 * - Validate the range of values received in
178 * - Checks if the Ue has any scell added.
179 * - If validated successfully,
180 * - if SCells have been added ,then
181 * send the lchDel structure to update the same values to SMAC.
183 * - Else return RFAILED.
185 * @param[in] Inst inst
186 * @param[in] CrgDel *lcDel
187 * @param[in] Bool *isCfmRqrd
193 PUBLIC S16 rgPomSndUeSCellLchDelToSmac
200 PUBLIC S16 rgPomSndUeSCellLchDelToSmac(inst,lcDel,isCfmRqrd)
209 RgPrgUeSCellLchDelInfo delLcCb;
213 TRC2(rgPomSndUeSCellLchDelToSmac);
215 /* Fetch the Active cell */
216 if(((cell = rgCb[inst].cell) == NULLP) ||
217 (cell->cellId != lcDel->u.lchDel.cellId))
219 RGDBGERRNEW(inst,(rgPBuf(inst),
220 "[%d]Active Cell does not exist %d\n",
221 lcDel->u.lchDel.crnti, lcDel->u.lchDel.cellId));
225 RGDBGPRM(inst,(rgPBuf(inst),
226 "Filling SCell LCh Config : cellId %d ueId %d\n",
227 cell->cellId, cell->ueId));
229 if ((ue = rgDBMGetUeCb(cell, lcDel->u.lchDel.crnti)) == NULLP)
231 RGDBGERRNEW(inst,(rgPBuf(inst),
232 "[%d]Ue does not exist\n", lcDel->u.lchDel.crnti));
235 for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
237 if(TRUE == ue->sCelInfo[idx].isSCellAdded)
239 dstMacInst = ue->sCelInfo[idx].macInst - RG_INST_START;
240 delLcCb.cellId = ue->sCelInfo[idx].sCellId;
241 delLcCb.crnti = lcDel->u.lchDel.crnti;
242 delLcCb.lcId = lcDel->u.lchDel.lcId;
243 delLcCb.dir = lcDel->u.lchDel.dir;
245 /* Get post structure of the cell to whom delLcCb needs to be sent
246 * And then send the lch recfg based on Mac instances */
247 rgGetPstToInst(&dstInstPst, inst, dstMacInst);
248 RgPrgPMacSMacUeScellLchDel(&dstInstPst, &delLcCb);
257 * @brief A wrapper class to send the LCH reconfig req from PMAC to SMAC
261 * Function : rgPomSndUeSCellLchModToSmac
264 * - Retrieve the cell control block.
266 * - Validate the range of re-configured values recieved in
267 * re-configuration request.
268 * - Checks if the Ue has any scell added.
269 * - If validated successfully,
270 * - if SCells have been added ,then
271 * send the lchRecfg structure to update the same values to SMAC.
273 * - Else return RFAILED.
275 * @param[in] Inst inst
276 * @param[in] RgCellCb *cell
277 @param[in] RgUeCb *ue,
278 @param[in] CrgLchRecfg *lchRecfg,
279 @param[in] Bool *isCfmRqrd
285 PUBLIC S16 rgPomSndUeSCellLchModToSmac
290 CrgLchRecfg *lchRecfg,
294 PUBLIC S16 rgPomSndUeSCellLchModToSmac(inst, cell, ue, lchRecfg, isCfmRqrd)
298 CrgLchRecfg *lchRecfg;
304 RgPrgUeSCellLchModInfo lchCfgCb;
307 TRC2(rgPomSndUeSCellLchModToSmac);
309 for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
311 if(TRUE == ue->sCelInfo[idx].isSCellAdded)
313 dstMacInst = ue->sCelInfo[idx].macInst - RG_INST_START;
314 lchCfgCb.cellId = ue->sCelInfo[idx].sCellId;
315 lchCfgCb.crnti = lchRecfg->crnti;
316 lchCfgCb.lcId = lchRecfg->lcId;
317 lchCfgCb.ulLchRecfg.lcgId = lchRecfg->ulRecfg.lcgId;
319 /* Get post structure of the cell to whom lchCfgCb needs to be sent
320 * And then send the lch recfg based on Mac instances */
321 rgGetPstToInst(&dstInstPst, inst, dstMacInst);
322 RgPrgPMacSMacUeScellLchMod(&dstInstPst, &lchCfgCb);
330 * @brief A wrapper class to send the LCH config req from PMAC to SMAC
334 * Function : rgPomSndUeSCellLchAddToSmac
337 * - Checks if the Ue has any scell added.
338 * - if SCells have been added ,then
339 * send the lchCfgCb structure to update the same values to SMAC.
341 * - Else return RFAILED.
343 * @param[in] Inst insg
345 * @param[in] RgCellCb *cell
346 * @paran[in] RgUeCb *ue
347 * @paran[in] CrgLchCfg *lchCfg
348 * @paran[in] Bool *isCfmRqrd
354 PUBLIC S16 rgPomSndUeSCellLchAddToSmac
363 PUBLIC S16 rgPomSndUeSCellLchAddToSmac(inst, cell, ue, lchCfg, isCfmRqrd)
373 RgPrgUeSCellLchAddInfo lchCfgCb;
376 TRC2(rgPomSndUeSCellLchAddToSmac);
378 for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
380 if(TRUE == ue->sCelInfo[idx].isSCellAdded)
382 dstMacInst = ue->sCelInfo[idx].macInst - RG_INST_START;
383 lchCfgCb.cellId = ue->sCelInfo[idx].sCellId;
384 lchCfgCb.crnti = lchCfg->crnti;
385 lchCfgCb.lcId = lchCfg->lcId;
386 lchCfgCb.lcType = lchCfg->lcType;
387 lchCfgCb.dir = lchCfg->dir;
388 lchCfgCb.dlInfo.dlTrchType = lchCfg->dlInfo.dlTrchType;
389 lchCfgCb.ulInfo.ulTrchType = lchCfg->ulInfo.ulTrchType;
390 lchCfgCb.ulInfo.lcgId = lchCfg->ulInfo.lcgId;
392 lchCfgCb.qci = lchCfg->qci;
393 #endif /* LTE_L2_MEAS */
395 /* Get post structure of the cell to whom lchCfgCb needs to be sent
396 * And then send the lch recfg based on Mac instances */
397 rgGetPstToInst(&dstInstPst, inst, dstMacInst);
398 RgPrgPMacSMacUeScellLchAdd(&dstInstPst, &lchCfgCb);
403 } /* rgPomSndUeSCellLchAddToSmac */
406 * @brief Handler for the Lch delete request from PMAC to SMAC.
410 * Function : RgPrgPMacSMacUeSCellLchDelReq
413 * - calls the function for validating cell, uecb and Lch sent by PMAC
414 * - If successful, delete the logical channel
415 * else Rollback and FAIL.
417 * @param[in] Pst *pst
418 * @param[in] RgPrgUeSCellLchDelInfo *lchCfgCb
424 PUBLIC S16 RgPrgPMacSMacUeSCellLchDelReq
427 RgPrgUeSCellLchDelInfo *delLcCb
430 PUBLIC S16 RgPrgPMacSMacUeSCellLchDelReq(pst, delLcCb)
432 RgPrgUeSCellLchDelInfo *delLcCb;
435 RgPrgCfgCfmInfo cfgCfm;
436 Inst inst = pst->dstInst;
444 TRC2(RgPrgPMacSMacUeSCellLchDelReq);
446 RGDBGPRM(inst,(rgPBuf(inst),
447 "APPLYING CRG UE SCELL CONFIG: cellId %d ueId %d\n",
448 lchCfgCb->cellId, lchCfgCb->crnti));
450 cfgCfm.ueId = delLcCb->crnti;
451 cfgCfm.sCellId = delLcCb->cellId;
452 cfgCfm.status = PRG_CFG_CFM_OK;
453 cfgCfm.event = EVTPRGUESCELLLCHDELCFM;
454 rgGetPstToInst(&cfmPst, inst, pst->srcInst);
456 ret = rgPomVltdDelLch(inst,delLcCb, &cell, &ue,&ulLc,&dlLc);
459 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMAC SCell Lc Cfg failed:\
460 cellId %d\n", delLcCb->crnti, delLcCb->cellId));
461 /* Set status as Not OK*/
462 cfgCfm.status = PRG_CFG_CFM_NOK;
466 ret = rgPomUeSCellLcDel(inst, delLcCb, ue, ulLc,dlLc);
469 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMac SCell lc cfg failed:\
470 cellId %d\n", delLcCb->crnti, delLcCb->cellId));
471 /* Set status as Not OK*/
472 cfgCfm.status = PRG_CFG_CFM_NOK;
476 RGDBGINFONEW(inst,(rgPBuf(inst), "[%d] Scell Lch Config done:\
477 cellId %d\n", delLcCb->crnti, delLcCb->cellId));
479 /* Send positive confirmation to primary cell*/
480 RgPrgSMacPMacCfg(&cfmPst, &cfgCfm);
482 } /* RgPrgPMacSMacUeSCellLchDelReq */
486 * @brief Handler for the Lch configuration request from PMAC to SMAC.
490 * Function : RgPrgPMacSMacUeSCellLchAddReq
493 * - calls the function for validating cell, uecb and Lch sent by PMAC
494 * - Updates the lch recfg into ueCb.
495 * - If successful, add the control block to hash list of UEs for the cell
496 * else Rollback and FAIL.
498 * @param[in] Pst *pst
499 * @param[in] RgPrgLchRecfgInfo *lchCfgCb
505 PUBLIC S16 RgPrgPMacSMacUeSCellLchAddReq
508 RgPrgUeSCellLchAddInfo *lchCfgCb
511 PUBLIC S16 RgPrgPMacSMacUeSCellLchAddReq(pst, lchCfgCb)
513 RgPrgUeSCellLchAddInfo *lchCfgCb;
516 RgPrgCfgCfmInfo cfgCfm;
517 Inst inst = pst->dstInst;
523 TRC2(RgPrgPMacSMacUeSCellLchAddReq);
525 RGDBGPRM(inst,(rgPBuf(inst),
526 "APPLYING UE SCELL CONFIG AT SMAC : cellId %d ueId %d\n",
527 lchCfgCb->cellId, lchCfgCb->crnti));
529 cfgCfm.ueId = lchCfgCb->crnti;
530 cfgCfm.sCellId = lchCfgCb->cellId;
531 cfgCfm.status = PRG_CFG_CFM_OK;
532 cfgCfm.event = EVTPRGUESCELLLCHADDCFM;
533 rgGetPstToInst(&cfmPst, inst, pst->srcInst);
535 ret = rgPomVldtAddLch(inst,lchCfgCb, &cell, &ue);
538 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMAC SCell Lc Cfg failed:\
539 cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
540 /* Set status as Not OK*/
541 cfgCfm.status = PRG_CFG_CFM_NOK;
545 ret = rgPomUeSCellLcAdd(inst, cell, ue, lchCfgCb);
548 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMac SCell lc cfg failed:\
549 cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
550 /* Set status as Not OK*/
551 cfgCfm.status = PRG_CFG_CFM_NOK;
555 RGDBGINFONEW(inst,(rgPBuf(inst), "[%d] Scell Lch Config done:\
556 cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
558 /* Send positive confirmation to primary cell*/
559 RgPrgSMacPMacCfg(&cfmPst, &cfgCfm);
561 } /* RgPrgPMacSMacUeSCellLchAddReq */
563 * @brief Validates the logical channel configuration request from PMAC to SMAC.
567 * Function : rPommVldtAddLch
570 * - Validate the logical channel configuration request from PMAC to
571 * SMAC : validate if configured values are within the range.
572 * - If validated successfully,
573 * - Return ROK and pointer to cell and UE for dedicated logical channels.
577 * @param[in] Inst inst
578 * @param[in] RgPrgUeSCellLchAddInfo *lcCfg
579 * @param[out] RgCellCb **cell
580 * @param[out] RgUeCb **ue
586 PUBLIC S16 rgPomVldtAddLch
589 RgPrgUeSCellLchAddInfo *lcCfg,
594 PUBLIC S16 rgPomVldtAddLch(inst,lcCfg, cell, ue)
596 RgPrgUeSCellLchAddInfo *lcCfg;
602 TRC2(rgPomVldtAddLch);
603 RGDBGPRM(inst,(rgPBuf(inst), "VALIDATE SMAC LC CONFIG: cellId %d ueId %d lcId %d\
604 cell %p ue %p\n", lcCfg->cellId, lcCfg->crnti, lcCfg->lcId,
605 (void*)*cell, (void*)*ue));
607 if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
609 /* Dedicated logical channels */
610 if ((rgPomVldtSCellDedLchCfg(inst,lcCfg, cell, ue)) != ROK)
612 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UEID Validation for dedicated LC failed\n",
619 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UEID Invalid logical channel type %d\n",\
620 lcCfg->crnti, lcCfg->lcType));
624 if ( lcCfg->qci < RG_QCI_MIN ||
625 lcCfg->qci > RG_QCI_MAX
628 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UEID Invalid qci %x\n",
629 lcCfg->crnti, lcCfg->qci));
633 #endif /*LTE_L2_MEAS */
635 RGDBGINFONEW(inst,(rgPBuf(inst),"[%d]UEID CRG LCconfig validation done:cellId:%d lcId:%d\n",
636 lcCfg->crnti, lcCfg->cellId, lcCfg->lcId));
640 * @brief Handler for the logical channel configuration request from
645 * Function : rgPomUeSCellLcAdd
648 * - Update the dedicated logical channel Cb with the configured values.
649 * - If successful, return ROK else RFAILED.
651 * @param[in] Inst inst
652 * @param[in] RgCellCb *cell
653 * @param[in] RgUeCb *ue
654 * @param[in] CrgLchCfg *lcCfg
655 * @param[out] RgErrInfo *errInfo
661 PUBLIC S16 rgPomUeSCellLcAdd
666 RgPrgUeSCellLchAddInfo *lcCfg
669 PUBLIC S16 rgPomUeSCellLcAdd(inst,cell, ue, lcCfg)
673 RgPrgUeSCellLchAddInfo *lcCfg;
677 TRC2(rgPomUeSCellLcAdd);
678 RGDBGPRM(inst,(rgPBuf(inst), "APPLYING CRG LC CONFIG: cellId %d ueId %d\
679 lcId %d dir %d cell %p ue %p\n", lcCfg->cellId, lcCfg->crnti,
680 lcCfg->lcId, lcCfg->dir, (void*)cell, (void*)ue));
682 if ((rgPomUeSCellDedLcCfg(cell, ue, lcCfg)) != ROK)
684 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Dedicated logical channel configuration"
685 "failed in SCell%d\n", lcCfg->crnti, lcCfg->lcId));
689 RGDBGINFONEW(inst,(rgPBuf(inst), "[%d]SCell LC config done: cellId %d lcId %d\n",
690 lcCfg->crnti, lcCfg->cellId, lcCfg->lcId));
692 } /* rgPomUeSCellLcAdd */
694 /***********************************************************
696 * Func : rgPomVldtSCellDedLchCfg
699 * Desc : Validates dedicated logical channel configuration received from PMAC.
701 * @param[in] Inst inst
702 * @param[in] RgPrgUeScellLchAddInfo *lcCfg
703 * @param[in] RgCellCb **cell
704 * @param[in] RgUeCb **ue
714 **********************************************************/
716 PRIVATE S16 rgPomVldtSCellDedLchCfg
719 RgPrgUeSCellLchAddInfo *lcCfg,
724 PRIVATE S16 rgPomVldtSCellDedLchCfg(inst,lcCfg, cell, ue)
726 RgPrgUeSCellLchAddInfo *lcCfg;
731 TRC2(rgPomVldtSCellDedLchCfg);
732 RGDBGPRM(inst,(rgPBuf(inst), "VALIDATING CRG DEDICATED LC CONFIG \n"));
735 /* Fetch the Active cell */
736 if (((*cell = rgCb[inst].cell) == NULLP)
737 || ((*cell)->cellId != lcCfg->cellId))
739 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist: Cell %d\n",
740 lcCfg->crnti, lcCfg->cellId));
745 if ((*ue = rgDBMGetUeCb(*cell, lcCfg->crnti)) == NULLP)
747 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE does not exist for dedicated logical"
748 "channel %d\n", lcCfg->crnti, lcCfg->lcId));
752 /* Validate logical channel Id */
753 /*if ((lcCfg->lcId < RG_DEDLC_MIN_LCID)
754 ||(lcCfg->lcId > RG_DEDLC_MAX_LCID))
756 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid logical channel Id %d\n",
757 lcCfg->crnti, lcCfg->lcId));
760 /* Validate downlink info */
761 if (lcCfg->dir & PRG_DIR_TX)
763 if (rgDBMGetDlDedLcCb((*ue), lcCfg->lcId) != NULLP)
765 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE: Dedicated DL LC %d already configured\n",
766 lcCfg->crnti, lcCfg->lcId));
772 /* Validate uplink info */
773 if (lcCfg->dir & PRG_DIR_RX)
775 if (lcCfg->ulInfo.lcgId > (RG_MAX_LCG_PER_UE - 1))
777 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE: Invalid lcgId for uplink logical"
778 "channel %d\n", lcCfg->crnti, lcCfg->ulInfo.lcgId));
781 if (rgDBMGetUlDedLcCb((*ue), lcCfg->lcId) != NULLP)
783 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE: Dedicated UL LC %d already configured\n",
784 lcCfg->crnti, lcCfg->lcId));
792 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid Direction %d \n",
793 lcCfg->crnti, lcCfg->dir));
797 RGDBGINFONEW(inst,(rgPBuf(inst), "[%d]Dedicated logical channel %d validated"
798 "for cell %d\n", lcCfg->crnti, lcCfg->lcId, lcCfg->cellId));
800 } /* rgPomVldtSCellDedLchCfg */
801 /***********************************************************
803 * Func : rgPomUeSCellDedLcCfg
806 * Desc : Validates dedicated logical channel configuration received from PMAC.
808 * @param[in] RgCellCb *cell
809 * @param[in] RgUeCb *ue
810 * @param[in] RgPrgUeSCellLchAddInfo *lcCfg
820 **********************************************************/
822 PRIVATE S16 rgPomUeSCellDedLcCfg
826 RgPrgUeSCellLchAddInfo *lcCfg
829 PRIVATE S16 rgPomUeSCellDedLcCfg(cell, ue, lcCfg)
832 RgPrgUeSCellLchAddInfo *lcCfg;
835 //Inst inst = cell->macInst - RG_INST_START;
836 TRC2(rgPomUeSCellDedLcCfg);
837 //RGDBGPRM(inst,(rgPBuf(inst), "APPLYING DEDICATED LC CONFIG\n"));
839 /* Uplink/Bi-directional logical channel */
840 if (lcCfg->dir & PRG_DIR_RX)
843 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId, lcCfg->qci);
844 cell->qciArray[lcCfg->qci].qci = lcCfg->qci;
845 if(lcCfg->lcType == CM_LTE_LCH_DTCH)
847 rgAddToL2MeasPerQci(cell,lcCfg->qci);/*LTE_L2_MEAS_PHASE2*/
850 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId);
854 /* Downlink/Bi-directional logical channel */
855 if (lcCfg->dir & PRG_DIR_TX)
857 rgDBMInsDlDedLcCb(ue, lcCfg->lcId);
859 RGDBGINFO(inst,(rgPBuf(inst), "Dedicated LC config done\n"));
862 } /* rgPomUeSCellDedLcCfg */
864 * @brief Function to validate SCellLchReCfg.
868 * Function : rgPomVltdModLch
871 * @param[in] inst instance number to fetch rgCb instance
872 * @param[in] lchCfg Cb lchCfg CB for validation
873 * @param[out] cell cell control block
874 * @param[out] RgCellCb **cell
875 * @param[out] RgUeCb **ue
876 * @param[out] RgUlLcCb **ulLc
881 PUBLIC S16 rgPomVltdModLch
884 RgPrgUeSCellLchModInfo *lchCfgCb,
890 PUBLIC S16 rgPomVltdModLch(inst, lchCfgCb, cell, ue, ulLc)
892 RgPrgUeSCellLchModInfo *lchCfgCb;
898 TRC2(rgPomVltdModLch);
899 RGDBGPRM(inst,(rgPBuf(inst), "VALIDATE SMAC LC RECONFIG: cellId %d ueId %d \
900 lcId %d cell %p ue %p ulLc %p\n",lchCfgCb->cellId,
901 lchCfgCb->crnti,lchCfgCb->lcId, (void*)*cell, (void*)*ue,
904 if ((((*cell = rgCb[inst].cell)) == NULLP)
905 || ((*cell)->cellId != lchCfgCb->cellId))
907 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist %d\n",lchCfgCb->crnti, lchCfgCb->cellId));
910 /* Fetch the Ue for dedicated channels */
911 if ((*ue = rgDBMGetUeCb(*cell, lchCfgCb->crnti)) == NULLP)
913 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Ue does not exist for dedicated logical channel\n",
917 if ((*ulLc = rgDBMGetUlDedLcCb((*ue), lchCfgCb->lcId)) == NULLP)
919 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Dedicated UL LC does not exist %d\n",
920 lchCfgCb->crnti, lchCfgCb->lcId));
923 /* if (lchCfgCb->ulLchRecfg.lcgId > (RG_MAX_LCG_PER_UE - 1))
925 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid lcgId for uplink logical channel: lcg %d"
926 "lc %d\n",lchCfgCb->crnti, lchCfgCb->ulLchRecfg.lcgId, lchCfgCb->lcId));
930 } /*rgPomVltdModLch*/
932 * @brief Handler for the logical channel re-configuration request from
937 * Function : rgPomUeSCellLcMod
940 * - Update the dedicated logical channel Cb with the re-configured
942 * - If successful, return ROK else RFAILED.
944 * @param[in] Inst inst
945 * @param[in] RgUlUeCb *ue
946 * @param[in] RgUlLcCb *ulLc
947 * @param[in] RgPrgLchRecfgInfo *lchCfgCb
953 PUBLIC S16 rgPomUeSCellLcMod
958 RgPrgUeSCellLchModInfo *lchCfgCb
961 PUBLIC S16 rgPomUeSCellLcMod(inst,cell, ue, ulLc, lchCfgCb)
965 RgPrgUeSCellLchModInfo *lchCfgCb;
968 TRC2(rgPomUeSCellLcMod);
969 RGDBGPRM(inst,(rgPBuf(inst), "APPLYING SMAC LC RECONFIG: cellId %d ueId %d\
971 lchCfgCb->cellId, lchCfgCb->crnti, lchCfgCb->lcId));
973 if (ulLc->lcgId != lchCfgCb->ulLchRecfg.lcgId)
975 rgDBMUpdUlDedLcCb(ue, ulLc, lchCfgCb->ulLchRecfg.lcgId);
978 RGDBGINFO(inst,(rgPBuf(inst), "LC %d of Ue %d of cell %d Reconfigured\n",
979 lchCfgCb->lcId, ue->ueId, cell->cellId));
981 } /* rgPomUeSCellLcMod */
983 * @brief Function to validate SCellLchDel.
987 * Function : rgPomVltdDelLch
990 * @param[in] inst instance number to fetch rgCb instance
991 * @param[in] lchCfg Cb lchCfg CB for validation
992 * @param[out] cell cell control block
993 * @param[out] RgCellCb **cell
994 * @param[out] RgUeCb **ue
995 * @param[out] RgUlLcCb **ulLc
1000 PUBLIC S16 rgPomVltdDelLch
1003 RgPrgUeSCellLchDelInfo *delLcCb,
1010 PUBLIC S16 rgPomVltdDelLch(inst, delLcCb, cell, ue, ulLc, dlLc)
1012 RgPrgUeSCellLchDelInfo *delLcCb;
1019 TRC2(rgPomVltdDelLch);
1020 RGDBGPRM(inst,(rgPBuf(inst), "VALIDATE SMAC LC RECONFIG: cellId %d ueId %d \
1021 lcId %d cell %p ue %p ulLc %p\n",delLcCb->cellId,
1022 delLcCb->crnti,delLcCb->lcId, (void*)*cell, (void*)*ue,
1024 /* Fetch the cell */
1025 if ((((*cell = rgCb[inst].cell)) == NULLP)
1026 || ((*cell)->cellId != delLcCb->cellId))
1028 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist %d\n",delLcCb->crnti, delLcCb->cellId));
1031 /* Fetch the Ue for dedicated channels */
1032 if ((*ue = rgDBMGetUeCb(*cell, delLcCb->crnti)) == NULLP)
1034 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Ue does not exist for dedicated logical channel\n",
1038 if ((*ulLc = rgDBMGetUlDedLcCb((*ue), delLcCb->lcId)) == NULLP)
1040 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Dedicated UL LC does not exist %d\n",
1041 delLcCb->crnti, delLcCb->lcId));
1044 if ((*dlLc = rgDBMGetDlDedLcCb((*ue), delLcCb->lcId)) == NULLP)
1046 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]DL LC %d does not exist\n",
1047 delLcCb->crnti, delLcCb->lcId));
1051 } /*rgPomVltdDelLch*/
1053 * @brief Handler for the logical channel delete request from
1058 * Function : rgPomUeSCellLcDel
1061 * - Fetch the logical channel control block.
1062 * - Free the logical channel control block.
1063 * - If successful, return ROK else return RFAILED.
1065 * @param[in] Inst inst
1066 * @param[in] RgPrgUeSCellLchDelInfo *delLcCb
1067 * @param[in] RgUeCb *ue
1068 * @param[in] RgUlLcCb *ulLc
1074 PUBLIC S16 rgPomUeSCellLcDel
1077 RgPrgUeSCellLchDelInfo *delLcCb,
1083 PUBLIC S16 rgPomUeSCellLcDel(inst,delLcCb,ue,ulLc,dlLc)
1085 RgPrgUeSCellLchDelInfo *delLcCb;
1092 TRC2(rgPomUeSCellLcDel);
1093 RGDBGPRM(inst,(rgPBuf(inst), "APPLYING CRG LC DELETE: cellId %d ueId %d\
1094 lcId %d dir %d\n", delLcCb->cellId,
1095 delLcCb->crnti, delLcCb->lcId,
1099 /* Validate downlink info */
1100 if (delLcCb->dir & PRG_DIR_TX)
1102 rgDBMDelDlDedLcCb(ue, dlLc);
1106 /* Validate uplink info */
1107 if (delLcCb->dir & PRG_DIR_RX)
1109 rgDBMDelUlDedLcCb(ue, ulLc);
1115 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid direction %d for LC Delete\n",
1116 delLcCb->crnti, delLcCb->dir));
1119 RGDBGINFONEW(inst,(rgPBuf(inst), "[%d]UE's Logical channel %d deleted from cell %d\n",
1120 delLcCb->crnti, delLcCb->lcId,
1123 } /* rgPomUeSCellLcDel */
1125 /**********************************************************************
1128 **********************************************************************/