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*/
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*/
608 errInfo->errCause = RGERR_CFG_CRG_CELL_CFG;
610 /* Allocate the cell control block */
611 if((ret = rgAllocSBuf(inst,(Data**)&cell, sizeof(RgCellCb))) != ROK)
613 DU_LOG("\nERROR --> MAC : Memory allocation FAILED for cell");
618 DU_LOG("\nERROR --> MAC : Memory allocation FAILED for cell");
622 /* Initialize the cell */
623 cell->cellId = cellCfg->cellId;
624 cell->rachCfg = cellCfg->rachCfg;
625 cell->bwCfg = cellCfg->bwCfg;
627 if(cellCfg->emtcEnable)
629 cell->emtcEnable = cellCfg->emtcEnable;
632 /* Initialize UL and DL CCCH logical channels */
633 cell->ulCcchId = RG_INVALID_LC_ID;
634 cell->dlCcchId = RG_INVALID_LC_ID;
637 /* Initialize the lists of the cell */
638 ret = rgDBMInitCell(cell);
641 DU_LOG("\nERROR --> MAC : DBM initialization for cell failed");
642 rgCFGFreeInactvCellCb(cell);
647 if (RFAILED == RgLaaCellCbInit(cell))
649 rgCFGFreeInactvCellCb(cell);
654 for(idx=0;idx < RG_NUM_SUB_FRAMES; idx++)
656 cell->subFrms[idx].txDone = TRUE;
659 cell->macInst = inst + RG_INST_START;
660 /* Insert cell in the incative cell list */
661 rgCb[inst].inactiveCell = cell;
662 rgCb[inst].cell = NULLP;
663 #ifdef TENB_MULT_CELL_SUPPRT
664 rguDlSapId = cellCfg->rguDlSapId;
665 rguUlSapId = cellCfg->rguUlSapId;
667 if(rgCb[inst].numRguSaps > 1)
672 cell->rguDlSap = &(rgCb[inst].rguSap[rguDlSapId]);
673 cell->rguUlSap = &(rgCb[inst].rguSap[rguUlSapId]);
677 cmLListInit(&cell->l2mList);
678 for(idx = 0; idx < RG_NUM_UL_SUB_FRAMES; idx++)
680 memset(&cell->ulSf[idx], 0, sizeof(RgUlSf));
683 cell->ttiCycle = (uint32_t)RG_TTI_CYCLE_INVLD;
685 /* Update Statistics */
686 rgUpdtCellCnt(inst,RG_CFG_ADD);
687 errInfo->errCause = RGERR_NONE;
689 pst = &rgCb[inst].rguSap[rguDlSapId].sapCfg.sapPst;
690 /* Allocate a buffer for flowCntrlInd.*/
691 SGetSBuf(pst->region, pst->pool, (Data **)&cell->flowCntrlInd,
692 sizeof(RguFlowCntrlInd));
694 } /* rgCFGCrgCellCfg */
698 * @brief Add SCell Cfg recvd from primary MAC instance.
702 * Function : rgCfgAddUeSCellCfg
705 * - Allocate and create UE control block.
706 * - Update UE control block with the values recieved in the
708 * - If successful, add the control block to hash list of UEs for the cell
709 * else Rollback and FAIL.
711 * @param[in] Inst dstMacInst
712 * @param[in] RgPrgUeSCellCfgInfo *ueSCellCb
713 * @param[in] RgCellCb cell
719 S16 rgCfgAddUeSCellCfg
722 RgPrgUeSCellCfgInfo *ueSCellCb,
726 RgUeCb *ueCb = NULLP;
733 rguDlSapId = ueSCellCb->rguDlSapId;
734 rguUlSapId = ueSCellCb->rguUlSapId;
736 #ifndef TENB_MULT_CELL_SUPPRT
737 if(rgCb[dstMacInst].numRguSaps > 1)
743 if ((ueCb = rgDBMGetUeCb(cell, ueSCellCb->ueId)) != NULLP)
745 DU_LOG("\nERROR --> MAC : [%d]UE already exist in scell %d during scell addition\n",
752 if((ueCb = rgRAMCreateUeCb(cell, ueSCellCb->ueId,
753 FALSE, &errInfo)) == NULLP)
755 DU_LOG("\nERROR --> MAC : [%d]UeCb creation failed\n", ueSCellCb->ueId);
759 if(rgDHMHqEntInit(dstMacInst, &ueCb->dl.hqEnt,
760 (rgCb[dstMacInst].cell)->maxDlHqProcPerUe) != ROK)
762 DU_LOG("\nERROR --> MAC : [%d]UeCb Harq Entity Initialization failed\n", ueSCellCb->ueId);
765 rgDBMInsUeCb(cell, ueCb);
768 ueCb->rguDlSap = &(rgCb[dstMacInst].rguSap[rguDlSapId]);
769 ueCb->rguUlSap = &(rgCb[dstMacInst].rguSap[rguUlSapId]);
771 /* Update satistics */
772 rgUpdtUeCnt(dstMacInst, RG_CFG_ADD);
773 /*Commit Added SCell info to UeCb */
775 ueCb->sCelAddInfo[idx].isSCellAdded = TRUE;
776 ueCb->sCelAddInfo[idx].macInst = dstMacInst;
777 ueCb->sCelAddInfo[idx].sCellId = ueSCellCb->cellId;
780 ueCb->txMode = ueSCellCb->txMode;
781 ueCb->ul.hqEnt.maxHqRetx = ueSCellCb->maxUlHqRetx;
783 for (idx =0; idx <RG_MAX_LC_PER_UE; idx++)
785 ueCb->ul.lcCb[idx] = ueSCellCb->ulLcInfo[idx];
786 ueCb->dl.lcCb[idx] = ueSCellCb->dlLcInfo[idx];
789 for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
791 ueCb->ul.lcgArr[idx].lcgId = ueSCellCb->lcgInfo[idx].lcgId;
792 ueCb->ul.lcgArr[idx].lcCount = ueSCellCb->lcgInfo[idx].lcCount;
793 ueCb->ul.lcgArr[idx].isGbr = ueSCellCb->lcgInfo[idx].isGbr;
796 }/* rgCfgAddUeSCellCfg */
799 * @brief SCell Config Filling for added cell from RRC to MAC.
803 * Function : rgFillAndAddSCellCfg
806 * - Update UE control block with the values recieved in the
808 * - Update UE control block with the values present in the
810 * - If successful, add the control block to hash list of UEs for the cell
811 * else Rollback and FAIL.
813 * @param[in] Inst inst
814 * @param[in] RgCellCb *cell
815 * @param[in] CrgUeCfg *ueCfg
816 * @param[in] CrgCfgTransId transId
821 S16 rgFillAndAddSCellCfg
826 CrgCfgTransId transId,
833 RgPrgUeSCellCfgInfo ueSCellCb;
836 /* Fetch the Active cell */
837 if(((cell = rgCb[inst].cell) == NULLP) ||
838 (cell->cellId != ueRecfg->cellId))
840 DU_LOG("\nERROR --> MAC : [%d]Active Cell does not exist %d\n",
841 ueRecfg->oldCrnti, ueRecfg->cellId);
845 DU_LOG("\nINFO --> MAC : Filling SCell Config : cellId %d ueId %d\n",
846 cell->cellId, cell->ueId);
848 if ((ue = rgDBMGetUeCb(cell, ueRecfg->oldCrnti)) == NULLP)
850 DU_LOG("\nERROR --> MAC : [%d]UE does not exist\n", ueRecfg->oldCrnti);
854 /* Initialize cfgCfmInfo in the ueCb. This is used while processing SCellAdd
856 ue->cfgCfmInfo.numSCells = ueRecfg->crgSCellCfg.numSCells;
857 ue->cfgCfmInfo.cfgCfgCount = 0;
858 ue->cfgCfmInfo.mask = 0x0;
860 memcpy(&(ue->cfgCfmInfo.transId), &transId,
861 sizeof(CrgCfgTransId));
862 ueSCellCb.ueId = ueRecfg->oldCrnti;
863 ueSCellCb.txMode = ue->txMode;
864 ueSCellCb.maxUlHqRetx = ue->ul.hqEnt.maxHqRetx;
865 memcpy(ueSCellCb.ulLcInfo, ue->ul.lcCb, sizeof(ue->ul.lcCb));
866 memcpy(ueSCellCb.dlLcInfo, ue->dl.lcCb, sizeof(ue->dl.lcCb));
867 for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
869 ueSCellCb.lcgInfo[idx].lcgId = ue->ul.lcgArr[idx].lcgId;
870 ueSCellCb.lcgInfo[idx].lcCount = ue->ul.lcgArr[idx].lcCount;
871 ueSCellCb.lcgInfo[idx].isGbr = ue->ul.lcgArr[idx].isGbr;
875 idx < ueRecfg->crgSCellCfg.numSCells; idx++)
877 dstMacInst = ueRecfg->crgSCellCfg.ueSCellCfg[idx].macInst - RG_INST_START;
878 ueSCellCb.cellId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].sCellId;
879 ueSCellCb.rguDlSapId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].rguDlSapId;
880 ueSCellCb.rguUlSapId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].rguUlSapId;
882 /* Get post structure of the cell to whom ueSCellCb needs to be sent
883 * And then send the sCell Add based on Mac instances */
884 rgGetPstToInst(&dstInstPst, inst, dstMacInst);
885 RgPrgPMacSMacUeSCellCfg(&dstInstPst, &ueSCellCb);
887 /*Commit Added SCell info to UeCb is moved to config confirm*/
888 } /*end of for loop */
892 } /* rgFillAndAddSCellCfg */
896 * @brief Handler for the UE configuration request from RRC to MAC.
900 * Function : rgCFGCrgUeCfg
903 * - Allocate and create UE control block.
904 * - Update UE control block with the values recieved in the
906 * - Invoke RAM, SCH, UHM and DHM with created UE control block, to
907 * update random access, scheduler, uplink harq and downlink harq
908 * specific information respectively.
909 * - If successful, add the control block to hash list of UEs for the cell
910 * else Rollback and FAIL.
912 * @param[in] Inst inst
913 * @param[in] RgCellCb *cell
914 * @param[in] CrgUeCfg *ueCfg
915 * @param[out] RgErrInfo *errInfo
929 Bool handover = FALSE;
933 errInfo->errCause = RGERR_CFG_CRG_UE_CFG;
935 /* Start: LTEMAC_2.1_DEV_CFG */
936 if ((ue = rgDBMGetUeCbFromRachLst(cell, ueCfg->crnti)) == NULLP)
938 /* Create UeCb and Insert in Rach List */
939 if((ue=rgRAMCreateUeCb(cell, ueCfg->crnti, FALSE, errInfo)) == NULLP)
941 DU_LOG("\nERROR --> MAC : UeCb creation failed");
944 if(rgDHMHqEntInit(inst,&ue->dl.hqEnt, cell->maxDlHqProcPerUe) != ROK)
946 DU_LOG("\nERROR --> MAC : UeCb Harq Entity Initialization failed");
951 /* End: LTEMAC_2.1_DEV_CFG */
953 if(handover == FALSE)
955 /* Remove from the rachLst */
956 rgDBMDelUeCbFromRachLst(cell, ue);
960 /* Initialize uplink HARQ related information for UE */
961 rgUHMCrgUeCfg(cell, ue, ueCfg);
963 rgDBMInsUeCb(cell, ue);
965 #ifdef TENB_MULT_CELL_SUPPRT
966 rguDlSapId = ueCfg->rguDlSapId;
967 rguUlSapId = ueCfg->rguUlSapId;
969 if(rgCb[inst].numRguSaps > 1)
975 ue->rguDlSap = &(rgCb[inst].rguSap[rguDlSapId]);
976 ue->rguUlSap = &(rgCb[inst].rguSap[rguUlSapId]);
979 /* Update satistics */
980 rgUpdtUeCnt(inst,RG_CFG_ADD);
981 errInfo->errCause = RGERR_NONE;
983 } /* rgCFGCrgUeCfg */
987 * @brief Handler for the logical channel configuration request from
992 * Function : rgCFGCrgLcCfg
995 * - Check if the configuration is for dedicated or common logical channel.
996 * - For Dedicated logical channels:
997 * - Update the dedicated logical channel Cb with the configured values.
998 * - Invoke SCH will cell, UE and logical channel Cb to update scheduler
999 * specific information.
1000 * - For Common logical channels:
1001 * - Update the common logical channel Cb with the configured values.
1002 * - Move cell to active list of cells if cell becomes ACTIVE.
1003 * - If successful, return ROK else RFAILED.
1005 * @param[in] Inst inst
1006 * @param[in] RgCellCb *cell
1007 * @param[in] RgUeCb *ue
1008 * @param[in] CrgLchCfg *lcCfg
1009 * @param[out] RgErrInfo *errInfo
1010 * @param[in] Bool *isCfmRqrd
1023 CrgCfgTransId transId
1027 /* Handle Config for dedicated/common logical channels */
1028 if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
1031 if ((rgCFGCrgDedLcCfg(cell, ue, lcCfg, errInfo)) != ROK)
1033 DU_LOG("\nERROR --> MAC : Dedicated logical channel configuration failed %d",lcCfg->lcId);
1037 /*ERAB Multl Cell fix*/
1038 memcpy(&(ue->cfgCfmInfo.transId), &transId,
1039 sizeof(CrgCfgTransId));
1040 rgPomSndUeSCellLchAddToSmac(inst, cell, ue, lcCfg,isCfmRqrd);
1045 if ((rgCFGCrgCmnLcCfg(inst,cell, lcCfg, errInfo)) != ROK)
1047 DU_LOG("\nERROR --> MAC : Common logical channel configuration"
1048 "failed %d\n", lcCfg->lcId);
1053 errInfo->errCause = RGERR_NONE;
1054 DU_LOG("\nINFO --> MAC : CRG LC config done for UE lcId %d\n", lcCfg->lcId);
1056 } /* rgCFGCrgLcCfg */
1060 * @brief Handler for the cell re-configuration request from RRC to MAC.
1064 * Function : rgCFGCrgCellRecfg
1067 * - Invoke SCH with updated Cell Cb to update scheduler specific
1069 * - Update the cell Cb with the reconfigured values.
1070 * - If successful, return ROK else RFAILED.
1072 * @param[in] Inst inst
1073 * @param[in] RgCellCb *cell
1074 * @param[in] CrgCellRecfg *cellRecfg
1075 * @param[out] RgErrInfo *errInfo
1080 S16 rgCFGCrgCellRecfg
1084 CrgCellRecfg *cellRecfg,
1088 /* Store the given rachCfg */
1089 cell->rachCfg = cellRecfg->rachRecfg;
1091 errInfo->errCause = RGERR_NONE;
1093 } /* rgCFGCrgCellRecfg */
1097 * @brief Handler for the UE re-configuration request from RRC to MAC.
1101 * Function : rgCFGCrgUeRecfg
1104 * - If rnti changes,
1105 * - Invoke RAM for UE reconfiguration.
1106 * - Delete old UE from the list.
1107 * - Update the new rnti and re-insert the UE in the list.
1108 * - Update the UE control block with the reconfigured values.
1109 * - Invoke SCH, UHM and DHM with updated UE control block to
1110 * update scheduler, uplink HARQ and downlink HARQ specific
1112 * - If successful, return ROK else RFAILED.
1114 * @param[in] Inst inst
1115 * @param[in] RgCellCb *cell
1116 * @param[in] RgUeCb *ue
1117 * @param[in] CrgUeRecfg *ueRecfg
1118 * @param[out] RgErrInfo *errInfo
1128 CrgUeRecfg *ueRecfg,
1132 errInfo->errCause = RGERR_CFG_CRG_UE_RECFG;
1134 /* Fix : syed UE ID change at MAC will now be controlled
1137 /* Update uplink HARQ related information for UE */
1138 rgUHMCrgUeRecfg(cell, ue, ueRecfg);
1140 errInfo->errCause = RGERR_NONE;
1142 } /* rgCFGCrgUeRecfg */
1146 * @brief Handler for the logical channel re-configuration request from
1151 * Function : rgCFGCrgLcRecfg
1154 * - Invoke scheduler to update scheduler specific information.
1155 * - Update the dedicated logical channel Cb with the re-configured
1157 * - If successful, return ROK else RFAILED.
1159 * @param[in] Inst inst
1160 * @param[in] RgUlCellCb *cell
1161 * @param[in] RgUlUeCb *ue
1162 * @param[in] RgUlLcCb *ulLc
1163 * @param[in] RgDlLcCb *dlLc
1164 * @param[in] CrgLchRecfg *lcRecfg
1165 * @param[out] RgErrInfo *errInfo
1176 CrgLchRecfg *lcRecfg,
1182 if (ulLc->lcgId != lcRecfg->ulRecfg.lcgId)
1184 rgDBMUpdUlDedLcCb(ue, ulLc, lcRecfg->ulRecfg.lcgId);
1186 rgPomSndUeSCellLchModToSmac(inst, cell, ue, lcRecfg,isCfmRqrd);
1190 errInfo->errCause = RGERR_NONE;
1192 } /* rgCFGCrgLcRecfg */
1194 /* Start: LTEMAC_2.1_DEV_CFG */
1196 * @brief Handler for the logical channel re-configuration request from
1201 * Function : rgCFGCrgUeReset
1205 * @param[in] RgUlCellCb *cell
1206 * @param[in] RgUlUeCb *ue
1207 * @param[in] CrgRst *reset
1208 * @param[out] RgErrInfo *errInfo
1222 DU_LOG("\nDEBUG --> MAC : UE of cell %d Reset\n", cell->cellId);
1223 rgDHMUeReset(cell, &ue->dl.hqEnt);
1225 errInfo->errCause = RGERR_NONE;
1228 } /* rgCFGCrgUeReset */
1229 /* End: LTEMAC_2.1_DEV_CFG */
1232 * @brief Handler for the cell delete request from RRC to MAC.
1236 * Function : rgCFGCrgCellDel
1239 * - Fetch the cell control block.
1240 * - Remove the cell control block from the hash list of cells.
1241 * - Free the cell control block.
1242 * - If successful, return ROK else return RFAILED.
1244 * @param[in] Inst inst
1245 * @param[in] CrgDel *cellDelInfo
1246 * @param[out] RgErrInfo *errInfo
1254 CrgDel *cellDelInfo,
1262 errInfo->errCause = RGERR_CFG_CRG_CELL_DEL;
1263 if (((cell = rgCb[inst].cell) == NULLP)
1264 ||(cell->cellId != cellDelInfo->u.cellDel.cellId))
1266 if(((cell = rgCb[inst].inactiveCell) == NULLP)
1267 ||(cell->cellId != cellDelInfo->u.cellDel.cellId))
1271 DU_LOG("\nERROR --> MAC : Cell does not exist");
1275 /* Delete cell from inactive list */
1276 rgCb[inst].inactiveCell = NULLP ;
1278 /* Free the inactive cell */
1279 rgCFGFreeInactvCellCb(cell);
1281 errInfo->errCause = RGERR_NONE;
1285 /* Delete from the cell list */
1286 //rgDBMDelCellCb(cell);
1287 for(idx=0;idx < RG_NUM_SUB_FRAMES; idx++)
1289 rgTOMRlsSf(inst,&cell->subFrms[idx]);
1292 /* Free the active cell */
1293 rgCFGFreeCellCb(cell);
1295 rgCb[inst].cell = NULLP;
1297 errInfo->errCause = RGERR_NONE;
1298 DU_LOG("\nINFO --> MAC : Cell %d deleted\n", cellDelInfo->u.cellDel.cellId);
1300 } /* rgCFGCrgCellDel */
1304 * @brief Handler for the UE delete request from RRC to MAC.
1308 * Function : rgCFGCrgUeDel
1311 * - Fetch the UE control block.
1312 * - Remove the UE control block from the hash list of UEs for the cell.
1313 * - Free the UE control block.
1314 * - If successful, return ROK else return RFAILED.
1316 * @param[in] Inst inst
1317 * @param[in] CrgDel *ueDelInfo
1318 * @param[out] RgErrInfo *errInfo
1331 errInfo->errCause = RGERR_CFG_CRG_UE_DEL;
1333 DU_LOG("\nDEBUG --> MAC : UE %d Deletion Req at MAC\n", \
1334 ueDelInfo->u.ueDel.crnti);
1335 if ((rgCb[inst].cell == NULLP)
1336 || (rgCb[inst].cell->cellId != ueDelInfo->u.ueDel.cellId))
1338 DU_LOG("\nERROR --> MAC : Cell does not exist %d",
1339 ueDelInfo->u.ueDel.cellId);
1343 errInfo->errCause = RGERR_NONE;
1344 /* Fix: syed Context Deletion is relied upon SCH indication */
1346 } /* rgCFGCrgUeDel */
1350 * @brief Handler for the logical channel delete request from
1355 * Function : rgCFGCrgLcDel
1358 * - Fetch the logical channel control block.
1359 * - Free the logical channel control block.
1360 * - If successful, return ROK else return RFAILED.
1362 * @param[in] Inst inst
1363 * @param[in] CrgDel *lcDelInfo
1364 * @param[out] RgErrInfo *errInfo
1375 CrgCfgTransId transId
1378 Bool dirVld = FALSE;
1384 errInfo->errCause = RGERR_CFG_CRG_LC_DEL;
1386 /* Fetch the Active cell */
1387 if (((cell = rgCb[inst].cell) == NULLP) ||
1388 (rgCb[inst].cell->cellId != lcDelInfo->u.lchDel.cellId))
1390 DU_LOG("\nERROR --> MAC : Cell does not exist %d",
1391 lcDelInfo->u.lchDel.cellId);
1396 if ((ue = rgDBMGetUeCb(cell, lcDelInfo->u.lchDel.crnti)) == NULLP)
1398 DU_LOG("\nERROR --> MAC : UE does not exist for dedicated logical channel");
1402 /* Validate downlink info */
1403 if (lcDelInfo->u.lchDel.dir & CRG_DIR_TX)
1405 if ((dlLc = rgDBMGetDlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
1408 DU_LOG("\nERROR --> MAC : DL LC %d does not exist",
1409 lcDelInfo->u.lchDel.lcId);
1412 rgDBMDelDlDedLcCb(ue, dlLc);
1416 /* Validate uplink info */
1417 if (lcDelInfo->u.lchDel.dir & CRG_DIR_RX)
1419 if ((ulLc = rgDBMGetUlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
1422 DU_LOG("\nERROR --> MAC : UL LC %d does not exist",
1423 lcDelInfo->u.lchDel.lcId);
1426 rgDBMDelUlDedLcCb(ue, ulLc);
1432 DU_LOG("\nERROR --> MAC : Invalid direction %d for LC Delete",
1433 lcDelInfo->u.lchDel.dir);
1437 /*ERAB - multicell fix*/
1438 memcpy( &(ue->cfgCfmInfo.transId), &transId,
1439 sizeof(CrgCfgTransId));
1440 rgPomSndUeSCellLchDelToSmac(inst, lcDelInfo, isCfmRqrd);
1442 errInfo->errCause = RGERR_NONE;
1444 } /* rgCFGCrgLcDel */
1446 /***********************************************************
1448 * Func : rgCFGVldtCrgDedLcCfg
1451 * Desc : Validates dedicated logical channel configuration recieved from RRC.
1461 **********************************************************/
1462 static S16 rgCFGVldtCrgDedLcCfg
1471 uint8_t dirVld = FALSE;
1473 errInfo->errCause = RGERR_CFG_INVALID_CRG_DED_LC_CFG;
1475 /* Fetch the Active cell */
1476 if (((*cell = rgCb[inst].cell) == NULLP)
1477 || ((*cell)->cellId != lcCfg->cellId))
1479 DU_LOG("\nERROR --> MAC : Active Cell does not exist: Cell %d",
1485 if ((*ue = rgDBMGetUeCb(*cell, lcCfg->crnti)) == NULLP)
1487 DU_LOG("\nERROR --> MAC : UE does not exist for dedicated logical channel %d",
1492 /* Validate logical channel Id */
1493 if ((lcCfg->lcId < RG_DEDLC_MIN_LCID)
1494 ||(lcCfg->lcId > RG_DEDLC_MAX_LCID))
1496 DU_LOG("\nERROR --> MAC : Invalid logical channel Id %d",
1501 /* Validate downlink info */
1502 if (lcCfg->dir & CRG_DIR_TX)
1504 if (rgDBMGetDlDedLcCb((*ue), lcCfg->lcId) != NULLP)
1506 DU_LOG("\nERROR --> MAC : UE Dedicated DL LC %d already configured",
1513 /* Validate uplink info */
1514 if (lcCfg->dir & CRG_DIR_RX)
1516 if (lcCfg->ulInfo.lcgId > (RG_MAX_LCG_PER_UE - 1))
1518 DU_LOG("\nERROR --> MAC : UE Invalid lcgId for uplink logical channel %d",
1519 lcCfg->ulInfo.lcgId);
1522 if (rgDBMGetUlDedLcCb((*ue), lcCfg->lcId) != NULLP)
1524 DU_LOG("\nERROR --> MAC : UE Dedicated UL LC %d already configured",
1533 DU_LOG("\nERROR --> MAC : Invalid Direction %d",
1539 } /* rgCFGVldtCrgDedLcCfg */
1542 /***********************************************************
1544 * Func : rgCFGVldtCrgCmnLcCfg
1547 * Desc : Validates common logical channel configuration recieved from RRC.
1557 **********************************************************/
1558 static S16 rgCFGVldtCrgCmnLcCfg
1566 uint8_t dirVld = FALSE;
1568 errInfo->errCause = RGERR_CFG_INVALID_CRG_CMN_LC_CFG;
1570 /* Ensure cell is not in the active list */
1571 if (((*cell = rgCb[inst].cell) != NULLP)
1572 && ((*cell)->cellId != lcCfg->cellId))
1574 DU_LOG("\nERROR --> MAC : Active Cell exists for common channels");
1578 /* Fetch the inactive cell for common logical channels */
1579 if (((*cell = rgCb[inst].inactiveCell) == NULLP)
1580 || ((*cell)->cellId != lcCfg->cellId))
1583 DU_LOG("\nERROR --> MAC : Inactive Cell does not exist for common channels");
1586 /* Validate downlink info */
1587 if (lcCfg->dir & CRG_DIR_TX)
1589 if (lcCfg->lcType == CM_LTE_LCH_BCCH)
1591 if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_DL_SCH)
1593 if (rgDBMGetBcchOnDlsch(*cell,lcCfg->lcId) != NULLP)
1595 DU_LOG("\nERROR --> MAC : BCCH on DLSCH already configured for cell");
1599 else if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_BCH)
1601 if (rgDBMGetBcchOnBch(*cell) != NULLP)
1603 DU_LOG("\nERROR --> MAC : BCCH on BCH already configured for cell ");
1609 DU_LOG("\nERROR --> MAC : Invalid transport channel %d for cell",
1610 lcCfg->dlInfo.dlTrchType);
1614 else if (lcCfg->lcType == CM_LTE_LCH_PCCH)
1616 if (rgDBMGetPcch(*cell) != NULLP)
1618 DU_LOG("\nERROR --> MAC : PCCH already configured for cell");
1622 else if (RG_DLCCCH_ISCFGD(*cell))
1624 DU_LOG("\nERROR --> MAC : DL CCCH already configured for cell ");
1630 /* Validate uplink info */
1631 if (lcCfg->dir & CRG_DIR_RX)
1634 if (lcCfg->lcType != CM_LTE_LCH_CCCH)
1636 DU_LOG("\nERROR --> MAC : Invalid UL common lcType %d for cell ",
1640 if (RG_ULCCCH_ISCFGD(*cell))
1642 DU_LOG("\nERROR --> MAC : UL CCCH already configured for cell ");
1648 /* Invalid direction */
1651 DU_LOG("\nERROR --> MAC : Invalid Direction %d", lcCfg->dir);
1656 } /* rgCFGVldtCrgCmnLcCfg */
1658 /***********************************************************
1660 * Func : rgCFGCrgDedLcCfg
1663 * Desc : Handles dedicated logical channel configuration
1664 * recieved from RRC.
1674 **********************************************************/
1675 static S16 rgCFGCrgDedLcCfg
1683 //Inst inst = cell->macInst - RG_INST_START;
1684 errInfo->errCause = RGERR_CFG_CRG_DED_LC_CFG;
1686 /* Uplink/Bi-directional logical channel */
1687 if (lcCfg->dir & CRG_DIR_RX)
1690 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId, lcCfg->qci);
1691 cell->qciArray[lcCfg->qci].qci = lcCfg->qci;
1692 if(lcCfg->lcType == CM_LTE_LCH_DTCH)
1694 rgAddToL2MeasPerQci(cell,lcCfg->qci);/*LTE_L2_MEAS_PHASE2*/
1697 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId);
1701 /* Downlink/Bi-directional logical channel */
1702 if (lcCfg->dir & CRG_DIR_TX)
1704 rgDBMInsDlDedLcCb(ue, lcCfg->lcId);
1707 } /* rgCFGCrgDedLcCfg */
1710 /***********************************************************
1712 * Func : rgCFGCrgCmnLcCfg
1715 * Desc : Handles dedicated logical channel configuration
1716 * recieved from RRC.
1726 **********************************************************/
1727 static S16 rgCFGCrgCmnLcCfg
1735 errInfo->errCause = RGERR_CFG_CRG_CMN_LC_CFG;
1737 /* Handle configuration for CCCH/BCCH/PCCH */
1738 if (lcCfg->lcType == CM_LTE_LCH_CCCH)
1740 /* UL and DL CCCH configuration */
1741 if (lcCfg->dir & CRG_DIR_TX)
1743 cell->dlCcchId = lcCfg->lcId;
1744 cell->cellActvState |= RG_DL_CCCH_CFG_DONE;
1747 if (lcCfg->dir & CRG_DIR_RX)
1749 cell->ulCcchId = lcCfg->lcId;
1750 cell->cellActvState |= RG_UL_CCCH_CFG_DONE;
1755 if (lcCfg->lcType == CM_LTE_LCH_BCCH)
1757 /* BCCH on BCH and DLSCH configuration */
1758 if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_DL_SCH)
1760 rgDBMInsBcchOnDlsch(cell, lcCfg->lcId);
1762 if(cell->cellActvState & RG_BCCH_DLSCH_CFG1_DONE)
1764 cell->cellActvState |= RG_BCCH_DLSCH_CFG2_DONE;
1768 cell->cellActvState |= RG_BCCH_DLSCH_CFG1_DONE;
1773 rgDBMInsBcchOnBch(cell, lcCfg->lcId);
1774 cell->cellActvState |= RG_BCCH_BCH_CFG_DONE;
1777 else /* PCCH configuration */
1779 rgDBMInsPcch(cell, lcCfg->lcId);
1780 cell->cellActvState |= RG_PCCH_CFG_DONE;
1784 /* Add to active cell list if cell is active */
1785 if (cell->cellActvState == RG_CELL_ACTIVE)
1787 rgCb[inst].cell = cell;
1788 rgCb[inst].inactiveCell = NULLP;
1789 DU_LOG("\nDEBUG --> MAC : Cell added to active list after common LC %d\
1790 config\n", lcCfg->lcId);
1794 } /* rgCFGCrgCmnLcCfg */
1796 /***********************************************************
1798 * Func : rgCFGFreeUeUlAlloc
1802 * - Processing Steps:
1803 * - Frees cell control block.
1811 **********************************************************/
1812 static Void rgCFGFreeUeUlAlloc(RgCellCb *cell)
1815 Inst inst = cell->macInst - RG_INST_START;
1817 for(sfIdx = 0; sfIdx < RG_NUM_UL_SUB_FRAMES; sfIdx++)
1819 if(cell->ulSf[sfIdx].ueUlAllocInfo != NULLP)
1821 /*ccpu00117052 - MOD- Passing double pointer for proper
1822 * NULLP assignment */
1823 rgFreeSBuf(inst,(Data **)&(cell->ulSf[sfIdx].ueUlAllocInfo),
1824 (cell->ulSf[sfIdx].numUe * sizeof(RgUeUlAlloc)));
1827 }/* rgCFGFreeUeUlAlloc */
1829 /***********************************************************
1831 * Func : rgCFGFreeCellCb
1835 * - Processing Steps:
1836 * - Frees cell control block.
1844 **********************************************************/
1845 Void rgCFGFreeCellCb(RgCellCb *cell)
1847 Inst inst = cell->macInst - RG_INST_START;
1850 RgLaaCellCbDeInit(cell);
1852 /* Free lists of the cell */
1854 rgCFGFreeSpsUeLst(cell);
1855 #endif /* LTEMAC_SPS */
1856 rgCFGFreeUeLst(cell);
1857 rgRAMFreeCell(cell);
1858 rgCFGFreeCmnLcLst(cell);
1860 rgCFGFreeUeUlAlloc(cell);
1862 /* ccpu00117052 - MOD - Passing double pointer for proper NULLP
1864 /* Update satistics */
1865 rgUpdtCellCnt(inst,RG_CFG_DEL);
1866 rgDHMFreeAllTbBufs(inst);
1868 rgFreeSBuf(inst,(Data **)&cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
1870 /* De-allocate the Cell */
1871 rgFreeSBuf(inst,(Data **)&cell, sizeof(*cell));
1874 DU_LOG("\nINFO --> MAC : Cell freed\n");
1876 /* Stack Crash Problem for TRACE5 Changes. Added return below */
1878 } /* rgCFGFreeCellCb */
1881 /***********************************************************
1883 * Func : rgCFGFreeInactvCellCb
1887 * - Processing Steps:
1888 * - Frees inactive cell control block.
1896 **********************************************************/
1897 Void rgCFGFreeInactvCellCb(RgCellCb *cell)
1899 Inst inst = cell->macInst - RG_INST_START;
1900 /* De-initialize the Ue list */
1901 rgDBMDeInitUeCbLst(cell);
1903 rgDBMDeInitSpsUeCbLst(cell);
1906 rgCFGFreeCmnLcLst(cell);
1908 rgFreeSBuf(inst, (Data **)&cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
1909 /*ccpu00117052 - MOD- Passing double pointer for proper
1911 /* De-allocate the Cell */
1912 rgFreeSBuf(inst,(Data **)&cell, sizeof(*cell));
1914 /* Update satistics */
1915 rgUpdtCellCnt(inst,RG_CFG_DEL);
1918 /* Stack Crash Problem for TRACE5 Changes. Added return below */
1920 } /* rgCFGFreeInactvCellCb */
1923 /***********************************************************
1925 * Func : rgCFGFreeUeCb
1929 * - Processing Steps:
1930 * - Frees UE control block.
1938 **********************************************************/
1939 Void rgCFGFreeUeCb(RgCellCb *cell,RgUeCb *ue)
1941 Inst inst = cell->macInst - RG_INST_START;
1943 rgDHMFreeUe(inst,&ue->dl.hqEnt);
1945 /* ccpu00117052 - MOD - Passing double pointer for proper NULLP
1947 /* De-allocate the Ue */
1948 rgFreeSBuf(inst,(Data **)&ue, sizeof(*ue));
1950 /* Update Statistics */
1951 rgUpdtUeCnt(inst,RG_CFG_DEL);
1954 /* Stack Crash Problem for TRACE5 Changes. Added return below */
1956 } /* rgCFGFreeUeCb */
1958 /***********************************************************
1960 * Func : rgCFGFreeCmnLcLst
1964 * - Processing Steps:
1965 * - Frees common logical channels in cell control block.
1973 **********************************************************/
1974 static Void rgCFGFreeCmnLcLst(RgCellCb *cell)
1976 rgDBMFreeCmnLcLst(cell);
1979 /* Stack Crash Problem for TRACE5 Changes. Added return below */
1981 } /* rgCFGFreeCmnLcLst */
1984 /***********************************************************
1986 * Func : rgCFGFreeUeLst
1990 * - Processing Steps:
1991 * - Frees UE list in cell control block.
1999 **********************************************************/
2000 static Void rgCFGFreeUeLst(RgCellCb *cell)
2004 /* Free Ues in the list */
2005 while ((ue = rgDBMGetNextUeCb(cell, NULLP)) != NULLP)
2008 rgDelUeFrmAllSCell(cell,ue);
2010 rgDBMDelUeCb(cell, ue);
2011 rgCFGFreeUeCb(cell, ue);
2014 /* De-initialize the Ue list */
2015 rgDBMDeInitUeCbLst(cell);
2018 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2020 } /* rgCFGFreeUeLst */
2023 /***********************************************************
2025 * Func : rgCFGFreeSpsUeLst
2029 * - Processing Steps:
2030 * - Frees Sps UE list in cell control block.
2038 **********************************************************/
2039 static Void rgCFGFreeSpsUeLst(RgCellCb *cell)
2043 /* Free Ues in the list */
2044 while ((ue = rgDBMGetNextSpsUeCb(cell, NULLP)))
2046 rgDBMDelSpsUeCb(cell, ue);
2049 /* De-initialize the Ue list */
2050 rgDBMDeInitSpsUeCbLst(cell);
2052 } /* rgCFGFreeSpsUeLst */
2054 #endif /* LTEMAC_SPS */
2057 * @brief Function for registering cell- scheduler instance mapping
2061 * Function : RgSchMacCellRegReq
2063 * This function shall be invoked whenever scheduler is done with the
2064 * cell configuration successfully.
2065 * This shall create a mapping of the cell, scheduler instance that
2066 * is serving the cell and the unique identifier of the cell on the
2067 * scheduler at MAC. This mapping shall be used for further
2068 * communication to the scheduler instance for this cell.
2071 * @param[in] Pst* pst,
2072 * @param[in] CmLteCellId cellId,
2073 * @param[in] RaRespReqInfo raRespReq
2077 S16 RgSchMacCellRegReq(Pst* pst,RgInfCellReg* regReq)
2080 RgCellCb *cell = NULLP;
2082 RG_IS_INST_VALID(pst->dstInst);
2083 inst = pst->dstInst - RG_INST_START;
2084 cell = rgCb[inst].cell;
2091 if((cell == NULLP) || (cell->cellId != regReq->cellId))
2095 if(regReq->maxDlHqProcPerUe > RG_MAX_DL_HARQ_NUM)
2100 cell->schInstMap.cellSapId = regReq->cellSapId;
2101 cell->schInstMap.schInst = pst->srcInst;
2102 cell->maxDlHqProcPerUe = regReq->maxDlHqProcPerUe;
2106 } /* end of RgSchMacCellRegReq */
2108 /*Added Ue for Onging L2 Meas*/
2110 /*LTE_L2_MEAS_PHASE2*/
2111 S16 rgAddToL2MeasPerQci(RgCellCb *cell,uint8_t qci)
2118 lnk = cell->l2mList.first;
2119 while(lnk != NULLP )
2121 measCb = (RgL2MeasCb *)lnk->node;
2122 if(measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
2124 for(idx = 0;idx< measCb->measReq.t.prbReq.numQci;idx++)
2126 if(measCb->measReq.t.prbReq.qci[idx] == qci)
2128 break; /*exit from for loop*/
2131 if(idx == measCb->measReq.t.prbReq.numQci)
2133 cell->qciArray[qci].mask = TRUE;
2134 measCb->measReq.t.prbReq.qci[measCb->measReq.t.prbReq.numQci++] = qci;
2148 /**********************************************************************
2151 **********************************************************************/