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*/
74 #include "rg_pom_scell.x"
75 PRIVATE S16 rgPomVldtSCellDedLchCfg ARGS((
77 RgPrgUeSCellLchAddInfo *lcCfg,
81 PRIVATE S16 rgPomUeSCellDedLcCfg ARGS((RgCellCb *cell,
83 RgPrgUeSCellLchAddInfo *lcCfg
86 * @brief Handler for the Lch reconfiguration request from PMAC to SMAC.
90 * Function : RgPrgPMacSMacUeSCellLchModReq
93 * - calls the function for validating cell, uecb and lch sent by PMAC
94 * - Updates the lch recfg into ueCb.
95 * - If successful, add the control block to hash list of UEs for the cell
96 * else Rollback and FAIL.
99 * @param[in] RgPrgUeSCellLchModInfo *lchCfgCb
105 PUBLIC S16 RgPrgPMacSMacUeSCellLchModReq
108 RgPrgUeSCellLchModInfo *lchCfgCb
111 PUBLIC S16 RgPrgPMacSMacUeSCellLchModReq(pst, lchCfgCb)
113 RgPrgUeSCellLchModInfo *lchCfgCb;
116 RgPrgCfgCfmInfo cfgCfm;
117 Inst inst = pst->dstInst;
124 TRC2(RgPrgPMacSMacUeSCellLchModReq);
126 RGDBGPRM(inst,(rgPBuf(inst),
127 "APPLYING CRG UE SCELL CONFIG: cellId %d ueId %d lcId %d lcgId %d\n",
128 lchCfgCb->cellId, lchCfgCb->crnti,lchCfgCb->lcId,lchCfgCb->ulLchRecfg.lcgId));
130 cfgCfm.ueId = lchCfgCb->crnti;
131 cfgCfm.sCellId = lchCfgCb->cellId;
132 cfgCfm.status = PRG_CFG_CFM_OK;
133 cfgCfm.event = EVTPRGUESCELLLCHMODCFM;
134 rgGetPstToInst(&cfmPst, inst, pst->srcInst);
136 ret = rgPomVltdModLch(inst,lchCfgCb, &cell, &ue,&ulLc);
139 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMAC SCell Lc Cfg failed:\
140 cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
141 /* Set status as Not OK*/
142 cfgCfm.status = PRG_CFG_CFM_NOK;
146 ret = rgPomUeSCellLcMod(inst, ue, ulLc, lchCfgCb);
149 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMac SCell lc cfg failed:\
150 cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
151 /* Set status as Not OK*/
152 cfgCfm.status = PRG_CFG_CFM_NOK;
156 RGDBGINFONEW(inst,(rgPBuf(inst), "[%d] Scell Lch Config done:\
157 cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
159 /* Send positive confirmation to primary cell*/
160 RgPrgSMacPMacCfg(&cfmPst, &cfgCfm);
162 } /* RgPrgPMacSMacUeSCellLchModReq */
166 * @brief A wrapper class to send the LCH Del req from PMAC to SMAC
170 * Function : rgPomSndUeSCellLchDelToSmac
173 * - Retrieve the cell control block.
175 * - Validate the range of values received in
177 * - Checks if the Ue has any scell added.
178 * - If validated successfully,
179 * - if SCells have been added ,then
180 * send the lchDel structure to update the same values to SMAC.
182 * - Else return RFAILED.
184 * @param[in] Inst inst
185 * @param[in] CrgDel *lcDel
186 * @param[in] Bool *isCfmRqrd
192 PUBLIC S16 rgPomSndUeSCellLchDelToSmac
199 PUBLIC S16 rgPomSndUeSCellLchDelToSmac(inst,lcDel,isCfmRqrd)
208 RgPrgUeSCellLchDelInfo delLcCb;
212 TRC2(rgPomSndUeSCellLchDelToSmac);
214 /* Fetch the Active cell */
215 if(((cell = rgCb[inst].cell) == NULLP) ||
216 (cell->cellId != lcDel->u.lchDel.cellId))
218 RGDBGERRNEW(inst,(rgPBuf(inst),
219 "[%d]Active Cell does not exist %d\n",
220 lcDel->u.lchDel.crnti, lcDel->u.lchDel.cellId));
224 RGDBGPRM(inst,(rgPBuf(inst),
225 "Filling SCell LCh Config : cellId %d ueId %d\n",
226 cell->cellId, cell->ueId));
228 if ((ue = rgDBMGetUeCb(cell, lcDel->u.lchDel.crnti)) == NULLP)
230 RGDBGERRNEW(inst,(rgPBuf(inst),
231 "[%d]Ue does not exist\n", lcDel->u.lchDel.crnti));
234 for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
236 if(TRUE == ue->sCelInfo[idx].isSCellAdded)
238 dstMacInst = ue->sCelInfo[idx].macInst - RG_INST_START;
239 delLcCb.cellId = ue->sCelInfo[idx].sCellId;
240 delLcCb.crnti = lcDel->u.lchDel.crnti;
241 delLcCb.lcId = lcDel->u.lchDel.lcId;
242 delLcCb.dir = lcDel->u.lchDel.dir;
244 /* Get post structure of the cell to whom delLcCb needs to be sent
245 * And then send the lch recfg based on Mac instances */
246 rgGetPstToInst(&dstInstPst, inst, dstMacInst);
247 RgPrgPMacSMacUeScellLchDel(&dstInstPst, &delLcCb);
256 * @brief A wrapper class to send the LCH reconfig req from PMAC to SMAC
260 * Function : rgPomSndUeSCellLchModToSmac
263 * - Retrieve the cell control block.
265 * - Validate the range of re-configured values recieved in
266 * re-configuration request.
267 * - Checks if the Ue has any scell added.
268 * - If validated successfully,
269 * - if SCells have been added ,then
270 * send the lchRecfg structure to update the same values to SMAC.
272 * - Else return RFAILED.
274 * @param[in] Inst inst
275 * @param[in] RgCellCb *cell
276 @param[in] RgUeCb *ue,
277 @param[in] CrgLchRecfg *lchRecfg,
278 @param[in] Bool *isCfmRqrd
284 PUBLIC S16 rgPomSndUeSCellLchModToSmac
289 CrgLchRecfg *lchRecfg,
293 PUBLIC S16 rgPomSndUeSCellLchModToSmac(inst, cell, ue, lchRecfg, isCfmRqrd)
297 CrgLchRecfg *lchRecfg;
303 RgPrgUeSCellLchModInfo lchCfgCb;
306 TRC2(rgPomSndUeSCellLchModToSmac);
308 for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
310 if(TRUE == ue->sCelInfo[idx].isSCellAdded)
312 dstMacInst = ue->sCelInfo[idx].macInst - RG_INST_START;
313 lchCfgCb.cellId = ue->sCelInfo[idx].sCellId;
314 lchCfgCb.crnti = lchRecfg->crnti;
315 lchCfgCb.lcId = lchRecfg->lcId;
316 lchCfgCb.ulLchRecfg.lcgId = lchRecfg->ulRecfg.lcgId;
318 /* Get post structure of the cell to whom lchCfgCb needs to be sent
319 * And then send the lch recfg based on Mac instances */
320 rgGetPstToInst(&dstInstPst, inst, dstMacInst);
321 RgPrgPMacSMacUeScellLchMod(&dstInstPst, &lchCfgCb);
329 * @brief A wrapper class to send the LCH config req from PMAC to SMAC
333 * Function : rgPomSndUeSCellLchAddToSmac
336 * - Checks if the Ue has any scell added.
337 * - if SCells have been added ,then
338 * send the lchCfgCb structure to update the same values to SMAC.
340 * - Else return RFAILED.
342 * @param[in] Inst insg
344 * @param[in] RgCellCb *cell
345 * @paran[in] RgUeCb *ue
346 * @paran[in] CrgLchCfg *lchCfg
347 * @paran[in] Bool *isCfmRqrd
353 PUBLIC S16 rgPomSndUeSCellLchAddToSmac
362 PUBLIC S16 rgPomSndUeSCellLchAddToSmac(inst, cell, ue, lchCfg, isCfmRqrd)
372 RgPrgUeSCellLchAddInfo lchCfgCb;
375 TRC2(rgPomSndUeSCellLchAddToSmac);
377 for(idx = 0; idx < RG_MAX_SCELL_PER_UE ; idx++)
379 if(TRUE == ue->sCelInfo[idx].isSCellAdded)
381 dstMacInst = ue->sCelInfo[idx].macInst - RG_INST_START;
382 lchCfgCb.cellId = ue->sCelInfo[idx].sCellId;
383 lchCfgCb.crnti = lchCfg->crnti;
384 lchCfgCb.lcId = lchCfg->lcId;
385 lchCfgCb.lcType = lchCfg->lcType;
386 lchCfgCb.dir = lchCfg->dir;
387 lchCfgCb.dlInfo.dlTrchType = lchCfg->dlInfo.dlTrchType;
388 lchCfgCb.ulInfo.ulTrchType = lchCfg->ulInfo.ulTrchType;
389 lchCfgCb.ulInfo.lcgId = lchCfg->ulInfo.lcgId;
391 lchCfgCb.qci = lchCfg->qci;
392 #endif /* LTE_L2_MEAS */
394 /* Get post structure of the cell to whom lchCfgCb needs to be sent
395 * And then send the lch recfg based on Mac instances */
396 rgGetPstToInst(&dstInstPst, inst, dstMacInst);
397 RgPrgPMacSMacUeScellLchAdd(&dstInstPst, &lchCfgCb);
402 } /* rgPomSndUeSCellLchAddToSmac */
405 * @brief Handler for the Lch delete request from PMAC to SMAC.
409 * Function : RgPrgPMacSMacUeSCellLchDelReq
412 * - calls the function for validating cell, uecb and Lch sent by PMAC
413 * - If successful, delete the logical channel
414 * else Rollback and FAIL.
416 * @param[in] Pst *pst
417 * @param[in] RgPrgUeSCellLchDelInfo *lchCfgCb
423 PUBLIC S16 RgPrgPMacSMacUeSCellLchDelReq
426 RgPrgUeSCellLchDelInfo *delLcCb
429 PUBLIC S16 RgPrgPMacSMacUeSCellLchDelReq(pst, delLcCb)
431 RgPrgUeSCellLchDelInfo *delLcCb;
434 RgPrgCfgCfmInfo cfgCfm;
435 Inst inst = pst->dstInst;
443 TRC2(RgPrgPMacSMacUeSCellLchDelReq);
445 RGDBGPRM(inst,(rgPBuf(inst),
446 "APPLYING CRG UE SCELL CONFIG: cellId %d ueId %d\n",
447 lchCfgCb->cellId, lchCfgCb->crnti));
449 cfgCfm.ueId = delLcCb->crnti;
450 cfgCfm.sCellId = delLcCb->cellId;
451 cfgCfm.status = PRG_CFG_CFM_OK;
452 cfgCfm.event = EVTPRGUESCELLLCHDELCFM;
453 rgGetPstToInst(&cfmPst, inst, pst->srcInst);
455 ret = rgPomVltdDelLch(inst,delLcCb, &cell, &ue,&ulLc,&dlLc);
458 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMAC SCell Lc Cfg failed:\
459 cellId %d\n", delLcCb->crnti, delLcCb->cellId));
460 /* Set status as Not OK*/
461 cfgCfm.status = PRG_CFG_CFM_NOK;
465 ret = rgPomUeSCellLcDel(inst, delLcCb, ue, ulLc,dlLc);
468 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMac SCell lc cfg failed:\
469 cellId %d\n", delLcCb->crnti, delLcCb->cellId));
470 /* Set status as Not OK*/
471 cfgCfm.status = PRG_CFG_CFM_NOK;
475 RGDBGINFONEW(inst,(rgPBuf(inst), "[%d] Scell Lch Config done:\
476 cellId %d\n", delLcCb->crnti, delLcCb->cellId));
478 /* Send positive confirmation to primary cell*/
479 RgPrgSMacPMacCfg(&cfmPst, &cfgCfm);
481 } /* RgPrgPMacSMacUeSCellLchDelReq */
485 * @brief Handler for the Lch configuration request from PMAC to SMAC.
489 * Function : RgPrgPMacSMacUeSCellLchAddReq
492 * - calls the function for validating cell, uecb and Lch sent by PMAC
493 * - Updates the lch recfg into ueCb.
494 * - If successful, add the control block to hash list of UEs for the cell
495 * else Rollback and FAIL.
497 * @param[in] Pst *pst
498 * @param[in] RgPrgLchRecfgInfo *lchCfgCb
504 PUBLIC S16 RgPrgPMacSMacUeSCellLchAddReq
507 RgPrgUeSCellLchAddInfo *lchCfgCb
510 PUBLIC S16 RgPrgPMacSMacUeSCellLchAddReq(pst, lchCfgCb)
512 RgPrgUeSCellLchAddInfo *lchCfgCb;
515 RgPrgCfgCfmInfo cfgCfm;
516 Inst inst = pst->dstInst;
522 TRC2(RgPrgPMacSMacUeSCellLchAddReq);
524 RGDBGPRM(inst,(rgPBuf(inst),
525 "APPLYING UE SCELL CONFIG AT SMAC : cellId %d ueId %d\n",
526 lchCfgCb->cellId, lchCfgCb->crnti));
528 cfgCfm.ueId = lchCfgCb->crnti;
529 cfgCfm.sCellId = lchCfgCb->cellId;
530 cfgCfm.status = PRG_CFG_CFM_OK;
531 cfgCfm.event = EVTPRGUESCELLLCHADDCFM;
532 rgGetPstToInst(&cfmPst, inst, pst->srcInst);
534 ret = rgPomVldtAddLch(inst,lchCfgCb, &cell, &ue);
537 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMAC SCell Lc Cfg failed:\
538 cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
539 /* Set status as Not OK*/
540 cfgCfm.status = PRG_CFG_CFM_NOK;
544 ret = rgPomUeSCellLcAdd(inst, cell, ue, lchCfgCb);
547 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d] SMac SCell lc cfg failed:\
548 cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
549 /* Set status as Not OK*/
550 cfgCfm.status = PRG_CFG_CFM_NOK;
554 RGDBGINFONEW(inst,(rgPBuf(inst), "[%d] Scell Lch Config done:\
555 cellId %d\n", lchCfgCb->crnti, lchCfgCb->cellId));
557 /* Send positive confirmation to primary cell*/
558 RgPrgSMacPMacCfg(&cfmPst, &cfgCfm);
560 } /* RgPrgPMacSMacUeSCellLchAddReq */
562 * @brief Validates the logical channel configuration request from PMAC to SMAC.
566 * Function : rPommVldtAddLch
569 * - Validate the logical channel configuration request from PMAC to
570 * SMAC : validate if configured values are within the range.
571 * - If validated successfully,
572 * - Return ROK and pointer to cell and UE for dedicated logical channels.
576 * @param[in] Inst inst
577 * @param[in] RgPrgUeSCellLchAddInfo *lcCfg
578 * @param[out] RgCellCb **cell
579 * @param[out] RgUeCb **ue
585 PUBLIC S16 rgPomVldtAddLch
588 RgPrgUeSCellLchAddInfo *lcCfg,
593 PUBLIC S16 rgPomVldtAddLch(inst,lcCfg, cell, ue)
595 RgPrgUeSCellLchAddInfo *lcCfg;
601 TRC2(rgPomVldtAddLch);
602 RGDBGPRM(inst,(rgPBuf(inst), "VALIDATE SMAC LC CONFIG: cellId %d ueId %d lcId %d\
603 cell %p ue %p\n", lcCfg->cellId, lcCfg->crnti, lcCfg->lcId,
604 (void*)*cell, (void*)*ue));
606 if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
608 /* Dedicated logical channels */
609 if ((rgPomVldtSCellDedLchCfg(inst,lcCfg, cell, ue)) != ROK)
611 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UEID Validation for dedicated LC failed\n",
618 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UEID Invalid logical channel type %d\n",\
619 lcCfg->crnti, lcCfg->lcType));
623 if ( lcCfg->qci < RG_QCI_MIN ||
624 lcCfg->qci > RG_QCI_MAX
627 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UEID Invalid qci %x\n",
628 lcCfg->crnti, lcCfg->qci));
632 #endif /*LTE_L2_MEAS */
634 RGDBGINFONEW(inst,(rgPBuf(inst),"[%d]UEID CRG LCconfig validation done:cellId:%d lcId:%d\n",
635 lcCfg->crnti, lcCfg->cellId, lcCfg->lcId));
639 * @brief Handler for the logical channel configuration request from
644 * Function : rgPomUeSCellLcAdd
647 * - Update the dedicated logical channel Cb with the configured values.
648 * - If successful, return ROK else RFAILED.
650 * @param[in] Inst inst
651 * @param[in] RgCellCb *cell
652 * @param[in] RgUeCb *ue
653 * @param[in] CrgLchCfg *lcCfg
654 * @param[out] RgErrInfo *errInfo
660 PUBLIC S16 rgPomUeSCellLcAdd
665 RgPrgUeSCellLchAddInfo *lcCfg
668 PUBLIC S16 rgPomUeSCellLcAdd(inst,cell, ue, lcCfg)
672 RgPrgUeSCellLchAddInfo *lcCfg;
676 TRC2(rgPomUeSCellLcAdd);
677 RGDBGPRM(inst,(rgPBuf(inst), "APPLYING CRG LC CONFIG: cellId %d ueId %d\
678 lcId %d dir %d cell %p ue %p\n", lcCfg->cellId, lcCfg->crnti,
679 lcCfg->lcId, lcCfg->dir, (void*)cell, (void*)ue));
681 if ((rgPomUeSCellDedLcCfg(cell, ue, lcCfg)) != ROK)
683 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Dedicated logical channel configuration"
684 "failed in SCell%d\n", lcCfg->crnti, lcCfg->lcId));
688 RGDBGINFONEW(inst,(rgPBuf(inst), "[%d]SCell LC config done: cellId %d lcId %d\n",
689 lcCfg->crnti, lcCfg->cellId, lcCfg->lcId));
691 } /* rgPomUeSCellLcAdd */
693 /***********************************************************
695 * Func : rgPomVldtSCellDedLchCfg
698 * Desc : Validates dedicated logical channel configuration received from PMAC.
700 * @param[in] Inst inst
701 * @param[in] RgPrgUeScellLchAddInfo *lcCfg
702 * @param[in] RgCellCb **cell
703 * @param[in] RgUeCb **ue
713 **********************************************************/
715 PRIVATE S16 rgPomVldtSCellDedLchCfg
718 RgPrgUeSCellLchAddInfo *lcCfg,
723 PRIVATE S16 rgPomVldtSCellDedLchCfg(inst,lcCfg, cell, ue)
725 RgPrgUeSCellLchAddInfo *lcCfg;
730 TRC2(rgPomVldtSCellDedLchCfg);
731 RGDBGPRM(inst,(rgPBuf(inst), "VALIDATING CRG DEDICATED LC CONFIG \n"));
734 /* Fetch the Active cell */
735 if (((*cell = rgCb[inst].cell) == NULLP)
736 || ((*cell)->cellId != lcCfg->cellId))
738 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist: Cell %d\n",
739 lcCfg->crnti, lcCfg->cellId));
744 if ((*ue = rgDBMGetUeCb(*cell, lcCfg->crnti)) == NULLP)
746 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE does not exist for dedicated logical"
747 "channel %d\n", lcCfg->crnti, lcCfg->lcId));
751 /* Validate logical channel Id */
752 /*if ((lcCfg->lcId < RG_DEDLC_MIN_LCID)
753 ||(lcCfg->lcId > RG_DEDLC_MAX_LCID))
755 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid logical channel Id %d\n",
756 lcCfg->crnti, lcCfg->lcId));
759 /* Validate downlink info */
760 if (lcCfg->dir & PRG_DIR_TX)
762 if (rgDBMGetDlDedLcCb((*ue), lcCfg->lcId) != NULLP)
764 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE: Dedicated DL LC %d already configured\n",
765 lcCfg->crnti, lcCfg->lcId));
771 /* Validate uplink info */
772 if (lcCfg->dir & PRG_DIR_RX)
774 if (lcCfg->ulInfo.lcgId > (RG_MAX_LCG_PER_UE - 1))
776 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE: Invalid lcgId for uplink logical"
777 "channel %d\n", lcCfg->crnti, lcCfg->ulInfo.lcgId));
780 if (rgDBMGetUlDedLcCb((*ue), lcCfg->lcId) != NULLP)
782 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]UE: Dedicated UL LC %d already configured\n",
783 lcCfg->crnti, lcCfg->lcId));
791 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid Direction %d \n",
792 lcCfg->crnti, lcCfg->dir));
796 RGDBGINFONEW(inst,(rgPBuf(inst), "[%d]Dedicated logical channel %d validated"
797 "for cell %d\n", lcCfg->crnti, lcCfg->lcId, lcCfg->cellId));
799 } /* rgPomVldtSCellDedLchCfg */
800 /***********************************************************
802 * Func : rgPomUeSCellDedLcCfg
805 * Desc : Validates dedicated logical channel configuration received from PMAC.
807 * @param[in] RgCellCb *cell
808 * @param[in] RgUeCb *ue
809 * @param[in] RgPrgUeSCellLchAddInfo *lcCfg
819 **********************************************************/
821 PRIVATE S16 rgPomUeSCellDedLcCfg
825 RgPrgUeSCellLchAddInfo *lcCfg
828 PRIVATE S16 rgPomUeSCellDedLcCfg(cell, ue, lcCfg)
831 RgPrgUeSCellLchAddInfo *lcCfg;
834 //Inst inst = cell->macInst - RG_INST_START;
835 TRC2(rgPomUeSCellDedLcCfg);
836 //RGDBGPRM(inst,(rgPBuf(inst), "APPLYING DEDICATED LC CONFIG\n"));
838 /* Uplink/Bi-directional logical channel */
839 if (lcCfg->dir & PRG_DIR_RX)
842 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId, lcCfg->qci);
843 cell->qciArray[lcCfg->qci].qci = lcCfg->qci;
844 if(lcCfg->lcType == CM_LTE_LCH_DTCH)
846 rgAddToL2MeasPerQci(cell,lcCfg->qci);/*LTE_L2_MEAS_PHASE2*/
849 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId);
853 /* Downlink/Bi-directional logical channel */
854 if (lcCfg->dir & PRG_DIR_TX)
856 rgDBMInsDlDedLcCb(ue, lcCfg->lcId);
858 RGDBGINFO(inst,(rgPBuf(inst), "Dedicated LC config done\n"));
861 } /* rgPomUeSCellDedLcCfg */
863 * @brief Function to validate SCellLchReCfg.
867 * Function : rgPomVltdModLch
870 * @param[in] inst instance number to fetch rgCb instance
871 * @param[in] lchCfg Cb lchCfg CB for validation
872 * @param[out] cell cell control block
873 * @param[out] RgCellCb **cell
874 * @param[out] RgUeCb **ue
875 * @param[out] RgUlLcCb **ulLc
880 PUBLIC S16 rgPomVltdModLch
883 RgPrgUeSCellLchModInfo *lchCfgCb,
889 PUBLIC S16 rgPomVltdModLch(inst, lchCfgCb, cell, ue, ulLc)
891 RgPrgUeSCellLchModInfo *lchCfgCb;
897 TRC2(rgPomVltdModLch);
898 RGDBGPRM(inst,(rgPBuf(inst), "VALIDATE SMAC LC RECONFIG: cellId %d ueId %d \
899 lcId %d cell %p ue %p ulLc %p\n",lchCfgCb->cellId,
900 lchCfgCb->crnti,lchCfgCb->lcId, (void*)*cell, (void*)*ue,
903 if ((((*cell = rgCb[inst].cell)) == NULLP)
904 || ((*cell)->cellId != lchCfgCb->cellId))
906 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist %d\n",lchCfgCb->crnti, lchCfgCb->cellId));
909 /* Fetch the Ue for dedicated channels */
910 if ((*ue = rgDBMGetUeCb(*cell, lchCfgCb->crnti)) == NULLP)
912 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Ue does not exist for dedicated logical channel\n",
916 if ((*ulLc = rgDBMGetUlDedLcCb((*ue), lchCfgCb->lcId)) == NULLP)
918 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Dedicated UL LC does not exist %d\n",
919 lchCfgCb->crnti, lchCfgCb->lcId));
922 /* if (lchCfgCb->ulLchRecfg.lcgId > (RG_MAX_LCG_PER_UE - 1))
924 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid lcgId for uplink logical channel: lcg %d"
925 "lc %d\n",lchCfgCb->crnti, lchCfgCb->ulLchRecfg.lcgId, lchCfgCb->lcId));
929 } /*rgPomVltdModLch*/
931 * @brief Handler for the logical channel re-configuration request from
936 * Function : rgPomUeSCellLcMod
939 * - Update the dedicated logical channel Cb with the re-configured
941 * - If successful, return ROK else RFAILED.
943 * @param[in] Inst inst
944 * @param[in] RgUlUeCb *ue
945 * @param[in] RgUlLcCb *ulLc
946 * @param[in] RgPrgLchRecfgInfo *lchCfgCb
952 PUBLIC S16 rgPomUeSCellLcMod
957 RgPrgUeSCellLchModInfo *lchCfgCb
960 PUBLIC S16 rgPomUeSCellLcMod(inst,cell, ue, ulLc, lchCfgCb)
964 RgPrgUeSCellLchModInfo *lchCfgCb;
967 TRC2(rgPomUeSCellLcMod);
968 RGDBGPRM(inst,(rgPBuf(inst), "APPLYING SMAC LC RECONFIG: cellId %d ueId %d\
970 lchCfgCb->cellId, lchCfgCb->crnti, lchCfgCb->lcId));
972 if (ulLc->lcgId != lchCfgCb->ulLchRecfg.lcgId)
974 rgDBMUpdUlDedLcCb(ue, ulLc, lchCfgCb->ulLchRecfg.lcgId);
977 RGDBGINFO(inst,(rgPBuf(inst), "LC %d of Ue %d of cell %d Reconfigured\n",
978 lchCfgCb->lcId, ue->ueId, cell->cellId));
980 } /* rgPomUeSCellLcMod */
982 * @brief Function to validate SCellLchDel.
986 * Function : rgPomVltdDelLch
989 * @param[in] inst instance number to fetch rgCb instance
990 * @param[in] lchCfg Cb lchCfg CB for validation
991 * @param[out] cell cell control block
992 * @param[out] RgCellCb **cell
993 * @param[out] RgUeCb **ue
994 * @param[out] RgUlLcCb **ulLc
999 PUBLIC S16 rgPomVltdDelLch
1002 RgPrgUeSCellLchDelInfo *delLcCb,
1009 PUBLIC S16 rgPomVltdDelLch(inst, delLcCb, cell, ue, ulLc, dlLc)
1011 RgPrgUeSCellLchDelInfo *delLcCb;
1018 TRC2(rgPomVltdDelLch);
1019 RGDBGPRM(inst,(rgPBuf(inst), "VALIDATE SMAC LC RECONFIG: cellId %d ueId %d \
1020 lcId %d cell %p ue %p ulLc %p\n",delLcCb->cellId,
1021 delLcCb->crnti,delLcCb->lcId, (void*)*cell, (void*)*ue,
1023 /* Fetch the cell */
1024 if ((((*cell = rgCb[inst].cell)) == NULLP)
1025 || ((*cell)->cellId != delLcCb->cellId))
1027 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist %d\n",delLcCb->crnti, delLcCb->cellId));
1030 /* Fetch the Ue for dedicated channels */
1031 if ((*ue = rgDBMGetUeCb(*cell, delLcCb->crnti)) == NULLP)
1033 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Ue does not exist for dedicated logical channel\n",
1037 if ((*ulLc = rgDBMGetUlDedLcCb((*ue), delLcCb->lcId)) == NULLP)
1039 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Dedicated UL LC does not exist %d\n",
1040 delLcCb->crnti, delLcCb->lcId));
1043 if ((*dlLc = rgDBMGetDlDedLcCb((*ue), delLcCb->lcId)) == NULLP)
1045 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]DL LC %d does not exist\n",
1046 delLcCb->crnti, delLcCb->lcId));
1050 } /*rgPomVltdDelLch*/
1052 * @brief Handler for the logical channel delete request from
1057 * Function : rgPomUeSCellLcDel
1060 * - Fetch the logical channel control block.
1061 * - Free the logical channel control block.
1062 * - If successful, return ROK else return RFAILED.
1064 * @param[in] Inst inst
1065 * @param[in] RgPrgUeSCellLchDelInfo *delLcCb
1066 * @param[in] RgUeCb *ue
1067 * @param[in] RgUlLcCb *ulLc
1073 PUBLIC S16 rgPomUeSCellLcDel
1076 RgPrgUeSCellLchDelInfo *delLcCb,
1082 PUBLIC S16 rgPomUeSCellLcDel(inst,delLcCb,ue,ulLc,dlLc)
1084 RgPrgUeSCellLchDelInfo *delLcCb;
1091 TRC2(rgPomUeSCellLcDel);
1092 RGDBGPRM(inst,(rgPBuf(inst), "APPLYING CRG LC DELETE: cellId %d ueId %d\
1093 lcId %d dir %d\n", delLcCb->cellId,
1094 delLcCb->crnti, delLcCb->lcId,
1098 /* Validate downlink info */
1099 if (delLcCb->dir & PRG_DIR_TX)
1101 rgDBMDelDlDedLcCb(ue, dlLc);
1105 /* Validate uplink info */
1106 if (delLcCb->dir & PRG_DIR_RX)
1108 rgDBMDelUlDedLcCb(ue, ulLc);
1114 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Invalid direction %d for LC Delete\n",
1115 delLcCb->crnti, delLcCb->dir));
1118 RGDBGINFONEW(inst,(rgPBuf(inst), "[%d]UE's Logical channel %d deleted from cell %d\n",
1119 delLcCb->crnti, delLcCb->lcId,
1122 } /* rgPomUeSCellLcDel */
1124 /**********************************************************************
1127 **********************************************************************/