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 PUBLIC 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 PUBLIC S16 rgCFGVldtCrgCellCfg
123 PUBLIC S16 rgCFGVldtCrgCellCfg(inst,cellCfg, errInfo)
129 TRC2(rgCFGVldtCrgCellCfg);
131 errInfo->errCause = RGERR_CFG_INVALID_CRG_CELL_CFG;
132 if ((rgCb[inst].cell != NULLP)
133 || rgCb[inst].inactiveCell != NULLP)
135 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Cell already exists");
138 if ((cellCfg->bwCfg.dlTotalBw < RG_MIN_DL_BW
139 || cellCfg->bwCfg.dlTotalBw > RG_MAX_DL_BW)
140 || (cellCfg->bwCfg.ulTotalBw < RG_MIN_UL_BW
141 || cellCfg->bwCfg.ulTotalBw > RG_MAX_UL_BW))
143 RLOG_ARG2(L_ERROR,DBG_CELLID,cellCfg->cellId,
144 "Invalid Bandwidth configuration: ul %d dl %d",
145 cellCfg->bwCfg.ulTotalBw, cellCfg->bwCfg.dlTotalBw);
148 if (cellCfg->rachCfg.maxMsg3Tx < RG_MIN_HQ_TX)
150 RLOG_ARG1(L_ERROR,DBG_CELLID,cellCfg->cellId,
151 "Invalid RACH configuration: maxMsg3Tx %d",cellCfg->rachCfg.maxMsg3Tx);
154 #ifdef TENB_MULT_CELL_SUPPRT
155 if((cellCfg->rguDlSapId > rgCb[inst].numRguSaps) ||
156 (cellCfg->rguUlSapId > rgCb[inst].numRguSaps))
158 RGDBGERRNEW(inst,(rgPBuf(inst), "Invald Sap Id: DL %d UL %d for CellId %d failed\n",
165 errInfo->errCause = RGERR_NONE;
167 } /* rgCFGVldtCrgCellCfg */
171 * @brief Validates the UE configuration request from RRC to MAC.
175 * Function : rgCFGVldtCrgUeCfg
178 * - Validate the UE configuration request from RRC to MAC at CFG:
179 * validate the value range for the configured values.
180 * - If validated successfully,
181 * - Return ROK and pointer to the cell of UE.
185 * @param[in] Inst inst
186 * @param[in] CrgUeCfg *ueCfg
187 * @param[out] RgCellCb **cell
188 * @param[out] RgErrInfo *errInfo
194 PUBLIC S16 rgCFGVldtCrgUeCfg
202 PUBLIC S16 rgCFGVldtCrgUeCfg(inst,ueCfg, cell, errInfo)
209 TRC2(rgCFGVldtCrgUeCfg);
211 errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_CFG;
212 if ((ueCfg->txMode.pres == PRSNT_NODEF) &&
213 (ueCfg->txMode.tm == CRG_UE_TM_5))
215 RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Transmission Mode=%d not supported",
220 /* Fetch the Active cell */
221 if(((*cell = rgCb[inst].cell) == NULLP) ||
222 ((*cell)->cellId != ueCfg->cellId))
224 RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Active Cell does not exist for cellId%d",
228 /* Check if Ue already configured */
229 if (rgDBMGetUeCb(*cell, ueCfg->crnti) != NULLP)
231 RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"Ue already exists");
235 if (ueCfg->ueUlHqCfg.maxUlHqTx < RG_MIN_HQ_TX)
237 RLOG_ARG1(L_ERROR,DBG_CRNTI,ueCfg->crnti, "Invalid Uplink HARQ config %d ",
238 ueCfg->ueUlHqCfg.maxUlHqTx);
241 #ifdef TENB_MULT_CELL_SUPPRT
242 if((ueCfg->rguDlSapId > rgCb[inst].numRguSaps) ||
243 (ueCfg->rguUlSapId > rgCb[inst].numRguSaps))
245 RGDBGERRNEW(inst,(rgPBuf(inst), "Invald Sap Id: DL %d UL %d for ueId %d failed\n",
253 errInfo->errCause = RGERR_NONE;
255 } /* rgCFGVldtCrgUeCfg */
259 * @brief Validates the logical channel configuration request from RRC to MAC.
263 * Function : rgCFGVldtCrgLcCfg
266 * - Validate the logical channel configuration request from RRC to
267 * MAC at CFG: validate if configured values are within the range.
268 * - If validated successfully,
269 * - Return ROK and pointer to the cell for common channels. Return
270 * pointer to cell and UE for dedicated logical channels.
274 * @param[in] CrgLchCfg *lcCfg
275 * @param[in] Inst inst
276 * @param[out] RgCellCb **cell
277 * @param[out] RgUeCb **ue
278 * @param[out] RgErrInfo *errInfo
284 PUBLIC S16 rgCFGVldtCrgLcCfg
293 PUBLIC S16 rgCFGVldtCrgLcCfg(inst,lcCfg, cell, ue, errInfo)
302 TRC2(rgCFGVldtCrgLcCfg);
304 if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
306 /* Dedicated logical channels */
307 if ((rgCFGVldtCrgDedLcCfg(inst,lcCfg, cell, ue, errInfo)) != ROK)
309 RLOG_ARG0(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Validation for dedicated LC failed");
313 else if (lcCfg->lcType == CM_LTE_LCH_BCCH
314 || lcCfg->lcType == CM_LTE_LCH_PCCH
315 || lcCfg->lcType == CM_LTE_LCH_CCCH)
317 if ((rgCFGVldtCrgCmnLcCfg(inst,lcCfg, cell, errInfo)) != ROK)
319 RLOG_ARG0(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Validation for common logical channels failed");
325 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid logical channel type %d",
330 if ( lcCfg->qci < RG_QCI_MIN ||
331 lcCfg->qci > RG_QCI_MAX
334 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid qci %x",lcCfg->qci);
338 #endif /*LTE_L2_MEAS */
340 errInfo->errCause = RGERR_NONE;
342 } /* rgCFGVldtCrgLcCfg */
346 * @brief Validates the cell re-configuration request from RRC to MAC.
350 * Function : rgCFGVldtCrgCellRecfg
353 * - Retrieve the cell control block.
355 * - Validate the range of re-configured values recieved in
356 * re-configuration request.
357 * - If validated successfully,
358 * - Return ROK and pointer to the cell.
361 * - Else return RFAILED.
363 * @param[in] Inst inst
364 * @param[in] CrgCellRecfg *cellRecfg
365 * @param[out] RgCellCb **cell
366 * @param[out] RgErrInfo *errInfo
372 PUBLIC S16 rgCFGVldtCrgCellRecfg
375 CrgCellRecfg *cellRecfg,
380 PUBLIC S16 rgCFGVldtCrgCellRecfg(inst,cellRecfg, cell, errInfo)
382 CrgCellRecfg *cellRecfg;
387 TRC2(rgCFGVldtCrgCellRecfg);
389 errInfo->errCause = RGERR_CFG_INVALID_CRG_CELL_RECFG;
391 if (((*cell = rgCb[inst].cell) == NULLP)
392 && ((*cell = rgCb[inst].inactiveCell) == NULLP))
394 RLOG_ARG0(L_ERROR,DBG_CELLID,cellRecfg->cellId,"Cell does not exist");
398 if((*cell)->cellId != cellRecfg->cellId)
400 RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId, "Cell does not exist %d\n",cellRecfg->cellId);
403 if (cellRecfg->rachRecfg.maxMsg3Tx < RG_MIN_HQ_TX)
405 RLOG_ARG1(L_ERROR,DBG_CELLID,cellRecfg->cellId,
406 "Invalid RACH configuration: maxMsg3Tx %d",cellRecfg->rachRecfg.maxMsg3Tx);
409 errInfo->errCause = RGERR_NONE;
411 } /* rgCFGVldtCrgCellRecfg */
415 * @brief Validates the UE re-configuration request from RRC to MAC.
419 * Function : rgCFGVldtCrgUeRecfg
422 * - Retrieve the UE control block.
424 * - Validate the range of re-configured values recieved in
425 * re-configuration request.
426 * - If validated successfully,
427 * - Return ROK and pointer to the cell and ue.
430 * - Else return RFAILED.
432 * @param[in] Inst inst
433 * @param[in] CrgUeRecfg *ueRecfg
434 * @param[out] RgCellCb **cell
435 * @param[out] RgUeCb **ue
436 * @param[out] RgErrInfo *errInfo
442 PUBLIC S16 rgCFGVldtCrgUeRecfg
451 PUBLIC S16 rgCFGVldtCrgUeRecfg(inst,ueRecfg, cell, ue, errInfo)
459 TRC2(rgCFGVldtCrgUeRecfg);
461 errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_RECFG;
463 if ((ueRecfg->txMode.pres == PRSNT_NODEF) &&
464 (ueRecfg->txMode.tm == CRG_UE_TM_5))
466 RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Transmission Mode=%d not supported",
471 /* Fetch the Active cell */
472 if (((*cell = rgCb[inst].cell) == NULLP)
473 || ((*cell)->cellId != ueRecfg->cellId))
475 RLOG_ARG0(L_ERROR,DBG_CELLID,ueRecfg->cellId, "Active Cell does not exist\n");
479 /* Fix : syed UE ID change at MAC will now be controlled
481 if ((*ue = rgDBMGetUeCb(*cell, ueRecfg->oldCrnti)) == NULLP)
483 RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"[%d]Old Ue does not exist", ueRecfg->oldCrnti);
486 if (ueRecfg->ueUlHqRecfg.maxUlHqTx < RG_MIN_HQ_TX)
488 RLOG_ARG1(L_ERROR,DBG_CELLID,ueRecfg->cellId,"Invalid Uplink HARQ config for UE %d",
489 ueRecfg->ueUlHqRecfg.maxUlHqTx);
492 errInfo->errCause = RGERR_NONE;
494 } /* rgCFGVldtCrgUeRecfg */
498 * @brief Validates the logical channel re-configuration request from
503 * Function : rgCFGVldtCrgLcRecfg
506 * - Retrieve the uplink and downlink logical channel control block.
508 * - Validate the range of re-configured values recieved in
509 * re-configuration request.
510 * - If validated successfully,
511 * - Return ROK and pointer to the cell, UE and logical channel.
514 * - Else return RFAILED.
516 * @param[in] Inst inst
517 * @param[in] CrgLchRecfg *lcRecfg
518 * @param[out] RgCellCb **cell
519 * @param[out] RgUeCb **ue
520 * @param[out] RgUlLcCb **ulLc
521 * @param[out] RgDlLcCb **dlLc
522 * @param[out] RgErrInfo *errInfo
528 PUBLIC S16 rgCFGVldtCrgLcRecfg
531 CrgLchRecfg *lcRecfg,
538 PUBLIC S16 rgCFGVldtCrgLcRecfg(inst,lcRecfg, cell, ue, ulLc, errInfo)
540 CrgLchRecfg *lcRecfg;
547 TRC2(rgCFGVldtCrgLcRecfg);
549 errInfo->errCause = RGERR_CFG_INVALID_CRG_LC_RECFG;
552 if ((((*cell = rgCb[inst].cell)) == NULLP)
553 || ((*cell)->cellId != lcRecfg->cellId))
555 RLOG_ARG2(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Active Cell %u does not exist for UE %u", lcRecfg->cellId, lcRecfg->crnti);
558 /* Fetch the Ue for dedicated channels */
559 if ((*ue = rgDBMGetUeCb(*cell, lcRecfg->crnti)) == NULLP)
561 RLOG_ARG0(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Ue does not exist for dedicated logical channel");
565 if ((*ulLc = rgDBMGetUlDedLcCb((*ue), lcRecfg->lcId)) == NULLP)
567 RLOG_ARG1(L_ERROR, DBG_CRNTI,lcRecfg->crnti,"Dedicated UL LC does not exist %d",lcRecfg->lcId);
571 if (lcRecfg->ulRecfg.lcgId > (RG_MAX_LCG_PER_UE - 1))
573 RLOG_ARG2(L_ERROR,DBG_CRNTI,lcRecfg->crnti,"Invalid lcgId for uplink logical channel lcg %d lc %d",
574 lcRecfg->ulRecfg.lcgId, lcRecfg->lcId);
578 errInfo->errCause = RGERR_NONE;
580 } /* rgCFGVldtCrgLcRecfg */
582 /* Start: LTEMAC_2.1_DEV_CFG */
584 * @brief Validates the UE Reset request from RRC to MAC.
588 * Function : rgCFGVldtCrgUeReset
591 * - Retrieve the CELL control block.
594 * - Retrieve the UE control block.
598 * @param[in] Inst inst
599 * @param[in] CrgRst *reset,
600 * @param[out] RgCellCb **cell
601 * @param[out] RgUeCb **ue
602 * @param[out] RgErrInfo *errInfo
608 PUBLIC S16 rgCFGVldtCrgUeReset
617 PUBLIC S16 rgCFGVldtCrgUeReset(inst,reset, cell, ue, errInfo)
625 TRC2(rgCFGVldtCrgUeReset);
627 errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_RESET;
629 /* Fetch the Active cell */
630 if (((*cell = rgCb[inst].cell) == NULLP)
631 || ((*cell)->cellId != reset->cellId))
633 RGDBGERRNEW(inst,(rgPBuf(inst), "[%d]Active Cell does not exist %d\n",reset->crnti, reset->cellId));
634 RLOG_ARG1(L_ERROR,DBG_CRNTI,reset->crnti,"Active Cell does not exist %d",reset->cellId);
639 if ((*ue = rgDBMGetUeCb(*cell, reset->crnti)) == NULLP)
641 RLOG_ARG0(L_ERROR,DBG_CRNTI,reset->crnti,"UE does not exist");
645 errInfo->errCause = RGERR_NONE;
647 } /* rgCFGVldtCrgUeReset*/
648 /* End: LTEMAC_2.1_DEV_CFG */
653 * @brief Handler for the cell configuration request from RRC to MAC.
657 * Function : rgCFGCrgCellCfg
660 * - Allocate and create cell control block.
661 * - Update cell control block with the values recieved in the
663 * - Add the control block to hash list of cells.
664 * - Update the statistics.
665 * - If successful, return ROK else return RFAILED.
667 * @param[in] Inst inst
668 * @param[in] CrgCellCfg *cellCfg
669 * @param[out] RgErrInfo *errInfo
675 PUBLIC S16 rgCFGCrgCellCfg
682 PUBLIC S16 rgCFGCrgCellCfg(inst,cellCfg, errInfo)
689 RgCellCb *cell = NULLP;
693 /* RLC SAP to allocate flowCntrlInd buffer*/
696 TRC2(rgCFGCrgCellCfg);
698 errInfo->errCause = RGERR_CFG_CRG_CELL_CFG;
700 /* Allocate the cell control block */
701 if((ret = rgAllocSBuf(inst,(Data**)&cell, sizeof(RgCellCb))) != ROK)
703 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"Memory allocation FAILED for cell");
708 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId, "Memory allocation FAILED for cell");
712 /* Initialize the cell */
713 cell->cellId = cellCfg->cellId;
714 cell->rachCfg = cellCfg->rachCfg;
715 cell->bwCfg = cellCfg->bwCfg;
717 if(cellCfg->emtcEnable)
719 cell->emtcEnable = cellCfg->emtcEnable;
722 /* Initialize UL and DL CCCH logical channels */
723 cell->ulCcchId = RG_INVALID_LC_ID;
724 cell->dlCcchId = RG_INVALID_LC_ID;
727 /* Initialize the lists of the cell */
728 ret = rgDBMInitCell(cell);
731 RLOG_ARG0(L_ERROR,DBG_CELLID,cellCfg->cellId,"DBM initialization for cell failed");
732 rgCFGFreeInactvCellCb(cell);
737 if (RFAILED == RgLaaCellCbInit(cell))
739 rgCFGFreeInactvCellCb(cell);
744 for(idx=0;idx < RG_NUM_SUB_FRAMES; idx++)
746 cell->subFrms[idx].txDone = TRUE;
749 cell->macInst = inst + RG_INST_START;
750 /* Insert cell in the incative cell list */
751 rgCb[inst].inactiveCell = cell;
752 rgCb[inst].cell = NULLP;
753 #ifdef TENB_MULT_CELL_SUPPRT
754 rguDlSapId = cellCfg->rguDlSapId;
755 rguUlSapId = cellCfg->rguUlSapId;
757 if(rgCb[inst].numRguSaps > 1)
762 cell->rguDlSap = &(rgCb[inst].rguSap[rguDlSapId]);
763 cell->rguUlSap = &(rgCb[inst].rguSap[rguUlSapId]);
767 cmLListInit(&cell->l2mList);
768 for(idx = 0; idx < RG_NUM_UL_SUB_FRAMES; idx++)
770 cmMemset((U8 *)&cell->ulSf[idx], 0, sizeof(RgUlSf));
773 cell->ttiCycle = (U32)RG_TTI_CYCLE_INVLD;
775 /* Update Statistics */
776 rgUpdtCellCnt(inst,RG_CFG_ADD);
777 errInfo->errCause = RGERR_NONE;
779 pst = &rgCb[inst].rguSap[rguDlSapId].sapCfg.sapPst;
780 /* Allocate a buffer for flowCntrlInd.*/
781 SGetSBuf(pst->region, pst->pool, (Data **)&cell->flowCntrlInd,
782 sizeof(RguFlowCntrlInd));
784 } /* rgCFGCrgCellCfg */
788 * @brief Add SCell Cfg recvd from primary MAC instance.
792 * Function : rgCfgAddUeSCellCfg
795 * - Allocate and create UE control block.
796 * - Update UE control block with the values recieved in the
798 * - If successful, add the control block to hash list of UEs for the cell
799 * else Rollback and FAIL.
801 * @param[in] Inst dstMacInst
802 * @param[in] RgPrgUeSCellCfgInfo *ueSCellCb
803 * @param[in] RgCellCb cell
810 PUBLIC S16 rgCfgAddUeSCellCfg
813 RgPrgUeSCellCfgInfo *ueSCellCb,
817 PUBLIC S16 rgCfgAddUeSCellCfg(dstMacInst, ueSCellCb, cell)
819 RgPrgUeSCellCfgInfo *ueSCellCb;
823 RgUeCb *ueCb = NULLP;
829 TRC2(rgCfgAddUeSCellCfg);
832 rguDlSapId = ueSCellCb->rguDlSapId;
833 rguUlSapId = ueSCellCb->rguUlSapId;
835 #ifndef TENB_MULT_CELL_SUPPRT
836 if(rgCb[dstMacInst].numRguSaps > 1)
842 if ((ueCb = rgDBMGetUeCb(cell, ueSCellCb->ueId)) != NULLP)
844 RGDBGERRNEW(dstMacInst,(rgPBuf(dstMacInst),
845 "[%d]Ue already exist in scell %d during scell addition\n",
852 if((ueCb = rgRAMCreateUeCb(cell, ueSCellCb->ueId,
853 FALSE, &errInfo)) == NULLP)
855 RGDBGERRNEW(dstMacInst, (rgPBuf(dstMacInst),
856 "[%d]UeCb creation failed\n", ueSCellCb->ueId));
860 if(rgDHMHqEntInit(dstMacInst, &ueCb->dl.hqEnt,
861 (rgCb[dstMacInst].cell)->maxDlHqProcPerUe) != ROK)
863 RGDBGERRNEW(dstMacInst,(rgPBuf(dstMacInst),
864 "[%d]UeCb Harq Entity Initialization failed\n", ueSCellCb->ueId));
867 rgDBMInsUeCb(cell, ueCb);
870 ueCb->rguDlSap = &(rgCb[dstMacInst].rguSap[rguDlSapId]);
871 ueCb->rguUlSap = &(rgCb[dstMacInst].rguSap[rguUlSapId]);
873 /* Update satistics */
874 rgUpdtUeCnt(dstMacInst, RG_CFG_ADD);
875 /*Commit Added SCell info to UeCb */
877 ueCb->sCelAddInfo[idx].isSCellAdded = TRUE;
878 ueCb->sCelAddInfo[idx].macInst = dstMacInst;
879 ueCb->sCelAddInfo[idx].sCellId = ueSCellCb->cellId;
882 ueCb->txMode = ueSCellCb->txMode;
883 ueCb->ul.hqEnt.maxHqRetx = ueSCellCb->maxUlHqRetx;
885 for (idx =0; idx <RG_MAX_LC_PER_UE; idx++)
887 ueCb->ul.lcCb[idx] = ueSCellCb->ulLcInfo[idx];
888 ueCb->dl.lcCb[idx] = ueSCellCb->dlLcInfo[idx];
891 for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
893 ueCb->ul.lcgArr[idx].lcgId = ueSCellCb->lcgInfo[idx].lcgId;
894 ueCb->ul.lcgArr[idx].lcCount = ueSCellCb->lcgInfo[idx].lcCount;
895 ueCb->ul.lcgArr[idx].isGbr = ueSCellCb->lcgInfo[idx].isGbr;
898 }/* rgCfgAddUeSCellCfg */
901 * @brief SCell Config Filling for added cell from RRC to MAC.
905 * Function : rgFillAndAddSCellCfg
908 * - Update UE control block with the values recieved in the
910 * - Update UE control block with the values present in the
912 * - If successful, add the control block to hash list of UEs for the cell
913 * else Rollback and FAIL.
915 * @param[in] Inst inst
916 * @param[in] RgCellCb *cell
917 * @param[in] CrgUeCfg *ueCfg
918 * @param[in] CrgCfgTransId transId
924 PUBLIC S16 rgFillAndAddSCellCfg
929 CrgCfgTransId transId,
933 PUBLIC S16 rgFillAndAddSCellCfg(inst, cell, ueRecfg, transId, isCfmRqrd)
937 CrgCfgTransId transId;
944 RgPrgUeSCellCfgInfo ueSCellCb;
947 TRC2(rgFillAndAddSCellCfg);
949 /* Fetch the Active cell */
950 if(((cell = rgCb[inst].cell) == NULLP) ||
951 (cell->cellId != ueRecfg->cellId))
953 RGDBGERRNEW(inst,(rgPBuf(inst),
954 "[%d]Active Cell does not exist %d\n",
955 ueRecfg->oldCrnti, ueRecfg->cellId));
959 RGDBGPRM(inst,(rgPBuf(inst),
960 "Filling SCell Config : cellId %d ueId %d\n",
961 cell->cellId, cell->ueId));
963 if ((ue = rgDBMGetUeCb(cell, ueRecfg->oldCrnti)) == NULLP)
965 RGDBGERRNEW(inst,(rgPBuf(inst),
966 "[%d]Ue does not exist\n", ueRecfg->oldCrnti));
970 /* Initialize cfgCfmInfo in the ueCb. This is used while processing SCellAdd
972 ue->cfgCfmInfo.numSCells = ueRecfg->crgSCellCfg.numSCells;
973 ue->cfgCfmInfo.cfgCfgCount = 0;
974 ue->cfgCfmInfo.mask = 0x0;
976 cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
977 sizeof(CrgCfgTransId));
978 ueSCellCb.ueId = ueRecfg->oldCrnti;
979 ueSCellCb.txMode = ue->txMode;
980 ueSCellCb.maxUlHqRetx = ue->ul.hqEnt.maxHqRetx;
981 cmMemcpy((U8 *)ueSCellCb.ulLcInfo, (U8 *)ue->ul.lcCb, sizeof(ue->ul.lcCb));
982 cmMemcpy((U8 *)ueSCellCb.dlLcInfo, (U8 *)ue->dl.lcCb, sizeof(ue->dl.lcCb));
983 for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
985 ueSCellCb.lcgInfo[idx].lcgId = ue->ul.lcgArr[idx].lcgId;
986 ueSCellCb.lcgInfo[idx].lcCount = ue->ul.lcgArr[idx].lcCount;
987 ueSCellCb.lcgInfo[idx].isGbr = ue->ul.lcgArr[idx].isGbr;
991 idx < ueRecfg->crgSCellCfg.numSCells; idx++)
993 dstMacInst = ueRecfg->crgSCellCfg.ueSCellCfg[idx].macInst - RG_INST_START;
994 ueSCellCb.cellId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].sCellId;
995 ueSCellCb.rguDlSapId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].rguDlSapId;
996 ueSCellCb.rguUlSapId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].rguUlSapId;
998 /* Get post structure of the cell to whom ueSCellCb needs to be sent
999 * And then send the sCell Add based on Mac instances */
1000 rgGetPstToInst(&dstInstPst, inst, dstMacInst);
1001 RgPrgPMacSMacUeSCellCfg(&dstInstPst, &ueSCellCb);
1003 /*Commit Added SCell info to UeCb is moved to config confirm*/
1004 } /*end of for loop */
1008 } /* rgFillAndAddSCellCfg */
1009 #endif /* LTE_ADV */
1012 * @brief Handler for the UE configuration request from RRC to MAC.
1016 * Function : rgCFGCrgUeCfg
1019 * - Allocate and create UE control block.
1020 * - Update UE control block with the values recieved in the
1022 * - Invoke RAM, SCH, UHM and DHM with created UE control block, to
1023 * update random access, scheduler, uplink harq and downlink harq
1024 * specific information respectively.
1025 * - If successful, add the control block to hash list of UEs for the cell
1026 * else Rollback and FAIL.
1028 * @param[in] Inst inst
1029 * @param[in] RgCellCb *cell
1030 * @param[in] CrgUeCfg *ueCfg
1031 * @param[out] RgErrInfo *errInfo
1037 PUBLIC S16 rgCFGCrgUeCfg
1045 PUBLIC S16 rgCFGCrgUeCfg(inst,cell, ueCfg, errInfo)
1053 Bool handover = FALSE;
1054 SuId rguUlSapId = 0;
1055 SuId rguDlSapId = 0;
1057 TRC2(rgCFGCrgUeCfg);
1059 errInfo->errCause = RGERR_CFG_CRG_UE_CFG;
1061 /* Start: LTEMAC_2.1_DEV_CFG */
1062 if ((ue = rgDBMGetUeCbFromRachLst(cell, ueCfg->crnti)) == NULLP)
1064 /* Create UeCb and Insert in Rach List */
1065 if((ue=rgRAMCreateUeCb(cell, ueCfg->crnti, FALSE, errInfo)) == NULLP)
1067 RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"UeCb creation failed");
1070 if(rgDHMHqEntInit(inst,&ue->dl.hqEnt, cell->maxDlHqProcPerUe) != ROK)
1072 RLOG_ARG0(L_ERROR,DBG_CRNTI,ueCfg->crnti,"UeCb Harq Entity Initialization failed");
1077 /* End: LTEMAC_2.1_DEV_CFG */
1079 if(handover == FALSE)
1081 /* Remove from the rachLst */
1082 rgDBMDelUeCbFromRachLst(cell, ue);
1086 /* Initialize uplink HARQ related information for UE */
1087 rgUHMCrgUeCfg(cell, ue, ueCfg);
1089 rgDBMInsUeCb(cell, ue);
1091 #ifdef TENB_MULT_CELL_SUPPRT
1092 rguDlSapId = ueCfg->rguDlSapId;
1093 rguUlSapId = ueCfg->rguUlSapId;
1095 if(rgCb[inst].numRguSaps > 1)
1101 ue->rguDlSap = &(rgCb[inst].rguSap[rguDlSapId]);
1102 ue->rguUlSap = &(rgCb[inst].rguSap[rguUlSapId]);
1105 /* Update satistics */
1106 rgUpdtUeCnt(inst,RG_CFG_ADD);
1107 errInfo->errCause = RGERR_NONE;
1109 } /* rgCFGCrgUeCfg */
1113 * @brief Handler for the logical channel configuration request from
1118 * Function : rgCFGCrgLcCfg
1121 * - Check if the configuration is for dedicated or common logical channel.
1122 * - For Dedicated logical channels:
1123 * - Update the dedicated logical channel Cb with the configured values.
1124 * - Invoke SCH will cell, UE and logical channel Cb to update scheduler
1125 * specific information.
1126 * - For Common logical channels:
1127 * - Update the common logical channel Cb with the configured values.
1128 * - Move cell to active list of cells if cell becomes ACTIVE.
1129 * - If successful, return ROK else RFAILED.
1131 * @param[in] Inst inst
1132 * @param[in] RgCellCb *cell
1133 * @param[in] RgUeCb *ue
1134 * @param[in] CrgLchCfg *lcCfg
1135 * @param[out] RgErrInfo *errInfo
1136 * @param[in] Bool *isCfmRqrd
1142 PUBLIC S16 rgCFGCrgLcCfg
1150 CrgCfgTransId transId
1153 PUBLIC S16 rgCFGCrgLcCfg(inst,cell, ue, lcCfg, errInfo, isCfmRqrd,transId)
1160 CrgCfgTransId transId;
1164 TRC2(rgCFGCrgLcCfg);
1166 /* Handle Config for dedicated/common logical channels */
1167 if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
1170 if ((rgCFGCrgDedLcCfg(cell, ue, lcCfg, errInfo)) != ROK)
1172 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,
1173 "Dedicated logical channel configuration failed %d",lcCfg->lcId);
1177 /*ERAB Multl Cell fix*/
1178 cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
1179 sizeof(CrgCfgTransId));
1180 rgPomSndUeSCellLchAddToSmac(inst, cell, ue, lcCfg,isCfmRqrd);
1185 if ((rgCFGCrgCmnLcCfg(inst,cell, lcCfg, errInfo)) != ROK)
1187 RLOG_ARG1(L_ERROR, DBG_CRNTI, lcCfg->crnti, "Common logical channel configuration"
1188 "failed %d\n", lcCfg->lcId);
1193 errInfo->errCause = RGERR_NONE;
1194 RLOG_ARG1(L_INFO, DBG_CRNTI,lcCfg->crnti, "CRG LC config done for UE: lcId %d\n", lcCfg->lcId);
1196 } /* rgCFGCrgLcCfg */
1200 * @brief Handler for the cell re-configuration request from RRC to MAC.
1204 * Function : rgCFGCrgCellRecfg
1207 * - Invoke SCH with updated Cell Cb to update scheduler specific
1209 * - Update the cell Cb with the reconfigured values.
1210 * - If successful, return ROK else RFAILED.
1212 * @param[in] Inst inst
1213 * @param[in] RgCellCb *cell
1214 * @param[in] CrgCellRecfg *cellRecfg
1215 * @param[out] RgErrInfo *errInfo
1221 PUBLIC S16 rgCFGCrgCellRecfg
1225 CrgCellRecfg *cellRecfg,
1229 PUBLIC S16 rgCFGCrgCellRecfg(inst,cell, cellRecfg, errInfo)
1232 CrgCellRecfg *cellRecfg;
1236 TRC2(rgCFGCrgCellRecfg);
1238 /* Store the given rachCfg */
1239 cell->rachCfg = cellRecfg->rachRecfg;
1241 errInfo->errCause = RGERR_NONE;
1243 } /* rgCFGCrgCellRecfg */
1247 * @brief Handler for the UE re-configuration request from RRC to MAC.
1251 * Function : rgCFGCrgUeRecfg
1254 * - If rnti changes,
1255 * - Invoke RAM for UE reconfiguration.
1256 * - Delete old UE from the list.
1257 * - Update the new rnti and re-insert the UE in the list.
1258 * - Update the UE control block with the reconfigured values.
1259 * - Invoke SCH, UHM and DHM with updated UE control block to
1260 * update scheduler, uplink HARQ and downlink HARQ specific
1262 * - If successful, return ROK else RFAILED.
1264 * @param[in] Inst inst
1265 * @param[in] RgCellCb *cell
1266 * @param[in] RgUeCb *ue
1267 * @param[in] CrgUeRecfg *ueRecfg
1268 * @param[out] RgErrInfo *errInfo
1274 PUBLIC S16 rgCFGCrgUeRecfg
1279 CrgUeRecfg *ueRecfg,
1283 PUBLIC S16 rgCFGCrgUeRecfg(inst,cell, ue, ueRecfg, errInfo)
1287 CrgUeRecfg *ueRecfg;
1291 TRC2(rgCFGCrgUeRecfg);
1293 errInfo->errCause = RGERR_CFG_CRG_UE_RECFG;
1295 /* Fix : syed UE ID change at MAC will now be controlled
1298 /* Update uplink HARQ related information for UE */
1299 rgUHMCrgUeRecfg(cell, ue, ueRecfg);
1301 errInfo->errCause = RGERR_NONE;
1303 } /* rgCFGCrgUeRecfg */
1307 * @brief Handler for the logical channel re-configuration request from
1312 * Function : rgCFGCrgLcRecfg
1315 * - Invoke scheduler to update scheduler specific information.
1316 * - Update the dedicated logical channel Cb with the re-configured
1318 * - If successful, return ROK else RFAILED.
1320 * @param[in] Inst inst
1321 * @param[in] RgUlCellCb *cell
1322 * @param[in] RgUlUeCb *ue
1323 * @param[in] RgUlLcCb *ulLc
1324 * @param[in] RgDlLcCb *dlLc
1325 * @param[in] CrgLchRecfg *lcRecfg
1326 * @param[out] RgErrInfo *errInfo
1332 PUBLIC S16 rgCFGCrgLcRecfg
1338 CrgLchRecfg *lcRecfg,
1343 PUBLIC S16 rgCFGCrgLcRecfg(inst,cell, ue, ulLc, lcRecfg, errInfo, isCfmRqrd)
1348 CrgLchRecfg *lcRecfg;
1353 TRC2(rgCFGCrgLcRecfg);
1355 if (ulLc->lcgId != lcRecfg->ulRecfg.lcgId)
1357 rgDBMUpdUlDedLcCb(ue, ulLc, lcRecfg->ulRecfg.lcgId);
1359 rgPomSndUeSCellLchModToSmac(inst, cell, ue, lcRecfg,isCfmRqrd);
1363 errInfo->errCause = RGERR_NONE;
1365 } /* rgCFGCrgLcRecfg */
1367 /* Start: LTEMAC_2.1_DEV_CFG */
1369 * @brief Handler for the logical channel re-configuration request from
1374 * Function : rgCFGCrgUeReset
1378 * @param[in] RgUlCellCb *cell
1379 * @param[in] RgUlUeCb *ue
1380 * @param[in] CrgRst *reset
1381 * @param[out] RgErrInfo *errInfo
1387 PUBLIC S16 rgCFGCrgUeReset
1395 PUBLIC S16 rgCFGCrgUeReset(cell, ue, reset, errInfo)
1402 TRC2(rgCFGCrgUeReset);
1404 RLOG_ARG1(L_DEBUG, DBG_CRNTI, ue->ueId, "UE: of cell %d Reset\n", cell->cellId);
1405 rgDHMUeReset(cell, &ue->dl.hqEnt);
1407 errInfo->errCause = RGERR_NONE;
1410 } /* rgCFGCrgUeReset */
1411 /* End: LTEMAC_2.1_DEV_CFG */
1414 * @brief Handler for the cell delete request from RRC to MAC.
1418 * Function : rgCFGCrgCellDel
1421 * - Fetch the cell control block.
1422 * - Remove the cell control block from the hash list of cells.
1423 * - Free the cell control block.
1424 * - If successful, return ROK else return RFAILED.
1426 * @param[in] Inst inst
1427 * @param[in] CrgDel *cellDelInfo
1428 * @param[out] RgErrInfo *errInfo
1434 PUBLIC S16 rgCFGCrgCellDel
1437 CrgDel *cellDelInfo,
1441 PUBLIC S16 rgCFGCrgCellDel(inst,cellDelInfo, errInfo)
1443 CrgDel *cellDelInfo;
1450 TRC2(rgCFGCrgCellDel);
1452 errInfo->errCause = RGERR_CFG_CRG_CELL_DEL;
1453 if (((cell = rgCb[inst].cell) == NULLP)
1454 ||(cell->cellId != cellDelInfo->u.cellDel.cellId))
1456 if(((cell = rgCb[inst].inactiveCell) == NULLP)
1457 ||(cell->cellId != cellDelInfo->u.cellDel.cellId))
1461 RLOG_ARG0(L_ERROR,DBG_CELLID,cellDelInfo->u.cellDel.cellId,"Cell does not exist");
1465 /* Delete cell from inactive list */
1466 rgCb[inst].inactiveCell = NULLP ;
1468 /* Free the inactive cell */
1469 rgCFGFreeInactvCellCb(cell);
1471 errInfo->errCause = RGERR_NONE;
1475 /* Delete from the cell list */
1476 //rgDBMDelCellCb(cell);
1477 for(idx=0;idx < RG_NUM_SUB_FRAMES; idx++)
1479 rgTOMRlsSf(inst,&cell->subFrms[idx]);
1482 /* Free the active cell */
1483 rgCFGFreeCellCb(cell);
1485 rgCb[inst].cell = NULLP;
1487 errInfo->errCause = RGERR_NONE;
1488 RGDBGINFO(inst,(rgPBuf(inst), "Cell %d deleted\n", cellDelInfo->u.cellDel.cellId));
1490 } /* rgCFGCrgCellDel */
1494 * @brief Handler for the UE delete request from RRC to MAC.
1498 * Function : rgCFGCrgUeDel
1501 * - Fetch the UE control block.
1502 * - Remove the UE control block from the hash list of UEs for the cell.
1503 * - Free the UE control block.
1504 * - If successful, return ROK else return RFAILED.
1506 * @param[in] Inst inst
1507 * @param[in] CrgDel *ueDelInfo
1508 * @param[out] RgErrInfo *errInfo
1514 PUBLIC S16 rgCFGCrgUeDel
1521 PUBLIC S16 rgCFGCrgUeDel(inst,ueDelInfo, errInfo)
1527 TRC2(rgCFGCrgUeDel);
1529 errInfo->errCause = RGERR_CFG_CRG_UE_DEL;
1531 RLOG_ARG1(L_DEBUG, DBG_CRNTI, ueDelInfo->u.ueDel.crnti, "UE %d Deletion Req at MAC\n", \
1532 ueDelInfo->u.ueDel.crnti);
1533 if ((rgCb[inst].cell == NULLP)
1534 || (rgCb[inst].cell->cellId != ueDelInfo->u.ueDel.cellId))
1536 RLOG_ARG1(L_ERROR,DBG_CRNTI,ueDelInfo->u.ueDel.crnti,"Cell does not exist %d",
1537 ueDelInfo->u.ueDel.cellId);
1541 errInfo->errCause = RGERR_NONE;
1542 /* Fix: syed Context Deletion is relied upon SCH indication */
1544 } /* rgCFGCrgUeDel */
1548 * @brief Handler for the logical channel delete request from
1553 * Function : rgCFGCrgLcDel
1556 * - Fetch the logical channel control block.
1557 * - Free the logical channel control block.
1558 * - If successful, return ROK else return RFAILED.
1560 * @param[in] Inst inst
1561 * @param[in] CrgDel *lcDelInfo
1562 * @param[out] RgErrInfo *errInfo
1568 PUBLIC S16 rgCFGCrgLcDel
1574 CrgCfgTransId transId
1577 PUBLIC S16 rgCFGCrgLcDel(inst,lcDelInfo, errInfo,isCfmRqrd,transId)
1581 CrgCfgTransId transId;
1584 Bool dirVld = FALSE;
1590 TRC2(rgCFGCrgLcDel);
1592 errInfo->errCause = RGERR_CFG_CRG_LC_DEL;
1594 /* Fetch the Active cell */
1595 if (((cell = rgCb[inst].cell) == NULLP) ||
1596 (rgCb[inst].cell->cellId != lcDelInfo->u.lchDel.cellId))
1598 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"Cell does not exist %d",
1599 lcDelInfo->u.lchDel.cellId);
1604 if ((ue = rgDBMGetUeCb(cell, lcDelInfo->u.lchDel.crnti)) == NULLP)
1606 RLOG_ARG0(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,
1607 "UE does not exist for dedicated logical channel");
1611 /* Validate downlink info */
1612 if (lcDelInfo->u.lchDel.dir & CRG_DIR_TX)
1614 if ((dlLc = rgDBMGetDlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
1617 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"DL LC %d does not exist",
1618 lcDelInfo->u.lchDel.lcId);
1621 rgDBMDelDlDedLcCb(ue, dlLc);
1625 /* Validate uplink info */
1626 if (lcDelInfo->u.lchDel.dir & CRG_DIR_RX)
1628 if ((ulLc = rgDBMGetUlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
1631 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"UL LC %d does not exist",
1632 lcDelInfo->u.lchDel.lcId);
1635 rgDBMDelUlDedLcCb(ue, ulLc);
1641 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcDelInfo->u.lchDel.crnti,"Invalid direction %d for LC Delete",
1642 lcDelInfo->u.lchDel.dir);
1646 /*ERAB - multicell fix*/
1647 cmMemcpy( (U8*)&(ue->cfgCfmInfo.transId), (U8*)&transId,
1648 sizeof(CrgCfgTransId));
1649 rgPomSndUeSCellLchDelToSmac(inst, lcDelInfo, isCfmRqrd);
1651 errInfo->errCause = RGERR_NONE;
1653 } /* rgCFGCrgLcDel */
1655 /***********************************************************
1657 * Func : rgCFGVldtCrgDedLcCfg
1660 * Desc : Validates dedicated logical channel configuration recieved from RRC.
1670 **********************************************************/
1672 PRIVATE S16 rgCFGVldtCrgDedLcCfg
1681 PRIVATE S16 rgCFGVldtCrgDedLcCfg(inst,lcCfg, cell, ue, errInfo)
1690 TRC2(rgCFGVldtCrgDedLcCfg);
1692 errInfo->errCause = RGERR_CFG_INVALID_CRG_DED_LC_CFG;
1694 /* Fetch the Active cell */
1695 if (((*cell = rgCb[inst].cell) == NULLP)
1696 || ((*cell)->cellId != lcCfg->cellId))
1698 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Active Cell does not exist: Cell %d",
1704 if ((*ue = rgDBMGetUeCb(*cell, lcCfg->crnti)) == NULLP)
1706 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE does not exist for dedicated logical channel %d",
1711 /* Validate logical channel Id */
1712 if ((lcCfg->lcId < RG_DEDLC_MIN_LCID)
1713 ||(lcCfg->lcId > RG_DEDLC_MAX_LCID))
1715 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid logical channel Id %d",
1720 /* Validate downlink info */
1721 if (lcCfg->dir & CRG_DIR_TX)
1723 if (rgDBMGetDlDedLcCb((*ue), lcCfg->lcId) != NULLP)
1725 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Dedicated DL LC %d already configured",
1732 /* Validate uplink info */
1733 if (lcCfg->dir & CRG_DIR_RX)
1735 if (lcCfg->ulInfo.lcgId > (RG_MAX_LCG_PER_UE - 1))
1737 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Invalid lcgId for uplink logical channel %d",
1738 lcCfg->ulInfo.lcgId);
1741 if (rgDBMGetUlDedLcCb((*ue), lcCfg->lcId) != NULLP)
1743 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"UE: Dedicated UL LC %d already configured",
1752 RLOG_ARG1(L_ERROR,DBG_CRNTI,lcCfg->crnti,"Invalid Direction %d",
1758 } /* rgCFGVldtCrgDedLcCfg */
1761 /***********************************************************
1763 * Func : rgCFGVldtCrgCmnLcCfg
1766 * Desc : Validates common logical channel configuration recieved from RRC.
1776 **********************************************************/
1778 PRIVATE S16 rgCFGVldtCrgCmnLcCfg
1786 PRIVATE S16 rgCFGVldtCrgCmnLcCfg(inst,lcCfg, cell, errInfo)
1795 TRC2(rgCFGVldtCrgCmnLcCfg);
1797 errInfo->errCause = RGERR_CFG_INVALID_CRG_CMN_LC_CFG;
1799 /* Ensure cell is not in the active list */
1800 if (((*cell = rgCb[inst].cell) != NULLP)
1801 && ((*cell)->cellId != lcCfg->cellId))
1803 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"Active Cell exists for common channels");
1807 /* Fetch the inactive cell for common logical channels */
1808 if (((*cell = rgCb[inst].inactiveCell) == NULLP)
1809 || ((*cell)->cellId != lcCfg->cellId))
1812 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"Inactive Cell does not exist for common channels");
1815 /* Validate downlink info */
1816 if (lcCfg->dir & CRG_DIR_TX)
1818 if (lcCfg->lcType == CM_LTE_LCH_BCCH)
1820 if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_DL_SCH)
1822 if (rgDBMGetBcchOnDlsch(*cell,lcCfg->lcId) != NULLP)
1824 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"BCCH on DLSCH already configured for cell");
1828 else if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_BCH)
1830 if (rgDBMGetBcchOnBch(*cell) != NULLP)
1832 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"BCCH on BCH already configured for cell %d");
1838 RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid transport channel %d for cell",
1839 lcCfg->dlInfo.dlTrchType);
1843 else if (lcCfg->lcType == CM_LTE_LCH_PCCH)
1845 if (rgDBMGetPcch(*cell) != NULLP)
1847 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"PCCH already configured for cell");
1851 else if (RG_DLCCCH_ISCFGD(*cell))
1853 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"DL CCCH already configured for cell %d");
1859 /* Validate uplink info */
1860 if (lcCfg->dir & CRG_DIR_RX)
1863 if (lcCfg->lcType != CM_LTE_LCH_CCCH)
1865 RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid UL common lcType %d for cell ",
1869 if (RG_ULCCCH_ISCFGD(*cell))
1871 RLOG_ARG0(L_ERROR,DBG_CELLID,lcCfg->cellId,"UL CCCH already configured for cell ");
1877 /* Invalid direction */
1880 RLOG_ARG1(L_ERROR,DBG_CELLID,lcCfg->cellId,"Invalid Direction %d", lcCfg->dir);
1885 } /* rgCFGVldtCrgCmnLcCfg */
1887 /***********************************************************
1889 * Func : rgCFGCrgDedLcCfg
1892 * Desc : Handles dedicated logical channel configuration
1893 * recieved from RRC.
1903 **********************************************************/
1905 PRIVATE S16 rgCFGCrgDedLcCfg
1913 PRIVATE S16 rgCFGCrgDedLcCfg(cell, ue, lcCfg, errInfo)
1920 //Inst inst = cell->macInst - RG_INST_START;
1921 TRC2(rgCFGCrgDedLcCfg);
1923 errInfo->errCause = RGERR_CFG_CRG_DED_LC_CFG;
1925 /* Uplink/Bi-directional logical channel */
1926 if (lcCfg->dir & CRG_DIR_RX)
1929 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId, lcCfg->qci);
1930 cell->qciArray[lcCfg->qci].qci = lcCfg->qci;
1931 if(lcCfg->lcType == CM_LTE_LCH_DTCH)
1933 rgAddToL2MeasPerQci(cell,lcCfg->qci);/*LTE_L2_MEAS_PHASE2*/
1936 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId);
1940 /* Downlink/Bi-directional logical channel */
1941 if (lcCfg->dir & CRG_DIR_TX)
1943 rgDBMInsDlDedLcCb(ue, lcCfg->lcId);
1946 } /* rgCFGCrgDedLcCfg */
1949 /***********************************************************
1951 * Func : rgCFGCrgCmnLcCfg
1954 * Desc : Handles dedicated logical channel configuration
1955 * recieved from RRC.
1965 **********************************************************/
1967 PRIVATE S16 rgCFGCrgCmnLcCfg
1975 PRIVATE S16 rgCFGCrgCmnLcCfg(inst,cell, lcCfg, errInfo)
1982 TRC2(rgCFGCrgCmnLcCfg);
1984 errInfo->errCause = RGERR_CFG_CRG_CMN_LC_CFG;
1986 /* Handle configuration for CCCH/BCCH/PCCH */
1987 if (lcCfg->lcType == CM_LTE_LCH_CCCH)
1989 /* UL and DL CCCH configuration */
1990 if (lcCfg->dir & CRG_DIR_TX)
1992 cell->dlCcchId = lcCfg->lcId;
1993 cell->cellActvState |= RG_DL_CCCH_CFG_DONE;
1996 if (lcCfg->dir & CRG_DIR_RX)
1998 cell->ulCcchId = lcCfg->lcId;
1999 cell->cellActvState |= RG_UL_CCCH_CFG_DONE;
2004 if (lcCfg->lcType == CM_LTE_LCH_BCCH)
2006 /* BCCH on BCH and DLSCH configuration */
2007 if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_DL_SCH)
2009 rgDBMInsBcchOnDlsch(cell, lcCfg->lcId);
2011 if(cell->cellActvState & RG_BCCH_DLSCH_CFG1_DONE)
2013 cell->cellActvState |= RG_BCCH_DLSCH_CFG2_DONE;
2017 cell->cellActvState |= RG_BCCH_DLSCH_CFG1_DONE;
2022 rgDBMInsBcchOnBch(cell, lcCfg->lcId);
2023 cell->cellActvState |= RG_BCCH_BCH_CFG_DONE;
2026 else /* PCCH configuration */
2028 rgDBMInsPcch(cell, lcCfg->lcId);
2029 cell->cellActvState |= RG_PCCH_CFG_DONE;
2033 /* Add to active cell list if cell is active */
2034 if (cell->cellActvState == RG_CELL_ACTIVE)
2036 rgCb[inst].cell = cell;
2037 rgCb[inst].inactiveCell = NULLP;
2038 RLOG_ARG1(L_DEBUG, DBG_CELLID, cell->cellId, "Cell %d added to active list after common LC %d\
2039 config\n", lcCfg->lcId);
2043 } /* rgCFGCrgCmnLcCfg */
2045 /***********************************************************
2047 * Func : rgCFGFreeUeUlAlloc
2051 * - Processing Steps:
2052 * - Frees cell control block.
2060 **********************************************************/
2062 PRIVATE Void rgCFGFreeUeUlAlloc
2067 PRIVATE Void rgCFGFreeUeUlAlloc(cell)
2072 Inst inst = cell->macInst - RG_INST_START;
2074 TRC2(rgCFGFreeUeUlAlloc);
2076 for(sfIdx = 0; sfIdx < RG_NUM_UL_SUB_FRAMES; sfIdx++)
2078 if(cell->ulSf[sfIdx].ueUlAllocInfo != NULLP)
2080 /*ccpu00117052 - MOD- Passing double pointer for proper
2081 * NULLP assignment */
2082 rgFreeSBuf(inst,(Data **)&(cell->ulSf[sfIdx].ueUlAllocInfo),
2083 (cell->ulSf[sfIdx].numUe * sizeof(RgUeUlAlloc)));
2086 }/* rgCFGFreeUeUlAlloc */
2088 /***********************************************************
2090 * Func : rgCFGFreeCellCb
2094 * - Processing Steps:
2095 * - Frees cell control block.
2103 **********************************************************/
2105 PUBLIC Void rgCFGFreeCellCb
2110 PUBLIC Void rgCFGFreeCellCb(cell)
2114 Inst inst = cell->macInst - RG_INST_START;
2115 TRC2(rgCFGFreeCellCb);
2118 RgLaaCellCbDeInit(cell);
2120 /* Free lists of the cell */
2122 rgCFGFreeSpsUeLst(cell);
2123 #endif /* LTEMAC_SPS */
2124 rgCFGFreeUeLst(cell);
2125 rgRAMFreeCell(cell);
2126 rgCFGFreeCmnLcLst(cell);
2128 rgCFGFreeUeUlAlloc(cell);
2130 /* ccpu00117052 - MOD - Passing double pointer for proper NULLP
2132 /* Update satistics */
2133 rgUpdtCellCnt(inst,RG_CFG_DEL);
2134 rgDHMFreeAllTbBufs(inst);
2136 rgFreeSBuf(inst,(Data **)&cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
2138 /* De-allocate the Cell */
2139 rgFreeSBuf(inst,(Data **)&cell, sizeof(*cell));
2142 RGDBGINFO(inst,(rgPBuf(inst), "Cell freed\n"));
2144 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2146 } /* rgCFGFreeCellCb */
2149 /***********************************************************
2151 * Func : rgCFGFreeInactvCellCb
2155 * - Processing Steps:
2156 * - Frees inactive cell control block.
2164 **********************************************************/
2166 PUBLIC Void rgCFGFreeInactvCellCb
2171 PUBLIC Void rgCFGFreeInactvCellCb(cell)
2175 Inst inst = cell->macInst - RG_INST_START;
2176 TRC2(rgCFGFreeInactvCellCb);
2178 /* De-initialize the Ue list */
2179 rgDBMDeInitUeCbLst(cell);
2181 rgDBMDeInitSpsUeCbLst(cell);
2184 rgCFGFreeCmnLcLst(cell);
2186 rgFreeSBuf(inst, (Data **)&cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
2187 /*ccpu00117052 - MOD- Passing double pointer for proper
2189 /* De-allocate the Cell */
2190 rgFreeSBuf(inst,(Data **)&cell, sizeof(*cell));
2192 /* Update satistics */
2193 rgUpdtCellCnt(inst,RG_CFG_DEL);
2196 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2198 } /* rgCFGFreeInactvCellCb */
2201 /***********************************************************
2203 * Func : rgCFGFreeUeCb
2207 * - Processing Steps:
2208 * - Frees UE control block.
2216 **********************************************************/
2218 PUBLIC Void rgCFGFreeUeCb
2224 PUBLIC Void rgCFGFreeUeCb(cell, ue)
2229 Inst inst = cell->macInst - RG_INST_START;
2231 TRC2(rgCFGFreeUeCb);
2233 rgDHMFreeUe(inst,&ue->dl.hqEnt);
2235 /* ccpu00117052 - MOD - Passing double pointer for proper NULLP
2237 /* De-allocate the Ue */
2238 rgFreeSBuf(inst,(Data **)&ue, sizeof(*ue));
2240 /* Update Statistics */
2241 rgUpdtUeCnt(inst,RG_CFG_DEL);
2244 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2246 } /* rgCFGFreeUeCb */
2248 /***********************************************************
2250 * Func : rgCFGFreeCmnLcLst
2254 * - Processing Steps:
2255 * - Frees common logical channels in cell control block.
2263 **********************************************************/
2265 PRIVATE Void rgCFGFreeCmnLcLst
2270 PRIVATE Void rgCFGFreeCmnLcLst(cell)
2274 TRC2(rgCFGFreeCmnLcLst);
2276 rgDBMFreeCmnLcLst(cell);
2279 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2281 } /* rgCFGFreeCmnLcLst */
2284 /***********************************************************
2286 * Func : rgCFGFreeUeLst
2290 * - Processing Steps:
2291 * - Frees UE list in cell control block.
2299 **********************************************************/
2301 PRIVATE Void rgCFGFreeUeLst
2306 PRIVATE Void rgCFGFreeUeLst(cell)
2312 TRC2(rgCFGFreeUeLst);
2314 /* Free Ues in the list */
2315 while ((ue = rgDBMGetNextUeCb(cell, NULLP)) != NULLP)
2318 rgDelUeFrmAllSCell(cell,ue);
2320 rgDBMDelUeCb(cell, ue);
2321 rgCFGFreeUeCb(cell, ue);
2324 /* De-initialize the Ue list */
2325 rgDBMDeInitUeCbLst(cell);
2328 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2330 } /* rgCFGFreeUeLst */
2333 /***********************************************************
2335 * Func : rgCFGFreeSpsUeLst
2339 * - Processing Steps:
2340 * - Frees Sps UE list in cell control block.
2348 **********************************************************/
2350 PRIVATE Void rgCFGFreeSpsUeLst
2355 PRIVATE Void rgCFGFreeSpsUeLst(cell)
2361 TRC2(rgCFGFreeSpsUeLst);
2363 /* Free Ues in the list */
2364 while ((ue = rgDBMGetNextSpsUeCb(cell, NULLP)))
2366 rgDBMDelSpsUeCb(cell, ue);
2369 /* De-initialize the Ue list */
2370 rgDBMDeInitSpsUeCbLst(cell);
2372 } /* rgCFGFreeSpsUeLst */
2374 #endif /* LTEMAC_SPS */
2377 * @brief Function for registering cell- scheduler instance mapping
2381 * Function : RgSchMacCellRegReq
2383 * This function shall be invoked whenever scheduler is done with the
2384 * cell configuration successfully.
2385 * This shall create a mapping of the cell, scheduler instance that
2386 * is serving the cell and the unique identifier of the cell on the
2387 * scheduler at MAC. This mapping shall be used for further
2388 * communication to the scheduler instance for this cell.
2391 * @param[in] Pst* pst,
2392 * @param[in] CmLteCellId cellId,
2393 * @param[in] RaRespReqInfo raRespReq
2398 PUBLIC S16 RgSchMacCellRegReq
2401 RgInfCellReg* regReq
2404 PUBLIC S16 RgSchMacCellRegReq(pst, regReq)
2406 RgInfCellReg* regReq;
2410 RgCellCb *cell = NULLP;
2412 TRC3(RgSchMacCellRegReq)
2414 RG_IS_INST_VALID(pst->dstInst);
2415 inst = pst->dstInst - RG_INST_START;
2416 cell = rgCb[inst].cell;
2423 if((cell == NULLP) || (cell->cellId != regReq->cellId))
2427 if(regReq->maxDlHqProcPerUe > RG_MAX_DL_HARQ_NUM)
2432 cell->schInstMap.cellSapId = regReq->cellSapId;
2433 cell->schInstMap.schInst = pst->srcInst;
2434 cell->maxDlHqProcPerUe = regReq->maxDlHqProcPerUe;
2438 } /* end of RgSchMacCellRegReq */
2440 /*Added Ue for Onging L2 Meas*/
2442 /*LTE_L2_MEAS_PHASE2*/
2443 PUBLIC S16 rgAddToL2MeasPerQci(RgCellCb *cell,U8 qci)
2450 lnk = cell->l2mList.first;
2451 while(lnk != NULLP )
2453 measCb = (RgL2MeasCb *)lnk->node;
2454 if(measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
2456 for(idx = 0;idx< measCb->measReq.t.prbReq.numQci;idx++)
2458 if(measCb->measReq.t.prbReq.qci[idx] == qci)
2460 break; /*exit from for loop*/
2463 if(idx == measCb->measReq.t.prbReq.numQci)
2465 cell->qciArray[qci].mask = TRUE;
2466 measCb->measReq.t.prbReq.qci[measCb->measReq.t.prbReq.numQci++] = qci;
2480 /**********************************************************************
2483 **********************************************************************/