X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrsch%2Fsch_drx.c;h=4eb815ac8c36eb0844a01eadfc3d9a578326cf5d;hb=ebe7300f91cb53117193fbec021b423013d1d6ef;hp=bcff9a0ccb347d6c0a72dfc531fccb1ec2616159;hpb=aae1fb8fd1e149a7b3a6a6ca799c56aceadc6184;p=o-du%2Fl2.git diff --git a/src/5gnrsch/sch_drx.c b/src/5gnrsch/sch_drx.c index bcff9a0cc..4eb815ac8 100644 --- a/src/5gnrsch/sch_drx.c +++ b/src/5gnrsch/sch_drx.c @@ -29,6 +29,42 @@ #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 * @@ -47,10 +83,9 @@ 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; } /** @@ -78,12 +113,8 @@ void schInitDrxUeCb(SchUeCb *ueCb) 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 * @@ -98,43 +129,37 @@ void schInitDrxUeCb(SchUeCb *ueCb) * -# 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; idxprocs[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; idxprocs[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 @@ -149,45 +174,38 @@ void schInitDrxUeCb(SchUeCb *ueCb) * @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; idxprocs[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; idxprocs[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 @@ -238,9 +256,9 @@ void schDeleteUeDrxInfo(SchCellCb *cell, SchUeCb *ueCb) 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); } } @@ -306,7 +324,43 @@ void schFillDrxUeCb(uint8_t numerology, SchDrxCfg drxCfg, SchDrxUeCb *drxUeCb) * -# 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; @@ -320,8 +374,9 @@ uint8_t schAddDrxTimerIntoList(CmLListCp *drxTimerList,void * nodeInfo, CmLList currentNodeInfo->node = (PTR)nodeInfo; cmLListAdd2Tail(drxTimerList, currentNodeInfo); - drxNodeInfo = currentNodeInfo; + (*drxNodeInfo) = currentNodeInfo; DU_LOG("\nINFO --> SCH : Drx node added into the list"); + return ROK; } @@ -484,7 +539,7 @@ void schDrxUeReCfgTimer(SchCellCb *cell, SchUeCb *ueCb) } 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); } /** @@ -514,7 +569,7 @@ void schAddUeInOndurationList(SchCellCb *cell, SchUeCb *ueCb, uint8_t delta) 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); } } @@ -557,7 +612,10 @@ void schHdlDrxOnDurStrtTimerForDlDirection(SchCellCb *cell, uint16_t currListIn } 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 @@ -573,7 +631,7 @@ void schHdlDrxOnDurStrtTimerForDlDirection(SchCellCb *cell, uint16_t currListIn /* 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; } @@ -615,9 +673,10 @@ void schHdlDrxOnDurStrtTimerForUlDirection(SchCellCb *cell, uint16_t currListIn { 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)); @@ -633,7 +692,7 @@ void schHdlDrxOnDurStrtTimerForUlDirection(SchCellCb *cell, uint16_t currListIn } 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); } } } @@ -652,6 +711,7 @@ void schHdlDrxOnDurStrtTimerForUlDirection(SchCellCb *cell, uint16_t currListIn * -# ROK * -# RFAILED **/ + void schHdlDrxOnDurStrtTimer(SchCellCb *cell) { uint16_t dlIndx = 0, ulIndx=0; @@ -706,215 +766,553 @@ void schHdlDrxInActvStrtTmr(SchCellCb *cell, SchUeCb *ueCb, uint8_t delta) /* 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); @@ -924,7 +1322,7 @@ void schHdlDrxInActvExpiryTimerForUlDirection(SchCellCb *cell, uint16_t ulIndx) if(ueCb->drxUeCb.shortCyclePresent) { /* Start short cycle timer */ - /* TODO Will implement this in next gerrit */ + schHdlDrxStartShortCycleTimer(cell, ueCb); } } } @@ -944,6 +1342,7 @@ void schHdlDrxInActvExpiryTimerForUlDirection(SchCellCb *cell, uint16_t ulIndx) * -# ROK * -# RFAILED **/ + void schHdlDrxInActvExpiryTimer(SchCellCb *cell) { uint16_t dlIndx = 0, ulIndx = 0; @@ -959,24 +1358,601 @@ void schHdlDrxInActvExpiryTimer(SchCellCb *cell) } /** - * @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