#include "sch_utils.h"
#include "sch_drx.h"
+/**
+ * @brief set the final Ue drx status
+ *
+ * @details
+ *
+ * Function : setDrxUeStatusForDlandUl
+ *
+ * set the final Ue drx status to active or inactive
+ *
+ * @param[in] SchDrxUeCb *drxUeCb
+ * @return
+ * -#void
+ **/
+
+void setDrxUeStatusForDlandUl(SchDrxUeCb *drxUeCb)
+{
+ /* Setting the Dl Ue status */
+ if(drxUeCb->drxDlUeActiveMask || drxUeCb->drxDlUeActiveMaskForHarq)
+ {
+ drxUeCb->drxDlUeActiveStatus = true;
+ }
+ else
+ {
+ drxUeCb->drxDlUeActiveStatus = false;
+ }
+ /* Setting the Ul Ue status */
+ if(drxUeCb->drxUlUeActiveMask || drxUeCb->drxUlUeActiveMaskForHarq)
+ {
+ drxUeCb->drxUlUeActiveStatus = true;
+ }
+ else
+ {
+ drxUeCb->drxUlUeActiveStatus = false;
+ }
+}
+
/**
* @brief intialize the SchDrxHarqCb structre
*
void schInitDrxHarqCb(SchDrxHarqCb *hqDrxCb)
{
memset(hqDrxCb, 0, sizeof(SchDrxHarqCb));
- hqDrxCb->retxExpDistance = SCH_DRX_INVALID_DISTANCE;
hqDrxCb->retxStrtIndex = SCH_DRX_INVALID_INDEX;
- hqDrxCb->rttIndex = SCH_DRX_INVALID_INDEX;
- hqDrxCb->retxIndex = SCH_DRX_INVALID_INDEX;
+ hqDrxCb->rttExpIndex = SCH_DRX_INVALID_INDEX;
+ hqDrxCb->retxExpIndex = SCH_DRX_INVALID_INDEX;
}
/**
ueCb->drxUeCb.onDurationStartDistance = SCH_DRX_INVALID_DISTANCE;
ueCb->drxUeCb.onDurationExpiryDistance = SCH_DRX_INVALID_DISTANCE;
ueCb->drxUeCb.inActiveTmrExpiryDistance = SCH_DRX_INVALID_DISTANCE;
- ueCb->drxUeCb.drxDlUeActiveStatus = 0;
- ueCb->drxUeCb.drxUlUeActiveStatus = 0;
}
-/* will uncomment this function in next gerrit */
-#if 0
/**
* @brief delete Dl harq drx timers and information
*
* -# ROK
* -# RFAILED
**/
- void schDeleteDlHarqDrxTimer(SchCellCb *cell, SchDlHqEnt *dlHqEnt)
- {
- uint8_t idx, numHqPrcs;
- uint16_t tmrIdx = 0;
- SchDlHqProcCb *procs;
- CmLList *node = NULLP;
-
- numHqPrcs = dlHqEnt->numHqPrcs;
- for(idx =0; idx<numHqPrcs; idx++)
- {
- procs = &dlHqEnt->procs[idx];
- tmrIdx = procs->dlDrxHarqCb.retxStrtIndex;
- CM_LLIST_FIRST_NODE(&cell->drxCb[tmrIdx].dlRetransTmrStartList, node);
- if(node)
- {
- cmLListDelFrm(&cell->drxCb[tmrIdx].dlRetransTmrStartList, node);
- SCH_FREE(node, sizeof(CmLList));
- }
- tmrIdx = procs->dlDrxHarqCb.rttIndex;
- CM_LLIST_FIRST_NODE(&cell->drxCb[tmrIdx].dlHarqRttExpiryList, node);
- if(node)
- {
- cmLListDelFrm(&cell->drxCb[tmrIdx].dlHarqRttExpiryList, node);
- SCH_FREE(node, sizeof(CmLList));
- }
+void schDeleteDlHarqDrxTimer(SchCellCb *cell, SchDlHqEnt *dlHqEnt)
+{
+ uint8_t idx, numHqPrcs;
+ SchDlHqProcCb *dlProc;
- tmrIdx = procs->dlDrxHarqCb.retxIndex;
- CM_LLIST_FIRST_NODE(&cell->drxCb[tmrIdx].dlRetransExpiryList, node);
- if(node)
- {
- cmLListDelFrm(&cell->drxCb[tmrIdx].dlRetransExpiryList, node);
- SCH_FREE(node, sizeof(CmLList));
- }
- schInitDrxHarqCb(&procs->dlDrxHarqCb);
- }
- }
+ numHqPrcs = dlHqEnt->numHqPrcs;
+ for(idx =0; idx<numHqPrcs; idx++)
+ {
+ dlProc = &dlHqEnt->procs[idx];
+
+ if(dlProc->dlDrxHarqCb.retxStrtIndex != SCH_DRX_INVALID_INDEX)
+ {
+ cmLListDelFrm(&cell->drxCb[dlProc->dlDrxHarqCb.retxStrtIndex].dlRetransTmrStartList, dlProc->dlDrxHarqCb.retxStrtNode);
+ SCH_FREE(dlProc->dlDrxHarqCb.retxStrtNode, sizeof(CmLList));
+ }
+
+ if(dlProc->dlDrxHarqCb.rttExpIndex != SCH_DRX_INVALID_INDEX)
+ {
+ cmLListDelFrm(&cell->drxCb[dlProc->dlDrxHarqCb.rttExpIndex ].dlHarqRttExpiryList, dlProc->dlDrxHarqCb.rttExpNode);
+ SCH_FREE(dlProc->dlDrxHarqCb.rttExpNode, sizeof(CmLList));
+ }
+
+ if(dlProc->dlDrxHarqCb.retxExpIndex != SCH_DRX_INVALID_INDEX)
+ {
+ cmLListDelFrm(&cell->drxCb[dlProc->dlDrxHarqCb.retxExpIndex].dlRetransExpiryList, dlProc->dlDrxHarqCb.retxExpNode);
+ SCH_FREE(dlProc->dlDrxHarqCb.retxExpNode, sizeof(CmLList));
+ }
+ schInitDrxHarqCb(&dlProc->dlDrxHarqCb);
+ }
+}
/**
* @brief delete UL harq drx timers and information
* @return
* -# ROK
* -# RFAILED
- **/
- void schDeleteUlHarqDrxTimer(SchCellCb *cell, SchUlHqEnt *ulHqEnt)
- {
- uint8_t idx, numHqPrcs;
- uint16_t tmrIdx = 0;
- CmLList *node = NULLP;
- SchUlHqProcCb *procs;
+**/
- numHqPrcs = ulHqEnt->numHqPrcs;
- for(idx =0; idx<numHqPrcs; idx++)
- {
- procs = &ulHqEnt->procs[idx];
- tmrIdx = procs->ulDrxHarqCb.retxStrtIndex;
- CM_LLIST_FIRST_NODE(&cell->drxCb[tmrIdx].ulRetransTmrStartList, node);
- if(node)
- {
- cmLListDelFrm(&cell->drxCb[tmrIdx].ulRetransTmrStartList, node);
- SCH_FREE(node, sizeof(CmLList));
- }
+void schDeleteUlHarqDrxTimer(SchCellCb *cell, SchUlHqEnt *ulHqEnt)
+{
+ uint8_t idx, numHqPrcs;
+ SchUlHqProcCb *ulProc;
- tmrIdx = procs->ulDrxHarqCb.rttIndex;
- CM_LLIST_FIRST_NODE(&cell->drxCb[tmrIdx].ulHarqRttExpiryList, node);
- if(node)
- {
- cmLListDelFrm(&cell->drxCb[tmrIdx].ulHarqRttExpiryList, node);
- SCH_FREE(node, sizeof(CmLList));
- }
+ numHqPrcs = ulHqEnt->numHqPrcs;
+ for(idx =0; idx<numHqPrcs; idx++)
+ {
+ ulProc = &ulHqEnt->procs[idx];
- tmrIdx = procs->ulDrxHarqCb.retxIndex;
- CM_LLIST_FIRST_NODE(&cell->drxCb[tmrIdx].ulRetransExpiryList, node);
- if(node)
- {
- cmLListDelFrm(&cell->drxCb[tmrIdx].ulRetransExpiryList, node);
- SCH_FREE(node, sizeof(CmLList));
- }
- schInitDrxHarqCb(&procs->ulDrxHarqCb);
- }
- }
-#endif
+ if(ulProc->ulDrxHarqCb.retxStrtIndex != SCH_DRX_INVALID_INDEX)
+ {
+ cmLListDelFrm(&cell->drxCb[ulProc->ulDrxHarqCb.retxStrtIndex].ulRetransTmrStartList, ulProc->ulDrxHarqCb.retxStrtNode);
+ SCH_FREE(ulProc->ulDrxHarqCb.retxStrtNode, sizeof(CmLList));
+ }
+
+ if(ulProc->ulDrxHarqCb.rttExpIndex != SCH_DRX_INVALID_INDEX)
+ {
+ cmLListDelFrm(&cell->drxCb[ulProc->ulDrxHarqCb.rttExpIndex ].ulHarqRttExpiryList, ulProc->ulDrxHarqCb.rttExpNode);
+ SCH_FREE(ulProc->ulDrxHarqCb.rttExpNode, sizeof(CmLList));
+ }
+
+ if(ulProc->ulDrxHarqCb.retxExpIndex != SCH_DRX_INVALID_INDEX)
+ {
+ cmLListDelFrm(&cell->drxCb[ulProc->ulDrxHarqCb.retxExpIndex].ulRetransExpiryList, ulProc->ulDrxHarqCb.retxExpNode);
+ SCH_FREE(ulProc->ulDrxHarqCb.retxExpNode, sizeof(CmLList));
+ }
+ schInitDrxHarqCb(&ulProc->ulDrxHarqCb);
+ }
+}
/**
* @brief delete UE drx timers and information
cmLListDelFrm(&cell->drxCb[drxUeCb->shortCycleExpiryIndex].shortCycleExpiryList, drxUeCb->shortCycleTmrExpiryNodeInfo);
SCH_FREE(drxUeCb->shortCycleTmrExpiryNodeInfo, sizeof(CmLList));
}
- /* TODO - will uncomment this function in next gerrit */
- //schDeleteDlHarqDrxTimer(cell, &ueCb->dlHqEnt);
- //schDeleteUlHarqDrxTimer(cell, &ueCb->ulHqEnt);
+
+ schDeleteDlHarqDrxTimer(cell, &ueCb->dlHqEnt);
+ schDeleteUlHarqDrxTimer(cell, &ueCb->ulHqEnt);
schInitDrxUeCb(ueCb);
}
}
* -# RFAILED
**/
-uint8_t schAddDrxTimerIntoList(CmLListCp *drxTimerList,void * nodeInfo, CmLList *drxNodeInfo)
+uint8_t schAddDrxTimerIntoList(CmLListCp *drxTimerList,void * nodeInfo, CmLList **drxNodeInfo)
+{
+ CmLList *currentNodeInfo = NULLP;
+
+ SCH_ALLOC(currentNodeInfo, sizeof(CmLList));
+ if(!currentNodeInfo)
+ {
+ DU_LOG("\nERROR --> SCH : schAddDrxTimerIntoList() : Memory allocation failed");
+ return RFAILED;
+ }
+
+ currentNodeInfo->node = (PTR)nodeInfo;
+
+ cmLListAdd2Tail(drxTimerList, currentNodeInfo);
+ (*drxNodeInfo) = currentNodeInfo;
+ DU_LOG("\nINFO --> SCH : Drx node added into the list");
+ return ROK;
+}
+
+/**
+ * @brief Add new entry into the drx harq timer list
+ *
+ * @details
+ *
+ * Function : schAddDrxNodeIntoHarqTimerList
+ *
+ * Add new entry into the drx harq timer list
+ *
+ * @param[in] CmLListCp *drxTimerList -> List in which new entery have to add
+ * void * nodeInfo-> ue information which is need to the added into list
+ * CmLList **drxNodeInfo -> pointer to the node
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+uint8_t schAddDrxNodeIntoHarqTimerList(CmLListCp *drxTimerList,void * nodeInfo, CmLList **drxNodeInfo)
{
CmLList *currentNodeInfo = NULLP;
currentNodeInfo->node = (PTR)nodeInfo;
cmLListAdd2Tail(drxTimerList, currentNodeInfo);
- drxNodeInfo = currentNodeInfo;
+ (*drxNodeInfo) = currentNodeInfo;
DU_LOG("\nINFO --> SCH : Drx node added into the list");
+
return ROK;
}
}
SCH_CALCULATE_TIMER_INDEX(onDurTime, ueCb->drxUeCb.onDurationStartIndex);
ueCb->drxUeCb.onDurationStartDistance = SCH_CALC_SLOT_DIFF(onDurationOccurance, cell->slotInfo, cell->numSlots)/MAX_DRX_SIZE;
- schAddDrxTimerIntoList(&cell->drxCb[ueCb->drxUeCb.onDurationStartIndex].onDurationStartList, ueCb, ueCb->drxUeCb.onDurationStartNodeInfo);
+ schAddDrxTimerIntoList(&cell->drxCb[ueCb->drxUeCb.onDurationStartIndex].onDurationStartList, ueCb, &ueCb->drxUeCb.onDurationStartNodeInfo);
}
/**
onDurTime = onDurationOccurance.sfn*cell->numSlots+onDurationOccurance.slot;
SCH_CALCULATE_TIMER_INDEX(onDurTime, ueCb->drxUeCb.onDurationStartIndex);
ueCb->drxUeCb.onDurationStartDistance = SCH_CALC_SLOT_DIFF(onDurationOccurance, cell->slotInfo, cell->numSlots)/MAX_DRX_SIZE;
- schAddDrxTimerIntoList(&cell->drxCb[ueCb->drxUeCb.onDurationStartIndex].onDurationStartList, ueCb, ueCb->drxUeCb.onDurationStartNodeInfo);
+ schAddDrxTimerIntoList(&cell->drxCb[ueCb->drxUeCb.onDurationStartIndex].onDurationStartList, ueCb, &ueCb->drxUeCb.onDurationStartNodeInfo);
}
}
}
else
{
- ueCb->drxUeCb.drxDlUeActiveStatus |= UE_ACTIVE_FOR_ONDURATION;
+ ueCb->drxUeCb.drxDlUeActiveMask |= UE_ACTIVE_FOR_ONDURATION;
+
+ /* set the Ue status as active or inactive*/
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
/* If there is any entery present in onDurationExpiry list remove
* the entery from the list and recalculate the
/* 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);
+ schAddDrxTimerIntoList(&cell->drxCb[onDurationExpiry].onDurationExpiryList, ueCb, &ueCb->drxUeCb.onDurationExpiryNodeInfo);
ueCb->drxUeCb.onDurationExpiryIndex = onDurationExpiry;
}
{
continue;
}
- ueCb->drxUeCb.drxUlUeActiveStatus |= UE_ACTIVE_FOR_ONDURATION;
-
-
+ ueCb->drxUeCb.drxUlUeActiveMask |= UE_ACTIVE_FOR_ONDURATION;
+ /* set the final Ue status as active or inactive */
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
+
/* 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));
}
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);
+ schAddDrxTimerIntoList(&cell->drxCb[ueCb->drxUeCb.onDurationStartIndex].onDurationStartList, ueCb, &ueCb->drxUeCb.onDurationStartNodeInfo);
}
}
}
* -# ROK
* -# RFAILED
**/
+
void schHdlDrxOnDurStrtTimer(SchCellCb *cell)
{
uint16_t dlIndx = 0, ulIndx=0;
/* 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);
+ 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;
+ ueCb->drxUeCb.drxDlUeActiveMask |= UE_ACTIVE_FOR_INACTIVE_TIMER;
+ ueCb->drxUeCb.drxUlUeActiveMask |= UE_ACTIVE_FOR_INACTIVE_TIMER;
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
}
/**
- * @brief Handling of the DRX timers start
+ * @brief Handling of short cycle drx start timer
*
* @details
*
- * Function : schHandleStartDrxTimer
+ * Function : schHdlDrxStartShortCycleTimer
*
- * Handling of DRX timers start
+ * Handling of short cycle drx start timer
*
* @param[in] SchCellCb *cell
* @return
* -# ROK
* -# RFAILED
**/
-void schHandleStartDrxTimer(SchCellCb *cell)
+
+void schHdlDrxStartShortCycleTimer(SchCellCb *cell, SchUeCb *ueCb)
{
- /* Handling the onduration start timer */
- schHdlDrxOnDurStrtTimer(cell);
+ 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 expiry onduration timer in dl direction
+ * @brief Handling of the Dl harq DRX timers start for Dl scheduling
*
* @details
*
- * Function : schHdlDrxOnDurExpiryTimerForDlDirection
+ * Function : schHdlDlHqRetxStrtTimerForDl
*
- * Handling of expiry onduration DRX timers in dl direction
+ * Handling of Dl harq DRX timers start for Dl scheduling
*
- * @param[in] SchCellCb *cell
+ * @param[in] SchCellCb *cell, uint16_t currIdx
* @return
- * -# ROK
- * -# RFAILED
- **/
-void schHdlDrxOnDurExpiryTimerForDlDirection(SchCellCb *cell, uint16_t currListIndx)
+ * void
+**/
+
+void schHdlDlHqRetxStrtTimerForDl(SchCellCb *cell, uint16_t currIndx)
{
- CmLList *drxCurrNode;
- SchUeCb *ueCb = NULLP;
-
- drxCurrNode = cell->drxCb[currListIndx].onDurationExpiryList.first;
- if(drxCurrNode)
+ uint32_t retxExpIndx;
+ CmLList *currNode;
+ SchDlHqProcCb *hqP;
+ SchUeCb *ueCb;
+
+ currNode = cell->drxCb[currIndx].dlRetransTmrStartList.first;
+
+ while(currNode)
{
- /* Handling of dl On duration drx start list */
- while(drxCurrNode)
+ hqP = (SchDlHqProcCb*)currNode->node;
+ currNode = currNode->next;
+ cell->api->SchAddUeToSchedule(hqP->hqEnt->cell, hqP->hqEnt->ue->ueId);
+ ueCb = hqP->hqEnt->ue;
+
+ /* calculate the retransmission exp index */
+ retxExpIndx = (currIndx + ueCb->drxUeCb.retransDlTimerLen)%MAX_DRX_SIZE;
+ if(hqP->dlDrxHarqCb.retxExpIndex == SCH_DRX_INVALID_INDEX)
{
- 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;
+ hqP->dlDrxHarqCb.retxExpIndex = retxExpIndx;
+ schAddDrxNodeIntoHarqTimerList(&cell->drxCb[retxExpIndx].dlRetransExpiryList, hqP, &hqP->dlDrxHarqCb.retxExpNode);
}
+
+ /* Mark the UE active for downlink */
+ ueCb->drxUeCb.drxDlUeActiveMaskForHarq |= (SCH_DRX_DL_HARQ_BITMASK << hqP->procId);
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
}
}
/**
- * @brief Handling of the expiry onduration DRX timers for Ul direction
+ * @brief Handling of the Dl harq DRX timers start for Ul scheduling
*
* @details
*
- * Function schHdlDrxOnDurExpiryTimerForUlDirection:
+ * Function : schHdlDlHqRetxStrtTimerForUl
*
- * Handling of expiry onduration DRX timers in Ul direction
+ * Handling of Dl harq DRX timers start for Ul scheduling
*
- * @param[in] SchCellCb *cell
+ * @param[in] SchCellCb *cell, uint16_t currIdx
* @return
- * -# ROK
- * -# RFAILED
+ * void
**/
-void schHdlDrxOnDurExpiryTimerForUlDirection(SchCellCb *cell, uint16_t currListIndx)
+
+void schHdlDlHqRetxStrtTimerForUl(SchCellCb *cell, uint16_t currIndx)
{
- CmLList *drxCurrNode;
- SchUeCb *ueCb = NULLP;
+ CmLList *currNode;
+ SchDlHqProcCb *hqP;
+ SchUeCb *ueCb;
- drxCurrNode = cell->drxCb[currListIndx].onDurationExpiryList.first;
- if(drxCurrNode)
+ currNode = cell->drxCb[currIndx].dlRetransTmrStartList.first;
+
+ while(currNode)
{
- /* 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;
- }
+ hqP = (SchDlHqProcCb*)currNode->node;
+ currNode = currNode->next;
+ ueCb = hqP->hqEnt->ue;
+
+ /* Mark the UE active for uplink */
+ ueCb->drxUeCb.drxUlUeActiveMaskForHarq |= (SCH_DRX_UL_HARQ_BITMASK << hqP->procId);
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
+
+ /* Delete the node */
+ cmLListDelFrm(&cell->drxCb[currIndx].dlRetransTmrStartList, hqP->dlDrxHarqCb.retxStrtNode);
+ SCH_FREE(hqP->dlDrxHarqCb.retxStrtNode, sizeof(CmLList));
+ hqP->dlDrxHarqCb.retxStrtIndex = SCH_DRX_INVALID_INDEX;
}
}
+
/**
- * @brief Handling of the expiry onduration DRX timers
+ * @brief Handling of the Dl harq DRX timers start
*
* @details
*
- * Function : schHdlDrxOnDurExpiryTimer
+ * Function : schHdlDrxDlHqRetxStrtTimer
*
- * Handling of expiry onduration DRX timers
+ * Handling of Dl harq DRX timers start
*
* @param[in] SchCellCb *cell
* @return
* -# ROK
* -# RFAILED
**/
-void schHdlDrxOnDurExpiryTimer(SchCellCb *cell)
+
+void schHdlDrxDlHqRetxStrtTimer(SchCellCb *cell)
{
- uint16_t dlIndx = 0, ulIndx = 0;
+ 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);
+ 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);
+ schHdlDlHqRetxStrtTimerForDl(cell, dlIndx);
+ schHdlDlHqRetxStrtTimerForUl(cell, ulIndx);
}
/**
- * @brief Handling of the expiry of in-active DRX timers in Dl
+ * @brief Handling of the DRX timers start
*
* @details
*
- * Function : schHdlDrxInActvExpiryTimerForDlDirection
+ * Function : schHandleStartDrxTimer
*
- * Handling of expiry of in-active DRX timers at Dl index
+ * Handling of DRX timers start
*
- * @param[in] SchCellCb *cell, uint16_t dlIndx
+ * @param[in] SchCellCb *cell
* @return
* -# ROK
* -# RFAILED
**/
-void schHdlDrxInActvExpiryTimerForDlDirection(SchCellCb *cell, uint16_t dlIndx)
+void schHandleStartDrxTimer(SchCellCb *cell)
{
- 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;
- }
- }
+ /* Handling the onduration start timer */
+ schHdlDrxOnDurStrtTimer(cell);
+ schHdlDrxDlHqRetxStrtTimer(cell);
+ schHdlDrxUlHqRetxStrtTimer(cell);
}
/**
- * @brief Handling of the expiry of in-active DRX timers in Ul
+ * @brief Handling of the Dl harq Rtt start DRX timers
*
* @details
*
- * Function : schHdlDrxInActvExpiryTimerForUlDirection
+ * Function : schDrxStrtDlHqRttTmr
*
- * Handling of expiry of in-active DRX timers at Ul index
+ * Handling of the Dl harq Rtt start DRX timers
*
- * @param[in] SchCellCb *cell, uint16_t ulIndx
+ * @param[in] SchCellCb *cell
* @return
* -# ROK
* -# RFAILED
**/
-void schHdlDrxInActvExpiryTimerForUlDirection(SchCellCb *cell, uint16_t ulIndx)
+void schDrxStrtDlHqRttTmr(SchDlHqProcCb *hqP)
{
- CmLList *drxNode;
- SchUeCb *ueCb = NULLP;
+ uint16_t harqRttExpTimer=0;
+ SchDrxUeCb *drxUeCb;
+
+ drxUeCb = &hqP->hqEnt->ue->drxUeCb;
+
+ harqRttExpTimer = (hqP->pucchTime.sfn * MAX_SLOTS + hqP->pucchTime.slot + drxUeCb->harqRttDlTimerLen)%MAX_DRX_SIZE;
+ hqP->dlDrxHarqCb.rttExpIndex = harqRttExpTimer;
+ schAddDrxNodeIntoHarqTimerList(&hqP->hqEnt->cell->drxCb[harqRttExpTimer].dlHarqRttExpiryList, hqP, &hqP->dlDrxHarqCb.rttExpNode);
+}
- drxNode = cell->drxCb[ulIndx].inActvTmrExpiryList.first;
- if(drxNode)
+/**
+ * @brief Handling of the Ul harq DRX timers start for Dl scheduling
+ *
+ * @details
+ *
+ * Function : schHdlUlHqRetxStrtTimerForDl
+ *
+ * Handling of Ul harq DRX timers start for Dl scheduling
+ *
+ * @param[in] SchCellCb *cell, uint16_t currIdx
+ * @return
+ * void
+**/
+
+void schHdlUlHqRetxStrtTimerForDl(SchCellCb *cell, uint16_t currIndx)
+{
+ uint32_t retxExpIndx;
+ CmLList *currNode;
+ SchUlHqProcCb *hqP;
+ SchUeCb *ueCb;
+
+ currNode = cell->drxCb[currIndx].ulRetransTmrStartList.first;
+
+ while(currNode)
{
- /* Handling of dl On duration drx start list */
- while(drxNode)
+ hqP = (SchUlHqProcCb*)currNode->node;
+ currNode = currNode->next;
+ cell->api->SchAddUeToSchedule(hqP->hqEnt->cell, hqP->hqEnt->ue->ueId);
+ ueCb = hqP->hqEnt->ue;
+
+ /* calculate the retransmission exp index */
+ retxExpIndx = (currIndx + ueCb->drxUeCb.retransUlTimerLen)%MAX_DRX_SIZE;
+ if(hqP->ulDrxHarqCb.retxExpIndex == SCH_DRX_INVALID_INDEX)
{
- ueCb = (SchUeCb*)drxNode->node;
- drxNode = drxNode->next;
+ hqP->ulDrxHarqCb.retxExpIndex = retxExpIndx;
+ schAddDrxNodeIntoHarqTimerList(&cell->drxCb[retxExpIndx].ulRetransExpiryList, hqP, &hqP->ulDrxHarqCb.retxExpNode);
+ }
+
+ /* Mark the UE active for downlink */
+ ueCb->drxUeCb.drxUlUeActiveMaskForHarq |= (SCH_DRX_UL_HARQ_BITMASK << hqP->procId);
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
+ }
+}
- if(ueCb->drxUeCb.onDurationExpiryDistance != SCH_DRX_INVALID_DISTANCE)
- {
+/**
+ * @brief Handling of the Ul harq DRX timers start for Ul scheduling
+ *
+ * @details
+ *
+ * Function : schHdlUlHqRetxStrtTimerForUl
+ *
+ * Handling of Ul harq DRX timers start for Ul scheduling
+ *
+ * @param[in] SchCellCb *cell, uint16_t currIdx
+ * @return
+ * void
+ **/
+
+void schHdlUlHqRetxStrtTimerForUl(SchCellCb *cell, uint16_t currIndx)
+{
+ CmLList *currNode;
+ SchUlHqProcCb *hqP;
+ SchUeCb *ueCb;
+
+ currNode = cell->drxCb[currIndx].ulRetransTmrStartList.first;
+
+ while(currNode)
+ {
+ hqP = (SchUlHqProcCb*)currNode->node;
+ currNode = currNode->next;
+ ueCb = hqP->hqEnt->ue;
+
+ /* Mark the UE active for uplink */
+ ueCb->drxUeCb.drxUlUeActiveMaskForHarq |= (SCH_DRX_UL_HARQ_BITMASK << hqP->procId);
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
+
+ /* Delete the node */
+ cmLListDelFrm(&cell->drxCb[currIndx].ulRetransTmrStartList, hqP->ulDrxHarqCb.retxStrtNode);
+ SCH_FREE(hqP->ulDrxHarqCb.retxStrtNode, sizeof(CmLList));
+ hqP->ulDrxHarqCb.retxStrtIndex = SCH_DRX_INVALID_INDEX;
+ }
+}
+
+/**
+ * @brief Handling of the Ul harq DRX timers start
+ *
+ * @details
+ *
+ * Function : schHdlDrxUlHqRetxStrtTimer
+ *
+ * Handling of Ul harq DRX timers start
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+void schHdlDrxUlHqRetxStrtTimer(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;
+
+ schHdlUlHqRetxStrtTimerForDl(cell, dlIndx);
+ schHdlUlHqRetxStrtTimerForUl(cell, ulIndx);
+}
+
+/**
+ * @brief Handling of the Ul harq Rtt start DRX timers
+ *
+ * @details
+ *
+ * Function : schDrxStrtUlHqRttTmr
+ *
+ * Handling of the Ul harq Rtt start DRX timers
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+void schDrxStrtUlHqRttTmr(SchUlHqProcCb *hqP)
+{
+ uint16_t harqRttExpTimer=0;
+ SchDrxUeCb *drxUeCb;
+
+ drxUeCb = &hqP->hqEnt->ue->drxUeCb;
+
+ harqRttExpTimer = (hqP->puschTime.sfn * MAX_SLOTS + hqP->puschTime.slot + drxUeCb->harqRttUlTimerLen)%MAX_DRX_SIZE;
+ hqP->ulDrxHarqCb.rttExpIndex = harqRttExpTimer;
+ schAddDrxNodeIntoHarqTimerList(&hqP->hqEnt->cell->drxCb[harqRttExpTimer].ulHarqRttExpiryList, hqP, &hqP->ulDrxHarqCb.rttExpNode);
+}
+
+/**
+ * @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.drxDlUeActiveMask &= ~UE_ACTIVE_FOR_ONDURATION;
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
+ }
+ }
+}
+
+/**
+ * @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.drxUlUeActiveMask &= ~UE_ACTIVE_FOR_ONDURATION;
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
+ 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.drxDlUeActiveMask &= ~UE_ACTIVE_FOR_INACTIVE_TIMER;
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
+ }
+ }
+}
+
+/**
+ * @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;
+ ueCb->drxUeCb.drxUlUeActiveMask &= ~UE_ACTIVE_FOR_INACTIVE_TIMER;
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
/* Remove the entry from the in-active exp timer list */
cmLListDelFrm(&cell->drxCb[ulIndx].inActvTmrExpiryList, ueCb->drxUeCb.inActvTimerExpiryNodeInfo);
if(ueCb->drxUeCb.shortCyclePresent)
{
/* Start short cycle timer */
- /* TODO Will implement this in next gerrit */
+ schHdlDrxStartShortCycleTimer(cell, ueCb);
}
}
}
* -# ROK
* -# RFAILED
**/
+
void schHdlDrxInActvExpiryTimer(SchCellCb *cell)
{
uint16_t dlIndx = 0, ulIndx = 0;
}
/**
- * @brief Handling of the expiry DRX timers
+ * @brief Handling of the expiry ShortCycle DRX timers in DL
*
* @details
*
- * Function : schHandleExpiryDrxTimer
+ * Function : schHdlDrxShortCycleExpiryTimerForDlDirection
*
- * Handling of expiry DRX timers
+ * Handling of expiry ShortCycle
*
* @param[in] SchCellCb *cell
* @return
* -# ROK
* -# RFAILED
**/
-void schHandleExpiryDrxTimer(SchCellCb *cell)
+
+void schHdlDrxShortCycleExpiryTimerForDlDirection(SchCellCb *cell, uint16_t dlIndx)
{
- /* Handling the onduration start timer */
+ 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 Dl harq rrt DRX timers
+ *
+ * @details
+ *
+ * Function : schHdlDlHqRttExpiryTimerForDl
+ *
+ * Handling of expiry Dl harq rrt DRX timers
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+void schHdlDlHqRttExpiryTimerForDl(SchCellCb *cell, uint16_t currIdx)
+{
+ SchDlHqProcCb *hqP;
+ CmLList *drxCurrNode;
+
+ drxCurrNode = cell->drxCb[currIdx].dlHarqRttExpiryList.first;
+
+ while(drxCurrNode)
+ {
+ hqP = (SchDlHqProcCb*)drxCurrNode->node;
+ drxCurrNode = drxCurrNode->next;
+
+ /* Add ue to dlRetransTmrStartList list */
+ if(hqP->dlDrxHarqCb.retxStrtIndex == SCH_DRX_INVALID_INDEX)
+ {
+ schAddDrxNodeIntoHarqTimerList(&cell->drxCb[currIdx + 1].dlRetransTmrStartList, hqP, &hqP->dlDrxHarqCb.retxStrtNode);
+ hqP->dlDrxHarqCb.retxStrtIndex = currIdx + 1;
+ }
+ }
+}
+
+/**
+ * @brief Handling of the expiry Dl harq retransmission DRX timers
+ *
+ * @details
+ *
+ * Function : schHdlDlHqRetxExpiryTimerForDl
+ *
+ * Handling of expiry Dl harq retransmission DRX timers
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+**/
+
+void schHdlDlHqRetxExpiryTimerForDl(SchCellCb *cell, uint16_t currIdx)
+{
+ SchDlHqProcCb *hqP;
+ SchUeCb *ueCb;
+ CmLList *drxCurrNode;
+
+ drxCurrNode = cell->drxCb[currIdx].dlRetransExpiryList.first;
+
+ while(drxCurrNode)
+ {
+ hqP = (SchDlHqProcCb*)drxCurrNode->node;
+ drxCurrNode = drxCurrNode->next;
+ ueCb = hqP->hqEnt->ue;
+
+ ueCb->drxUeCb.drxDlUeActiveMaskForHarq &= ~(SCH_DRX_DL_HARQ_BITMASK << hqP->procId);
+
+ /* Set the Ue status as inactive */
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
+ }
+}
+
+/**
+ * @brief Handling of the expiry Dl harq rrt DRX timers for Ul scheduling
+ *
+ * @details
+ *
+ * Function : schHdlDlHqRttExpiryTimerForUl
+ *
+ * Handling of expiry Dl harq rrt DRX timers for Ul scheduling
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+**/
+
+void schHdlDlHqRttExpiryTimerForUl(SchCellCb *cell, uint16_t currIdx)
+{
+ SchDlHqProcCb *hqP;
+ CmLList *drxCurrNode;
+
+ drxCurrNode = cell->drxCb[currIdx].dlHarqRttExpiryList.first;
+
+ while(drxCurrNode)
+ {
+ hqP = (SchDlHqProcCb*)drxCurrNode->node;
+ drxCurrNode = drxCurrNode->next;
+
+ /* Delete the node from list */
+ cmLListDelFrm(&cell->drxCb[currIdx].dlHarqRttExpiryList, hqP->dlDrxHarqCb.rttExpNode);
+ SCH_FREE(hqP->dlDrxHarqCb.rttExpNode, sizeof(CmLList));
+ hqP->dlDrxHarqCb.rttExpIndex = SCH_DRX_INVALID_INDEX;
+ }
+}
+
+/**
+ * @brief Handling of the expiry Dl harq retransmission DRX timers for Ul scheduling
+ *
+ * @details
+ *
+ * Function : schHdlDlHqRetxExpiryTimerForUl
+ *
+ * Handling of expiry Dl harq retransmission DRX timers for Ul scheduling
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+**/
+
+void schHdlDlHqRetxExpiryTimerForUl(SchCellCb *cell, uint16_t currIdx)
+{
+ SchDlHqProcCb *hqP;
+ SchUeCb *ueCb;
+ CmLList *drxCurrNode;
+
+ drxCurrNode = cell->drxCb[currIdx].dlRetransExpiryList.first;
+
+ while(drxCurrNode)
+ {
+ hqP = (SchDlHqProcCb*)drxCurrNode->node;
+ ueCb = hqP->hqEnt->ue;
+ drxCurrNode = drxCurrNode->next;
+
+ /* Set the Ue status as inactive for uplink */
+ ueCb->drxUeCb.drxUlUeActiveMaskForHarq &= ~(SCH_DRX_UL_HARQ_BITMASK << hqP->procId);
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
+
+ /* Delete the UE */
+ cmLListDelFrm(&cell->drxCb[currIdx].dlRetransExpiryList, hqP->dlDrxHarqCb.retxExpNode);
+ SCH_FREE(hqP->dlDrxHarqCb.retxExpNode, sizeof(CmLList));
+ hqP->dlDrxHarqCb.retxExpIndex = SCH_DRX_INVALID_INDEX;
+
+ }
+}
+
+/**
+ * @brief Handling of the expiry of Dl harq DRX timers
+ *
+ * @details
+ *
+ * Function : schHdlDrxDlHarqExpireTimer
+ *
+ * Handling of expiry of Dl harq DRX timers
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# void
+
+ **/
+
+void schHdlDrxDlHarqExpireTimer(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;
+
+ schHdlDlHqRttExpiryTimerForDl(cell, dlIndx);
+ schHdlDlHqRetxExpiryTimerForDl(cell, dlIndx);
+ schHdlDlHqRttExpiryTimerForUl(cell, ulIndx );
+ schHdlDlHqRetxExpiryTimerForUl(cell, ulIndx);
+}
+
+/**
+ * @brief Handling of the expiry of harq DRX timers
+ *
+ * @details
+ *
+ * Function : schDrxStopDlHqRetxTmr
+ *
+ * Handling of expiry DRX timers
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+void schDrxStopDlHqRetxTmr(SchCellCb *cell, SchUeCb *ueCb, SchDlHqProcCb **hqP)
+{
+
+ if((*hqP)->dlDrxHarqCb.retxExpIndex != SCH_DRX_INVALID_INDEX)
+ {
+ ueCb->drxUeCb.drxDlUeActiveMaskForHarq &= ~(SCH_DRX_DL_HARQ_BITMASK << (*hqP)->procId);
+ ueCb->drxUeCb.drxUlUeActiveMaskForHarq &= ~(SCH_DRX_UL_HARQ_BITMASK << (*hqP)->procId);
+
+ /* Change the UE status to Inactive */
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
+
+ /* If there is any node present in rtt list then remove the node from list */
+ if((*hqP)->dlDrxHarqCb.rttExpIndex != SCH_DRX_INVALID_INDEX)
+ {
+ cmLListDelFrm(&cell->drxCb[(*hqP)->dlDrxHarqCb.rttExpIndex].dlHarqRttExpiryList, (*hqP)->dlDrxHarqCb.rttExpNode);
+ SCH_FREE((*hqP)->dlDrxHarqCb.rttExpNode, sizeof(CmLList));
+ (*hqP)->dlDrxHarqCb.rttExpIndex = SCH_DRX_INVALID_INDEX;
+ }
+
+ /* If there is any node present in retx list then remove the node from list */
+ if((*hqP)->dlDrxHarqCb.retxStrtIndex != SCH_DRX_INVALID_INDEX)
+ {
+ cmLListDelFrm(&cell->drxCb[(*hqP)->dlDrxHarqCb.retxStrtIndex].dlRetransTmrStartList, (*hqP)->dlDrxHarqCb.retxStrtNode);
+ SCH_FREE((*hqP)->dlDrxHarqCb.retxStrtNode, sizeof(CmLList));
+ (*hqP)->dlDrxHarqCb.retxStrtIndex = SCH_DRX_INVALID_INDEX;
+ }
+
+ cmLListDelFrm(&cell->drxCb[(*hqP)->dlDrxHarqCb.retxExpIndex].dlRetransExpiryList, (*hqP)->dlDrxHarqCb.retxExpNode);
+ SCH_FREE((*hqP)->dlDrxHarqCb.retxExpNode, sizeof(CmLList));
+ (*hqP)->dlDrxHarqCb.retxExpIndex = SCH_DRX_INVALID_INDEX;
+ }
+}
+
+/**
+ * @brief Handling of the expiry Ul harq rrt DRX timers
+ *
+ * @details
+ *
+ * Function : schHdlUlHqRttExpiryTimerForDl
+ *
+ * Handling of expiry ul harq rrt DRX timers
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+void schHdlUlHqRttExpiryTimerForDl(SchCellCb *cell, uint16_t currIdx)
+{
+ SchUlHqProcCb *hqP;
+ CmLList *drxCurrNode;
+
+ drxCurrNode = cell->drxCb[currIdx].ulHarqRttExpiryList.first;
+
+ while(drxCurrNode)
+ {
+ hqP = (SchUlHqProcCb*)drxCurrNode->node;
+ drxCurrNode = drxCurrNode->next;
+
+ /* Add ue to ulRetransTmrStartList list */
+ if(hqP->ulDrxHarqCb.retxStrtIndex == SCH_DRX_INVALID_INDEX)
+ {
+ schAddDrxNodeIntoHarqTimerList(&cell->drxCb[currIdx + 1].ulRetransTmrStartList, hqP, &hqP->ulDrxHarqCb.retxStrtNode);
+ hqP->ulDrxHarqCb.retxStrtIndex = currIdx + 1;
+ }
+ }
+}
+
+/**
+ * @brief Handling of the expiry ul harq retransmission DRX timers
+ *
+ * @details
+ *
+ * Function : schHdlUlHqRetxExpiryTimerForDl
+ *
+ * Handling of expiry Ul harq retransmission DRX timers
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+**/
+
+void schHdlUlHqRetxExpiryTimerForDl(SchCellCb *cell, uint16_t currIdx)
+{
+ SchUlHqProcCb *hqP;
+ SchUeCb *ueCb;
+ CmLList *drxCurrNode;
+
+ drxCurrNode = cell->drxCb[currIdx].ulRetransExpiryList.first;
+
+ while(drxCurrNode)
+ {
+ hqP = (SchUlHqProcCb*)drxCurrNode->node;
+ drxCurrNode = drxCurrNode->next;
+ ueCb = hqP->hqEnt->ue;
+
+ ueCb->drxUeCb.drxUlUeActiveMaskForHarq &= ~(SCH_DRX_UL_HARQ_BITMASK << hqP->procId);
+
+ /* Set the Ue status as inactive */
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
+ }
+}
+
+/**
+ * @brief Handling of the expiry ul harq rrt DRX timers for Ul scheduling
+ *
+ * @details
+ *
+ * Function : schHdlUlHqRttExpiryTimerForUl
+ *
+ * Handling of expiry Ul harq rrt DRX timers for Ul scheduling
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+**/
+
+void schHdlUlHqRttExpiryTimerForUl(SchCellCb *cell, uint16_t currIdx)
+{
+ SchUlHqProcCb *hqP;
+ CmLList *drxCurrNode;
+
+ drxCurrNode = cell->drxCb[currIdx].ulHarqRttExpiryList.first;
+
+ while(drxCurrNode)
+ {
+ hqP = (SchUlHqProcCb*)drxCurrNode->node;
+ drxCurrNode = drxCurrNode->next;
+
+ /* Delete the node from list */
+ cmLListDelFrm(&cell->drxCb[currIdx].ulHarqRttExpiryList, hqP->ulDrxHarqCb.rttExpNode);
+ SCH_FREE(hqP->ulDrxHarqCb.rttExpNode, sizeof(CmLList));
+ hqP->ulDrxHarqCb.rttExpIndex = SCH_DRX_INVALID_INDEX;
+ }
+}
+
+/**
+ * @brief Handling of the expiry Ul harq retransmission DRX timers for Ul scheduling
+ *
+ * @details
+ *
+ * Function : schHdlUlHqRetxExpiryTimerForUl
+ *
+ * Handling of expiry Ul harq retransmission DRX timers for Ul scheduling
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+**/
+
+void schHdlUlHqRetxExpiryTimerForUl(SchCellCb *cell, uint16_t currIdx)
+{
+ SchUlHqProcCb *hqP;
+ SchUeCb *ueCb;
+ CmLList *drxCurrNode;
+
+ drxCurrNode = cell->drxCb[currIdx].ulRetransExpiryList.first;
+
+ while(drxCurrNode)
+ {
+ hqP = (SchUlHqProcCb*)drxCurrNode->node;
+ ueCb = hqP->hqEnt->ue;
+ drxCurrNode = drxCurrNode->next;
+
+ /* Set the Ue status as inactive for uplink */
+ ueCb->drxUeCb.drxUlUeActiveMaskForHarq &= ~(SCH_DRX_UL_HARQ_BITMASK << hqP->procId);
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
+
+ /* Delete the UE */
+ cmLListDelFrm(&cell->drxCb[currIdx].ulRetransExpiryList, hqP->ulDrxHarqCb.retxExpNode);
+ SCH_FREE(hqP->ulDrxHarqCb.retxExpNode, sizeof(CmLList));
+ hqP->ulDrxHarqCb.retxExpIndex = SCH_DRX_INVALID_INDEX;
+
+ }
+}
+
+/**
+ * @brief Handling of the expiry of Ul harq DRX timers
+ *
+ * @details
+ *
+ * Function : schHdlDrxUlHarqExpireTimer
+ *
+ * Handling of expiry of Ul harq DRX timers
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# void
+
+ **/
+
+void schHdlDrxUlHarqExpireTimer(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;
+
+ schHdlUlHqRttExpiryTimerForDl(cell, dlIndx);
+ schHdlUlHqRetxExpiryTimerForDl(cell, dlIndx);
+ schHdlUlHqRttExpiryTimerForUl(cell, ulIndx );
+ schHdlUlHqRetxExpiryTimerForUl(cell, ulIndx);
+}
+
+/**
+ * @brief Hanuling of the expiry of harq DRX timers
+ *
+ * @details
+ *
+ * Function : schDrxStopUlHqRetxTmr
+ *
+ * Hanuling of expiry DRX timers
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+void schDrxStopUlHqRetxTmr(SchCellCb *cell, SchUeCb *ueCb, SchUlHqProcCb **hqP)
+{
+
+ if((*hqP)->ulDrxHarqCb.retxExpIndex != SCH_DRX_INVALID_INDEX)
+ {
+ ueCb->drxUeCb.drxDlUeActiveMaskForHarq &= ~(SCH_DRX_DL_HARQ_BITMASK << (*hqP)->procId);
+ ueCb->drxUeCb.drxUlUeActiveMaskForHarq &= ~(SCH_DRX_UL_HARQ_BITMASK << (*hqP)->procId);
+
+ /* Change the UE status to Inactive */
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
+
+ /* If there is any node present in rtt list then remove the node from list */
+ if((*hqP)->ulDrxHarqCb.rttExpIndex != SCH_DRX_INVALID_INDEX)
+ {
+ cmLListDelFrm(&cell->drxCb[(*hqP)->ulDrxHarqCb.rttExpIndex].ulHarqRttExpiryList, (*hqP)->ulDrxHarqCb.rttExpNode);
+ SCH_FREE((*hqP)->ulDrxHarqCb.rttExpNode, sizeof(CmLList));
+ (*hqP)->ulDrxHarqCb.rttExpIndex = SCH_DRX_INVALID_INDEX;
+ }
+
+ /* If there is any node present in retx list then remove the node from list */
+ if((*hqP)->ulDrxHarqCb.retxStrtIndex != SCH_DRX_INVALID_INDEX)
+ {
+ cmLListDelFrm(&cell->drxCb[(*hqP)->ulDrxHarqCb.retxStrtIndex].ulRetransTmrStartList, (*hqP)->ulDrxHarqCb.retxStrtNode);
+ SCH_FREE((*hqP)->ulDrxHarqCb.retxStrtNode, sizeof(CmLList));
+ (*hqP)->ulDrxHarqCb.retxStrtIndex = SCH_DRX_INVALID_INDEX;
+ }
+
+ cmLListDelFrm(&cell->drxCb[(*hqP)->ulDrxHarqCb.retxExpIndex].ulRetransExpiryList, (*hqP)->ulDrxHarqCb.retxExpNode);
+ SCH_FREE((*hqP)->ulDrxHarqCb.retxExpNode, sizeof(CmLList));
+ (*hqP)->ulDrxHarqCb.retxExpIndex = SCH_DRX_INVALID_INDEX;
+ }
+}
+
+/**
+ * @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);
+ schHdlDrxDlHarqExpireTimer(cell);
+ schHdlDrxUlHarqExpireTimer(cell);
}
#endif