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*/
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 MAC_ALLOC(cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
692 if(cell->flowCntrlInd == NULLP)
694 DU_LOG("ERROR --> MAC : rgCFGCrgCellCfg(): Memory allocation failed");
698 } /* rgCFGCrgCellCfg */
702 * @brief Add SCell Cfg recvd from primary MAC instance.
706 * Function : rgCfgAddUeSCellCfg
709 * - Allocate and create UE control block.
710 * - Update UE control block with the values recieved in the
712 * - If successful, add the control block to hash list of UEs for the cell
713 * else Rollback and FAIL.
715 * @param[in] Inst dstMacInst
716 * @param[in] RgPrgUeSCellCfgInfo *ueSCellCb
717 * @param[in] RgCellCb cell
723 S16 rgCfgAddUeSCellCfg
726 RgPrgUeSCellCfgInfo *ueSCellCb,
730 RgUeCb *ueCb = NULLP;
737 rguDlSapId = ueSCellCb->rguDlSapId;
738 rguUlSapId = ueSCellCb->rguUlSapId;
740 #ifndef TENB_MULT_CELL_SUPPRT
741 if(rgCb[dstMacInst].numRguSaps > 1)
747 if ((ueCb = rgDBMGetUeCb(cell, ueSCellCb->ueId)) != NULLP)
749 DU_LOG("\nERROR --> MAC : [%d]UE already exist in scell %d during scell addition\n",
756 if((ueCb = rgRAMCreateUeCb(cell, ueSCellCb->ueId,
757 FALSE, &errInfo)) == NULLP)
759 DU_LOG("\nERROR --> MAC : [%d]UeCb creation failed\n", ueSCellCb->ueId);
763 if(rgDHMHqEntInit(dstMacInst, &ueCb->dl.hqEnt,
764 (rgCb[dstMacInst].cell)->maxDlHqProcPerUe) != ROK)
766 DU_LOG("\nERROR --> MAC : [%d]UeCb Harq Entity Initialization failed\n", ueSCellCb->ueId);
769 rgDBMInsUeCb(cell, ueCb);
772 ueCb->rguDlSap = &(rgCb[dstMacInst].rguSap[rguDlSapId]);
773 ueCb->rguUlSap = &(rgCb[dstMacInst].rguSap[rguUlSapId]);
775 /* Update satistics */
776 rgUpdtUeCnt(dstMacInst, RG_CFG_ADD);
777 /*Commit Added SCell info to UeCb */
779 ueCb->sCelAddInfo[idx].isSCellAdded = TRUE;
780 ueCb->sCelAddInfo[idx].macInst = dstMacInst;
781 ueCb->sCelAddInfo[idx].sCellId = ueSCellCb->cellId;
784 ueCb->txMode = ueSCellCb->txMode;
785 ueCb->ul.hqEnt.maxHqRetx = ueSCellCb->maxUlHqRetx;
787 for (idx =0; idx <RG_MAX_LC_PER_UE; idx++)
789 ueCb->ul.lcCb[idx] = ueSCellCb->ulLcInfo[idx];
790 ueCb->dl.lcCb[idx] = ueSCellCb->dlLcInfo[idx];
793 for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
795 ueCb->ul.lcgArr[idx].lcgId = ueSCellCb->lcgInfo[idx].lcgId;
796 ueCb->ul.lcgArr[idx].lcCount = ueSCellCb->lcgInfo[idx].lcCount;
797 ueCb->ul.lcgArr[idx].isGbr = ueSCellCb->lcgInfo[idx].isGbr;
800 }/* rgCfgAddUeSCellCfg */
803 * @brief SCell Config Filling for added cell from RRC to MAC.
807 * Function : rgFillAndAddSCellCfg
810 * - Update UE control block with the values recieved in the
812 * - Update UE control block with the values present in the
814 * - If successful, add the control block to hash list of UEs for the cell
815 * else Rollback and FAIL.
817 * @param[in] Inst inst
818 * @param[in] RgCellCb *cell
819 * @param[in] CrgUeCfg *ueCfg
820 * @param[in] CrgCfgTransId transId
825 S16 rgFillAndAddSCellCfg
830 CrgCfgTransId transId,
837 RgPrgUeSCellCfgInfo ueSCellCb;
840 /* Fetch the Active cell */
841 if(((cell = rgCb[inst].cell) == NULLP) ||
842 (cell->cellId != ueRecfg->cellId))
844 DU_LOG("\nERROR --> MAC : [%d]Active Cell does not exist %d\n",
845 ueRecfg->oldCrnti, ueRecfg->cellId);
849 DU_LOG("\nINFO --> MAC : Filling SCell Config : cellId %d ueId %d\n",
850 cell->cellId, cell->ueId);
852 if ((ue = rgDBMGetUeCb(cell, ueRecfg->oldCrnti)) == NULLP)
854 DU_LOG("\nERROR --> MAC : [%d]UE does not exist\n", ueRecfg->oldCrnti);
858 /* Initialize cfgCfmInfo in the ueCb. This is used while processing SCellAdd
860 ue->cfgCfmInfo.numSCells = ueRecfg->crgSCellCfg.numSCells;
861 ue->cfgCfmInfo.cfgCfgCount = 0;
862 ue->cfgCfmInfo.mask = 0x0;
864 memcpy(&(ue->cfgCfmInfo.transId), &transId,
865 sizeof(CrgCfgTransId));
866 ueSCellCb.ueId = ueRecfg->oldCrnti;
867 ueSCellCb.txMode = ue->txMode;
868 ueSCellCb.maxUlHqRetx = ue->ul.hqEnt.maxHqRetx;
869 memcpy(ueSCellCb.ulLcInfo, ue->ul.lcCb, sizeof(ue->ul.lcCb));
870 memcpy(ueSCellCb.dlLcInfo, ue->dl.lcCb, sizeof(ue->dl.lcCb));
871 for (idx =0; idx < RG_MAX_LCG_PER_UE; idx++)
873 ueSCellCb.lcgInfo[idx].lcgId = ue->ul.lcgArr[idx].lcgId;
874 ueSCellCb.lcgInfo[idx].lcCount = ue->ul.lcgArr[idx].lcCount;
875 ueSCellCb.lcgInfo[idx].isGbr = ue->ul.lcgArr[idx].isGbr;
879 idx < ueRecfg->crgSCellCfg.numSCells; idx++)
881 dstMacInst = ueRecfg->crgSCellCfg.ueSCellCfg[idx].macInst - RG_INST_START;
882 ueSCellCb.cellId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].sCellId;
883 ueSCellCb.rguDlSapId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].rguDlSapId;
884 ueSCellCb.rguUlSapId = ueRecfg->crgSCellCfg.ueSCellCfg[idx].rguUlSapId;
886 /* Get post structure of the cell to whom ueSCellCb needs to be sent
887 * And then send the sCell Add based on Mac instances */
888 rgGetPstToInst(&dstInstPst, inst, dstMacInst);
889 RgPrgPMacSMacUeSCellCfg(&dstInstPst, &ueSCellCb);
891 /*Commit Added SCell info to UeCb is moved to config confirm*/
892 } /*end of for loop */
896 } /* rgFillAndAddSCellCfg */
900 * @brief Handler for the UE configuration request from RRC to MAC.
904 * Function : rgCFGCrgUeCfg
907 * - Allocate and create UE control block.
908 * - Update UE control block with the values recieved in the
910 * - Invoke RAM, SCH, UHM and DHM with created UE control block, to
911 * update random access, scheduler, uplink harq and downlink harq
912 * specific information respectively.
913 * - If successful, add the control block to hash list of UEs for the cell
914 * else Rollback and FAIL.
916 * @param[in] Inst inst
917 * @param[in] RgCellCb *cell
918 * @param[in] CrgUeCfg *ueCfg
919 * @param[out] RgErrInfo *errInfo
933 Bool handover = FALSE;
937 errInfo->errCause = RGERR_CFG_CRG_UE_CFG;
939 /* Start: LTEMAC_2.1_DEV_CFG */
940 if ((ue = rgDBMGetUeCbFromRachLst(cell, ueCfg->crnti)) == NULLP)
942 /* Create UeCb and Insert in Rach List */
943 if((ue=rgRAMCreateUeCb(cell, ueCfg->crnti, FALSE, errInfo)) == NULLP)
945 DU_LOG("\nERROR --> MAC : UeCb creation failed");
948 if(rgDHMHqEntInit(inst,&ue->dl.hqEnt, cell->maxDlHqProcPerUe) != ROK)
950 DU_LOG("\nERROR --> MAC : UeCb Harq Entity Initialization failed");
955 /* End: LTEMAC_2.1_DEV_CFG */
957 if(handover == FALSE)
959 /* Remove from the rachLst */
960 rgDBMDelUeCbFromRachLst(cell, ue);
964 /* Initialize uplink HARQ related information for UE */
965 rgUHMCrgUeCfg(cell, ue, ueCfg);
967 rgDBMInsUeCb(cell, ue);
969 #ifdef TENB_MULT_CELL_SUPPRT
970 rguDlSapId = ueCfg->rguDlSapId;
971 rguUlSapId = ueCfg->rguUlSapId;
973 if(rgCb[inst].numRguSaps > 1)
979 ue->rguDlSap = &(rgCb[inst].rguSap[rguDlSapId]);
980 ue->rguUlSap = &(rgCb[inst].rguSap[rguUlSapId]);
983 /* Update satistics */
984 rgUpdtUeCnt(inst,RG_CFG_ADD);
985 errInfo->errCause = RGERR_NONE;
987 } /* rgCFGCrgUeCfg */
991 * @brief Handler for the logical channel configuration request from
996 * Function : rgCFGCrgLcCfg
999 * - Check if the configuration is for dedicated or common logical channel.
1000 * - For Dedicated logical channels:
1001 * - Update the dedicated logical channel Cb with the configured values.
1002 * - Invoke SCH will cell, UE and logical channel Cb to update scheduler
1003 * specific information.
1004 * - For Common logical channels:
1005 * - Update the common logical channel Cb with the configured values.
1006 * - Move cell to active list of cells if cell becomes ACTIVE.
1007 * - If successful, return ROK else RFAILED.
1009 * @param[in] Inst inst
1010 * @param[in] RgCellCb *cell
1011 * @param[in] RgUeCb *ue
1012 * @param[in] CrgLchCfg *lcCfg
1013 * @param[out] RgErrInfo *errInfo
1014 * @param[in] Bool *isCfmRqrd
1027 CrgCfgTransId transId
1031 /* Handle Config for dedicated/common logical channels */
1032 if (lcCfg->lcType == CM_LTE_LCH_DTCH || lcCfg->lcType == CM_LTE_LCH_DCCH)
1035 if ((rgCFGCrgDedLcCfg(cell, ue, lcCfg, errInfo)) != ROK)
1037 DU_LOG("\nERROR --> MAC : Dedicated logical channel configuration failed %d",lcCfg->lcId);
1041 /*ERAB Multl Cell fix*/
1042 memcpy(&(ue->cfgCfmInfo.transId), &transId,
1043 sizeof(CrgCfgTransId));
1044 rgPomSndUeSCellLchAddToSmac(inst, cell, ue, lcCfg,isCfmRqrd);
1049 if ((rgCFGCrgCmnLcCfg(inst,cell, lcCfg, errInfo)) != ROK)
1051 DU_LOG("\nERROR --> MAC : Common logical channel configuration"
1052 "failed %d\n", lcCfg->lcId);
1057 errInfo->errCause = RGERR_NONE;
1058 DU_LOG("\nINFO --> MAC : CRG LC config done for UE lcId %d\n", lcCfg->lcId);
1060 } /* rgCFGCrgLcCfg */
1064 * @brief Handler for the cell re-configuration request from RRC to MAC.
1068 * Function : rgCFGCrgCellRecfg
1071 * - Invoke SCH with updated Cell Cb to update scheduler specific
1073 * - Update the cell Cb with the reconfigured values.
1074 * - If successful, return ROK else RFAILED.
1076 * @param[in] Inst inst
1077 * @param[in] RgCellCb *cell
1078 * @param[in] CrgCellRecfg *cellRecfg
1079 * @param[out] RgErrInfo *errInfo
1084 S16 rgCFGCrgCellRecfg
1088 CrgCellRecfg *cellRecfg,
1092 /* Store the given rachCfg */
1093 cell->rachCfg = cellRecfg->rachRecfg;
1095 errInfo->errCause = RGERR_NONE;
1097 } /* rgCFGCrgCellRecfg */
1101 * @brief Handler for the UE re-configuration request from RRC to MAC.
1105 * Function : rgCFGCrgUeRecfg
1108 * - If rnti changes,
1109 * - Invoke RAM for UE reconfiguration.
1110 * - Delete old UE from the list.
1111 * - Update the new rnti and re-insert the UE in the list.
1112 * - Update the UE control block with the reconfigured values.
1113 * - Invoke SCH, UHM and DHM with updated UE control block to
1114 * update scheduler, uplink HARQ and downlink HARQ specific
1116 * - If successful, return ROK else RFAILED.
1118 * @param[in] Inst inst
1119 * @param[in] RgCellCb *cell
1120 * @param[in] RgUeCb *ue
1121 * @param[in] CrgUeRecfg *ueRecfg
1122 * @param[out] RgErrInfo *errInfo
1132 CrgUeRecfg *ueRecfg,
1136 errInfo->errCause = RGERR_CFG_CRG_UE_RECFG;
1138 /* Fix : syed UE ID change at MAC will now be controlled
1141 /* Update uplink HARQ related information for UE */
1142 rgUHMCrgUeRecfg(cell, ue, ueRecfg);
1144 errInfo->errCause = RGERR_NONE;
1146 } /* rgCFGCrgUeRecfg */
1150 * @brief Handler for the logical channel re-configuration request from
1155 * Function : rgCFGCrgLcRecfg
1158 * - Invoke scheduler to update scheduler specific information.
1159 * - Update the dedicated logical channel Cb with the re-configured
1161 * - If successful, return ROK else RFAILED.
1163 * @param[in] Inst inst
1164 * @param[in] RgUlCellCb *cell
1165 * @param[in] RgUlUeCb *ue
1166 * @param[in] RgUlLcCb *ulLc
1167 * @param[in] RgDlLcCb *dlLc
1168 * @param[in] CrgLchRecfg *lcRecfg
1169 * @param[out] RgErrInfo *errInfo
1180 CrgLchRecfg *lcRecfg,
1186 if (ulLc->lcgId != lcRecfg->ulRecfg.lcgId)
1188 rgDBMUpdUlDedLcCb(ue, ulLc, lcRecfg->ulRecfg.lcgId);
1190 rgPomSndUeSCellLchModToSmac(inst, cell, ue, lcRecfg,isCfmRqrd);
1194 errInfo->errCause = RGERR_NONE;
1196 } /* rgCFGCrgLcRecfg */
1198 /* Start: LTEMAC_2.1_DEV_CFG */
1200 * @brief Handler for the logical channel re-configuration request from
1205 * Function : rgCFGCrgUeReset
1209 * @param[in] RgUlCellCb *cell
1210 * @param[in] RgUlUeCb *ue
1211 * @param[in] CrgRst *reset
1212 * @param[out] RgErrInfo *errInfo
1226 DU_LOG("\nDEBUG --> MAC : UE of cell %d Reset\n", cell->cellId);
1227 rgDHMUeReset(cell, &ue->dl.hqEnt);
1229 errInfo->errCause = RGERR_NONE;
1232 } /* rgCFGCrgUeReset */
1233 /* End: LTEMAC_2.1_DEV_CFG */
1236 * @brief Handler for the cell delete request from RRC to MAC.
1240 * Function : rgCFGCrgCellDel
1243 * - Fetch the cell control block.
1244 * - Remove the cell control block from the hash list of cells.
1245 * - Free the cell control block.
1246 * - If successful, return ROK else return RFAILED.
1248 * @param[in] Inst inst
1249 * @param[in] CrgDel *cellDelInfo
1250 * @param[out] RgErrInfo *errInfo
1258 CrgDel *cellDelInfo,
1266 errInfo->errCause = RGERR_CFG_CRG_CELL_DEL;
1267 if (((cell = rgCb[inst].cell) == NULLP)
1268 ||(cell->cellId != cellDelInfo->u.cellDel.cellId))
1270 if(((cell = rgCb[inst].inactiveCell) == NULLP)
1271 ||(cell->cellId != cellDelInfo->u.cellDel.cellId))
1275 DU_LOG("\nERROR --> MAC : Cell does not exist");
1279 /* Delete cell from inactive list */
1280 rgCb[inst].inactiveCell = NULLP ;
1282 /* Free the inactive cell */
1283 rgCFGFreeInactvCellCb(cell);
1285 errInfo->errCause = RGERR_NONE;
1289 /* Delete from the cell list */
1290 //rgDBMDelCellCb(cell);
1291 for(idx=0;idx < RG_NUM_SUB_FRAMES; idx++)
1293 rgTOMRlsSf(inst,&cell->subFrms[idx]);
1296 /* Free the active cell */
1297 rgCFGFreeCellCb(cell);
1299 rgCb[inst].cell = NULLP;
1301 errInfo->errCause = RGERR_NONE;
1302 DU_LOG("\nINFO --> MAC : Cell %d deleted\n", cellDelInfo->u.cellDel.cellId);
1304 } /* rgCFGCrgCellDel */
1308 * @brief Handler for the UE delete request from RRC to MAC.
1312 * Function : rgCFGCrgUeDel
1315 * - Fetch the UE control block.
1316 * - Remove the UE control block from the hash list of UEs for the cell.
1317 * - Free the UE control block.
1318 * - If successful, return ROK else return RFAILED.
1320 * @param[in] Inst inst
1321 * @param[in] CrgDel *ueDelInfo
1322 * @param[out] RgErrInfo *errInfo
1335 errInfo->errCause = RGERR_CFG_CRG_UE_DEL;
1337 DU_LOG("\nDEBUG --> MAC : UE %d Deletion Req at MAC\n", \
1338 ueDelInfo->u.ueDel.crnti);
1339 if ((rgCb[inst].cell == NULLP)
1340 || (rgCb[inst].cell->cellId != ueDelInfo->u.ueDel.cellId))
1342 DU_LOG("\nERROR --> MAC : Cell does not exist %d",
1343 ueDelInfo->u.ueDel.cellId);
1347 errInfo->errCause = RGERR_NONE;
1348 /* Fix: syed Context Deletion is relied upon SCH indication */
1350 } /* rgCFGCrgUeDel */
1354 * @brief Handler for the logical channel delete request from
1359 * Function : rgCFGCrgLcDel
1362 * - Fetch the logical channel control block.
1363 * - Free the logical channel control block.
1364 * - If successful, return ROK else return RFAILED.
1366 * @param[in] Inst inst
1367 * @param[in] CrgDel *lcDelInfo
1368 * @param[out] RgErrInfo *errInfo
1379 CrgCfgTransId transId
1382 Bool dirVld = FALSE;
1388 errInfo->errCause = RGERR_CFG_CRG_LC_DEL;
1390 /* Fetch the Active cell */
1391 if (((cell = rgCb[inst].cell) == NULLP) ||
1392 (rgCb[inst].cell->cellId != lcDelInfo->u.lchDel.cellId))
1394 DU_LOG("\nERROR --> MAC : Cell does not exist %d",
1395 lcDelInfo->u.lchDel.cellId);
1400 if ((ue = rgDBMGetUeCb(cell, lcDelInfo->u.lchDel.crnti)) == NULLP)
1402 DU_LOG("\nERROR --> MAC : UE does not exist for dedicated logical channel");
1406 /* Validate downlink info */
1407 if (lcDelInfo->u.lchDel.dir & CRG_DIR_TX)
1409 if ((dlLc = rgDBMGetDlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
1412 DU_LOG("\nERROR --> MAC : DL LC %d does not exist",
1413 lcDelInfo->u.lchDel.lcId);
1416 rgDBMDelDlDedLcCb(ue, dlLc);
1420 /* Validate uplink info */
1421 if (lcDelInfo->u.lchDel.dir & CRG_DIR_RX)
1423 if ((ulLc = rgDBMGetUlDedLcCb(ue, lcDelInfo->u.lchDel.lcId))
1426 DU_LOG("\nERROR --> MAC : UL LC %d does not exist",
1427 lcDelInfo->u.lchDel.lcId);
1430 rgDBMDelUlDedLcCb(ue, ulLc);
1436 DU_LOG("\nERROR --> MAC : Invalid direction %d for LC Delete",
1437 lcDelInfo->u.lchDel.dir);
1441 /*ERAB - multicell fix*/
1442 memcpy( &(ue->cfgCfmInfo.transId), &transId,
1443 sizeof(CrgCfgTransId));
1444 rgPomSndUeSCellLchDelToSmac(inst, lcDelInfo, isCfmRqrd);
1446 errInfo->errCause = RGERR_NONE;
1448 } /* rgCFGCrgLcDel */
1450 /***********************************************************
1452 * Func : rgCFGVldtCrgDedLcCfg
1455 * Desc : Validates dedicated logical channel configuration recieved from RRC.
1465 **********************************************************/
1466 static S16 rgCFGVldtCrgDedLcCfg
1475 uint8_t dirVld = FALSE;
1477 errInfo->errCause = RGERR_CFG_INVALID_CRG_DED_LC_CFG;
1479 /* Fetch the Active cell */
1480 if (((*cell = rgCb[inst].cell) == NULLP)
1481 || ((*cell)->cellId != lcCfg->cellId))
1483 DU_LOG("\nERROR --> MAC : Active Cell does not exist: Cell %d",
1489 if ((*ue = rgDBMGetUeCb(*cell, lcCfg->crnti)) == NULLP)
1491 DU_LOG("\nERROR --> MAC : UE does not exist for dedicated logical channel %d",
1496 /* Validate logical channel Id */
1497 if ((lcCfg->lcId < RG_DEDLC_MIN_LCID)
1498 ||(lcCfg->lcId > RG_DEDLC_MAX_LCID))
1500 DU_LOG("\nERROR --> MAC : Invalid logical channel Id %d",
1505 /* Validate downlink info */
1506 if (lcCfg->dir & CRG_DIR_TX)
1508 if (rgDBMGetDlDedLcCb((*ue), lcCfg->lcId) != NULLP)
1510 DU_LOG("\nERROR --> MAC : UE Dedicated DL LC %d already configured",
1517 /* Validate uplink info */
1518 if (lcCfg->dir & CRG_DIR_RX)
1520 if (lcCfg->ulInfo.lcgId > (RG_MAX_LCG_PER_UE - 1))
1522 DU_LOG("\nERROR --> MAC : UE Invalid lcgId for uplink logical channel %d",
1523 lcCfg->ulInfo.lcgId);
1526 if (rgDBMGetUlDedLcCb((*ue), lcCfg->lcId) != NULLP)
1528 DU_LOG("\nERROR --> MAC : UE Dedicated UL LC %d already configured",
1537 DU_LOG("\nERROR --> MAC : Invalid Direction %d",
1543 } /* rgCFGVldtCrgDedLcCfg */
1546 /***********************************************************
1548 * Func : rgCFGVldtCrgCmnLcCfg
1551 * Desc : Validates common logical channel configuration recieved from RRC.
1561 **********************************************************/
1562 static S16 rgCFGVldtCrgCmnLcCfg
1570 uint8_t dirVld = FALSE;
1572 errInfo->errCause = RGERR_CFG_INVALID_CRG_CMN_LC_CFG;
1574 /* Ensure cell is not in the active list */
1575 if (((*cell = rgCb[inst].cell) != NULLP)
1576 && ((*cell)->cellId != lcCfg->cellId))
1578 DU_LOG("\nERROR --> MAC : Active Cell exists for common channels");
1582 /* Fetch the inactive cell for common logical channels */
1583 if (((*cell = rgCb[inst].inactiveCell) == NULLP)
1584 || ((*cell)->cellId != lcCfg->cellId))
1587 DU_LOG("\nERROR --> MAC : Inactive Cell does not exist for common channels");
1590 /* Validate downlink info */
1591 if (lcCfg->dir & CRG_DIR_TX)
1593 if (lcCfg->lcType == CM_LTE_LCH_BCCH)
1595 if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_DL_SCH)
1597 if (rgDBMGetBcchOnDlsch(*cell,lcCfg->lcId) != NULLP)
1599 DU_LOG("\nERROR --> MAC : BCCH on DLSCH already configured for cell");
1603 else if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_BCH)
1605 if (rgDBMGetBcchOnBch(*cell) != NULLP)
1607 DU_LOG("\nERROR --> MAC : BCCH on BCH already configured for cell ");
1613 DU_LOG("\nERROR --> MAC : Invalid transport channel %d for cell",
1614 lcCfg->dlInfo.dlTrchType);
1618 else if (lcCfg->lcType == CM_LTE_LCH_PCCH)
1620 if (rgDBMGetPcch(*cell) != NULLP)
1622 DU_LOG("\nERROR --> MAC : PCCH already configured for cell");
1626 else if (RG_DLCCCH_ISCFGD(*cell))
1628 DU_LOG("\nERROR --> MAC : DL CCCH already configured for cell ");
1634 /* Validate uplink info */
1635 if (lcCfg->dir & CRG_DIR_RX)
1638 if (lcCfg->lcType != CM_LTE_LCH_CCCH)
1640 DU_LOG("\nERROR --> MAC : Invalid UL common lcType %d for cell ",
1644 if (RG_ULCCCH_ISCFGD(*cell))
1646 DU_LOG("\nERROR --> MAC : UL CCCH already configured for cell ");
1652 /* Invalid direction */
1655 DU_LOG("\nERROR --> MAC : Invalid Direction %d", lcCfg->dir);
1660 } /* rgCFGVldtCrgCmnLcCfg */
1662 /***********************************************************
1664 * Func : rgCFGCrgDedLcCfg
1667 * Desc : Handles dedicated logical channel configuration
1668 * recieved from RRC.
1678 **********************************************************/
1679 static S16 rgCFGCrgDedLcCfg
1687 //Inst inst = cell->macInst - RG_INST_START;
1688 errInfo->errCause = RGERR_CFG_CRG_DED_LC_CFG;
1690 /* Uplink/Bi-directional logical channel */
1691 if (lcCfg->dir & CRG_DIR_RX)
1694 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId, lcCfg->qci);
1695 cell->qciArray[lcCfg->qci].qci = lcCfg->qci;
1696 if(lcCfg->lcType == CM_LTE_LCH_DTCH)
1698 rgAddToL2MeasPerQci(cell,lcCfg->qci);/*LTE_L2_MEAS_PHASE2*/
1701 rgDBMInsUlDedLcCb(ue, lcCfg->lcId, lcCfg->ulInfo.lcgId);
1705 /* Downlink/Bi-directional logical channel */
1706 if (lcCfg->dir & CRG_DIR_TX)
1708 rgDBMInsDlDedLcCb(ue, lcCfg->lcId);
1711 } /* rgCFGCrgDedLcCfg */
1714 /***********************************************************
1716 * Func : rgCFGCrgCmnLcCfg
1719 * Desc : Handles dedicated logical channel configuration
1720 * recieved from RRC.
1730 **********************************************************/
1731 static S16 rgCFGCrgCmnLcCfg
1739 errInfo->errCause = RGERR_CFG_CRG_CMN_LC_CFG;
1741 /* Handle configuration for CCCH/BCCH/PCCH */
1742 if (lcCfg->lcType == CM_LTE_LCH_CCCH)
1744 /* UL and DL CCCH configuration */
1745 if (lcCfg->dir & CRG_DIR_TX)
1747 cell->dlCcchId = lcCfg->lcId;
1748 cell->cellActvState |= RG_DL_CCCH_CFG_DONE;
1751 if (lcCfg->dir & CRG_DIR_RX)
1753 cell->ulCcchId = lcCfg->lcId;
1754 cell->cellActvState |= RG_UL_CCCH_CFG_DONE;
1759 if (lcCfg->lcType == CM_LTE_LCH_BCCH)
1761 /* BCCH on BCH and DLSCH configuration */
1762 if (lcCfg->dlInfo.dlTrchType == CM_LTE_TRCH_DL_SCH)
1764 rgDBMInsBcchOnDlsch(cell, lcCfg->lcId);
1766 if(cell->cellActvState & RG_BCCH_DLSCH_CFG1_DONE)
1768 cell->cellActvState |= RG_BCCH_DLSCH_CFG2_DONE;
1772 cell->cellActvState |= RG_BCCH_DLSCH_CFG1_DONE;
1777 rgDBMInsBcchOnBch(cell, lcCfg->lcId);
1778 cell->cellActvState |= RG_BCCH_BCH_CFG_DONE;
1781 else /* PCCH configuration */
1783 rgDBMInsPcch(cell, lcCfg->lcId);
1784 cell->cellActvState |= RG_PCCH_CFG_DONE;
1788 /* Add to active cell list if cell is active */
1789 if (cell->cellActvState == RG_CELL_ACTIVE)
1791 rgCb[inst].cell = cell;
1792 rgCb[inst].inactiveCell = NULLP;
1793 DU_LOG("\nDEBUG --> MAC : Cell added to active list after common LC %d\
1794 config\n", lcCfg->lcId);
1798 } /* rgCFGCrgCmnLcCfg */
1800 /***********************************************************
1802 * Func : rgCFGFreeUeUlAlloc
1806 * - Processing Steps:
1807 * - Frees cell control block.
1815 **********************************************************/
1816 static Void rgCFGFreeUeUlAlloc(RgCellCb *cell)
1819 Inst inst = cell->macInst - RG_INST_START;
1821 for(sfIdx = 0; sfIdx < RG_NUM_UL_SUB_FRAMES; sfIdx++)
1823 if(cell->ulSf[sfIdx].ueUlAllocInfo != NULLP)
1825 /*ccpu00117052 - MOD- Passing double pointer for proper
1826 * NULLP assignment */
1827 rgFreeSBuf(inst,(Data **)&(cell->ulSf[sfIdx].ueUlAllocInfo),
1828 (cell->ulSf[sfIdx].numUe * sizeof(RgUeUlAlloc)));
1831 }/* rgCFGFreeUeUlAlloc */
1833 /***********************************************************
1835 * Func : rgCFGFreeCellCb
1839 * - Processing Steps:
1840 * - Frees cell control block.
1848 **********************************************************/
1849 Void rgCFGFreeCellCb(RgCellCb *cell)
1851 Inst inst = cell->macInst - RG_INST_START;
1854 RgLaaCellCbDeInit(cell);
1856 /* Free lists of the cell */
1858 rgCFGFreeSpsUeLst(cell);
1859 #endif /* LTEMAC_SPS */
1860 rgCFGFreeUeLst(cell);
1861 rgRAMFreeCell(cell);
1862 rgCFGFreeCmnLcLst(cell);
1864 rgCFGFreeUeUlAlloc(cell);
1866 /* ccpu00117052 - MOD - Passing double pointer for proper NULLP
1868 /* Update satistics */
1869 rgUpdtCellCnt(inst,RG_CFG_DEL);
1870 rgDHMFreeAllTbBufs(inst);
1872 rgFreeSBuf(inst,(Data **)&cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
1874 /* De-allocate the Cell */
1875 rgFreeSBuf(inst,(Data **)&cell, sizeof(*cell));
1878 DU_LOG("\nINFO --> MAC : Cell freed\n");
1880 /* Stack Crash Problem for TRACE5 Changes. Added return below */
1882 } /* rgCFGFreeCellCb */
1885 /***********************************************************
1887 * Func : rgCFGFreeInactvCellCb
1891 * - Processing Steps:
1892 * - Frees inactive cell control block.
1900 **********************************************************/
1901 Void rgCFGFreeInactvCellCb(RgCellCb *cell)
1903 Inst inst = cell->macInst - RG_INST_START;
1904 /* De-initialize the Ue list */
1905 rgDBMDeInitUeCbLst(cell);
1907 rgDBMDeInitSpsUeCbLst(cell);
1910 rgCFGFreeCmnLcLst(cell);
1912 rgFreeSBuf(inst, (Data **)&cell->flowCntrlInd, sizeof(RguFlowCntrlInd));
1913 /*ccpu00117052 - MOD- Passing double pointer for proper
1915 /* De-allocate the Cell */
1916 rgFreeSBuf(inst,(Data **)&cell, sizeof(*cell));
1918 /* Update satistics */
1919 rgUpdtCellCnt(inst,RG_CFG_DEL);
1922 /* Stack Crash Problem for TRACE5 Changes. Added return below */
1924 } /* rgCFGFreeInactvCellCb */
1927 /***********************************************************
1929 * Func : rgCFGFreeUeCb
1933 * - Processing Steps:
1934 * - Frees UE control block.
1942 **********************************************************/
1943 Void rgCFGFreeUeCb(RgCellCb *cell,RgUeCb *ue)
1945 Inst inst = cell->macInst - RG_INST_START;
1947 rgDHMFreeUe(inst,&ue->dl.hqEnt);
1949 /* ccpu00117052 - MOD - Passing double pointer for proper NULLP
1951 /* De-allocate the Ue */
1952 rgFreeSBuf(inst,(Data **)&ue, sizeof(*ue));
1954 /* Update Statistics */
1955 rgUpdtUeCnt(inst,RG_CFG_DEL);
1958 /* Stack Crash Problem for TRACE5 Changes. Added return below */
1960 } /* rgCFGFreeUeCb */
1962 /***********************************************************
1964 * Func : rgCFGFreeCmnLcLst
1968 * - Processing Steps:
1969 * - Frees common logical channels in cell control block.
1977 **********************************************************/
1978 static Void rgCFGFreeCmnLcLst(RgCellCb *cell)
1980 rgDBMFreeCmnLcLst(cell);
1983 /* Stack Crash Problem for TRACE5 Changes. Added return below */
1985 } /* rgCFGFreeCmnLcLst */
1988 /***********************************************************
1990 * Func : rgCFGFreeUeLst
1994 * - Processing Steps:
1995 * - Frees UE list in cell control block.
2003 **********************************************************/
2004 static Void rgCFGFreeUeLst(RgCellCb *cell)
2008 /* Free Ues in the list */
2009 while ((ue = rgDBMGetNextUeCb(cell, NULLP)) != NULLP)
2012 rgDelUeFrmAllSCell(cell,ue);
2014 rgDBMDelUeCb(cell, ue);
2015 rgCFGFreeUeCb(cell, ue);
2018 /* De-initialize the Ue list */
2019 rgDBMDeInitUeCbLst(cell);
2022 /* Stack Crash Problem for TRACE5 Changes. Added return below */
2024 } /* rgCFGFreeUeLst */
2027 /***********************************************************
2029 * Func : rgCFGFreeSpsUeLst
2033 * - Processing Steps:
2034 * - Frees Sps UE list in cell control block.
2042 **********************************************************/
2043 static Void rgCFGFreeSpsUeLst(RgCellCb *cell)
2047 /* Free Ues in the list */
2048 while ((ue = rgDBMGetNextSpsUeCb(cell, NULLP)))
2050 rgDBMDelSpsUeCb(cell, ue);
2053 /* De-initialize the Ue list */
2054 rgDBMDeInitSpsUeCbLst(cell);
2056 } /* rgCFGFreeSpsUeLst */
2058 #endif /* LTEMAC_SPS */
2061 * @brief Function for registering cell- scheduler instance mapping
2065 * Function : RgSchMacCellRegReq
2067 * This function shall be invoked whenever scheduler is done with the
2068 * cell configuration successfully.
2069 * This shall create a mapping of the cell, scheduler instance that
2070 * is serving the cell and the unique identifier of the cell on the
2071 * scheduler at MAC. This mapping shall be used for further
2072 * communication to the scheduler instance for this cell.
2075 * @param[in] Pst* pst,
2076 * @param[in] CmLteCellId cellId,
2077 * @param[in] RaRespReqInfo raRespReq
2081 S16 RgSchMacCellRegReq(Pst* pst,RgInfCellReg* regReq)
2084 RgCellCb *cell = NULLP;
2086 RG_IS_INST_VALID(pst->dstInst);
2087 inst = pst->dstInst - RG_INST_START;
2088 cell = rgCb[inst].cell;
2095 if((cell == NULLP) || (cell->cellId != regReq->cellId))
2099 if(regReq->maxDlHqProcPerUe > RG_MAX_DL_HARQ_NUM)
2104 cell->schInstMap.cellSapId = regReq->cellSapId;
2105 cell->schInstMap.schInst = pst->srcInst;
2106 cell->maxDlHqProcPerUe = regReq->maxDlHqProcPerUe;
2110 } /* end of RgSchMacCellRegReq */
2112 /*Added Ue for Onging L2 Meas*/
2114 /*LTE_L2_MEAS_PHASE2*/
2115 S16 rgAddToL2MeasPerQci(RgCellCb *cell,uint8_t qci)
2122 lnk = cell->l2mList.first;
2123 while(lnk != NULLP )
2125 measCb = (RgL2MeasCb *)lnk->node;
2126 if(measCb->measReq.measType & LRG_L2MEAS_AVG_PRB_PER_QCI_UL)
2128 for(idx = 0;idx< measCb->measReq.t.prbReq.numQci;idx++)
2130 if(measCb->measReq.t.prbReq.qci[idx] == qci)
2132 break; /*exit from for loop*/
2135 if(idx == measCb->measReq.t.prbReq.numQci)
2137 cell->qciArray[qci].mask = TRUE;
2138 measCb->measReq.t.prbReq.qci[measCb->measReq.t.prbReq.numQci++] = qci;
2152 /**********************************************************************
2155 **********************************************************************/