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.
36 /* header include files -- defines (.h) */
37 #include "common_def.h"
38 #include "lrg.h" /* Layer manager interface includes*/
39 #include "crg.h" /* CRG interface includes*/
40 #include "rgu.h" /* RGU interface includes*/
41 #include "tfu.h" /* TFU interface includes */
42 #include "rg_sch_inf.h" /* SCH interface includes */
43 #include "rg_prg.h" /* PRG (MAC-MAC) interface includes*/
44 #include "rg_env.h" /* MAC environmental includes*/
45 #include "rg.h" /* MAC includes*/
46 #include "rg_err.h" /* MAC error includes*/
47 #include "mac_utils.h"
48 /* header/extern include files (.x) */
49 #include "rgu.x" /* RGU types */
50 #include "tfu.x" /* RGU types */
51 #include "lrg.x" /* layer management typedefs for MAC */
52 #include "crg.x" /* CRG interface includes */
53 #include "rg_sch_inf.x" /* SCH interface typedefs */
54 #include "rg_prg.x" /* PRG (MAC-MAC) Interface typedefs */
55 #include "du_app_mac_inf.h"
56 #include "rg.x" /* typedefs for MAC */
58 #include "rg_pom_scell.x"
60 /* LTE-MAC Control Block Structure */
61 RgCb rgCb[RG_MAX_INST];
64 static S16 rgCFGVldtCrgDedLcCfg ARGS((Inst inst,CrgLchCfg *lcCfg, RgCellCb **cell,
65 RgUeCb **ue, RgErrInfo *errInfo));
66 static S16 rgCFGVldtCrgCmnLcCfg ARGS((Inst inst,CrgLchCfg *lcCfg, RgCellCb **cell,
68 static S16 rgCFGCrgDedLcCfg ARGS((RgCellCb *cell, RgUeCb *ue,
69 CrgLchCfg *lcCfg, RgErrInfo *errInfo));
70 static S16 rgCFGCrgCmnLcCfg ARGS((Inst inst,RgCellCb *cell, CrgLchCfg *lcCfg,
73 static Void rgCFGFreeCmnLcLst ARGS((RgCellCb *cell));
74 static Void rgCFGFreeUeLst ARGS((RgCellCb *cell));
75 /* Added support for SPS*/
77 static Void rgCFGFreeSpsUeLst ARGS((RgCellCb *cell));
78 #endif /* LTEMAC_SPS */
85 /* forward references */
91 * @brief Validates the cell configuration request from RRC to MAC.
95 * Function : rgCFGVldtCrgCellCfg
98 * - Validate the cell configuration request from RRC to MAC at CFG:
99 * validate the value range for the configured values.
100 * - If validated successfully,
105 * @param[in] Inst inst
106 * @param[in] CrgCellCfg *cellCfg
107 * @param[out] RgErrInfo *errInfo
112 S16 rgCFGVldtCrgCellCfg
119 errInfo->errCause = RGERR_CFG_INVALID_CRG_CELL_CFG;
120 if ((rgCb[inst].cell != NULLP)
121 || rgCb[inst].inactiveCell != NULLP)
123 DU_LOG("\nERROR --> MAC : Cell already exists");
126 if ((cellCfg->bwCfg.dlTotalBw < RG_MIN_DL_BW
127 || cellCfg->bwCfg.dlTotalBw > RG_MAX_DL_BW)
128 || (cellCfg->bwCfg.ulTotalBw < RG_MIN_UL_BW
129 || cellCfg->bwCfg.ulTotalBw > RG_MAX_UL_BW))
131 DU_LOG("\nERROR --> MAC : Invalid Bandwidth configuration: ul %d dl %d",
132 cellCfg->bwCfg.ulTotalBw, cellCfg->bwCfg.dlTotalBw);
135 if (cellCfg->rachCfg.maxMsg3Tx < RG_MIN_HQ_TX)
137 DU_LOG("\nERROR --> MAC : Invalid RACH configuration: maxMsg3Tx %d",cellCfg->rachCfg.maxMsg3Tx);
140 #ifdef TENB_MULT_CELL_SUPPRT
141 if((cellCfg->rguDlSapId > rgCb[inst].numRguSaps) ||
142 (cellCfg->rguUlSapId > rgCb[inst].numRguSaps))
144 DU_LOG("\nERROR --> MAC : Invald Sap Id: DL %d UL %d for CellId %d failed\n",
151 errInfo->errCause = RGERR_NONE;
153 } /* rgCFGVldtCrgCellCfg */
157 * @brief Validates the UE configuration request from RRC to MAC.
161 * Function : rgCFGVldtCrgUeCfg
164 * - Validate the UE configuration request from RRC to MAC at CFG:
165 * validate the value range for the configured values.
166 * - If validated successfully,
167 * - Return ROK and pointer to the cell of UE.
171 * @param[in] Inst inst
172 * @param[in] CrgUeCfg *ueCfg
173 * @param[out] RgCellCb **cell
174 * @param[out] RgErrInfo *errInfo
179 S16 rgCFGVldtCrgUeCfg
187 errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_CFG;
188 if ((ueCfg->txMode.pres == PRSNT_NODEF) &&
189 (ueCfg->txMode.tm == CRG_UE_TM_5))
191 DU_LOG("\nERROR --> MAC : Transmission Mode=%d not supported",
196 /* Fetch the Active cell */
197 if(((*cell = rgCb[inst].cell) == NULLP) ||
198 ((*cell)->cellId != ueCfg->cellId))
200 DU_LOG("\nERROR --> MAC : Active Cell does not exist for cellId%d",
204 /* Check if UE already configured */
205 if (rgDBMGetUeCb(*cell, ueCfg->crnti) != NULLP)
207 DU_LOG("\nERROR --> MAC : UE already exists");
211 if (ueCfg->ueUlHqCfg.maxUlHqTx < RG_MIN_HQ_TX)
213 DU_LOG("\nERROR --> MAC : Invalid Uplink HARQ config %d ",
214 ueCfg->ueUlHqCfg.maxUlHqTx);
217 #ifdef TENB_MULT_CELL_SUPPRT
218 if((ueCfg->rguDlSapId > rgCb[inst].numRguSaps) ||
219 (ueCfg->rguUlSapId > rgCb[inst].numRguSaps))
221 DU_LOG("\nERROR --> MAC : Invald Sap Id: DL %d UL %d for ueId %d failed\n",
229 errInfo->errCause = RGERR_NONE;
231 } /* rgCFGVldtCrgUeCfg */
235 * @brief Validates the logical channel configuration request from RRC to MAC.
239 * Function : rgCFGVldtCrgLcCfg
242 * - Validate the logical channel configuration request from RRC to
243 * MAC at CFG: validate if configured values are within the range.
244 * - If validated successfully,
245 * - Return ROK and pointer to the cell for common channels. Return
246 * pointer to cell and UE for dedicated logical channels.
250 * @param[in] CrgLchCfg *lcCfg
251 * @param[in] Inst inst
252 * @param[out] RgCellCb **cell
253 * @param[out] RgUeCb **ue
254 * @param[out] RgErrInfo *errInfo
259 S16 rgCFGVldtCrgLcCfg
269 if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
271 /* Dedicated logical channels */
272 if ((rgCFGVldtCrgDedLcCfg(inst,lcCfg, cell, ue, errInfo)) != ROK)
274 DU_LOG("\nERROR --> MAC : Validation for dedicated LC failed");
278 else if (lcCfg->lcType == CM_LTE_LCH_BCCH
279 || lcCfg->lcType == CM_LTE_LCH_PCCH
280 || lcCfg->lcType == CM_LTE_LCH_CCCH)
282 if ((rgCFGVldtCrgCmnLcCfg(inst,lcCfg, cell, errInfo)) != ROK)
284 DU_LOG("\nERROR --> MAC : Validation for common logical channels failed");
290 DU_LOG("\nERROR --> MAC : Invalid logical channel type %d",
295 if ( lcCfg->qci < RG_QCI_MIN ||
296 lcCfg->qci > RG_QCI_MAX
299 DU_LOG("\nERROR --> MAC : Invalid qci %x",lcCfg->qci);
303 #endif /*LTE_L2_MEAS */
305 errInfo->errCause = RGERR_NONE;
307 } /* rgCFGVldtCrgLcCfg */
311 * @brief Validates the cell re-configuration request from RRC to MAC.
315 * Function : rgCFGVldtCrgCellRecfg
318 * - Retrieve the cell control block.
320 * - Validate the range of re-configured values recieved in
321 * re-configuration request.
322 * - If validated successfully,
323 * - Return ROK and pointer to the cell.
326 * - Else return RFAILED.
328 * @param[in] Inst inst
329 * @param[in] CrgCellRecfg *cellRecfg
330 * @param[out] RgCellCb **cell
331 * @param[out] RgErrInfo *errInfo
336 S16 rgCFGVldtCrgCellRecfg
339 CrgCellRecfg *cellRecfg,
344 errInfo->errCause = RGERR_CFG_INVALID_CRG_CELL_RECFG;
346 if (((*cell = rgCb[inst].cell) == NULLP)
347 && ((*cell = rgCb[inst].inactiveCell) == NULLP))
349 DU_LOG("\nERROR --> MAC : Cell does not exist");
353 if((*cell)->cellId != cellRecfg->cellId)
355 DU_LOG("\nERROR --> MAC : Cell does not exist %d\n",cellRecfg->cellId);
358 if (cellRecfg->rachRecfg.maxMsg3Tx < RG_MIN_HQ_TX)
360 DU_LOG("\nERROR --> MAC : Invalid RACH configuration: maxMsg3Tx %d",cellRecfg->rachRecfg.maxMsg3Tx);
363 errInfo->errCause = RGERR_NONE;
365 } /* rgCFGVldtCrgCellRecfg */
369 * @brief Validates the UE re-configuration request from RRC to MAC.
373 * Function : rgCFGVldtCrgUeRecfg
376 * - Retrieve the UE control block.
378 * - Validate the range of re-configured values recieved in
379 * re-configuration request.
380 * - If validated successfully,
381 * - Return ROK and pointer to the cell and ue.
384 * - Else return RFAILED.
386 * @param[in] Inst inst
387 * @param[in] CrgUeRecfg *ueRecfg
388 * @param[out] RgCellCb **cell
389 * @param[out] RgUeCb **ue
390 * @param[out] RgErrInfo *errInfo
395 S16 rgCFGVldtCrgUeRecfg
404 errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_RECFG;
406 if ((ueRecfg->txMode.pres == PRSNT_NODEF) &&
407 (ueRecfg->txMode.tm == CRG_UE_TM_5))
409 DU_LOG("\nERROR --> MAC : Transmission Mode=%d not supported",
414 /* Fetch the Active cell */
415 if (((*cell = rgCb[inst].cell) == NULLP)
416 || ((*cell)->cellId != ueRecfg->cellId))
418 DU_LOG("\nERROR --> MAC : Active Cell does not exist\n");
422 /* Fix : syed UE ID change at MAC will now be controlled
424 if ((*ue = rgDBMGetUeCb(*cell, ueRecfg->oldCrnti)) == NULLP)
426 DU_LOG("\nERROR --> MAC : [%d]Old UE does not exist", ueRecfg->oldCrnti);
429 if (ueRecfg->ueUlHqRecfg.maxUlHqTx < RG_MIN_HQ_TX)
431 DU_LOG("\nERROR --> MAC : Invalid Uplink HARQ config for UE %d",
432 ueRecfg->ueUlHqRecfg.maxUlHqTx);
435 errInfo->errCause = RGERR_NONE;
437 } /* rgCFGVldtCrgUeRecfg */
441 * @brief Validates the logical channel re-configuration request from
446 * Function : rgCFGVldtCrgLcRecfg
449 * - Retrieve the uplink and downlink logical channel control block.
451 * - Validate the range of re-configured values recieved in
452 * re-configuration request.
453 * - If validated successfully,
454 * - Return ROK and pointer to the cell, UE and logical channel.
457 * - Else return RFAILED.
459 * @param[in] Inst inst
460 * @param[in] CrgLchRecfg *lcRecfg
461 * @param[out] RgCellCb **cell
462 * @param[out] RgUeCb **ue
463 * @param[out] RgUlLcCb **ulLc
464 * @param[out] RgDlLcCb **dlLc
465 * @param[out] RgErrInfo *errInfo
470 S16 rgCFGVldtCrgLcRecfg
473 CrgLchRecfg *lcRecfg,
480 errInfo->errCause = RGERR_CFG_INVALID_CRG_LC_RECFG;
483 if ((((*cell = rgCb[inst].cell)) == NULLP)
484 || ((*cell)->cellId != lcRecfg->cellId))
486 DU_LOG("\nERROR --> MAC : Active Cell %u does not exist for UE %u", lcRecfg->cellId, lcRecfg->crnti);
489 /* Fetch the Ue for dedicated channels */
490 if ((*ue = rgDBMGetUeCb(*cell, lcRecfg->crnti)) == NULLP)
492 DU_LOG("\nERROR --> MAC : UE does not exist for dedicated logical channel");
496 if ((*ulLc = rgDBMGetUlDedLcCb((*ue), lcRecfg->lcId)) == NULLP)
498 DU_LOG("\nERROR --> MAC : Dedicated UL LC does not exist %d",lcRecfg->lcId);
502 if (lcRecfg->ulRecfg.lcgId > (RG_MAX_LCG_PER_UE - 1))
504 DU_LOG("\nERROR --> MAC : Invalid lcgId for uplink logical channel lcg %d lc %d",
505 lcRecfg->ulRecfg.lcgId, lcRecfg->lcId);
509 errInfo->errCause = RGERR_NONE;
511 } /* rgCFGVldtCrgLcRecfg */
513 /* Start: LTEMAC_2.1_DEV_CFG */
515 * @brief Validates the UE Reset request from RRC to MAC.
519 * Function : rgCFGVldtCrgUeReset
522 * - Retrieve the CELL control block.
525 * - Retrieve the UE control block.
529 * @param[in] Inst inst
530 * @param[in] CrgRst *reset,
531 * @param[out] RgCellCb **cell
532 * @param[out] RgUeCb **ue
533 * @param[out] RgErrInfo *errInfo
538 S16 rgCFGVldtCrgUeReset
547 errInfo->errCause = RGERR_CFG_INVALID_CRG_UE_RESET;
549 /* Fetch the Active cell */
550 if (((*cell = rgCb[inst].cell) == NULLP)
551 || ((*cell)->cellId != reset->cellId))
553 DU_LOG("\nERROR --> MAC : Active Cell does not exist %d",reset->cellId);
558 if ((*ue = rgDBMGetUeCb(*cell, reset->crnti)) == NULLP)
560 DU_LOG("\nERROR --> MAC : UE does not exist");
564 errInfo->errCause = RGERR_NONE;
566 } /* rgCFGVldtCrgUeReset*/
567 /* End: LTEMAC_2.1_DEV_CFG */
572 * @brief Handler for the cell configuration request from RRC to MAC.
576 * Function : rgCFGCrgCellCfg
579 * - Allocate and create cell control block.
580 * - Update cell control block with the values recieved in the
582 * - Add the control block to hash list of cells.
583 * - Update the statistics.
584 * - If successful, return ROK else return RFAILED.
586 * @param[in] Inst inst
587 * @param[in] CrgCellCfg *cellCfg
588 * @param[out] RgErrInfo *errInfo
601 RgCellCb *cell = NULLP;
605 /* RLC SAP to allocate flowCntrlInd buffer*/
606 /* Commented below to resolve compilation warning */
609 errInfo->errCause = RGERR_CFG_CRG_CELL_CFG;
611 /* Allocate the cell control block */
612 if((ret = rgAllocSBuf(inst,(Data**)&cell, sizeof(RgCellCb))) != ROK)
614 DU_LOG("\nERROR --> MAC : Memory allocation FAILED for cell");
619 DU_LOG("\nERROR --> MAC : Memory allocation FAILED for cell");
623 /* Initialize the cell */
624 cell->cellId = cellCfg->cellId;
625 cell->rachCfg = cellCfg->rachCfg;
626 cell->bwCfg = cellCfg->bwCfg;
628 if(cellCfg->emtcEnable)
630 cell->emtcEnable = cellCfg->emtcEnable;
633 /* Initialize UL and DL CCCH logical channels */
634 cell->ulCcchId = RG_INVALID_LC_ID;
635 cell->dlCcchId = RG_INVALID_LC_ID;
638 /* Initialize the lists of the cell */
639 ret = rgDBMInitCell(cell);
642 DU_LOG("\nERROR --> MAC : DBM initialization for cell failed");
643 rgCFGFreeInactvCellCb(cell);
648 if (RFAILED == RgLaaCellCbInit(cell))
650 rgCFGFreeInactvCellCb(cell);
655 for(idx=0;idx < RG_NUM_SUB_FRAMES; idx++)
657 cell->subFrms[idx].txDone = TRUE;
660 cell->macInst = inst + RG_INST_START;
661 /* Insert cell in the incative cell list */
662 rgCb[inst].inactiveCell = cell;
663 rgCb[inst].cell = NULLP;
664 #ifdef TENB_MULT_CELL_SUPPRT
665 rguDlSapId = cellCfg->rguDlSapId;
666 rguUlSapId = cellCfg->rguUlSapId;
668 if(rgCb[inst].numRguSaps > 1)
673 cell->rguDlSap = &(rgCb[inst].rguSap[rguDlSapId]);
674 cell->rguUlSap = &(rgCb[inst].rguSap[rguUlSapId]);
678 cmLListInit(&cell->l2mList);
679 for(idx = 0; idx < RG_NUM_UL_SUB_FRAMES; idx++)
681 memset(&cell->ulSf[idx], 0, sizeof(RgUlSf));
684 cell->ttiCycle = (uint32_t)RG_TTI_CYCLE_INVLD;
686 /* Update Statistics */
687 rgUpdtCellCnt(inst,RG_CFG_ADD);
688 errInfo->errCause = RGERR_NONE;
690 /* Commented below to resolve compilation warning */
691 //pst = &rgCb[inst].rguSap[rguDlSapId].sapCfg.sapPst;
692 /* Allocate a buffer for flowCntrlInd.*/
693 MAC_ALLOC(cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
694 if(cell->flowCntrlInd == NULLP)
696 DU_LOG("ERROR --> MAC : rgCFGCrgCellCfg(): Memory allocation failed");
700 } /* rgCFGCrgCellCfg */
704 * @brief Add SCell Cfg recvd from primary MAC instance.
708 * Function : rgCfgAddUeSCellCfg
711 * - Allocate and create UE control block.
712 * - Update UE control block with the values recieved in the
714 * - If successful, add the control block to hash list of UEs for the cell
715 * else Rollback and FAIL.
717 * @param[in] Inst dstMacInst
718 * @param[in] RgPrgUeSCellCfgInfo *ueSCellCb
719 * @param[in] RgCellCb cell
725 S16 rgCfgAddUeSCellCfg
728 RgPrgUeSCellCfgInfo *ueSCellCb,
732 RgUeCb *ueCb = NULLP;
739 rguDlSapId = ueSCellCb->rguDlSapId;
740 rguUlSapId = ueSCellCb->rguUlSapId;
742 #ifndef TENB_MULT_CELL_SUPPRT
743 if(rgCb[dstMacInst].numRguSaps > 1)
749 if ((ueCb = rgDBMGetUeCb(cell, ueSCellCb->ueId)) != NULLP)
751 DU_LOG("\nERROR --> MAC : [%d]UE already exist in scell %d during scell addition\n",
758 if((ueCb = rgRAMCreateUeCb(cell, ueSCellCb->ueId,
759 FALSE, &errInfo)) == NULLP)
761 DU_LOG("\nERROR --> MAC : [%d]UeCb creation failed\n", ueSCellCb->ueId);
765 if(rgDHMHqEntInit(dstMacInst, &ueCb->dl.hqEnt,
766 (rgCb[dstMacInst].cell)->maxDlHqProcPerUe) != ROK)
768 DU_LOG("\nERROR --> MAC : [%d]UeCb Harq Entity Initialization failed\n", ueSCellCb->ueId);
771 rgDBMInsUeCb(cell, ueCb);
774 ueCb->rguDlSap = &(rgCb[dstMacInst].rguSap[rguDlSapId]);
775 ueCb->rguUlSap = &(rgCb[dstMacInst].rguSap[rguUlSapId]);
777 /* Update satistics */
778 rgUpdtUeCnt(dstMacInst, RG_CFG_ADD);
779 /*Commit Added SCell info to UeCb */
781 ueCb->sCelAddInfo[idx].isSCellAdded = TRUE;
782 ueCb->sCelAddInfo[idx].macInst = dstMacInst;
783 ueCb->sCelAddInfo[idx].sCellId = ueSCellCb->cellId;
786 ueCb->txMode = ueSCellCb->txMode;
787 ueCb->ul.hqEnt.maxHqRetx = ueSCellCb->maxUlHqRetx;
789 for (idx =0; idx <RG_MAX_LC_PER_UE; idx++)
791 ueCb->ul.lcCb[idx] = ueSCellCb->ulLcInfo[idx];
792 ueCb->dl.lcCb[idx] = ueSCellCb->dlLcInfo[idx];
795 for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
797 ueCb->ul.lcgArr[idx].lcgId = ueSCellCb->lcgInfo[idx].lcgId;
798 ueCb->ul.lcgArr[idx].lcCount = ueSCellCb->lcgInfo[idx].lcCount;
799 ueCb->ul.lcgArr[idx].isGbr = ueSCellCb->lcgInfo[idx].isGbr;
802 }/* rgCfgAddUeSCellCfg */
805 * @brief SCell Config Filling for added cell from RRC to MAC.
809 * Function : rgFillAndAddSCellCfg
812 * - Update UE control block with the values recieved in the
814 * - Update UE control block with the values present in the
816 * - If successful, add the control block to hash list of UEs for the cell
817 * else Rollback and FAIL.
819 * @param[in] Inst inst
820 * @param[in] RgCellCb *cell
821 * @param[in] CrgUeCfg *ueCfg
822 * @param[in] CrgCfgTransId transId
827 S16 rgFillAndAddSCellCfg
832 CrgCfgTransId transId,
839 RgPrgUeSCellCfgInfo ueSCellCb;
842 /* Fetch the Active cell */
843 if(((cell = rgCb[inst].cell) == NULLP) ||
844 (cell->cellId != ueRecfg->cellId))
846 DU_LOG("\nERROR --> MAC : [%d]Active Cell does not exist %d\n",
847 ueRecfg->oldCrnti, ueRecfg->cellId);
851 DU_LOG("\nINFO --> MAC : Filling SCell Config : cellId %d ueId %d\n",
852 cell->cellId, cell->ueId);
854 if ((ue = rgDBMGetUeCb(cell, ueRecfg->oldCrnti)) == NULLP)
856 DU_LOG("\nERROR --> MAC : [%d]UE does not exist\n", ueRecfg->oldCrnti);
860 /* Initialize cfgCfmInfo in the ueCb. This is used while processing SCellAdd
862 ue->cfgCfmInfo.numSCells = ueRecfg->crgSCellCfg.numSCells;
863 ue->cfgCfmInfo.cfgCfgCount = 0;
864 ue->cfgCfmInfo.mask = 0x0;
866 memcpy(&(ue->cfgCfmInfo.transId), &transId,
867 sizeof(CrgCfgTransId));
868 ueSCellCb.ueId = ueRecfg->oldCrnti;
869 ueSCellCb.txMode = ue->txMode;
870 ueSCellCb.maxUlHqRetx = ue->ul.hqEnt.maxHqRetx;
871 memcpy(ueSCellCb.ulLcInfo, ue->ul.lcCb, sizeof(ue->ul.lcCb));
872 memcpy(ueSCellCb.dlLcInfo, ue->dl.lcCb, sizeof(ue->dl.lcCb));
873 for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
875 ueSCellCb.lcgInfo[idx].lcgId = ue->ul.lcgArr[idx].lcgId;
876 ueSCellCb.lcgInfo[idx].lcCount = ue->ul.lcgArr[idx].lcCount;
877 ueSCellCb.lcgInfo[idx].isGbr = ue->ul.lcgArr[idx].isGbr;
881 idx < ueRecfg->crgSCellCfg.numSCells; idx++)
883 dstMacInst = ueRecfg->crgSCellCfg.ueSCellCfg[idx].macInst - RG_INST_START;
884 ueSCellCb.cellId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].sCellId;
885 ueSCellCb.rguDlSapId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].rguDlSapId;
886 ueSCellCb.rguUlSapId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].rguUlSapId;
888 /* Get post structure of the cell to whom ueSCellCb needs to be sent
889 * And then send the sCell Add based on Mac instances */
890 rgGetPstToInst(&dstInstPst, inst, dstMacInst);
891 RgPrgPMacSMacUeSCellCfg(&dstInstPst, &ueSCellCb);
893 /*Commit Added SCell info to UeCb is moved to config confirm*/
894 } /*end of for loop */
898 } /* rgFillAndAddSCellCfg */
902 * @brief Handler for the UE configuration request from RRC to MAC.
906 * Function : rgCFGCrgUeCfg
909 * - Allocate and create UE control block.
910 * - Update UE control block with the values recieved in the
912 * - Invoke RAM, SCH, UHM and DHM with created UE control block, to
913 * update random access, scheduler, uplink harq and downlink harq
914 * specific information respectively.
915 * - If successful, add the control block to hash list of UEs for the cell
916 * else Rollback and FAIL.
918 * @param[in] Inst inst
919 * @param[in] RgCellCb *cell
920 * @param[in] CrgUeCfg *ueCfg
921 * @param[out] RgErrInfo *errInfo
935 Bool handover = FALSE;
939 errInfo->errCause = RGERR_CFG_CRG_UE_CFG;
941 /* Start: LTEMAC_2.1_DEV_CFG */
942 if ((ue = rgDBMGetUeCbFromRachLst(cell, ueCfg->crnti)) == NULLP)
944 /* Create UeCb and Insert in Rach List */
945 if((ue=rgRAMCreateUeCb(cell, ueCfg->crnti, FALSE, errInfo)) == NULLP)
947 DU_LOG("\nERROR --> MAC : UeCb creation failed");
950 if(rgDHMHqEntInit(inst,&ue->dl.hqEnt, cell->maxDlHqProcPerUe) != ROK)
952 DU_LOG("\nERROR --> MAC : UeCb Harq Entity Initialization failed");
957 /* End: LTEMAC_2.1_DEV_CFG */
959 if(handover == FALSE)
961 /* Remove from the rachLst */
962 rgDBMDelUeCbFromRachLst(cell, ue);
966 /* Initialize uplink HARQ related information for UE */
967 rgUHMCrgUeCfg(cell, ue, ueCfg);
969 rgDBMInsUeCb(cell, ue);
971 #ifdef TENB_MULT_CELL_SUPPRT
972 rguDlSapId = ueCfg->rguDlSapId;
973 rguUlSapId = ueCfg->rguUlSapId;
975 if(rgCb[inst].numRguSaps > 1)
981 ue->rguDlSap = &(rgCb[inst].rguSap[rguDlSapId]);
982 ue->rguUlSap = &(rgCb[inst].rguSap[rguUlSapId]);
985 /* Update satistics */
986 rgUpdtUeCnt(inst,RG_CFG_ADD);
987 errInfo->errCause = RGERR_NONE;
989 } /* rgCFGCrgUeCfg */
993 * @brief Handler for the logical channel configuration request from
998 * Function : rgCFGCrgLcCfg
1001 * - Check if the configuration is for dedicated or common logical channel.
1002 * - For Dedicated logical channels:
1003 * - Update the dedicated logical channel Cb with the configured values.
1004 * - Invoke SCH will cell, UE and logical channel Cb to update scheduler
1005 * specific information.
1006 * - For Common logical channels:
1007 * - Update the common logical channel Cb with the configured values.
1008 * - Move cell to active list of cells if cell becomes ACTIVE.
1009 * - If successful, return ROK else RFAILED.
1011 * @param[in] Inst inst
1012 * @param[in] RgCellCb *cell
1013 * @param[in] RgUeCb *ue
1014 * @param[in] CrgLchCfg *lcCfg
1015 * @param[out] RgErrInfo *errInfo
1016 * @param[in] Bool *isCfmRqrd
1029 CrgCfgTransId transId
1033 /* Handle Config for dedicated/common logical channels */
1034 if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
1037 if ((rgCFGCrgDedLcCfg(cell, ue, lcCfg, errInfo)) != ROK)
1039 DU_LOG("\nERROR --> MAC : Dedicated logical channel configuration failed %d",lcCfg->lcId);
1043 /*ERAB Multl Cell fix*/
1044 memcpy(&(ue->cfgCfmInfo.transId), &transId,
1045 sizeof(CrgCfgTransId));
1046 rgPomSndUeSCellLchAddToSmac(inst, cell, ue, lcCfg,isCfmRqrd);
1051 if ((rgCFGCrgCmnLcCfg(inst,cell, lcCfg, errInfo)) != ROK)
1053 DU_LOG("\nERROR --> MAC : Common logical channel configuration"
1054 "failed %d\n", lcCfg->lcId);
1059 errInfo->errCause = RGERR_NONE;
1060 DU_LOG("\nINFO --> MAC : CRG LC config done for UE lcId %d\n", lcCfg->lcId);
1062 } /* rgCFGCrgLcCfg */
1066 * @brief Handler for the cell re-configuration request from RRC to MAC.
1070 * Function : rgCFGCrgCellRecfg
1073 * - Invoke SCH with updated Cell Cb to update scheduler specific
1075 * - Update the cell Cb with the reconfigured values.
1076 * - If successful, return ROK else RFAILED.
1078 * @param[in] Inst inst
1079 * @param[in] RgCellCb *cell
1080 * @param[in] CrgCellRecfg *cellRecfg
1081 * @param[out] RgErrInfo *errInfo
1086 S16 rgCFGCrgCellRecfg
1090 CrgCellRecfg *cellRecfg,
1094 /* Store the given rachCfg */
1095 cell->rachCfg = cellRecfg->rachRecfg;
1097 errInfo->errCause = RGERR_NONE;
1099 } /* rgCFGCrgCellRecfg */
1103 * @brief Handler for the UE re-configuration request from RRC to MAC.
1107 * Function : rgCFGCrgUeRecfg
1110 * - If rnti changes,
1111 * - Invoke RAM for UE reconfiguration.
1112 * - Delete old UE from the list.
1113 * - Update the new rnti and re-insert the UE in the list.
1114 * - Update the UE control block with the reconfigured values.
1115 * - Invoke SCH, UHM and DHM with updated UE control block to
1116 * update scheduler, uplink HARQ and downlink HARQ specific
1118 * - If successful, return ROK else RFAILED.
1120 * @param[in] Inst inst
1121 * @param[in] RgCellCb *cell
1122 * @param[in] RgUeCb *ue
1123 * @param[in] CrgUeRecfg *ueRecfg
1124 * @param[out] RgErrInfo *errInfo
1134 CrgUeRecfg *ueRecfg,
1138 errInfo->errCause = RGERR_CFG_CRG_UE_RECFG;
1140 /* Fix : syed UE ID change at MAC will now be controlled
1143 /* Update uplink HARQ related information for UE */
1144 rgUHMCrgUeRecfg(cell, ue, ueRecfg);
1146 errInfo->errCause = RGERR_NONE;
1148 } /* rgCFGCrgUeRecfg */
1152 * @brief Handler for the logical channel re-configuration request from
1157 * Function : rgCFGCrgLcRecfg
1160 * - Invoke scheduler to update scheduler specific information.
1161 * - Update the dedicated logical channel Cb with the re-configured
1163 * - If successful, return ROK else RFAILED.
1165 * @param[in] Inst inst
1166 * @param[in] RgUlCellCb *cell
1167 * @param[in] RgUlUeCb *ue
1168 * @param[in] RgUlLcCb *ulLc
1169 * @param[in] RgDlLcCb *dlLc
1170 * @param[in] CrgLchRecfg *lcRecfg
1171 * @param[out] RgErrInfo *errInfo
1182 CrgLchRecfg *lcRecfg,
1188 if (ulLc->lcgId != lcRecfg->ulRecfg.lcgId)
1190 rgDBMUpdUlDedLcCb(ue, ulLc, lcRecfg->ulRecfg.lcgId);
1192 rgPomSndUeSCellLchModToSmac(inst, cell, ue, lcRecfg,isCfmRqrd);
1196 errInfo->errCause = RGERR_NONE;
1198 } /* rgCFGCrgLcRecfg */
1200 /* Start: LTEMAC_2.1_DEV_CFG */
1202 * @brief Handler for the logical channel re-configuration request from
1207 * Function : rgCFGCrgUeReset
1211 * @param[in] RgUlCellCb *cell
1212 * @param[in] RgUlUeCb *ue
1213 * @param[in] CrgRst *reset
1214 * @param[out] RgErrInfo *errInfo
1228 DU_LOG("\nDEBUG --> MAC : UE of cell %d Reset\n", cell->cellId);
1229 rgDHMUeReset(cell, &ue->dl.hqEnt);
1231 errInfo->errCause = RGERR_NONE;
1234 } /* rgCFGCrgUeReset */
1235 /* End: LTEMAC_2.1_DEV_CFG */
1238 * @brief Handler for the cell delete request from RRC to MAC.
1242 * Function : rgCFGCrgCellDel
1245 * - Fetch the cell control block.
1246 * - Remove the cell control block from the hash list of cells.
1247 * - Free the cell control block.
1248 * - If successful, return ROK else return RFAILED.
1250 * @param[in] Inst inst
1251 * @param[in] CrgDel *cellDelInfo
1252 * @param[out] RgErrInfo *errInfo
1260 CrgDel *cellDelInfo,
1268 errInfo->errCause = RGERR_CFG_CRG_CELL_DEL;
1269 if (((cell = rgCb[inst].cell) == NULLP)
1270 ||(cell->cellId != cellDelInfo->u.cellDel.cellId))
1272 if(((cell = rgCb[inst].inactiveCell) == NULLP)
1273 ||(cell->cellId != cellDelInfo->u.cellDel.cellId))
1277 DU_LOG("\nERROR --> MAC : Cell does not exist");
1281 /* Delete cell from inactive list */
1282 rgCb[inst].inactiveCell = NULLP ;
1284 /* Free the inactive cell */
1285 rgCFGFreeInactvCellCb(cell);
1287 errInfo->errCause = RGERR_NONE;
1291 /* Delete from the cell list */
1292 //rgDBMDelCellCb(cell);
1293 for(idx=0;idx < RG_NUM_SUB_FRAMES; idx++)
1295 rgTOMRlsSf(inst,&cell->subFrms[idx]);
1298 /* Free the active cell */
1299 rgCFGFreeCellCb(cell);
1301 rgCb[inst].cell = NULLP;
1303 errInfo->errCause = RGERR_NONE;
1304 DU_LOG("\nINFO --> MAC : Cell %d deleted\n", cellDelInfo->u.cellDel.cellId);
1306 } /* rgCFGCrgCellDel */
1310 * @brief Handler for the UE delete request from RRC to MAC.
1314 * Function : rgCFGCrgUeDel
1317 * - Fetch the UE control block.
1318 * - Remove the UE control block from the hash list of UEs for the cell.
1319 * - Free the UE control block.
1320 * - If successful, return ROK else return RFAILED.
1322 * @param[in] Inst inst
1323 * @param[in] CrgDel *ueDelInfo
1324 * @param[out] RgErrInfo *errInfo
1337 errInfo->errCause = RGERR_CFG_CRG_UE_DEL;
1339 DU_LOG("\nDEBUG --> MAC : UE %d Deletion Req at MAC\n", \
1340 ueDelInfo->u.ueDel.crnti);
1341 if ((rgCb[inst].cell == NULLP)
1342 || (rgCb[inst].cell->cellId != ueDelInfo->u.ueDel.cellId))
1344 DU_LOG("\nERROR --> MAC : Cell does not exist %d",
1345 ueDelInfo->u.ueDel.cellId);
1349 errInfo->errCause = RGERR_NONE;
1350 /* Fix: syed Context Deletion is relied upon SCH indication */
1352 } /* rgCFGCrgUeDel */
1356 * @brief Handler for the logical channel delete request from
1361 * Function : rgCFGCrgLcDel
1364 * - Fetch the logical channel control block.
1365 * - Free the logical channel control block.
1366 * - If successful, return ROK else return RFAILED.
1368 * @param[in] Inst inst
1369 * @param[in] CrgDel *lcDelInfo
1370 * @param[out] RgErrInfo *errInfo
1381 CrgCfgTransId transId
1384 Bool dirVld = FALSE;
1390 errInfo->errCause = RGERR_CFG_CRG_LC_DEL;
1392 /* Fetch the Active cell */
1393 if (((cell = rgCb[inst].cell) == NULLP) ||
1394 (rgCb[inst].cell->cellId != lcDelInfo->u.lchDel.cellId))
1396 DU_LOG("\nERROR --> MAC : Cell does not exist %d",
1397 lcDelInfo->u.lchDel.cellId);
1402 if ((ue = rgDBMGetUeCb(cell, lcDelInfo->u.lchDel.crnti)) == NULLP)
1404 DU_LOG("\nERROR --> MAC : UE does not exist for dedicated logical channel");
1408 /* Validate downlink info */
1409 if (lcDelInfo->u.lchDel.dir & CRG_DIR_TX)
1411 if ((dlLc = rgDBMGetDlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
1414 DU_LOG("\nERROR --> MAC : DL LC %d does not exist",
1415 lcDelInfo->u.lchDel.lcId);
1418 rgDBMDelDlDedLcCb(ue, dlLc);
1422 /* Validate uplink info */
1423 if (lcDelInfo->u.lchDel.dir & CRG_DIR_RX)
1425 if ((ulLc = rgDBMGetUlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
1428 DU_LOG("\nERROR --> MAC : UL LC %d does not exist",
1429 lcDelInfo->u.lchDel.lcId);
1432 rgDBMDelUlDedLcCb(ue, ulLc);
1438 DU_LOG("\nERROR --> MAC : Invalid direction %d for LC Delete",
1439 lcDelInfo->u.lchDel.dir);
1443 /*ERAB - multicell fix*/
1444 memcpy( &(ue->cfgCfmInfo.transId), &transId,
1445 sizeof(CrgCfgTransId));
1446 rgPomSndUeSCellLchDelToSmac(inst, lcDelInfo, isCfmRqrd);
1448 errInfo->errCause = RGERR_NONE;
1450 } /* rgCFGCrgLcDel */
1452 /***********************************************************
1454 * Func : rgCFGVldtCrgDedLcCfg
1457 * Desc : Validates dedicated logical channel configuration recieved from RRC.
1467 **********************************************************/
1468 static S16 rgCFGVldtCrgDedLcCfg
1477 uint8_t dirVld = FALSE;
1479 errInfo->errCause = RGERR_CFG_INVALID_CRG_DED_LC_CFG;
1481 /* Fetch the Active cell */
1482 if (((*cell = rgCb[inst].cell) == NULLP)
1483 || ((*cell)->cellId != lcCfg->cellId))
1485 DU_LOG("\nERROR --> MAC : Active Cell does not exist: Cell %d",
1491 if ((*ue = rgDBMGetUeCb(*cell, lcCfg->crnti)) == NULLP)
1493 DU_LOG("\nERROR --> MAC : UE does not exist for dedicated logical channel %d",
1498 /* Validate logical channel Id */
1499 if ((lcCfg->lcId < RG_DEDLC_MIN_LCID)
1500 ||(lcCfg->lcId > RG_DEDLC_MAX_LCID))
1502 DU_LOG("\nERROR --> MAC : Invalid logical channel Id %d",
1507 /* Validate downlink info */
1508 if (lcCfg->dir & CRG_DIR_TX)
1510 if (rgDBMGetDlDedLcCb((*ue), lcCfg->lcId) != NULLP)
1512 DU_LOG("\nERROR --> MAC : UE Dedicated DL LC %d already configured",
1519 /* Validate uplink info */
1520 if (lcCfg->dir & CRG_DIR_RX)
1522 if (lcCfg->ulInfo.lcgId > (RG_MAX_LCG_PER_UE - 1))
1524 DU_LOG("\nERROR --> MAC : UE Invalid lcgId for uplink logical channel %d",
1525 lcCfg->ulInfo.lcgId);
1528 if (rgDBMGetUlDedLcCb((*ue), lcCfg->lcId) != NULLP)
1530 DU_LOG("\nERROR --> MAC : UE Dedicated UL LC %d already configured",
1539 DU_LOG("\nERROR --> MAC : Invalid Direction %d",
1545 } /* rgCFGVldtCrgDedLcCfg */
1548 /***********************************************************
1550 * Func : rgCFGVldtCrgCmnLcCfg
1553 * Desc : Validates common logical channel configuration recieved from RRC.
1563 **********************************************************/
1564 static S16 rgCFGVldtCrgCmnLcCfg
1572 uint8_t dirVld = FALSE;
1574 errInfo->errCause = RGERR_CFG_INVALID_CRG_CMN_LC_CFG;
1576 /* Ensure cell is not in the active list */
1577 if (((*cell = rgCb[inst].cell) != NULLP)
1578 && ((*cell)->cellId != lcCfg->cellId))
1580 DU_LOG("\nERROR --> MAC : Active Cell exists for common channels");
1584 /* Fetch the inactive cell for common logical channels */
1585 if (((*cell = rgCb[inst].inactiveCell) == NULLP)
1586 || ((*cell)->cellId != lcCfg->cellId))
1589 DU_LOG("\nERROR --> MAC : Inactive Cell does not exist for common channels");
1592 /* Validate downlink info */
1593 if (lcCfg->dir & CRG_DIR_TX)
1595 if (lcCfg->lcType == CM_LTE_LCH_BCCH)
1597 if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_DL_SCH)
1599 if (rgDBMGetBcchOnDlsch(*cell,lcCfg->lcId) != NULLP)
1601 DU_LOG("\nERROR --> MAC : BCCH on DLSCH already configured for cell");
1605 else if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_BCH)
1607 if (rgDBMGetBcchOnBch(*cell) != NULLP)
1609 DU_LOG("\nERROR --> MAC : BCCH on BCH already configured for cell ");
1615 DU_LOG("\nERROR --> MAC : Invalid transport channel %d for cell",
1616 lcCfg->dlInfo.dlTrchType);
1620 else if (lcCfg->lcType == CM_LTE_LCH_PCCH)
1622 if (rgDBMGetPcch(*cell) != NULLP)
1624 DU_LOG("\nERROR --> MAC : PCCH already configured for cell");
1628 else if (RG_DLCCCH_ISCFGD(*cell))
1630 DU_LOG("\nERROR --> MAC : DL CCCH already configured for cell ");
1636 /* Validate uplink info */
1637 if (lcCfg->dir & CRG_DIR_RX)
1640 if (lcCfg->lcType != CM_LTE_LCH_CCCH)
1642 DU_LOG("\nERROR --> MAC : Invalid UL common lcType %d for cell ",
1646 if (RG_ULCCCH_ISCFGD(*cell))
1648 DU_LOG("\nERROR --> MAC : UL CCCH already configured for cell ");
1654 /* Invalid direction */
1657 DU_LOG("\nERROR --> MAC : Invalid Direction %d", lcCfg->dir);
1662 } /* rgCFGVldtCrgCmnLcCfg */
1664 /***********************************************************
1666 * Func : rgCFGCrgDedLcCfg
1669 * Desc : Handles dedicated logical channel configuration
1670 * recieved from RRC.
1680 **********************************************************/
1681 static S16 rgCFGCrgDedLcCfg
1689 //Inst inst = cell->macInst - RG_INST_START;
1690 errInfo->errCause = RGERR_CFG_CRG_DED_LC_CFG;
1692 /* Uplink/Bi-directional logical channel */
1693 if (lcCfg->dir & CRG_DIR_RX)
1696 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId, lcCfg->qci);
1697 cell->qciArray[lcCfg->qci].qci = lcCfg->qci;
1698 if(lcCfg->lcType == CM_LTE_LCH_DTCH)
1700 rgAddToL2MeasPerQci(cell,lcCfg->qci);/*LTE_L2_MEAS_PHASE2*/
1703 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId);
1707 /* Downlink/Bi-directional logical channel */
1708 if (lcCfg->dir & CRG_DIR_TX)
1710 rgDBMInsDlDedLcCb(ue, lcCfg->lcId);
1713 } /* rgCFGCrgDedLcCfg */
1716 /***********************************************************
1718 * Func : rgCFGCrgCmnLcCfg
1721 * Desc : Handles dedicated logical channel configuration
1722 * recieved from RRC.
1732 **********************************************************/
1733 static S16 rgCFGCrgCmnLcCfg
1741 errInfo->errCause = RGERR_CFG_CRG_CMN_LC_CFG;
1743 /* Handle configuration for CCCH/BCCH/PCCH */
1744 if (lcCfg->lcType == CM_LTE_LCH_CCCH)
1746 /* UL and DL CCCH configuration */
1747 if (lcCfg->dir & CRG_DIR_TX)
1749 cell->dlCcchId = lcCfg->lcId;
1750 cell->cellActvState |= RG_DL_CCCH_CFG_DONE;
1753 if (lcCfg->dir & CRG_DIR_RX)
1755 cell->ulCcchId = lcCfg->lcId;
1756 cell->cellActvState |= RG_UL_CCCH_CFG_DONE;
1761 if (lcCfg->lcType == CM_LTE_LCH_BCCH)
1763 /* BCCH on BCH and DLSCH configuration */
1764 if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_DL_SCH)
1766 rgDBMInsBcchOnDlsch(cell, lcCfg->lcId);
1768 if(cell->cellActvState & RG_BCCH_DLSCH_CFG1_DONE)
1770 cell->cellActvState |= RG_BCCH_DLSCH_CFG2_DONE;
1774 cell->cellActvState |= RG_BCCH_DLSCH_CFG1_DONE;
1779 rgDBMInsBcchOnBch(cell, lcCfg->lcId);
1780 cell->cellActvState |= RG_BCCH_BCH_CFG_DONE;
1783 else /* PCCH configuration */
1785 rgDBMInsPcch(cell, lcCfg->lcId);
1786 cell->cellActvState |= RG_PCCH_CFG_DONE;
1790 /* Add to active cell list if cell is active */
1791 if (cell->cellActvState == RG_CELL_ACTIVE)
1793 rgCb[inst].cell = cell;
1794 rgCb[inst].inactiveCell = NULLP;
1795 DU_LOG("\nDEBUG --> MAC : Cell added to active list after common LC %d\
1796 config\n", lcCfg->lcId);
1800 } /* rgCFGCrgCmnLcCfg */
1802 /***********************************************************
1804 * Func : rgCFGFreeUeUlAlloc
1808 * - Processing Steps:
1809 * - Frees cell control block.
1817 **********************************************************/
1818 static Void rgCFGFreeUeUlAlloc(RgCellCb *cell)
1821 Inst inst = cell->macInst - RG_INST_START;
1823 for(sfIdx = 0; sfIdx < RG_NUM_UL_SUB_FRAMES; sfIdx++)
1825 if(cell->ulSf[sfIdx].ueUlAllocInfo != NULLP)
1827 /*ccpu00117052 - MOD- Passing double pointer for proper
1828 * NULLP assignment */
1829 rgFreeSBuf(inst,(Data **)&(cell->ulSf[sfIdx].ueUlAllocInfo),
1830 (cell->ulSf[sfIdx].numUe * sizeof(RgUeUlAlloc)));
1833 }/* rgCFGFreeUeUlAlloc */
1835 /***********************************************************
1837 * Func : rgCFGFreeCellCb
1841 * - Processing Steps:
1842 * - Frees cell control block.
1850 **********************************************************/
1851 Void rgCFGFreeCellCb(RgCellCb *cell)
1853 Inst inst = cell->macInst - RG_INST_START;
1856 RgLaaCellCbDeInit(cell);
1858 /* Free lists of the cell */
1860 rgCFGFreeSpsUeLst(cell);
1861 #endif /* LTEMAC_SPS */
1862 rgCFGFreeUeLst(cell);
1863 rgRAMFreeCell(cell);
1864 rgCFGFreeCmnLcLst(cell);
1866 rgCFGFreeUeUlAlloc(cell);
1868 /* ccpu00117052 - MOD - Passing double pointer for proper NULLP
1870 /* Update satistics */
1871 rgUpdtCellCnt(inst,RG_CFG_DEL);
1872 rgDHMFreeAllTbBufs(inst);
1874 rgFreeSBuf(inst,(Data **)&cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
1876 /* De-allocate the Cell */
1877 rgFreeSBuf(inst,(Data **)&cell, sizeof(*cell));
1880 DU_LOG("\nINFO --> MAC : Cell freed\n");
1882 /* Stack Crash Problem for TRACE5 Changes. Added return below */
1884 } /* rgCFGFreeCellCb */
1887 /***********************************************************
1889 * Func : rgCFGFreeInactvCellCb
1893 * - Processing Steps:
1894 * - Frees inactive cell control block.
1902 **********************************************************/
1903 Void rgCFGFreeInactvCellCb(RgCellCb *cell)
1905 Inst inst = cell->macInst - RG_INST_START;
1906 /* De-initialize the Ue list */
1907 rgDBMDeInitUeCbLst(cell);
1909 rgDBMDeInitSpsUeCbLst(cell);
1912 rgCFGFreeCmnLcLst(cell);
1914 rgFreeSBuf(inst, (Data **)&cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
1915 /*ccpu00117052 - MOD- Passing double pointer for proper
1917 /* De-allocate the Cell */
1918 rgFreeSBuf(inst,(Data **)&cell, sizeof(*cell));
1920 /* Update satistics */
1921 rgUpdtCellCnt(inst,RG_CFG_DEL);
1924 /* Stack Crash Problem for TRACE5 Changes. Added return below */
1926 } /* rgCFGFreeInactvCellCb */
1929 /***********************************************************
1931 * Func : rgCFGFreeUeCb
1935 * - Processing Steps:
1936 * - Frees UE control block.
1944 **********************************************************/
1945 Void rgCFGFreeUeCb(RgCellCb *cell,RgUeCb *ue)
1947 Inst inst = cell->macInst - RG_INST_START;
1949 rgDHMFreeUe(inst,&ue->dl.hqEnt);
1951 /* ccpu00117052 - MOD - Passing double pointer for proper NULLP
1953 /* De-allocate the Ue */
1954 rgFreeSBuf(inst,(Data **)&ue, sizeof(*ue));
1956 /* Update Statistics */
1957 rgUpdtUeCnt(inst,RG_CFG_DEL);
1960 /* Stack Crash Problem for TRACE5 Changes. Added return below */
1962 } /* rgCFGFreeUeCb */
1964 /***********************************************************
1966 * Func : rgCFGFreeCmnLcLst
1970 * - Processing Steps:
1971 * - Frees common logical channels in cell control block.
1979 **********************************************************/
1980 static Void rgCFGFreeCmnLcLst(RgCellCb *cell)
1982 rgDBMFreeCmnLcLst(cell);
1985 /* Stack Crash Problem for TRACE5 Changes. Added return below */
1987 } /* rgCFGFreeCmnLcLst */
1990 /***********************************************************
1992 * Func : rgCFGFreeUeLst
1996 * - Processing Steps:
1997 * - Frees UE list in cell control block.
2005 **********************************************************/
2006 static Void rgCFGFreeUeLst(RgCellCb *cell)
2010 /* Free Ues in the list */
2011 while ((ue = rgDBMGetNextUeCb(cell, NULLP)) != NULLP)
2014 rgDelUeFrmAllSCell(cell,ue);
2016 rgDBMDelUeCb(cell, ue);
2017 rgCFGFreeUeCb(cell, ue);
2020 /* De-initialize the Ue list */
2021 rgDBMDeInitUeCbLst(cell);
2024 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2026 } /* rgCFGFreeUeLst */
2029 /***********************************************************
2031 * Func : rgCFGFreeSpsUeLst
2035 * - Processing Steps:
2036 * - Frees Sps UE list in cell control block.
2044 **********************************************************/
2045 static Void rgCFGFreeSpsUeLst(RgCellCb *cell)
2049 /* Free Ues in the list */
2050 while ((ue = rgDBMGetNextSpsUeCb(cell, NULLP)))
2052 rgDBMDelSpsUeCb(cell, ue);
2055 /* De-initialize the Ue list */
2056 rgDBMDeInitSpsUeCbLst(cell);
2058 } /* rgCFGFreeSpsUeLst */
2060 #endif /* LTEMAC_SPS */
2063 * @brief Function for registering cell- scheduler instance mapping
2067 * Function : RgSchMacCellRegReq
2069 * This function shall be invoked whenever scheduler is done with the
2070 * cell configuration successfully.
2071 * This shall create a mapping of the cell, scheduler instance that
2072 * is serving the cell and the unique identifier of the cell on the
2073 * scheduler at MAC. This mapping shall be used for further
2074 * communication to the scheduler instance for this cell.
2077 * @param[in] Pst* pst,
2078 * @param[in] CmLteCellId cellId,
2079 * @param[in] RaRespReqInfo raRespReq
2083 S16 RgSchMacCellRegReq(Pst* pst,RgInfCellReg* regReq)
2086 RgCellCb *cell = NULLP;
2088 RG_IS_INST_VALID(pst->dstInst);
2089 inst = pst->dstInst - RG_INST_START;
2090 cell = rgCb[inst].cell;
2097 if((cell == NULLP) || (cell->cellId != regReq->cellId))
2101 if(regReq->maxDlHqProcPerUe > RG_MAX_DL_HARQ_NUM)
2106 cell->schInstMap.cellSapId = regReq->cellSapId;
2107 cell->schInstMap.schInst = pst->srcInst;
2108 cell->maxDlHqProcPerUe = regReq->maxDlHqProcPerUe;
2112 } /* end of RgSchMacCellRegReq */
2114 /*Added Ue for Onging L2 Meas*/
2116 /*LTE_L2_MEAS_PHASE2*/
2117 S16 rgAddToL2MeasPerQci(RgCellCb *cell,uint8_t qci)
2124 lnk = cell->l2mList.first;
2125 while(lnk != NULLP )
2127 measCb = (RgL2MeasCb *)lnk->node;
2128 if(measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
2130 for(idx = 0;idx< measCb->measReq.t.prbReq.numQci;idx++)
2132 if(measCb->measReq.t.prbReq.qci[idx] == qci)
2134 break; /*exit from for loop*/
2137 if(idx == measCb->measReq.t.prbReq.numQci)
2139 cell->qciArray[qci].mask = TRUE;
2140 measCb->measReq.t.prbReq.qci[measCb->measReq.t.prbReq.numQci++] = qci;
2154 /**********************************************************************
2157 **********************************************************************/