#ifdef NR_DRX
typedef struct schDrxUeCb
{
- bool drxDlUeActiveStatus; /* variable is used to store the status about downlink active status */
- bool drxUlUeActiveStatus; /* variable is used to store the status about uplink active status */
+ uint32_t drxDlUeActiveStatus; /* variable is used to store the status about downlink active status */
+ uint32_t drxUlUeActiveStatus; /* variable is used to store the status about uplink active status */
uint32_t onDurationLen; /* length of on duration which is received from ue cfg/recfg in form of ms and subms, informs about after how many slots on duration gets expire */
uint32_t inActvTimerLen; /* length of inActvTimer value received from ue cfg/recfg in form of ms, informs about after how many slots in active gets expire */
uint8_t harqRttDlTimerLen; /* length of harqRttDlTimer received from ue cfg/recfg in form of symbols, inform about after how many slots on the harq drx-HARQ-RTT-TimerDL expire */
SchCellCb *cell = schCb[inst].cells[inst];
SchPucchCfgCmn *pucchCfg = NULLP;
SchBwpParams *ulBwp = NULLP;
+ SchUeCb *ueCb = NULLP;
uint16_t startPrb;
GET_UE_ID(schPucchInfo->rnti, ueId);
ueIdx = ueId -1;
+#ifdef NR_DRX
+ ueCb = schGetUeCb(cell, schPucchInfo->rnti);
+ if(ueCb->ueDrxInfoPres)
+ {
+ if(!ueCb->drxUeCb.drxUlUeActiveStatus)
+ return RFAILED;
+ }
+#endif
if(cell->ueCb[ueIdx].ueCfg.spCellCfg.servCellCfg.initUlBwp.pucchCfgPres)
{
/* fill pucch dedicated cfg */
uint8_t schUlResAlloc(SchCellCb *cell, Inst schInst)
{
int ret = ROK;
+ SchUeCb *ueCb;
UlSchedInfo ulSchedInfo;
SchUlSlotInfo *schUlSlotInfo = NULLP;
SlotTimingInfo ulTimingInfo;
if(schUlSlotInfo->schPuschInfo)
{
ulSchedInfo.crnti = schUlSlotInfo->schPuschInfo->crnti;
+ /* Check the ue drx status if the UE is active for uplink scheduling or not */
+#ifdef NR_DRX
+ ueCb = schGetUeCb(cell, ulSchedInfo.crnti);
+ if(ueCb->ueDrxInfoPres)
+ {
+ if(!ueCb->drxUeCb.drxUlUeActiveStatus)
+ return RFAILED;
+ }
+#endif
ulSchedInfo.dataType |= SCH_DATATYPE_PUSCH;
memcpy(&ulSchedInfo.schPuschInfo, schUlSlotInfo->schPuschInfo,
sizeof(SchPuschInfo));
memcpy(&ulSchedInfo.schPucchInfo, &schUlSlotInfo->schPucchInfo,
sizeof(SchPucchInfo));
}
+ else
+ {
+ return RFAILED;
+ }
memset(&schUlSlotInfo->schPucchInfo, 0, sizeof(SchPucchInfo));
}
ueCb->drxUeCb.onDurationStartDistance = SCH_DRX_INVALID_DISTANCE;
ueCb->drxUeCb.onDurationExpiryDistance = SCH_DRX_INVALID_DISTANCE;
ueCb->drxUeCb.inActiveTmrExpiryDistance = SCH_DRX_INVALID_DISTANCE;
- ueCb->drxUeCb.drxDlUeActiveStatus = false;
- ueCb->drxUeCb.drxUlUeActiveStatus = false;
+ ueCb->drxUeCb.drxDlUeActiveStatus = 0;
+ ueCb->drxUeCb.drxUlUeActiveStatus = 0;
}
/* will uncomment this function in next gerrit */
uint32_t onDurTime, onDurExpSlotTime, currentSlotTime;
uint32_t cycleLen;
SlotTimingInfo onDurationOccurance;
-
+
if(ueCb->drxUeCb.shortCyclePresent == false)
{
/* if short cycle configuration are not recived as a part of UE Recfg then if there is any entry present in short cycle timer list
{
cmLListDelFrm(&cell->drxCb[ueCb->drxUeCb.onDurationStartIndex].onDurationStartList, ueCb->drxUeCb.onDurationStartNodeInfo);
SCH_FREE(ueCb->drxUeCb.onDurationStartNodeInfo, sizeof(CmLList));
- ueCb->drxUeCb.onDurationStartIndex = SCH_DRX_INVALID_INDEX;
- ueCb->drxUeCb.onDurationStartDistance = SCH_DRX_INVALID_DISTANCE;
+ ueCb->drxUeCb.onDurationStartIndex= SCH_DRX_INVALID_INDEX;
+ ueCb->drxUeCb.onDurationStartDistance= SCH_DRX_INVALID_DISTANCE;
+
}
findNextOndurationOccurance(cell, &ueCb->drxUeCb, &onDurationOccurance, 0);
}
}
+/**
+ * @brief Handling of On duration drx start timer
+ *
+ * @details
+ *
+ * Function : schHdlDrxOnDurStrtTimerForDlDirection
+ *
+ * Handling of On duration drx start timer
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+void schHdlDrxOnDurStrtTimerForDlDirection(SchCellCb *cell, uint16_t currListIndx)
+{
+ uint16_t onDurationExpiry=0;
+ CmLList *drxCurrNode = NULLP;
+ SchUeCb *ueCb = NULLP;
+
+ drxCurrNode = cell->drxCb[currListIndx].onDurationStartList.first;
+ if(drxCurrNode)
+ {
+ /* Handling of dl On duration drx start list */
+ while(drxCurrNode)
+ {
+ ueCb = (SchUeCb*)drxCurrNode->node;
+ drxCurrNode = drxCurrNode->next;
+
+ ueCb->drxUeCb.onDurationStartDistance--;
+
+ if(ueCb->drxUeCb.onDurationStartDistance != SCH_DRX_INVALID_DISTANCE)
+ {
+ continue;
+ }
+ else
+ {
+ ueCb->drxUeCb.drxDlUeActiveStatus |= UE_ACTIVE_FOR_ONDURATION;
+
+ /* If there is any entery present in onDurationExpiry list remove
+ * the entery from the list and recalculate the
+ * onDurationExpiry time and add it to list */
+ if(ueCb->drxUeCb.onDurationExpiryIndex != SCH_DRX_INVALID_INDEX)
+ {
+ cmLListDelFrm(&cell->drxCb[ueCb->drxUeCb.onDurationExpiryIndex].onDurationExpiryList, ueCb->drxUeCb.onDurationExpiryNodeInfo);
+ SCH_FREE(ueCb->drxUeCb.onDurationExpiryNodeInfo, sizeof(CmLList));
+ ueCb->drxUeCb.onDurationExpiryIndex = SCH_DRX_INVALID_INDEX;
+ ueCb->drxUeCb.onDurationExpiryDistance = SCH_DRX_INVALID_DISTANCE;
+ }
+
+ /* onDurationExpiry = (current slot + onduration length) % MAX_DRX_SIZE*/
+ onDurationExpiry = (currListIndx + ueCb->drxUeCb.onDurationLen)%MAX_DRX_SIZE;
+ ueCb->drxUeCb.onDurationExpiryDistance = (ueCb->drxUeCb.onDurationLen)/MAX_DRX_SIZE;
+ schAddDrxTimerIntoList(&cell->drxCb[onDurationExpiry].onDurationExpiryList, ueCb, ueCb->drxUeCb.onDurationExpiryNodeInfo);
+ ueCb->drxUeCb.onDurationExpiryIndex = onDurationExpiry;
+
+ }
+ }
+ }
+}
+
+/**
+ * @brief Handling of On duration drx start timer
+ *
+ * @details
+ *
+ * Function : schHdlDrxOnDurStrtTimerForUlDirection
+ *
+ * Handling of On duration drx start timer
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+void schHdlDrxOnDurStrtTimerForUlDirection(SchCellCb *cell, uint16_t currListIndx)
+{
+ uint16_t onDurTime=0;
+ CmLList *drxCurrNode = NULLP;
+ SchUeCb *ueCb = NULLP;
+
+ drxCurrNode = cell->drxCb[currListIndx].onDurationStartList.first;
+ if(drxCurrNode)
+ {
+ /* Handling of dl On duration drx start list */
+ while(drxCurrNode)
+ {
+ ueCb = (SchUeCb*)drxCurrNode->node;
+ drxCurrNode = drxCurrNode->next;
+
+ if(ueCb->drxUeCb.onDurationStartDistance != SCH_DRX_INVALID_DISTANCE)
+ {
+ continue;
+ }
+ ueCb->drxUeCb.drxUlUeActiveStatus |= UE_ACTIVE_FOR_ONDURATION;
+
+
+ /* if there short cycle length is used as the cycle length for onduration calculation then based on the short cycle else long cycle is used for calculating next onduration */
+ cmLListDelFrm(&cell->drxCb[currListIndx].onDurationStartList, ueCb->drxUeCb.onDurationStartNodeInfo);
+ SCH_FREE(ueCb->drxUeCb.onDurationStartNodeInfo, sizeof(CmLList));
+ ueCb->drxUeCb.onDurationStartIndex= SCH_DRX_INVALID_INDEX;
+
+ if(ueCb->drxUeCb.longCycleToBeUsed)
+ {
+ onDurTime = currListIndx + ueCb->drxUeCb.longCycleLen;
+ }
+ else
+ {
+ onDurTime = currListIndx + ueCb->drxUeCb.shortCycleLen;
+ }
+ SCH_CALCULATE_TIMER_INDEX(onDurTime, ueCb->drxUeCb.onDurationStartIndex);
+ ueCb->drxUeCb.onDurationStartDistance = ueCb->drxUeCb.longCycleLen/MAX_DRX_SIZE;
+ schAddDrxTimerIntoList(&cell->drxCb[ueCb->drxUeCb.onDurationStartIndex].onDurationStartList, ueCb, ueCb->drxUeCb.onDurationStartNodeInfo);
+ }
+ }
+}
+
+/**
+ * @brief Handling of On duration drx start timer
+ *
+ * @details
+ *
+ * Function : schHdlDrxOnDurStrtTimer
+ *
+ * Handling of On duration drx start timer
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+void schHdlDrxOnDurStrtTimer(SchCellCb *cell)
+{
+ uint16_t dlIndx = 0, ulIndx=0;
+ SlotTimingInfo dlSlotInfo, ulSlotInfo;
+
+ ADD_DELTA_TO_TIME(cell->slotInfo, dlSlotInfo, PHY_DELTA_DL + SCHED_DELTA, cell->numSlots);
+ ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA, cell->numSlots);
+
+ dlIndx = (dlSlotInfo.sfn*MAX_SLOTS+dlSlotInfo.slot)%MAX_DRX_SIZE;
+ ulIndx = (ulSlotInfo.sfn*MAX_SLOTS+ulSlotInfo.slot)%MAX_DRX_SIZE;
+ schHdlDrxOnDurStrtTimerForDlDirection(cell, dlIndx);
+ schHdlDrxOnDurStrtTimerForUlDirection(cell, ulIndx);
+}
+
+/**
+ * @brief Handling of the DRX timers start
+ *
+ * @details
+ *
+ * Function : schHandleStartDrxTimer
+ *
+ * Handling of DRX timers start
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+void schHandleStartDrxTimer(SchCellCb *cell)
+{
+ /* Handling the onduration start timer */
+ schHdlDrxOnDurStrtTimer(cell);
+}
+
+/**
+ * @brief Handling of the expiry onduration timer in dl direction
+ *
+ * @details
+ *
+ * Function : schHdlDrxOnDurExpiryTimerForDlDirection
+ *
+ * Handling of expiry onduration DRX timers in dl direction
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+void schHdlDrxOnDurExpiryTimerForDlDirection(SchCellCb *cell, uint16_t currListIndx)
+{
+ CmLList *drxCurrNode;
+ SchUeCb *ueCb = NULLP;
+
+ drxCurrNode = cell->drxCb[currListIndx].onDurationExpiryList.first;
+ if(drxCurrNode)
+ {
+ /* Handling of dl On duration drx start list */
+ while(drxCurrNode)
+ {
+ ueCb = (SchUeCb*)drxCurrNode->node;
+ drxCurrNode = drxCurrNode->next;
+
+ ueCb->drxUeCb.onDurationExpiryDistance--;
+
+ if(ueCb->drxUeCb.onDurationExpiryDistance != SCH_DRX_INVALID_DISTANCE)
+ {
+ continue;
+ }
+ ueCb->drxUeCb.drxDlUeActiveStatus &= ~UE_ACTIVE_FOR_ONDURATION;
+ }
+ }
+}
+
+/**
+ * @brief Handling of the expiry onduration DRX timers for Ul direction
+ *
+ * @details
+ *
+ * Function schHdlDrxOnDurExpiryTimerForUlDirection:
+ *
+ * Handling of expiry onduration DRX timers in Ul direction
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+void schHdlDrxOnDurExpiryTimerForUlDirection(SchCellCb *cell, uint16_t currListIndx)
+{
+ CmLList *drxCurrNode;
+ SchUeCb *ueCb = NULLP;
+
+ drxCurrNode = cell->drxCb[currListIndx].onDurationExpiryList.first;
+ if(drxCurrNode)
+ {
+ /* Handling of dl On duration drx start list */
+ while(drxCurrNode)
+ {
+ ueCb = (SchUeCb*)drxCurrNode->node;
+ drxCurrNode = drxCurrNode->next;
+
+ if(ueCb->drxUeCb.onDurationExpiryDistance != SCH_DRX_INVALID_DISTANCE)
+ {
+ continue;
+ }
+
+ ueCb->drxUeCb.drxUlUeActiveStatus &= ~UE_ACTIVE_FOR_ONDURATION;
+ cmLListDelFrm(&cell->drxCb[ueCb->drxUeCb.onDurationExpiryIndex].onDurationExpiryList, ueCb->drxUeCb.onDurationExpiryNodeInfo);
+ SCH_FREE(ueCb->drxUeCb.onDurationExpiryNodeInfo, sizeof(CmLList));
+ ueCb->drxUeCb.onDurationExpiryIndex = SCH_DRX_INVALID_INDEX;
+ }
+ }
+}
+/**
+ * @brief Handling of the expiry onduration DRX timers
+ *
+ * @details
+ *
+ * Function : schHdlDrxOnDurExpiryTimer
+ *
+ * Handling of expiry onduration DRX timers
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+void schHdlDrxOnDurExpiryTimer(SchCellCb *cell)
+{
+ uint16_t dlIndx = 0, ulIndx = 0;
+ SlotTimingInfo dlSlotInfo, ulSlotInfo;
+
+ ADD_DELTA_TO_TIME(cell->slotInfo, dlSlotInfo, PHY_DELTA_DL + SCHED_DELTA, cell->numSlots);
+ ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA, cell->numSlots);
+ dlIndx = (dlSlotInfo.sfn*MAX_SLOTS+dlSlotInfo.slot)%MAX_DRX_SIZE;
+ ulIndx = (ulSlotInfo.sfn*MAX_SLOTS+ulSlotInfo.slot)%MAX_DRX_SIZE;
+
+ schHdlDrxOnDurExpiryTimerForDlDirection(cell, dlIndx);
+ schHdlDrxOnDurExpiryTimerForUlDirection(cell, ulIndx);
+}
+
+/**
+ * @brief Handling of the expiry DRX timers
+ *
+ * @details
+ *
+ * Function : schHandleExpiryDrxTimer
+ *
+ * Handling of expiry DRX timers
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+void schHandleExpiryDrxTimer(SchCellCb *cell)
+{
+ /* Handling the onduration start timer */
+ schHdlDrxOnDurExpiryTimer(cell);
+}
+
#endif
/**********************************************************************
End of file
#define SCH_DRX_INVALID_DISTANCE -1
#define SCH_DRX_INVALID_INDEX 0xFFFFFF
-#define SCH_DRX_MAX_DELTA 1
+#define SCH_DRX_MAX_DELTA 3
#define SCH_DRX_TMRS_EXP_DELTA 1
+#define UE_ACTIVE_FOR_ONDURATION 1
+#define UE_ACTIVE_FOR_INACTIVE_TIMER 2
+#define UE_ACTIVE_FOR_SR 4
/** @brief Macro to convert milli second to slots */
#define SCH_CNVRT_MS_TO_SLOT(_numSlot, _timeInMs, _mu)\
#include "mac_sch_interface.h"
#include "sch.h"
#include "sch_utils.h"
+#ifdef NR_DRX
+#include "sch_drx.h"
+#endif
SchMacDlAllocFunc schMacDlAllocOpts[] =
{
dlSchedInfo.cellId = cell->cellId;
slot = dlSchedInfo.schSlotValue.broadcastTime.slot;
+#ifdef NR_DRX
+ schHandleStartDrxTimer(cell);
+#endif
+
/* Check for SSB occassion */
dlBrdcstAlloc->ssbTrans = schCheckSsbOcc(cell, dlSchedInfo.schSlotValue.broadcastTime);
if(dlBrdcstAlloc->ssbTrans)
}
}
- /* DL Data */
- node = cell->ueCb[ueId-1].dlRetxHqList.first;
- if(node != NULLP)
+#ifdef NR_DRX
+ if((cell->ueCb[ueId-1].ueDrxInfoPres == true) && (cell->ueCb[ueId-1].drxUeCb.drxDlUeActiveStatus != true))
{
- /* DL Data ReTransmisson */
- isDlMsgPending = true;
- isDlMsgScheduled = schFillBoGrantDlSchedInfo(cell, *slotInd, ueId, TRUE, ((SchDlHqProcCb**) &(node->node)));
- cmLListDelFrm(&cell->ueCb[ueId-1].dlRetxHqList, node);
+ if(pendingUeNode->node)
+ {
+ cmLListAdd2Tail(&cell->ueToBeScheduled, cmLListDelFrm(&cell->ueToBeScheduled, pendingUeNode));
+ }
}
- else
+ else
+#endif
{
- /* DL Data new transmission */
- if((cell->boIndBitMap) & (1<<ueId))
+
+ /* DL Data */
+ node = cell->ueCb[ueId-1].dlRetxHqList.first;
+ if(node != NULLP)
+ {
+ /* DL Data ReTransmisson */
+ isDlMsgPending = true;
+ isDlMsgScheduled = schFillBoGrantDlSchedInfo(cell, *slotInd, ueId, TRUE, ((SchDlHqProcCb**) &(node->node)));
+ cmLListDelFrm(&cell->ueCb[ueId-1].dlRetxHqList, node);
+ }
+ else
{
- isDlMsgPending = true;
- isDlMsgScheduled = schFillBoGrantDlSchedInfo(cell, *slotInd, ueId, FALSE, &hqP);
+ /* DL Data new transmission */
+ if((cell->boIndBitMap) & (1<<ueId))
+ {
+ isDlMsgPending = true;
+ isDlMsgScheduled = schFillBoGrantDlSchedInfo(cell, *slotInd, ueId, FALSE, &hqP);
- /* If DL scheduling failed, free the newly assigned HARQ process */
- if(!isDlMsgScheduled)
- schDlReleaseHqProcess(hqP);
+ /* If DL scheduling failed, free the newly assigned HARQ process */
+ if(!isDlMsgScheduled)
+ schDlReleaseHqProcess(hqP);
+ }
}
- }
- /* Scheduling of UL grant */
- node = cell->ueCb[ueId-1].ulRetxHqList.first;
- if(node != NULLP)
- {
- /* UL Data ReTransmisson */
- isUlGrantPending = true;
- isUlGrantScheduled = schProcessSrOrBsrReq(cell, *slotInd, ueId, TRUE, (SchUlHqProcCb**) &(node->node));
- cmLListDelFrm(&cell->ueCb[ueId-1].ulRetxHqList, node);
- }
- else
- {
- /* UL Data new transmission */
- if(cell->ueCb[ueId-1].srRcvd || cell->ueCb[ueId-1].bsrRcvd)
+ /* Scheduling of UL grant */
+ node = cell->ueCb[ueId-1].ulRetxHqList.first;
+ if(node != NULLP)
{
+ /* UL Data ReTransmisson */
isUlGrantPending = true;
- isUlGrantScheduled = schProcessSrOrBsrReq(cell, *slotInd, ueId, FALSE, &ulHqP);
- if(!isUlGrantScheduled)
- schUlReleaseHqProcess(ulHqP, FALSE);
+ isUlGrantScheduled = schProcessSrOrBsrReq(cell, *slotInd, ueId, TRUE, (SchUlHqProcCb**) &(node->node));
+ cmLListDelFrm(&cell->ueCb[ueId-1].ulRetxHqList, node);
+ }
+ else
+ {
+ /* UL Data new transmission */
+ if(cell->ueCb[ueId-1].srRcvd || cell->ueCb[ueId-1].bsrRcvd)
+ {
+ isUlGrantPending = true;
+ isUlGrantScheduled = schProcessSrOrBsrReq(cell, *slotInd, ueId, FALSE, &ulHqP);
+ if(!isUlGrantScheduled)
+ schUlReleaseHqProcess(ulHqP, FALSE);
+ }
}
- }
- if(!isUlGrantPending && !isDlMsgPending)
- {
- /* No action required */
- }
- else if((isUlGrantPending && !isUlGrantScheduled) || (isDlMsgPending && !isDlMsgScheduled))
- {
- cmLListAdd2Tail(&cell->ueToBeScheduled, cmLListDelFrm(&cell->ueToBeScheduled, pendingUeNode));
- }
- else
- {
- SCH_FREE(ueNode, sizeof(uint8_t));
- deleteNodeFromLList(&cell->ueToBeScheduled, pendingUeNode);
+ if(!isUlGrantPending && !isDlMsgPending)
+ {
+ /* No action required */
+ }
+ else if((isUlGrantPending && !isUlGrantScheduled) || (isDlMsgPending && !isDlMsgScheduled))
+ {
+ cmLListAdd2Tail(&cell->ueToBeScheduled, cmLListDelFrm(&cell->ueToBeScheduled, pendingUeNode));
+ }
+ else
+ {
+ SCH_FREE(ueNode, sizeof(uint8_t));
+ deleteNodeFromLList(&cell->ueToBeScheduled, pendingUeNode);
+ }
}
}
}
schInitDlSlot(cell->schDlSlotInfo[slot]);
schUlResAlloc(cell, schInst);
-
+#ifdef NR_DRX
+ schHandleExpiryDrxTimer(cell);
+#endif
return ret;
}
******************************************************************/
uint8_t BuildDrxCycle(DRXCycle_t *drxCycle)
{
- drxCycle->longDRXCycleLength = LongDRXCycleLength_ms40;
+ drxCycle->longDRXCycleLength = LongDRXCycleLength_ms80;
CU_ALLOC(drxCycle->shortDRXCycleLength, sizeof(ShortDRXCycleLength_t));
if(!drxCycle->shortDRXCycleLength)
{
/* Macros for Drx configuration */
#define DRX_ONDURATION_TIMER_VALUE_PRESENT_IN_MS true
#define DRX_ONDURATION_TIMER_VALUE_IN_SUBMS 32
-#define DRX_ONDURATION_TIMER_VALUE_IN_MS 1
+#define DRX_ONDURATION_TIMER_VALUE_IN_MS 10
#define DRX_INACTIVITY_TIMER 2
#define DRX_HARQ_RTT_TIMER_DL 56
#define DRX_HARQ_RTT_TIMER_UL 56
#define DRX_RETRANSMISSION_TIMER_DL 4
#define DRX_RETRANSMISSION_TIMER_UL 4
-#define DRX_LONG_CYCLE_START_OFFSET_CHOICE 20
+#define DRX_LONG_CYCLE_START_OFFSET_CHOICE 40
#define DRX_LONG_CYCLE_START_OFFSET_VAL 8
#define DRX_SHORT_CYCLE_PRESENT true
#define DRX_SHORT_CYCLE 2
DU_LOG("\nERROR --> DU_APP : System Task creation for DU APP failed");
return RFAILED;
}
- //ODU_SET_THREAD_AFFINITY(&du_app_stsk, SS_AFFINITY_MODE_EXCL, 16, 0);
+ ODU_SET_THREAD_AFFINITY(&du_app_stsk, SS_AFFINITY_MODE_EXCL, 16, 0);
/* system task for EGTP */
if(ODU_CREATE_TASK(PRIOR0, &egtp_stsk) != ROK)
DU_LOG("\nERROR --> DU_APP : System Task creation for EGTP failed");
return RFAILED;
}
- //ODU_SET_THREAD_AFFINITY(&egtp_stsk, SS_AFFINITY_MODE_EXCL, 27, 0);
+ ODU_SET_THREAD_AFFINITY(&egtp_stsk, SS_AFFINITY_MODE_EXCL, 27, 0);
/* system task for RLC_DL and MAC */
if(ODU_CREATE_TASK(PRIOR0, &rlc_mac_cl_stsk) != ROK)
}
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
- //ODU_SET_THREAD_AFFINITY(&rlc_mac_cl_stsk, SS_AFFINITY_MODE_EXCL, 18, 0);
+ ODU_SET_THREAD_AFFINITY(&rlc_mac_cl_stsk, SS_AFFINITY_MODE_EXCL, 18, 0);
/* system task for RLC UL */
if(ODU_CREATE_TASK(PRIOR1, &rlc_ul_stsk) != ROK)
DU_LOG("\nERROR --> DU_APP : System Task creation for RLC UL failed");
return RFAILED;
}
- //ODU_SET_THREAD_AFFINITY(&rlc_ul_stsk, SS_AFFINITY_MODE_EXCL, 22, 0);
+ ODU_SET_THREAD_AFFINITY(&rlc_ul_stsk, SS_AFFINITY_MODE_EXCL, 22, 0);
/* system task for SCTP receiver thread */
if(ODU_CREATE_TASK(PRIOR0, &sctp_stsk) != ROK)
DU_LOG("\nERROR --> DU_APP : System Task creation for SCTP failed");
return RFAILED;
}
- //ODU_SET_THREAD_AFFINITY(&sctp_stsk, SS_AFFINITY_MODE_EXCL, 25, 0);
+ ODU_SET_THREAD_AFFINITY(&sctp_stsk, SS_AFFINITY_MODE_EXCL, 25, 0);
/* system task for lower-mac receiver thread */
if(ODU_CREATE_TASK(PRIOR0, &lwr_mac_stsk) != ROK)
DU_LOG("\nERROR --> DU_APP : System Task creation for Lower MAC failed");
return RFAILED;
}
- //ODU_SET_THREAD_AFFINITY(&lwr_mac_stsk, SS_AFFINITY_MODE_EXCL, 21, 0);
+ ODU_SET_THREAD_AFFINITY(&lwr_mac_stsk, SS_AFFINITY_MODE_EXCL, 21, 0);
#ifndef INTEL_WLS_MEM
/* system task for phy stub's slot indication generator thread */
{
if(ulDciReq->pdus[numPdus-1].pduType == 0)
{
- DU_LOG("\nINFO --> PHY STUB: Received UL DCI Request for PDCCH PDU");
+ DU_LOG("\nINFO --> PHY STUB: Received UL DCI Request for PDCCH PDU");
//l1BuildAndSendMsg5(ulDciReq->sfn, ulDciReq->slot);
//msg5Sent = true;
}
Code Review / o-du / l2.git / commitdiff