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.ssbStartPrbIdx = ssbStartPrb;
 147                         ssbInfo.fdAlloc.ssbPrbDuration = SCH_SSB_PRB_DURATION;
 148                         ssbInfo.tdAlloc.ssbStartSymbIdx = ssbStartSymb;
 149                         ssbInfo.tdAlloc.ssbSymbolDuration = 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         uint8_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    /* Schedule resources for PRACH */
 309         schPrachResAlloc(cell, &ulSchInfo);
 310         //send msg to MAC
 311    ret = sendUlSchInfoToMac(&ulSchInfo, schInst);
 312    if(ret != ROK)
 313    {
 314       DU_LOG("\nSending UL Sch info from SCH to MAC failed");
 315    }
 316
 317         return ret;
 318 }
 319 /**********************************************************************
 320   End of file
 321  **********************************************************************/
 322