6ca545b035b5626002f66edb380a86840961d7e7
[o-du/l2.git] / src / 5gnrsch / sch_rach.c
1 /*******************************************************************************
2 ################################################################################
3 #   Copyright (c) [2017-2019] [Radisys]                                        #
4 #                                                                              #
5 #   Licensed under the Apache License, Version 2.0 (the "License");            #
6 #   you may not use this file except in compliance with the License.           #
7 #   You may obtain a copy of the License at                                    #
8 #                                                                              #
9 #       http://www.apache.org/licenses/LICENSE-2.0                             #
10 #                                                                              #
11 #   Unless required by applicable law or agreed to in writing, software        #
12 #   distributed under the License is distributed on an "AS IS" BASIS,          #
13 #   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   #
14 #   See the License for the specific language governing permissions and        #
15 #   limitations under the License.                                             #
16 ################################################################################
17 *******************************************************************************/
18
19 /************************************************************************
20  
21      Name:     sch_rach.c
22   
23      Type:     C source file
24   
25      Desc:     C source code for rach handling functions
26   
27      File:     sch_rach.c
28   
29 **********************************************************************/
30
31 /** @file sch_rach.c
32 @brief This file implements the rach handling.
33 */
34 #include "common_def.h"
35 #include "tfu.h"
36 #include "lrg.h"
37 #include "tfu.x"
38 #include "lrg.x"
39 #include "du_log.h"
40 #include "du_app_mac_inf.h"
41 #include "mac_sch_interface.h"
42 #include "sch.h"
43 #include "sch_utils.h"
44
45 SchRachRsrcRspFunc SchRachRsrcRspOpts[] =
46 {
47    packSchRachRsrcRsp,      /* LC */
48    MacProcSchRachRsrcRsp,   /* TC */
49    packSchRachRsrcRsp       /* LWLC */
50 };
51
52 /**
53  * @brief Checks if PRACH can be scheduled in current slot
54  *
55  * @details
56  *
57  *     Function : schCheckPrachOcc
58  *
59  *     This function checks if PRACH can be scheduled in 
60  *     current slot
61  *
62  *  @param[in]  Cell Cb
63  *              Slot timing
64  *  @return  TRUE
65  *           FALSE
66  **/
67 bool schCheckPrachOcc(SchCellCb *cell, SlotTimingInfo prachOccasionTimingInfo)
68 {
69    uint8_t  prachCfgIdx = 0;
70    uint8_t  x = 0;
71    uint8_t  y = 0;
72    uint8_t  subFrame = 0;
73    uint16_t prachSubframe = 0;
74
75    prachCfgIdx      = cell->cellCfg.schRachCfg.prachCfgIdx;
76
77    /* derive the prachCfgIdx table paramters */
78    x                = prachCfgIdxTable[prachCfgIdx][1];
79    y                = prachCfgIdxTable[prachCfgIdx][2];
80    prachSubframe    = prachCfgIdxTable[prachCfgIdx][3];
81
82    if((prachOccasionTimingInfo.sfn%x) == y)
83    {
84       subFrame = prachOccasionTimingInfo.slot/pow(2, cell->cellCfg.numerology);
85
86       /* check for subFrame number */
87       if ((1 << subFrame) & prachSubframe)
88       {
89          /* prach ocassion present in this subframe */
90 #ifdef NR_TDD
91          if(UL_SLOT != schGetSlotSymbFrmt(prachOccasionTimingInfo.slot % cell->numSlotsInPeriodicity,\
92          cell->slotFrmtBitMap))
93          {
94             DU_LOG("\nERROR  --> SCH : PrachCfgIdx %d doesn't support UL slot", prachCfgIdx);
95             return FALSE;
96          }
97 #endif
98          return TRUE;
99       }
100    }
101    return FALSE;
102 }
103
104 /**
105  * @brief Calculate number of PRBs to be allocated for PRACH 
106  *
107  * @details
108  *
109  *     Function : schCalcPrachNumRb
110  *
111  *     Calculate number of PRBs to be allocated for PRACH
112  *
113  *  @param[in]  SchCellCb *cell, cell cb
114  *  @return  Number of PRBs
115  **/
116 uint8_t schCalcPrachNumRb(SchCellCb *cell)
117 {
118    uint8_t tableIdx = 0;
119    uint16_t puschScs = convertScsEnumValToScsVal(cell->cellCfg.schInitialUlBwp.bwp.scs);
120
121    for(tableIdx=0; tableIdx < MAX_RACH_NUM_RB_IDX; tableIdx++)
122    {
123       if((numRbForPrachTable[tableIdx][0] == cell->cellCfg.schRachCfg.rootSeqLen) &&
124             (numRbForPrachTable[tableIdx][1] == cell->cellCfg.schRachCfg.prachSubcSpacing) &&
125             (numRbForPrachTable[tableIdx][2] == puschScs))
126       {
127          return numRbForPrachTable[tableIdx][3];
128       }
129    }
130    return 0;
131 }
132
133 /**
134  * @brief resource allocation for PRACH
135  *
136  * @details
137  *
138  *     Function : schPrachResAlloc
139  *
140  *     This function handles PRACH allocation
141  *
142  *  @param[in]  SchCellCb *cell, cell cb
143  *  @param[in]  UlSchedInfo *ulSchedInfo, UL scheduling info
144  *  @return  void
145  **/
146 void schPrachResAlloc(SchCellCb *cell, UlSchedInfo *ulSchedInfo, SlotTimingInfo prachOccasionTimingInfo)
147 {
148    uint8_t  numPrachRb = 0;
149    uint8_t  numRa = 0;
150    uint8_t  prachCfgIdx = 0;
151    uint8_t  prachFormat = 0;
152    uint8_t  prachStartSymbol = 0;
153    uint8_t  prachDuration = 0;
154    uint8_t  prachOcas = 0;
155    uint8_t  dataType = 0;
156    uint16_t freqStart = 0;
157
158    if(cell == NULLP)
159    {
160       DU_LOG("\nERROR  --> SCH : schPrachResAlloc(): Received cellCb is null");
161       return;
162    }
163
164    /* If this slot is not a PRACH occassion, return */
165    if(!schCheckPrachOcc(cell, prachOccasionTimingInfo))
166       return;
167
168    prachCfgIdx      = cell->cellCfg.schRachCfg.prachCfgIdx;
169    prachFormat      = prachCfgIdxTable[prachCfgIdx][0];
170    prachStartSymbol = prachCfgIdxTable[prachCfgIdx][4];
171    prachOcas        = prachCfgIdxTable[prachCfgIdx][6];
172    prachDuration    = prachCfgIdxTable[prachCfgIdx][7];
173
174    /* numRa determined as 𝑛 belonging {0,1,.., M − 1},
175     * where M is given by msg1Fdm */
176    numRa = (cell->cellCfg.schRachCfg.msg1Fdm - 1);
177
178    /* freq domain resource determination for RACH*/
179    freqStart = cell->cellCfg.schRachCfg.msg1FreqStart;
180    numPrachRb = schCalcPrachNumRb(cell);
181    /* Allocate PRACH resources from the UL resource bitmap */
182    allocatePrbUl(cell, prachOccasionTimingInfo, prachStartSymbol, prachDuration, &freqStart, numPrachRb);
183
184    /* prach info */
185    dataType |= SCH_DATATYPE_PRACH;
186    ulSchedInfo->dataType = dataType;
187    ulSchedInfo->prachSchInfo.numPrachOcas   = prachOcas;
188    ulSchedInfo->prachSchInfo.prachFormat    = prachFormat;
189    ulSchedInfo->prachSchInfo.numRa          = numRa;
190    ulSchedInfo->prachSchInfo.prachStartSymb = prachStartSymbol;
191    DU_LOG("\nINFO  --> SCH : RACH occassion set for slot %d", prachOccasionTimingInfo.slot);
192 }
193
194 /**
195  * @brief Process RACH resource request for CFRA
196  *
197  * @details
198  *
199  *     Function : MacSchRachRsrcReq
200  *     
201  *     This function processes RACH resorce request 
202  *     from MAC for CFRA. It assigns a dedicated preamble
203  *     to the UE and sends the same in RACH resource
204  *     response
205  *     
206  *  @param[in]  Post structure
207  *  @param[in]  RACH resource request
208  *  @return     ROK
209  *              RFAILED
210  **/
211 uint8_t MacSchRachRsrcReq(Pst *pst, SchRachRsrcReq *schRachRsrcReq)
212 {
213    uint8_t      ssbIdx = 0, cfraSsbIdx = 0;
214    uint8_t      firstCFPreambleIndex = 0, lastCFPreambleIndex = 0;
215    uint16_t     cellIdx = 0;
216    uint64_t     mask = 0;
217    Pst          rspPst;
218    Inst         inst = pst->dstInst - SCH_INST_START;
219    SchCellCb    *cellCb = NULLP;
220    SchUeCb      *ueCb = NULLP;
221    SchRachRsrcRsp *rachRsrcRsp = NULLP;
222
223    DU_LOG("\nINFO  -->  SCH : Received RACH resource request for Cell ID [%d] CRNTI [%d]", \
224          schRachRsrcReq->cellId, schRachRsrcReq->crnti);
225
226  /* Fill RACH resource response to MAC */
227    SCH_ALLOC(rachRsrcRsp, sizeof(SchRachRsrcRsp));
228    if(!rachRsrcRsp)
229    {   
230       DU_LOG("\nERROR  -->  SCH : Memory allocation failed for RACH resource response");
231       return RFAILED;
232    }   
233    rachRsrcRsp->cellId = schRachRsrcReq->cellId;
234    rachRsrcRsp->crnti = schRachRsrcReq->crnti;
235    rachRsrcRsp->result = RSP_OK;
236
237    /* Fill SCH to MAC Pst structure */
238    memset(&rspPst, 0, sizeof(Pst));
239    FILL_PST_SCH_TO_MAC(rspPst, inst);
240    rspPst.event = EVENT_RACH_RESOURCE_RESPONSE_TO_MAC;
241
242    /* Fetch Cell CB */
243    for(cellIdx = 0; cellIdx < MAX_NUM_CELL; cellIdx++)
244    {
245       if((schCb[inst].cells[cellIdx]) && (schCb[inst].cells[cellIdx]->cellId == schRachRsrcReq->cellId))
246       {
247          cellCb = schCb[inst].cells[cellIdx];
248          break;
249       }
250    }
251    
252    if(cellCb)
253    {
254       /* Fetch UE CB */
255       ueCb = schGetUeCb(cellCb, schRachRsrcReq->crnti);
256       if(ueCb->crnti != schRachRsrcReq->crnti)
257       {
258          DU_LOG("\nERROR  -->  SCH : CRNTI [%d] not found" ,schRachRsrcReq->crnti);
259          rachRsrcRsp->result = RSP_NOK;
260       }
261    }
262    else
263    {
264       DU_LOG("\nERROR  -->  SCH : Cell ID [%d] not found" ,schRachRsrcReq->cellId);
265       rachRsrcRsp->result = RSP_NOK;
266    }
267
268    /* Allocate SSB resource if no failure has occurred until this step */
269    if(rachRsrcRsp->result == RSP_OK)
270    {
271       /* Find first free preamble index from the pool CF preambles 
272        * Preamble index from 0 to (numCbPreamblePerSsb-1) is used for CBRA 
273        * Preamble index from numCbPreamblePerSsb to totalNumOfRAPreamble
274        * is used for CFRA */
275       firstCFPreambleIndex = cellCb->cellCfg.schRachCfg.numCbPreamblePerSsb;
276       lastCFPreambleIndex = cellCb->cellCfg.schRachCfg.totalNumRaPreamble;
277
278       /* Allocate resource for each SSB index requested */
279       for(ssbIdx = 0; ssbIdx < schRachRsrcReq->numSsb; ssbIdx++)
280       {
281          /* Find the first CF Preamble index not dedicated to any UE currently */
282          while(firstCFPreambleIndex <= lastCFPreambleIndex)
283          {
284             mask = 1 << firstCFPreambleIndex;
285             if(cellCb->dedPreambleBitMap & mask)
286             {
287                firstCFPreambleIndex++;
288                continue;
289             }
290             else
291                break;
292          }
293
294          /* If firstCFPreambleIndex > lastCFPreambleIndex, it means all
295           * dedicated preambles are in use currently. In such a case, CBRA
296           * should be initiated. 
297           * If a dedicated preamble is found, use this for CFRA and mark it as
298           * IN-USE in the bitmap.
299           * Considering only CFRA scenario for now. */
300          if(firstCFPreambleIndex <= lastCFPreambleIndex)
301          {
302             ueCb->cfraResource.ssbResource[cfraSsbIdx].ssbIdx = schRachRsrcReq->ssbIdx[ssbIdx]; 
303             ueCb->cfraResource.ssbResource[cfraSsbIdx].raPreambleIdx = firstCFPreambleIndex;
304             SET_ONE_BIT(firstCFPreambleIndex, cellCb->dedPreambleBitMap);
305             cfraSsbIdx++;
306             firstCFPreambleIndex++;
307          }
308          else
309          {
310             DU_LOG("\nINFO : SCH : No dedicated preameble availble to assign to ssbIdx[%d]", schRachRsrcReq->ssbIdx[ssbIdx]);
311             /* Breaking out of for loop since no dedicated preambles are available
312              * for remaining ssbIdx too */
313             break;
314          }
315       } /* End of for */
316
317       ueCb->cfraResource.numSsb = cfraSsbIdx;
318
319       if(ueCb->cfraResource.numSsb == 0)
320       {
321          /* If numSsb is 0, it means no CFRA resource was alloacted for any of the
322           * SSB Idx, hence send a negative response */
323          rachRsrcRsp->result = RSP_NOK;
324       }
325       else
326       {   
327          /* Send ssb resource information to MAC in RACH resource response */
328          rachRsrcRsp->cfraResource.numSsb = ueCb->cfraResource.numSsb;
329          memcpy(rachRsrcRsp->cfraResource.ssbResource, ueCb->cfraResource.ssbResource, \
330             ueCb->cfraResource.numSsb * sizeof(SchCfraSsbResource));
331       }
332    } /* End of if */
333
334    /* Free RACH resource request memory allocated by MAC */
335    SCH_FREE(schRachRsrcReq, sizeof(SchRachRsrcReq));
336
337    /* Send RACH resource response to MAC */
338    return (SchRachRsrcRspOpts[rspPst.selector](&rspPst, rachRsrcRsp));
339 }
340
341 /**
342  * @brief calculate ra-rnti function. 
343  *
344  * @details
345  *
346  *     Function : calculateRaRnti
347  *     
348  *     This function calculates ra-rnti
349  *     
350  *  @param[in]  symbol index
351  *  @param[in]  slot index
352  *  @param[in]  frequency index
353  *  @return  ra-rnti
354  **/
355 uint16_t calculateRaRnti(uint8_t symbolIdx, uint8_t slotIdx, uint8_t freqIdx)
356 {
357    uint16_t raRnti = 0;
358    uint8_t  ulCarrierIdx = 0; /* Uplink carrier used for MSG1 transmission. 0:NUL carrier; 1:SUL carrier */
359    
360    /* Refer to spec 38.321, section 5.1.3 */
361    raRnti = (1 + symbolIdx + (14*slotIdx) + (14*80*freqIdx) + (14*80*8*ulCarrierIdx));
362    return raRnti;
363 }
364
365 /**
366  * @brief create raCb function. 
367  *
368  * @details
369  *
370  *     Function : createSchRaCb
371  *     
372  *     This function create raCb
373  *     
374  *  @param[in]  tcrnti
375  *  @param[in]  shed instance
376  *  @return  void
377  **/
378 void createSchRaCb(uint16_t tcrnti, Inst schInst)
379 {
380    uint8_t ueId = 0;
381
382    GET_UE_ID(tcrnti, ueId);
383    schCb[schInst].cells[schInst]->raCb[ueId -1].tcrnti = tcrnti;
384    schCb[schInst].cells[schInst]->raCb[ueId -1].msg4recvd = FALSE;
385 }
386
387 /**
388  * @brief resource allocation for msg3 PUSCH
389  *
390  * @details
391  *
392  *     Function : schAllocMsg3Pusch 
393  *     
394  *     This function handles msg3 PUSCH allocation
395  *     
396  *  @param[in]  Inst schInst, SCH instance
397  *  @param[in]  slot, current slot
398  *  @param[out]  msg3StartRb
399  *  @param[out]  msg3NumRb
400  *  @return  void
401  **/
402 SchPuschInfo* schAllocMsg3Pusch(Inst schInst, uint16_t crnti, uint8_t k2Index, SlotTimingInfo msg3SlotTime)
403 {
404    SchCellCb      *cell          = NULLP;
405    SchUlSlotInfo  *schUlSlotInfo = NULLP;
406    uint8_t    mcs       = DEFAULT_MCS;
407    uint8_t    startSymb = 0;
408    uint8_t    symbLen   = 0; 
409    uint16_t   startRb   = 0;
410    uint16_t   numRb     = 0;
411    uint16_t   tbSize    = 0;
412
413    cell = schCb[schInst].cells[schInst];
414    if(cell == NULL)
415    {
416       DU_LOG("\n\nERROR  -->  SCH :  Failed to find cell in schAllocMsg3Pusch");
417       return NULLP;
418    }
419
420    /* Allocate time-domain and frequency-domain resource for MSG3 PUSCH */
421    startSymb = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].startSymbol;
422    symbLen = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].symbolLength;
423
424    startRb = MAX_NUM_RB;
425    tbSize = schCalcTbSize(8); /* 6 bytes msg3 and 2 bytes header */
426    numRb = schCalcNumPrb(tbSize, mcs, symbLen);
427    numRb++; /* allocating 1 extra RB for now */
428    allocatePrbUl(cell, msg3SlotTime, startSymb, symbLen, &startRb, numRb);
429
430    /* Fill PUSCH scheduling details in Slot structure */
431    schUlSlotInfo = cell->schUlSlotInfo[msg3SlotTime.slot];
432    SCH_ALLOC(schUlSlotInfo->schPuschInfo, sizeof(SchPuschInfo));
433    if(!schUlSlotInfo->schPuschInfo)
434    {
435       DU_LOG("\nERROR  -->  SCH :  Memory allocation failed in schAllocMsg3Pusch");
436       return NULLP;
437    }
438
439    tbSize = 0;  /* since nPrb has been incremented, recalculating tbSize */
440    tbSize = schCalcTbSizeFromNPrb(numRb, mcs, NUM_PDSCH_SYMBOL);
441    tbSize = tbSize / 8 ; /*bits to byte conversion*/
442
443    schUlSlotInfo->schPuschInfo->crnti             = crnti;
444    schUlSlotInfo->schPuschInfo->harqProcId        = SCH_HARQ_PROC_ID;
445    schUlSlotInfo->schPuschInfo->resAllocType      = SCH_ALLOC_TYPE_1;
446    schUlSlotInfo->schPuschInfo->fdAlloc.startPrb  = startRb;
447    schUlSlotInfo->schPuschInfo->fdAlloc.numPrb    = numRb;
448    schUlSlotInfo->schPuschInfo->tdAlloc.startSymb = startSymb;
449    schUlSlotInfo->schPuschInfo->tdAlloc.numSymb   = symbLen;
450    schUlSlotInfo->schPuschInfo->tbInfo.qamOrder   = QPSK_MODULATION;  /* QPSK modulation */
451    schUlSlotInfo->schPuschInfo->tbInfo.mcs           = mcs;
452    schUlSlotInfo->schPuschInfo->tbInfo.mcsTable   = SCH_MCS_TABLE_QAM_64;
453    schUlSlotInfo->schPuschInfo->tbInfo.ndi        = NEW_TRANSMISSION; /* new transmission */
454    schUlSlotInfo->schPuschInfo->tbInfo.rv               = 0;
455    schUlSlotInfo->schPuschInfo->tbInfo.tbSize     = tbSize;
456    schUlSlotInfo->schPuschInfo->dmrsMappingType   = DMRS_MAP_TYPE_A;  /* Setting Type-A */
457    schUlSlotInfo->schPuschInfo->nrOfDmrsSymbols   = NUM_DMRS_SYMBOLS;
458    schUlSlotInfo->schPuschInfo->dmrsAddPos        = DMRS_ADDITIONAL_POS;
459
460    return schUlSlotInfo->schPuschInfo;
461 }
462
463 /**
464  * @brief Check if a time frame is in RA Response window
465  *
466  * @details
467  *
468  *     Function : isInRaRspWindow
469  *
470  *     Check if a time frame is in RA Response window
471  *
472  *  @param[in]  RA request
473  *  @param[in]  Time frame to check
474  *  @param[in]  Total number of slot per radio frame
475  *  @return  true 
476  *  @return  false
477  **/
478 RaRspWindowStatus isInRaRspWindow(SchRaReq *raReq, SlotTimingInfo frameToCheck, uint16_t numSlotsPerSystemFrame)
479 {
480    uint32_t winStartTime, winEndTime, timeToCheck;
481    
482    winStartTime = (raReq->winStartTime.sfn * numSlotsPerSystemFrame) + raReq->winStartTime.slot;
483    winEndTime = (raReq->winEndTime.sfn * numSlotsPerSystemFrame) + raReq->winEndTime.slot;
484    timeToCheck = (frameToCheck.sfn * numSlotsPerSystemFrame) + frameToCheck.slot;
485
486    /* TODO : check how to handle the wrap around scenario of MAX_SFN */
487    if((timeToCheck >= winStartTime) && (timeToCheck <= winEndTime))
488       return WITHIN_WINDOW;
489    else if(timeToCheck < winStartTime)
490       return WINDOW_YET_TO_START;
491       
492    return WINDOW_EXPIRED;
493 }
494
495 /**
496  * @brief Processes any pending RA request
497  *
498  * @details
499  *
500  *     Function : schProcessRaReq
501  *
502  *     This function process pending RA request
503  *
504  *  @param[in]  Current timing of the cell
505  *  @return  ROK
506  **/
507 bool schProcessRaReq(Inst schInst, SchCellCb *cell, SlotTimingInfo currTime, uint8_t ueId)
508 {
509    bool      k2Found = false;
510    uint8_t   k0TblIdx = 0, k2TblIdx = 0;
511    uint8_t   k0Index = 0, k2Index = 0;
512    uint8_t   k0 = 0, k2 = 0;
513    uint8_t   puschMu = 0;
514    uint8_t   msg3Delta = 0, msg3MinSchTime = 0;
515 #ifdef NR_TDD
516    uint8_t   totalCfgSlot = 0;
517 #endif
518    uint16_t             dciSlot = 0, rarSlot = 0;
519    SlotTimingInfo       dciTime, rarTime, msg3Time;
520    RarAlloc             *dciSlotAlloc = NULLP;    /* Stores info for transmission of PDCCH for RAR */
521    RarAlloc             *rarSlotAlloc = NULLP;    /* Stores info for transmission of RAR PDSCH */
522    SchPuschInfo         *msg3PuschInfo = NULLP;   /* Stores MSG3 PUSCH scheduling information */
523    SchK0K1TimingInfoTbl *k0K1InfoTbl=NULLP;    
524    SchK2TimingInfoTbl   *msg3K2InfoTbl=NULLP;
525    RaRspWindowStatus    windowStatus=0;
526
527 #ifdef NR_TDD
528    totalCfgSlot = calculateSlotPatternLength(cell->cellCfg.ssbSchCfg.scsCommon, cell->cellCfg.tddCfg.tddPeriod);
529 #endif
530    k0K1InfoTbl = &cell->cellCfg.schInitialDlBwp.k0K1InfoTbl;
531    msg3K2InfoTbl = &cell->cellCfg.schInitialUlBwp.msg3K2InfoTbl;
532    puschMu = cell->cellCfg.numerology;
533    msg3Delta = puschDeltaTable[puschMu];
534    msg3MinSchTime = minMsg3SchTime[cell->cellCfg.numerology];
535
536    /* Calculating time frame to send DCI for RAR */
537    ADD_DELTA_TO_TIME(currTime, dciTime, PHY_DELTA_DL + SCHED_DELTA);
538    dciSlot = dciTime.slot;
539 #ifdef NR_TDD
540    /* Consider this slot for sending DCI, only if it is a DL slot */
541    if(schGetSlotSymbFrmt(dciSlot, cell->slotFrmtBitMap) == DL_SLOT)
542 #endif
543    {
544       /* If PDCCH is already scheduled on this slot, cannot schedule PDSCH for another UE here. */
545       if(cell->schDlSlotInfo[dciSlot]->pdcchUe != 0)
546          return false;
547
548       /* Check if this slot is within RA response window */
549       windowStatus = isInRaRspWindow(cell->raReq[ueId-1], dciTime, cell->numSlots);
550       if(windowStatus == WITHIN_WINDOW)
551       {
552          /* For all k0 values, search for a suitable k2 value to schedule MSG3.
553           * RAR DCI, RAR PDSCH and MSG3 is scheduled only if one such k0-k2 combination
554           * is found. Else no scheduling happens. 
555           */
556          for(k0TblIdx = 0; k0TblIdx < k0K1InfoTbl->k0k1TimingInfo[dciSlot].numK0; k0TblIdx++)
557          {
558             k0Index = k0K1InfoTbl->k0k1TimingInfo[dciSlot].k0Indexes[k0TblIdx].k0Index;
559             k0 = cell->cellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[k0Index].k0;
560
561             /* Calculating time frame to send RAR PDSCH */
562             ADD_DELTA_TO_TIME(dciTime, rarTime, k0);
563             rarSlot = rarTime.slot;
564             
565             /* If PDSCH is already scheduled on this slot, cannot schedule PDSCH for another UE here. */
566             if(cell->schDlSlotInfo[rarSlot]->pdschUe != 0)
567                continue;
568
569             for(k2TblIdx = 0; k2TblIdx < msg3K2InfoTbl->k2TimingInfo[rarSlot].numK2; k2TblIdx++)
570             {
571                k2Index = msg3K2InfoTbl->k2TimingInfo[rarSlot].k2Indexes[k2TblIdx];
572                k2 = cell->cellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[k2Index].k2;
573
574                /* Delta is added to the slot allocation for msg3 based on 38.214 section 6.1.2.1 */
575                k2 = k2 + msg3Delta;
576                if(k2 >= msg3MinSchTime)
577                {
578                   ADD_DELTA_TO_TIME(rarTime, msg3Time, k2);
579 #ifdef NR_TDD
580                   if(schGetSlotSymbFrmt(msg3Time.slot % totalCfgSlot, cell->slotFrmtBitMap) == DL_SLOT)
581                      continue;
582 #endif
583                   /* If PUSCH is already scheduled on this slot, another PUSCH
584                    * pdu cannot be scheduled here */
585                   if(cell->schUlSlotInfo[msg3Time.slot]->puschUe != 0)
586                      continue;
587
588                   k2Found = true;
589                   break;
590                }
591             }
592             if(k2Found)
593                break;
594          }
595       }
596       else if(windowStatus == WINDOW_EXPIRED)
597       {
598          SCH_FREE(cell->raReq[ueId-1]->rachInd, sizeof(RachIndInfo));
599          SCH_FREE(cell->raReq[ueId-1], sizeof(SchRaReq));
600          return false;
601       }
602
603       /* If K0-K2 combination not found, no scheduling happens */
604       if(!k2Found)
605          return false;
606
607       /* Allocate memory for RAR PDCCH slot, pointer will be checked at schProcessSlotInd() */
608       SCH_ALLOC(dciSlotAlloc, sizeof(RarAlloc));
609       if(dciSlotAlloc == NULLP)
610       {
611          DU_LOG("\nERROR  -->  SCH : Memory Allocation failed for dciSlotAlloc");
612          return false;
613       }
614       cell->schDlSlotInfo[dciSlot]->rarAlloc[ueId-1] = dciSlotAlloc;
615
616       /* Fill PDCCH and PDSCH scheduling information for RAR */
617       if((schFillRar(cell, rarTime, ueId, dciSlotAlloc, k0Index)) != ROK)
618       {
619          DU_LOG("\nERROR  -->  SCH: Scheduling of RAR failed in slot [%d]", rarSlot);
620          SCH_FREE(dciSlotAlloc, sizeof(RarAlloc));
621          cell->schDlSlotInfo[dciSlot]->rarAlloc[ueId-1] = NULLP;
622          return false;
623       }
624
625       /* Allocate resources for msg3 */
626       msg3PuschInfo = schAllocMsg3Pusch(schInst, cell->raReq[ueId-1]->rachInd->crnti, k2Index, msg3Time);
627       if(msg3PuschInfo)
628       {
629          /* Fill RAR info */
630          dciSlotAlloc->rarInfo.raRnti = cell->raReq[ueId-1]->raRnti;
631          dciSlotAlloc->rarInfo.tcrnti = cell->raReq[ueId-1]->rachInd->crnti;
632          dciSlotAlloc->rarInfo.RAPID = cell->raReq[ueId-1]->rachInd->preambleIdx;
633          dciSlotAlloc->rarInfo.ta = cell->raReq[ueId-1]->rachInd->timingAdv;
634          dciSlotAlloc->rarInfo.ulGrant.bwpSize = cell->cellCfg.schInitialUlBwp.bwp.freqAlloc.numPrb;
635          /* Spec 38.213, section 8.2, 0 : MSG3 PUSCH will be transmitted without frequency hopping */
636          dciSlotAlloc->rarInfo.ulGrant.freqHopFlag = 0;
637          dciSlotAlloc->rarInfo.ulGrant.msg3FreqAlloc.startPrb = msg3PuschInfo->fdAlloc.startPrb;
638          dciSlotAlloc->rarInfo.ulGrant.msg3FreqAlloc.numPrb = msg3PuschInfo->fdAlloc.numPrb;
639          dciSlotAlloc->rarInfo.ulGrant.k2Index = k2Index;
640          dciSlotAlloc->rarInfo.ulGrant.mcs = msg3PuschInfo->tbInfo.mcs;
641          dciSlotAlloc->rarInfo.ulGrant.tpc = 3;  /* TODO : Check appropriate value to be filled */
642          /* Spec 38.213, section 8.2 : In a contention based random access
643           * procedure, the CSI request field is reserved. */
644          dciSlotAlloc->rarInfo.ulGrant.csiReq = 0;
645       }
646
647       /* Check if both DCI and RAR are sent in the same slot.
648        * If not, allocate memory RAR PDSCH slot to store RAR info
649        */
650       if(dciSlot == rarSlot)
651          dciSlotAlloc->pduPres = BOTH;
652       else
653       {
654          /* Allocate memory to schedule rarSlot to send RAR, pointer will be checked at schProcessSlotInd() */
655          SCH_ALLOC(rarSlotAlloc, sizeof(RarAlloc));
656          if(rarSlotAlloc == NULLP)
657          {
658             DU_LOG("\nERROR  -->  SCH : Memory Allocation failed for rarSlotAlloc");
659             SCH_FREE(dciSlotAlloc, sizeof(RarAlloc));
660             cell->schDlSlotInfo[dciSlot]->rarAlloc[ueId-1] = NULLP;
661             return false;
662          }
663          cell->schDlSlotInfo[rarSlot]->rarAlloc[ueId-1] = rarSlotAlloc;
664
665          /* Copy all RAR info */
666          memcpy(rarSlotAlloc, dciSlotAlloc, sizeof(RarAlloc));
667          rarSlotAlloc->rarPdcchCfg.dci.pdschCfg = &rarSlotAlloc->rarPdschCfg;
668
669          /* Assign correct PDU types in corresponding slots */
670          rarSlotAlloc->pduPres = PDSCH_PDU;
671          dciSlotAlloc->pduPres = PDCCH_PDU;
672          dciSlotAlloc->pdschSlot = rarSlot;  
673       }
674
675       cell->schDlSlotInfo[dciSlot]->pdcchUe = ueId;
676       cell->schDlSlotInfo[rarSlot]->pdschUe = ueId;
677       cell->schUlSlotInfo[msg3Time.slot]->puschUe = ueId;
678
679       /* Create raCb at SCH */
680       createSchRaCb(cell->raReq[ueId-1]->rachInd->crnti, schInst);
681
682       /* Remove RachInd from pending RA request list */
683       SCH_FREE(cell->raReq[ueId-1]->rachInd, sizeof(RachIndInfo));
684       SCH_FREE(cell->raReq[ueId-1], sizeof(SchRaReq));
685       
686       return true;
687    }
688    return false;
689 }
690
691 /**
692  * @brief process rach indication function. 
693  *
694  * @details
695  *
696  *     Function : schProcessRachInd
697  *     
698  *     This function process rach indication
699  *     
700  *  @param[in]  rachInd parameters
701  *  @param[in]  shed instance
702  *  @return  ROK
703  **/
704 uint8_t schProcessRachInd(RachIndInfo *rachInd, Inst schInst)
705 {
706    SchCellCb *cell = schCb[schInst].cells[schInst];
707    SchRaReq  *raReq = NULLP;
708    float    slotDuration;
709    uint8_t  winNumSlots;
710    uint8_t  ueId;
711
712    if(cell == NULLP)
713    {
714       DU_LOG("\nERROR  -->  SCH: Failed to find cell in schProcessRachInd");
715       return RFAILED;
716    }
717
718    /* Storing RA request in cellCb */
719    GET_UE_ID(rachInd->crnti, ueId);
720    if(ueId <= 0)
721    {
722       DU_LOG("\nERROR  -->  SCH: Invalid CRNTI [%d]", rachInd->crnti);
723       return RFAILED;
724    }
725
726    SCH_ALLOC(raReq, sizeof(SchRaReq));
727    if(!raReq)
728    {
729       DU_LOG("\nERROR  -->  SCH : Memory allocation failure in schProcessRachInd");
730       SCH_FREE(rachInd, sizeof(RachIndInfo));
731       return RFAILED;
732    }
733
734    /* calculate the ra-rnti value */
735    raReq->raRnti = calculateRaRnti(rachInd->symbolIdx, rachInd->slotIdx, rachInd->freqIdx);
736    raReq->rachInd = rachInd;
737    raReq->winStartTime.sfn = rachInd->timingInfo.sfn;
738    raReq->winStartTime.slot = rachInd->timingInfo.slot;
739   
740    /* Converting window size from ms to number of slots */
741    slotDuration = (1 / pow(2, cell->cellCfg.numerology));
742    winNumSlots = (float)cell->cellCfg.schRachCfg.raRspWindow / slotDuration;
743    
744    /* Adding window size to window start time to get window end time */
745    ADD_DELTA_TO_TIME(raReq->winStartTime, raReq->winEndTime, winNumSlots);
746    cell->raReq[ueId -1] = raReq;
747
748    /* Adding UE Id to list of pending UEs to be scheduled */
749    addUeToBeScheduled(cell, ueId);
750
751    return ROK;
752 }
753
754 /**
755  * @brief fill RAR info function. 
756  *
757  * @details
758  *
759  *     Function : calculateRaRnti
760  *     
761  *     This function fills pdcch and pdsch info for RAR
762  *     
763  *  @param[in]  rar Allocation info
764  *  @param[in]  ra-rnti
765  *  @param[in]  PCI
766  *  @param[in]  offset to pointA to determine freq alloc
767  *  @return  ROK
768  **/
769 uint8_t schFillRar(SchCellCb *cell, SlotTimingInfo rarTime, uint16_t ueId, RarAlloc *rarAlloc, uint8_t k0Index)
770 {
771    uint8_t  coreset0Idx = 0;
772    uint8_t  firstSymbol = 0, numSymbols = 0;
773    uint8_t  mcs = DEFAULT_MCS;  /* MCS fixed to 4 */
774    uint8_t  dmrsStartSymbol, startSymbol, numSymbol ;
775    uint16_t numRbs = 0;
776    uint16_t tbSize = 0;
777
778    SchBwpDlCfg *initialBwp = &cell->cellCfg.schInitialDlBwp;
779    PdcchCfg *pdcch = &rarAlloc->rarPdcchCfg;
780    PdschCfg *pdsch = &rarAlloc->rarPdschCfg;
781    BwpCfg *bwp = &rarAlloc->bwp;
782
783    /* derive the sib1 coreset0 params from table 13-1 spec 38.213 */
784    coreset0Idx     = initialBwp->pdcchCommon.commonSearchSpace.coresetId;
785    numRbs     = coresetIdxTable[coreset0Idx][1]; 
786    numSymbols = coresetIdxTable[coreset0Idx][2];
787
788    /* calculate time domain parameters */
789    // note: since slot value is made sl1, RAR can be sent at all slots
790    uint16_t mask = 0x2000;
791    for(firstSymbol=0; firstSymbol<MAX_SYMB_PER_SLOT; firstSymbol++)
792    {
793       if(initialBwp->pdcchCommon.commonSearchSpace.monitoringSymbol & mask)
794          break;
795       else
796          mask = mask>>1;
797    }
798
799    /* fill BWP */
800    bwp->freqAlloc.numPrb   = initialBwp->bwp.freqAlloc.numPrb;
801    bwp->freqAlloc.startPrb = initialBwp->bwp.freqAlloc.startPrb;
802    bwp->subcarrierSpacing  = initialBwp->bwp.scs;
803    bwp->cyclicPrefix       = initialBwp->bwp.cyclicPrefix;
804
805    /* fill the PDCCH PDU */
806    pdcch->coresetCfg.startSymbolIndex = firstSymbol;
807    pdcch->coresetCfg.durationSymbols = numSymbols;
808    memcpy(pdcch->coresetCfg.freqDomainResource, \
809       cell->cellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.freqDomainRsrc, FREQ_DOM_RSRC_SIZE);
810
811    pdcch->coresetCfg.cceRegMappingType = 1; /* coreset0 is always interleaved */
812    pdcch->coresetCfg.regBundleSize = 6;    /* spec-38.211 sec 7.3.2.2 */
813    pdcch->coresetCfg.interleaverSize = 2;  /* spec-38.211 sec 7.3.2.2 */
814    pdcch->coresetCfg.coreSetType = 0;
815    pdcch->coresetCfg.coreSetSize = numRbs;
816    pdcch->coresetCfg.shiftIndex = cell->cellCfg.phyCellId;
817    pdcch->coresetCfg.precoderGranularity = 0; /* sameAsRegBundle */
818    pdcch->numDlDci = 1;
819    pdcch->dci.rnti = cell->raReq[ueId-1]->raRnti; /* RA-RNTI */
820    pdcch->dci.scramblingId = cell->cellCfg.phyCellId;
821    pdcch->dci.scramblingRnti = 0;
822    pdcch->dci.cceIndex = 4; /* considering SIB1 is sent at cce 0-1-2-3 */
823    pdcch->dci.aggregLevel = 4;
824    pdcch->dci.beamPdcchInfo.numPrgs = 1;
825    pdcch->dci.beamPdcchInfo.prgSize = 1;
826    pdcch->dci.beamPdcchInfo.digBfInterfaces = 0;
827    pdcch->dci.beamPdcchInfo.prg[0].pmIdx = 0;
828    pdcch->dci.beamPdcchInfo.prg[0].beamIdx[0] = 0;
829    pdcch->dci.txPdcchPower.powerValue = 0;
830    pdcch->dci.txPdcchPower.powerControlOffsetSS = 0;
831    pdcch->dci.pdschCfg = pdsch;
832
833    /* fill the PDSCH PDU */
834    uint8_t cwCount = 0;
835    pdsch->pduBitmap = 0; /* PTRS and CBG params are excluded */
836    pdsch->rnti = cell->raReq[ueId-1]->raRnti; /* RA-RNTI */
837    pdsch->pduIndex = 0;
838    pdsch->numCodewords = 1;
839    for(cwCount = 0; cwCount < pdsch->numCodewords; cwCount++)
840    {
841       pdsch->codeword[cwCount].targetCodeRate = 308;
842       pdsch->codeword[cwCount].qamModOrder = 2;
843       pdsch->codeword[cwCount].mcsIndex = mcs; /* mcs configured to 4 */
844       pdsch->codeword[cwCount].mcsTable = 0;   /* notqam256 */
845       pdsch->codeword[cwCount].rvIndex = 0;
846       /* RAR PDU length and FAPI payload header length */
847       tbSize = schCalcTbSize(RAR_PAYLOAD_SIZE + TX_PAYLOAD_HDR_LEN);
848       pdsch->codeword[cwCount].tbSize = tbSize;
849    }
850    pdsch->dataScramblingId = cell->cellCfg.phyCellId;
851    pdsch->numLayers = 1;
852    pdsch->transmissionScheme = 0;
853    pdsch->refPoint = 0;
854    pdsch->dmrs.dlDmrsSymbPos = 4;  /* Bitmap value 00000000000100 i.e. using 3rd symbol for PDSCH DMRS */
855    pdsch->dmrs.dmrsConfigType = 0; /* type-1 */
856    pdsch->dmrs.dlDmrsScramblingId = cell->cellCfg.phyCellId;
857    pdsch->dmrs.scid = 0;
858    pdsch->dmrs.numDmrsCdmGrpsNoData = 1;
859    pdsch->dmrs.dmrsPorts = 0;
860    pdsch->dmrs.mappingType      = DMRS_MAP_TYPE_A;  /* Type-A */
861    pdsch->dmrs.nrOfDmrsSymbols  = NUM_DMRS_SYMBOLS;
862    pdsch->dmrs.dmrsAddPos       = DMRS_ADDITIONAL_POS;
863
864    pdsch->pdschTimeAlloc.rowIndex = k0Index;
865    pdsch->pdschTimeAlloc.timeAlloc.startSymb = initialBwp->pdschCommon.timeDomRsrcAllocList[k0Index].startSymbol;
866    pdsch->pdschTimeAlloc.timeAlloc.numSymb = initialBwp->pdschCommon.timeDomRsrcAllocList[k0Index].lengthSymbol;
867
868    pdsch->pdschFreqAlloc.vrbPrbMapping = 0; /* non-interleaved */
869    pdsch->pdschFreqAlloc.resourceAllocType = 1; /* RAT type-1 RIV format */
870    pdsch->pdschFreqAlloc.freqAlloc.startPrb = MAX_NUM_RB;
871    pdsch->pdschFreqAlloc.freqAlloc.numPrb = \
872       schCalcNumPrb(tbSize, mcs, initialBwp->pdschCommon.timeDomRsrcAllocList[k0Index].lengthSymbol);
873
874    /* Find total symbols occupied including DMRS */
875    dmrsStartSymbol = findDmrsStartSymbol(pdsch->dmrs.dlDmrsSymbPos);
876    /* If there are no DRMS symbols, findDmrsStartSymbol() returns MAX_SYMB_PER_SLOT, 
877     * in that case only PDSCH symbols are marked as occupied */
878    if(dmrsStartSymbol == MAX_SYMB_PER_SLOT)
879    {
880       startSymbol = pdsch->pdschTimeAlloc.timeAlloc.startSymb;
881       numSymbol = pdsch->pdschTimeAlloc.timeAlloc.numSymb;
882    }
883    /* If DMRS symbol is found, mark DMRS and PDSCH symbols as occupied */
884    else
885    {
886       startSymbol = dmrsStartSymbol;
887       numSymbol = pdsch->dmrs.nrOfDmrsSymbols + pdsch->pdschTimeAlloc.timeAlloc.numSymb;
888    }
889
890    /* Allocate the number of PRBs required for RAR PDSCH */
891    if((allocatePrbDl(cell, rarTime, startSymbol, numSymbol,\
892       &pdsch->pdschFreqAlloc.freqAlloc.startPrb, pdsch->pdschFreqAlloc.freqAlloc.numPrb)) != ROK)
893    {
894       DU_LOG("\nERROR  --> SCH : allocatePrbDl() failed for RAR");
895       return RFAILED;
896    }
897
898    pdsch->beamPdschInfo.numPrgs = 1;
899    pdsch->beamPdschInfo.prgSize = 1;
900    pdsch->beamPdschInfo.digBfInterfaces = 0;
901    pdsch->beamPdschInfo.prg[0].pmIdx = 0;
902    pdsch->beamPdschInfo.prg[0].beamIdx[0] = 0;
903    pdsch->txPdschPower.powerControlOffset = 0;
904    pdsch->txPdschPower.powerControlOffsetSS = 0;
905
906    return ROK;
907 }
908
909 /**********************************************************************
910          End of file
911 **********************************************************************/