src/5gnrsch/sch_common.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:     5G NR SCH layer
  22
  23 Type:     C source file
  24
  25 Desc:     C source code for Entry point fucntions
  26
  27 File:     sch_common.c
  28
  29  **********************************************************************/
  30
  31 /** @file sch_common.c
  32   @brief This module performs common scheduling
  33  */
  34 #include "stdbool.h"
  35 #include "envopt.h"        /* environment options */
  36 #include "envdep.h"        /* environment dependent */
  37 #include "envind.h"        /* environment independent */
  38 #include "gen.h"           /* general layer */
  39 #include "ssi.h"           /* system service interface */
  40 #include "cm_tkns.h"       /* Common Token Defines */
  41 #include "cm_llist.h"      /* Common Link List Defines */
  42 #include "cm_hash.h"       /* Common Hash List Defines */
  43 #include "cm_mblk.h"       /* common memory link list library */
  44 #include "cm_lte.h"        /* Common LTE Defines */
  45 #include "tfu.h"
  46 #include "lrg.h"
  47
  48 #include "gen.x"           /* general layer typedefs */
  49 #include "ssi.x"           /* system services typedefs */
  50 #include "cm5.x"           /* system services */
  51 #include "cm_tkns.x"       /* Common Token Definitions */
  52 #include "cm_llist.x"      /* Common Link List Definitions */
  53 #include "cm_lib.x"        /* Common Library Definitions */
  54 #include "cm_hash.x"       /* Common Hash List Definitions */
  55 #include "cm_mblk.x"       /* common memory link list library */
  56 #include "cm_lte.x"        /* Common LTE Defines */
  57 #include "tfu.x"
  58 #include "lrg.x"
  59 #include "du_log.h"
  60 #include "du_app_mac_inf.h"
  61 #include "mac_sch_interface.h"
  62 #include "sch.h"
  63 #include "sch_utils.h"
  64
  65 extern SchCb schCb[SCH_MAX_INST];
  66 extern uint16_t prachCfgIdxTable[MAX_PRACH_CONFIG_IDX][8];
  67 extern uint16_t numRbForPrachTable[MAX_RACH_NUM_RB_IDX][5];
  68
  69 SchMacUlSchInfoFunc schMacUlSchInfoOpts[] =
  70 {
  71         packSchMacUlSchInfo,
  72         MacProcUlSchInfo,
  73         packSchMacUlSchInfo
  74 };
  75
  76 /**
  77  * @brief Time domain allocation for SSB
  78  *
  79  * @details
  80  *
  81  *     Function : ssbDlTdAlloc
  82  *
  83  *     This function handles common scheduling for DL
  84  *
  85  *  @param[in]  uint8_t scs, uint8_t *ssbStartSym
  86  *  @return  void
  87  **/
  88 void ssbDlTdAlloc(uint8_t scs, uint8_t *ssbStartSymb)
  89 {
  90    uint8_t n;
  91         /* Determine value of "n" based on Section 4.1 of 3GPP TS 38.213 */
  92         switch(scs)
  93         {
  94                 case SCH_SCS_15KHZ:
  95                         {
  96                            uint8_t symbIdx=0;
  97                            n = 2;/* n = 0, 1 for SCS = 15KHz */
  98                                 for(uint8_t idx=0; idx<n; idx++)
  99                                 {
 100                /* start symbol determined using {2, 8} + 14n */
 101                                         ssbStartSymb[symbIdx++] = 2 + SCH_SYMBOL_PER_SLOT*idx;
 102                                         ssbStartSymb[symbIdx++] = 8 + SCH_SYMBOL_PER_SLOT*idx;
 103                                 }
 104                         }
 105                         break;
 106                 default:
 107                         DU_LOG("\nSCS %d is currently not supported", scs);
 108         }
 109 }
 110
 111 /**
 112  * @brief common resource allocation for SSB
 113  *
 114  * @details
 115  *
 116  *     Function : schBroadcastAlloc
 117  *
 118  *     This function handles common scheduling for DL
 119  *
 120  *  @param[in]  SchCellCb *cell, cell cb
 121  *  @param[in]  DlBrdcstAlloc *dlBrdcstAlloc, DL brdcst allocation
 122  *  @return  void
 123  **/
 124 uint8_t schBroadcastAlloc(SchCellCb *cell, DlBrdcstAlloc *dlBrdcstAlloc,
 125         uint16_t slot)
 126 {
 127         /* schedule SSB */
 128         uint8_t scs, ssbStartPrb, ssbStartSymb, idx;
 129         uint8_t ssbStartSymbArr[SCH_MAX_SSB_BEAM];
 130         SchDlAlloc *dlAlloc;
 131         SsbInfo ssbInfo;
 132
 133         dlAlloc = cell->dlAlloc[slot];
 134         if(dlBrdcstAlloc->ssbTrans)
 135         {
 136                 scs = cell->cellCfg.ssbSchCfg.scsCommon;
 137                 ssbStartPrb = cell->cellCfg.ssbSchCfg.ssbOffsetPointA;
 138
 139                 memset(ssbStartSymbArr, 0, SCH_MAX_SSB_BEAM);
 140                 ssbDlTdAlloc(scs, ssbStartSymbArr);
 141                 ssbStartSymb = ssbStartSymbArr[dlBrdcstAlloc->ssbIdxSupported-1]; /*since we are supporting only 1 ssb beam */
 142                 /* Assign interface structure */
 143                 for(idx=0; idx<dlBrdcstAlloc->ssbIdxSupported; idx++)
 144                 {
 145                         ssbInfo.ssbIdx = idx;
 146                         ssbInfo.fdAlloc.startPrb  = ssbStartPrb;
 147                         ssbInfo.fdAlloc.numPrb    = SCH_SSB_PRB_DURATION;
 148                         ssbInfo.tdAlloc.startSymb = ssbStartSymb;
 149                         ssbInfo.tdAlloc.numSymb   = SCH_SSB_SYMB_DURATION;
 150                         dlBrdcstAlloc->ssbInfo[idx] = ssbInfo;
 151                         dlAlloc->ssbInfo[idx] = ssbInfo;
 152
 153                 }
 154
 155                 dlAlloc->ssbPres = true;
 156                 dlAlloc->ssbIdxSupported = dlBrdcstAlloc->ssbIdxSupported;
 157                 for(idx=ssbStartSymb; idx<ssbStartSymb+SCH_SSB_SYMB_DURATION; idx++)
 158                 {
 159                         dlAlloc->assignedPrb[idx] = ssbStartPrb + SCH_SSB_PRB_DURATION + 1; /* +1 for kSsb */
 160                 }
 161
 162         }
 163
 164         /* SIB1 allocation */
 165         if(dlBrdcstAlloc->sib1Trans)
 166         {
 167                 dlAlloc->sib1Pres = true;
 168                 for(idx=0; idx<SCH_SYMBOL_PER_SLOT; idx++)
 169                 {
 170                         dlAlloc->assignedPrb[idx] = ssbStartPrb + SCH_SSB_PRB_DURATION + 1 + 10; /* 10 PRBs for sib1 */
 171                 }
 172            memcpy(&dlBrdcstAlloc->sib1Alloc.sib1PdcchCfg, &cell->cellCfg.sib1SchCfg.sib1PdcchCfg, sizeof(PdcchCfg));
 173            memcpy(&dlBrdcstAlloc->sib1Alloc.sib1PdschCfg, &cell->cellCfg.sib1SchCfg.sib1PdschCfg, sizeof(PdschCfg));
 174         }
 175         return ROK;
 176 }
 177
 178 /*******************************************************************
 179  *
 180  * @brief Handles sending UL scheduler info to MAC
 181  *
 182  * @details
 183  *
 184  *    Function : sendUlSchInfoToMac
 185  *
 186  *    Functionality:
 187  *     Sends UL Sch info to MAC from SCH
 188  *
 189  * @params[in]
 190  * @return ROK     - success
 191  *         RFAILED - failure
 192  *
 193  * ****************************************************************/
 194 int sendUlSchInfoToMac(UlSchInfo *ulSchInfo, Inst inst)
 195 {
 196         Pst pst;
 197
 198    memset(&pst, 0, sizeof(Pst));
 199    SCH_FILL_RSP_PST(pst, inst);
 200         pst.event = EVENT_UL_SCH_INFO;
 201
 202         return(*schMacUlSchInfoOpts[pst.selector])(&pst, ulSchInfo);
 203
 204 }
 205 /**
 206  * @brief resource allocation for PRACH
 207  *
 208  * @details
 209  *
 210  *     Function : schPrachResAlloc
 211  *
 212  *     This function handles PRACH allocation
 213  *
 214  *  @param[in]  SchCellCb *cell, cell cb
 215  *  @param[in]  UlSchInfo *ulSchInfo, UL scheduling info
 216  *  @return  void
 217  **/
 218 int schPrachResAlloc(SchCellCb *cell, UlSchInfo *ulSchInfo)
 219 {
 220    uint8_t  numPrachRb = 0;
 221         uint8_t  numRa = 0;
 222         uint8_t  freqStart = 0;
 223         uint16_t sfn = 0;
 224         uint16_t slot = 0;
 225         uint8_t  prachCfgIdx = 0;
 226         uint8_t  prachFormat = 0;
 227         uint8_t  x = 0;
 228         uint8_t  y = 0;
 229         uint16_t prachSubframe = 0;
 230         uint8_t  prachStartSymbol = 0;
 231         uint8_t  prachOcas = 0;
 232         uint8_t  dataType = 0;
 233         uint8_t  idx = 0;
 234         SchUlAlloc *ulAlloc = NULLP;
 235
 236         sfn  = cell->slotInfo.sfn;
 237         slot = cell->slotInfo.slot;
 238         ulAlloc = cell->ulAlloc[cell->slotInfo.slot];
 239         prachCfgIdx = cell->cellCfg.schRachCfg.prachCfgIdx;
 240
 241     /* derive the prachCfgIdx table paramters */
 242         x                = prachCfgIdxTable[prachCfgIdx][1];
 243         y                = prachCfgIdxTable[prachCfgIdx][2];
 244         prachSubframe    = prachCfgIdxTable[prachCfgIdx][3];
 245
 246         if((sfn%x) != y)
 247         {
 248            /* prach occasion does not lie in this SFN */
 249                 DU_LOG("\nPRACH ocassion doesn't lie in this SFN");
 250            return RFAILED;
 251         }
 252         /* check for subFrame number */
 253         if ((1 << slot) & prachSubframe)
 254         {
 255       /* prach ocassion present in this subframe */
 256
 257                 prachFormat      = prachCfgIdxTable[prachCfgIdx][0];
 258                 prachStartSymbol = prachCfgIdxTable[prachCfgIdx][4];
 259                 prachOcas        = prachCfgIdxTable[prachCfgIdx][6];
 260
 261                 /* freq domain resource determination for RACH*/
 262                 freqStart = cell->cellCfg.schRachCfg.msg1FreqStart;
 263                 /* numRa determined as 𝑛 belonging {0,1,.., M − 1},
 264                  * where M is given by msg1Fdm */
 265                 numRa = (cell->cellCfg.schRachCfg.msg1Fdm - 1);
 266                 for(idx=0; idx<MAX_RACH_NUM_RB_IDX; idx++)
 267                 {
 268          if(numRbForPrachTable[idx][0] == cell->cellCfg.schRachCfg.rootSeqIdx)
 269                            break;
 270                 }
 271                 numPrachRb = numRbForPrachTable[idx][3];
 272                 dataType |= SCH_DATATYPE_PRACH;
 273                 /* Considering first slot in the frame for PRACH */
 274                 idx = 0;
 275                 ulAlloc->assignedPrb[idx] = freqStart+numPrachRb;
 276         }
 277
 278         /* Fill UL SCH Info */
 279         ulSchInfo->cellId = cell->cellId;
 280         ulSchInfo->slotIndInfo.sfn = sfn;
 281    ulSchInfo->slotIndInfo.slot = slot;
 282         ulSchInfo->dataType = dataType;
 283         /* prach info */
 284         ulSchInfo->prachSchInfo.numPrachOcas   = prachOcas;
 285         ulSchInfo->prachSchInfo.prachFormat    = prachFormat;
 286         ulSchInfo->prachSchInfo.numRa          = numRa;
 287         ulSchInfo->prachSchInfo.prachStartSymb = prachStartSymbol;
 288
 289         return ROK;
 290 }
 291
 292 /**
 293  * @brief resource allocation for UL
 294  *
 295  * @details
 296  *
 297  *     Function : schUlResAlloc
 298  *
 299  *     This function handles UL Resource allocation
 300  *
 301  *  @param[in]  SchCellCb *cell, cellCb
 302  *  @return  void
 303  **/
 304 uint8_t schUlResAlloc(SchCellCb *cell, Inst schInst)
 305 {
 306    int ret = ROK;
 307    UlSchInfo ulSchInfo;
 308         SchUlAlloc *ulAlloc;
 309
 310    /* Schedule resources for PRACH */
 311         schPrachResAlloc(cell, &ulSchInfo);
 312
 313         ulAlloc = cell->ulAlloc[cell->slotInfo.slot];
 314
 315         if(ulAlloc->schPuschInfo)
 316         {
 317            ulSchInfo.crnti = cell->raCb[0].tcrnti;
 318                 ulSchInfo.dataType |= SCH_DATATYPE_PUSCH;
 319                 memcpy(&ulSchInfo.schPuschInfo, ulAlloc->schPuschInfo,
 320                                 sizeof(SchPuschInfo));
 321                 SCH_FREE(ulAlloc->schPuschInfo, sizeof(SchPuschInfo));
 322                 ulAlloc->schPuschInfo = NULL;
 323         }
 324
 325         //send msg to MAC
 326    ret = sendUlSchInfoToMac(&ulSchInfo, schInst);
 327    if(ret != ROK)
 328    {
 329       DU_LOG("\nSending UL Sch info from SCH to MAC failed");
 330    }
 331
 332         return ret;
 333 }
 334
 335 /*******************************************************************
 336  *
 337  * @brief Fills pdcch and pdsch info for msg4
 338  *
 339  * @details
 340  *
 341  *    Function : schDlRsrcAllocMsg4
 342  *
 343  *    Functionality:
 344  *       Fills pdcch and pdsch info for msg4
 345  *
 346  * @params[in]
 347  * @return ROK     - success
 348  *         RFAILED - failure
 349  *
 350  * ****************************************************************/
 351 uint8_t schDlRsrcAllocMsg4(Msg4Alloc *msg4Alloc, SchCellCb *cell, uint16_t slot)
 352 {
 353    uint8_t coreset0Idx = 0;
 354    uint8_t numRbs = 0;
 355    uint8_t firstSymbol = 0;
 356    uint8_t numSymbols = 0;
 357    uint8_t offset = 0;
 358    uint8_t offsetPointA;
 359    uint8_t FreqDomainResource[6] = {0};
 360    SchBwpDlCfg *initialBwp;
 361
 362    PdcchCfg *pdcch = &msg4Alloc->msg4PdcchCfg;
 363    PdschCfg *pdsch = &msg4Alloc->msg4PdschCfg;
 364
 365    initialBwp   = &cell->cellCfg.schInitialDlBwp;
 366    offsetPointA = cell->cellCfg.ssbSchCfg.ssbOffsetPointA;
 367    coreset0Idx  = initialBwp->pdcchCommon.raSearchSpace.coresetId;
 368
 369    /* derive the sib1 coreset0 params from table 13-1 spec 38.213 */
 370    numRbs        = coresetIdxTable[coreset0Idx][1];
 371    numSymbols    = coresetIdxTable[coreset0Idx][2];
 372    offset        = coresetIdxTable[coreset0Idx][3];
 373
 374    /* calculate time domain parameters */
 375    uint16_t mask = 0x2000;
 376    for(firstSymbol=0; firstSymbol<14;firstSymbol++)
 377    {
 378       if(initialBwp->pdcchCommon.raSearchSpace.monitoringSymbol & mask)
 379          break;
 380       else
 381          mask = mask>>1;
 382    }
 383
 384    /* calculate the PRBs */
 385    calculatePRB( ((offsetPointA-offset)/6), (numRbs/6), FreqDomainResource);
 386
 387    /* fill the PDCCH PDU */
 388    pdcch->pdcchBwpCfg.BWPSize = initialBwp->bwp.numPrb;
 389    pdcch->pdcchBwpCfg.BWPStart = initialBwp->bwp.firstPrb;
 390    pdcch->pdcchBwpCfg.subcarrierSpacing = initialBwp->bwp.scs;
 391    pdcch->pdcchBwpCfg.cyclicPrefix = initialBwp->bwp.cyclicPrefix;
 392    pdcch->coreset0Cfg.startSymbolIndex = firstSymbol;
 393    pdcch->coreset0Cfg.durationSymbols = numSymbols;
 394    memcpy(pdcch->coreset0Cfg.freqDomainResource,FreqDomainResource,6);
 395    pdcch->coreset0Cfg.cceRegMappingType = 1; /* coreset0 is always interleaved */
 396    pdcch->coreset0Cfg.regBundleSize = 6;    /* spec-38.211 sec 7.3.2.2 */
 397    pdcch->coreset0Cfg.interleaverSize = 2;  /* spec-38.211 sec 7.3.2.2 */
 398    pdcch->coreset0Cfg.coreSetType = 0;
 399    pdcch->coreset0Cfg.coreSet0Size = numRbs;
 400    pdcch->coreset0Cfg.shiftIndex = cell->cellCfg.phyCellId;
 401    pdcch->coreset0Cfg.precoderGranularity = 0; /* sameAsRegBundle */
 402    pdcch->numDlDci = 1;
 403    pdcch->dci.rnti = cell->dlAlloc[slot]->msg4Info->crnti;
 404    pdcch->dci.scramblingId = cell->cellCfg.phyCellId;
 405    pdcch->dci.scramblingRnti = 0;
 406    pdcch->dci.cceIndex = 4; /* considering SIB1 is sent at cce 0-1-2-3 */
 407    pdcch->dci.aggregLevel = 4;
 408    pdcch->dci.beamPdcchInfo.numPrgs = 1;
 409    pdcch->dci.beamPdcchInfo.prgSize = 1;
 410    pdcch->dci.beamPdcchInfo.digBfInterfaces = 0;
 411    pdcch->dci.beamPdcchInfo.prg[0].pmIdx = 0;
 412    pdcch->dci.beamPdcchInfo.prg[0].beamIdx[0] = 0;
 413    pdcch->dci.txPdcchPower.powerValue = 0;
 414    pdcch->dci.txPdcchPower.powerControlOffsetSS = 0;
 415
 416    /* fill the PDSCH PDU */
 417    uint8_t cwCount = 0;
 418    pdsch->pduBitmap = 0; /* PTRS and CBG params are excluded */
 419    pdsch->rnti = cell->dlAlloc[slot]->msg4Info->crnti;
 420    pdsch->pduIndex = 0;
 421    pdsch->pdschBwpCfg.BWPSize = initialBwp->bwp.numPrb;
 422    pdsch->pdschBwpCfg.BWPStart = initialBwp->bwp.firstPrb;
 423    pdsch->numCodewords = 1;
 424    for(cwCount = 0; cwCount < pdsch->numCodewords; cwCount++)
 425    {
 426       pdsch->codeword[cwCount].targetCodeRate = 308;
 427       pdsch->codeword[cwCount].qamModOrder = 2;
 428       pdsch->codeword[cwCount].mcsIndex = 4; /* mcs configured to 4 */
 429       pdsch->codeword[cwCount].mcsTable = 0; /* notqam256 */
 430       pdsch->codeword[cwCount].rvIndex = 0;
 431       /* 38.214: Table 5.1.3.2-1,  divided by 8 to get the value in bytes */
 432       /* TODO : Calculate tbSize based of DL CCCH msg size */
 433       pdsch->codeword[cwCount].tbSize = 2664/8;
 434    }
 435    pdsch->dataScramblingId = cell->cellCfg.phyCellId;
 436    pdsch->numLayers = 1;
 437    pdsch->transmissionScheme = 0;
 438    pdsch->refPoint = 0;
 439    pdsch->dmrs.dlDmrsSymbPos = 2;
 440    pdsch->dmrs.dmrsConfigType = 0; /* type-1 */
 441    pdsch->dmrs.dlDmrsScramblingId = cell->cellCfg.phyCellId;
 442    pdsch->dmrs.scid = 0;
 443    pdsch->dmrs.numDmrsCdmGrpsNoData = 1;
 444    pdsch->dmrs.dmrsPorts = 0;
 445    pdsch->freqAlloc.resourceAlloc = 1; /* RAT type-1 RIV format */
 446    /* the RB numbering starts from coreset0, and PDSCH is always above SSB */
 447    pdsch->freqAlloc.rbStart = offset + SCH_SSB_PRB_DURATION;
 448    /* formula used for calculation of rbSize, 38.213 section 5.1.3.2 *
 449     * Ninfo = S . Nre . R . Qm . v                                   *
 450     * Nre' = Nsc . NsymPdsch - NdmrsSymb - Noh                       *
 451     * Nre = min(156,Nre') . nPrb                                     */
 452    /* TODO : Calculate rbSize based on tbSize calculated */
 453    pdsch->freqAlloc.rbSize = 34;
 454    pdsch->freqAlloc.vrbPrbMapping = 0; /* non-interleaved */
 455    pdsch->timeAlloc.startSymbolIndex = 2; /* spec-38.214, Table 5.1.2.1-1 */
 456    pdsch->timeAlloc.numSymbols = 12;
 457    pdsch->beamPdschInfo.numPrgs = 1;
 458    pdsch->beamPdschInfo.prgSize = 1;
 459    pdsch->beamPdschInfo.digBfInterfaces = 0;
 460    pdsch->beamPdschInfo.prg[0].pmIdx = 0;
 461    pdsch->beamPdschInfo.prg[0].beamIdx[0] = 0;
 462    pdsch->txPdschPower.powerControlOffset = 0;
 463    pdsch->txPdschPower.powerControlOffsetSS = 0;
 464
 465    pdcch->dci.pdschCfg = pdsch;
 466    return ROK;
 467 }
 468
 469 /**********************************************************************
 470   End of file
 471  **********************************************************************/
 472