#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
*
* -# ROK
* -# RFAILED
**/
+
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;
}
/**
* -# ROK
* -# RFAILED
**/
+
void schInitDrxUeCb(SchUeCb *ueCb)
{
memset(&ueCb->drxUeCb, 0, sizeof(SchDrxUeCb));
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;
}
-#if 0
-/* will uncomment this function in next gerrit */
+
/**
* @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->drxHarqCb.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->drxHarqCb.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->drxHarqCb.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->drxHarqCb);
- }
- }
+ 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->drxHarqCb.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->drxHarqCb.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];
+
+ 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);
+ }
+}
- tmrIdx = procs->drxHarqCb.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->drxHarqCb);
- }
- }
-#endif
/**
* @brief delete UE drx timers and information
*
* delete UE drx timers and information
*
* @param[in] SchCellCb *cell, SchUeCb *ueCb
- * @return
- * -# ROK
- * -# RFAILED
+ * @return void
+ *
**/
+
void schDeleteUeDrxInfo(SchCellCb *cell, SchUeCb *ueCb)
{
SchDrxUeCb *drxUeCb;
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);
}
}
* -# ROK
* -# RFAILED
**/
+
void schFillDrxUeCb(uint8_t numerology, SchDrxCfg drxCfg, SchDrxUeCb *drxUeCb)
{
if(drxCfg.drxOnDurationTimer.onDurationTimerValInMs)
SCH_CNVRT_MS_TO_SLOT(drxUeCb->inActvTimerLen, drxCfg.drxInactivityTimer, numerology);
SCH_CNVRT_SYMBL_TO_SLOT(drxUeCb->harqRttDlTimerLen, drxCfg.drxHarqRttTimerDl);
SCH_CNVRT_SYMBL_TO_SLOT(drxUeCb->harqRttUlTimerLen, drxCfg.drxHarqRttTimerUl);
- SCH_CNVRT_MS_TO_SLOT(drxUeCb->retransDlTimerLen, drxCfg.drxRetransmissionTimerDl, numerology);
- SCH_CNVRT_MS_TO_SLOT(drxUeCb->retransUlTimerLen, drxCfg.drxRetransmissionTimerUl, numerology);
+ drxUeCb->retransDlTimerLen = drxCfg.drxRetransmissionTimerDl;
+ drxUeCb->retransUlTimerLen = drxCfg.drxRetransmissionTimerUl;
SCH_CNVRT_MS_TO_SLOT(drxUeCb->longCycleLen, drxCfg.drxLongCycleStartOffset.drxLongCycleStartOffsetChoice, numerology);
- drxUeCb->drxStartOffset = drxCfg.drxLongCycleStartOffset.drxLongCycleStartOffsetVal;
+ SCH_CNVRT_MS_TO_SLOT(drxUeCb->drxStartOffset, drxCfg.drxLongCycleStartOffset.drxLongCycleStartOffsetVal, numerology);
if(drxCfg.shortDrxPres)
{
drxUeCb->shortCyclePresent = true;
SCH_CNVRT_MS_TO_SLOT(drxUeCb->shortCycleLen, drxCfg.shortDrx.drxShortCycle, numerology);
- drxUeCb->shortCycleTmrLen = drxCfg.shortDrx.drxShortCycleTimer;
+ drxUeCb->shortCycleTmrLen = drxUeCb->shortCycleLen*drxCfg.shortDrx.drxShortCycleTimer;
}
- else
- drxUeCb->longCycleToBeUsed = true;
+ drxUeCb->longCycleToBeUsed = true;
SCH_CNVRT_MS_TO_SLOT(drxUeCb->drxSlotOffset, drxCfg.drxSlotOffset, numerology);
drxUeCb->drxSlotOffset = drxUeCb->drxSlotOffset>>5;
}
* -# ROK
* -# RFAILED
**/
+
uint8_t schAddDrxTimerIntoList(CmLListCp *drxTimerList,void * nodeInfo, CmLList *drxNodeInfo)
{
CmLList *currentNodeInfo = NULLP;
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;
+
+ 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;
}
* @return
* -# void
**/
+
void findNextOndurationOccurance(SchCellCb *cell, SchDrxUeCb *ueDrxCb, SlotTimingInfo *nxtOnDur, uint8_t delta)
{
- uint16_t resultX, reusltY, idx;
+ uint16_t tmpDistance, numOfCycles;
uint32_t curTime, cycleLen, nxtDist;
SlotTimingInfo tmpTime;
-
+
if (ueDrxCb->longCycleToBeUsed == true)
{
cycleLen = ueDrxCb->longCycleLen;
}
/* Add delta to current time */
- ADD_DELTA_TO_TIME(cell->slotInfo, tmpTime, delta);
+ ADD_DELTA_TO_TIME(cell->slotInfo, tmpTime, delta, cell->numSlots);
/* Convert tmpTime to number of slots */
- curTime = ((tmpTime.sfn * MAX_SLOTS) + tmpTime.slot);
+ curTime = ((tmpTime.sfn * cell->numSlots) + tmpTime.slot);
/* as per 38.321, if the criterion below is satisfied, then that sfn and
* slot are the correct ones for the on-duration timer.
* (drx-ShortCycle) = (drxStartOffset) modulo (drx-ShortCycle); or
* if the Long DRX Cycle is used, and [(SFN × 10) + subframe number] modulo
* (drx-LongCycle) = drxStartOffset */
- for(idx =1; idx<MAX_DRX_SIZE; idx++)
+ if ( curTime <= ueDrxCb->drxStartOffset)
{
- resultX = (tmpTime.sfn *10+tmpTime.slot) % cycleLen;
- if (TRUE != ueDrxCb->shortCyclePresent)
- reusltY = ueDrxCb->drxStartOffset;
- else
- reusltY = ueDrxCb->drxStartOffset % cycleLen;
- if(resultX == reusltY)
+ /* offset is the nextOnDur */
+ nxtDist = ((((ueDrxCb->drxStartOffset / cell->numSlots)) & (MAX_SFN - 1)) * cell->numSlots) + (ueDrxCb->drxStartOffset % cell->numSlots);
+ }
+ else
+ {
+ tmpDistance = curTime - ueDrxCb->drxStartOffset;
+ numOfCycles = tmpDistance / cycleLen;
+
+ if (0 == (tmpDistance % cycleLen))
{
- memcpy(nxtOnDur, &tmpTime, sizeof(SlotTimingInfo));
- nxtDist = ((nxtOnDur->sfn * MAX_SLOTS) + nxtOnDur->slot);
- break;
+ /* Perfect match pick up the current time */
+ nxtDist = ((((curTime / cell->numSlots)) & (MAX_SFN - 1)) * cell->numSlots) + (curTime % cell->numSlots);
}
else
{
- ADD_DELTA_TO_TIME(tmpTime, tmpTime, 1);
+ nxtDist = ueDrxCb->drxStartOffset + (numOfCycles + 1) * cycleLen;
}
}
if(ueDrxCb->drxSlotOffset)
{
nxtDist = nxtDist + ueDrxCb->drxSlotOffset;
- ADD_DELTA_TO_TIME(tmpTime, tmpTime, ueDrxCb->drxSlotOffset);
- memcpy(nxtOnDur, &tmpTime, sizeof(SlotTimingInfo));
}
/*If next On Duration is less than DL DELTA ahead, we will miss it and
* hence need to move to the On-Duration after that.*/
if((nxtDist - (curTime - delta)) <= SCH_DRX_MAX_DELTA)
{
- ADD_DELTA_TO_TIME(tmpTime, tmpTime, cycleLen);
- memcpy(nxtOnDur, &tmpTime, sizeof(SlotTimingInfo));
+ nxtDist = nxtDist + cycleLen;
}
+
+ nxtOnDur->sfn = ((nxtDist / cell->numSlots) & (MAX_SFN - 1));
+ nxtOnDur->slot = (nxtDist % cell->numSlots);
}
/**
* @param[in] SchCellCb *cell, SchUeCb *ueCb
* uint8_t delta
*
- * @return
+ * @return void
**/
+
void schDrxUeReCfgTimer(SchCellCb *cell, SchUeCb *ueCb)
{
- uint8_t onDurIndx, currentSlotIndx;
+ uint8_t currentSlotIndx;
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);
- onDurTime = onDurationOccurance.sfn*MAX_SLOTS+onDurationOccurance.slot;
- onDurIndx = onDurTime%MAX_DRX_SIZE;
+ onDurTime = onDurationOccurance.sfn*cell->numSlots+onDurationOccurance.slot;
+
/* If Onduration timer of old configuration is already running then next onduration
* starts once it expires*/
- if((ueCb->drxUeCb.onDurationExpiryDistance != SCH_DRX_INVALID_DISTANCE) && (ueCb->drxUeCb.onDurationExpiryIndex == SCH_DRX_INVALID_INDEX))
+ if((ueCb->drxUeCb.onDurationExpiryDistance != SCH_DRX_INVALID_DISTANCE) && (ueCb->drxUeCb.onDurationExpiryIndex != SCH_DRX_INVALID_INDEX))
{
- currentSlotTime = cell->slotInfo.sfn * MAX_SLOTS + cell->slotInfo.slot;
+ currentSlotTime = cell->slotInfo.sfn * cell->numSlots + cell->slotInfo.slot;
currentSlotIndx = (currentSlotTime + PHY_DELTA_DL + SCHED_DELTA)%MAX_DRX_SIZE;
if(currentSlotIndx >= ueCb->drxUeCb.onDurationExpiryIndex )
{
- onDurExpSlotTime = currentSlotTime + ((ueCb->drxUeCb.onDurationExpiryDistance +1) * MAX_DRX_SIZE) + (ueCb->drxUeCb.onDurationExpiryIndex - currentSlotIndx + PHY_DELTA_DL + SCHED_DELTA);
+ onDurExpSlotTime = currentSlotTime + ((ueCb->drxUeCb.onDurationExpiryDistance +1) * MAX_DRX_SIZE) +\
+ (ueCb->drxUeCb.onDurationExpiryIndex - currentSlotIndx + PHY_DELTA_DL + SCHED_DELTA);
}
else
{
- onDurExpSlotTime = currentSlotTime + ((ueCb->drxUeCb.onDurationExpiryDistance) * MAX_DRX_SIZE) + (ueCb->drxUeCb.onDurationExpiryIndex - currentSlotIndx + PHY_DELTA_DL + SCHED_DELTA);
+ onDurExpSlotTime = currentSlotTime + ((ueCb->drxUeCb.onDurationExpiryDistance) * MAX_DRX_SIZE) +\
+ (ueCb->drxUeCb.onDurationExpiryIndex - currentSlotIndx + PHY_DELTA_DL + SCHED_DELTA);
}
if(onDurTime <= onDurExpSlotTime)
{
onDurTime = onDurTime + ((onDurExpSlotTime - onDurTime)/cycleLen + 1) * cycleLen;
}
}
- onDurIndx = onDurTime%MAX_DRX_SIZE;
- ueCb->drxUeCb.onDurationStartIndex = onDurIndx;
- ueCb->drxUeCb.onDurationStartDistance = SCH_CALC_SLOT_DIFF(onDurationOccurance, cell->slotInfo, MAX_SLOTS)/MAX_DRX_SIZE;
- schAddDrxTimerIntoList(&cell->drxCb[onDurIndx].onDurationStartList, ueCb, ueCb->drxUeCb.onDurationStartNodeInfo);
- if((TRUE == ueCb->drxUeCb.shortCyclePresent) &&(ueCb->drxUeCb.longCycleToBeUsed == false))
- {
- /* Starting Short Cycle Timer */
- ueCb->drxUeCb.shortCycleDistance = (ueCb->drxUeCb.shortCycleTmrLen * ueCb->drxUeCb.shortCycleLen) / MAX_DRX_SIZE;
- ueCb->drxUeCb.shortCycleExpiryIndex = (onDurTime + (ueCb->drxUeCb.shortCycleTmrLen * ueCb->drxUeCb.shortCycleLen)) % MAX_DRX_SIZE;
- schAddDrxTimerIntoList(&cell->drxCb[ ueCb->drxUeCb.shortCycleExpiryIndex].shortCycleExpiryList, ueCb, ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo);
- DU_LOG("\nPBORLA ShortCycleE Added %d",ueCb->drxUeCb.shortCycleExpiryIndex);
- }
+ 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);
}
+
/**
- * @brief Add entry into the on duration list and short cycle list
+ * @brief Add entry into the on duration list
*
* @details
*
- * Function : schAddUeInOndurationAndShortCycleList
+ * Function : schAddUeInOndurationList
*
- * This function is used to Add entry into the on duration list and short
- * cycle list
+ * This function is used to Add entry into the on duration list
*
* @param[in] SchCellCb *cell, SchDrxUeCb *ueDrxCb, SlotTimingInfo *nxtOnDur,
* uint8_t delta
* @return
* -# void
**/
-void schAddUeInOndurationAndShortCycleList(SchCellCb *cell, SchUeCb *ueCb, uint8_t delta)
+
+void schAddUeInOndurationList(SchCellCb *cell, SchUeCb *ueCb, uint8_t delta)
{
- uint8_t onDurIndx;
uint32_t onDurTime;
SlotTimingInfo onDurationOccurance;
if(ueCb->ueDrxInfoPres)
{
findNextOndurationOccurance(cell, &ueCb->drxUeCb, &onDurationOccurance, delta);
- onDurTime = onDurationOccurance.sfn*MAX_SLOTS+onDurationOccurance.slot;
- onDurIndx = onDurTime%MAX_DRX_SIZE;
- ueCb->drxUeCb.onDurationStartIndex = onDurIndx;
- ueCb->drxUeCb.onDurationStartDistance = SCH_CALC_SLOT_DIFF(onDurationOccurance, cell->slotInfo, MAX_SLOTS)/MAX_DRX_SIZE;
- schAddDrxTimerIntoList(&cell->drxCb[onDurIndx].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);
- if((TRUE == ueCb->drxUeCb.shortCyclePresent) &&(ueCb->drxUeCb.longCycleToBeUsed == false))
- {
- /* Starting Short Cycle Timer */
- ueCb->drxUeCb.shortCycleDistance = (ueCb->drxUeCb.shortCycleTmrLen * ueCb->drxUeCb.shortCycleLen) / MAX_DRX_SIZE;
- ueCb->drxUeCb.shortCycleExpiryIndex = (onDurTime + (ueCb->drxUeCb.shortCycleTmrLen * ueCb->drxUeCb.shortCycleLen)) % MAX_DRX_SIZE;
- schAddDrxTimerIntoList(&cell->drxCb[ ueCb->drxUeCb.shortCycleExpiryIndex].shortCycleExpiryList, ueCb, ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo);
- DU_LOG("\nPBORLA ShortCycleE Added %d",ueCb->drxUeCb.shortCycleExpiryIndex);
- }
}
}
+
/**
* @brief Handling of On duration drx start timer
*
* @details
*
- * Function : schHdlDrxOnDurStrtTimerForUlandDlDirection
+ * Function : schHdlDrxOnDurStrtTimerForDlDirection
*
* Handling of On duration drx start timer
*
* -# ROK
* -# RFAILED
**/
-void schHdlDrxOnDurStrtTimerForUlandDlDirection(SchCellCb *cell, uint16_t currListIndx, bool isDlDirection)
+
+void schHdlDrxOnDurStrtTimerForDlDirection(SchCellCb *cell, uint16_t currListIndx)
{
uint16_t onDurationExpiry=0;
CmLList *drxCurrNode = NULLP;
while(drxCurrNode)
{
ueCb = (SchUeCb*)drxCurrNode->node;
+ drxCurrNode = drxCurrNode->next;
+
ueCb->drxUeCb.onDurationStartDistance--;
+
if(ueCb->drxUeCb.onDurationStartDistance != SCH_DRX_INVALID_DISTANCE)
{
continue;
}
else
{
- if(isDlDirection == true)
- ueCb->drxUeCb.drxDlUeActiveStatus = true;
- else
- ueCb->drxUeCb.drxUlUeActiveStatus = true;
-
- DU_LOG("\nPBORLA drxUeCb.drxUlUeActiveStatus drxUeCb.drxDlUeActiveStatus [%d:%d] line %d", ueCb->drxUeCb.drxUlUeActiveStatus, ueCb->drxUeCb.drxDlUeActiveStatus,__LINE__);
-
+ 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 time and add it to list */
- if(ueCb->drxUeCb.onDurationExpiryIndex != SCH_DRX_INVALID_INDEX)
+ 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*/
ueCb->drxUeCb.onDurationExpiryDistance = (ueCb->drxUeCb.onDurationLen)/MAX_DRX_SIZE;
schAddDrxTimerIntoList(&cell->drxCb[onDurationExpiry].onDurationExpiryList, ueCb, ueCb->drxUeCb.onDurationExpiryNodeInfo);
ueCb->drxUeCb.onDurationExpiryIndex = onDurationExpiry;
-
- /* if there is any entry present in onduration list remove the entry from the list */
- DU_LOG("\nPBORLA ONDURATION START HIT %d %d startIndx %d [%d %d]",\
- currListIndx, ueCb->drxUeCb.onDurationStartDistance,ueCb->drxUeCb.onDurationStartIndex, cell->slotInfo.sfn,cell->slotInfo.slot);
- cmLListDelFrm(&cell->drxCb[currListIndx].onDurationStartList, ueCb->drxUeCb.onDurationStartNodeInfo);
- SCH_FREE(ueCb->drxUeCb.onDurationStartNodeInfo, sizeof(CmLList));
- ueCb->drxUeCb.onDurationStartIndex = SCH_DRX_INVALID_INDEX;
- /* if there long cycle length is used as the cycle length for onduration calculation then based on that calculating next onduration occurance
- * other wise next onduration is calcuated based on short cycle
- * timer */
- if(ueCb->drxUeCb.longCycleToBeUsed)
- {
- schAddUeInOndurationAndShortCycleList(cell, ueCb, 0);
- }
+
}
- drxCurrNode = drxCurrNode->next;
}
}
}
+
/**
* @brief Handling of On duration drx start timer
*
* @details
*
- * Function : schHdlDrxOnDurStrtTimer
+ * Function : schHdlDrxOnDurStrtTimerForUlDirection
*
* Handling of On duration drx start timer
*
* -# ROK
* -# RFAILED
**/
-void schHdlDrxOnDurStrtTimer(SchCellCb *cell)
+
+void schHdlDrxOnDurStrtTimerForUlDirection(SchCellCb *cell, uint16_t currListIndx)
{
- uint16_t dlIndx = 0, ulIndx=0;
- SlotTimingInfo dlSlotInfo, ulSlotInfo;
+ uint16_t onDurTime=0;
+ CmLList *drxCurrNode = NULLP;
+ SchUeCb *ueCb = NULLP;
- ADD_DELTA_TO_TIME(cell->slotInfo, dlSlotInfo, PHY_DELTA_DL + SCHED_DELTA);
- ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA);
-
- dlIndx = (dlSlotInfo.sfn*MAX_SLOTS+dlSlotInfo.slot)%MAX_DRX_SIZE;
- ulIndx = (ulSlotInfo.sfn*MAX_SLOTS+ulSlotInfo.slot)%MAX_DRX_SIZE;
- schHdlDrxOnDurStrtTimerForUlandDlDirection(cell, dlIndx, true);
- schHdlDrxOnDurStrtTimerForUlandDlDirection(cell, ulIndx, false);
+ 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.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));
+ 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 short cycle drx start timer
+ * @brief Handling of On duration drx start timer
*
* @details
*
- * Function : schHdlDrxStartShortCycleTimer
+ * Function : schHdlDrxOnDurStrtTimer
*
- * Handling of short cycle drx start timer
+ * Handling of On duration drx start timer
*
* @param[in] SchCellCb *cell
* @return
* -# ROK
* -# RFAILED
**/
- void schHdlDrxStartShortCycleTimer(SchCellCb *cell, SchUeCb *ueCb)
- {
- ueCb->drxUeCb.longCycleToBeUsed = false;
- schAddUeInOndurationAndShortCycleList(cell, ueCb, PHY_DELTA_DL + SCHED_DELTA + SCH_DRX_TMRS_EXP_DELTA);
- }
+
+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 inactv timers start
+ * @brief Handling of the DRX in-active start timer
*
* @details
*
- * Function : schHdlDrxInActvStrtTmr
+ * Function :
*
- * Handling of DRX in active timers start
+ * 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);
- slotIndx = (tmpSlotInfo.sfn*MAX_SLOTS+tmpSlotInfo.slot)%MAX_DRX_SIZE;
- DU_LOG("\nPBORLA IN ACTV START HIT %d %d", cell->slotInfo.sfn, cell->slotInfo.slot);
- /* if there is nay old entry present in the list 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);
+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;
+ }
- /* Set the UE active for UL And Dl transfer */
- ueCb->drxUeCb.drxDlUeActiveStatus = true;
- ueCb->drxUeCb.drxUlUeActiveStatus = true;
- DU_LOG("\nPBORLA drxUeCb.drxUlUeActiveStatus drxUeCb.drxDlUeActiveStatus [%d:%d] line %d", ueCb->drxUeCb.drxUlUeActiveStatus, ueCb->drxUeCb.drxDlUeActiveStatus,__LINE__);
+ /* 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.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 timea*/
- 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 ShortCycle DRX timers
+ * @brief Handling of the Dl harq DRX timers start for Dl scheduling
*
* @details
*
- * Function : schHdlDrxShortCycleExpiryTimerForUlandDlDirection
+ * Function : schHdlDlHqRetxStrtTimerForDl
*
- * Handling of expiry ShortCycle
+ * 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 schHdlDrxShortCycleExpiryTimerForUlandDlDirection(SchCellCb *cell, uint16_t currListIndx, bool isDlDirection)
+ * void
+**/
+
+void schHdlDlHqRetxStrtTimerForDl(SchCellCb *cell, uint16_t currIndx)
{
- CmLList *drxCurrNode = NULLP;
- SchUeCb *ueCb = NULLP;
- SchUeCb *tempUeCb = NULLP;
-
- drxCurrNode = cell->drxCb[currListIndx].shortCycleExpiryList.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;
+ addUeToBeScheduled(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;
- if(ueCb->ueDrxInfoPres)
- {
- if(ueCb->drxUeCb.shortCycleDistance != SCH_DRX_INVALID_DISTANCE)
- ueCb->drxUeCb.shortCycleDistance--;
-
- if(ueCb->drxUeCb.shortCycleDistance== SCH_DRX_INVALID_DISTANCE)
- {
- DU_LOG("\nPBORLA ShortCycleE EXP HIT %d",currListIndx);
- ueCb->drxUeCb.longCycleToBeUsed = true;
- /* Remove Short Cycle timer from the list */
- cmLListDelFrm(&cell->drxCb[currListIndx].shortCycleExpiryList, ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo);
- SCH_FREE(ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo, sizeof(CmLList));
- ueCb->drxUeCb.shortCycleExpiryIndex = SCH_DRX_INVALID_INDEX;
-
- /* calculating the next duration event
- If another entry is found in the On duration list, it must first be removed
- before the next On duration occurrences may be calculated */
- 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));
- tempUeCb->drxUeCb.onDurationStartDistance = SCH_DRX_INVALID_DISTANCE;
- tempUeCb->drxUeCb.onDurationStartIndex = SCH_DRX_INVALID_INDEX;
- }
- if(isDlDirection == true)
- schAddUeInOndurationAndShortCycleList(cell, ueCb, PHY_DELTA_DL + SCHED_DELTA + SCH_DRX_TMRS_EXP_DELTA);
- else
- schAddUeInOndurationAndShortCycleList(cell, ueCb, PHY_DELTA_UL + SCHED_DELTA + SCH_DRX_TMRS_EXP_DELTA);
-
- }
- else
- continue;
- }
- drxCurrNode = drxCurrNode->next;
+ 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 ShortCycle DRX timers
+ * @brief Handling of the Dl harq DRX timers start for Ul scheduling
*
* @details
*
- * Function :schHdlDrxShortCycleExpiryTimer
+ * Function : schHdlDlHqRetxStrtTimerForUl
*
- * Handling of expiry ShortCycle
+ * 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 schHdlDrxShortCycleExpiryTimer(SchCellCb *cell)
+
+void schHdlDlHqRetxStrtTimerForUl(SchCellCb *cell, uint16_t currIndx)
{
- uint16_t dlIndx = 0, ulIndx= 0;
+ CmLList *currNode;
+ SchDlHqProcCb *hqP;
+ SchUeCb *ueCb;
+
+ currNode = cell->drxCb[currIndx].dlRetransTmrStartList.first;
+
+ while(currNode)
+ {
+ 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 Dl harq DRX timers start
+ *
+ * @details
+ *
+ * Function : schHdlDrxDlHqRetxStrtTimer
+ *
+ * Handling of Dl harq DRX timers start
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+void schHdlDrxDlHqRetxStrtTimer(SchCellCb *cell)
+{
+ uint16_t dlIndx = 0, ulIndx=0;
SlotTimingInfo dlSlotInfo, ulSlotInfo;
- ADD_DELTA_TO_TIME(cell->slotInfo, dlSlotInfo, PHY_DELTA_DL + SCHED_DELTA + SCH_DRX_TMRS_EXP_DELTA);
- ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA + SCH_DRX_TMRS_EXP_DELTA);
+ 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;
+
+ schHdlDlHqRetxStrtTimerForDl(cell, dlIndx);
+ schHdlDlHqRetxStrtTimerForUl(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);
+ schHdlDrxDlHqRetxStrtTimer(cell);
+ schHdlDrxUlHqRetxStrtTimer(cell);
+}
+
+/**
+ * @brief Handling of the Dl harq Rtt start DRX timers
+ *
+ * @details
+ *
+ * Function : schDrxStrtDlHqRttTmr
+ *
+ * Handling of the Dl harq Rtt start DRX timers
+ *
+ * @param[in] SchCellCb *cell
+ * @return
+ * -# ROK
+ * -# RFAILED
+ **/
+
+void schDrxStrtDlHqRttTmr(SchDlHqProcCb *hqP)
+{
+ uint16_t harqRttExpTimer=0;
+ SchDrxUeCb *drxUeCb;
+
+ drxUeCb = &hqP->hqEnt->ue->drxUeCb;
- schHdlDrxShortCycleExpiryTimerForUlandDlDirection(cell, dlIndx, true);
- schHdlDrxShortCycleExpiryTimerForUlandDlDirection(cell, ulIndx, false);
+ 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);
}
/**
- * @brief Handling of the expiry onduration DRX timers for specific direction
+ * @brief Handling of the Ul harq DRX timers start for Dl scheduling
*
* @details
*
- * Function :schHdlDrxOnDurExpiryTimerForUlandDlDirection
+ * Function : schHdlUlHqRetxStrtTimerForDl
*
- * Handling of expiry onduration DRX timers
+ * 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)
+ {
+ hqP = (SchUlHqProcCb*)currNode->node;
+ currNode = currNode->next;
+ addUeToBeScheduled(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)
+ {
+ 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);
+ }
+}
+
+/**
+ * @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 schHdlDrxOnDurExpiryTimerForUlandDlDirection(SchCellCb *cell, uint16_t currListIndx, bool isDlDirection)
+
+void schHdlDrxOnDurExpiryTimerForDlDirection(SchCellCb *cell, uint16_t currListIndx)
{
CmLList *drxCurrNode;
SchUeCb *ueCb = NULLP;
while(drxCurrNode)
{
ueCb = (SchUeCb*)drxCurrNode->node;
- if(ueCb->ueDrxInfoPres)
+ drxCurrNode = drxCurrNode->next;
+
+ ueCb->drxUeCb.onDurationExpiryDistance--;
+
+ if(ueCb->drxUeCb.onDurationExpiryDistance != SCH_DRX_INVALID_DISTANCE)
{
- ueCb->drxUeCb.onDurationExpiryDistance--;
+ continue;
+ }
+ ueCb->drxUeCb.drxDlUeActiveMask &= ~UE_ACTIVE_FOR_ONDURATION;
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
+ }
+ }
+}
- if(ueCb->drxUeCb.onDurationExpiryDistance== SCH_DRX_INVALID_DISTANCE)
- {
+/**
+ * @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
+ **/
- DU_LOG("\nPBORLA ONDURATION EXP HIT %d[%d:%d]",currListIndx, cell->slotInfo.sfn, cell->slotInfo.slot);
-
- /* delete on duration expiry timer from ueCb */
- if(drxCurrNode->node)
- {
- cmLListDelFrm(&cell->drxCb[currListIndx].onDurationExpiryList, ueCb->drxUeCb.onDurationExpiryNodeInfo);
- SCH_FREE(ueCb->drxUeCb.onDurationExpiryNodeInfo, sizeof(CmLList));
- ueCb->drxUeCb.onDurationExpiryIndex = SCH_DRX_INVALID_INDEX;
- }
- if(isDlDirection == true)
- ueCb->drxUeCb.drxDlUeActiveStatus = false;
- else
- ueCb->drxUeCb.drxUlUeActiveStatus = false;
- DU_LOG("\nPBORLA drxUeCb.drxUlUeActiveStatus drxUeCb.drxDlUeActiveStatus [%d:%d] line %d", ueCb->drxUeCb.drxUlUeActiveStatus, ueCb->drxUeCb.drxDlUeActiveStatus,__LINE__);
- }
- else
- continue;
- }
+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
+ * Function : schHdlDrxOnDurExpiryTimer
*
* Handling of expiry onduration DRX timers
*
* -# 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 + SCH_DRX_TMRS_EXP_DELTA);
- ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA + SCH_DRX_TMRS_EXP_DELTA);
+ 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;
-
- schHdlDrxOnDurExpiryTimerForUlandDlDirection(cell, dlIndx, true);
- schHdlDrxOnDurExpiryTimerForUlandDlDirection(cell, ulIndx, false);
+
+ schHdlDrxOnDurExpiryTimerForDlDirection(cell, dlIndx);
+ schHdlDrxOnDurExpiryTimerForUlDirection(cell, ulIndx);
}
+
/**
- * @brief Handling of the expiry in active DRX timers in Dl and Ul direction
+ * @brief Handling of the expiry of in-active DRX timers in Dl
*
* @details
*
- * Function : schHdlDrxInActvExpiryTimerForUlandDlDirection
+ * Function : schHdlDrxInActvExpiryTimerForDlDirection
*
- * Handling of expiry in active DRX timers in DLand Ul direction
+ * Handling of expiry of in-active DRX timers at Dl index
*
- * @param[in] SchCellCb *cell, uint16_t dlIndx
+ * @param[in] SchCellCb *cell, uint16_t dlIndx
* @return
* -# ROK
* -# RFAILED
**/
-void schHdlDrxInActvExpiryTimerForUlandDlDirection(SchCellCb *cell, uint16_t listIndx, bool isDlDirection)
+
+void schHdlDrxInActvExpiryTimerForDlDirection(SchCellCb *cell, uint16_t dlIndx)
{
CmLList *drxNode;
SchUeCb *ueCb = NULLP;
- drxNode = cell->drxCb[listIndx].inActvTmrExpiryList.first;
+ 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)
- {
- DU_LOG("\nPBORLA IN ACTV EXP HIT %d[%d:%d]",listIndx, cell->slotInfo.sfn, cell->slotInfo.slot);
- /*Delete the current entry from list */
- if(drxNode->node)
- {
- cmLListDelFrm(&cell->drxCb[listIndx].inActvTmrExpiryList, ueCb->drxUeCb.inActvTimerExpiryNodeInfo);
- SCH_FREE(ueCb->drxUeCb.inActvTimerExpiryNodeInfo, sizeof(CmLList));
- ueCb->drxUeCb.inActvExpiryIndex = SCH_DRX_INVALID_INDEX;
- }
+ if(ueCb->drxUeCb.onDurationExpiryDistance != SCH_DRX_INVALID_DISTANCE)
+ {
+ continue;
+ }
+
+ ueCb->drxUeCb.drxDlUeActiveMask &= ~UE_ACTIVE_FOR_INACTIVE_TIMER;
+ setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
+ }
+ }
+}
- /* If short cycle is configured then start the short cycle timer */
- if(ueCb->drxUeCb.shortCyclePresent)
- {
- schHdlDrxStartShortCycleTimer(cell, ueCb);
- }
- else
- {
- ueCb->drxUeCb.longCycleToBeUsed = true;
- }
- /* Set the drx ue status as inactive once the in active timer gets
- * expire */
- if(isDlDirection == true)
- ueCb->drxUeCb.drxDlUeActiveStatus = false;
- else
- ueCb->drxUeCb.drxUlUeActiveStatus = false;
- DU_LOG("\nPBORLA drxUeCb.drxUlUeActiveStatus drxUeCb.drxDlUeActiveStatus [%d:%d] line %d", ueCb->drxUeCb.drxUlUeActiveStatus, ueCb->drxUeCb.drxDlUeActiveStatus,__LINE__);
+/**
+ * @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
+ **/
- }
- else
- continue;
+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.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);
+ 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 in active DRX timers
+ * @brief Handling of the expiry of in-active DRX timers
*
* @details
*
- * Function :schHdlDrxInActvExpiryTimer
+ * Function :schHdlDrxInActvExpiryTimer
*
- * Handling of expiry in active DRX timers
+ * 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 + SCH_DRX_TMRS_EXP_DELTA);
- ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA + SCH_DRX_TMRS_EXP_DELTA);
+ 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;
-
- schHdlDrxInActvExpiryTimerForUlandDlDirection(cell, dlIndx, true);
- schHdlDrxInActvExpiryTimerForUlandDlDirection(cell, ulIndx, false);
-}/**
- * @brief Handling of the expiry DRX timers
+
+ schHdlDrxInActvExpiryTimerForDlDirection(cell, dlIndx);
+ schHdlDrxInActvExpiryTimerForUlDirection(cell, ulIndx);
+}
+
+/**
+ * @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 */
- schHdlDrxShortCycleExpiryTimer(cell);
- schHdlDrxOnDurExpiryTimer(cell);
- schHdlDrxInActvExpiryTimer(cell);
-}
+ 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
/**********************************************************************
Code Review / o-du / l2.git / blobdiff