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 module handles the configuration of MAC by RRC and RRM.
35 static const char* RLOG_MODULE_NAME="MAC";
36 static int RLOG_FILE_ID=180;
37 static int RLOG_MODULE_ID=4096;
39 /* header include files -- defines (.h) */
40 #include "envopt.h" /* environment options */
41 #include "envdep.h" /* environment dependent */
42 #include "envind.h" /* environment independent */
43 #include "gen.h" /* general layer */
44 #include "ssi.h" /* system service interface */
45 #include "cm_hash.h" /* common hash list */
46 #include "cm_mblk.h" /* common memory link list library */
47 #include "cm_llist.h" /* common linked list library */
48 #include "cm_err.h" /* common error */
49 #include "cm_lte.h" /* common LTE */
50 #include "lrg.h" /* Layer manager interface includes*/
51 #include "crg.h" /* CRG interface includes*/
52 #include "rgu.h" /* RGU interface includes*/
53 #include "tfu.h" /* TFU interface includes */
54 #include "rg_sch_inf.h" /* SCH interface includes */
55 #include "rg_prg.h" /* PRG (MAC-MAC) interface includes*/
56 #include "rg_env.h" /* MAC environmental includes*/
57 #include "rg.h" /* MAC includes*/
58 #include "rg_err.h" /* MAC error includes*/
60 /* header/extern include files (.x) */
61 #include "gen.x" /* general layer typedefs */
62 #include "ssi.x" /* system services typedefs */
63 #include "cm5.x" /* common timers */
64 #include "cm_hash.x" /* common hash list */
65 #include "cm_lib.x" /* common library */
66 #include "cm_llist.x" /* common linked list */
67 #include "cm_mblk.x" /* memory management */
68 #include "cm_tkns.x" /* common tokens */
69 #include "cm_lte.x" /* common tokens */
70 #include "rgu.x" /* RGU types */
71 #include "tfu.x" /* RGU types */
72 #include "lrg.x" /* layer management typedefs for MAC */
73 #include "crg.x" /* CRG interface includes */
74 #include "rg_sch_inf.x" /* SCH interface typedefs */
75 #include "rg_prg.x" /* PRG (MAC-MAC) Interface typedefs */
76 #include "rg.x" /* typedefs for MAC */
78 #include "rg_pom_scell.x"
80 /* LTE-MAC Control Block Structure */
81 PUBLIC RgCb rgCb[RG_MAX_INST];
84 PRIVATE S16 rgCFGVldtCrgDedLcCfg ARGS((Inst inst,CrgLchCfg *lcCfg, RgCellCb **cell,
85 RgUeCb **ue, RgErrInfo *errInfo));
86 PRIVATE S16 rgCFGVldtCrgCmnLcCfg ARGS((Inst inst,CrgLchCfg *lcCfg, RgCellCb **cell,
88 PRIVATE S16 rgCFGCrgDedLcCfg ARGS((RgCellCb *cell, RgUeCb *ue,
89 CrgLchCfg *lcCfg, RgErrInfo *errInfo));
90 PRIVATE S16 rgCFGCrgCmnLcCfg ARGS((Inst inst,RgCellCb *cell, CrgLchCfg *lcCfg,
93 PRIVATE Void rgCFGFreeCmnLcLst ARGS((RgCellCb *cell));
94 PRIVATE Void rgCFGFreeUeLst ARGS((RgCellCb *cell));
95 /* Added support for SPS*/
97 PRIVATE Void rgCFGFreeSpsUeLst ARGS((RgCellCb *cell));
98 #endif /* LTEMAC_SPS */
105 /* forward references */
111 * @brief Validates the cell configuration request from RRC to MAC.
115 * Function : rgCFGVldtCrgCellCfg
118 * - Validate the cell configuration request from RRC to MAC at CFG:
119 * validate the value range for the configured values.
120 * - If validated successfully,
125 * @param[in] Inst inst
126 * @param[in] CrgCellCfg *cellCfg
127 * @param[out] RgErrInfo *errInfo
133 PUBLIC S16 rgCFGVldtCrgCellCfg
140 PUBLIC S16 rgCFGVldtCrgCellCfg(inst,cellCfg, errInfo)
146 TRC2(rgCFGVldtCrgCellCfg);
148 errInfo->errCause = RGERR_CFG_INVALID_CRG_CELL_CFG;
149 if ((rgCb[inst].cell != NULLP)
150 || rgCb[inst].inactiveCell != NULLP)
152 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Cell already exists");
155 if ((cellCfg->bwCfg.dlTotalBw < RG_MIN_DL_BW
156 || cellCfg->bwCfg.dlTotalBw > RG_MAX_DL_BW)
157 || (cellCfg->bwCfg.ulTotalBw < RG_MIN_UL_BW
158 || cellCfg->bwCfg.ulTotalBw > RG_MAX_UL_BW))
160 RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId,
161 "Invalid Bandwidth configuration: ul %d dl %d",
162 cellCfg->bwCfg.ulTotalBw, cellCfg->bwCfg.dlTotalBw);
165 if (cellCfg->rachCfg.maxMsg3Tx < RG_MIN_HQ_TX)
167 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,
168 "Invalid RACH configuration: maxMsg3Tx %d",cellCfg->rachCfg.maxMsg3Tx);
171 #ifdef TENB_MULT_CELL_SUPPRT
172 if((cellCfg->rguDlSapId > rgCb[inst].numRguSaps) ||
173 (cellCfg->rguUlSapId > rgCb[inst].numRguSaps))
175 RGDBGERRNEW(inst,(rgPBuf(inst), "Invald Sap Id: DL %d UL %d for CellId %d failed\n",
182 errInfo->errCause = RGERR_NONE;
184 } /* rgCFGVldtCrgCellCfg */
188 * @brief Validates the UE configuration request from RRC to MAC.
192 * Function : rgCFGVldtCrgUeCfg
195 * - Validate the UE configuration request from RRC to MAC at CFG:
196 * validate the value range for the configured values.
197 * - If validated successfully,
198 * - Return ROK and pointer to the cell of UE.
202 * @param[in] Inst inst
203 * @param[in] CrgUeCfg *ueCfg
204 * @param[out] RgCellCb **cell
205 * @param[out] RgErrInfo *errInfo
211 PUBLIC S16 rgCFGVldtCrgUeCfg
219 PUBLIC S16 rgCFGVldtCrgUeCfg(inst,ueCfg, cell, errInfo)
226 TRC2(rgCFGVldtCrgUeCfg);
228 errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_CFG;
229 if ((ueCfg->txMode.pres == PRSNT_NODEF) &&
230 (ueCfg->txMode.tm == CRG_UE_TM_5))
232 RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Transmission Mode=%d not supported",
237 /* Fetch the Active cell */
238 if(((*cell = rgCb[inst].cell) == NULLP) ||
239 ((*cell)->cellId != ueCfg->cellId))
241 RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Active Cell does not exist for cellId%d",
245 /* Check if Ue already configured */
246 if (rgDBMGetUeCb(*cell, ueCfg->crnti) != NULLP)
248 RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Ue already exists");
252 if (ueCfg->ueUlHqCfg.maxUlHqTx < RG_MIN_HQ_TX)
254 RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti, "Invalid Uplink HARQ config %d ",
255 ueCfg->ueUlHqCfg.maxUlHqTx);
258 #ifdef TENB_MULT_CELL_SUPPRT
259 if((ueCfg->rguDlSapId > rgCb[inst].numRguSaps) ||
260 (ueCfg->rguUlSapId > rgCb[inst].numRguSaps))
262 RGDBGERRNEW(inst,(rgPBuf(inst), "Invald Sap Id: DL %d UL %d for ueId %d failed\n",
270 errInfo->errCause = RGERR_NONE;
272 } /* rgCFGVldtCrgUeCfg */
276 * @brief Validates the logical channel configuration request from RRC to MAC.
280 * Function : rgCFGVldtCrgLcCfg
283 * - Validate the logical channel configuration request from RRC to
284 * MAC at CFG: validate if configured values are within the range.
285 * - If validated successfully,
286 * - Return ROK and pointer to the cell for common channels. Return
287 * pointer to cell and UE for dedicated logical channels.
291 * @param[in] CrgLchCfg *lcCfg
292 * @param[in] Inst inst
293 * @param[out] RgCellCb **cell
294 * @param[out] RgUeCb **ue
295 * @param[out] RgErrInfo *errInfo
301 PUBLIC S16 rgCFGVldtCrgLcCfg
310 PUBLIC S16 rgCFGVldtCrgLcCfg(inst,lcCfg, cell, ue, errInfo)
319 TRC2(rgCFGVldtCrgLcCfg);
321 if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
323 /* Dedicated logical channels */
324 if ((rgCFGVldtCrgDedLcCfg(inst,lcCfg, cell, ue, errInfo)) != ROK)
326 RLOG_ARG0(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Validation for dedicated LC failed");
330 else if (lcCfg->lcType == CM_LTE_LCH_BCCH
331 || lcCfg->lcType == CM_LTE_LCH_PCCH
332 || lcCfg->lcType == CM_LTE_LCH_CCCH)
334 if ((rgCFGVldtCrgCmnLcCfg(inst,lcCfg, cell, errInfo)) != ROK)
336 RLOG_ARG0(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Validation for common logical channels failed");
342 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid logical channel type %d",
347 if ( lcCfg->qci < RG_QCI_MIN ||
348 lcCfg->qci > RG_QCI_MAX
351 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid qci %x",lcCfg->qci);
355 #endif /*LTE_L2_MEAS */
357 errInfo->errCause = RGERR_NONE;
359 } /* rgCFGVldtCrgLcCfg */
363 * @brief Validates the cell re-configuration request from RRC to MAC.
367 * Function : rgCFGVldtCrgCellRecfg
370 * - Retrieve the cell control block.
372 * - Validate the range of re-configured values recieved in
373 * re-configuration request.
374 * - If validated successfully,
375 * - Return ROK and pointer to the cell.
378 * - Else return RFAILED.
380 * @param[in] Inst inst
381 * @param[in] CrgCellRecfg *cellRecfg
382 * @param[out] RgCellCb **cell
383 * @param[out] RgErrInfo *errInfo
389 PUBLIC S16 rgCFGVldtCrgCellRecfg
392 CrgCellRecfg *cellRecfg,
397 PUBLIC S16 rgCFGVldtCrgCellRecfg(inst,cellRecfg, cell, errInfo)
399 CrgCellRecfg *cellRecfg;
404 TRC2(rgCFGVldtCrgCellRecfg);
406 errInfo->errCause = RGERR_CFG_INVALID_CRG_CELL_RECFG;
408 if (((*cell = rgCb[inst].cell) == NULLP)
409 && ((*cell = rgCb[inst].inactiveCell) == NULLP))
411 RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Cell does not exist");
415 if((*cell)->cellId != cellRecfg->cellId)
417 RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId, "Cell does not exist %d\n",cellRecfg->cellId);
420 if (cellRecfg->rachRecfg.maxMsg3Tx < RG_MIN_HQ_TX)
422 RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId,
423 "Invalid RACH configuration: maxMsg3Tx %d",cellRecfg->rachRecfg.maxMsg3Tx);
426 errInfo->errCause = RGERR_NONE;
428 } /* rgCFGVldtCrgCellRecfg */
432 * @brief Validates the UE re-configuration request from RRC to MAC.
436 * Function : rgCFGVldtCrgUeRecfg
439 * - Retrieve the UE control block.
441 * - Validate the range of re-configured values recieved in
442 * re-configuration request.
443 * - If validated successfully,
444 * - Return ROK and pointer to the cell and ue.
447 * - Else return RFAILED.
449 * @param[in] Inst inst
450 * @param[in] CrgUeRecfg *ueRecfg
451 * @param[out] RgCellCb **cell
452 * @param[out] RgUeCb **ue
453 * @param[out] RgErrInfo *errInfo
459 PUBLIC S16 rgCFGVldtCrgUeRecfg
468 PUBLIC S16 rgCFGVldtCrgUeRecfg(inst,ueRecfg, cell, ue, errInfo)
476 TRC2(rgCFGVldtCrgUeRecfg);
478 errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_RECFG;
480 if ((ueRecfg->txMode.pres == PRSNT_NODEF) &&
481 (ueRecfg->txMode.tm == CRG_UE_TM_5))
483 RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Transmission Mode=%d not supported",
488 /* Fetch the Active cell */
489 if (((*cell = rgCb[inst].cell) == NULLP)
490 || ((*cell)->cellId != ueRecfg->cellId))
492 RLOG_ARG0(L_ERROR,DBG_CELLID,ueRecfg->cellId, "Active Cell does not exist\n");
496 /* Fix : syed UE ID change at MAC will now be controlled
498 if ((*ue = rgDBMGetUeCb(*cell, ueRecfg->oldCrnti)) == NULLP)
500 RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"[%d]Old Ue does not exist", ueRecfg->oldCrnti);
503 if (ueRecfg->ueUlHqRecfg.maxUlHqTx < RG_MIN_HQ_TX)
505 RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid Uplink HARQ config for UE %d",
506 ueRecfg->ueUlHqRecfg.maxUlHqTx);
509 errInfo->errCause = RGERR_NONE;
511 } /* rgCFGVldtCrgUeRecfg */
515 * @brief Validates the logical channel re-configuration request from
520 * Function : rgCFGVldtCrgLcRecfg
523 * - Retrieve the uplink and downlink logical channel control block.
525 * - Validate the range of re-configured values recieved in
526 * re-configuration request.
527 * - If validated successfully,
528 * - Return ROK and pointer to the cell, UE and logical channel.
531 * - Else return RFAILED.
533 * @param[in] Inst inst
534 * @param[in] CrgLchRecfg *lcRecfg
535 * @param[out] RgCellCb **cell
536 * @param[out] RgUeCb **ue
537 * @param[out] RgUlLcCb **ulLc
538 * @param[out] RgDlLcCb **dlLc
539 * @param[out] RgErrInfo *errInfo
545 PUBLIC S16 rgCFGVldtCrgLcRecfg
548 CrgLchRecfg *lcRecfg,
555 PUBLIC S16 rgCFGVldtCrgLcRecfg(inst,lcRecfg, cell, ue, ulLc, errInfo)
557 CrgLchRecfg *lcRecfg;
564 TRC2(rgCFGVldtCrgLcRecfg);
566 errInfo->errCause = RGERR_CFG_INVALID_CRG_LC_RECFG;
569 if ((((*cell = rgCb[inst].cell)) == NULLP)
570 || ((*cell)->cellId != lcRecfg->cellId))
572 RLOG_ARG2(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Active Cell %u does not exist for UE %u", lcRecfg->cellId, lcRecfg->crnti);
575 /* Fetch the Ue for dedicated channels */
576 if ((*ue = rgDBMGetUeCb(*cell, lcRecfg->crnti)) == NULLP)
578 RLOG_ARG0(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Ue does not exist for dedicated logical channel");
582 if ((*ulLc = rgDBMGetUlDedLcCb((*ue), lcRecfg->lcId)) == NULLP)
584 RLOG_ARG1(L_ERROR, DBG_CRNTI,lcRecfg->crnti,"Dedicated UL LC does not exist %d",lcRecfg->lcId);
588 if (lcRecfg->ulRecfg.lcgId > (RG_MAX_LCG_PER_UE - 1))
590 RLOG_ARG2(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Invalid lcgId for uplink logical channel lcg %d lc %d",
591 lcRecfg->ulRecfg.lcgId, lcRecfg->lcId);
595 errInfo->errCause = RGERR_NONE;
597 } /* rgCFGVldtCrgLcRecfg */
599 /* Start: LTEMAC_2.1_DEV_CFG */
601 * @brief Validates the UE Reset request from RRC to MAC.
605 * Function : rgCFGVldtCrgUeReset
608 * - Retrieve the CELL control block.
611 * - Retrieve the UE control block.
615 * @param[in] Inst inst
616 * @param[in] CrgRst *reset,
617 * @param[out] RgCellCb **cell
618 * @param[out] RgUeCb **ue
619 * @param[out] RgErrInfo *errInfo
625 PUBLIC S16 rgCFGVldtCrgUeReset
634 PUBLIC S16 rgCFGVldtCrgUeReset(inst,reset, cell, ue, errInfo)
642 TRC2(rgCFGVldtCrgUeReset);
644 errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_RESET;
646 /* Fetch the Active cell */
647 if (((*cell = rgCb[inst].cell) == NULLP)
648 || ((*cell)->cellId != reset->cellId))
650 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist %d\n",reset->crnti, reset->cellId));
651 RLOG_ARG1(L_ERROR,DBG_CRNTI,reset->crnti,"Active Cell does not exist %d",reset->cellId);
656 if ((*ue = rgDBMGetUeCb(*cell, reset->crnti)) == NULLP)
658 RLOG_ARG0(L_ERROR,DBG_CRNTI,reset->crnti,"UE does not exist");
662 errInfo->errCause = RGERR_NONE;
664 } /* rgCFGVldtCrgUeReset*/
665 /* End: LTEMAC_2.1_DEV_CFG */
670 * @brief Handler for the cell configuration request from RRC to MAC.
674 * Function : rgCFGCrgCellCfg
677 * - Allocate and create cell control block.
678 * - Update cell control block with the values recieved in the
680 * - Add the control block to hash list of cells.
681 * - Update the statistics.
682 * - If successful, return ROK else return RFAILED.
684 * @param[in] Inst inst
685 * @param[in] CrgCellCfg *cellCfg
686 * @param[out] RgErrInfo *errInfo
692 PUBLIC S16 rgCFGCrgCellCfg
699 PUBLIC S16 rgCFGCrgCellCfg(inst,cellCfg, errInfo)
706 RgCellCb *cell = NULLP;
710 /* RLC SAP to allocate flowCntrlInd buffer*/
713 TRC2(rgCFGCrgCellCfg);
715 errInfo->errCause = RGERR_CFG_CRG_CELL_CFG;
717 /* Allocate the cell control block */
718 if((ret = rgAllocSBuf(inst,(Data**)&cell, sizeof(RgCellCb))) != ROK)
720 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
725 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId, "Memory allocation FAILED for cell");
729 /* Initialize the cell */
730 cell->cellId = cellCfg->cellId;
731 cell->rachCfg = cellCfg->rachCfg;
732 cell->bwCfg = cellCfg->bwCfg;
734 if(cellCfg->emtcEnable)
736 cell->emtcEnable = cellCfg->emtcEnable;
739 /* Initialize UL and DL CCCH logical channels */
740 cell->ulCcchId = RG_INVALID_LC_ID;
741 cell->dlCcchId = RG_INVALID_LC_ID;
744 /* Initialize the lists of the cell */
745 ret = rgDBMInitCell(cell);
748 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"DBM initialization for cell failed");
749 rgCFGFreeInactvCellCb(cell);
754 if (RFAILED == RgLaaCellCbInit(cell))
756 rgCFGFreeInactvCellCb(cell);
761 for(idx=0;idx < RG_NUM_SUB_FRAMES; idx++)
763 cell->subFrms[idx].txDone = TRUE;
766 cell->macInst = inst + RG_INST_START;
767 /* Insert cell in the incative cell list */
768 rgCb[inst].inactiveCell = cell;
769 rgCb[inst].cell = NULLP;
770 #ifdef TENB_MULT_CELL_SUPPRT
771 rguDlSapId = cellCfg->rguDlSapId;
772 rguUlSapId = cellCfg->rguUlSapId;
774 if(rgCb[inst].numRguSaps > 1)
779 cell->rguDlSap = &(rgCb[inst].rguSap[rguDlSapId]);
780 cell->rguUlSap = &(rgCb[inst].rguSap[rguUlSapId]);
784 cmLListInit(&cell->l2mList);
785 for(idx = 0; idx < RG_NUM_UL_SUB_FRAMES; idx++)
787 cmMemset((U8 *)&cell->ulSf[idx], 0, sizeof(RgUlSf));
790 cell->ttiCycle = (U32)RG_TTI_CYCLE_INVLD;
792 /* Update Statistics */
793 rgUpdtCellCnt(inst,RG_CFG_ADD);
794 errInfo->errCause = RGERR_NONE;
796 pst = &rgCb[inst].rguSap[rguDlSapId].sapCfg.sapPst;
797 /* Allocate a buffer for flowCntrlInd.*/
798 SGetSBuf(pst->region, pst->pool, (Data **)&cell->flowCntrlInd,
799 sizeof(RguFlowCntrlInd));
801 } /* rgCFGCrgCellCfg */
805 * @brief Add SCell Cfg recvd from primary MAC instance.
809 * Function : rgCfgAddUeSCellCfg
812 * - Allocate and create UE control block.
813 * - Update UE control block with the values recieved in the
815 * - If successful, add the control block to hash list of UEs for the cell
816 * else Rollback and FAIL.
818 * @param[in] Inst dstMacInst
819 * @param[in] RgPrgUeSCellCfgInfo *ueSCellCb
820 * @param[in] RgCellCb cell
827 PUBLIC S16 rgCfgAddUeSCellCfg
830 RgPrgUeSCellCfgInfo *ueSCellCb,
834 PUBLIC S16 rgCfgAddUeSCellCfg(dstMacInst, ueSCellCb, cell)
836 RgPrgUeSCellCfgInfo *ueSCellCb;
840 RgUeCb *ueCb = NULLP;
846 TRC2(rgCfgAddUeSCellCfg);
849 rguDlSapId = ueSCellCb->rguDlSapId;
850 rguUlSapId = ueSCellCb->rguUlSapId;
852 #ifndef TENB_MULT_CELL_SUPPRT
853 if(rgCb[dstMacInst].numRguSaps > 1)
859 if ((ueCb = rgDBMGetUeCb(cell, ueSCellCb->ueId)) != NULLP)
861 RGDBGERRNEW(dstMacInst,(rgPBuf(dstMacInst),
862 "[%d]Ue already exist in scell %d during scell addition\n",
869 if((ueCb = rgRAMCreateUeCb(cell, ueSCellCb->ueId,
870 FALSE, &errInfo)) == NULLP)
872 RGDBGERRNEW(dstMacInst, (rgPBuf(dstMacInst),
873 "[%d]UeCb creation failed\n", ueSCellCb->ueId));
877 if(rgDHMHqEntInit(dstMacInst, &ueCb->dl.hqEnt,
878 (rgCb[dstMacInst].cell)->maxDlHqProcPerUe) != ROK)
880 RGDBGERRNEW(dstMacInst,(rgPBuf(dstMacInst),
881 "[%d]UeCb Harq Entity Initialization failed\n", ueSCellCb->ueId));
884 rgDBMInsUeCb(cell, ueCb);
887 ueCb->rguDlSap = &(rgCb[dstMacInst].rguSap[rguDlSapId]);
888 ueCb->rguUlSap = &(rgCb[dstMacInst].rguSap[rguUlSapId]);
890 /* Update satistics */
891 rgUpdtUeCnt(dstMacInst, RG_CFG_ADD);
892 /*Commit Added SCell info to UeCb */
894 ueCb->sCelAddInfo[idx].isSCellAdded = TRUE;
895 ueCb->sCelAddInfo[idx].macInst = dstMacInst;
896 ueCb->sCelAddInfo[idx].sCellId = ueSCellCb->cellId;
899 ueCb->txMode = ueSCellCb->txMode;
900 ueCb->ul.hqEnt.maxHqRetx = ueSCellCb->maxUlHqRetx;
902 for (idx =0; idx <RG_MAX_LC_PER_UE; idx++)
904 ueCb->ul.lcCb[idx] = ueSCellCb->ulLcInfo[idx];
905 ueCb->dl.lcCb[idx] = ueSCellCb->dlLcInfo[idx];
908 for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
910 ueCb->ul.lcgArr[idx].lcgId = ueSCellCb->lcgInfo[idx].lcgId;
911 ueCb->ul.lcgArr[idx].lcCount = ueSCellCb->lcgInfo[idx].lcCount;
912 ueCb->ul.lcgArr[idx].isGbr = ueSCellCb->lcgInfo[idx].isGbr;
915 }/* rgCfgAddUeSCellCfg */
918 * @brief SCell Config Filling for added cell from RRC to MAC.
922 * Function : rgFillAndAddSCellCfg
925 * - Update UE control block with the values recieved in the
927 * - Update UE control block with the values present in the
929 * - If successful, add the control block to hash list of UEs for the cell
930 * else Rollback and FAIL.
932 * @param[in] Inst inst
933 * @param[in] RgCellCb *cell
934 * @param[in] CrgUeCfg *ueCfg
935 * @param[in] CrgCfgTransId transId
941 PUBLIC S16 rgFillAndAddSCellCfg
946 CrgCfgTransId transId,
950 PUBLIC S16 rgFillAndAddSCellCfg(inst, cell, ueRecfg, transId, isCfmRqrd)
954 CrgCfgTransId transId;
961 RgPrgUeSCellCfgInfo ueSCellCb;
964 TRC2(rgFillAndAddSCellCfg);
966 /* Fetch the Active cell */
967 if(((cell = rgCb[inst].cell) == NULLP) ||
968 (cell->cellId != ueRecfg->cellId))
970 RGDBGERRNEW(inst,(rgPBuf(inst),
971 "[%d]Active Cell does not exist %d\n",
972 ueRecfg->oldCrnti, ueRecfg->cellId));
976 RGDBGPRM(inst,(rgPBuf(inst),
977 "Filling SCell Config : cellId %d ueId %d\n",
978 cell->cellId, cell->ueId));
980 if ((ue = rgDBMGetUeCb(cell, ueRecfg->oldCrnti)) == NULLP)
982 RGDBGERRNEW(inst,(rgPBuf(inst),
983 "[%d]Ue does not exist\n", ueRecfg->oldCrnti));
987 /* Initialize cfgCfmInfo in the ueCb. This is used while processing SCellAdd
989 ue->cfgCfmInfo.numSCells = ueRecfg->crgSCellCfg.numSCells;
990 ue->cfgCfmInfo.cfgCfgCount = 0;
991 ue->cfgCfmInfo.mask = 0x0;
993 cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
994 sizeof(CrgCfgTransId));
995 ueSCellCb.ueId = ueRecfg->oldCrnti;
996 ueSCellCb.txMode = ue->txMode;
997 ueSCellCb.maxUlHqRetx = ue->ul.hqEnt.maxHqRetx;
998 cmMemcpy((U8 *)ueSCellCb.ulLcInfo, (U8 *)ue->ul.lcCb, sizeof(ue->ul.lcCb));
999 cmMemcpy((U8 *)ueSCellCb.dlLcInfo, (U8 *)ue->dl.lcCb, sizeof(ue->dl.lcCb));
1000 for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
1002 ueSCellCb.lcgInfo[idx].lcgId = ue->ul.lcgArr[idx].lcgId;
1003 ueSCellCb.lcgInfo[idx].lcCount = ue->ul.lcgArr[idx].lcCount;
1004 ueSCellCb.lcgInfo[idx].isGbr = ue->ul.lcgArr[idx].isGbr;
1008 idx < ueRecfg->crgSCellCfg.numSCells; idx++)
1010 dstMacInst = ueRecfg->crgSCellCfg.ueSCellCfg[idx].macInst - RG_INST_START;
1011 ueSCellCb.cellId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].sCellId;
1012 ueSCellCb.rguDlSapId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].rguDlSapId;
1013 ueSCellCb.rguUlSapId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].rguUlSapId;
1015 /* Get post structure of the cell to whom ueSCellCb needs to be sent
1016 * And then send the sCell Add based on Mac instances */
1017 rgGetPstToInst(&dstInstPst, inst, dstMacInst);
1018 RgPrgPMacSMacUeSCellCfg(&dstInstPst, &ueSCellCb);
1020 /*Commit Added SCell info to UeCb is moved to config confirm*/
1021 } /*end of for loop */
1025 } /* rgFillAndAddSCellCfg */
1026 #endif /* LTE_ADV */
1029 * @brief Handler for the UE configuration request from RRC to MAC.
1033 * Function : rgCFGCrgUeCfg
1036 * - Allocate and create UE control block.
1037 * - Update UE control block with the values recieved in the
1039 * - Invoke RAM, SCH, UHM and DHM with created UE control block, to
1040 * update random access, scheduler, uplink harq and downlink harq
1041 * specific information respectively.
1042 * - If successful, add the control block to hash list of UEs for the cell
1043 * else Rollback and FAIL.
1045 * @param[in] Inst inst
1046 * @param[in] RgCellCb *cell
1047 * @param[in] CrgUeCfg *ueCfg
1048 * @param[out] RgErrInfo *errInfo
1054 PUBLIC S16 rgCFGCrgUeCfg
1062 PUBLIC S16 rgCFGCrgUeCfg(inst,cell, ueCfg, errInfo)
1070 Bool handover = FALSE;
1071 SuId rguUlSapId = 0;
1072 SuId rguDlSapId = 0;
1074 TRC2(rgCFGCrgUeCfg);
1076 errInfo->errCause = RGERR_CFG_CRG_UE_CFG;
1078 /* Start: LTEMAC_2.1_DEV_CFG */
1079 if ((ue = rgDBMGetUeCbFromRachLst(cell, ueCfg->crnti)) == NULLP)
1081 /* Create UeCb and Insert in Rach List */
1082 if((ue=rgRAMCreateUeCb(cell, ueCfg->crnti, FALSE, errInfo)) == NULLP)
1084 RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"UeCb creation failed");
1087 if(rgDHMHqEntInit(inst,&ue->dl.hqEnt, cell->maxDlHqProcPerUe) != ROK)
1089 RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"UeCb Harq Entity Initialization failed");
1094 /* End: LTEMAC_2.1_DEV_CFG */
1096 if(handover == FALSE)
1098 /* Remove from the rachLst */
1099 rgDBMDelUeCbFromRachLst(cell, ue);
1103 /* Initialize uplink HARQ related information for UE */
1104 rgUHMCrgUeCfg(cell, ue, ueCfg);
1106 rgDBMInsUeCb(cell, ue);
1108 #ifdef TENB_MULT_CELL_SUPPRT
1109 rguDlSapId = ueCfg->rguDlSapId;
1110 rguUlSapId = ueCfg->rguUlSapId;
1112 if(rgCb[inst].numRguSaps > 1)
1118 ue->rguDlSap = &(rgCb[inst].rguSap[rguDlSapId]);
1119 ue->rguUlSap = &(rgCb[inst].rguSap[rguUlSapId]);
1122 /* Update satistics */
1123 rgUpdtUeCnt(inst,RG_CFG_ADD);
1124 errInfo->errCause = RGERR_NONE;
1126 } /* rgCFGCrgUeCfg */
1130 * @brief Handler for the logical channel configuration request from
1135 * Function : rgCFGCrgLcCfg
1138 * - Check if the configuration is for dedicated or common logical channel.
1139 * - For Dedicated logical channels:
1140 * - Update the dedicated logical channel Cb with the configured values.
1141 * - Invoke SCH will cell, UE and logical channel Cb to update scheduler
1142 * specific information.
1143 * - For Common logical channels:
1144 * - Update the common logical channel Cb with the configured values.
1145 * - Move cell to active list of cells if cell becomes ACTIVE.
1146 * - If successful, return ROK else RFAILED.
1148 * @param[in] Inst inst
1149 * @param[in] RgCellCb *cell
1150 * @param[in] RgUeCb *ue
1151 * @param[in] CrgLchCfg *lcCfg
1152 * @param[out] RgErrInfo *errInfo
1153 * @param[in] Bool *isCfmRqrd
1159 PUBLIC S16 rgCFGCrgLcCfg
1167 CrgCfgTransId transId
1170 PUBLIC S16 rgCFGCrgLcCfg(inst,cell, ue, lcCfg, errInfo, isCfmRqrd,transId)
1177 CrgCfgTransId transId;
1181 TRC2(rgCFGCrgLcCfg);
1183 /* Handle Config for dedicated/common logical channels */
1184 if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
1187 if ((rgCFGCrgDedLcCfg(cell, ue, lcCfg, errInfo)) != ROK)
1189 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,
1190 "Dedicated logical channel configuration failed %d",lcCfg->lcId);
1194 /*ERAB Multl Cell fix*/
1195 cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
1196 sizeof(CrgCfgTransId));
1197 rgPomSndUeSCellLchAddToSmac(inst, cell, ue, lcCfg,isCfmRqrd);
1202 if ((rgCFGCrgCmnLcCfg(inst,cell, lcCfg, errInfo)) != ROK)
1204 RLOG_ARG1(L_ERROR, DBG_CRNTI, lcCfg->crnti, "Common logical channel configuration"
1205 "failed %d\n", lcCfg->lcId);
1210 errInfo->errCause = RGERR_NONE;
1211 RLOG_ARG1(L_INFO, DBG_CRNTI,lcCfg->crnti, "CRG LC config done for UE: lcId %d\n", lcCfg->lcId);
1213 } /* rgCFGCrgLcCfg */
1217 * @brief Handler for the cell re-configuration request from RRC to MAC.
1221 * Function : rgCFGCrgCellRecfg
1224 * - Invoke SCH with updated Cell Cb to update scheduler specific
1226 * - Update the cell Cb with the reconfigured values.
1227 * - If successful, return ROK else RFAILED.
1229 * @param[in] Inst inst
1230 * @param[in] RgCellCb *cell
1231 * @param[in] CrgCellRecfg *cellRecfg
1232 * @param[out] RgErrInfo *errInfo
1238 PUBLIC S16 rgCFGCrgCellRecfg
1242 CrgCellRecfg *cellRecfg,
1246 PUBLIC S16 rgCFGCrgCellRecfg(inst,cell, cellRecfg, errInfo)
1249 CrgCellRecfg *cellRecfg;
1253 TRC2(rgCFGCrgCellRecfg);
1255 /* Store the given rachCfg */
1256 cell->rachCfg = cellRecfg->rachRecfg;
1258 errInfo->errCause = RGERR_NONE;
1260 } /* rgCFGCrgCellRecfg */
1264 * @brief Handler for the UE re-configuration request from RRC to MAC.
1268 * Function : rgCFGCrgUeRecfg
1271 * - If rnti changes,
1272 * - Invoke RAM for UE reconfiguration.
1273 * - Delete old UE from the list.
1274 * - Update the new rnti and re-insert the UE in the list.
1275 * - Update the UE control block with the reconfigured values.
1276 * - Invoke SCH, UHM and DHM with updated UE control block to
1277 * update scheduler, uplink HARQ and downlink HARQ specific
1279 * - If successful, return ROK else RFAILED.
1281 * @param[in] Inst inst
1282 * @param[in] RgCellCb *cell
1283 * @param[in] RgUeCb *ue
1284 * @param[in] CrgUeRecfg *ueRecfg
1285 * @param[out] RgErrInfo *errInfo
1291 PUBLIC S16 rgCFGCrgUeRecfg
1296 CrgUeRecfg *ueRecfg,
1300 PUBLIC S16 rgCFGCrgUeRecfg(inst,cell, ue, ueRecfg, errInfo)
1304 CrgUeRecfg *ueRecfg;
1308 TRC2(rgCFGCrgUeRecfg);
1310 errInfo->errCause = RGERR_CFG_CRG_UE_RECFG;
1312 /* Fix : syed UE ID change at MAC will now be controlled
1315 /* Update uplink HARQ related information for UE */
1316 rgUHMCrgUeRecfg(cell, ue, ueRecfg);
1318 errInfo->errCause = RGERR_NONE;
1320 } /* rgCFGCrgUeRecfg */
1324 * @brief Handler for the logical channel re-configuration request from
1329 * Function : rgCFGCrgLcRecfg
1332 * - Invoke scheduler to update scheduler specific information.
1333 * - Update the dedicated logical channel Cb with the re-configured
1335 * - If successful, return ROK else RFAILED.
1337 * @param[in] Inst inst
1338 * @param[in] RgUlCellCb *cell
1339 * @param[in] RgUlUeCb *ue
1340 * @param[in] RgUlLcCb *ulLc
1341 * @param[in] RgDlLcCb *dlLc
1342 * @param[in] CrgLchRecfg *lcRecfg
1343 * @param[out] RgErrInfo *errInfo
1349 PUBLIC S16 rgCFGCrgLcRecfg
1355 CrgLchRecfg *lcRecfg,
1360 PUBLIC S16 rgCFGCrgLcRecfg(inst,cell, ue, ulLc, lcRecfg, errInfo, isCfmRqrd)
1365 CrgLchRecfg *lcRecfg;
1370 TRC2(rgCFGCrgLcRecfg);
1372 if (ulLc->lcgId != lcRecfg->ulRecfg.lcgId)
1374 rgDBMUpdUlDedLcCb(ue, ulLc, lcRecfg->ulRecfg.lcgId);
1376 rgPomSndUeSCellLchModToSmac(inst, cell, ue, lcRecfg,isCfmRqrd);
1380 errInfo->errCause = RGERR_NONE;
1382 } /* rgCFGCrgLcRecfg */
1384 /* Start: LTEMAC_2.1_DEV_CFG */
1386 * @brief Handler for the logical channel re-configuration request from
1391 * Function : rgCFGCrgUeReset
1395 * @param[in] RgUlCellCb *cell
1396 * @param[in] RgUlUeCb *ue
1397 * @param[in] CrgRst *reset
1398 * @param[out] RgErrInfo *errInfo
1404 PUBLIC S16 rgCFGCrgUeReset
1412 PUBLIC S16 rgCFGCrgUeReset(cell, ue, reset, errInfo)
1419 TRC2(rgCFGCrgUeReset);
1421 RLOG_ARG1(L_DEBUG, DBG_CRNTI, ue->ueId, "UE: of cell %d Reset\n", cell->cellId);
1422 rgDHMUeReset(cell, &ue->dl.hqEnt);
1424 errInfo->errCause = RGERR_NONE;
1427 } /* rgCFGCrgUeReset */
1428 /* End: LTEMAC_2.1_DEV_CFG */
1431 * @brief Handler for the cell delete request from RRC to MAC.
1435 * Function : rgCFGCrgCellDel
1438 * - Fetch the cell control block.
1439 * - Remove the cell control block from the hash list of cells.
1440 * - Free the cell control block.
1441 * - If successful, return ROK else return RFAILED.
1443 * @param[in] Inst inst
1444 * @param[in] CrgDel *cellDelInfo
1445 * @param[out] RgErrInfo *errInfo
1451 PUBLIC S16 rgCFGCrgCellDel
1454 CrgDel *cellDelInfo,
1458 PUBLIC S16 rgCFGCrgCellDel(inst,cellDelInfo, errInfo)
1460 CrgDel *cellDelInfo;
1467 TRC2(rgCFGCrgCellDel);
1469 errInfo->errCause = RGERR_CFG_CRG_CELL_DEL;
1470 if (((cell = rgCb[inst].cell) == NULLP)
1471 ||(cell->cellId != cellDelInfo->u.cellDel.cellId))
1473 if(((cell = rgCb[inst].inactiveCell) == NULLP)
1474 ||(cell->cellId != cellDelInfo->u.cellDel.cellId))
1478 RLOG_ARG0(L_ERROR,DBG_CELLID,cellDelInfo->u.cellDel.cellId,"Cell does not exist");
1482 /* Delete cell from inactive list */
1483 rgCb[inst].inactiveCell = NULLP ;
1485 /* Free the inactive cell */
1486 rgCFGFreeInactvCellCb(cell);
1488 errInfo->errCause = RGERR_NONE;
1492 /* Delete from the cell list */
1493 //rgDBMDelCellCb(cell);
1494 for(idx=0;idx < RG_NUM_SUB_FRAMES; idx++)
1496 rgTOMRlsSf(inst,&cell->subFrms[idx]);
1499 /* Free the active cell */
1500 rgCFGFreeCellCb(cell);
1502 rgCb[inst].cell = NULLP;
1504 errInfo->errCause = RGERR_NONE;
1505 RGDBGINFO(inst,(rgPBuf(inst), "Cell %d deleted\n", cellDelInfo->u.cellDel.cellId));
1507 } /* rgCFGCrgCellDel */
1511 * @brief Handler for the UE delete request from RRC to MAC.
1515 * Function : rgCFGCrgUeDel
1518 * - Fetch the UE control block.
1519 * - Remove the UE control block from the hash list of UEs for the cell.
1520 * - Free the UE control block.
1521 * - If successful, return ROK else return RFAILED.
1523 * @param[in] Inst inst
1524 * @param[in] CrgDel *ueDelInfo
1525 * @param[out] RgErrInfo *errInfo
1531 PUBLIC S16 rgCFGCrgUeDel
1538 PUBLIC S16 rgCFGCrgUeDel(inst,ueDelInfo, errInfo)
1544 TRC2(rgCFGCrgUeDel);
1546 errInfo->errCause = RGERR_CFG_CRG_UE_DEL;
1548 RLOG_ARG1(L_DEBUG, DBG_CRNTI, ueDelInfo->u.ueDel.crnti, "UE %d Deletion Req at MAC\n", \
1549 ueDelInfo->u.ueDel.crnti);
1550 if ((rgCb[inst].cell == NULLP)
1551 || (rgCb[inst].cell->cellId != ueDelInfo->u.ueDel.cellId))
1553 RLOG_ARG1(L_ERROR,DBG_CRNTI,ueDelInfo->u.ueDel.crnti,"Cell does not exist %d",
1554 ueDelInfo->u.ueDel.cellId);
1558 errInfo->errCause = RGERR_NONE;
1559 /* Fix: syed Context Deletion is relied upon SCH indication */
1561 } /* rgCFGCrgUeDel */
1565 * @brief Handler for the logical channel delete request from
1570 * Function : rgCFGCrgLcDel
1573 * - Fetch the logical channel control block.
1574 * - Free the logical channel control block.
1575 * - If successful, return ROK else return RFAILED.
1577 * @param[in] Inst inst
1578 * @param[in] CrgDel *lcDelInfo
1579 * @param[out] RgErrInfo *errInfo
1585 PUBLIC S16 rgCFGCrgLcDel
1591 CrgCfgTransId transId
1594 PUBLIC S16 rgCFGCrgLcDel(inst,lcDelInfo, errInfo,isCfmRqrd,transId)
1598 CrgCfgTransId transId;
1601 Bool dirVld = FALSE;
1607 TRC2(rgCFGCrgLcDel);
1609 errInfo->errCause = RGERR_CFG_CRG_LC_DEL;
1611 /* Fetch the Active cell */
1612 if (((cell = rgCb[inst].cell) == NULLP) ||
1613 (rgCb[inst].cell->cellId != lcDelInfo->u.lchDel.cellId))
1615 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"Cell does not exist %d",
1616 lcDelInfo->u.lchDel.cellId);
1621 if ((ue = rgDBMGetUeCb(cell, lcDelInfo->u.lchDel.crnti)) == NULLP)
1623 RLOG_ARG0(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,
1624 "UE does not exist for dedicated logical channel");
1628 /* Validate downlink info */
1629 if (lcDelInfo->u.lchDel.dir & CRG_DIR_TX)
1631 if ((dlLc = rgDBMGetDlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
1634 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"DL LC %d does not exist",
1635 lcDelInfo->u.lchDel.lcId);
1638 rgDBMDelDlDedLcCb(ue, dlLc);
1642 /* Validate uplink info */
1643 if (lcDelInfo->u.lchDel.dir & CRG_DIR_RX)
1645 if ((ulLc = rgDBMGetUlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
1648 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"UL LC %d does not exist",
1649 lcDelInfo->u.lchDel.lcId);
1652 rgDBMDelUlDedLcCb(ue, ulLc);
1658 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"Invalid direction %d for LC Delete",
1659 lcDelInfo->u.lchDel.dir);
1663 /*ERAB - multicell fix*/
1664 cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
1665 sizeof(CrgCfgTransId));
1666 rgPomSndUeSCellLchDelToSmac(inst, lcDelInfo, isCfmRqrd);
1668 errInfo->errCause = RGERR_NONE;
1670 } /* rgCFGCrgLcDel */
1672 /***********************************************************
1674 * Func : rgCFGVldtCrgDedLcCfg
1677 * Desc : Validates dedicated logical channel configuration recieved from RRC.
1687 **********************************************************/
1689 PRIVATE S16 rgCFGVldtCrgDedLcCfg
1698 PRIVATE S16 rgCFGVldtCrgDedLcCfg(inst,lcCfg, cell, ue, errInfo)
1707 TRC2(rgCFGVldtCrgDedLcCfg);
1709 errInfo->errCause = RGERR_CFG_INVALID_CRG_DED_LC_CFG;
1711 /* Fetch the Active cell */
1712 if (((*cell = rgCb[inst].cell) == NULLP)
1713 || ((*cell)->cellId != lcCfg->cellId))
1715 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Active Cell does not exist: Cell %d",
1721 if ((*ue = rgDBMGetUeCb(*cell, lcCfg->crnti)) == NULLP)
1723 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE does not exist for dedicated logical channel %d",
1728 /* Validate logical channel Id */
1729 if ((lcCfg->lcId < RG_DEDLC_MIN_LCID)
1730 ||(lcCfg->lcId > RG_DEDLC_MAX_LCID))
1732 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid logical channel Id %d",
1737 /* Validate downlink info */
1738 if (lcCfg->dir & CRG_DIR_TX)
1740 if (rgDBMGetDlDedLcCb((*ue), lcCfg->lcId) != NULLP)
1742 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Dedicated DL LC %d already configured",
1749 /* Validate uplink info */
1750 if (lcCfg->dir & CRG_DIR_RX)
1752 if (lcCfg->ulInfo.lcgId > (RG_MAX_LCG_PER_UE - 1))
1754 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Invalid lcgId for uplink logical channel %d",
1755 lcCfg->ulInfo.lcgId);
1758 if (rgDBMGetUlDedLcCb((*ue), lcCfg->lcId) != NULLP)
1760 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Dedicated UL LC %d already configured",
1769 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid Direction %d",
1775 } /* rgCFGVldtCrgDedLcCfg */
1778 /***********************************************************
1780 * Func : rgCFGVldtCrgCmnLcCfg
1783 * Desc : Validates common logical channel configuration recieved from RRC.
1793 **********************************************************/
1795 PRIVATE S16 rgCFGVldtCrgCmnLcCfg
1803 PRIVATE S16 rgCFGVldtCrgCmnLcCfg(inst,lcCfg, cell, errInfo)
1812 TRC2(rgCFGVldtCrgCmnLcCfg);
1814 errInfo->errCause = RGERR_CFG_INVALID_CRG_CMN_LC_CFG;
1816 /* Ensure cell is not in the active list */
1817 if (((*cell = rgCb[inst].cell) != NULLP)
1818 && ((*cell)->cellId != lcCfg->cellId))
1820 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"Active Cell exists for common channels");
1824 /* Fetch the inactive cell for common logical channels */
1825 if (((*cell = rgCb[inst].inactiveCell) == NULLP)
1826 || ((*cell)->cellId != lcCfg->cellId))
1829 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"Inactive Cell does not exist for common channels");
1832 /* Validate downlink info */
1833 if (lcCfg->dir & CRG_DIR_TX)
1835 if (lcCfg->lcType == CM_LTE_LCH_BCCH)
1837 if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_DL_SCH)
1839 if (rgDBMGetBcchOnDlsch(*cell,lcCfg->lcId) != NULLP)
1841 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"BCCH on DLSCH already configured for cell");
1845 else if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_BCH)
1847 if (rgDBMGetBcchOnBch(*cell) != NULLP)
1849 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"BCCH on BCH already configured for cell %d");
1855 RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid transport channel %d for cell",
1856 lcCfg->dlInfo.dlTrchType);
1860 else if (lcCfg->lcType == CM_LTE_LCH_PCCH)
1862 if (rgDBMGetPcch(*cell) != NULLP)
1864 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"PCCH already configured for cell");
1868 else if (RG_DLCCCH_ISCFGD(*cell))
1870 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"DL CCCH already configured for cell %d");
1876 /* Validate uplink info */
1877 if (lcCfg->dir & CRG_DIR_RX)
1880 if (lcCfg->lcType != CM_LTE_LCH_CCCH)
1882 RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid UL common lcType %d for cell ",
1886 if (RG_ULCCCH_ISCFGD(*cell))
1888 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"UL CCCH already configured for cell ");
1894 /* Invalid direction */
1897 RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid Direction %d", lcCfg->dir);
1902 } /* rgCFGVldtCrgCmnLcCfg */
1904 /***********************************************************
1906 * Func : rgCFGCrgDedLcCfg
1909 * Desc : Handles dedicated logical channel configuration
1910 * recieved from RRC.
1920 **********************************************************/
1922 PRIVATE S16 rgCFGCrgDedLcCfg
1930 PRIVATE S16 rgCFGCrgDedLcCfg(cell, ue, lcCfg, errInfo)
1937 //Inst inst = cell->macInst - RG_INST_START;
1938 TRC2(rgCFGCrgDedLcCfg);
1940 errInfo->errCause = RGERR_CFG_CRG_DED_LC_CFG;
1942 /* Uplink/Bi-directional logical channel */
1943 if (lcCfg->dir & CRG_DIR_RX)
1946 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId, lcCfg->qci);
1947 cell->qciArray[lcCfg->qci].qci = lcCfg->qci;
1948 if(lcCfg->lcType == CM_LTE_LCH_DTCH)
1950 rgAddToL2MeasPerQci(cell,lcCfg->qci);/*LTE_L2_MEAS_PHASE2*/
1953 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId);
1957 /* Downlink/Bi-directional logical channel */
1958 if (lcCfg->dir & CRG_DIR_TX)
1960 rgDBMInsDlDedLcCb(ue, lcCfg->lcId);
1963 } /* rgCFGCrgDedLcCfg */
1966 /***********************************************************
1968 * Func : rgCFGCrgCmnLcCfg
1971 * Desc : Handles dedicated logical channel configuration
1972 * recieved from RRC.
1982 **********************************************************/
1984 PRIVATE S16 rgCFGCrgCmnLcCfg
1992 PRIVATE S16 rgCFGCrgCmnLcCfg(inst,cell, lcCfg, errInfo)
1999 TRC2(rgCFGCrgCmnLcCfg);
2001 errInfo->errCause = RGERR_CFG_CRG_CMN_LC_CFG;
2003 /* Handle configuration for CCCH/BCCH/PCCH */
2004 if (lcCfg->lcType == CM_LTE_LCH_CCCH)
2006 /* UL and DL CCCH configuration */
2007 if (lcCfg->dir & CRG_DIR_TX)
2009 cell->dlCcchId = lcCfg->lcId;
2010 cell->cellActvState |= RG_DL_CCCH_CFG_DONE;
2013 if (lcCfg->dir & CRG_DIR_RX)
2015 cell->ulCcchId = lcCfg->lcId;
2016 cell->cellActvState |= RG_UL_CCCH_CFG_DONE;
2021 if (lcCfg->lcType == CM_LTE_LCH_BCCH)
2023 /* BCCH on BCH and DLSCH configuration */
2024 if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_DL_SCH)
2026 rgDBMInsBcchOnDlsch(cell, lcCfg->lcId);
2028 if(cell->cellActvState & RG_BCCH_DLSCH_CFG1_DONE)
2030 cell->cellActvState |= RG_BCCH_DLSCH_CFG2_DONE;
2034 cell->cellActvState |= RG_BCCH_DLSCH_CFG1_DONE;
2039 rgDBMInsBcchOnBch(cell, lcCfg->lcId);
2040 cell->cellActvState |= RG_BCCH_BCH_CFG_DONE;
2043 else /* PCCH configuration */
2045 rgDBMInsPcch(cell, lcCfg->lcId);
2046 cell->cellActvState |= RG_PCCH_CFG_DONE;
2050 /* Add to active cell list if cell is active */
2051 if (cell->cellActvState == RG_CELL_ACTIVE)
2053 rgCb[inst].cell = cell;
2054 rgCb[inst].inactiveCell = NULLP;
2055 RLOG_ARG1(L_DEBUG, DBG_CELLID, cell->cellId, "Cell %d added to active list after common LC %d\
2056 config\n", lcCfg->lcId);
2060 } /* rgCFGCrgCmnLcCfg */
2062 /***********************************************************
2064 * Func : rgCFGFreeUeUlAlloc
2068 * - Processing Steps:
2069 * - Frees cell control block.
2077 **********************************************************/
2079 PRIVATE Void rgCFGFreeUeUlAlloc
2084 PRIVATE Void rgCFGFreeUeUlAlloc(cell)
2089 Inst inst = cell->macInst - RG_INST_START;
2091 TRC2(rgCFGFreeUeUlAlloc);
2093 for(sfIdx = 0; sfIdx < RG_NUM_UL_SUB_FRAMES; sfIdx++)
2095 if(cell->ulSf[sfIdx].ueUlAllocInfo != NULLP)
2097 /*ccpu00117052 - MOD- Passing double pointer for proper
2098 * NULLP assignment */
2099 rgFreeSBuf(inst,(Data **)&(cell->ulSf[sfIdx].ueUlAllocInfo),
2100 (cell->ulSf[sfIdx].numUe * sizeof(RgUeUlAlloc)));
2103 }/* rgCFGFreeUeUlAlloc */
2105 /***********************************************************
2107 * Func : rgCFGFreeCellCb
2111 * - Processing Steps:
2112 * - Frees cell control block.
2120 **********************************************************/
2122 PUBLIC Void rgCFGFreeCellCb
2127 PUBLIC Void rgCFGFreeCellCb(cell)
2131 Inst inst = cell->macInst - RG_INST_START;
2132 TRC2(rgCFGFreeCellCb);
2135 RgLaaCellCbDeInit(cell);
2137 /* Free lists of the cell */
2139 rgCFGFreeSpsUeLst(cell);
2140 #endif /* LTEMAC_SPS */
2141 rgCFGFreeUeLst(cell);
2142 rgRAMFreeCell(cell);
2143 rgCFGFreeCmnLcLst(cell);
2145 rgCFGFreeUeUlAlloc(cell);
2147 /* ccpu00117052 - MOD - Passing double pointer for proper NULLP
2149 /* Update satistics */
2150 rgUpdtCellCnt(inst,RG_CFG_DEL);
2151 rgDHMFreeAllTbBufs(inst);
2153 rgFreeSBuf(inst,(Data **)&cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
2155 /* De-allocate the Cell */
2156 rgFreeSBuf(inst,(Data **)&cell, sizeof(*cell));
2159 RGDBGINFO(inst,(rgPBuf(inst), "Cell freed\n"));
2161 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2163 } /* rgCFGFreeCellCb */
2166 /***********************************************************
2168 * Func : rgCFGFreeInactvCellCb
2172 * - Processing Steps:
2173 * - Frees inactive cell control block.
2181 **********************************************************/
2183 PUBLIC Void rgCFGFreeInactvCellCb
2188 PUBLIC Void rgCFGFreeInactvCellCb(cell)
2192 Inst inst = cell->macInst - RG_INST_START;
2193 TRC2(rgCFGFreeInactvCellCb);
2195 /* De-initialize the Ue list */
2196 rgDBMDeInitUeCbLst(cell);
2198 rgDBMDeInitSpsUeCbLst(cell);
2201 rgCFGFreeCmnLcLst(cell);
2203 rgFreeSBuf(inst, (Data **)&cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
2204 /*ccpu00117052 - MOD- Passing double pointer for proper
2206 /* De-allocate the Cell */
2207 rgFreeSBuf(inst,(Data **)&cell, sizeof(*cell));
2209 /* Update satistics */
2210 rgUpdtCellCnt(inst,RG_CFG_DEL);
2213 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2215 } /* rgCFGFreeInactvCellCb */
2218 /***********************************************************
2220 * Func : rgCFGFreeUeCb
2224 * - Processing Steps:
2225 * - Frees UE control block.
2233 **********************************************************/
2235 PUBLIC Void rgCFGFreeUeCb
2241 PUBLIC Void rgCFGFreeUeCb(cell, ue)
2246 Inst inst = cell->macInst - RG_INST_START;
2248 TRC2(rgCFGFreeUeCb);
2250 rgDHMFreeUe(inst,&ue->dl.hqEnt);
2252 /* ccpu00117052 - MOD - Passing double pointer for proper NULLP
2254 /* De-allocate the Ue */
2255 rgFreeSBuf(inst,(Data **)&ue, sizeof(*ue));
2257 /* Update Statistics */
2258 rgUpdtUeCnt(inst,RG_CFG_DEL);
2261 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2263 } /* rgCFGFreeUeCb */
2265 /***********************************************************
2267 * Func : rgCFGFreeCmnLcLst
2271 * - Processing Steps:
2272 * - Frees common logical channels in cell control block.
2280 **********************************************************/
2282 PRIVATE Void rgCFGFreeCmnLcLst
2287 PRIVATE Void rgCFGFreeCmnLcLst(cell)
2291 TRC2(rgCFGFreeCmnLcLst);
2293 rgDBMFreeCmnLcLst(cell);
2296 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2298 } /* rgCFGFreeCmnLcLst */
2301 /***********************************************************
2303 * Func : rgCFGFreeUeLst
2307 * - Processing Steps:
2308 * - Frees UE list in cell control block.
2316 **********************************************************/
2318 PRIVATE Void rgCFGFreeUeLst
2323 PRIVATE Void rgCFGFreeUeLst(cell)
2329 TRC2(rgCFGFreeUeLst);
2331 /* Free Ues in the list */
2332 while ((ue = rgDBMGetNextUeCb(cell, NULLP)) != NULLP)
2335 rgDelUeFrmAllSCell(cell,ue);
2337 rgDBMDelUeCb(cell, ue);
2338 rgCFGFreeUeCb(cell, ue);
2341 /* De-initialize the Ue list */
2342 rgDBMDeInitUeCbLst(cell);
2345 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2347 } /* rgCFGFreeUeLst */
2350 /***********************************************************
2352 * Func : rgCFGFreeSpsUeLst
2356 * - Processing Steps:
2357 * - Frees Sps UE list in cell control block.
2365 **********************************************************/
2367 PRIVATE Void rgCFGFreeSpsUeLst
2372 PRIVATE Void rgCFGFreeSpsUeLst(cell)
2378 TRC2(rgCFGFreeSpsUeLst);
2380 /* Free Ues in the list */
2381 while ((ue = rgDBMGetNextSpsUeCb(cell, NULLP)))
2383 rgDBMDelSpsUeCb(cell, ue);
2386 /* De-initialize the Ue list */
2387 rgDBMDeInitSpsUeCbLst(cell);
2389 } /* rgCFGFreeSpsUeLst */
2391 #endif /* LTEMAC_SPS */
2394 * @brief Function for registering cell- scheduler instance mapping
2398 * Function : RgSchMacCellRegReq
2400 * This function shall be invoked whenever scheduler is done with the
2401 * cell configuration successfully.
2402 * This shall create a mapping of the cell, scheduler instance that
2403 * is serving the cell and the unique identifier of the cell on the
2404 * scheduler at MAC. This mapping shall be used for further
2405 * communication to the scheduler instance for this cell.
2408 * @param[in] Pst* pst,
2409 * @param[in] CmLteCellId cellId,
2410 * @param[in] RaRespReqInfo raRespReq
2415 PUBLIC S16 RgSchMacCellRegReq
2418 RgInfCellReg* regReq
2421 PUBLIC S16 RgSchMacCellRegReq(pst, regReq)
2423 RgInfCellReg* regReq;
2427 RgCellCb *cell = NULLP;
2429 TRC3(RgSchMacCellRegReq)
2431 RG_IS_INST_VALID(pst->dstInst);
2432 inst = pst->dstInst - RG_INST_START;
2433 cell = rgCb[inst].cell;
2440 if((cell == NULLP) || (cell->cellId != regReq->cellId))
2444 if(regReq->maxDlHqProcPerUe > RG_MAX_DL_HARQ_NUM)
2449 cell->schInstMap.cellSapId = regReq->cellSapId;
2450 cell->schInstMap.schInst = pst->srcInst;
2451 cell->maxDlHqProcPerUe = regReq->maxDlHqProcPerUe;
2455 } /* end of RgSchMacCellRegReq */
2457 /*Added Ue for Onging L2 Meas*/
2459 /*LTE_L2_MEAS_PHASE2*/
2460 PUBLIC S16 rgAddToL2MeasPerQci(RgCellCb *cell,U8 qci)
2467 lnk = cell->l2mList.first;
2468 while(lnk != NULLP )
2470 measCb = (RgL2MeasCb *)lnk->node;
2471 if(measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
2473 for(idx = 0;idx< measCb->measReq.t.prbReq.numQci;idx++)
2475 if(measCb->measReq.t.prbReq.qci[idx] == qci)
2477 break; /*exit from for loop*/
2480 if(idx == measCb->measReq.t.prbReq.numQci)
2482 cell->qciArray[qci].mask = TRUE;
2483 measCb->measReq.t.prbReq.qci[measCb->measReq.t.prbReq.numQci++] = qci;
2497 /**********************************************************************
2500 **********************************************************************/