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 "common_def.h"
41 #include "lrg.h" /* Layer manager interface includes*/
42 #include "crg.h" /* CRG interface includes*/
43 #include "rgu.h" /* RGU interface includes*/
44 #include "tfu.h" /* TFU interface includes */
45 #include "rg_sch_inf.h" /* SCH interface includes */
46 #include "rg_prg.h" /* PRG (MAC-MAC) interface includes*/
47 #include "rg_env.h" /* MAC environmental includes*/
48 #include "rg.h" /* MAC includes*/
49 #include "rg_err.h" /* MAC error includes*/
51 /* header/extern include files (.x) */
52 #include "rgu.x" /* RGU types */
53 #include "tfu.x" /* RGU types */
54 #include "lrg.x" /* layer management typedefs for MAC */
55 #include "crg.x" /* CRG interface includes */
56 #include "rg_sch_inf.x" /* SCH interface typedefs */
57 #include "rg_prg.x" /* PRG (MAC-MAC) Interface typedefs */
58 #include "du_app_mac_inf.h"
59 #include "rg.x" /* typedefs for MAC */
61 #include "rg_pom_scell.x"
63 /* LTE-MAC Control Block Structure */
64 RgCb rgCb[RG_MAX_INST];
67 PRIVATE S16 rgCFGVldtCrgDedLcCfg ARGS((Inst inst,CrgLchCfg *lcCfg, RgCellCb **cell,
68 RgUeCb **ue, RgErrInfo *errInfo));
69 PRIVATE S16 rgCFGVldtCrgCmnLcCfg ARGS((Inst inst,CrgLchCfg *lcCfg, RgCellCb **cell,
71 PRIVATE S16 rgCFGCrgDedLcCfg ARGS((RgCellCb *cell, RgUeCb *ue,
72 CrgLchCfg *lcCfg, RgErrInfo *errInfo));
73 PRIVATE S16 rgCFGCrgCmnLcCfg ARGS((Inst inst,RgCellCb *cell, CrgLchCfg *lcCfg,
76 PRIVATE Void rgCFGFreeCmnLcLst ARGS((RgCellCb *cell));
77 PRIVATE Void rgCFGFreeUeLst ARGS((RgCellCb *cell));
78 /* Added support for SPS*/
80 PRIVATE Void rgCFGFreeSpsUeLst ARGS((RgCellCb *cell));
81 #endif /* LTEMAC_SPS */
88 /* forward references */
94 * @brief Validates the cell configuration request from RRC to MAC.
98 * Function : rgCFGVldtCrgCellCfg
101 * - Validate the cell configuration request from RRC to MAC at CFG:
102 * validate the value range for the configured values.
103 * - If validated successfully,
108 * @param[in] Inst inst
109 * @param[in] CrgCellCfg *cellCfg
110 * @param[out] RgErrInfo *errInfo
116 S16 rgCFGVldtCrgCellCfg
123 S16 rgCFGVldtCrgCellCfg(inst,cellCfg, errInfo)
129 errInfo->errCause = RGERR_CFG_INVALID_CRG_CELL_CFG;
130 if ((rgCb[inst].cell != NULLP)
131 || rgCb[inst].inactiveCell != NULLP)
133 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Cell already exists");
136 if ((cellCfg->bwCfg.dlTotalBw < RG_MIN_DL_BW
137 || cellCfg->bwCfg.dlTotalBw > RG_MAX_DL_BW)
138 || (cellCfg->bwCfg.ulTotalBw < RG_MIN_UL_BW
139 || cellCfg->bwCfg.ulTotalBw > RG_MAX_UL_BW))
141 RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId,
142 "Invalid Bandwidth configuration: ul %d dl %d",
143 cellCfg->bwCfg.ulTotalBw, cellCfg->bwCfg.dlTotalBw);
146 if (cellCfg->rachCfg.maxMsg3Tx < RG_MIN_HQ_TX)
148 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,
149 "Invalid RACH configuration: maxMsg3Tx %d",cellCfg->rachCfg.maxMsg3Tx);
152 #ifdef TENB_MULT_CELL_SUPPRT
153 if((cellCfg->rguDlSapId > rgCb[inst].numRguSaps) ||
154 (cellCfg->rguUlSapId > rgCb[inst].numRguSaps))
156 RGDBGERRNEW(inst,(rgPBuf(inst), "Invald Sap Id: DL %d UL %d for CellId %d failed\n",
163 errInfo->errCause = RGERR_NONE;
165 } /* rgCFGVldtCrgCellCfg */
169 * @brief Validates the UE configuration request from RRC to MAC.
173 * Function : rgCFGVldtCrgUeCfg
176 * - Validate the UE configuration request from RRC to MAC at CFG:
177 * validate the value range for the configured values.
178 * - If validated successfully,
179 * - Return ROK and pointer to the cell of UE.
183 * @param[in] Inst inst
184 * @param[in] CrgUeCfg *ueCfg
185 * @param[out] RgCellCb **cell
186 * @param[out] RgErrInfo *errInfo
192 S16 rgCFGVldtCrgUeCfg
200 S16 rgCFGVldtCrgUeCfg(inst,ueCfg, cell, errInfo)
207 errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_CFG;
208 if ((ueCfg->txMode.pres == PRSNT_NODEF) &&
209 (ueCfg->txMode.tm == CRG_UE_TM_5))
211 RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Transmission Mode=%d not supported",
216 /* Fetch the Active cell */
217 if(((*cell = rgCb[inst].cell) == NULLP) ||
218 ((*cell)->cellId != ueCfg->cellId))
220 RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Active Cell does not exist for cellId%d",
224 /* Check if Ue already configured */
225 if (rgDBMGetUeCb(*cell, ueCfg->crnti) != NULLP)
227 RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Ue already exists");
231 if (ueCfg->ueUlHqCfg.maxUlHqTx < RG_MIN_HQ_TX)
233 RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti, "Invalid Uplink HARQ config %d ",
234 ueCfg->ueUlHqCfg.maxUlHqTx);
237 #ifdef TENB_MULT_CELL_SUPPRT
238 if((ueCfg->rguDlSapId > rgCb[inst].numRguSaps) ||
239 (ueCfg->rguUlSapId > rgCb[inst].numRguSaps))
241 RGDBGERRNEW(inst,(rgPBuf(inst), "Invald Sap Id: DL %d UL %d for ueId %d failed\n",
249 errInfo->errCause = RGERR_NONE;
251 } /* rgCFGVldtCrgUeCfg */
255 * @brief Validates the logical channel configuration request from RRC to MAC.
259 * Function : rgCFGVldtCrgLcCfg
262 * - Validate the logical channel configuration request from RRC to
263 * MAC at CFG: validate if configured values are within the range.
264 * - If validated successfully,
265 * - Return ROK and pointer to the cell for common channels. Return
266 * pointer to cell and UE for dedicated logical channels.
270 * @param[in] CrgLchCfg *lcCfg
271 * @param[in] Inst inst
272 * @param[out] RgCellCb **cell
273 * @param[out] RgUeCb **ue
274 * @param[out] RgErrInfo *errInfo
280 S16 rgCFGVldtCrgLcCfg
289 S16 rgCFGVldtCrgLcCfg(inst,lcCfg, cell, ue, errInfo)
298 if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
300 /* Dedicated logical channels */
301 if ((rgCFGVldtCrgDedLcCfg(inst,lcCfg, cell, ue, errInfo)) != ROK)
303 RLOG_ARG0(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Validation for dedicated LC failed");
307 else if (lcCfg->lcType == CM_LTE_LCH_BCCH
308 || lcCfg->lcType == CM_LTE_LCH_PCCH
309 || lcCfg->lcType == CM_LTE_LCH_CCCH)
311 if ((rgCFGVldtCrgCmnLcCfg(inst,lcCfg, cell, errInfo)) != ROK)
313 RLOG_ARG0(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Validation for common logical channels failed");
319 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid logical channel type %d",
324 if ( lcCfg->qci < RG_QCI_MIN ||
325 lcCfg->qci > RG_QCI_MAX
328 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid qci %x",lcCfg->qci);
332 #endif /*LTE_L2_MEAS */
334 errInfo->errCause = RGERR_NONE;
336 } /* rgCFGVldtCrgLcCfg */
340 * @brief Validates the cell re-configuration request from RRC to MAC.
344 * Function : rgCFGVldtCrgCellRecfg
347 * - Retrieve the cell control block.
349 * - Validate the range of re-configured values recieved in
350 * re-configuration request.
351 * - If validated successfully,
352 * - Return ROK and pointer to the cell.
355 * - Else return RFAILED.
357 * @param[in] Inst inst
358 * @param[in] CrgCellRecfg *cellRecfg
359 * @param[out] RgCellCb **cell
360 * @param[out] RgErrInfo *errInfo
366 S16 rgCFGVldtCrgCellRecfg
369 CrgCellRecfg *cellRecfg,
374 S16 rgCFGVldtCrgCellRecfg(inst,cellRecfg, cell, errInfo)
376 CrgCellRecfg *cellRecfg;
381 errInfo->errCause = RGERR_CFG_INVALID_CRG_CELL_RECFG;
383 if (((*cell = rgCb[inst].cell) == NULLP)
384 && ((*cell = rgCb[inst].inactiveCell) == NULLP))
386 RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Cell does not exist");
390 if((*cell)->cellId != cellRecfg->cellId)
392 RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId, "Cell does not exist %d\n",cellRecfg->cellId);
395 if (cellRecfg->rachRecfg.maxMsg3Tx < RG_MIN_HQ_TX)
397 RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId,
398 "Invalid RACH configuration: maxMsg3Tx %d",cellRecfg->rachRecfg.maxMsg3Tx);
401 errInfo->errCause = RGERR_NONE;
403 } /* rgCFGVldtCrgCellRecfg */
407 * @brief Validates the UE re-configuration request from RRC to MAC.
411 * Function : rgCFGVldtCrgUeRecfg
414 * - Retrieve the UE control block.
416 * - Validate the range of re-configured values recieved in
417 * re-configuration request.
418 * - If validated successfully,
419 * - Return ROK and pointer to the cell and ue.
422 * - Else return RFAILED.
424 * @param[in] Inst inst
425 * @param[in] CrgUeRecfg *ueRecfg
426 * @param[out] RgCellCb **cell
427 * @param[out] RgUeCb **ue
428 * @param[out] RgErrInfo *errInfo
434 S16 rgCFGVldtCrgUeRecfg
443 S16 rgCFGVldtCrgUeRecfg(inst,ueRecfg, cell, ue, errInfo)
451 errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_RECFG;
453 if ((ueRecfg->txMode.pres == PRSNT_NODEF) &&
454 (ueRecfg->txMode.tm == CRG_UE_TM_5))
456 RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Transmission Mode=%d not supported",
461 /* Fetch the Active cell */
462 if (((*cell = rgCb[inst].cell) == NULLP)
463 || ((*cell)->cellId != ueRecfg->cellId))
465 RLOG_ARG0(L_ERROR,DBG_CELLID,ueRecfg->cellId, "Active Cell does not exist\n");
469 /* Fix : syed UE ID change at MAC will now be controlled
471 if ((*ue = rgDBMGetUeCb(*cell, ueRecfg->oldCrnti)) == NULLP)
473 RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"[%d]Old Ue does not exist", ueRecfg->oldCrnti);
476 if (ueRecfg->ueUlHqRecfg.maxUlHqTx < RG_MIN_HQ_TX)
478 RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid Uplink HARQ config for UE %d",
479 ueRecfg->ueUlHqRecfg.maxUlHqTx);
482 errInfo->errCause = RGERR_NONE;
484 } /* rgCFGVldtCrgUeRecfg */
488 * @brief Validates the logical channel re-configuration request from
493 * Function : rgCFGVldtCrgLcRecfg
496 * - Retrieve the uplink and downlink logical channel control block.
498 * - Validate the range of re-configured values recieved in
499 * re-configuration request.
500 * - If validated successfully,
501 * - Return ROK and pointer to the cell, UE and logical channel.
504 * - Else return RFAILED.
506 * @param[in] Inst inst
507 * @param[in] CrgLchRecfg *lcRecfg
508 * @param[out] RgCellCb **cell
509 * @param[out] RgUeCb **ue
510 * @param[out] RgUlLcCb **ulLc
511 * @param[out] RgDlLcCb **dlLc
512 * @param[out] RgErrInfo *errInfo
518 S16 rgCFGVldtCrgLcRecfg
521 CrgLchRecfg *lcRecfg,
528 S16 rgCFGVldtCrgLcRecfg(inst,lcRecfg, cell, ue, ulLc, errInfo)
530 CrgLchRecfg *lcRecfg;
537 errInfo->errCause = RGERR_CFG_INVALID_CRG_LC_RECFG;
540 if ((((*cell = rgCb[inst].cell)) == NULLP)
541 || ((*cell)->cellId != lcRecfg->cellId))
543 RLOG_ARG2(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Active Cell %u does not exist for UE %u", lcRecfg->cellId, lcRecfg->crnti);
546 /* Fetch the Ue for dedicated channels */
547 if ((*ue = rgDBMGetUeCb(*cell, lcRecfg->crnti)) == NULLP)
549 RLOG_ARG0(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Ue does not exist for dedicated logical channel");
553 if ((*ulLc = rgDBMGetUlDedLcCb((*ue), lcRecfg->lcId)) == NULLP)
555 RLOG_ARG1(L_ERROR, DBG_CRNTI,lcRecfg->crnti,"Dedicated UL LC does not exist %d",lcRecfg->lcId);
559 if (lcRecfg->ulRecfg.lcgId > (RG_MAX_LCG_PER_UE - 1))
561 RLOG_ARG2(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Invalid lcgId for uplink logical channel lcg %d lc %d",
562 lcRecfg->ulRecfg.lcgId, lcRecfg->lcId);
566 errInfo->errCause = RGERR_NONE;
568 } /* rgCFGVldtCrgLcRecfg */
570 /* Start: LTEMAC_2.1_DEV_CFG */
572 * @brief Validates the UE Reset request from RRC to MAC.
576 * Function : rgCFGVldtCrgUeReset
579 * - Retrieve the CELL control block.
582 * - Retrieve the UE control block.
586 * @param[in] Inst inst
587 * @param[in] CrgRst *reset,
588 * @param[out] RgCellCb **cell
589 * @param[out] RgUeCb **ue
590 * @param[out] RgErrInfo *errInfo
596 S16 rgCFGVldtCrgUeReset
605 S16 rgCFGVldtCrgUeReset(inst,reset, cell, ue, errInfo)
613 errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_RESET;
615 /* Fetch the Active cell */
616 if (((*cell = rgCb[inst].cell) == NULLP)
617 || ((*cell)->cellId != reset->cellId))
619 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist %d\n",reset->crnti, reset->cellId));
620 RLOG_ARG1(L_ERROR,DBG_CRNTI,reset->crnti,"Active Cell does not exist %d",reset->cellId);
625 if ((*ue = rgDBMGetUeCb(*cell, reset->crnti)) == NULLP)
627 RLOG_ARG0(L_ERROR,DBG_CRNTI,reset->crnti,"UE does not exist");
631 errInfo->errCause = RGERR_NONE;
633 } /* rgCFGVldtCrgUeReset*/
634 /* End: LTEMAC_2.1_DEV_CFG */
639 * @brief Handler for the cell configuration request from RRC to MAC.
643 * Function : rgCFGCrgCellCfg
646 * - Allocate and create cell control block.
647 * - Update cell control block with the values recieved in the
649 * - Add the control block to hash list of cells.
650 * - Update the statistics.
651 * - If successful, return ROK else return RFAILED.
653 * @param[in] Inst inst
654 * @param[in] CrgCellCfg *cellCfg
655 * @param[out] RgErrInfo *errInfo
668 S16 rgCFGCrgCellCfg(inst,cellCfg, errInfo)
675 RgCellCb *cell = NULLP;
679 /* RLC SAP to allocate flowCntrlInd buffer*/
682 errInfo->errCause = RGERR_CFG_CRG_CELL_CFG;
684 /* Allocate the cell control block */
685 if((ret = rgAllocSBuf(inst,(Data**)&cell, sizeof(RgCellCb))) != ROK)
687 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
692 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId, "Memory allocation FAILED for cell");
696 /* Initialize the cell */
697 cell->cellId = cellCfg->cellId;
698 cell->rachCfg = cellCfg->rachCfg;
699 cell->bwCfg = cellCfg->bwCfg;
701 if(cellCfg->emtcEnable)
703 cell->emtcEnable = cellCfg->emtcEnable;
706 /* Initialize UL and DL CCCH logical channels */
707 cell->ulCcchId = RG_INVALID_LC_ID;
708 cell->dlCcchId = RG_INVALID_LC_ID;
711 /* Initialize the lists of the cell */
712 ret = rgDBMInitCell(cell);
715 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"DBM initialization for cell failed");
716 rgCFGFreeInactvCellCb(cell);
721 if (RFAILED == RgLaaCellCbInit(cell))
723 rgCFGFreeInactvCellCb(cell);
728 for(idx=0;idx < RG_NUM_SUB_FRAMES; idx++)
730 cell->subFrms[idx].txDone = TRUE;
733 cell->macInst = inst + RG_INST_START;
734 /* Insert cell in the incative cell list */
735 rgCb[inst].inactiveCell = cell;
736 rgCb[inst].cell = NULLP;
737 #ifdef TENB_MULT_CELL_SUPPRT
738 rguDlSapId = cellCfg->rguDlSapId;
739 rguUlSapId = cellCfg->rguUlSapId;
741 if(rgCb[inst].numRguSaps > 1)
746 cell->rguDlSap = &(rgCb[inst].rguSap[rguDlSapId]);
747 cell->rguUlSap = &(rgCb[inst].rguSap[rguUlSapId]);
751 cmLListInit(&cell->l2mList);
752 for(idx = 0; idx < RG_NUM_UL_SUB_FRAMES; idx++)
754 memset(&cell->ulSf[idx], 0, sizeof(RgUlSf));
757 cell->ttiCycle = (U32)RG_TTI_CYCLE_INVLD;
759 /* Update Statistics */
760 rgUpdtCellCnt(inst,RG_CFG_ADD);
761 errInfo->errCause = RGERR_NONE;
763 pst = &rgCb[inst].rguSap[rguDlSapId].sapCfg.sapPst;
764 /* Allocate a buffer for flowCntrlInd.*/
765 SGetSBuf(pst->region, pst->pool, (Data **)&cell->flowCntrlInd,
766 sizeof(RguFlowCntrlInd));
768 } /* rgCFGCrgCellCfg */
772 * @brief Add SCell Cfg recvd from primary MAC instance.
776 * Function : rgCfgAddUeSCellCfg
779 * - Allocate and create UE control block.
780 * - Update UE control block with the values recieved in the
782 * - If successful, add the control block to hash list of UEs for the cell
783 * else Rollback and FAIL.
785 * @param[in] Inst dstMacInst
786 * @param[in] RgPrgUeSCellCfgInfo *ueSCellCb
787 * @param[in] RgCellCb cell
794 S16 rgCfgAddUeSCellCfg
797 RgPrgUeSCellCfgInfo *ueSCellCb,
801 S16 rgCfgAddUeSCellCfg(dstMacInst, ueSCellCb, cell)
803 RgPrgUeSCellCfgInfo *ueSCellCb;
807 RgUeCb *ueCb = NULLP;
814 rguDlSapId = ueSCellCb->rguDlSapId;
815 rguUlSapId = ueSCellCb->rguUlSapId;
817 #ifndef TENB_MULT_CELL_SUPPRT
818 if(rgCb[dstMacInst].numRguSaps > 1)
824 if ((ueCb = rgDBMGetUeCb(cell, ueSCellCb->ueId)) != NULLP)
826 RGDBGERRNEW(dstMacInst,(rgPBuf(dstMacInst),
827 "[%d]Ue already exist in scell %d during scell addition\n",
834 if((ueCb = rgRAMCreateUeCb(cell, ueSCellCb->ueId,
835 FALSE, &errInfo)) == NULLP)
837 RGDBGERRNEW(dstMacInst, (rgPBuf(dstMacInst),
838 "[%d]UeCb creation failed\n", ueSCellCb->ueId));
842 if(rgDHMHqEntInit(dstMacInst, &ueCb->dl.hqEnt,
843 (rgCb[dstMacInst].cell)->maxDlHqProcPerUe) != ROK)
845 RGDBGERRNEW(dstMacInst,(rgPBuf(dstMacInst),
846 "[%d]UeCb Harq Entity Initialization failed\n", ueSCellCb->ueId));
849 rgDBMInsUeCb(cell, ueCb);
852 ueCb->rguDlSap = &(rgCb[dstMacInst].rguSap[rguDlSapId]);
853 ueCb->rguUlSap = &(rgCb[dstMacInst].rguSap[rguUlSapId]);
855 /* Update satistics */
856 rgUpdtUeCnt(dstMacInst, RG_CFG_ADD);
857 /*Commit Added SCell info to UeCb */
859 ueCb->sCelAddInfo[idx].isSCellAdded = TRUE;
860 ueCb->sCelAddInfo[idx].macInst = dstMacInst;
861 ueCb->sCelAddInfo[idx].sCellId = ueSCellCb->cellId;
864 ueCb->txMode = ueSCellCb->txMode;
865 ueCb->ul.hqEnt.maxHqRetx = ueSCellCb->maxUlHqRetx;
867 for (idx =0; idx <RG_MAX_LC_PER_UE; idx++)
869 ueCb->ul.lcCb[idx] = ueSCellCb->ulLcInfo[idx];
870 ueCb->dl.lcCb[idx] = ueSCellCb->dlLcInfo[idx];
873 for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
875 ueCb->ul.lcgArr[idx].lcgId = ueSCellCb->lcgInfo[idx].lcgId;
876 ueCb->ul.lcgArr[idx].lcCount = ueSCellCb->lcgInfo[idx].lcCount;
877 ueCb->ul.lcgArr[idx].isGbr = ueSCellCb->lcgInfo[idx].isGbr;
880 }/* rgCfgAddUeSCellCfg */
883 * @brief SCell Config Filling for added cell from RRC to MAC.
887 * Function : rgFillAndAddSCellCfg
890 * - Update UE control block with the values recieved in the
892 * - Update UE control block with the values present in the
894 * - If successful, add the control block to hash list of UEs for the cell
895 * else Rollback and FAIL.
897 * @param[in] Inst inst
898 * @param[in] RgCellCb *cell
899 * @param[in] CrgUeCfg *ueCfg
900 * @param[in] CrgCfgTransId transId
906 S16 rgFillAndAddSCellCfg
911 CrgCfgTransId transId,
915 S16 rgFillAndAddSCellCfg(inst, cell, ueRecfg, transId, isCfmRqrd)
919 CrgCfgTransId transId;
926 RgPrgUeSCellCfgInfo ueSCellCb;
929 /* Fetch the Active cell */
930 if(((cell = rgCb[inst].cell) == NULLP) ||
931 (cell->cellId != ueRecfg->cellId))
933 RGDBGERRNEW(inst,(rgPBuf(inst),
934 "[%d]Active Cell does not exist %d\n",
935 ueRecfg->oldCrnti, ueRecfg->cellId));
939 RGDBGPRM(inst,(rgPBuf(inst),
940 "Filling SCell Config : cellId %d ueId %d\n",
941 cell->cellId, cell->ueId));
943 if ((ue = rgDBMGetUeCb(cell, ueRecfg->oldCrnti)) == NULLP)
945 RGDBGERRNEW(inst,(rgPBuf(inst),
946 "[%d]Ue does not exist\n", ueRecfg->oldCrnti));
950 /* Initialize cfgCfmInfo in the ueCb. This is used while processing SCellAdd
952 ue->cfgCfmInfo.numSCells = ueRecfg->crgSCellCfg.numSCells;
953 ue->cfgCfmInfo.cfgCfgCount = 0;
954 ue->cfgCfmInfo.mask = 0x0;
956 memcpy(&(ue->cfgCfmInfo.transId), &transId,
957 sizeof(CrgCfgTransId));
958 ueSCellCb.ueId = ueRecfg->oldCrnti;
959 ueSCellCb.txMode = ue->txMode;
960 ueSCellCb.maxUlHqRetx = ue->ul.hqEnt.maxHqRetx;
961 memcpy(ueSCellCb.ulLcInfo, ue->ul.lcCb, sizeof(ue->ul.lcCb));
962 memcpy(ueSCellCb.dlLcInfo, ue->dl.lcCb, sizeof(ue->dl.lcCb));
963 for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
965 ueSCellCb.lcgInfo[idx].lcgId = ue->ul.lcgArr[idx].lcgId;
966 ueSCellCb.lcgInfo[idx].lcCount = ue->ul.lcgArr[idx].lcCount;
967 ueSCellCb.lcgInfo[idx].isGbr = ue->ul.lcgArr[idx].isGbr;
971 idx < ueRecfg->crgSCellCfg.numSCells; idx++)
973 dstMacInst = ueRecfg->crgSCellCfg.ueSCellCfg[idx].macInst - RG_INST_START;
974 ueSCellCb.cellId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].sCellId;
975 ueSCellCb.rguDlSapId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].rguDlSapId;
976 ueSCellCb.rguUlSapId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].rguUlSapId;
978 /* Get post structure of the cell to whom ueSCellCb needs to be sent
979 * And then send the sCell Add based on Mac instances */
980 rgGetPstToInst(&dstInstPst, inst, dstMacInst);
981 RgPrgPMacSMacUeSCellCfg(&dstInstPst, &ueSCellCb);
983 /*Commit Added SCell info to UeCb is moved to config confirm*/
984 } /*end of for loop */
988 } /* rgFillAndAddSCellCfg */
992 * @brief Handler for the UE configuration request from RRC to MAC.
996 * Function : rgCFGCrgUeCfg
999 * - Allocate and create UE control block.
1000 * - Update UE control block with the values recieved in the
1002 * - Invoke RAM, SCH, UHM and DHM with created UE control block, to
1003 * update random access, scheduler, uplink harq and downlink harq
1004 * specific information respectively.
1005 * - If successful, add the control block to hash list of UEs for the cell
1006 * else Rollback and FAIL.
1008 * @param[in] Inst inst
1009 * @param[in] RgCellCb *cell
1010 * @param[in] CrgUeCfg *ueCfg
1011 * @param[out] RgErrInfo *errInfo
1025 S16 rgCFGCrgUeCfg(inst,cell, ueCfg, errInfo)
1033 Bool handover = FALSE;
1034 SuId rguUlSapId = 0;
1035 SuId rguDlSapId = 0;
1037 errInfo->errCause = RGERR_CFG_CRG_UE_CFG;
1039 /* Start: LTEMAC_2.1_DEV_CFG */
1040 if ((ue = rgDBMGetUeCbFromRachLst(cell, ueCfg->crnti)) == NULLP)
1042 /* Create UeCb and Insert in Rach List */
1043 if((ue=rgRAMCreateUeCb(cell, ueCfg->crnti, FALSE, errInfo)) == NULLP)
1045 RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"UeCb creation failed");
1048 if(rgDHMHqEntInit(inst,&ue->dl.hqEnt, cell->maxDlHqProcPerUe) != ROK)
1050 RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"UeCb Harq Entity Initialization failed");
1055 /* End: LTEMAC_2.1_DEV_CFG */
1057 if(handover == FALSE)
1059 /* Remove from the rachLst */
1060 rgDBMDelUeCbFromRachLst(cell, ue);
1064 /* Initialize uplink HARQ related information for UE */
1065 rgUHMCrgUeCfg(cell, ue, ueCfg);
1067 rgDBMInsUeCb(cell, ue);
1069 #ifdef TENB_MULT_CELL_SUPPRT
1070 rguDlSapId = ueCfg->rguDlSapId;
1071 rguUlSapId = ueCfg->rguUlSapId;
1073 if(rgCb[inst].numRguSaps > 1)
1079 ue->rguDlSap = &(rgCb[inst].rguSap[rguDlSapId]);
1080 ue->rguUlSap = &(rgCb[inst].rguSap[rguUlSapId]);
1083 /* Update satistics */
1084 rgUpdtUeCnt(inst,RG_CFG_ADD);
1085 errInfo->errCause = RGERR_NONE;
1087 } /* rgCFGCrgUeCfg */
1091 * @brief Handler for the logical channel configuration request from
1096 * Function : rgCFGCrgLcCfg
1099 * - Check if the configuration is for dedicated or common logical channel.
1100 * - For Dedicated logical channels:
1101 * - Update the dedicated logical channel Cb with the configured values.
1102 * - Invoke SCH will cell, UE and logical channel Cb to update scheduler
1103 * specific information.
1104 * - For Common logical channels:
1105 * - Update the common logical channel Cb with the configured values.
1106 * - Move cell to active list of cells if cell becomes ACTIVE.
1107 * - If successful, return ROK else RFAILED.
1109 * @param[in] Inst inst
1110 * @param[in] RgCellCb *cell
1111 * @param[in] RgUeCb *ue
1112 * @param[in] CrgLchCfg *lcCfg
1113 * @param[out] RgErrInfo *errInfo
1114 * @param[in] Bool *isCfmRqrd
1128 CrgCfgTransId transId
1131 S16 rgCFGCrgLcCfg(inst,cell, ue, lcCfg, errInfo, isCfmRqrd,transId)
1138 CrgCfgTransId transId;
1142 /* Handle Config for dedicated/common logical channels */
1143 if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
1146 if ((rgCFGCrgDedLcCfg(cell, ue, lcCfg, errInfo)) != ROK)
1148 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,
1149 "Dedicated logical channel configuration failed %d",lcCfg->lcId);
1153 /*ERAB Multl Cell fix*/
1154 memcpy(&(ue->cfgCfmInfo.transId), &transId,
1155 sizeof(CrgCfgTransId));
1156 rgPomSndUeSCellLchAddToSmac(inst, cell, ue, lcCfg,isCfmRqrd);
1161 if ((rgCFGCrgCmnLcCfg(inst,cell, lcCfg, errInfo)) != ROK)
1163 RLOG_ARG1(L_ERROR, DBG_CRNTI, lcCfg->crnti, "Common logical channel configuration"
1164 "failed %d\n", lcCfg->lcId);
1169 errInfo->errCause = RGERR_NONE;
1170 RLOG_ARG1(L_INFO, DBG_CRNTI,lcCfg->crnti, "CRG LC config done for UE: lcId %d\n", lcCfg->lcId);
1172 } /* rgCFGCrgLcCfg */
1176 * @brief Handler for the cell re-configuration request from RRC to MAC.
1180 * Function : rgCFGCrgCellRecfg
1183 * - Invoke SCH with updated Cell Cb to update scheduler specific
1185 * - Update the cell Cb with the reconfigured values.
1186 * - If successful, return ROK else RFAILED.
1188 * @param[in] Inst inst
1189 * @param[in] RgCellCb *cell
1190 * @param[in] CrgCellRecfg *cellRecfg
1191 * @param[out] RgErrInfo *errInfo
1197 S16 rgCFGCrgCellRecfg
1201 CrgCellRecfg *cellRecfg,
1205 S16 rgCFGCrgCellRecfg(inst,cell, cellRecfg, errInfo)
1208 CrgCellRecfg *cellRecfg;
1212 /* Store the given rachCfg */
1213 cell->rachCfg = cellRecfg->rachRecfg;
1215 errInfo->errCause = RGERR_NONE;
1217 } /* rgCFGCrgCellRecfg */
1221 * @brief Handler for the UE re-configuration request from RRC to MAC.
1225 * Function : rgCFGCrgUeRecfg
1228 * - If rnti changes,
1229 * - Invoke RAM for UE reconfiguration.
1230 * - Delete old UE from the list.
1231 * - Update the new rnti and re-insert the UE in the list.
1232 * - Update the UE control block with the reconfigured values.
1233 * - Invoke SCH, UHM and DHM with updated UE control block to
1234 * update scheduler, uplink HARQ and downlink HARQ specific
1236 * - If successful, return ROK else RFAILED.
1238 * @param[in] Inst inst
1239 * @param[in] RgCellCb *cell
1240 * @param[in] RgUeCb *ue
1241 * @param[in] CrgUeRecfg *ueRecfg
1242 * @param[out] RgErrInfo *errInfo
1253 CrgUeRecfg *ueRecfg,
1257 S16 rgCFGCrgUeRecfg(inst,cell, ue, ueRecfg, errInfo)
1261 CrgUeRecfg *ueRecfg;
1265 errInfo->errCause = RGERR_CFG_CRG_UE_RECFG;
1267 /* Fix : syed UE ID change at MAC will now be controlled
1270 /* Update uplink HARQ related information for UE */
1271 rgUHMCrgUeRecfg(cell, ue, ueRecfg);
1273 errInfo->errCause = RGERR_NONE;
1275 } /* rgCFGCrgUeRecfg */
1279 * @brief Handler for the logical channel re-configuration request from
1284 * Function : rgCFGCrgLcRecfg
1287 * - Invoke scheduler to update scheduler specific information.
1288 * - Update the dedicated logical channel Cb with the re-configured
1290 * - If successful, return ROK else RFAILED.
1292 * @param[in] Inst inst
1293 * @param[in] RgUlCellCb *cell
1294 * @param[in] RgUlUeCb *ue
1295 * @param[in] RgUlLcCb *ulLc
1296 * @param[in] RgDlLcCb *dlLc
1297 * @param[in] CrgLchRecfg *lcRecfg
1298 * @param[out] RgErrInfo *errInfo
1310 CrgLchRecfg *lcRecfg,
1315 S16 rgCFGCrgLcRecfg(inst,cell, ue, ulLc, lcRecfg, errInfo, isCfmRqrd)
1320 CrgLchRecfg *lcRecfg;
1326 if (ulLc->lcgId != lcRecfg->ulRecfg.lcgId)
1328 rgDBMUpdUlDedLcCb(ue, ulLc, lcRecfg->ulRecfg.lcgId);
1330 rgPomSndUeSCellLchModToSmac(inst, cell, ue, lcRecfg,isCfmRqrd);
1334 errInfo->errCause = RGERR_NONE;
1336 } /* rgCFGCrgLcRecfg */
1338 /* Start: LTEMAC_2.1_DEV_CFG */
1340 * @brief Handler for the logical channel re-configuration request from
1345 * Function : rgCFGCrgUeReset
1349 * @param[in] RgUlCellCb *cell
1350 * @param[in] RgUlUeCb *ue
1351 * @param[in] CrgRst *reset
1352 * @param[out] RgErrInfo *errInfo
1366 S16 rgCFGCrgUeReset(cell, ue, reset, errInfo)
1374 RLOG_ARG1(L_DEBUG, DBG_CRNTI, ue->ueId, "UE: of cell %d Reset\n", cell->cellId);
1375 rgDHMUeReset(cell, &ue->dl.hqEnt);
1377 errInfo->errCause = RGERR_NONE;
1380 } /* rgCFGCrgUeReset */
1381 /* End: LTEMAC_2.1_DEV_CFG */
1384 * @brief Handler for the cell delete request from RRC to MAC.
1388 * Function : rgCFGCrgCellDel
1391 * - Fetch the cell control block.
1392 * - Remove the cell control block from the hash list of cells.
1393 * - Free the cell control block.
1394 * - If successful, return ROK else return RFAILED.
1396 * @param[in] Inst inst
1397 * @param[in] CrgDel *cellDelInfo
1398 * @param[out] RgErrInfo *errInfo
1407 CrgDel *cellDelInfo,
1411 S16 rgCFGCrgCellDel(inst,cellDelInfo, errInfo)
1413 CrgDel *cellDelInfo;
1421 errInfo->errCause = RGERR_CFG_CRG_CELL_DEL;
1422 if (((cell = rgCb[inst].cell) == NULLP)
1423 ||(cell->cellId != cellDelInfo->u.cellDel.cellId))
1425 if(((cell = rgCb[inst].inactiveCell) == NULLP)
1426 ||(cell->cellId != cellDelInfo->u.cellDel.cellId))
1430 RLOG_ARG0(L_ERROR,DBG_CELLID,cellDelInfo->u.cellDel.cellId,"Cell does not exist");
1434 /* Delete cell from inactive list */
1435 rgCb[inst].inactiveCell = NULLP ;
1437 /* Free the inactive cell */
1438 rgCFGFreeInactvCellCb(cell);
1440 errInfo->errCause = RGERR_NONE;
1444 /* Delete from the cell list */
1445 //rgDBMDelCellCb(cell);
1446 for(idx=0;idx < RG_NUM_SUB_FRAMES; idx++)
1448 rgTOMRlsSf(inst,&cell->subFrms[idx]);
1451 /* Free the active cell */
1452 rgCFGFreeCellCb(cell);
1454 rgCb[inst].cell = NULLP;
1456 errInfo->errCause = RGERR_NONE;
1457 RGDBGINFO(inst,(rgPBuf(inst), "Cell %d deleted\n", cellDelInfo->u.cellDel.cellId));
1459 } /* rgCFGCrgCellDel */
1463 * @brief Handler for the UE delete request from RRC to MAC.
1467 * Function : rgCFGCrgUeDel
1470 * - Fetch the UE control block.
1471 * - Remove the UE control block from the hash list of UEs for the cell.
1472 * - Free the UE control block.
1473 * - If successful, return ROK else return RFAILED.
1475 * @param[in] Inst inst
1476 * @param[in] CrgDel *ueDelInfo
1477 * @param[out] RgErrInfo *errInfo
1490 S16 rgCFGCrgUeDel(inst,ueDelInfo, errInfo)
1497 errInfo->errCause = RGERR_CFG_CRG_UE_DEL;
1499 RLOG_ARG1(L_DEBUG, DBG_CRNTI, ueDelInfo->u.ueDel.crnti, "UE %d Deletion Req at MAC\n", \
1500 ueDelInfo->u.ueDel.crnti);
1501 if ((rgCb[inst].cell == NULLP)
1502 || (rgCb[inst].cell->cellId != ueDelInfo->u.ueDel.cellId))
1504 RLOG_ARG1(L_ERROR,DBG_CRNTI,ueDelInfo->u.ueDel.crnti,"Cell does not exist %d",
1505 ueDelInfo->u.ueDel.cellId);
1509 errInfo->errCause = RGERR_NONE;
1510 /* Fix: syed Context Deletion is relied upon SCH indication */
1512 } /* rgCFGCrgUeDel */
1516 * @brief Handler for the logical channel delete request from
1521 * Function : rgCFGCrgLcDel
1524 * - Fetch the logical channel control block.
1525 * - Free the logical channel control block.
1526 * - If successful, return ROK else return RFAILED.
1528 * @param[in] Inst inst
1529 * @param[in] CrgDel *lcDelInfo
1530 * @param[out] RgErrInfo *errInfo
1542 CrgCfgTransId transId
1545 S16 rgCFGCrgLcDel(inst,lcDelInfo, errInfo,isCfmRqrd,transId)
1549 CrgCfgTransId transId;
1552 Bool dirVld = FALSE;
1558 errInfo->errCause = RGERR_CFG_CRG_LC_DEL;
1560 /* Fetch the Active cell */
1561 if (((cell = rgCb[inst].cell) == NULLP) ||
1562 (rgCb[inst].cell->cellId != lcDelInfo->u.lchDel.cellId))
1564 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"Cell does not exist %d",
1565 lcDelInfo->u.lchDel.cellId);
1570 if ((ue = rgDBMGetUeCb(cell, lcDelInfo->u.lchDel.crnti)) == NULLP)
1572 RLOG_ARG0(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,
1573 "UE does not exist for dedicated logical channel");
1577 /* Validate downlink info */
1578 if (lcDelInfo->u.lchDel.dir & CRG_DIR_TX)
1580 if ((dlLc = rgDBMGetDlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
1583 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"DL LC %d does not exist",
1584 lcDelInfo->u.lchDel.lcId);
1587 rgDBMDelDlDedLcCb(ue, dlLc);
1591 /* Validate uplink info */
1592 if (lcDelInfo->u.lchDel.dir & CRG_DIR_RX)
1594 if ((ulLc = rgDBMGetUlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
1597 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"UL LC %d does not exist",
1598 lcDelInfo->u.lchDel.lcId);
1601 rgDBMDelUlDedLcCb(ue, ulLc);
1607 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"Invalid direction %d for LC Delete",
1608 lcDelInfo->u.lchDel.dir);
1612 /*ERAB - multicell fix*/
1613 memcpy( &(ue->cfgCfmInfo.transId), &transId,
1614 sizeof(CrgCfgTransId));
1615 rgPomSndUeSCellLchDelToSmac(inst, lcDelInfo, isCfmRqrd);
1617 errInfo->errCause = RGERR_NONE;
1619 } /* rgCFGCrgLcDel */
1621 /***********************************************************
1623 * Func : rgCFGVldtCrgDedLcCfg
1626 * Desc : Validates dedicated logical channel configuration recieved from RRC.
1636 **********************************************************/
1638 PRIVATE S16 rgCFGVldtCrgDedLcCfg
1647 PRIVATE S16 rgCFGVldtCrgDedLcCfg(inst,lcCfg, cell, ue, errInfo)
1657 errInfo->errCause = RGERR_CFG_INVALID_CRG_DED_LC_CFG;
1659 /* Fetch the Active cell */
1660 if (((*cell = rgCb[inst].cell) == NULLP)
1661 || ((*cell)->cellId != lcCfg->cellId))
1663 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Active Cell does not exist: Cell %d",
1669 if ((*ue = rgDBMGetUeCb(*cell, lcCfg->crnti)) == NULLP)
1671 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE does not exist for dedicated logical channel %d",
1676 /* Validate logical channel Id */
1677 if ((lcCfg->lcId < RG_DEDLC_MIN_LCID)
1678 ||(lcCfg->lcId > RG_DEDLC_MAX_LCID))
1680 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid logical channel Id %d",
1685 /* Validate downlink info */
1686 if (lcCfg->dir & CRG_DIR_TX)
1688 if (rgDBMGetDlDedLcCb((*ue), lcCfg->lcId) != NULLP)
1690 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Dedicated DL LC %d already configured",
1697 /* Validate uplink info */
1698 if (lcCfg->dir & CRG_DIR_RX)
1700 if (lcCfg->ulInfo.lcgId > (RG_MAX_LCG_PER_UE - 1))
1702 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Invalid lcgId for uplink logical channel %d",
1703 lcCfg->ulInfo.lcgId);
1706 if (rgDBMGetUlDedLcCb((*ue), lcCfg->lcId) != NULLP)
1708 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Dedicated UL LC %d already configured",
1717 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid Direction %d",
1723 } /* rgCFGVldtCrgDedLcCfg */
1726 /***********************************************************
1728 * Func : rgCFGVldtCrgCmnLcCfg
1731 * Desc : Validates common logical channel configuration recieved from RRC.
1741 **********************************************************/
1743 PRIVATE S16 rgCFGVldtCrgCmnLcCfg
1751 PRIVATE S16 rgCFGVldtCrgCmnLcCfg(inst,lcCfg, cell, errInfo)
1760 errInfo->errCause = RGERR_CFG_INVALID_CRG_CMN_LC_CFG;
1762 /* Ensure cell is not in the active list */
1763 if (((*cell = rgCb[inst].cell) != NULLP)
1764 && ((*cell)->cellId != lcCfg->cellId))
1766 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"Active Cell exists for common channels");
1770 /* Fetch the inactive cell for common logical channels */
1771 if (((*cell = rgCb[inst].inactiveCell) == NULLP)
1772 || ((*cell)->cellId != lcCfg->cellId))
1775 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"Inactive Cell does not exist for common channels");
1778 /* Validate downlink info */
1779 if (lcCfg->dir & CRG_DIR_TX)
1781 if (lcCfg->lcType == CM_LTE_LCH_BCCH)
1783 if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_DL_SCH)
1785 if (rgDBMGetBcchOnDlsch(*cell,lcCfg->lcId) != NULLP)
1787 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"BCCH on DLSCH already configured for cell");
1791 else if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_BCH)
1793 if (rgDBMGetBcchOnBch(*cell) != NULLP)
1795 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"BCCH on BCH already configured for cell %d");
1801 RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid transport channel %d for cell",
1802 lcCfg->dlInfo.dlTrchType);
1806 else if (lcCfg->lcType == CM_LTE_LCH_PCCH)
1808 if (rgDBMGetPcch(*cell) != NULLP)
1810 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"PCCH already configured for cell");
1814 else if (RG_DLCCCH_ISCFGD(*cell))
1816 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"DL CCCH already configured for cell %d");
1822 /* Validate uplink info */
1823 if (lcCfg->dir & CRG_DIR_RX)
1826 if (lcCfg->lcType != CM_LTE_LCH_CCCH)
1828 RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid UL common lcType %d for cell ",
1832 if (RG_ULCCCH_ISCFGD(*cell))
1834 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"UL CCCH already configured for cell ");
1840 /* Invalid direction */
1843 RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid Direction %d", lcCfg->dir);
1848 } /* rgCFGVldtCrgCmnLcCfg */
1850 /***********************************************************
1852 * Func : rgCFGCrgDedLcCfg
1855 * Desc : Handles dedicated logical channel configuration
1856 * recieved from RRC.
1866 **********************************************************/
1868 PRIVATE S16 rgCFGCrgDedLcCfg
1876 PRIVATE S16 rgCFGCrgDedLcCfg(cell, ue, lcCfg, errInfo)
1883 //Inst inst = cell->macInst - RG_INST_START;
1884 errInfo->errCause = RGERR_CFG_CRG_DED_LC_CFG;
1886 /* Uplink/Bi-directional logical channel */
1887 if (lcCfg->dir & CRG_DIR_RX)
1890 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId, lcCfg->qci);
1891 cell->qciArray[lcCfg->qci].qci = lcCfg->qci;
1892 if(lcCfg->lcType == CM_LTE_LCH_DTCH)
1894 rgAddToL2MeasPerQci(cell,lcCfg->qci);/*LTE_L2_MEAS_PHASE2*/
1897 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId);
1901 /* Downlink/Bi-directional logical channel */
1902 if (lcCfg->dir & CRG_DIR_TX)
1904 rgDBMInsDlDedLcCb(ue, lcCfg->lcId);
1907 } /* rgCFGCrgDedLcCfg */
1910 /***********************************************************
1912 * Func : rgCFGCrgCmnLcCfg
1915 * Desc : Handles dedicated logical channel configuration
1916 * recieved from RRC.
1926 **********************************************************/
1928 PRIVATE S16 rgCFGCrgCmnLcCfg
1936 PRIVATE S16 rgCFGCrgCmnLcCfg(inst,cell, lcCfg, errInfo)
1943 errInfo->errCause = RGERR_CFG_CRG_CMN_LC_CFG;
1945 /* Handle configuration for CCCH/BCCH/PCCH */
1946 if (lcCfg->lcType == CM_LTE_LCH_CCCH)
1948 /* UL and DL CCCH configuration */
1949 if (lcCfg->dir & CRG_DIR_TX)
1951 cell->dlCcchId = lcCfg->lcId;
1952 cell->cellActvState |= RG_DL_CCCH_CFG_DONE;
1955 if (lcCfg->dir & CRG_DIR_RX)
1957 cell->ulCcchId = lcCfg->lcId;
1958 cell->cellActvState |= RG_UL_CCCH_CFG_DONE;
1963 if (lcCfg->lcType == CM_LTE_LCH_BCCH)
1965 /* BCCH on BCH and DLSCH configuration */
1966 if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_DL_SCH)
1968 rgDBMInsBcchOnDlsch(cell, lcCfg->lcId);
1970 if(cell->cellActvState & RG_BCCH_DLSCH_CFG1_DONE)
1972 cell->cellActvState |= RG_BCCH_DLSCH_CFG2_DONE;
1976 cell->cellActvState |= RG_BCCH_DLSCH_CFG1_DONE;
1981 rgDBMInsBcchOnBch(cell, lcCfg->lcId);
1982 cell->cellActvState |= RG_BCCH_BCH_CFG_DONE;
1985 else /* PCCH configuration */
1987 rgDBMInsPcch(cell, lcCfg->lcId);
1988 cell->cellActvState |= RG_PCCH_CFG_DONE;
1992 /* Add to active cell list if cell is active */
1993 if (cell->cellActvState == RG_CELL_ACTIVE)
1995 rgCb[inst].cell = cell;
1996 rgCb[inst].inactiveCell = NULLP;
1997 RLOG_ARG1(L_DEBUG, DBG_CELLID, cell->cellId, "Cell %d added to active list after common LC %d\
1998 config\n", lcCfg->lcId);
2002 } /* rgCFGCrgCmnLcCfg */
2004 /***********************************************************
2006 * Func : rgCFGFreeUeUlAlloc
2010 * - Processing Steps:
2011 * - Frees cell control block.
2019 **********************************************************/
2021 PRIVATE Void rgCFGFreeUeUlAlloc
2026 PRIVATE Void rgCFGFreeUeUlAlloc(cell)
2031 Inst inst = cell->macInst - RG_INST_START;
2033 for(sfIdx = 0; sfIdx < RG_NUM_UL_SUB_FRAMES; sfIdx++)
2035 if(cell->ulSf[sfIdx].ueUlAllocInfo != NULLP)
2037 /*ccpu00117052 - MOD- Passing double pointer for proper
2038 * NULLP assignment */
2039 rgFreeSBuf(inst,(Data **)&(cell->ulSf[sfIdx].ueUlAllocInfo),
2040 (cell->ulSf[sfIdx].numUe * sizeof(RgUeUlAlloc)));
2043 }/* rgCFGFreeUeUlAlloc */
2045 /***********************************************************
2047 * Func : rgCFGFreeCellCb
2051 * - Processing Steps:
2052 * - Frees cell control block.
2060 **********************************************************/
2062 Void rgCFGFreeCellCb
2067 Void rgCFGFreeCellCb(cell)
2071 Inst inst = cell->macInst - RG_INST_START;
2074 RgLaaCellCbDeInit(cell);
2076 /* Free lists of the cell */
2078 rgCFGFreeSpsUeLst(cell);
2079 #endif /* LTEMAC_SPS */
2080 rgCFGFreeUeLst(cell);
2081 rgRAMFreeCell(cell);
2082 rgCFGFreeCmnLcLst(cell);
2084 rgCFGFreeUeUlAlloc(cell);
2086 /* ccpu00117052 - MOD - Passing double pointer for proper NULLP
2088 /* Update satistics */
2089 rgUpdtCellCnt(inst,RG_CFG_DEL);
2090 rgDHMFreeAllTbBufs(inst);
2092 rgFreeSBuf(inst,(Data **)&cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
2094 /* De-allocate the Cell */
2095 rgFreeSBuf(inst,(Data **)&cell, sizeof(*cell));
2098 RGDBGINFO(inst,(rgPBuf(inst), "Cell freed\n"));
2100 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2102 } /* rgCFGFreeCellCb */
2105 /***********************************************************
2107 * Func : rgCFGFreeInactvCellCb
2111 * - Processing Steps:
2112 * - Frees inactive cell control block.
2120 **********************************************************/
2122 Void rgCFGFreeInactvCellCb
2127 Void rgCFGFreeInactvCellCb(cell)
2131 Inst inst = cell->macInst - RG_INST_START;
2132 /* De-initialize the Ue list */
2133 rgDBMDeInitUeCbLst(cell);
2135 rgDBMDeInitSpsUeCbLst(cell);
2138 rgCFGFreeCmnLcLst(cell);
2140 rgFreeSBuf(inst, (Data **)&cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
2141 /*ccpu00117052 - MOD- Passing double pointer for proper
2143 /* De-allocate the Cell */
2144 rgFreeSBuf(inst,(Data **)&cell, sizeof(*cell));
2146 /* Update satistics */
2147 rgUpdtCellCnt(inst,RG_CFG_DEL);
2150 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2152 } /* rgCFGFreeInactvCellCb */
2155 /***********************************************************
2157 * Func : rgCFGFreeUeCb
2161 * - Processing Steps:
2162 * - Frees UE control block.
2170 **********************************************************/
2178 Void rgCFGFreeUeCb(cell, ue)
2183 Inst inst = cell->macInst - RG_INST_START;
2185 rgDHMFreeUe(inst,&ue->dl.hqEnt);
2187 /* ccpu00117052 - MOD - Passing double pointer for proper NULLP
2189 /* De-allocate the Ue */
2190 rgFreeSBuf(inst,(Data **)&ue, sizeof(*ue));
2192 /* Update Statistics */
2193 rgUpdtUeCnt(inst,RG_CFG_DEL);
2196 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2198 } /* rgCFGFreeUeCb */
2200 /***********************************************************
2202 * Func : rgCFGFreeCmnLcLst
2206 * - Processing Steps:
2207 * - Frees common logical channels in cell control block.
2215 **********************************************************/
2217 PRIVATE Void rgCFGFreeCmnLcLst
2222 PRIVATE Void rgCFGFreeCmnLcLst(cell)
2226 rgDBMFreeCmnLcLst(cell);
2229 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2231 } /* rgCFGFreeCmnLcLst */
2234 /***********************************************************
2236 * Func : rgCFGFreeUeLst
2240 * - Processing Steps:
2241 * - Frees UE list in cell control block.
2249 **********************************************************/
2251 PRIVATE Void rgCFGFreeUeLst
2256 PRIVATE Void rgCFGFreeUeLst(cell)
2262 /* Free Ues in the list */
2263 while ((ue = rgDBMGetNextUeCb(cell, NULLP)) != NULLP)
2266 rgDelUeFrmAllSCell(cell,ue);
2268 rgDBMDelUeCb(cell, ue);
2269 rgCFGFreeUeCb(cell, ue);
2272 /* De-initialize the Ue list */
2273 rgDBMDeInitUeCbLst(cell);
2276 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2278 } /* rgCFGFreeUeLst */
2281 /***********************************************************
2283 * Func : rgCFGFreeSpsUeLst
2287 * - Processing Steps:
2288 * - Frees Sps UE list in cell control block.
2296 **********************************************************/
2298 PRIVATE Void rgCFGFreeSpsUeLst
2303 PRIVATE Void rgCFGFreeSpsUeLst(cell)
2309 /* Free Ues in the list */
2310 while ((ue = rgDBMGetNextSpsUeCb(cell, NULLP)))
2312 rgDBMDelSpsUeCb(cell, ue);
2315 /* De-initialize the Ue list */
2316 rgDBMDeInitSpsUeCbLst(cell);
2318 } /* rgCFGFreeSpsUeLst */
2320 #endif /* LTEMAC_SPS */
2323 * @brief Function for registering cell- scheduler instance mapping
2327 * Function : RgSchMacCellRegReq
2329 * This function shall be invoked whenever scheduler is done with the
2330 * cell configuration successfully.
2331 * This shall create a mapping of the cell, scheduler instance that
2332 * is serving the cell and the unique identifier of the cell on the
2333 * scheduler at MAC. This mapping shall be used for further
2334 * communication to the scheduler instance for this cell.
2337 * @param[in] Pst* pst,
2338 * @param[in] CmLteCellId cellId,
2339 * @param[in] RaRespReqInfo raRespReq
2344 S16 RgSchMacCellRegReq
2347 RgInfCellReg* regReq
2350 S16 RgSchMacCellRegReq(pst, regReq)
2352 RgInfCellReg* regReq;
2356 RgCellCb *cell = NULLP;
2358 RG_IS_INST_VALID(pst->dstInst);
2359 inst = pst->dstInst - RG_INST_START;
2360 cell = rgCb[inst].cell;
2367 if((cell == NULLP) || (cell->cellId != regReq->cellId))
2371 if(regReq->maxDlHqProcPerUe > RG_MAX_DL_HARQ_NUM)
2376 cell->schInstMap.cellSapId = regReq->cellSapId;
2377 cell->schInstMap.schInst = pst->srcInst;
2378 cell->maxDlHqProcPerUe = regReq->maxDlHqProcPerUe;
2382 } /* end of RgSchMacCellRegReq */
2384 /*Added Ue for Onging L2 Meas*/
2386 /*LTE_L2_MEAS_PHASE2*/
2387 S16 rgAddToL2MeasPerQci(RgCellCb *cell,U8 qci)
2394 lnk = cell->l2mList.first;
2395 while(lnk != NULLP )
2397 measCb = (RgL2MeasCb *)lnk->node;
2398 if(measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
2400 for(idx = 0;idx< measCb->measReq.t.prbReq.numQci;idx++)
2402 if(measCb->measReq.t.prbReq.qci[idx] == qci)
2404 break; /*exit from for loop*/
2407 if(idx == measCb->measReq.t.prbReq.numQci)
2409 cell->qciArray[qci].mask = TRUE;
2410 measCb->measReq.t.prbReq.qci[measCb->measReq.t.prbReq.numQci++] = qci;
2424 /**********************************************************************
2427 **********************************************************************/