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 in-active start timer
+ *
+ * @details
+ *
+ * Function :
+ *
+ * Handling of DRX in-active start timer
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+void schHdlDrxInActvStrtTmr(SchCellCb *cell, SchUeCb *ueCb, uint8_t delta)
+{
+ uint16_t slotIndx = 0;
+ SlotTimingInfo tmpSlotInfo;
+
+ if(ueCb->drxUeCb.inActvTimerLen == 0)
+ {
+ return;
+ }
+
+ ADD_DELTA_TO_TIME(cell->slotInfo, tmpSlotInfo, delta, cell->numSlots);
+ slotIndx = (tmpSlotInfo.sfn*MAX_SLOTS+tmpSlotInfo.slot)%MAX_DRX_SIZE;
+
+ /* if there is any entry present in the in-active exp list then remove the entry */
+ if(ueCb->drxUeCb.inActvExpiryIndex != SCH_DRX_INVALID_INDEX)
+ {
+ cmLListDelFrm(&cell->drxCb[ueCb->drxUeCb.inActvExpiryIndex].inActvTmrExpiryList, ueCb->drxUeCb.inActvTimerExpiryNodeInfo);
+ SCH_FREE(ueCb->drxUeCb.inActvTimerExpiryNodeInfo, sizeof(CmLList));
+ ueCb->drxUeCb.inActvExpiryIndex= SCH_DRX_INVALID_INDEX;
+ ueCb->drxUeCb.inActiveTmrExpiryDistance= SCH_DRX_INVALID_DISTANCE;
+ }
+
+ /* Adding the new entry in in-activity timer list */
+ ueCb->drxUeCb.inActvExpiryIndex = (slotIndx + ueCb->drxUeCb.inActvTimerLen) % MAX_DRX_SIZE;
+ ueCb->drxUeCb.inActiveTmrExpiryDistance = (ueCb->drxUeCb.inActvTimerLen) / MAX_DRX_SIZE;
+ schAddDrxTimerIntoList(&cell->drxCb[ueCb->drxUeCb.inActvExpiryIndex].inActvTmrExpiryList, ueCb, ueCb->drxUeCb.inActvTimerExpiryNodeInfo);
+
+ /* Set the UE active for UL And Dl transfer */
+ ueCb->drxUeCb.drxDlUeActiveStatus |= UE_ACTIVE_FOR_INACTIVE_TIMER;
+ ueCb->drxUeCb.drxUlUeActiveStatus |= UE_ACTIVE_FOR_INACTIVE_TIMER;
+}
+
+/**
+ * @brief Handling of short cycle drx start timer
+ *
+ * @details
+ *
+ * Function : schHdlDrxStartShortCycleTimer
+ *
+ * Handling of short cycle drx start timer
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+ void schHdlDrxStartShortCycleTimer(SchCellCb *cell, SchUeCb *ueCb)
+ {
+ ueCb->drxUeCb.longCycleToBeUsed = false;
+
+ /* if there is any present in on-duration start list, remove the entry from on duration start list */
+ if(ueCb->drxUeCb.onDurationStartIndex != SCH_DRX_INVALID_INDEX)
+ {
+ 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;
+ }
+
+ /* recalculate the new index of on duration start based on short cycle */
+ schAddUeInOndurationList(cell, ueCb, PHY_DELTA_DL + SCHED_DELTA);
+
+ /* if any node is present in short cycle exp list then remove the node from list */
+ if(ueCb->drxUeCb.shortCycleExpiryIndex != SCH_DRX_INVALID_INDEX && ueCb->drxUeCb.shortCycleDistance != SCH_DRX_INVALID_DISTANCE)
+ {
+ cmLListDelFrm(&cell->drxCb[ueCb->drxUeCb.shortCycleExpiryIndex].shortCycleExpiryList, ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo);
+ SCH_FREE(ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo, sizeof(CmLList));
+ ueCb->drxUeCb.shortCycleExpiryIndex = SCH_DRX_INVALID_INDEX;
+ ueCb->drxUeCb.shortCycleDistance = SCH_DRX_INVALID_DISTANCE;
+ }
+
+ /* recalculate the new index for shortCycleExpiryList */
+ ueCb->drxUeCb.shortCycleExpiryIndex = (ueCb->drxUeCb.onDurationStartIndex + ueCb->drxUeCb.shortCycleTmrLen) % MAX_DRX_SIZE;
+ ueCb->drxUeCb.shortCycleDistance = ueCb->drxUeCb.shortCycleTmrLen / MAX_DRX_SIZE;
+ schAddDrxTimerIntoList(&cell->drxCb[ueCb->drxUeCb.shortCycleExpiryIndex].shortCycleExpiryList, ueCb, ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo);
+ }
+
+/**
+ * @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 of in-active DRX timers in Dl
+ *
+ * @details
+ *
+ * Function : schHdlDrxInActvExpiryTimerForDlDirection
+ *
+ * Handling of expiry of in-active DRX timers at Dl index
+ *
+ * @param[in] SchCellCb *cell, uint16_t dlIndx
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+void schHdlDrxInActvExpiryTimerForDlDirection(SchCellCb *cell, uint16_t dlIndx)
+{
+ CmLList *drxNode;
+ SchUeCb *ueCb = NULLP;
+
+ drxNode = cell->drxCb[dlIndx].inActvTmrExpiryList.first;
+ if(drxNode)
+ {
+ /* Handling of dl On duration drx start list */
+ while(drxNode)
+ {
+ ueCb = (SchUeCb*)drxNode->node;
+ drxNode = drxNode->next;
+ ueCb->drxUeCb.inActiveTmrExpiryDistance--;
+
+ if(ueCb->drxUeCb.onDurationExpiryDistance != SCH_DRX_INVALID_DISTANCE)
+ {
+ continue;
+ }
+
+ ueCb->drxUeCb.drxDlUeActiveStatus &= ~UE_ACTIVE_FOR_INACTIVE_TIMER;
+ }
+ }
+}
+
+/**
+ * @brief Handling of the expiry of in-active DRX timers in Ul
+ *
+ * @details
+ *
+ * Function : schHdlDrxInActvExpiryTimerForUlDirection
+ *
+ * Handling of expiry of in-active DRX timers at Ul index
+ *
+ * @param[in] SchCellCb *cell, uint16_t ulIndx
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+void schHdlDrxInActvExpiryTimerForUlDirection(SchCellCb *cell, uint16_t ulIndx)
+{
+ CmLList *drxNode;
+ SchUeCb *ueCb = NULLP;
+
+ drxNode = cell->drxCb[ulIndx].inActvTmrExpiryList.first;
+ if(drxNode)
+ {
+ /* Handling of dl On duration drx start list */
+ while(drxNode)
+ {
+ ueCb = (SchUeCb*)drxNode->node;
+ drxNode = drxNode->next;
+
+ if(ueCb->drxUeCb.onDurationExpiryDistance != SCH_DRX_INVALID_DISTANCE)
+ {
+ continue;
+ }
+
+ ueCb->drxUeCb.drxUlUeActiveStatus &= ~UE_ACTIVE_FOR_INACTIVE_TIMER;
+
+ /* Remove the entry from the in-active exp timer list */
+ cmLListDelFrm(&cell->drxCb[ulIndx].inActvTmrExpiryList, ueCb->drxUeCb.inActvTimerExpiryNodeInfo);
+ SCH_FREE(ueCb->drxUeCb.inActvTimerExpiryNodeInfo, sizeof(CmLList));
+ ueCb->drxUeCb.inActvExpiryIndex = SCH_DRX_INVALID_INDEX;
+
+ if(ueCb->drxUeCb.shortCyclePresent)
+ {
+ /* Start short cycle timer */
+ schHdlDrxStartShortCycleTimer(cell, ueCb);
+ }
+ }
+ }
+}
+
+/**
+ * @brief Handling of the expiry of in-active DRX timers
+ *
+ * @details
+ *
+ * Function :schHdlDrxInActvExpiryTimer
+ *
+ * Handling of expiry of in-active DRX timers
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+void schHdlDrxInActvExpiryTimer(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;
+
+ schHdlDrxInActvExpiryTimerForDlDirection(cell, dlIndx);
+ schHdlDrxInActvExpiryTimerForUlDirection(cell, ulIndx);
+}
+
+/**
+ * @brief Handling of the expiry ShortCycle DRX timers in DL
+ *
+ * @details
+ *
+ * Function : schHdlDrxShortCycleExpiryTimerForDlDirection
+ *
+ * Handling of expiry ShortCycle
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+void schHdlDrxShortCycleExpiryTimerForDlDirection(SchCellCb *cell, uint16_t dlIndx)
+{
+ CmLList *drxCurrNode = NULLP;
+ SchUeCb *ueCb = NULLP;
+
+ drxCurrNode = cell->drxCb[dlIndx].shortCycleExpiryList.first;
+ if(drxCurrNode)
+ {
+ /* Handling of short cycle expiry in Dl */
+ while(drxCurrNode)
+ {
+ ueCb = (SchUeCb*)drxCurrNode->node;
+ drxCurrNode = drxCurrNode->next;
+
+ ueCb->drxUeCb.shortCycleDistance--;
+
+ if(ueCb->drxUeCb.shortCycleDistance != SCH_DRX_INVALID_DISTANCE)
+ {
+ continue;
+ }
+
+ /* once short cycle timer gets expire we will recalculate on-duration start with long cycle */
+ ueCb->drxUeCb.longCycleToBeUsed = true;
+
+ /* delete the entry from on-duration start */
+ 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;
+
+ /* Recalculate on-duration with long cycle */
+ schAddUeInOndurationList(cell, ueCb, PHY_DELTA_DL + SCHED_DELTA);
+ }
+ }
+}
+
+/**
+ * @brief Handling of the expiry ShortCycle DRX timers in UL
+ *
+ * @details
+ *
+ * Function : schHdlDrxShortCycleExpiryTimerForUlDirection
+ *
+ * Handling of expiry ShortCycle
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+void schHdlDrxShortCycleExpiryTimerForUlDirection(SchCellCb *cell, uint16_t ulIndx)
+{
+ CmLList *drxCurrNode = NULLP;
+ SchUeCb *ueCb = NULLP;
+
+ drxCurrNode = cell->drxCb[ulIndx].shortCycleExpiryList.first;
+ if(drxCurrNode)
+ {
+ /* Handling of short cycle expiry in Ul */
+ while(drxCurrNode)
+ {
+ ueCb = (SchUeCb*)drxCurrNode->node;
+ drxCurrNode = drxCurrNode->next;
+
+ if(ueCb->drxUeCb.shortCycleDistance != SCH_DRX_INVALID_DISTANCE)
+ {
+ continue;
+ }
+
+ cmLListDelFrm(&cell->drxCb[ulIndx].shortCycleExpiryList, ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo);
+ SCH_FREE(ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo, sizeof(CmLList));
+ ueCb->drxUeCb.shortCycleExpiryIndex = SCH_DRX_INVALID_INDEX;
+
+ }
+ }
+}
+
+/**
+ * @brief Handling of the expiry ShortCycle DRX timers
+ *
+ * @details
+ *
+ * Function :schHdlDrxShortCycleExpiryTimer
+ *
+ * Handling of expiry ShortCycle
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+void schHdlDrxShortCycleExpiryTimer(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;
+
+ schHdlDrxShortCycleExpiryTimerForDlDirection(cell, dlIndx);
+ schHdlDrxShortCycleExpiryTimerForUlDirection(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)
+{
+ schHdlDrxShortCycleExpiryTimer(cell);
+ schHdlDrxOnDurExpiryTimer(cell);
+ schHdlDrxInActvExpiryTimer(cell);
+}
+
#endif
/**********************************************************************
End of file
Code Review / o-du / l2.git / blobdiff