2 /*******************************************************************************
3 ################################################################################
4 # Copyright (c) [2017-2019] [Radisys] #
6 # Licensed under the Apache License, Version 2.0 (the "License"); #
7 # you may not use this file except in compliance with the License. #
8 # You may obtain a copy of the License at #
10 # http://www.apache.org/licenses/LICENSE-2.0 #
12 # Unless required by applicable law or agreed to in writing, software #
13 # distributed under the License is distributed on an "AS IS" BASIS, #
14 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
15 # See the License for the specific language governing permissions and #
16 # limitations under the License. #
17 ################################################################################
18 *******************************************************************************/
20 #include "common_def.h"
26 #include "du_app_mac_inf.h"
27 #include "mac_sch_interface.h"
29 #include "sch_utils.h"
33 * @brief set the final Ue drx status
37 * Function : setDrxUeStatusForDlandUl
39 * set the final Ue drx status to active or inactive
41 * @param[in] SchDrxUeCb *drxUeCb
46 void setDrxUeStatusForDlandUl(SchDrxUeCb *drxUeCb)
48 /* Setting the Dl Ue status */
49 if(drxUeCb->drxDlUeActiveMask || drxUeCb->drxDlUeActiveMaskForHarq)
51 drxUeCb->drxDlUeActiveStatus = true;
55 drxUeCb->drxDlUeActiveStatus = false;
57 /* Setting the Ul Ue status */
58 if(drxUeCb->drxUlUeActiveMask || drxUeCb->drxUlUeActiveMaskForHarq)
60 drxUeCb->drxUlUeActiveStatus = true;
64 drxUeCb->drxUlUeActiveStatus = false;
69 * @brief intialize the SchDrxHarqCb structre
73 * Function :schInitDrxHarqCb
75 * intialize the SchDrxHarqCb structre
77 * @param[in] SchDrxHarqCb *hqCb
83 void schInitDrxHarqCb(SchDrxHarqCb *hqDrxCb)
85 memset(hqDrxCb, 0, sizeof(SchDrxHarqCb));
86 hqDrxCb->retxStrtIndex = SCH_DRX_INVALID_INDEX;
87 hqDrxCb->rttExpIndex = SCH_DRX_INVALID_INDEX;
88 hqDrxCb->retxExpIndex = SCH_DRX_INVALID_INDEX;
92 * @brief intialize the SchDrxUeCb structre
96 * Function : schInitDrxUeCb
98 * intialize the SchDrxUeCb structre
100 * @param[in] SchUeCb *ueCb
106 void schInitDrxUeCb(SchUeCb *ueCb)
108 memset(&ueCb->drxUeCb, 0, sizeof(SchDrxUeCb));
109 ueCb->drxUeCb.onDurationStartIndex = SCH_DRX_INVALID_INDEX;
110 ueCb->drxUeCb.onDurationExpiryIndex = SCH_DRX_INVALID_INDEX;
111 ueCb->drxUeCb.inActvExpiryIndex = SCH_DRX_INVALID_INDEX;
112 ueCb->drxUeCb.shortCycleExpiryIndex = SCH_DRX_INVALID_INDEX;
113 ueCb->drxUeCb.onDurationStartDistance = SCH_DRX_INVALID_DISTANCE;
114 ueCb->drxUeCb.onDurationExpiryDistance = SCH_DRX_INVALID_DISTANCE;
115 ueCb->drxUeCb.inActiveTmrExpiryDistance = SCH_DRX_INVALID_DISTANCE;
119 * @brief delete Dl harq drx timers and information
123 * Function : schDeleteDlHarqDrxTimer
125 * delete Dl harq drx timers and information
127 * @param[in] SchCellCb *cell, SchUeCb *ueCb
133 void schDeleteDlHarqDrxTimer(SchCellCb *cell, SchDlHqEnt *dlHqEnt)
135 uint8_t idx, numHqPrcs;
136 SchDlHqProcCb *dlProc;
138 numHqPrcs = dlHqEnt->numHqPrcs;
139 for(idx =0; idx<numHqPrcs; idx++)
141 dlProc = &dlHqEnt->procs[idx];
143 if(dlProc->dlDrxHarqCb.retxStrtIndex != SCH_DRX_INVALID_INDEX)
145 cmLListDelFrm(&cell->drxCb[dlProc->dlDrxHarqCb.retxStrtIndex].dlRetransTmrStartList, dlProc->dlDrxHarqCb.retxStrtNode);
146 SCH_FREE(dlProc->dlDrxHarqCb.retxStrtNode, sizeof(CmLList));
149 if(dlProc->dlDrxHarqCb.rttExpIndex != SCH_DRX_INVALID_INDEX)
151 cmLListDelFrm(&cell->drxCb[dlProc->dlDrxHarqCb.rttExpIndex ].dlHarqRttExpiryList, dlProc->dlDrxHarqCb.rttExpNode);
152 SCH_FREE(dlProc->dlDrxHarqCb.rttExpNode, sizeof(CmLList));
155 if(dlProc->dlDrxHarqCb.retxExpIndex != SCH_DRX_INVALID_INDEX)
157 cmLListDelFrm(&cell->drxCb[dlProc->dlDrxHarqCb.retxExpIndex].dlRetransExpiryList, dlProc->dlDrxHarqCb.retxExpNode);
158 SCH_FREE(dlProc->dlDrxHarqCb.retxExpNode, sizeof(CmLList));
160 schInitDrxHarqCb(&dlProc->dlDrxHarqCb);
165 * @brief delete UL harq drx timers and information
169 * Function : schDeleteUlHarqDrxTimer
171 * delete Ul harq drx timers and information
173 * @param[in] SchCellCb *cell, SchUeCb *ueCb
179 void schDeleteUlHarqDrxTimer(SchCellCb *cell, SchUlHqEnt *ulHqEnt)
181 uint8_t idx, numHqPrcs;
182 SchUlHqProcCb *ulProc;
184 numHqPrcs = ulHqEnt->numHqPrcs;
185 for(idx =0; idx<numHqPrcs; idx++)
187 ulProc = &ulHqEnt->procs[idx];
189 if(ulProc->ulDrxHarqCb.retxStrtIndex != SCH_DRX_INVALID_INDEX)
191 cmLListDelFrm(&cell->drxCb[ulProc->ulDrxHarqCb.retxStrtIndex].ulRetransTmrStartList, ulProc->ulDrxHarqCb.retxStrtNode);
192 SCH_FREE(ulProc->ulDrxHarqCb.retxStrtNode, sizeof(CmLList));
195 if(ulProc->ulDrxHarqCb.rttExpIndex != SCH_DRX_INVALID_INDEX)
197 cmLListDelFrm(&cell->drxCb[ulProc->ulDrxHarqCb.rttExpIndex ].ulHarqRttExpiryList, ulProc->ulDrxHarqCb.rttExpNode);
198 SCH_FREE(ulProc->ulDrxHarqCb.rttExpNode, sizeof(CmLList));
201 if(ulProc->ulDrxHarqCb.retxExpIndex != SCH_DRX_INVALID_INDEX)
203 cmLListDelFrm(&cell->drxCb[ulProc->ulDrxHarqCb.retxExpIndex].ulRetransExpiryList, ulProc->ulDrxHarqCb.retxExpNode);
204 SCH_FREE(ulProc->ulDrxHarqCb.retxExpNode, sizeof(CmLList));
206 schInitDrxHarqCb(&ulProc->ulDrxHarqCb);
211 * @brief delete UE drx timers and information
215 * Function : schDeleteUeDrxInfo
217 * delete UE drx timers and information
219 * @param[in] SchCellCb *cell, SchUeCb *ueCb
224 void schDeleteUeDrxInfo(SchCellCb *cell, SchUeCb *ueCb)
228 if(ueCb->ueDrxInfoPres == true)
230 drxUeCb = &ueCb->drxUeCb;
232 /* delete on duration start timer from ueCb */
233 if(drxUeCb->onDurationStartIndex != SCH_DRX_INVALID_INDEX)
235 cmLListDelFrm(&cell->drxCb[drxUeCb->onDurationStartIndex].onDurationStartList, drxUeCb->onDurationStartNodeInfo);
236 SCH_FREE(drxUeCb->onDurationStartNodeInfo, sizeof(CmLList));
239 /* delete on duration expiry timer from ueCb */
240 if(drxUeCb->onDurationExpiryIndex != SCH_DRX_INVALID_INDEX)
242 cmLListDelFrm(&cell->drxCb[drxUeCb->onDurationExpiryIndex].onDurationExpiryList, drxUeCb->onDurationExpiryNodeInfo);
243 SCH_FREE(drxUeCb->onDurationExpiryNodeInfo, sizeof(CmLList));
246 /* delete inActv Expiry Index timer from ueCb */
247 if(drxUeCb->inActvExpiryIndex != SCH_DRX_INVALID_INDEX)
249 cmLListDelFrm(&cell->drxCb[drxUeCb->inActvExpiryIndex].inActvTmrExpiryList, drxUeCb->inActvTimerExpiryNodeInfo);
250 SCH_FREE(drxUeCb->inActvTimerExpiryNodeInfo, sizeof(CmLList));
253 /* delete short cycle expiry timer from ueCb */
254 if(drxUeCb->shortCycleExpiryIndex != SCH_DRX_INVALID_INDEX)
256 cmLListDelFrm(&cell->drxCb[drxUeCb->shortCycleExpiryIndex].shortCycleExpiryList, drxUeCb->shortCycleTmrExpiryNodeInfo);
257 SCH_FREE(drxUeCb->shortCycleTmrExpiryNodeInfo, sizeof(CmLList));
260 schDeleteDlHarqDrxTimer(cell, &ueCb->dlHqEnt);
261 schDeleteUlHarqDrxTimer(cell, &ueCb->ulHqEnt);
262 schInitDrxUeCb(ueCb);
267 * @brief fill drxUeCb structure with the help of ue cfg/recfg information
271 * Function : schFillDrxUeCb
273 * fill drxUeCb structure with the help of ue cfg/recfg information
275 * @param[in] SchDrxCfg drxCfg ->configuration received from ue cfg/recfg api
276 * SchDrxUeCb *drxUeCb -> structure that need to be fill
282 void schFillDrxUeCb(uint8_t numerology, SchDrxCfg drxCfg, SchDrxUeCb *drxUeCb)
284 if(drxCfg.drxOnDurationTimer.onDurationTimerValInMs)
286 SCH_CNVRT_MS_TO_SLOT(drxUeCb->onDurationLen, drxCfg.drxOnDurationTimer.onDurationtimerValue.milliSeconds, numerology);
290 SCH_CNVRT_MS_TO_SLOT(drxUeCb->onDurationLen, drxCfg.drxOnDurationTimer.onDurationtimerValue.subMilliSeconds, numerology);
291 drxUeCb->onDurationLen = drxUeCb->onDurationLen >> 5;
293 SCH_CNVRT_MS_TO_SLOT(drxUeCb->inActvTimerLen, drxCfg.drxInactivityTimer, numerology);
294 SCH_CNVRT_SYMBL_TO_SLOT(drxUeCb->harqRttDlTimerLen, drxCfg.drxHarqRttTimerDl);
295 SCH_CNVRT_SYMBL_TO_SLOT(drxUeCb->harqRttUlTimerLen, drxCfg.drxHarqRttTimerUl);
296 drxUeCb->retransDlTimerLen = drxCfg.drxRetransmissionTimerDl;
297 drxUeCb->retransUlTimerLen = drxCfg.drxRetransmissionTimerUl;
298 SCH_CNVRT_MS_TO_SLOT(drxUeCb->longCycleLen, drxCfg.drxLongCycleStartOffset.drxLongCycleStartOffsetChoice, numerology);
299 SCH_CNVRT_MS_TO_SLOT(drxUeCb->drxStartOffset, drxCfg.drxLongCycleStartOffset.drxLongCycleStartOffsetVal, numerology);
300 if(drxCfg.shortDrxPres)
302 drxUeCb->shortCyclePresent = true;
303 SCH_CNVRT_MS_TO_SLOT(drxUeCb->shortCycleLen, drxCfg.shortDrx.drxShortCycle, numerology);
304 drxUeCb->shortCycleTmrLen = drxUeCb->shortCycleLen*drxCfg.shortDrx.drxShortCycleTimer;
306 drxUeCb->longCycleToBeUsed = true;
307 SCH_CNVRT_MS_TO_SLOT(drxUeCb->drxSlotOffset, drxCfg.drxSlotOffset, numerology);
308 drxUeCb->drxSlotOffset = drxUeCb->drxSlotOffset>>5;
312 * @brief Add new entry into the drx timer list
316 * Function : schAddDrxTimerIntoList
318 * Add new entry into the drx timer list
320 * @param[in] CmLListCp *drxTimerList -> List in which new entery have to add
321 * void * ueInfo -> ue information which is need to the added into list
327 uint8_t schAddDrxTimerIntoList(CmLListCp *drxTimerList,void * nodeInfo, CmLList **drxNodeInfo)
329 CmLList *currentNodeInfo = NULLP;
331 SCH_ALLOC(currentNodeInfo, sizeof(CmLList));
334 DU_LOG("\nERROR --> SCH : schAddDrxTimerIntoList() : Memory allocation failed");
338 currentNodeInfo->node = (PTR)nodeInfo;
340 cmLListAdd2Tail(drxTimerList, currentNodeInfo);
341 (*drxNodeInfo) = currentNodeInfo;
342 DU_LOG("\nINFO --> SCH : Drx node added into the list");
347 * @brief Add new entry into the drx harq timer list
351 * Function : schAddDrxNodeIntoHarqTimerList
353 * Add new entry into the drx harq timer list
355 * @param[in] CmLListCp *drxTimerList -> List in which new entery have to add
356 * void * nodeInfo-> ue information which is need to the added into list
357 * CmLList **drxNodeInfo -> pointer to the node
363 uint8_t schAddDrxNodeIntoHarqTimerList(CmLListCp *drxTimerList,void * nodeInfo, CmLList **drxNodeInfo)
365 CmLList *currentNodeInfo = NULLP;
367 SCH_ALLOC(currentNodeInfo, sizeof(CmLList));
370 DU_LOG("\nERROR --> SCH : schAddDrxTimerIntoList() : Memory allocation failed");
374 currentNodeInfo->node = (PTR)nodeInfo;
376 cmLListAdd2Tail(drxTimerList, currentNodeInfo);
377 (*drxNodeInfo) = currentNodeInfo;
378 DU_LOG("\nINFO --> SCH : Drx node added into the list");
384 * @brief This function is used to find the next onduration start timing
388 * Function : findNextOndurationOccurance
390 * This function is used to find the next onduration start timing
392 * @param[in] SchCellCb *cell, SchDrxUeCb *ueDrxCb, SlotTimingInfo *nxtOnDur,
399 void findNextOndurationOccurance(SchCellCb *cell, SchDrxUeCb *ueDrxCb, SlotTimingInfo *nxtOnDur, uint8_t delta)
401 uint16_t tmpDistance, numOfCycles;
402 uint32_t curTime, cycleLen, nxtDist;
403 SlotTimingInfo tmpTime;
405 if (ueDrxCb->longCycleToBeUsed == true)
407 cycleLen = ueDrxCb->longCycleLen;
411 cycleLen = ueDrxCb->shortCycleLen;
414 /* Add delta to current time */
415 ADD_DELTA_TO_TIME(cell->slotInfo, tmpTime, delta, cell->numSlots);
417 /* Convert tmpTime to number of slots */
418 curTime = ((tmpTime.sfn * cell->numSlots) + tmpTime.slot);
420 /* as per 38.321, if the criterion below is satisfied, then that sfn and
421 * slot are the correct ones for the on-duration timer.
422 * if the Short DRX Cycle is used, and [(SFN × 10) + subframe number] modulo
423 * (drx-ShortCycle) = (drxStartOffset) modulo (drx-ShortCycle); or
424 * if the Long DRX Cycle is used, and [(SFN × 10) + subframe number] modulo
425 * (drx-LongCycle) = drxStartOffset */
426 if ( curTime <= ueDrxCb->drxStartOffset)
428 /* offset is the nextOnDur */
429 nxtDist = ((((ueDrxCb->drxStartOffset / cell->numSlots)) & (MAX_SFN - 1)) * cell->numSlots) + (ueDrxCb->drxStartOffset % cell->numSlots);
433 tmpDistance = curTime - ueDrxCb->drxStartOffset;
434 numOfCycles = tmpDistance / cycleLen;
436 if (0 == (tmpDistance % cycleLen))
438 /* Perfect match pick up the current time */
439 nxtDist = ((((curTime / cell->numSlots)) & (MAX_SFN - 1)) * cell->numSlots) + (curTime % cell->numSlots);
443 nxtDist = ueDrxCb->drxStartOffset + (numOfCycles + 1) * cycleLen;
447 /* If slot offset is non-zero then Add slot offset to the calculated onDur
449 if(ueDrxCb->drxSlotOffset)
451 nxtDist = nxtDist + ueDrxCb->drxSlotOffset;
453 /*If next On Duration is less than DL DELTA ahead, we will miss it and
454 * hence need to move to the On-Duration after that.*/
455 if((nxtDist - (curTime - delta)) <= SCH_DRX_MAX_DELTA)
457 nxtDist = nxtDist + cycleLen;
460 nxtOnDur->sfn = ((nxtDist / cell->numSlots) & (MAX_SFN - 1));
461 nxtOnDur->slot = (nxtDist % cell->numSlots);
465 * @brief Add entry into the on duration list and short cycle list
469 * Function : schDrxUeReCfgTimer
471 * This function is used to Add entry into the on duration list and short
474 * @param[in] SchCellCb *cell, SchUeCb *ueCb
480 void schDrxUeReCfgTimer(SchCellCb *cell, SchUeCb *ueCb)
482 uint8_t currentSlotIndx;
483 uint32_t onDurTime, onDurExpSlotTime, currentSlotTime;
485 SlotTimingInfo onDurationOccurance;
487 if(ueCb->drxUeCb.shortCyclePresent == false)
489 /* 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
490 * remove the entry from the list */
491 if(ueCb->drxUeCb.shortCycleExpiryIndex != SCH_DRX_INVALID_INDEX)
493 cmLListDelFrm(&cell->drxCb[ueCb->drxUeCb.shortCycleExpiryIndex ].shortCycleExpiryList, ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo);
494 SCH_FREE(ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo, sizeof(CmLList));
495 ueCb->drxUeCb.shortCycleExpiryIndex = SCH_DRX_INVALID_INDEX;
496 ueCb->drxUeCb.shortCycleDistance = SCH_DRX_INVALID_DISTANCE;
499 /* If there is any entry present in on duration start list then remove the
500 * entry from the list and recaluate the nect onduration cucurance */
501 if(ueCb->drxUeCb.onDurationStartIndex != SCH_DRX_INVALID_INDEX)
503 cmLListDelFrm(&cell->drxCb[ueCb->drxUeCb.onDurationStartIndex].onDurationStartList, ueCb->drxUeCb.onDurationStartNodeInfo);
504 SCH_FREE(ueCb->drxUeCb.onDurationStartNodeInfo, sizeof(CmLList));
505 ueCb->drxUeCb.onDurationStartIndex= SCH_DRX_INVALID_INDEX;
506 ueCb->drxUeCb.onDurationStartDistance= SCH_DRX_INVALID_DISTANCE;
510 findNextOndurationOccurance(cell, &ueCb->drxUeCb, &onDurationOccurance, 0);
511 onDurTime = onDurationOccurance.sfn*cell->numSlots+onDurationOccurance.slot;
513 /* If Onduration timer of old configuration is already running then next onduration
514 * starts once it expires*/
515 if((ueCb->drxUeCb.onDurationExpiryDistance != SCH_DRX_INVALID_DISTANCE) && (ueCb->drxUeCb.onDurationExpiryIndex != SCH_DRX_INVALID_INDEX))
517 currentSlotTime = cell->slotInfo.sfn * cell->numSlots + cell->slotInfo.slot;
518 currentSlotIndx = (currentSlotTime + PHY_DELTA_DL + SCHED_DELTA)%MAX_DRX_SIZE;
519 if(currentSlotIndx >= ueCb->drxUeCb.onDurationExpiryIndex )
521 onDurExpSlotTime = currentSlotTime + ((ueCb->drxUeCb.onDurationExpiryDistance +1) * MAX_DRX_SIZE) +\
522 (ueCb->drxUeCb.onDurationExpiryIndex - currentSlotIndx + PHY_DELTA_DL + SCHED_DELTA);
527 onDurExpSlotTime = currentSlotTime + ((ueCb->drxUeCb.onDurationExpiryDistance) * MAX_DRX_SIZE) +\
528 (ueCb->drxUeCb.onDurationExpiryIndex - currentSlotIndx + PHY_DELTA_DL + SCHED_DELTA);
530 if(onDurTime <= onDurExpSlotTime)
532 if(ueCb->drxUeCb.longCycleToBeUsed == true)
533 cycleLen = ueCb->drxUeCb.longCycleLen;
535 cycleLen = ueCb->drxUeCb.shortCycleLen;
537 onDurTime = onDurTime + ((onDurExpSlotTime - onDurTime)/cycleLen + 1) * cycleLen;
540 SCH_CALCULATE_TIMER_INDEX(onDurTime, ueCb->drxUeCb.onDurationStartIndex);
541 ueCb->drxUeCb.onDurationStartDistance = SCH_CALC_SLOT_DIFF(onDurationOccurance, cell->slotInfo, cell->numSlots)/MAX_DRX_SIZE;
542 schAddDrxTimerIntoList(&cell->drxCb[ueCb->drxUeCb.onDurationStartIndex].onDurationStartList, ueCb, &ueCb->drxUeCb.onDurationStartNodeInfo);
546 * @brief Add entry into the on duration list
550 * Function : schAddUeInOndurationList
552 * This function is used to Add entry into the on duration list
554 * @param[in] SchCellCb *cell, SchDrxUeCb *ueDrxCb, SlotTimingInfo *nxtOnDur,
561 void schAddUeInOndurationList(SchCellCb *cell, SchUeCb *ueCb, uint8_t delta)
564 SlotTimingInfo onDurationOccurance;
566 if(ueCb->ueDrxInfoPres)
568 findNextOndurationOccurance(cell, &ueCb->drxUeCb, &onDurationOccurance, delta);
569 onDurTime = onDurationOccurance.sfn*cell->numSlots+onDurationOccurance.slot;
570 SCH_CALCULATE_TIMER_INDEX(onDurTime, ueCb->drxUeCb.onDurationStartIndex);
571 ueCb->drxUeCb.onDurationStartDistance = SCH_CALC_SLOT_DIFF(onDurationOccurance, cell->slotInfo, cell->numSlots)/MAX_DRX_SIZE;
572 schAddDrxTimerIntoList(&cell->drxCb[ueCb->drxUeCb.onDurationStartIndex].onDurationStartList, ueCb, &ueCb->drxUeCb.onDurationStartNodeInfo);
578 * @brief Handling of On duration drx start timer
582 * Function : schHdlDrxOnDurStrtTimerForDlDirection
584 * Handling of On duration drx start timer
586 * @param[in] SchCellCb *cell
592 void schHdlDrxOnDurStrtTimerForDlDirection(SchCellCb *cell, uint16_t currListIndx)
594 uint16_t onDurationExpiry=0;
595 CmLList *drxCurrNode = NULLP;
596 SchUeCb *ueCb = NULLP;
598 drxCurrNode = cell->drxCb[currListIndx].onDurationStartList.first;
601 /* Handling of dl On duration drx start list */
604 ueCb = (SchUeCb*)drxCurrNode->node;
605 drxCurrNode = drxCurrNode->next;
607 ueCb->drxUeCb.onDurationStartDistance--;
609 if(ueCb->drxUeCb.onDurationStartDistance != SCH_DRX_INVALID_DISTANCE)
615 ueCb->drxUeCb.drxDlUeActiveMask |= UE_ACTIVE_FOR_ONDURATION;
617 /* set the Ue status as active or inactive*/
618 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
620 /* If there is any entery present in onDurationExpiry list remove
621 * the entery from the list and recalculate the
622 * onDurationExpiry time and add it to list */
623 if(ueCb->drxUeCb.onDurationExpiryIndex != SCH_DRX_INVALID_INDEX)
625 cmLListDelFrm(&cell->drxCb[ueCb->drxUeCb.onDurationExpiryIndex].onDurationExpiryList, ueCb->drxUeCb.onDurationExpiryNodeInfo);
626 SCH_FREE(ueCb->drxUeCb.onDurationExpiryNodeInfo, sizeof(CmLList));
627 ueCb->drxUeCb.onDurationExpiryIndex = SCH_DRX_INVALID_INDEX;
628 ueCb->drxUeCb.onDurationExpiryDistance = SCH_DRX_INVALID_DISTANCE;
631 /* onDurationExpiry = (current slot + onduration length) % MAX_DRX_SIZE*/
632 onDurationExpiry = (currListIndx + ueCb->drxUeCb.onDurationLen)%MAX_DRX_SIZE;
633 ueCb->drxUeCb.onDurationExpiryDistance = (ueCb->drxUeCb.onDurationLen)/MAX_DRX_SIZE;
634 schAddDrxTimerIntoList(&cell->drxCb[onDurationExpiry].onDurationExpiryList, ueCb, &ueCb->drxUeCb.onDurationExpiryNodeInfo);
635 ueCb->drxUeCb.onDurationExpiryIndex = onDurationExpiry;
643 * @brief Handling of On duration drx start timer
647 * Function : schHdlDrxOnDurStrtTimerForUlDirection
649 * Handling of On duration drx start timer
651 * @param[in] SchCellCb *cell
657 void schHdlDrxOnDurStrtTimerForUlDirection(SchCellCb *cell, uint16_t currListIndx)
659 uint16_t onDurTime=0;
660 CmLList *drxCurrNode = NULLP;
661 SchUeCb *ueCb = NULLP;
663 drxCurrNode = cell->drxCb[currListIndx].onDurationStartList.first;
666 /* Handling of dl On duration drx start list */
669 ueCb = (SchUeCb*)drxCurrNode->node;
670 drxCurrNode = drxCurrNode->next;
672 if(ueCb->drxUeCb.onDurationStartDistance != SCH_DRX_INVALID_DISTANCE)
676 ueCb->drxUeCb.drxUlUeActiveMask |= UE_ACTIVE_FOR_ONDURATION;
677 /* set the final Ue status as active or inactive */
678 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
680 /* 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 */
681 cmLListDelFrm(&cell->drxCb[currListIndx].onDurationStartList, ueCb->drxUeCb.onDurationStartNodeInfo);
682 SCH_FREE(ueCb->drxUeCb.onDurationStartNodeInfo, sizeof(CmLList));
683 ueCb->drxUeCb.onDurationStartIndex= SCH_DRX_INVALID_INDEX;
685 if(ueCb->drxUeCb.longCycleToBeUsed)
687 onDurTime = currListIndx + ueCb->drxUeCb.longCycleLen;
691 onDurTime = currListIndx + ueCb->drxUeCb.shortCycleLen;
693 SCH_CALCULATE_TIMER_INDEX(onDurTime, ueCb->drxUeCb.onDurationStartIndex);
694 ueCb->drxUeCb.onDurationStartDistance = ueCb->drxUeCb.longCycleLen/MAX_DRX_SIZE;
695 schAddDrxTimerIntoList(&cell->drxCb[ueCb->drxUeCb.onDurationStartIndex].onDurationStartList, ueCb, &ueCb->drxUeCb.onDurationStartNodeInfo);
701 * @brief Handling of On duration drx start timer
705 * Function : schHdlDrxOnDurStrtTimer
707 * Handling of On duration drx start timer
709 * @param[in] SchCellCb *cell
715 void schHdlDrxOnDurStrtTimer(SchCellCb *cell)
717 uint16_t dlIndx = 0, ulIndx=0;
718 SlotTimingInfo dlSlotInfo, ulSlotInfo;
720 ADD_DELTA_TO_TIME(cell->slotInfo, dlSlotInfo, PHY_DELTA_DL + SCHED_DELTA, cell->numSlots);
721 ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA, cell->numSlots);
723 dlIndx = (dlSlotInfo.sfn*MAX_SLOTS+dlSlotInfo.slot)%MAX_DRX_SIZE;
724 ulIndx = (ulSlotInfo.sfn*MAX_SLOTS+ulSlotInfo.slot)%MAX_DRX_SIZE;
725 schHdlDrxOnDurStrtTimerForDlDirection(cell, dlIndx);
726 schHdlDrxOnDurStrtTimerForUlDirection(cell, ulIndx);
730 * @brief Handling of the DRX in-active start timer
736 * Handling of DRX in-active start timer
738 * @param[in] SchCellCb *cell
744 void schHdlDrxInActvStrtTmr(SchCellCb *cell, SchUeCb *ueCb, uint8_t delta)
746 uint16_t slotIndx = 0;
747 SlotTimingInfo tmpSlotInfo;
749 if(ueCb->drxUeCb.inActvTimerLen == 0)
754 ADD_DELTA_TO_TIME(cell->slotInfo, tmpSlotInfo, delta, cell->numSlots);
755 slotIndx = (tmpSlotInfo.sfn*MAX_SLOTS+tmpSlotInfo.slot)%MAX_DRX_SIZE;
757 /* if there is any entry present in the in-active exp list then remove the entry */
758 if(ueCb->drxUeCb.inActvExpiryIndex != SCH_DRX_INVALID_INDEX)
760 cmLListDelFrm(&cell->drxCb[ueCb->drxUeCb.inActvExpiryIndex].inActvTmrExpiryList, ueCb->drxUeCb.inActvTimerExpiryNodeInfo);
761 SCH_FREE(ueCb->drxUeCb.inActvTimerExpiryNodeInfo, sizeof(CmLList));
762 ueCb->drxUeCb.inActvExpiryIndex= SCH_DRX_INVALID_INDEX;
763 ueCb->drxUeCb.inActiveTmrExpiryDistance= SCH_DRX_INVALID_DISTANCE;
766 /* Adding the new entry in in-activity timer list */
767 ueCb->drxUeCb.inActvExpiryIndex = (slotIndx + ueCb->drxUeCb.inActvTimerLen) % MAX_DRX_SIZE;
768 ueCb->drxUeCb.inActiveTmrExpiryDistance = (ueCb->drxUeCb.inActvTimerLen) / MAX_DRX_SIZE;
769 schAddDrxTimerIntoList(&cell->drxCb[ueCb->drxUeCb.inActvExpiryIndex].inActvTmrExpiryList, ueCb, &ueCb->drxUeCb.inActvTimerExpiryNodeInfo);
771 /* Set the UE active for UL And Dl transfer */
772 ueCb->drxUeCb.drxDlUeActiveMask |= UE_ACTIVE_FOR_INACTIVE_TIMER;
773 ueCb->drxUeCb.drxUlUeActiveMask |= UE_ACTIVE_FOR_INACTIVE_TIMER;
774 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
778 * @brief Handling of short cycle drx start timer
782 * Function : schHdlDrxStartShortCycleTimer
784 * Handling of short cycle drx start timer
786 * @param[in] SchCellCb *cell
792 void schHdlDrxStartShortCycleTimer(SchCellCb *cell, SchUeCb *ueCb)
794 ueCb->drxUeCb.longCycleToBeUsed = false;
796 /* if there is any present in on-duration start list, remove the entry from on duration start list */
797 if(ueCb->drxUeCb.onDurationStartIndex != SCH_DRX_INVALID_INDEX)
799 cmLListDelFrm(&cell->drxCb[ueCb->drxUeCb.onDurationStartIndex].onDurationStartList, ueCb->drxUeCb.onDurationStartNodeInfo);
800 SCH_FREE(ueCb->drxUeCb.onDurationStartNodeInfo, sizeof(CmLList));
801 ueCb->drxUeCb.onDurationStartIndex = SCH_DRX_INVALID_INDEX;
802 ueCb->drxUeCb.onDurationStartDistance = SCH_DRX_INVALID_DISTANCE;
805 /* recalculate the new index of on duration start based on short cycle */
806 schAddUeInOndurationList(cell, ueCb, PHY_DELTA_DL + SCHED_DELTA);
808 /* if any node is present in short cycle exp list then remove the node from list */
809 if(ueCb->drxUeCb.shortCycleExpiryIndex != SCH_DRX_INVALID_INDEX && ueCb->drxUeCb.shortCycleDistance != SCH_DRX_INVALID_DISTANCE)
811 cmLListDelFrm(&cell->drxCb[ueCb->drxUeCb.shortCycleExpiryIndex].shortCycleExpiryList, ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo);
812 SCH_FREE(ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo, sizeof(CmLList));
813 ueCb->drxUeCb.shortCycleExpiryIndex = SCH_DRX_INVALID_INDEX;
814 ueCb->drxUeCb.shortCycleDistance = SCH_DRX_INVALID_DISTANCE;
817 /* recalculate the new index for shortCycleExpiryList */
818 ueCb->drxUeCb.shortCycleExpiryIndex = (ueCb->drxUeCb.onDurationStartIndex + ueCb->drxUeCb.shortCycleTmrLen) % MAX_DRX_SIZE;
819 ueCb->drxUeCb.shortCycleDistance = ueCb->drxUeCb.shortCycleTmrLen / MAX_DRX_SIZE;
820 schAddDrxTimerIntoList(&cell->drxCb[ueCb->drxUeCb.shortCycleExpiryIndex].shortCycleExpiryList, ueCb, &ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo);
824 * @brief Handling of the Dl harq DRX timers start for Dl scheduling
828 * Function : schHdlDlHqRetxStrtTimerForDl
830 * Handling of Dl harq DRX timers start for Dl scheduling
832 * @param[in] SchCellCb *cell, uint16_t currIdx
837 void schHdlDlHqRetxStrtTimerForDl(SchCellCb *cell, uint16_t currIndx)
839 uint32_t retxExpIndx;
844 currNode = cell->drxCb[currIndx].dlRetransTmrStartList.first;
848 hqP = (SchDlHqProcCb*)currNode->node;
849 currNode = currNode->next;
850 cell->api->SchAddUeToSchedule(hqP->hqEnt->cell, hqP->hqEnt->ue->ueId);
851 ueCb = hqP->hqEnt->ue;
853 /* calculate the retransmission exp index */
854 retxExpIndx = (currIndx + ueCb->drxUeCb.retransDlTimerLen)%MAX_DRX_SIZE;
855 if(hqP->dlDrxHarqCb.retxExpIndex == SCH_DRX_INVALID_INDEX)
857 hqP->dlDrxHarqCb.retxExpIndex = retxExpIndx;
858 schAddDrxNodeIntoHarqTimerList(&cell->drxCb[retxExpIndx].dlRetransExpiryList, hqP, &hqP->dlDrxHarqCb.retxExpNode);
861 /* Mark the UE active for downlink */
862 ueCb->drxUeCb.drxDlUeActiveMaskForHarq |= (SCH_DRX_DL_HARQ_BITMASK << hqP->procId);
863 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
868 * @brief Handling of the Dl harq DRX timers start for Ul scheduling
872 * Function : schHdlDlHqRetxStrtTimerForUl
874 * Handling of Dl harq DRX timers start for Ul scheduling
876 * @param[in] SchCellCb *cell, uint16_t currIdx
881 void schHdlDlHqRetxStrtTimerForUl(SchCellCb *cell, uint16_t currIndx)
887 currNode = cell->drxCb[currIndx].dlRetransTmrStartList.first;
891 hqP = (SchDlHqProcCb*)currNode->node;
892 currNode = currNode->next;
893 ueCb = hqP->hqEnt->ue;
895 /* Mark the UE active for uplink */
896 ueCb->drxUeCb.drxUlUeActiveMaskForHarq |= (SCH_DRX_UL_HARQ_BITMASK << hqP->procId);
897 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
899 /* Delete the node */
900 cmLListDelFrm(&cell->drxCb[currIndx].dlRetransTmrStartList, hqP->dlDrxHarqCb.retxStrtNode);
901 SCH_FREE(hqP->dlDrxHarqCb.retxStrtNode, sizeof(CmLList));
902 hqP->dlDrxHarqCb.retxStrtIndex = SCH_DRX_INVALID_INDEX;
907 * @brief Handling of the Dl harq DRX timers start
911 * Function : schHdlDrxDlHqRetxStrtTimer
913 * Handling of Dl harq DRX timers start
915 * @param[in] SchCellCb *cell
921 void schHdlDrxDlHqRetxStrtTimer(SchCellCb *cell)
923 uint16_t dlIndx = 0, ulIndx=0;
924 SlotTimingInfo dlSlotInfo, ulSlotInfo;
926 ADD_DELTA_TO_TIME(cell->slotInfo, dlSlotInfo, PHY_DELTA_DL + SCHED_DELTA, cell->numSlots);
927 ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA, cell->numSlots);
929 dlIndx = (dlSlotInfo.sfn*MAX_SLOTS+dlSlotInfo.slot)%MAX_DRX_SIZE;
930 ulIndx = (ulSlotInfo.sfn*MAX_SLOTS+ulSlotInfo.slot)%MAX_DRX_SIZE;
932 schHdlDlHqRetxStrtTimerForDl(cell, dlIndx);
933 schHdlDlHqRetxStrtTimerForUl(cell, ulIndx);
937 * @brief Handling of the DRX timers start
941 * Function : schHandleStartDrxTimer
943 * Handling of DRX timers start
945 * @param[in] SchCellCb *cell
951 void schHandleStartDrxTimer(SchCellCb *cell)
953 /* Handling the onduration start timer */
954 schHdlDrxOnDurStrtTimer(cell);
955 schHdlDrxDlHqRetxStrtTimer(cell);
956 schHdlDrxUlHqRetxStrtTimer(cell);
960 * @brief Handling of the Dl harq Rtt start DRX timers
964 * Function : schDrxStrtDlHqRttTmr
966 * Handling of the Dl harq Rtt start DRX timers
968 * @param[in] SchCellCb *cell
974 void schDrxStrtDlHqRttTmr(SchDlHqProcCb *hqP)
976 uint16_t harqRttExpTimer=0;
979 drxUeCb = &hqP->hqEnt->ue->drxUeCb;
981 harqRttExpTimer = (hqP->pucchTime.sfn * MAX_SLOTS + hqP->pucchTime.slot + drxUeCb->harqRttDlTimerLen)%MAX_DRX_SIZE;
982 hqP->dlDrxHarqCb.rttExpIndex = harqRttExpTimer;
983 schAddDrxNodeIntoHarqTimerList(&hqP->hqEnt->cell->drxCb[harqRttExpTimer].dlHarqRttExpiryList, hqP, &hqP->dlDrxHarqCb.rttExpNode);
987 * @brief Handling of the Ul harq DRX timers start for Dl scheduling
991 * Function : schHdlUlHqRetxStrtTimerForDl
993 * Handling of Ul harq DRX timers start for Dl scheduling
995 * @param[in] SchCellCb *cell, uint16_t currIdx
1000 void schHdlUlHqRetxStrtTimerForDl(SchCellCb *cell, uint16_t currIndx)
1002 uint32_t retxExpIndx;
1007 currNode = cell->drxCb[currIndx].ulRetransTmrStartList.first;
1011 hqP = (SchUlHqProcCb*)currNode->node;
1012 currNode = currNode->next;
1013 cell->api->SchAddUeToSchedule(hqP->hqEnt->cell, hqP->hqEnt->ue->ueId);
1014 ueCb = hqP->hqEnt->ue;
1016 /* calculate the retransmission exp index */
1017 retxExpIndx = (currIndx + ueCb->drxUeCb.retransUlTimerLen)%MAX_DRX_SIZE;
1018 if(hqP->ulDrxHarqCb.retxExpIndex == SCH_DRX_INVALID_INDEX)
1020 hqP->ulDrxHarqCb.retxExpIndex = retxExpIndx;
1021 schAddDrxNodeIntoHarqTimerList(&cell->drxCb[retxExpIndx].ulRetransExpiryList, hqP, &hqP->ulDrxHarqCb.retxExpNode);
1024 /* Mark the UE active for downlink */
1025 ueCb->drxUeCb.drxUlUeActiveMaskForHarq |= (SCH_DRX_UL_HARQ_BITMASK << hqP->procId);
1026 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
1031 * @brief Handling of the Ul harq DRX timers start for Ul scheduling
1035 * Function : schHdlUlHqRetxStrtTimerForUl
1037 * Handling of Ul harq DRX timers start for Ul scheduling
1039 * @param[in] SchCellCb *cell, uint16_t currIdx
1044 void schHdlUlHqRetxStrtTimerForUl(SchCellCb *cell, uint16_t currIndx)
1050 currNode = cell->drxCb[currIndx].ulRetransTmrStartList.first;
1054 hqP = (SchUlHqProcCb*)currNode->node;
1055 currNode = currNode->next;
1056 ueCb = hqP->hqEnt->ue;
1058 /* Mark the UE active for uplink */
1059 ueCb->drxUeCb.drxUlUeActiveMaskForHarq |= (SCH_DRX_UL_HARQ_BITMASK << hqP->procId);
1060 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
1062 /* Delete the node */
1063 cmLListDelFrm(&cell->drxCb[currIndx].ulRetransTmrStartList, hqP->ulDrxHarqCb.retxStrtNode);
1064 SCH_FREE(hqP->ulDrxHarqCb.retxStrtNode, sizeof(CmLList));
1065 hqP->ulDrxHarqCb.retxStrtIndex = SCH_DRX_INVALID_INDEX;
1070 * @brief Handling of the Ul harq DRX timers start
1074 * Function : schHdlDrxUlHqRetxStrtTimer
1076 * Handling of Ul harq DRX timers start
1078 * @param[in] SchCellCb *cell
1084 void schHdlDrxUlHqRetxStrtTimer(SchCellCb *cell)
1086 uint16_t dlIndx = 0, ulIndx=0;
1087 SlotTimingInfo dlSlotInfo, ulSlotInfo;
1089 ADD_DELTA_TO_TIME(cell->slotInfo, dlSlotInfo, PHY_DELTA_DL + SCHED_DELTA, cell->numSlots);
1090 ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA, cell->numSlots);
1092 dlIndx = (dlSlotInfo.sfn*MAX_SLOTS+dlSlotInfo.slot)%MAX_DRX_SIZE;
1093 ulIndx = (ulSlotInfo.sfn*MAX_SLOTS+ulSlotInfo.slot)%MAX_DRX_SIZE;
1095 schHdlUlHqRetxStrtTimerForDl(cell, dlIndx);
1096 schHdlUlHqRetxStrtTimerForUl(cell, ulIndx);
1100 * @brief Handling of the Ul harq Rtt start DRX timers
1104 * Function : schDrxStrtUlHqRttTmr
1106 * Handling of the Ul harq Rtt start DRX timers
1108 * @param[in] SchCellCb *cell
1114 void schDrxStrtUlHqRttTmr(SchUlHqProcCb *hqP)
1116 uint16_t harqRttExpTimer=0;
1117 SchDrxUeCb *drxUeCb;
1119 drxUeCb = &hqP->hqEnt->ue->drxUeCb;
1121 harqRttExpTimer = (hqP->puschTime.sfn * MAX_SLOTS + hqP->puschTime.slot + drxUeCb->harqRttUlTimerLen)%MAX_DRX_SIZE;
1122 hqP->ulDrxHarqCb.rttExpIndex = harqRttExpTimer;
1123 schAddDrxNodeIntoHarqTimerList(&hqP->hqEnt->cell->drxCb[harqRttExpTimer].ulHarqRttExpiryList, hqP, &hqP->ulDrxHarqCb.rttExpNode);
1127 * @brief Handling of the expiry onduration timer in dl direction
1131 * Function : schHdlDrxOnDurExpiryTimerForDlDirection
1133 * Handling of expiry onduration DRX timers in dl direction
1135 * @param[in] SchCellCb *cell
1141 void schHdlDrxOnDurExpiryTimerForDlDirection(SchCellCb *cell, uint16_t currListIndx)
1143 CmLList *drxCurrNode;
1144 SchUeCb *ueCb = NULLP;
1146 drxCurrNode = cell->drxCb[currListIndx].onDurationExpiryList.first;
1149 /* Handling of dl On duration drx start list */
1152 ueCb = (SchUeCb*)drxCurrNode->node;
1153 drxCurrNode = drxCurrNode->next;
1155 ueCb->drxUeCb.onDurationExpiryDistance--;
1157 if(ueCb->drxUeCb.onDurationExpiryDistance != SCH_DRX_INVALID_DISTANCE)
1161 ueCb->drxUeCb.drxDlUeActiveMask &= ~UE_ACTIVE_FOR_ONDURATION;
1162 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
1168 * @brief Handling of the expiry onduration DRX timers for Ul direction
1172 * Function schHdlDrxOnDurExpiryTimerForUlDirection:
1174 * Handling of expiry onduration DRX timers in Ul direction
1176 * @param[in] SchCellCb *cell
1182 void schHdlDrxOnDurExpiryTimerForUlDirection(SchCellCb *cell, uint16_t currListIndx)
1184 CmLList *drxCurrNode;
1185 SchUeCb *ueCb = NULLP;
1187 drxCurrNode = cell->drxCb[currListIndx].onDurationExpiryList.first;
1190 /* Handling of dl On duration drx start list */
1193 ueCb = (SchUeCb*)drxCurrNode->node;
1194 drxCurrNode = drxCurrNode->next;
1196 if(ueCb->drxUeCb.onDurationExpiryDistance != SCH_DRX_INVALID_DISTANCE)
1201 ueCb->drxUeCb.drxUlUeActiveMask &= ~UE_ACTIVE_FOR_ONDURATION;
1202 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
1203 cmLListDelFrm(&cell->drxCb[ueCb->drxUeCb.onDurationExpiryIndex].onDurationExpiryList, ueCb->drxUeCb.onDurationExpiryNodeInfo);
1204 SCH_FREE(ueCb->drxUeCb.onDurationExpiryNodeInfo, sizeof(CmLList));
1205 ueCb->drxUeCb.onDurationExpiryIndex = SCH_DRX_INVALID_INDEX;
1211 * @brief Handling of the expiry onduration DRX timers
1215 * Function : schHdlDrxOnDurExpiryTimer
1217 * Handling of expiry onduration DRX timers
1219 * @param[in] SchCellCb *cell
1225 void schHdlDrxOnDurExpiryTimer(SchCellCb *cell)
1227 uint16_t dlIndx = 0, ulIndx = 0;
1228 SlotTimingInfo dlSlotInfo, ulSlotInfo;
1230 ADD_DELTA_TO_TIME(cell->slotInfo, dlSlotInfo, PHY_DELTA_DL + SCHED_DELTA, cell->numSlots);
1231 ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA, cell->numSlots);
1232 dlIndx = (dlSlotInfo.sfn*MAX_SLOTS+dlSlotInfo.slot)%MAX_DRX_SIZE;
1233 ulIndx = (ulSlotInfo.sfn*MAX_SLOTS+ulSlotInfo.slot)%MAX_DRX_SIZE;
1235 schHdlDrxOnDurExpiryTimerForDlDirection(cell, dlIndx);
1236 schHdlDrxOnDurExpiryTimerForUlDirection(cell, ulIndx);
1240 * @brief Handling of the expiry of in-active DRX timers in Dl
1244 * Function : schHdlDrxInActvExpiryTimerForDlDirection
1246 * Handling of expiry of in-active DRX timers at Dl index
1248 * @param[in] SchCellCb *cell, uint16_t dlIndx
1254 void schHdlDrxInActvExpiryTimerForDlDirection(SchCellCb *cell, uint16_t dlIndx)
1257 SchUeCb *ueCb = NULLP;
1259 drxNode = cell->drxCb[dlIndx].inActvTmrExpiryList.first;
1262 /* Handling of dl On duration drx start list */
1265 ueCb = (SchUeCb*)drxNode->node;
1266 drxNode = drxNode->next;
1267 ueCb->drxUeCb.inActiveTmrExpiryDistance--;
1269 if(ueCb->drxUeCb.onDurationExpiryDistance != SCH_DRX_INVALID_DISTANCE)
1274 ueCb->drxUeCb.drxDlUeActiveMask &= ~UE_ACTIVE_FOR_INACTIVE_TIMER;
1275 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
1281 * @brief Handling of the expiry of in-active DRX timers in Ul
1285 * Function : schHdlDrxInActvExpiryTimerForUlDirection
1287 * Handling of expiry of in-active DRX timers at Ul index
1289 * @param[in] SchCellCb *cell, uint16_t ulIndx
1295 void schHdlDrxInActvExpiryTimerForUlDirection(SchCellCb *cell, uint16_t ulIndx)
1298 SchUeCb *ueCb = NULLP;
1300 drxNode = cell->drxCb[ulIndx].inActvTmrExpiryList.first;
1303 /* Handling of dl On duration drx start list */
1306 ueCb = (SchUeCb*)drxNode->node;
1307 drxNode = drxNode->next;
1309 if(ueCb->drxUeCb.onDurationExpiryDistance != SCH_DRX_INVALID_DISTANCE)
1314 ueCb->drxUeCb.drxUlUeActiveMask &= ~UE_ACTIVE_FOR_INACTIVE_TIMER;
1315 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
1317 /* Remove the entry from the in-active exp timer list */
1318 cmLListDelFrm(&cell->drxCb[ulIndx].inActvTmrExpiryList, ueCb->drxUeCb.inActvTimerExpiryNodeInfo);
1319 SCH_FREE(ueCb->drxUeCb.inActvTimerExpiryNodeInfo, sizeof(CmLList));
1320 ueCb->drxUeCb.inActvExpiryIndex = SCH_DRX_INVALID_INDEX;
1322 if(ueCb->drxUeCb.shortCyclePresent)
1324 /* Start short cycle timer */
1325 schHdlDrxStartShortCycleTimer(cell, ueCb);
1332 * @brief Handling of the expiry of in-active DRX timers
1336 * Function :schHdlDrxInActvExpiryTimer
1338 * Handling of expiry of in-active DRX timers
1340 * @param[in] SchCellCb *cell
1346 void schHdlDrxInActvExpiryTimer(SchCellCb *cell)
1348 uint16_t dlIndx = 0, ulIndx = 0;
1349 SlotTimingInfo dlSlotInfo, ulSlotInfo;
1351 ADD_DELTA_TO_TIME(cell->slotInfo, dlSlotInfo, PHY_DELTA_DL + SCHED_DELTA, cell->numSlots);
1352 ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA, cell->numSlots);
1353 dlIndx = (dlSlotInfo.sfn*MAX_SLOTS+dlSlotInfo.slot)%MAX_DRX_SIZE;
1354 ulIndx = (ulSlotInfo.sfn*MAX_SLOTS+ulSlotInfo.slot)%MAX_DRX_SIZE;
1356 schHdlDrxInActvExpiryTimerForDlDirection(cell, dlIndx);
1357 schHdlDrxInActvExpiryTimerForUlDirection(cell, ulIndx);
1361 * @brief Handling of the expiry ShortCycle DRX timers in DL
1365 * Function : schHdlDrxShortCycleExpiryTimerForDlDirection
1367 * Handling of expiry ShortCycle
1369 * @param[in] SchCellCb *cell
1375 void schHdlDrxShortCycleExpiryTimerForDlDirection(SchCellCb *cell, uint16_t dlIndx)
1377 CmLList *drxCurrNode = NULLP;
1378 SchUeCb *ueCb = NULLP;
1380 drxCurrNode = cell->drxCb[dlIndx].shortCycleExpiryList.first;
1383 /* Handling of short cycle expiry in Dl */
1386 ueCb = (SchUeCb*)drxCurrNode->node;
1387 drxCurrNode = drxCurrNode->next;
1389 ueCb->drxUeCb.shortCycleDistance--;
1391 if(ueCb->drxUeCb.shortCycleDistance != SCH_DRX_INVALID_DISTANCE)
1396 /* once short cycle timer gets expire we will recalculate on-duration start with long cycle */
1397 ueCb->drxUeCb.longCycleToBeUsed = true;
1399 /* delete the entry from on-duration start */
1400 cmLListDelFrm(&cell->drxCb[ueCb->drxUeCb.onDurationStartIndex].onDurationStartList, ueCb->drxUeCb.onDurationStartNodeInfo);
1401 SCH_FREE(ueCb->drxUeCb.onDurationStartNodeInfo, sizeof(CmLList));
1402 ueCb->drxUeCb.onDurationStartIndex = SCH_DRX_INVALID_INDEX;
1403 ueCb->drxUeCb.onDurationStartDistance = SCH_DRX_INVALID_DISTANCE;
1405 /* Recalculate on-duration with long cycle */
1406 schAddUeInOndurationList(cell, ueCb, PHY_DELTA_DL + SCHED_DELTA);
1412 * @brief Handling of the expiry ShortCycle DRX timers in UL
1416 * Function : schHdlDrxShortCycleExpiryTimerForUlDirection
1418 * Handling of expiry ShortCycle
1420 * @param[in] SchCellCb *cell
1426 void schHdlDrxShortCycleExpiryTimerForUlDirection(SchCellCb *cell, uint16_t ulIndx)
1428 CmLList *drxCurrNode = NULLP;
1429 SchUeCb *ueCb = NULLP;
1431 drxCurrNode = cell->drxCb[ulIndx].shortCycleExpiryList.first;
1434 /* Handling of short cycle expiry in Ul */
1437 ueCb = (SchUeCb*)drxCurrNode->node;
1438 drxCurrNode = drxCurrNode->next;
1440 if(ueCb->drxUeCb.shortCycleDistance != SCH_DRX_INVALID_DISTANCE)
1445 cmLListDelFrm(&cell->drxCb[ulIndx].shortCycleExpiryList, ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo);
1446 SCH_FREE(ueCb->drxUeCb.shortCycleTmrExpiryNodeInfo, sizeof(CmLList));
1447 ueCb->drxUeCb.shortCycleExpiryIndex = SCH_DRX_INVALID_INDEX;
1454 * @brief Handling of the expiry ShortCycle DRX timers
1458 * Function :schHdlDrxShortCycleExpiryTimer
1460 * Handling of expiry ShortCycle
1462 * @param[in] SchCellCb *cell
1468 void schHdlDrxShortCycleExpiryTimer(SchCellCb *cell)
1470 uint16_t dlIndx = 0, ulIndx= 0;
1471 SlotTimingInfo dlSlotInfo, ulSlotInfo;
1473 ADD_DELTA_TO_TIME(cell->slotInfo, dlSlotInfo, PHY_DELTA_DL + SCHED_DELTA, cell->numSlots);
1474 ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA, cell->numSlots);
1475 dlIndx = (dlSlotInfo.sfn*MAX_SLOTS+dlSlotInfo.slot)%MAX_DRX_SIZE;
1476 ulIndx = (ulSlotInfo.sfn*MAX_SLOTS+ulSlotInfo.slot)%MAX_DRX_SIZE;
1478 schHdlDrxShortCycleExpiryTimerForDlDirection(cell, dlIndx);
1479 schHdlDrxShortCycleExpiryTimerForUlDirection(cell, ulIndx);
1483 * @brief Handling of the expiry Dl harq rrt DRX timers
1487 * Function : schHdlDlHqRttExpiryTimerForDl
1489 * Handling of expiry Dl harq rrt DRX timers
1491 * @param[in] SchCellCb *cell
1497 void schHdlDlHqRttExpiryTimerForDl(SchCellCb *cell, uint16_t currIdx)
1500 CmLList *drxCurrNode;
1502 drxCurrNode = cell->drxCb[currIdx].dlHarqRttExpiryList.first;
1506 hqP = (SchDlHqProcCb*)drxCurrNode->node;
1507 drxCurrNode = drxCurrNode->next;
1509 /* Add ue to dlRetransTmrStartList list */
1510 if(hqP->dlDrxHarqCb.retxStrtIndex == SCH_DRX_INVALID_INDEX)
1512 schAddDrxNodeIntoHarqTimerList(&cell->drxCb[currIdx + 1].dlRetransTmrStartList, hqP, &hqP->dlDrxHarqCb.retxStrtNode);
1513 hqP->dlDrxHarqCb.retxStrtIndex = currIdx + 1;
1519 * @brief Handling of the expiry Dl harq retransmission DRX timers
1523 * Function : schHdlDlHqRetxExpiryTimerForDl
1525 * Handling of expiry Dl harq retransmission DRX timers
1527 * @param[in] SchCellCb *cell
1533 void schHdlDlHqRetxExpiryTimerForDl(SchCellCb *cell, uint16_t currIdx)
1537 CmLList *drxCurrNode;
1539 drxCurrNode = cell->drxCb[currIdx].dlRetransExpiryList.first;
1543 hqP = (SchDlHqProcCb*)drxCurrNode->node;
1544 drxCurrNode = drxCurrNode->next;
1545 ueCb = hqP->hqEnt->ue;
1547 ueCb->drxUeCb.drxDlUeActiveMaskForHarq &= ~(SCH_DRX_DL_HARQ_BITMASK << hqP->procId);
1549 /* Set the Ue status as inactive */
1550 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
1555 * @brief Handling of the expiry Dl harq rrt DRX timers for Ul scheduling
1559 * Function : schHdlDlHqRttExpiryTimerForUl
1561 * Handling of expiry Dl harq rrt DRX timers for Ul scheduling
1563 * @param[in] SchCellCb *cell
1569 void schHdlDlHqRttExpiryTimerForUl(SchCellCb *cell, uint16_t currIdx)
1572 CmLList *drxCurrNode;
1574 drxCurrNode = cell->drxCb[currIdx].dlHarqRttExpiryList.first;
1578 hqP = (SchDlHqProcCb*)drxCurrNode->node;
1579 drxCurrNode = drxCurrNode->next;
1581 /* Delete the node from list */
1582 cmLListDelFrm(&cell->drxCb[currIdx].dlHarqRttExpiryList, hqP->dlDrxHarqCb.rttExpNode);
1583 SCH_FREE(hqP->dlDrxHarqCb.rttExpNode, sizeof(CmLList));
1584 hqP->dlDrxHarqCb.rttExpIndex = SCH_DRX_INVALID_INDEX;
1589 * @brief Handling of the expiry Dl harq retransmission DRX timers for Ul scheduling
1593 * Function : schHdlDlHqRetxExpiryTimerForUl
1595 * Handling of expiry Dl harq retransmission DRX timers for Ul scheduling
1597 * @param[in] SchCellCb *cell
1603 void schHdlDlHqRetxExpiryTimerForUl(SchCellCb *cell, uint16_t currIdx)
1607 CmLList *drxCurrNode;
1609 drxCurrNode = cell->drxCb[currIdx].dlRetransExpiryList.first;
1613 hqP = (SchDlHqProcCb*)drxCurrNode->node;
1614 ueCb = hqP->hqEnt->ue;
1615 drxCurrNode = drxCurrNode->next;
1617 /* Set the Ue status as inactive for uplink */
1618 ueCb->drxUeCb.drxUlUeActiveMaskForHarq &= ~(SCH_DRX_UL_HARQ_BITMASK << hqP->procId);
1619 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
1622 cmLListDelFrm(&cell->drxCb[currIdx].dlRetransExpiryList, hqP->dlDrxHarqCb.retxExpNode);
1623 SCH_FREE(hqP->dlDrxHarqCb.retxExpNode, sizeof(CmLList));
1624 hqP->dlDrxHarqCb.retxExpIndex = SCH_DRX_INVALID_INDEX;
1630 * @brief Handling of the expiry of Dl harq DRX timers
1634 * Function : schHdlDrxDlHarqExpireTimer
1636 * Handling of expiry of Dl harq DRX timers
1638 * @param[in] SchCellCb *cell
1644 void schHdlDrxDlHarqExpireTimer(SchCellCb *cell)
1646 uint16_t dlIndx = 0, ulIndx = 0;
1647 SlotTimingInfo dlSlotInfo, ulSlotInfo;
1649 ADD_DELTA_TO_TIME(cell->slotInfo, dlSlotInfo, PHY_DELTA_DL + SCHED_DELTA, cell->numSlots);
1650 ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA, cell->numSlots);
1651 dlIndx = (dlSlotInfo.sfn*MAX_SLOTS+dlSlotInfo.slot)%MAX_DRX_SIZE;
1652 ulIndx = (ulSlotInfo.sfn*MAX_SLOTS+ulSlotInfo.slot)%MAX_DRX_SIZE;
1654 schHdlDlHqRttExpiryTimerForDl(cell, dlIndx);
1655 schHdlDlHqRetxExpiryTimerForDl(cell, dlIndx);
1656 schHdlDlHqRttExpiryTimerForUl(cell, ulIndx );
1657 schHdlDlHqRetxExpiryTimerForUl(cell, ulIndx);
1661 * @brief Handling of the expiry of harq DRX timers
1665 * Function : schDrxStopDlHqRetxTmr
1667 * Handling of expiry DRX timers
1669 * @param[in] SchCellCb *cell
1675 void schDrxStopDlHqRetxTmr(SchCellCb *cell, SchUeCb *ueCb, SchDlHqProcCb **hqP)
1678 if((*hqP)->dlDrxHarqCb.retxExpIndex != SCH_DRX_INVALID_INDEX)
1680 ueCb->drxUeCb.drxDlUeActiveMaskForHarq &= ~(SCH_DRX_DL_HARQ_BITMASK << (*hqP)->procId);
1681 ueCb->drxUeCb.drxUlUeActiveMaskForHarq &= ~(SCH_DRX_UL_HARQ_BITMASK << (*hqP)->procId);
1683 /* Change the UE status to Inactive */
1684 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
1686 /* If there is any node present in rtt list then remove the node from list */
1687 if((*hqP)->dlDrxHarqCb.rttExpIndex != SCH_DRX_INVALID_INDEX)
1689 cmLListDelFrm(&cell->drxCb[(*hqP)->dlDrxHarqCb.rttExpIndex].dlHarqRttExpiryList, (*hqP)->dlDrxHarqCb.rttExpNode);
1690 SCH_FREE((*hqP)->dlDrxHarqCb.rttExpNode, sizeof(CmLList));
1691 (*hqP)->dlDrxHarqCb.rttExpIndex = SCH_DRX_INVALID_INDEX;
1694 /* If there is any node present in retx list then remove the node from list */
1695 if((*hqP)->dlDrxHarqCb.retxStrtIndex != SCH_DRX_INVALID_INDEX)
1697 cmLListDelFrm(&cell->drxCb[(*hqP)->dlDrxHarqCb.retxStrtIndex].dlRetransTmrStartList, (*hqP)->dlDrxHarqCb.retxStrtNode);
1698 SCH_FREE((*hqP)->dlDrxHarqCb.retxStrtNode, sizeof(CmLList));
1699 (*hqP)->dlDrxHarqCb.retxStrtIndex = SCH_DRX_INVALID_INDEX;
1702 cmLListDelFrm(&cell->drxCb[(*hqP)->dlDrxHarqCb.retxExpIndex].dlRetransExpiryList, (*hqP)->dlDrxHarqCb.retxExpNode);
1703 SCH_FREE((*hqP)->dlDrxHarqCb.retxExpNode, sizeof(CmLList));
1704 (*hqP)->dlDrxHarqCb.retxExpIndex = SCH_DRX_INVALID_INDEX;
1709 * @brief Handling of the expiry Ul harq rrt DRX timers
1713 * Function : schHdlUlHqRttExpiryTimerForDl
1715 * Handling of expiry ul harq rrt DRX timers
1717 * @param[in] SchCellCb *cell
1723 void schHdlUlHqRttExpiryTimerForDl(SchCellCb *cell, uint16_t currIdx)
1726 CmLList *drxCurrNode;
1728 drxCurrNode = cell->drxCb[currIdx].ulHarqRttExpiryList.first;
1732 hqP = (SchUlHqProcCb*)drxCurrNode->node;
1733 drxCurrNode = drxCurrNode->next;
1735 /* Add ue to ulRetransTmrStartList list */
1736 if(hqP->ulDrxHarqCb.retxStrtIndex == SCH_DRX_INVALID_INDEX)
1738 schAddDrxNodeIntoHarqTimerList(&cell->drxCb[currIdx + 1].ulRetransTmrStartList, hqP, &hqP->ulDrxHarqCb.retxStrtNode);
1739 hqP->ulDrxHarqCb.retxStrtIndex = currIdx + 1;
1745 * @brief Handling of the expiry ul harq retransmission DRX timers
1749 * Function : schHdlUlHqRetxExpiryTimerForDl
1751 * Handling of expiry Ul harq retransmission DRX timers
1753 * @param[in] SchCellCb *cell
1759 void schHdlUlHqRetxExpiryTimerForDl(SchCellCb *cell, uint16_t currIdx)
1763 CmLList *drxCurrNode;
1765 drxCurrNode = cell->drxCb[currIdx].ulRetransExpiryList.first;
1769 hqP = (SchUlHqProcCb*)drxCurrNode->node;
1770 drxCurrNode = drxCurrNode->next;
1771 ueCb = hqP->hqEnt->ue;
1773 ueCb->drxUeCb.drxUlUeActiveMaskForHarq &= ~(SCH_DRX_UL_HARQ_BITMASK << hqP->procId);
1775 /* Set the Ue status as inactive */
1776 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
1781 * @brief Handling of the expiry ul harq rrt DRX timers for Ul scheduling
1785 * Function : schHdlUlHqRttExpiryTimerForUl
1787 * Handling of expiry Ul harq rrt DRX timers for Ul scheduling
1789 * @param[in] SchCellCb *cell
1795 void schHdlUlHqRttExpiryTimerForUl(SchCellCb *cell, uint16_t currIdx)
1798 CmLList *drxCurrNode;
1800 drxCurrNode = cell->drxCb[currIdx].ulHarqRttExpiryList.first;
1804 hqP = (SchUlHqProcCb*)drxCurrNode->node;
1805 drxCurrNode = drxCurrNode->next;
1807 /* Delete the node from list */
1808 cmLListDelFrm(&cell->drxCb[currIdx].ulHarqRttExpiryList, hqP->ulDrxHarqCb.rttExpNode);
1809 SCH_FREE(hqP->ulDrxHarqCb.rttExpNode, sizeof(CmLList));
1810 hqP->ulDrxHarqCb.rttExpIndex = SCH_DRX_INVALID_INDEX;
1815 * @brief Handling of the expiry Ul harq retransmission DRX timers for Ul scheduling
1819 * Function : schHdlUlHqRetxExpiryTimerForUl
1821 * Handling of expiry Ul harq retransmission DRX timers for Ul scheduling
1823 * @param[in] SchCellCb *cell
1829 void schHdlUlHqRetxExpiryTimerForUl(SchCellCb *cell, uint16_t currIdx)
1833 CmLList *drxCurrNode;
1835 drxCurrNode = cell->drxCb[currIdx].ulRetransExpiryList.first;
1839 hqP = (SchUlHqProcCb*)drxCurrNode->node;
1840 ueCb = hqP->hqEnt->ue;
1841 drxCurrNode = drxCurrNode->next;
1843 /* Set the Ue status as inactive for uplink */
1844 ueCb->drxUeCb.drxUlUeActiveMaskForHarq &= ~(SCH_DRX_UL_HARQ_BITMASK << hqP->procId);
1845 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
1848 cmLListDelFrm(&cell->drxCb[currIdx].ulRetransExpiryList, hqP->ulDrxHarqCb.retxExpNode);
1849 SCH_FREE(hqP->ulDrxHarqCb.retxExpNode, sizeof(CmLList));
1850 hqP->ulDrxHarqCb.retxExpIndex = SCH_DRX_INVALID_INDEX;
1856 * @brief Handling of the expiry of Ul harq DRX timers
1860 * Function : schHdlDrxUlHarqExpireTimer
1862 * Handling of expiry of Ul harq DRX timers
1864 * @param[in] SchCellCb *cell
1870 void schHdlDrxUlHarqExpireTimer(SchCellCb *cell)
1872 uint16_t dlIndx = 0, ulIndx = 0;
1873 SlotTimingInfo dlSlotInfo, ulSlotInfo;
1875 ADD_DELTA_TO_TIME(cell->slotInfo, dlSlotInfo, PHY_DELTA_DL + SCHED_DELTA, cell->numSlots);
1876 ADD_DELTA_TO_TIME(cell->slotInfo, ulSlotInfo, PHY_DELTA_UL + SCHED_DELTA, cell->numSlots);
1877 dlIndx = (dlSlotInfo.sfn*MAX_SLOTS+dlSlotInfo.slot)%MAX_DRX_SIZE;
1878 ulIndx = (ulSlotInfo.sfn*MAX_SLOTS+ulSlotInfo.slot)%MAX_DRX_SIZE;
1880 schHdlUlHqRttExpiryTimerForDl(cell, dlIndx);
1881 schHdlUlHqRetxExpiryTimerForDl(cell, dlIndx);
1882 schHdlUlHqRttExpiryTimerForUl(cell, ulIndx );
1883 schHdlUlHqRetxExpiryTimerForUl(cell, ulIndx);
1887 * @brief Hanuling of the expiry of harq DRX timers
1891 * Function : schDrxStopUlHqRetxTmr
1893 * Hanuling of expiry DRX timers
1895 * @param[in] SchCellCb *cell
1901 void schDrxStopUlHqRetxTmr(SchCellCb *cell, SchUeCb *ueCb, SchUlHqProcCb **hqP)
1904 if((*hqP)->ulDrxHarqCb.retxExpIndex != SCH_DRX_INVALID_INDEX)
1906 ueCb->drxUeCb.drxDlUeActiveMaskForHarq &= ~(SCH_DRX_DL_HARQ_BITMASK << (*hqP)->procId);
1907 ueCb->drxUeCb.drxUlUeActiveMaskForHarq &= ~(SCH_DRX_UL_HARQ_BITMASK << (*hqP)->procId);
1909 /* Change the UE status to Inactive */
1910 setDrxUeStatusForDlandUl(&ueCb->drxUeCb);
1912 /* If there is any node present in rtt list then remove the node from list */
1913 if((*hqP)->ulDrxHarqCb.rttExpIndex != SCH_DRX_INVALID_INDEX)
1915 cmLListDelFrm(&cell->drxCb[(*hqP)->ulDrxHarqCb.rttExpIndex].ulHarqRttExpiryList, (*hqP)->ulDrxHarqCb.rttExpNode);
1916 SCH_FREE((*hqP)->ulDrxHarqCb.rttExpNode, sizeof(CmLList));
1917 (*hqP)->ulDrxHarqCb.rttExpIndex = SCH_DRX_INVALID_INDEX;
1920 /* If there is any node present in retx list then remove the node from list */
1921 if((*hqP)->ulDrxHarqCb.retxStrtIndex != SCH_DRX_INVALID_INDEX)
1923 cmLListDelFrm(&cell->drxCb[(*hqP)->ulDrxHarqCb.retxStrtIndex].ulRetransTmrStartList, (*hqP)->ulDrxHarqCb.retxStrtNode);
1924 SCH_FREE((*hqP)->ulDrxHarqCb.retxStrtNode, sizeof(CmLList));
1925 (*hqP)->ulDrxHarqCb.retxStrtIndex = SCH_DRX_INVALID_INDEX;
1928 cmLListDelFrm(&cell->drxCb[(*hqP)->ulDrxHarqCb.retxExpIndex].ulRetransExpiryList, (*hqP)->ulDrxHarqCb.retxExpNode);
1929 SCH_FREE((*hqP)->ulDrxHarqCb.retxExpNode, sizeof(CmLList));
1930 (*hqP)->ulDrxHarqCb.retxExpIndex = SCH_DRX_INVALID_INDEX;
1935 * @brief Handling of the expiry DRX timers
1939 * Function : schHandleExpiryDrxTimer
1941 * Handling of expiry DRX timers
1943 * @param[in] SchCellCb *cell
1949 void schHandleExpiryDrxTimer(SchCellCb *cell)
1951 schHdlDrxShortCycleExpiryTimer(cell);
1952 schHdlDrxOnDurExpiryTimer(cell);
1953 schHdlDrxInActvExpiryTimer(cell);
1954 schHdlDrxDlHarqExpireTimer(cell);
1955 schHdlDrxUlHarqExpireTimer(cell);
1959 /**********************************************************************
1961 **********************************************************************/