src/5gnrmac/mac_cfg_hdl.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 /* This file stores handler for MAC and SCH configuration requests */
  19 /* header include files (.h) */
  20 #include "common_def.h"
  21 #include "lrg.h"
  22 #include "lrg.x"
  23 #include "du_app_mac_inf.h"
  24 #include "mac_sch_interface.h"
  25 #include "lwr_mac_upr_inf.h"
  26 #include "mac.h"
  27 #include "rlc_mac_inf.h"
  28 #include "mac_upr_inf_api.h"
  29 #include "lwr_mac.h"
  30 #include "lwr_mac_fsm.h"
  31 #include "mac_utils.h"
  32 #include "lwr_mac_phy.h"
  33
  34 uint8_t ssbPeriodicity[6] = {5, 10, 20, 40, 80, 160};
  35
  36 uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg  *macCellCfg);
  37
  38 packMacCellCfgConfirm packMacCellCfmOpts[] =
  39 {
  40    packMacCellCfgCfm,      /* packing for loosely coupled */
  41    duHandleMacCellCfgCfm,      /* packing for tightly coupled */
  42    packMacCellCfgCfm,    /* packing for light weight loosly coupled */
  43 };
  44
  45 SchCellCfgFunc SchCellCfgOpts[] =
  46 {
  47    packSchCellCfg,   /* packing for loosely coupled */
  48    SchHdlCellCfgReq, /* packing for tightly coupled */
  49    packSchCellCfg    /* packing for light weight loosly coupled */
  50 };
  51
  52 MacSchCellDeleteReqFunc macSchCellDeleteReqOpts[]=
  53 {
  54    packMacSchCellDeleteReq,    /* packing for loosely coupled */
  55    MacSchCellDeleteReq,        /* packing for tightly coupled */
  56    packMacSchCellDeleteReq     /* packing for light weight loosely coupled */
  57 };
  58
  59 MacDuCellDeleteRspFunc macDuCellDeleteRspOpts[] =
  60 {
  61    packDuMacCellDeleteRsp,   /* packing for loosely coupled */
  62    DuProcMacCellDeleteRsp,   /* packing for tightly coupled */
  63    packDuMacCellDeleteRsp   /* packing for light weight loosly coupled */
  64 };
  65
  66 MacDuSliceCfgRspFunc macDuSliceCfgRspOpts[] =
  67 {
  68    packDuMacSliceCfgRsp,   /* packing for loosely coupled */
  69    DuProcMacSliceCfgRsp,   /* packing for tightly coupled */
  70    packDuMacSliceCfgRsp   /* packing for light weight loosly coupled */
  71 };
  72
  73 MacDuSliceReCfgRspFunc macDuSliceReCfgRspOpts[] =
  74 {
  75    packDuMacSliceReCfgRsp,   /* packing for loosely coupled */
  76    DuProcMacSliceReCfgRsp,   /* packing for tightly coupled */
  77    packDuMacSliceReCfgRsp   /* packing for light weight loosly coupled */
  78 };
  79
  80 /**
  81  * @brief Layer Manager  Configuration request handler for Scheduler
  82  *
  83  * @details
  84  *
  85  *     Function : MacSchGenCfgReq
  86  *
  87  *     This function receives general configurations for Scheduler
  88  *     from DU APP and forwards to Scheduler.
  89  *
  90  *  @param[in]  Pst *pst, the post structure
  91  *  @param[in]  RgMngmt *cfg, the configuration parameter's structure
  92  *  @return
  93  *      -# ROK
  94  **/
  95 uint8_t MacSchGenCfgReq(Pst *pst, RgMngmt *cfg)
  96 {
  97    Pst schPst;
  98
  99    printf("\nReceived Scheduler gen config at MAC");
 100    memset(&schPst, 0, sizeof(Pst));
 101    FILL_PST_MAC_TO_SCH(schPst, EVENT_SCH_GEN_CFG);
 102    SchProcGenCfgReq(&schPst, cfg);
 103
 104    return ROK;
 105 }
 106
 107 /**
 108  * @brief Layer Manager Configuration response from Scheduler
 109  *
 110  * @details
 111  *
 112  *     Function : SchSendCfgCfm
 113  *
 114  *     This function sends general configurations response from
 115  *     Scheduler to DU APP.
 116  *
 117  *  @param[in]  Pst *pst, the post structure
 118  *  @param[in]  RgMngmt *cfm, the configuration confirm structure
 119  *  @return
 120  *      -# ROK
 121  **/
 122 uint8_t SchSendCfgCfm(Pst *pst, RgMngmt  *cfm)
 123 {
 124    DU_LOG("\nDEBUG  -->  Sending Scheduler config confirm to DU APP");
 125    pst->dstEnt = ENTDUAPP;
 126    pst->dstInst = 0;
 127    pst->srcInst = 0;
 128    pst->selector = ODU_SELECTOR_LC;
 129    RgMiLrgSchCfgCfm(pst, cfm);
 130
 131    return ROK;
 132 }
 133
 134 /**
 135  * @brief Layer Manager Configuration request handler.
 136  *
 137  * @details
 138  *
 139  *     Function : MacProcCellCfgReq
 140  *
 141  *     This function handles the gNB and cell configuration
 142  *     request received from DU APP.
 143  *     This API unapcks and forwards the config towards SCH
 144  *
 145  *  @param[in]  Pst           *pst
 146  *  @param[in]  MacCellCfg    *macCellCfg
 147  *  @return
 148  *      -# ROK
 149  **/
 150 uint8_t MacProcCellCfgReq(Pst *pst, MacCellCfg *macCellCfg)
 151 {
 152    Pst cfmPst;
 153    uint16_t cellIdx;
 154    uint8_t ret = ROK, sliceIdx = 0;
 155    MacCellCb     *macCellCb;
 156
 157    memset((uint8_t *)&cfmPst, 0, sizeof(Pst));
 158
 159    MAC_ALLOC(macCellCb, sizeof(MacCellCb));
 160    if(macCellCb == NULLP)
 161    {
 162       DU_LOG("\nERROR  -->  MAC : macCellCb is NULL at handling of macCellCfg\n");
 163       return RFAILED;
 164    }
 165    memset(macCellCb, 0, sizeof(MacCellCb));
 166
 167    GET_CELL_IDX(macCellCfg->cellId, cellIdx);
 168    macCb.macCell[cellIdx] = macCellCb;
 169    macCb.macCell[cellIdx]->cellId = macCellCfg->cellId;
 170    memcpy(&macCb.macCell[cellIdx]->macCellCfg, macCellCfg, sizeof(MacCellCfg));
 171
 172    MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, \
 173          macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen);
 174    if(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu == NULLP)
 175    {
 176       DU_LOG("\nERROR  -->  MAC : macCellCb is NULL at handling of sib1Pdu of macCellCfg\n");
 177       return RFAILED;
 178    }
 179    memcpy(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, macCellCfg->sib1Cfg.sib1Pdu, \
 180          macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen);
 181
 182    macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice = macCellCfg->plmnInfoList.numSupportedSlice;
 183    MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai, macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice\
 184          * sizeof(Snssai*));
 185    if(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai == NULLP)
 186    {
 187       DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacProcCellCfgReq");
 188       return RFAILED;
 189    }
 190
 191    if(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai)
 192    {
 193       for(sliceIdx=0; sliceIdx<macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice; sliceIdx++)
 194       {
 195          if(macCellCfg->plmnInfoList.snssai[sliceIdx])
 196          {
 197             MAC_ALLOC(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai));
 198             if(!macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx])
 199             {
 200                DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacProcCellCfgReq");
 201                return RFAILED;
 202             }
 203             memcpy(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx], macCellCfg->plmnInfoList.snssai[sliceIdx],\
 204             sizeof(Snssai));
 205          }
 206       }
 207    }
 208
 209    /* Send cell cfg to scheduler */
 210    ret = MacSchCellCfgReq(pst, macCellCfg);
 211    if(ret != ROK)
 212    {
 213       MacCellCfgCfm macCellCfgCfm;
 214       macCellCfgCfm.rsp = RSP_NOK;
 215       macCellCfgCfm.cellId = macCellCfg->cellId;
 216       /* Fill Pst */
 217       FILL_PST_MAC_TO_DUAPP(cfmPst, EVENT_MAC_CELL_CONFIG_CFM);
 218       cfmPst.selector  = ODU_SELECTOR_LC;
 219
 220       ret = (*packMacCellCfmOpts[cfmPst.selector])(&cfmPst,&macCellCfgCfm);
 221    }
 222    else
 223    {
 224       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg ,sizeof(MacCellCfg));
 225    }
 226    return ret;
 227 } /* end of MacProcCellCfgReq */
 228
 229 /**
 230  * @brief Layer Manager Configuration request handler.
 231  *
 232  * @details
 233  *
 234  *     Function : MacSchCellCfgReq
 235  *
 236  *     This function sends cell configuration to SCH
 237  *
 238  *  @param[in]  Pst           *pst
 239  *  @param[in]  MacCellCfg    *macCellCfg
 240  *  @return
 241  *      -# ROK
 242  **/
 243 uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg)
 244 {
 245    SchCellCfg schCellCfg;
 246    Pst        cfgPst;
 247    uint8_t    ssbMaskIdx = 0, rsrcListIdx = 0, ret=0, sliceIdx=0;
 248
 249    memset(&cfgPst, 0, sizeof(Pst));
 250    memset(&schCellCfg, 0, sizeof(SchCellCfg));
 251    schCellCfg.cellId = macCellCfg->cellId;
 252    schCellCfg.phyCellId = macCellCfg->phyCellId;
 253    schCellCfg.numerology = macCellCfg->numerology;
 254    schCellCfg.dupMode = macCellCfg->dupType;
 255    schCellCfg.bandwidth = macCellCfg->dlCarrCfg.bw;
 256    schCellCfg.dlFreq = macCellCfg->dlCarrCfg.freq;
 257    schCellCfg.ulFreq = macCellCfg->ulCarrCfg.freq;
 258
 259    /* fill ssb scheduler parameters */
 260    schCellCfg.ssbSchCfg.ssbPbchPwr = macCellCfg->ssbCfg.ssbPbchPwr;
 261    schCellCfg.ssbSchCfg.scsCommon = macCellCfg->ssbCfg.scsCmn;
 262    schCellCfg.ssbSchCfg.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA;
 263    schCellCfg.ssbSchCfg.ssbPeriod = ssbPeriodicity[macCellCfg->ssbCfg.ssbPeriod];
 264    schCellCfg.ssbSchCfg.ssbSubcOffset = macCellCfg->ssbCfg.ssbScOffset;
 265    for(ssbMaskIdx=0; ssbMaskIdx<SSB_MASK_SIZE; ssbMaskIdx++)
 266    {
 267       schCellCfg.ssbSchCfg.nSSBMask[ssbMaskIdx] = macCellCfg->ssbCfg.ssbMask[ssbMaskIdx];
 268    }
 269    schCellCfg.ssbSchCfg.totNumSsb = countSetBits(schCellCfg.ssbSchCfg.nSSBMask[0]);
 270
 271    /* fill SIB1 scheduler parameters */
 272    schCellCfg.sib1SchCfg.sib1PduLen = macCellCfg->sib1Cfg.sib1PduLen;
 273    schCellCfg.sib1SchCfg.sib1RepetitionPeriod = macCellCfg->sib1Cfg.sib1RepetitionPeriod;
 274    schCellCfg.sib1SchCfg.coresetZeroIndex = macCellCfg->sib1Cfg.coresetZeroIndex;
 275    schCellCfg.sib1SchCfg.searchSpaceZeroIndex = macCellCfg->sib1Cfg.searchSpaceZeroIndex;
 276    schCellCfg.sib1SchCfg.sib1Mcs = macCellCfg->sib1Cfg.sib1Mcs;
 277    schCellCfg.sib1SchCfg.pageCfg.numPO  =  macCellCfg->sib1Cfg.pagingCfg.numPO;
 278    schCellCfg.sib1SchCfg.pageCfg.poPresent = macCellCfg->sib1Cfg.pagingCfg.poPresent;
 279
 280    if(schCellCfg.sib1SchCfg.pageCfg.poPresent)
 281    {
 282       memcpy(schCellCfg.sib1SchCfg.pageCfg.pagingOcc, macCellCfg->sib1Cfg.pagingCfg.pagingOcc, MAX_PO_PER_PF);
 283    }
 284
 285    /* fill RACH config params */
 286    schCellCfg.schRachCfg.prachCfgIdx = macCellCfg->prachCfg.prachCfgIdx;
 287    schCellCfg.schRachCfg.prachSubcSpacing = \
 288                                             macCellCfg->prachCfg.prachSubcSpacing;
 289    schCellCfg.schRachCfg.msg1FreqStart = macCellCfg->prachCfg.msg1FreqStart;
 290    schCellCfg.schRachCfg.msg1Fdm       = macCellCfg->prachCfg.msg1Fdm;
 291    schCellCfg.schRachCfg.rootSeqLen    = macCellCfg->prachCfg.rootSeqLen;
 292    schCellCfg.schRachCfg.rootSeqIdx    = macCellCfg->prachCfg.fdm[0].rootSeqIdx;
 293    schCellCfg.schRachCfg.numRootSeq    = macCellCfg->prachCfg.fdm[0].numRootSeq;
 294    schCellCfg.schRachCfg.k1            = macCellCfg->prachCfg.fdm[0].k1;
 295    schCellCfg.schRachCfg.totalNumRaPreamble = macCellCfg->prachCfg.totalNumRaPreamble;
 296    schCellCfg.schRachCfg.ssbPerRach    = macCellCfg->prachCfg.ssbPerRach;
 297    schCellCfg.schRachCfg.numCbPreamblePerSsb = macCellCfg->prachCfg.numCbPreamblePerSsb;
 298    schCellCfg.schRachCfg.prachMultCarrBand = macCellCfg->prachCfg.prachMultCarrBand;
 299    schCellCfg.schRachCfg.raContResTmr  = macCellCfg->prachCfg.raContResTmr;
 300    schCellCfg.schRachCfg.rsrpThreshSsb = macCellCfg->prachCfg.rsrpThreshSsb;
 301    schCellCfg.schRachCfg.raRspWindow   = macCellCfg->prachCfg.raRspWindow;
 302
 303    /* fill initial DL BWP */
 304    schCellCfg.schInitialDlBwp.bwp.freqAlloc.startPrb = macCellCfg->initialDlBwp.bwp.firstPrb;
 305    schCellCfg.schInitialDlBwp.bwp.freqAlloc.numPrb = macCellCfg->initialDlBwp.bwp.numPrb;
 306    schCellCfg.schInitialDlBwp.bwp.scs = macCellCfg->initialDlBwp.bwp.scs;
 307    schCellCfg.schInitialDlBwp.bwp.cyclicPrefix = macCellCfg->initialDlBwp.bwp.cyclicPrefix;
 308    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId =
 309       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.searchSpaceId;
 310    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.coresetId =
 311       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.coresetId;
 312    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot =
 313       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSlot;
 314    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.duration =
 315       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.duration;
 316    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol =
 317       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.monitoringSymbol;
 318    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel1 =
 319       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel1;
 320    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel2 =
 321       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel2;
 322    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel4 =
 323       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel4;
 324    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8 =
 325       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel8;
 326    schCellCfg.schInitialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16 =
 327       macCellCfg->initialDlBwp.pdcchCommon.commonSearchSpace.candidate.aggLevel16;
 328    schCellCfg.schInitialDlBwp.pdschCommon.numTimeDomAlloc = macCellCfg->initialDlBwp.pdschCommon.numTimeDomAlloc;
 329    for(rsrcListIdx = 0; rsrcListIdx<macCellCfg->initialDlBwp.pdschCommon.numTimeDomAlloc; rsrcListIdx++)
 330    {
 331       schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0 =
 332          macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].k0;
 333       schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType =
 334          macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType;
 335       schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol =
 336          macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol;
 337       schCellCfg.schInitialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol =
 338          macCellCfg->initialDlBwp.pdschCommon.timeDomRsrcAllocList[rsrcListIdx].lengthSymbol;
 339    }
 340
 341    /* fill initial UL BWP */
 342    schCellCfg.schInitialUlBwp.bwp.freqAlloc.startPrb = macCellCfg->initialUlBwp.bwp.firstPrb;
 343    schCellCfg.schInitialUlBwp.bwp.freqAlloc.numPrb = macCellCfg->initialUlBwp.bwp.numPrb;
 344    schCellCfg.schInitialUlBwp.bwp.scs = macCellCfg->initialUlBwp.bwp.scs;
 345    schCellCfg.schInitialUlBwp.bwp.cyclicPrefix = macCellCfg->initialUlBwp.bwp.cyclicPrefix;
 346    schCellCfg.schInitialUlBwp.puschCommon.numTimeDomRsrcAlloc = \
 347       macCellCfg->initialUlBwp.puschCommon.numTimeDomRsrcAlloc;
 348    for(rsrcListIdx = 0; rsrcListIdx < macCellCfg->initialUlBwp.puschCommon.numTimeDomRsrcAlloc; rsrcListIdx++)
 349    {
 350       schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2 =
 351          macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].k2;
 352       schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType =
 353          macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].mappingType;
 354       schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol =
 355          macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].startSymbol;
 356       schCellCfg.schInitialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength =
 357          macCellCfg->initialUlBwp.puschCommon.timeDomRsrcAllocList[rsrcListIdx].symbolLength;
 358    }
 359
 360    if(macCellCfg->plmnInfoList.snssai)
 361    {
 362       schCellCfg.plmnInfoList.numSliceSupport = macCellCfg->plmnInfoList.numSupportedSlice;
 363       MAC_ALLOC(schCellCfg.plmnInfoList.snssai, schCellCfg.plmnInfoList.numSliceSupport * sizeof(Snssai*));
 364       if(!schCellCfg.plmnInfoList.snssai)
 365       {
 366          DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacSchCellCfgReq");
 367          return RFAILED;
 368       }
 369       for(sliceIdx=0; sliceIdx<schCellCfg.plmnInfoList.numSliceSupport; sliceIdx++)
 370       {
 371          if(macCellCfg->plmnInfoList.snssai[sliceIdx])
 372          {
 373             MAC_ALLOC(schCellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai));
 374             if(!schCellCfg.plmnInfoList.snssai[sliceIdx])
 375             {
 376                DU_LOG("\nERROR  --> MAC: Memory allocation failed at MacSchCellCfgReq");
 377                return RFAILED;
 378             }
 379             memcpy(schCellCfg.plmnInfoList.snssai[sliceIdx], macCellCfg->plmnInfoList.snssai[sliceIdx],  sizeof(Snssai));
 380          }
 381       }
 382    }
 383
 384 #ifdef NR_TDD
 385    memcpy(&schCellCfg.tddCfg, &macCellCfg->tddCfg, sizeof(TDDCfg));
 386 #endif
 387
 388    FILL_PST_MAC_TO_SCH(cfgPst, EVENT_SCH_CELL_CFG);
 389
 390    ret = (*SchCellCfgOpts[cfgPst.selector])(&cfgPst, &schCellCfg);
 391    return ret;
 392 } /* end of MacSchCellCfgReq */
 393
 394
 395 /*******************************************************************
 396  *
 397  * @brief Sends Cell config confirm to DU APP
 398  *
 399  * @details
 400  *
 401  *    Function : MacSendCellCfgCfm
 402  *
 403  *    Functionality:
 404  *      Sends Cell config confirm to DU APP
 405  *
 406  * @params[in] Response status
 407  * @return void
 408  *
 409  * ****************************************************************/
 410 void MacSendCellCfgCfm(uint16_t cellId, uint8_t response)
 411 {
 412    Pst pst;
 413    uint16_t   cellIdx;
 414    MacCellCfgCfm macCellCfgCfm;
 415
 416    memset(&pst, 0, sizeof(Pst));
 417
 418    GET_CELL_IDX(cellId, cellIdx);
 419    macCellCfgCfm.cellId = macCb.macCell[cellIdx]->macCellCfg.cellId;
 420    macCellCfgCfm.rsp = response;
 421
 422    /* Fill Pst */
 423    FILL_PST_MAC_TO_DUAPP(pst, EVENT_MAC_CELL_CONFIG_CFM);
 424    pst.selector  = ODU_SELECTOR_LC;
 425
 426    (*packMacCellCfmOpts[pst.selector])(&pst,&macCellCfgCfm);
 427 }
 428
 429
 430 /**
 431  * @brief Layer Manager Configuration response handler.
 432  *
 433  * @details
 434  *
 435  *     Function : MacProcSchCellCfgCfm
 436  *
 437  *     This function processes cell configuration to SCH
 438  *
 439  *  @param[in]  Pst           *pst
 440  *  @param[in]  SchCellCfgCfm *schCellCfgCfm
 441  *  @return  int
 442  *      -# ROK
 443  **/
 444 uint8_t MacProcSchCellCfgCfm(Pst *pst, SchCellCfgCfm *schCellCfgCfm)
 445 {
 446    uint16_t *cellId = NULLP;
 447
 448 #ifdef CALL_FLOW_DEBUG_LOG
 449    DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_SCH_CELL_CFG_CFM\n");
 450 #endif
 451
 452    if(schCellCfgCfm->rsp == RSP_OK)
 453    {
 454       cellId = &schCellCfgCfm->cellId;
 455 #ifdef INTEL_TIMER_MODE
 456       sendToLowerMac(UL_IQ_SAMPLE, 0, (void *)cellId);
 457 #else
 458       sendToLowerMac(CONFIG_REQUEST, 0, (void *)cellId);
 459 #endif
 460    }
 461    else
 462    {
 463       MacSendCellCfgCfm(schCellCfgCfm->cellId, RSP_NOK);
 464    }
 465    return ROK;
 466 }
 467
 468 /*******************************************************************
 469  *
 470  * @brief MAC handler for config response from PHY
 471  *
 472  * @details
 473  *
 474  *    Function : fapiMacConfigRsp
 475  *
 476  *    Functionality:
 477  *     Processes config response from PHY and sends cell config
 478  *     confirm to DU APP
 479  *
 480  * @params[in]
 481  * @return void
 482  *
 483  * ****************************************************************/
 484 void fapiMacConfigRsp(uint16_t cellId)
 485 {
 486    /* TODO : Processing of config response from PHY */
 487
 488    /* Send cell config cfm to DU APP */
 489    MacSendCellCfgCfm(cellId, RSP_OK);
 490 }
 491
 492 /*******************************************************************
 493  *
 494  * @brief Fill and Send Cell Delete response from MAC to DU APP
 495  *
 496  * @details
 497  *
 498  *    Function : MacSendCellDeleteRsp
 499  *
 500  *    Functionality: Fill and Send Cell Delete response from MAC to DUAPP
 501  *
 502  * @params[in] MAC Cell delete result
 503  *             SCH Cell delete response
 504  * @return ROK     - success
 505  *         RFAILED - failure
 506  *
 507  * ****************************************************************/
 508 uint8_t MacSendCellDeleteRsp(CellDeleteStatus result, uint8_t cellId)
 509 {
 510    MacCellDeleteRsp *deleteRsp=NULLP;
 511    Pst            rspPst;
 512
 513    MAC_ALLOC_SHRABL_BUF(deleteRsp, sizeof(MacCellDeleteRsp));
 514    if(!deleteRsp)
 515    {
 516       DU_LOG("\nERROR  -->  MAC : MacSendCellDeleteRsp(): Memory allocation for Cell delete response failed");
 517       return RFAILED;
 518    }
 519
 520    /* Filling CELL delete response */
 521
 522    memset(deleteRsp, 0, sizeof(MacCellDeleteRsp));
 523    deleteRsp->cellId = cellId;
 524    deleteRsp->result = result;
 525
 526    /* Fill Post structure and send CELL delete response*/
 527    memset(&rspPst, 0, sizeof(Pst));
 528    FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_CELL_DELETE_RSP);
 529    return (*macDuCellDeleteRspOpts[rspPst.selector])(&rspPst, deleteRsp);
 530 }
 531
 532 /*******************************************************************
 533  *
 534  * @brief  Processes CELL delete response from scheduler
 535  *
 536  * @details
 537  *
 538  *    Function : MacProcSchCellDeleteRsp
 539  *
 540  *    Functionality:
 541  *      Processes CELL delete from scheduler
 542  *
 543  * @params[in] Pst : Post structure
 544  *             schCellDelRsp : Scheduler CELL delete respons
 545  * @return ROK     - success
 546  *         RFAILED - failure
 547  *
 548  * * ****************************************************************/
 549 uint8_t MacProcSchCellDeleteRsp(Pst *pst, SchCellDeleteRsp *schCellDelRsp)
 550 {
 551    uint8_t  ret = ROK, sliceIdx = 0;
 552    uint16_t cellIdx=0;
 553    CellDeleteStatus status;
 554
 555 #ifdef CALL_FLOW_DEBUG_LOG
 556    DU_LOG("\nCall Flow: ENTSCH -> ENTMAC : EVENT_CELL_DELETE_RSP_TO_MAC\n");
 557 #endif
 558
 559    if(schCellDelRsp)
 560    {
 561       if(schCellDelRsp->rsp == RSP_OK)
 562       {
 563          DU_LOG("\nINFO   -->  MAC : SCH CELL Delete response for cellId[%d] is successful ", \
 564          schCellDelRsp->cellId);
 565          GET_CELL_IDX(schCellDelRsp->cellId, cellIdx);
 566          if(macCb.macCell[cellIdx])
 567          {
 568             if(macCb.macCell[cellIdx]->cellId == schCellDelRsp->cellId)
 569             {
 570                status  = SUCCESSFUL_RSP;
 571                if(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai)
 572                {
 573                   for(sliceIdx = 0; sliceIdx<macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.numSupportedSlice; sliceIdx++)
 574                   {
 575                      MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai[sliceIdx], sizeof(Snssai));
 576                   }
 577                   MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.snssai, macCb.macCell[cellIdx]->macCellCfg.plmnInfoList.\
 578                   numSupportedSlice * sizeof(Snssai*));
 579                }
 580                MAC_FREE(macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1Pdu, \
 581                   macCb.macCell[cellIdx]->macCellCfg.sib1Cfg.sib1PduLen);
 582                MAC_FREE(macCb.macCell[cellIdx], sizeof(MacCellCb));
 583             }
 584             else
 585             {
 586                 DU_LOG("ERROR  -->  MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
 587                 status = CELL_ID_INVALID;
 588                 ret = RFAILED;
 589             }
 590          }
 591          else
 592          {
 593             DU_LOG("ERROR  -->  MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
 594             status = CELL_ID_INVALID;
 595             ret = RFAILED;
 596          }
 597       }
 598       else
 599       {
 600          DU_LOG("ERROR  -->  MAC : MacProcSchCellDeleteRsp(): CellId[%d] does not exists", schCellDelRsp->cellId);
 601          status = CELL_ID_INVALID;
 602          ret = RFAILED;
 603       }
 604       if(MacSendCellDeleteRsp(status, schCellDelRsp->cellId) != ROK)
 605       {
 606          DU_LOG("\nERROR  -->  MAC: MacProcSchCellDeleteRsp(): Failed to send CELL delete response");
 607          ret = RFAILED;
 608       }
 609
 610    }
 611    else
 612    {
 613       DU_LOG("\nERROR  -->  MAC: MacProcSchCellDeleteRsp(): schCellDelRsp is NULL");
 614       ret = RFAILED;
 615    }
 616    return ret;
 617 }
 618
 619 /*******************************************************************
 620  *
 621  * @brief Sends Cell delete req to Scheduler
 622  *
 623  * @details
 624  *
 625  *    Function : sendCellDelReqToSch
 626  *
 627  *    Functionality: sends Cell delete req to Scheduler
 628  *
 629  * @params[in]  SchCellDelete *schCellDel
 630  * @return ROK     - success
 631  *         RFAILED - failure
 632  *
 633  * ****************************************************************/
 634
 635 uint8_t sendCellDelReqToSch(SchCellDelete *schCellDel)
 636 {
 637    Pst schPst;
 638    FILL_PST_MAC_TO_SCH(schPst, EVENT_CELL_DELETE_REQ_TO_SCH);
 639    return(*macSchCellDeleteReqOpts[schPst.selector])(&schPst, schCellDel);
 640 }
 641
 642 /*******************************************************************
 643  *
 644  * @brief Handles CELL Delete requst from DU APP
 645  *
 646  * @details
 647  *
 648  *    Function : MacProcCellDeleteReq
 649  *
 650  *    Functionality: Handles CELL Delete requst from DU APP
 651  *
 652  * @params[in] Pst *pst, MacCellDelete *cellDelete
 653  * @return ROK     - success
 654  *         RFAILED - failure
 655  *
 656  *
 657  * ****************************************************************/
 658 uint8_t MacProcCellDeleteReq(Pst *pst, MacCellDelete *cellDelete)
 659 {
 660    uint8_t ret = ROK, cellIdx=0;
 661    SchCellDelete schCellDelete;
 662
 663    DU_LOG("\nINFO   -->  MAC : Cell Delete Request received for cellId[%d]", cellDelete->cellId);
 664
 665    if(cellDelete)
 666    {
 667       GET_CELL_IDX(cellDelete->cellId, cellIdx);
 668       if(macCb.macCell[cellIdx])
 669       {
 670          if(macCb.macCell[cellIdx]->cellId == cellDelete->cellId)
 671          {
 672             memset(&schCellDelete, 0, sizeof(SchCellDelete));
 673             schCellDelete.cellId =  cellDelete->cellId;
 674             ret = sendCellDelReqToSch(&schCellDelete);
 675             if(ret != ROK)
 676             {
 677                DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Failed to send UE Delete Request to SCH");
 678                ret = RFAILED;
 679             }
 680          }
 681          else
 682          {
 683             DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
 684             cellDelete->cellId);
 685             ret = RFAILED;
 686          }
 687       }
 688       else
 689       {
 690          DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Failed to find the MacUeCb of CellId = %d",\
 691                cellDelete->cellId);
 692          ret = RFAILED;
 693       }
 694
 695       if(ret == RFAILED)
 696       {
 697           DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Sending failure response to DU");
 698           if(MacSendCellDeleteRsp(CELL_ID_INVALID, cellDelete->cellId) != ROK)
 699           {
 700              DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): failed to send cell delete rsp for cellID[%d]",\
 701              cellDelete->cellId);
 702           }
 703
 704       }
 705       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellDelete, sizeof(MacCellDelete));
 706    }
 707    else
 708    {
 709       DU_LOG("\nERROR  -->  MAC : MacProcCellDeleteReq(): Received MacCellDelete is NULL");
 710       ret = RFAILED;
 711    }
 712    return ret;
 713 }
 714
 715 /**
 716  * @brief free the temporary slice cfg stored in macCb.
 717  *
 718  * @details
 719  *
 720  *     Function : freeMacSliceCfgReq
 721  *
 722  *   free the temporary slice cfg stored in macCb
 723  *
 724  *  @param[in]
 725  *  @return  int
 726  *      -# ROK
 727  **/
 728 void freeMacSliceCfgReq(MacSliceCfgReq *cfgReq,Pst *pst)
 729 {
 730    uint8_t cfgIdx = 0;
 731
 732    if(cfgReq)
 733    {
 734       if(cfgReq->numOfConfiguredSlice)
 735       {
 736          for(cfgIdx = 0; cfgIdx<cfgReq->numOfConfiguredSlice; cfgIdx++)
 737          {
 738             if(cfgReq->listOfSliceCfg[cfgIdx])
 739             {
 740                MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfSliceCfg[cfgIdx]->rrmPolicyRatio, sizeof(RrmPolicyRatio));
 741             }
 742             MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfSliceCfg[cfgIdx], sizeof(MacSliceRrmPolicy));
 743          }
 744          MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq->listOfSliceCfg, cfgReq->numOfConfiguredSlice * sizeof(MacSliceRrmPolicy*));
 745       }
 746       MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cfgReq, sizeof(MacSliceCfgReq));
 747    }
 748 }
 749 /**
 750  * @brief fill Mac Slice Config Rsp
 751  *
 752  * @details
 753  *
 754  *     Function : fillMacSliceCfgRsp
 755  *
 756  *     This function   fill Mac Slice Config Rsp
 757  *
 758  *  @param[in]  SchSliceCfgRsp *sliceCfgRsp, MacSliceCfgRsp *macSliceCfgRsp,
 759  *  uint8_t *count
 760  *  @return  int
 761  *      -# ROK
 762  **/
 763 uint8_t fillMacSliceCfgRsp(SchSliceCfgRsp *schSliceCfgRsp, MacSliceCfgRsp *macSliceCfgRsp)
 764 {
 765
 766     bool sliceFound = false;
 767     uint8_t cfgIdx = 0;
 768
 769     macSliceCfgRsp->numSliceCfgRsp  = schSliceCfgRsp->numSliceCfgRsp;
 770     MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp->listOfSliceCfgRsp,  macSliceCfgRsp->numSliceCfgRsp* sizeof(MacSliceRsp*));
 771     if(macSliceCfgRsp->listOfSliceCfgRsp == NULLP)
 772     {
 773        DU_LOG("\nERROR  -->  MAC : Memory allocation failedi in fillMacSliceCfgRsp");
 774        return RFAILED;
 775     }
 776
 777     for(cfgIdx = 0; cfgIdx<schSliceCfgRsp->numSliceCfgRsp; cfgIdx++)
 778     {
 779        sliceFound = false;
 780        if(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp == RSP_OK)
 781        {
 782           sliceFound = true;
 783        }
 784
 785        MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(SliceRsp));
 786        if(macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx] == NULLP)
 787        {
 788           DU_LOG("\nERROR  -->  MAC : Memory allocation failedi in fillMacSliceCfgRsp");
 789           return RFAILED;
 790        }
 791
 792        macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->snssai = schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->snssai;
 793        if(sliceFound == true)
 794           macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp    = MAC_DU_APP_RSP_OK;
 795        else
 796        {
 797           macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->rsp    = MAC_DU_APP_RSP_NOK;
 798           macSliceCfgRsp->listOfSliceCfgRsp[cfgIdx]->cause  = SLICE_NOT_PRESENT;
 799        }
 800     }
 801     return ROK;
 802 }
 803
 804 /**
 805  * @brief send slice cfg response to duapp.
 806  *
 807  * @details
 808  *
 809  *     Function : MacSendSliceConfigRsp
 810  *
 811  *   sends  slice cfg response to duapp
 812  *
 813  *  @param[in] MacSliceCfgRsp macSliceCfgRsp
 814  *  @return  int
 815  *      -# ROK
 816  **/
 817 uint8_t MacSendSliceConfigRsp(MacSliceCfgRsp *macSliceCfgRsp)
 818 {
 819     Pst  rspPst;
 820
 821     memset(&rspPst, 0, sizeof(Pst));
 822     FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_SLICE_CFG_RSP);
 823     return (*macDuSliceCfgRspOpts[rspPst.selector])(&rspPst, macSliceCfgRsp);
 824
 825 }
 826 /**
 827  * @brief free the slice cfg rsp received from sch.
 828  *
 829  * @details
 830  *
 831  *     Function : freeSchSliceCfgRsp
 832  *
 833  *     This free the slice cfg rsp received from sch
 834  *
 835  *  @param[in]  SchSliceCfgRsp *sliceCfgrsp
 836  *  @return  int
 837  *      -# ROK
 838  **/
 839 void freeSchSliceCfgRsp(SchSliceCfgRsp *schSliceCfgRsp)
 840 {
 841    uint8_t cfgIdx = 0;
 842
 843    if(schSliceCfgRsp)
 844    {
 845       if(schSliceCfgRsp->numSliceCfgRsp)
 846       {
 847          for(cfgIdx = 0; cfgIdx< schSliceCfgRsp->numSliceCfgRsp; cfgIdx++)
 848          {
 849             MAC_FREE(schSliceCfgRsp->listOfSliceCfgRsp[cfgIdx], sizeof(SliceRsp));
 850          }
 851          MAC_FREE(schSliceCfgRsp->listOfSliceCfgRsp, schSliceCfgRsp->numSliceCfgRsp * sizeof(SliceRsp*));
 852       }
 853    }
 854 }
 855
 856 /**
 857  * @brief Mac process the slice cfg rsp received from sch.
 858  *
 859  * @details
 860  *
 861  *     Function : MacProcSchSliceCfgRsp
 862  *
 863  *     This function  process the slice cfg rsp received from sch
 864  *
 865  *  @param[in]  Pst           *pst
 866  *  @param[in]  SchSliceCfgRsp *sliceCfgrsp
 867  *  @return  int
 868  *      -# ROK
 869  **/
 870 uint8_t MacProcSchSliceCfgRsp(Pst *pst, SchSliceCfgRsp *schSliceCfgRsp)
 871 {
 872    MacSliceCfgRsp *macSliceCfgRsp = NULLP;
 873
 874    if(schSliceCfgRsp)
 875    {
 876       MAC_ALLOC_SHRABL_BUF(macSliceCfgRsp, sizeof(MacSliceCfgRsp));
 877       if(macSliceCfgRsp == NULLP)
 878       {
 879           DU_LOG("\nERROR  -->  MAC : Failed to allocate memory in MacProcSchSliceCfgRsp");
 880           return RFAILED;
 881       }
 882       if(schSliceCfgRsp->listOfSliceCfgRsp)
 883       {
 884          if(fillMacSliceCfgRsp(schSliceCfgRsp, macSliceCfgRsp) != ROK)
 885          {
 886             DU_LOG("\nERROR  -->  MAC : Failed to fill the slice cfg response");
 887             return RFAILED;
 888          }
 889          MacSendSliceConfigRsp(macSliceCfgRsp);
 890       }
 891       freeSchSliceCfgRsp(schSliceCfgRsp);
 892    }
 893    return ROK;
 894 }
 895
 896 /**
 897 * @brief send slice cfg response to duapp.
 898 *
 899 * @details
 900 *
 901 *     Function : MacSendSliceReconfigRsp
 902 *
 903 *   sends  slice cfg response to duapp
 904 *
 905 *  @param[in] MacSliceCfgRsp macSliceRecfgRsp
 906 *  @return  int
 907 *      -# ROK
 908 **/
 909 uint8_t MacSendSliceReconfigRsp(MacSliceCfgRsp *macSliceRecfgRsp)
 910 {
 911    Pst  rspPst;
 912
 913    memset(&rspPst, 0, sizeof(Pst));
 914    FILL_PST_MAC_TO_DUAPP(rspPst, EVENT_MAC_SLICE_RECFG_RSP);
 915    return (*macDuSliceReCfgRspOpts[rspPst.selector])(&rspPst, macSliceRecfgRsp);
 916
 917 }
 918
 919 /**
 920  * @brief Mac process the slice cfg rsp received from sch.
 921  *
 922  * @details
 923  *
 924  *     Function : MacProcSchSliceReCfgRsp
 925  *
 926  *     This function  process the slice cfg rsp received from sch
 927  *
 928  *  @param[in]  Pst           *pst
 929  *  @param[in]  SchSliceCfgRsp *schSliceRecfgRsp
 930  *  @return  int
 931  *      -# ROK
 932  **/
 933 uint8_t MacProcSchSliceReCfgRsp(Pst *pst, SchSliceCfgRsp *schSliceRecfgRsp)
 934 {
 935    MacSliceCfgRsp *macSliceReCfgRsp = NULLP;
 936
 937    if(schSliceRecfgRsp)
 938    {
 939       MAC_ALLOC_SHRABL_BUF(macSliceReCfgRsp, sizeof(MacSliceCfgRsp));
 940       if(macSliceReCfgRsp == NULLP)
 941       {
 942           DU_LOG("\nERROR  -->  MAC : Failed to allocate memory in MacProcSchSliceReCfgRsp");
 943           return RFAILED;
 944       }
 945
 946       if(schSliceRecfgRsp->listOfSliceCfgRsp)
 947       {
 948          if(fillMacSliceCfgRsp(schSliceRecfgRsp, macSliceReCfgRsp) != ROK)
 949          {
 950             DU_LOG("\nERROR  -->  MAC : Failed to fill the slice Recfg response");
 951             return RFAILED;
 952          }
 953          MacSendSliceReconfigRsp(macSliceReCfgRsp);
 954       }
 955       freeSchSliceCfgRsp(schSliceRecfgRsp);
 956    }
 957    return ROK;
 958 }
 959 /**********************************************************************
 960   End of file
 961  **********************************************************************/