From: Balaji Shankaran Date: Thu, 9 Apr 2020 08:08:59 +0000 (+0530) Subject: FAPI Slot Indication Changes X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=commitdiff_plain;h=f15bab416a36e421d42be3d2d1a42bf4c8c8b6c2;p=o-du%2Fl2.git FAPI Slot Indication Changes Change-Id: I2a5f3e41e851960dade3b41e0c436c1c026381ac Signed-off-by: Balaji Shankaran --- diff --git a/build/odu/makefile b/build/odu/makefile index 279ee02c9..0201c9e37 100644 --- a/build/odu/makefile +++ b/build/odu/makefile @@ -70,7 +70,7 @@ endif # macro for output file name and makefile name # -PLTFRM_FLAGS= -UMSPD -DODU #-DEGTP_TEST +PLTFRM_FLAGS= -UMSPD -DODU #-DEGTP_TEST -DWLS_MEM ifeq ($(MODE),TDD) PLTFRM_FLAGS += -DMODE=TDD diff --git a/src/5gnrmac/fapi_interface.h b/src/5gnrmac/fapi_interface.h index d68816624..c04751c6c 100644 --- a/src/5gnrmac/fapi_interface.h +++ b/src/5gnrmac/fapi_interface.h @@ -716,7 +716,7 @@ typedef struct { { uint32_t bchPayload; fapi_phy_mib_pdu_t phyMibPdu; - }; + }v; } fapi_bch_payload_t; // Updated per 5G FAPI @@ -742,7 +742,7 @@ typedef struct { fapi_dl_pdsch_pdu_t pdsch_pdu; fapi_dl_csi_rs_pdu_t csi_rs_pdu; fapi_dl_ssb_pdu_t ssb_pdu; - }; + }u; } fapi_dl_tti_req_pdu_t; // Updated per 5G FAPI diff --git a/src/5gnrmac/lwr_mac.h b/src/5gnrmac/lwr_mac.h index d153bccb2..dc6429ada 100644 --- a/src/5gnrmac/lwr_mac.h +++ b/src/5gnrmac/lwr_mac.h @@ -43,12 +43,11 @@ typedef enum /* Events in Lower Mac */ typedef enum{ - PARAM_REQ, - PARAM_RSP, - CONFIG_REQ, - CONFIG_RSP, - START_REQ, - STOP_REQ, + FAPI_PARAM_REQUEST, + FAPI_PARAM_RESPONSE, + FAPI_CONFIG_REQUEST, + FAPI_CONFIG_RESPONSE, + FAPI_START_REQUEST, MAX_EVENT }EventState; @@ -266,7 +265,6 @@ typedef struct clCellParam RssiMeasurement rssiMeasurementSupport; }ClCellParam; - EXTERN ClCb clGlobalCp; EXTERN ClCellCb * rgClUtlGetCellCb ARGS((U16 cellId)); diff --git a/src/5gnrmac/lwr_mac_cfg.c b/src/5gnrmac/lwr_mac_cfg.c deleted file mode 100644 index 4834162ec..000000000 --- a/src/5gnrmac/lwr_mac_cfg.c +++ /dev/null @@ -1,132 +0,0 @@ -/******************************************************************************* -################################################################################ -# Copyright (c) [2017-2019] [Radisys] # -# # -# Licensed under the Apache License, Version 2.0 (the "License"); # -# you may not use this file except in compliance with the License. # -# You may obtain a copy of the License at # -# # -# http://www.apache.org/licenses/LICENSE-2.0 # -# # -# Unless required by applicable law or agreed to in writing, software # -# distributed under the License is distributed on an "AS IS" BASIS, # -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # -# See the License for the specific language governing permissions and # -# limitations under the License. # -################################################################################ -*******************************************************************************/ - -/* This file handles the cell configurtaion for MAC CL */ - -#include "envdep.h" -#include "gen.h" -#include "ssi.h" -#include "cm_hash.h" - -#include "gen.x" -#include "ssi.x" -#include "cm_hash.x" -#include "cm_lib.x" - -#include "du_app_mac_inf.h" -#include "lwr_mac.h" - -EXTERN S16 rgClBldAndSndFAPICfgReq ARGS((ClCellCb *cellCb)); - -/******************************************************************* - * - * @brief Validates CL cell configuration - * - * @details - * - * Function : rgClVldtCellCfg - * - * Functionality: - * - Validates all PHY cell configuration patameters - * - * @params[in] cell config - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -PRIVATE S16 rgClVldtCellCfg -( -MacCellCfg *cellCfg -) -{ - RETVALUE(ROK); -} - - -/******************************************************************* - * - * @brief Cell configuration handler at MAC CL - * - * @details - * - * Function : RgClCellCfgReq - * - * Functionality: - * -Handler for new cell addition request from du_app - * - * @params[in] cell cfg - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -PUBLIC U16 RgClCellCfgReq -( -MacCellCfg *cellCfg -) -{ - ClCellCb *cellCb = NULLP; - - printf("\nReceived cell configuration request. Adding cellId[%d] phyCellId[%d]", cellCfg->cellId, cellCfg->phyCellId); - - if(clGlobalCp.numOfCells >= MAX_NUM_CELL_SUPP) - { - printf("\nMaximum number of cells [%d] already configured", MAX_NUM_CELL_SUPP); - RETVALUE(LCM_REASON_INVALID_PAR_VAL); - } - - if(rgClVldtCellCfg(cellCfg) != ROK) - { - printf("\nCell configuration failure. Cell Id [%d]", cellCfg->cellId); - RETVALUE(LCM_REASON_INVALID_PAR_VAL); - } - - if((cellCb = (ClCellCb *)rgClUtlGetCellCb(cellCfg->cellId)) == NULLP) - { - if((SGetSBuf(clGlobalCp.region, clGlobalCp.pool, (Data **)&cellCb, sizeof(ClCellCb)) != ROK) || (cellCb == NULLP)) - { - printf("\nFailed to allocate memory for new cell"); - RETVALUE(LCM_REASON_MEM_NOAVAIL); - } - cmMemset((U8 *)cellCb, 0, sizeof(ClCellCb)); - cellCb->cellId = cellCfg->cellId; - cellCb->phyState = PHY_STATE_IDLE; - - if((cmHashListInsert(&(clGlobalCp.cellCbLst), (PTR)cellCb, (U8 *)&cellCb->cellId, sizeof(U16))) != ROK) - { - printf("\nFailed to insert cell into list."); - RETVALUE(RFAILED); - } - - clGlobalCp.numOfCells++; - } - - cmMemcpy((U8 *)&cellCb->cellCfg, (U8 *)cellCfg, sizeof(MacCellCfg)); - - /* Build and send CONFIG request to PHY */ - if(rgClBldAndSndFAPICfgReq(cellCb) != ROK ) - { - printf("\nrgClBldAndSndPhyCfgReq failed"); - RETVALUE(LCM_REASON_NEG_CFM); - } - - RETVALUE(LCM_REASON_NOT_APPL); -} - -/********************************************************************** - End of file -**********************************************************************/ diff --git a/src/5gnrmac/lwr_mac_fsm.c b/src/5gnrmac/lwr_mac_fsm.c index b1676f891..06d37048d 100644 --- a/src/5gnrmac/lwr_mac_fsm.c +++ b/src/5gnrmac/lwr_mac_fsm.c @@ -16,9 +16,58 @@ ################################################################################ *******************************************************************************/ #include +#include + +/* header include files -- defines (.h) */ +#include "envopt.h" /* environment options */ +#include "envdep.h" /* environment dependent */ +#include "envind.h" /* environment independent */ +#include "gen.h" /* general layer */ +#include "ssi.h" /* system service interface */ +#include "cm_hash.h" /* common hash list */ +#include "cm_mblk.h" /* common memory link list library */ +#include "cm_llist.h" /* common linked list library */ +#include "cm_err.h" /* common error */ +#include "cm_lte.h" /* common LTE */ +#include "lrg.h" /* Layer manager interface includes*/ +#include "crg.h" /* CRG interface includes*/ +#include "rgu.h" /* RGU interface includes*/ +#include "tfu.h" /* TFU interface includes */ +#include "rg_sch_inf.h" /* SCH interface includes */ +#include "rg_prg.h" /* PRG (MAC-MAC) interface includes*/ +#include "rg_env.h" /* MAC environmental includes*/ +#include "rg.h" /* MAC includes*/ +#include "rg_err.h" /* MAC error includes*/ +#include "du_log.h" #include "lwr_mac_fsm.h" -EXTERN void sendToPhy ARGS((U16 msgType, U32 msgLen, void *msg)); +/* header/extern include files (.x) */ +#include "gen.x" /* general layer typedefs */ +#include "ssi.x" /* system services typedefs */ +#include "cm5.x" /* common timers */ +#include "cm_hash.x" /* common hash list */ +#include "cm_lib.x" /* common library */ +#include "cm_llist.x" /* common linked list */ +#include "cm_mblk.x" /* memory management */ +#include "cm_tkns.x" /* common tokens */ +#include "cm_lte.x" /* common tokens */ +#include "rgu.x" /* RGU types */ +#include "tfu.x" /* RGU types */ +#include "lrg.x" /* layer management typedefs for MAC */ +#include "crg.x" /* CRG interface includes */ +#include "rg_sch_inf.x" /* SCH interface typedefs */ +#include "rg_prg.x" /* PRG (MAC-MAC) Interface typedefs */ +#include "du_app_mac_inf.h" +#include "mac.h" +#include "rg.x" /* typedefs for MAC */ + +#define MIB_SFN_BITMASK 0xFC +#define SSB_PDU_TYPE 3 +#define SETLENGTH(x, size) x += size + + +EXTERN void sendToPhy ARGS((uint8_t msgType, uint32_t msgLen, void *msg)); +SlotIndInfo slotIndInfo; //global variable /******************************************************************* * @@ -38,7 +87,7 @@ EXTERN void sendToPhy ARGS((U16 msgType, U32 msgLen, void *msg)); * ****************************************************************/ S16 lwr_mac_handleInvalidEvt(void *msg) { - printf("\n Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState); + printf("\nLOWER MAC: Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState); RETVALUE(ROK); } @@ -60,7 +109,7 @@ S16 lwr_mac_handleInvalidEvt(void *msg) * @return void * * ****************************************************************/ -PUBLIC void fillMsgHeader(fapi_msg_t *hdr, U16 msgType, U16 msgLen) +PUBLIC void fillMsgHeader(fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen) { hdr->message_type_id = msgType; hdr->length = msgLen; @@ -85,7 +134,8 @@ PUBLIC void fillMsgHeader(fapi_msg_t *hdr, U16 msgType, U16 msgLen) * @return void * * ****************************************************************/ -PUBLIC void fillTlvs(fapi_uint16_tlv_t *tlv, U16 tag, U16 length, U16 value, U16 *msgLen) +PUBLIC void fillTlvs(fapi_uint16_tlv_t *tlv, uint16_t tag, uint16_t length, +uint16_t value, uint32_t *msgLen) { tlv->tl.tag = tag; tlv->tl.length = length; @@ -107,9 +157,9 @@ PUBLIC void fillTlvs(fapi_uint16_tlv_t *tlv, U16 tag, U16 length, U16 value, U16 * @params[in] Pointer to ClCellParam * Value to be compared * @return void - * + * ********************************************************************/ -PUBLIC void fillCyclicPrefix(U8 value, ClCellParam **cellPtr) +PUBLIC void fillCyclicPrefix(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_NORMAL_CYCLIC_PREFIX_MASK) == FAPI_NORMAL_CYCLIC_PREFIX_MASK) { @@ -143,7 +193,7 @@ PUBLIC void fillCyclicPrefix(U8 value, ClCellParam **cellPtr) * * ****************************************************************/ -PUBLIC void fillSubcarrierSpaceDl(U8 value, ClCellParam **cellPtr) +PUBLIC void fillSubcarrierSpaceDl(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK) { @@ -185,7 +235,7 @@ PUBLIC void fillSubcarrierSpaceDl(U8 value, ClCellParam **cellPtr) * * ****************************************************************/ -PUBLIC void fillBandwidthDl(U16 value, ClCellParam **cellPtr) +PUBLIC void fillBandwidthDl(uint16_t value, ClCellParam **cellPtr) { if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK) { @@ -202,7 +252,7 @@ PUBLIC void fillBandwidthDl(U16 value, ClCellParam **cellPtr) else if((value & FAPI_20MHZ_BW_MASK) == FAPI_20MHZ_BW_MASK) { (*cellPtr)->supportedBandwidthDl = BW_20MHZ; - } + } else if((value & FAPI_40MHZ_BW_MASK) == FAPI_40MHZ_BW_MASK) { (*cellPtr)->supportedBandwidthDl = BW_40MHZ; @@ -263,7 +313,7 @@ PUBLIC void fillBandwidthDl(U16 value, ClCellParam **cellPtr) * * ****************************************************************/ -PUBLIC void fillSubcarrierSpaceUl(U8 value, ClCellParam **cellPtr) +PUBLIC void fillSubcarrierSpaceUl(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK) { @@ -298,17 +348,17 @@ PUBLIC void fillSubcarrierSpaceUl(U8 value, ClCellParam **cellPtr) * Functionality: * -checks the value with the bitmask and * fills the cellPtr's UL Bandwidth - * + * * * * @params[in] Pointer to ClCellParam * Value to be compared * @return void - * + * * * ****************************************************************/ -PUBLIC void fillBandwidthUl(U16 value, ClCellParam **cellPtr) +PUBLIC void fillBandwidthUl(uint16_t value, ClCellParam **cellPtr) { if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK) { @@ -386,7 +436,7 @@ PUBLIC void fillBandwidthUl(U16 value, ClCellParam **cellPtr) * * ****************************************************************/ -PUBLIC void fillCCEmaping(U8 value, ClCellParam **cellPtr) +PUBLIC void fillCCEmaping(uint8_t value, ClCellParam **cellPtr) { if ((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_INTERLEAVED_MASK) { @@ -421,7 +471,7 @@ PUBLIC void fillCCEmaping(U8 value, ClCellParam **cellPtr) * * ****************************************************************/ -PUBLIC void fillPucchFormat(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPucchFormat(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK) { @@ -467,7 +517,7 @@ PUBLIC void fillPucchFormat(U8 value, ClCellParam **cellPtr) * * ****************************************************************/ -PUBLIC void fillPdschMappingType(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPdschMappingType(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PDSCH_MAPPING_TYPE_A_MASK) == FAPI_PDSCH_MAPPING_TYPE_A_MASK) { @@ -501,7 +551,7 @@ PUBLIC void fillPdschMappingType(U8 value, ClCellParam **cellPtr) * * ****************************************************************/ -PUBLIC void fillPdschAllocationType(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPdschAllocationType(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PDSCH_ALLOC_TYPE_0_MASK) == FAPI_PDSCH_ALLOC_TYPE_0_MASK) { @@ -534,7 +584,7 @@ PUBLIC void fillPdschAllocationType(U8 value, ClCellParam **cellPtr) * @return void * ******************************************************************/ -PUBLIC void fillPrbMappingType(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPrbMappingType(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) { @@ -568,7 +618,7 @@ PUBLIC void fillPrbMappingType(U8 value, ClCellParam **cellPtr) * ******************************************************************/ -PUBLIC void fillPdschDmrsConfigType(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPdschDmrsConfigType(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) { @@ -601,7 +651,7 @@ PUBLIC void fillPdschDmrsConfigType(U8 value, ClCellParam **cellPtr) * @return void * ******************************************************************/ -PUBLIC void fillPdschDmrsLength(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPdschDmrsLength(uint8_t value, ClCellParam **cellPtr) { if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_1) { @@ -635,7 +685,7 @@ PUBLIC void fillPdschDmrsLength(U8 value, ClCellParam **cellPtr) * ******************************************************************/ -PUBLIC void fillPdschDmrsAddPos(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPdschDmrsAddPos(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK) { @@ -676,7 +726,7 @@ PUBLIC void fillPdschDmrsAddPos(U8 value, ClCellParam **cellPtr) * @return void * ******************************************************************/ -PUBLIC void fillModulationOrderDl(U8 value, ClCellParam **cellPtr) +PUBLIC void fillModulationOrderDl(uint8_t value, ClCellParam **cellPtr) { if(value == 0 ) { @@ -718,7 +768,7 @@ PUBLIC void fillModulationOrderDl(U8 value, ClCellParam **cellPtr) * ******************************************************************/ -PUBLIC void fillPuschDmrsConfig(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPuschDmrsConfig(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK) { @@ -752,7 +802,7 @@ PUBLIC void fillPuschDmrsConfig(U8 value, ClCellParam **cellPtr) * ******************************************************************/ -PUBLIC void fillPuschDmrsLength(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPuschDmrsLength(uint8_t value, ClCellParam **cellPtr) { if(value == FAPI_PUSCH_DMRS_MAX_LENGTH_1) { @@ -786,7 +836,7 @@ PUBLIC void fillPuschDmrsLength(U8 value, ClCellParam **cellPtr) * ******************************************************************/ -PUBLIC void fillPuschDmrsAddPos(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPuschDmrsAddPos(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK) { @@ -828,7 +878,7 @@ PUBLIC void fillPuschDmrsAddPos(U8 value, ClCellParam **cellPtr) * ******************************************************************/ -PUBLIC void fillPuschMappingType(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPuschMappingType(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PUSCH_MAPPING_TYPE_A_MASK) == FAPI_PUSCH_MAPPING_TYPE_A_MASK) { @@ -862,7 +912,7 @@ PUBLIC void fillPuschMappingType(U8 value, ClCellParam **cellPtr) * ******************************************************************/ -PUBLIC void fillPuschAllocationType(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPuschAllocationType(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK) { @@ -896,7 +946,7 @@ PUBLIC void fillPuschAllocationType(U8 value, ClCellParam **cellPtr) * ******************************************************************/ -PUBLIC void fillPuschPrbMappingType(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPuschPrbMappingType(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) { @@ -930,7 +980,7 @@ PUBLIC void fillPuschPrbMappingType(U8 value, ClCellParam **cellPtr) * ******************************************************************/ -PUBLIC void fillModulationOrderUl(U8 value, ClCellParam **cellPtr) +PUBLIC void fillModulationOrderUl(uint8_t value, ClCellParam **cellPtr) { if(value == 0) { @@ -972,7 +1022,7 @@ PUBLIC void fillModulationOrderUl(U8 value, ClCellParam **cellPtr) * ******************************************************************/ -PUBLIC void fillPuschAggregationFactor(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPuschAggregationFactor(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK) { @@ -1014,7 +1064,7 @@ PUBLIC void fillPuschAggregationFactor(U8 value, ClCellParam **cellPtr) * ******************************************************************/ -PUBLIC void fillPrachLongFormat(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPrachLongFormat(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PRACH_LF_FORMAT_0_MASK) == FAPI_PRACH_LF_FORMAT_0_MASK) { @@ -1056,7 +1106,7 @@ PUBLIC void fillPrachLongFormat(U8 value, ClCellParam **cellPtr) * ******************************************************************/ -PUBLIC void fillPrachShortFormat(U8 value, ClCellParam **cellPtr) +PUBLIC void fillPrachShortFormat(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PRACH_SF_FORMAT_A1_MASK) == FAPI_PRACH_SF_FORMAT_A1_MASK) { @@ -1118,7 +1168,7 @@ PUBLIC void fillPrachShortFormat(U8 value, ClCellParam **cellPtr) * ******************************************************************/ -PUBLIC void fillFdOccasions(U8 value, ClCellParam **cellPtr) +PUBLIC void fillFdOccasions(uint8_t value, ClCellParam **cellPtr) { if(value == 0) { @@ -1160,7 +1210,7 @@ PUBLIC void fillFdOccasions(U8 value, ClCellParam **cellPtr) * ******************************************************************/ -PUBLIC void fillRssiMeas(U8 value, ClCellParam **cellPtr) +PUBLIC void fillRssiMeas(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_RSSI_REPORT_IN_DBM_MASK) == FAPI_RSSI_REPORT_IN_DBM_MASK) { @@ -1193,10 +1243,10 @@ PUBLIC void fillRssiMeas(U8 value, ClCellParam **cellPtr) * * ****************************************************************/ -S16 getParamValue(fapi_uint16_tlv_t *tlv, U16 type) +uint32_t getParamValue(fapi_uint16_tlv_t *tlv, uint16_t type) { - U16 valueLen; - void *temp, *posPtr; + uint16_t valueLen; + void *posPtr; valueLen = tlv->tl.length; posPtr = &tlv->tl.tag; posPtr += sizeof(tlv->tl.tag); @@ -1204,26 +1254,22 @@ S16 getParamValue(fapi_uint16_tlv_t *tlv, U16 type) /*TO DO: malloc to SSI memory */ if(type == FAPI_UINT_8) { - temp = (U8 *)malloc(valueLen * sizeof(U8)); - memcpy(temp, posPtr, valueLen); - return(*(U8 *)temp); + //temp = (uint8_t *)malloc(valueLen * sizeof(U8)); + //memcpy(temp, posPtr, valueLen); + return(*(uint8_t *)posPtr); } else if(type == FAPI_UINT_16) { - temp = (U16 *)malloc(valueLen * sizeof(U16)); - memcpy(temp, posPtr, valueLen); - return(*(U16 *)temp); + return(*(uint16_t *)posPtr); } else if(type == FAPI_UINT_32) { - temp = (U32 *)malloc(valueLen * sizeof(U32)); - memcpy(temp, posPtr, valueLen); - return(*(U32 *)temp); + return(*(uint32_t *)posPtr); } else { - printf("\n Value Extraction failed" ); - RETVALUE(RFAILED); + DU_LOG("\nLOWER MAC: Value Extraction failed" ); + return RFAILED; } } /******************************************************************* @@ -1246,23 +1292,28 @@ S16 getParamValue(fapi_uint16_tlv_t *tlv, U16 type) S16 lwr_mac_handleParamReqEvt(void *msg) { /* startGuardTimer(); */ - fapi_param_req_t *paramReq = (fapi_param_req_t *)msg; - if(SGetSBuf(0, 0, (Data **)¶mReq, sizeof(fapi_param_req_t)) != ROK) - { - printf("\nFailed to allocate memory for Param Request"); - RETVALUE(LCM_REASON_MEM_NOAVAIL); + uint32_t msgLen; //Length of message Body + msgLen = 0; + fapi_param_req_t *paramReq; + MAC_ALLOC(paramReq, sizeof(fapi_param_req_t)); + if(paramReq != NULLP) + { + fillMsgHeader(¶mReq->header, FAPI_PARAM_REQUEST, msgLen); + DU_LOG("\nLOWER MAC: sending param Req to Phy"); + sendToPhy(paramReq->header.message_type_id, sizeof(fapi_param_req_t), (void *)paramReq); + MAC_FREE(paramReq, sizeof(fapi_param_req_t)); + return ROK; } else { - fillMsgHeader(¶mReq->header, FAPI_PARAM_REQUEST, 0); - sendToPhy(paramReq->header.message_type_id, sizeof(fapi_param_req_t), (void *)paramReq); - RETVALUE(ROK); + DU_LOG("\nLOWER MAC: Failed to allocate memory for Param Request"); + return RFAILED; } } /******************************************************************* * - * @brief Sends FAPI Param rsp to MAC via PHY + * @brief Sends FAPI Param Response to MAC via PHY * * @details * @@ -1277,509 +1328,519 @@ S16 lwr_mac_handleParamReqEvt(void *msg) * * ****************************************************************/ -S16 lwr_mac_handleParamRspEvt(fapi_param_resp_t *paramRsp) +S16 lwr_mac_handleParamRspEvt(void *msg) { /* stopGuardTimer(); */ - U16 index; - U32 encodedVal; + uint8_t index; + uint32_t encodedVal; + fapi_param_resp_t *paramRsp; ClCellParam *cellParam = NULLP; - if(paramRsp == NULLP) - { - printf("\n Param Request for State [%d] is unsuccessfull", clGlobalCp.phyState); - RETVALUE(RFAILED); - } - printf("\n Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState); - SPutSBuf(0, 0, (Data *)paramRsp, paramRsp->header.length); - if(SGetSBuf(0, 0, (Data **)&cellParam, sizeof(ClCellParam)) != ROK) - { - printf("\nFailed to allocate memory for new cell"); - RETVALUE(LCM_REASON_MEM_NOAVAIL); - } - printf("\n Filling TLVS into MAC API"); - if(paramRsp->error_code == MSG_OK) + paramRsp = (fapi_param_resp_t *)msg; + DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState); + + if(paramRsp != NULLP) { - for(index = 0; index < paramRsp->number_of_tlvs; index++) + MAC_ALLOC(cellParam, sizeof(ClCellParam)); + if(cellParam != NULLP) { - switch(paramRsp->tlvs[index].tl.tag) + DU_LOG("\n LOWER MAC: Filling TLVS into MAC API"); + if(paramRsp->error_code == MSG_OK) { - case FAPI_RELEASE_CAPABILITY_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16); - if(encodedVal != RFAILED && (encodedVal & RELEASE_15) == RELEASE_15) - { - cellParam->releaseCapability = RELEASE_15; - } - break; - - case FAPI_PHY_STATE_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != clGlobalCp.phyState) - { - printf("\n PhyState mismatch [%d][%d]", clGlobalCp.phyState, clGlobalCp.event); - RETVALUE(RFAILED); - } - break; - - case FAPI_SKIP_BLANK_DL_CONFIG_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->skipBlankDlConfig = SUPPORTED; - } - else - { - cellParam->skipBlankDlConfig = NOT_SUPPORTED; - } - break; - - case FAPI_SKIP_BLANK_UL_CONFIG_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->skipBlankUlConfig = SUPPORTED; - } - else - { - cellParam->skipBlankUlConfig = NOT_SUPPORTED; - } - break; - - case FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG: - cellParam->numTlvsToReport = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16); - break; - - case FAPI_CYCLIC_PREFIX_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillCyclicPrefix(encodedVal, &cellParam); - } - break; - - case FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillSubcarrierSpaceDl(encodedVal, &cellParam); - } - break; - - case FAPI_SUPPORTED_BANDWIDTH_DL_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16); - if(encodedVal != RFAILED) - { - fillBandwidthDl(encodedVal, &cellParam); - } - break; - - case FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillSubcarrierSpaceUl(encodedVal, &cellParam); - } - break; - - case FAPI_SUPPORTED_BANDWIDTH_UL_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16); - if(encodedVal != RFAILED) - { - fillBandwidthUl(encodedVal, &cellParam); - } - break; - - case FAPI_CCE_MAPPING_TYPE_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillCCEmaping(encodedVal, &cellParam); - } - break; - - case FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->coresetOutsideFirst3OfdmSymsOfSlot = SUPPORTED; - } - else - { - cellParam->coresetOutsideFirst3OfdmSymsOfSlot = NOT_SUPPORTED; - } - break; - - case FAPI_PRECODER_GRANULARITY_CORESET_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->precoderGranularityCoreset = SUPPORTED; - } - else - { - cellParam->precoderGranularityCoreset = NOT_SUPPORTED; - } - break; - - case FAPI_PDCCH_MU_MIMO_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->pdcchMuMimo = SUPPORTED; - } - else - { - cellParam->pdcchMuMimo = NOT_SUPPORTED; - } - break; - - case FAPI_PDCCH_PRECODER_CYCLING_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->pdcchPrecoderCycling = SUPPORTED; - } - else - { - cellParam->pdcchPrecoderCycling = NOT_SUPPORTED; - } - break; - - case FAPI_MAX_PDCCHS_PER_SLOT_TAG: - cellParam->maxPdcchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - break; - - case FAPI_PUCCH_FORMATS_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPucchFormat(encodedVal, &cellParam); - } - break; - - case FAPI_MAX_PUCCHS_PER_SLOT_TAG: - cellParam->maxPucchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - break; - - case FAPI_PDSCH_MAPPING_TYPE_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPdschMappingType(encodedVal, &cellParam); - } - break; - - case FAPI_PDSCH_ALLOCATION_TYPES_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPdschAllocationType(encodedVal, &cellParam); - } - break; - - case FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPrbMappingType(encodedVal, &cellParam); - } - break; - - case FAPI_PDSCH_CBG_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->pdschCbg = SUPPORTED; - } - else - { - cellParam->pdschCbg = NOT_SUPPORTED; - } - break; - - case FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPdschDmrsConfigType(encodedVal, &cellParam); - } - break; - - case FAPI_PDSCH_DMRS_MAX_LENGTH_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPdschDmrsLength(encodedVal, &cellParam); - } - break; - - case FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPdschDmrsAddPos(encodedVal, &cellParam); - } - break; - - case FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG: - cellParam->maxPdschsTBsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - break; - - case FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal < FAPI_MAX_NUMBERMIMO_LAYERS_PDSCH) - { - cellParam->maxNumberMimoLayersPdsch = encodedVal; - } - break; - - case FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillModulationOrderDl(encodedVal, &cellParam); - } - break; - - case FAPI_MAX_MU_MIMO_USERS_DL_TAG: - cellParam->maxMuMimoUsersDl = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - break; - - case FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->pdschDataInDmrsSymbols = SUPPORTED; - } - else - { - cellParam->pdschDataInDmrsSymbols = NOT_SUPPORTED; - } - break; - - case FAPI_PREMPTIONSUPPORT_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->premptionSupport = SUPPORTED; - } - else - { - cellParam->premptionSupport = NOT_SUPPORTED; - } - break; - - case FAPI_PDSCH_NON_SLOT_SUPPORT_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->pdschNonSlotSupport = SUPPORTED; - } - else - { - cellParam->pdschNonSlotSupport = NOT_SUPPORTED; - } - break; - - case FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->uciMuxUlschInPusch = SUPPORTED; - } - else - { - cellParam->uciMuxUlschInPusch = NOT_SUPPORTED; - } - break; - - case FAPI_UCI_ONLY_PUSCH_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->uciOnlyPusch = SUPPORTED; - } - else - { - cellParam->uciOnlyPusch = NOT_SUPPORTED; - } - break; - - case FAPI_PUSCH_FREQUENCY_HOPPING_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->puschFrequencyHopping = SUPPORTED; - } - else + for(index = 0; index < paramRsp->number_of_tlvs; index++) + { + switch(paramRsp->tlvs[index].tl.tag) { - cellParam->puschFrequencyHopping = NOT_SUPPORTED; - } - break; - - case FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPuschDmrsConfig(encodedVal, &cellParam); - } - break; - - case FAPI_PUSCH_DMRS_MAX_LEN_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPuschDmrsLength(encodedVal, &cellParam); - } - break; - - case FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPuschDmrsAddPos(encodedVal, &cellParam); - } - break; - - case FAPI_PUSCH_CBG_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->puschCbg = SUPPORTED; + case FAPI_RELEASE_CAPABILITY_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16); + if(encodedVal != RFAILED && (encodedVal & RELEASE_15) == RELEASE_15) + { + cellParam->releaseCapability = RELEASE_15; + } + break; + + case FAPI_PHY_STATE_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != clGlobalCp.phyState) + { + printf("\n PhyState mismatch [%d][%d]", clGlobalCp.phyState, clGlobalCp.event); + RETVALUE(RFAILED); + } + break; + + case FAPI_SKIP_BLANK_DL_CONFIG_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->skipBlankDlConfig = SUPPORTED; + } + else + { + cellParam->skipBlankDlConfig = NOT_SUPPORTED; + } + break; + + case FAPI_SKIP_BLANK_UL_CONFIG_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->skipBlankUlConfig = SUPPORTED; + } + else + { + cellParam->skipBlankUlConfig = NOT_SUPPORTED; + } + break; + + case FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG: + cellParam->numTlvsToReport = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16); + break; + + case FAPI_CYCLIC_PREFIX_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillCyclicPrefix(encodedVal, &cellParam); + } + break; + + case FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillSubcarrierSpaceDl(encodedVal, &cellParam); + } + break; + + case FAPI_SUPPORTED_BANDWIDTH_DL_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16); + if(encodedVal != RFAILED) + { + fillBandwidthDl(encodedVal, &cellParam); + } + break; + + case FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillSubcarrierSpaceUl(encodedVal, &cellParam); + } + break; + + case FAPI_SUPPORTED_BANDWIDTH_UL_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16); + if(encodedVal != RFAILED) + { + fillBandwidthUl(encodedVal, &cellParam); + } + break; + + case FAPI_CCE_MAPPING_TYPE_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillCCEmaping(encodedVal, &cellParam); + } + break; + + case FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->coresetOutsideFirst3OfdmSymsOfSlot = SUPPORTED; + } + else + { + cellParam->coresetOutsideFirst3OfdmSymsOfSlot = NOT_SUPPORTED; + } + break; + + case FAPI_PRECODER_GRANULARITY_CORESET_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->precoderGranularityCoreset = SUPPORTED; + } + else + { + cellParam->precoderGranularityCoreset = NOT_SUPPORTED; + } + break; + + case FAPI_PDCCH_MU_MIMO_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->pdcchMuMimo = SUPPORTED; + } + else + { + cellParam->pdcchMuMimo = NOT_SUPPORTED; + } + break; + + case FAPI_PDCCH_PRECODER_CYCLING_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->pdcchPrecoderCycling = SUPPORTED; + } + else + { + cellParam->pdcchPrecoderCycling = NOT_SUPPORTED; + } + break; + + case FAPI_MAX_PDCCHS_PER_SLOT_TAG: + cellParam->maxPdcchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + break; + + case FAPI_PUCCH_FORMATS_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPucchFormat(encodedVal, &cellParam); + } + break; + + case FAPI_MAX_PUCCHS_PER_SLOT_TAG: + cellParam->maxPucchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + break; + + case FAPI_PDSCH_MAPPING_TYPE_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPdschMappingType(encodedVal, &cellParam); + } + break; + + case FAPI_PDSCH_ALLOCATION_TYPES_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPdschAllocationType(encodedVal, &cellParam); + } + break; + + case FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPrbMappingType(encodedVal, &cellParam); + } + break; + + case FAPI_PDSCH_CBG_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->pdschCbg = SUPPORTED; + } + else + { + cellParam->pdschCbg = NOT_SUPPORTED; + } + break; + + case FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPdschDmrsConfigType(encodedVal, &cellParam); + } + break; + + case FAPI_PDSCH_DMRS_MAX_LENGTH_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPdschDmrsLength(encodedVal, &cellParam); + } + break; + + case FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPdschDmrsAddPos(encodedVal, &cellParam); + } + break; + + case FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG: + cellParam->maxPdschsTBsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + break; + + case FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal < FAPI_MAX_NUMBERMIMO_LAYERS_PDSCH) + { + cellParam->maxNumberMimoLayersPdsch = encodedVal; + } + break; + + case FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillModulationOrderDl(encodedVal, &cellParam); + } + break; + + case FAPI_MAX_MU_MIMO_USERS_DL_TAG: + cellParam->maxMuMimoUsersDl = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + break; + + case FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->pdschDataInDmrsSymbols = SUPPORTED; + } + else + { + cellParam->pdschDataInDmrsSymbols = NOT_SUPPORTED; + } + break; + + case FAPI_PREMPTIONSUPPORT_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->premptionSupport = SUPPORTED; + } + else + { + cellParam->premptionSupport = NOT_SUPPORTED; + } + break; + + case FAPI_PDSCH_NON_SLOT_SUPPORT_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->pdschNonSlotSupport = SUPPORTED; + } + else + { + cellParam->pdschNonSlotSupport = NOT_SUPPORTED; + } + break; + + case FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->uciMuxUlschInPusch = SUPPORTED; + } + else + { + cellParam->uciMuxUlschInPusch = NOT_SUPPORTED; + } + break; + + case FAPI_UCI_ONLY_PUSCH_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->uciOnlyPusch = SUPPORTED; + } + else + { + cellParam->uciOnlyPusch = NOT_SUPPORTED; + } + break; + + case FAPI_PUSCH_FREQUENCY_HOPPING_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->puschFrequencyHopping = SUPPORTED; + } + else + { + cellParam->puschFrequencyHopping = NOT_SUPPORTED; + } + break; + + case FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPuschDmrsConfig(encodedVal, &cellParam); + } + break; + + case FAPI_PUSCH_DMRS_MAX_LEN_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPuschDmrsLength(encodedVal, &cellParam); + } + break; + + case FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPuschDmrsAddPos(encodedVal, &cellParam); + } + break; + + case FAPI_PUSCH_CBG_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->puschCbg = SUPPORTED; + } + else + { + cellParam->puschCbg = NOT_SUPPORTED; + } + break; + + case FAPI_PUSCH_MAPPING_TYPE_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPuschMappingType(encodedVal, &cellParam); + } + break; + + case FAPI_PUSCH_ALLOCATION_TYPES_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPuschAllocationType(encodedVal, &cellParam); + } + break; + + case FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPuschPrbMappingType(encodedVal, &cellParam); + } + break; + + case FAPI_PUSCH_MAX_PTRS_PORTS_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal < FAPI_PUSCH_MAX_PTRS_PORTS_UB) + { + cellParam->puschMaxPtrsPorts = encodedVal; + } + break; + + case FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG: + cellParam->maxPduschsTBsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + break; + + case FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG: + cellParam->maxNumberMimoLayersNonCbPusch = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + break; + + case FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillModulationOrderUl(encodedVal, &cellParam); + } + break; + + case FAPI_MAX_MU_MIMO_USERS_UL_TAG: + cellParam->maxMuMimoUsersUl = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + break; + + case FAPI_DFTS_OFDM_SUPPORT_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->dftsOfdmSupport = SUPPORTED; + } + else + { + cellParam->dftsOfdmSupport = NOT_SUPPORTED; + } + break; + + case FAPI_PUSCH_AGGREGATION_FACTOR_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPuschAggregationFactor(encodedVal, &cellParam); + } + break; + + case FAPI_PRACH_LONG_FORMATS_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPrachLongFormat(encodedVal, &cellParam); + } + break; + + case FAPI_PRACH_SHORT_FORMATS_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillPrachShortFormat(encodedVal, &cellParam); + } + break; + + case FAPI_PRACH_RESTRICTED_SETS_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED && encodedVal != 0) + { + cellParam->prachRestrictedSets = SUPPORTED; + } + else + { + cellParam->prachRestrictedSets = NOT_SUPPORTED; + } + break; + + case FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillFdOccasions(encodedVal, &cellParam); + } + break; + + case FAPI_RSSI_MEASUREMENT_SUPPORT_TAG: + encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + if(encodedVal != RFAILED) + { + fillRssiMeas(encodedVal, &cellParam); + } + break; + default: + //printf("\n Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index); + break; } - else - { - cellParam->puschCbg = NOT_SUPPORTED; - } - break; - - case FAPI_PUSCH_MAPPING_TYPE_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPuschMappingType(encodedVal, &cellParam); - } - break; - - case FAPI_PUSCH_ALLOCATION_TYPES_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPuschAllocationType(encodedVal, &cellParam); - } - break; - - case FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPuschPrbMappingType(encodedVal, &cellParam); - } - break; - - case FAPI_PUSCH_MAX_PTRS_PORTS_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal < FAPI_PUSCH_MAX_PTRS_PORTS_UB) - { - cellParam->puschMaxPtrsPorts = encodedVal; - } - break; - - case FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG: - cellParam->maxPduschsTBsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - break; - - case FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG: - cellParam->maxNumberMimoLayersNonCbPusch = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - break; - - case FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillModulationOrderUl(encodedVal, &cellParam); - } - break; - - case FAPI_MAX_MU_MIMO_USERS_UL_TAG: - cellParam->maxMuMimoUsersUl = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - break; - - case FAPI_DFTS_OFDM_SUPPORT_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->dftsOfdmSupport = SUPPORTED; - } - else - { - cellParam->dftsOfdmSupport = NOT_SUPPORTED; - } - break; - - case FAPI_PUSCH_AGGREGATION_FACTOR_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPuschAggregationFactor(encodedVal, &cellParam); - } - break; - - case FAPI_PRACH_LONG_FORMATS_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPrachLongFormat(encodedVal, &cellParam); - } - break; - - case FAPI_PRACH_SHORT_FORMATS_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillPrachShortFormat(encodedVal, &cellParam); - } - break; - - case FAPI_PRACH_RESTRICTED_SETS_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED && encodedVal != 0) - { - cellParam->prachRestrictedSets = SUPPORTED; - } - else - { - cellParam->prachRestrictedSets = NOT_SUPPORTED; - } - break; - - case FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillFdOccasions(encodedVal, &cellParam); - } - break; - - case FAPI_RSSI_MEASUREMENT_SUPPORT_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillRssiMeas(encodedVal, &cellParam); - } - break; - - default: - printf("\n Invalid value for TLV[%d]", paramRsp->tlvs[index].tl.tag); - break; - } - } - } - else - { - printf("\n Error Indication Evnt received in state[%d] event[%d]", clGlobalCp.phyState, clGlobalCp.event); - RETVALUE(RFAILED); - } - RETVALUE(ROK); + } + MAC_FREE(cellParam, sizeof(ClCellParam)); + MAC_FREE(paramRsp, sizeof(fapi_param_resp_t)); + return ROK; + } + else + { + DU_LOG("\n LOWER MAC: Invalid error code %d", paramRsp->error_code); + return RFAILED; + } + } + else + { + DU_LOG("\nLOWER MAC: Failed to allocate memory for cell param"); + return RFAILED; + } + } + else + { + DU_LOG("\nLOWER MAC: Param Response received from PHY is NULL"); + return RFAILED; + } } /******************************************************************* @@ -1801,23 +1862,146 @@ S16 lwr_mac_handleParamRspEvt(fapi_param_resp_t *paramRsp) S16 lwr_mac_handleConfigReqEvt(void *msg) { - RETVALUE(ROK); + uint8_t index = 0; + uint32_t msgLen = 0; + uint32_t configReqSize; + RgCellCb *cellParams; + MacCellCfg macCfgParams; + Inst inst = 0; + + DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState); + + fapi_config_req_t *configReq; + cellParams = rgCb[inst].cell; + macCfgParams = cellParams->macCellCfg; + configReqSize = sizeof(fapi_config_req_t) + (macCfgParams.numTlv * sizeof(fapi_uint16_tlv_t)); + MAC_ALLOC(configReq, configReqSize); + + if(configReq != NULL) + { + configReq->number_of_tlvs = macCfgParams.numTlv; + + if(macCfgParams.dlCarrCfg.pres) + { + fillTlvs(&configReq->tlvs[index++], FAPI_DL_BANDWIDTH_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.bw, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_DL_FREQUENCY_TAG, sizeof(uint32_t), macCfgParams.dlCarrCfg.freq, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_DL_K0_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.k0[0], &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_DL_GRIDSIZE_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.gridSize[0], &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_NUM_TX_ANT_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.numAnt, &msgLen); + } + if(macCfgParams.ulCarrCfg.pres) + { + fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_BANDWIDTH_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.bw, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_FREQUENCY_TAG, sizeof(uint32_t), macCfgParams.ulCarrCfg.freq, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_UL_K0_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.k0[0], &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_UL_GRID_SIZE_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.gridSize[0], &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_NUM_RX_ANT_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.numAnt, &msgLen); + } + fillTlvs(&configReq->tlvs[index++], FAPI_FREQUENCY_SHIFT_7P5_KHZ_TAG, sizeof(uint8_t), macCfgParams.freqShft, &msgLen); + + /* fill cell config */ + fillTlvs(&configReq->tlvs[index++], FAPI_PHY_CELL_ID_TAG, sizeof(uint8_t), macCfgParams.phyCellId, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_FRAME_DUPLEX_TYPE_TAG, sizeof(uint8_t), macCfgParams.dupType, &msgLen); + + /* fill SSB configuration */ + fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_POWER_TAG, sizeof(uint32_t), macCfgParams.ssbCfg.ssbPbchPwr, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_BCH_PAYLOAD_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.bchPayloadFlag, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_SCS_COMMON_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.scsCmn, &msgLen); + + /* fill PRACH configuration */ + fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SEQUENCE_LENGTH_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachSeqLen, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SUBC_SPACING_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachSubcSpacing, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_RESTRICTED_SET_CONFIG_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachRstSetCfg, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_NUM_PRACH_FD_OCCASIONS_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachFdm, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ROOT_SEQUENCE_INDEX_TAG, sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].rootSeqIdx, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_NUM_ROOT_SEQUENCES_TAG, sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numRootSeq, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_K1_TAG, sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].k1, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ZERO_CORR_CONF_TAG , sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].zeroCorrZoneCfg, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_NUM_UNUSED_ROOT_SEQUENCES_TAG, sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numUnusedRootSeq, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_UNUSED_ROOT_SEQUENCES_TAG, + sizeof(uint8_t), *(macCfgParams.prachCfg.fdm[0].unsuedRootSeq), &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PER_RACH_TAG, sizeof(uint8_t), macCfgParams.prachCfg.ssbPerRach, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachMultCarrBand, &msgLen); + + /* fill SSB table */ + fillTlvs(&configReq->tlvs[index++], FAPI_SSB_OFFSET_POINT_A_TAG, sizeof(uint16_t), macCfgParams.ssbCfg.ssbOffsetPointA, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_BETA_PSS_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.betaPss, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PERIOD_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.ssbPeriod, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_SSB_SUBCARRIER_OFFSET_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.ssbScOffset, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_MIB_TAG , sizeof(uint32_t), macCfgParams.ssbCfg.mibPdu[0], &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_SSB_MASK_TAG, sizeof(uint32_t), macCfgParams.ssbCfg.ssbMask[0], &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_BEAM_ID_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.beamId[0], &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.multCarrBand, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_MULTIPLE_CELLS_SS_PBCH_IN_A_CARRIER_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.multCellCarr, &msgLen); + + /* fill TDD table */ + fillTlvs(&configReq->tlvs[index++], FAPI_TDD_PERIOD_TAG, sizeof(uint8_t), macCfgParams.tddCfg.tddPeriod, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_SLOT_CONFIG_TAG, sizeof(uint8_t), macCfgParams.tddCfg.slotCfg[0][0], &msgLen); + + /* fill measurement config */ + fillTlvs(&configReq->tlvs[index++], FAPI_RSSI_MESUREMENT_TAG, sizeof(uint8_t), macCfgParams.rssiUnit, &msgLen); + + fillMsgHeader(&configReq->header, FAPI_CONFIG_REQUEST, msgLen); + DU_LOG("\nLOWER_MAC: Sending Config Request to Phy"); + sendToPhy(configReq->header.message_type_id, msgLen, (void *)configReq); + MAC_FREE(configReq, configReqSize); + return ROK; + } + else + { + DU_LOG("\nLOWER_MAC: Failed to allocate memory for config Request"); + return RFAILED; + } } -S16 lwr_mac_handleConfigRspEvt(fapi_config_resp_t *configRsp) +S16 lwr_mac_handleConfigRspEvt(void *msg) { - RETVALUE(ROK); + fapi_config_resp_t *configRsp; + configRsp = (fapi_config_resp_t *)msg; + DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState); + + if(configRsp != NULL) + { + if(configRsp->error_code == MSG_OK) + { + DU_LOG("\nLOWER MAC: PHY has moved to Conigured state \n"); + clGlobalCp.phyState = PHY_STATE_CONFIGURED; + MAC_FREE(configRsp, sizeof(fapi_config_resp_t)); + return ROK; + } + else + { + + DU_LOG("\n LOWER MAC: Invalid error code %d", configRsp->error_code); + return RFAILED; + } + } + else + { + DU_LOG("\nLOWER_MAC: Config Response received from PHY is NULL"); + return RFAILED; + } } S16 lwr_mac_handleStartReqEvt(void *msg) { - /*fapi_slot_ind_t *slotInd; - slotInd->header.message_type_id = FAPI_SLOT_INDICATION; - slotInd->sfn = 0; - slotInd->slot = 1; - phyToMac(slotInd->header.message_type_id, sizeof(fapi_slot_ind_t), (void *)slotInd); - */ - RETVALUE(ROK); + uint32_t msgLen = 0; + fapi_start_req_t *startReq; + MAC_ALLOC(startReq, sizeof(fapi_start_req_t)); + + if(startReq != NULL) + { + fillMsgHeader(&startReq->header, FAPI_START_REQUEST, msgLen); + DU_LOG("\nLOWER MAC: Sending Start Request to PHY"); + sendToPhy(startReq->header.message_type_id, sizeof(fapi_start_req_t), (void *)startReq); + MAC_FREE(startReq, sizeof(fapi_start_req_t)); + return ROK; + } + else + { + DU_LOG("\nLOWER MAC: Failed to allocate memory for Start Request"); + return RFAILED; + } } S16 lwr_mac_handleStopReqEvt(void *msg) @@ -1827,6 +2011,149 @@ S16 lwr_mac_handleStopReqEvt(void *msg) RETVALUE(ROK); } +/******************************************************************* + * + * @brief Modifes the received mibPdu to uint32 bit + * and stores it in MacCellCfg + * + * @details + * + * Function : setMibPdu + * + * Functionality: + * -Sets the MibPdu + * + * @params[in] Pointer to mibPdu + * pointer to modified value + ******************************************************************/ + +PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val) +{ + *mibPdu |= (((uint8_t)(slotIndInfo.sfn >> 2)) & MIB_SFN_BITMASK); + *val = (mibPdu[0] << 24 | mibPdu[1] << 16 | mibPdu[2] << 8); + DU_LOG("\nLOWER MAC: value filled %x", *val); +} + +/******************************************************************* + * + * @brief fills SSB PDU required for DL TTI info in MAC + * + * @details + * + * Function : fillSsbPdu + * + * Functionality: + * -Fills the SSB PDU info + * stored in MAC + * + * @params[in] Pointer to FAPI DL TTI Req + * Pointer to RgCellCb + * Pointer to msgLen of DL TTI Info + * @return ROK + * + ******************************************************************/ + +S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg, +uint32_t *msgLen) +{ + uint32_t mibPayload = 0; + if(dlTtiReqPdu != NULL) + { + dlTtiReqPdu->pduType = SSB_PDU_TYPE; /* SSB PDU */ + dlTtiReqPdu->u.ssb_pdu.physCellId = macCellCfg->phyCellId; + dlTtiReqPdu->u.ssb_pdu.betaPss = macCellCfg->ssbCfg.betaPss; + dlTtiReqPdu->u.ssb_pdu.ssbBlockIndex = macCb.macCell->dlSlot[0].cellBroadcastInfo.ssbIdxSupported; + dlTtiReqPdu->u.ssb_pdu.ssbSubCarrierOffset = macCellCfg->ssbCfg.ssbScOffset; + /* ssbOfPdufstA to be filled in ssbCfg */ + dlTtiReqPdu->u.ssb_pdu.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA; + dlTtiReqPdu->u.ssb_pdu.bchPayloadFlag = macCellCfg->ssbCfg.bchPayloadFlag; + /* Bit manipulation for SFN */ + setMibPdu(macCellCfg->ssbCfg.mibPdu, &mibPayload); + dlTtiReqPdu->u.ssb_pdu.bchPayload.v.bchPayload = mibPayload; + dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.numPrgs = 0; + dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.prgSize = 0; + dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.digBfInterfaces = 0; + dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.pmi_bfi[0].pmIdx = 0; + dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming. \ + pmi_bfi[0].beamIdx[0].beamidx = macCellCfg->ssbCfg.beamId[0]; + dlTtiReqPdu->pduSize = sizeof(fapi_dl_ssb_pdu_t); /* Size of SSB PDU */ + SETLENGTH(*msgLen, sizeof(fapi_dl_ssb_pdu_t)); + return ROK; + } + else + { + return RFAILED; + } +} + +/******************************************************************* + * + * @brief Sends DL TTI Request to PHY + * + * @details + * + * Function : handleDlTtiReq + * + * Functionality: + * -Sends FAPI Param req to PHY + * + * @params[in] RgDlSf *dlTtiReqSlot + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +S16 handleDlTtiReq(CmLteTimingInfo *dlTtiReqtimingInfo) +{ + uint32_t msgLen; + fapi_dl_tti_req_t *dlTtiReq; + fapi_dl_tti_req_pdu_t *dlTtiReqPdu; + RgCellCb *cellCbParams; + MacCellCfg macCellCfg; + Inst inst = 0; + + cellCbParams = rgCb[inst].cell; + if(dlTtiReqtimingInfo != NULLP) + { + MAC_ALLOC(dlTtiReq, sizeof(fapi_dl_tti_req_t)); + if(dlTtiReq != NULLP) + { + /* fill the SFN and slot value from crntTime */ + dlTtiReq->sfn = dlTtiReqtimingInfo->sfn; + dlTtiReq->slot = dlTtiReqtimingInfo->slot; + dlTtiReq->nPdus = 0; + dlTtiReq->nGroup = 0; + if(macCb.macCell->dlSlot[0].cellBroadcastInfo.ssbTrans) + { + macCellCfg = cellCbParams->macCellCfg; + + MAC_ALLOC(dlTtiReqPdu, sizeof(fapi_dl_tti_req_pdu_t)); + if(dlTtiReqPdu != NULLP) + { + fillSsbPdu(dlTtiReqPdu, &macCellCfg, &msgLen); + dlTtiReq->pdus = dlTtiReqPdu; + } + (dlTtiReq->nPdus)++; + msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t); + fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen); + sendToPhy(dlTtiReq->header.message_type_id, msgLen, (void *)dlTtiReq); + MAC_FREE(dlTtiReqPdu, sizeof(fapi_dl_tti_req_pdu_t)); + } + MAC_FREE(dlTtiReq, sizeof(fapi_dl_tti_req_t)); + return ROK; + } + else + { + DU_LOG("\nLOWER MAC: Failed to allocate memory for DL TTI Request"); + return RFAILED; + } + } + else + { + DU_LOG("\nLOWER MAC: Current TTI Info is NULL"); + return RFAILED; + } +} + lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] = { { @@ -1836,7 +2163,6 @@ lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] = lwr_mac_handleConfigReqEvt, lwr_mac_handleConfigRspEvt, lwr_mac_handleInvalidEvt, - lwr_mac_handleInvalidEvt }, { /* PHY_STATE_CONFIGURED */ @@ -1845,7 +2171,6 @@ lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] = lwr_mac_handleConfigReqEvt, lwr_mac_handleConfigRspEvt, lwr_mac_handleStartReqEvt, - lwr_mac_handleInvalidEvt }, { /* PHY_STATE_RUNNING */ @@ -1854,7 +2179,6 @@ lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] = lwr_mac_handleConfigReqEvt, lwr_mac_handleConfigRspEvt, lwr_mac_handleInvalidEvt, - lwr_mac_handleStopReqEvt } }; @@ -1876,10 +2200,10 @@ lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] = * @return void * ******************************************************************/ -S16 sendToLowerMac(U16 msgType, U32 msgLen, void *msg) +void sendToLowerMac(uint16_t msgType, uint32_t msgLen, void *msg) { clGlobalCp.event = msgType; - fapiEvtHdlr[clGlobalCp.phyState][msgType](msg); + fapiEvtHdlr[clGlobalCp.phyState][clGlobalCp.event](msg); } /********************************************************************** diff --git a/src/5gnrmac/lwr_mac_fsm.h b/src/5gnrmac/lwr_mac_fsm.h index e1a362833..a458b8147 100644 --- a/src/5gnrmac/lwr_mac_fsm.h +++ b/src/5gnrmac/lwr_mac_fsm.h @@ -28,11 +28,12 @@ S16 lwr_mac_handleInvalidEvt(void *msg); S16 lwr_mac_handleParamReqEvt(void *msg); -S16 lwr_mac_handleParamRspEvt(fapi_param_resp_t *); +S16 lwr_mac_handleParamRspEvt(void *msg); S16 lwr_mac_handleConfigReqEvt(void *msg); -S16 lwr_mac_handleConfigRspEvt(fapi_config_resp_t *); +S16 lwr_mac_handleConfigRspEvt(void *msg); S16 lwr_mac_handleStartReqEvt(void *msg); S16 lwr_mac_handleStopReqEvt(void *msg); +void sendToLowerMac(U16, U32, void *); typedef S16 (*lwrMacFsmHdlr)(void *); #endif diff --git a/src/5gnrmac/lwr_mac_handle_phy.c b/src/5gnrmac/lwr_mac_handle_phy.c index 39d5c7b8d..67f76d8c1 100644 --- a/src/5gnrmac/lwr_mac_handle_phy.c +++ b/src/5gnrmac/lwr_mac_handle_phy.c @@ -32,18 +32,18 @@ typedef S16 (*packSlotIndMsg) ARGS(( fapi_slot_ind_t *slotInd )); -S16 packLcSlotInd (Pst *pst, fapi_slot_ind_t *slotInd); +S16 packLcSlotInd (Pst *pst, SlotIndInfo *slotInd); S16 packTcSlotInd (Pst *pst, fapi_slot_ind_t *slotInd); S16 packLwlcSlotInd (Pst *pst, fapi_slot_ind_t *slotInd); -packSlotIndMsg packSlotIndMt[] = +packSlotIndMsg packSlotIndOpts[] = { packLcSlotInd, /* packing for loosely coupled */ fapiMacSlotInd, /* packing for tightly coupled */ packLwlcSlotInd, /* packing for light weight loosly coupled */ }; -S16 packLcSlotInd (Pst *pst, fapi_slot_ind_t *slotInd) +S16 packLcSlotInd (Pst *pst, SlotIndInfo *slotInd) { Buffer *mBuf = NULLP; if (SGetMsg(pst->region, pst->pool, &mBuf) != ROK) @@ -68,7 +68,7 @@ S16 packLwlcSlotInd (Pst *pst, fapi_slot_ind_t *slotInd) return ROK; } -void handleSlotInd(fapi_slot_ind_t *fapiSlotInd) +U16 handleSlotInd(fapi_slot_ind_t *fapiSlotInd) { /* fill Pst structure to send to lwr_mac to MAC */ Pst pst; @@ -88,10 +88,10 @@ void handleSlotInd(fapi_slot_ind_t *fapiSlotInd) slotInd.sfn = fapiSlotInd->sfn; slotInd.slot = fapiSlotInd->slot; - return (*packSlotIndMt[pst.selector])(&pst, &slotInd); + return (*packSlotIndOpts[pst.selector])(&pst, &slotInd); } -void handlePhyMessages(U8 *msg) +void handlePhyMessages(void *msg) { /* extract the header */ fapi_msg_t *header; diff --git a/src/5gnrmac/lwr_mac_li.c b/src/5gnrmac/lwr_mac_li.c deleted file mode 100644 index 001d2e383..000000000 --- a/src/5gnrmac/lwr_mac_li.c +++ /dev/null @@ -1,325 +0,0 @@ -/******************************************************************************* -################################################################################ -# Copyright (c) [2017-2019] [Radisys] # -# # -# Licensed under the Apache License, Version 2.0 (the "License"); # -# you may not use this file except in compliance with the License. # -# You may obtain a copy of the License at # -# # -# http://www.apache.org/licenses/LICENSE-2.0 # -# # -# Unless required by applicable law or agreed to in writing, software # -# distributed under the License is distributed on an "AS IS" BASIS, # -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # -# See the License for the specific language governing permissions and # -# limitations under the License. # -################################################################################ -*******************************************************************************/ - -/* This file contains handler for FAPI messages to be sent or received from PHY */ - -#include "envdep.h" -#include "gen.h" -#include "ssi.h" -#include "cm_hash.h" - -#include "gen.x" -#include "ssi.x" -#include "cm_hash.x" - -#include "du_app_mac_inf.h" -#include "lwr_mac.h" -#include "rg_cl_phy.h" -#include "fapi.h" -/*#include "wls_lib.h"*/ - -EXTERN S16 sendToPhy ARGS((U16 msgType, U32 msgLen, void *msg)); - -/******************************************************************* - * - * @brief Fills FAPI message header - * - * @details - * - * Function : fillMsgHdr - * - * Functionality: - * -Fills FAPI message header - * - * @params[in] Pointer to header - * Number of messages - * Messae Type - * Length of message - * @return void - * - * ****************************************************************/ -PUBLIC void fillMsgHdr(MsgHdr *hdr, U8 nMsg, U16 msgType, U32 msgLen) -{ - hdr->nMsg = nMsg; - hdr->msgType = msgType; - hdr->msgLen = msgLen; -} - - /******************************************************************* - * - * @brief Fills TLV - * - * @details - * - * Function : fillTlv - * - * Functionality: - * -Fills TLV - * - * @params[in] Pointer to TLV - * Tag - * Length - * Value - * @return Void - * - * ****************************************************************/ -PUBLIC void fillTlv(L1L2Tlv *tlv, U16 tag, U16 len, U16 value) -{ - tlv->tag = tag; - tlv->length = len; - tlv->value = value; -} - - - /******************************************************************* - * - * @brief Fills next config TLV - * - * @details - * - * Function : fillConfigTLV - * - * Functionality: - * - Finds pointer to next TLV in config req - * - Fills the TLV - * - Calculates Message length - * - * @params[in] - * @return ROK - void - * - * ****************************************************************/ -PUBLIC void fillConfigTLV(L1L2Tlv *nextTlv, U8 *configTlvs, U16 tag, U16 length, U16 value, U16 *msgLen) -{ - nextTlv = (L1L2Tlv *)(configTlvs + *msgLen); - fillTlv(nextTlv, tag, length, value); - *msgLen = *msgLen + sizeof(tag) + sizeof(length) + length; -} - - - /******************************************************************* - * - * @brief Build and send FAPI config req to PHY - * - * @details - * - * Function : rgClBldAndSndFAPICfgReq - * - * Functionality: - * -Build and send FAPI config req to PHY - * - * @params[in] - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ - -PUBLIC S16 rgClBldAndSndFAPICfgReq -( -ClCellCb *cellCb -) -{ - U16 msgLen; - U32 FAPIConfigReqSize; - U8 *configTlvs; - L1L2ConfigReq *FAPIConfigReq; - L1L2Tlv *nextTlv; - MacCellCfg cellCfg; - - FAPIConfigReqSize = sizeof(L1L2ConfigReq) - + (cellCb->cellCfg.numTlv * sizeof(L1L2Tlv)); - - /* TO DO :Change SGetSBuf to SGetSBufWls() later */ - if(SGetSBuf(0,0,(Data **)&FAPIConfigReq, FAPIConfigReqSize) != ROK ) - { - printf("\nMemory allocation failed for PHY Config Req"); - RETVALUE(RFAILED); - } - - nextTlv = NULLP; - msgLen = 0; - cellCfg = cellCb->cellCfg; - configTlvs = (U8 *)((U8 *)FAPIConfigReq + MSG_HDR_SIZE + 2); - - FAPIConfigReq->nTlv = cellCfg.numTlv; - FAPIConfigReq->carrierId = cellCb->cellId; - - /* Filling cell configuration */ - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_PHY_CELL_ID, sizeof(U16), cellCfg.phyCellId, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_FRAME_DUP_TYPE, sizeof(U16), cellCfg.dupType, &msgLen); - - /* Filling DL carrier configuration */ - if(cellCfg.dlCarrCfg.pres) - { - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_DL_BW, sizeof(U16), cellCfg.dlCarrCfg.bw, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_DL_FREQ, sizeof(U16), cellCfg.dlCarrCfg.freq, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_DLK0, sizeof(U16),cellCfg.dlCarrCfg.k0[0], &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_DL_GRID_SIZE, sizeof(U16),cellCfg.dlCarrCfg.gridSize[0], &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_NUM_TX_ANT, sizeof(U16), cellCfg.dlCarrCfg.numAnt, &msgLen); - } - - /* Filling UL carrier configuration */ - if(cellCfg.ulCarrCfg.pres) - { - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_UL_BW, sizeof(U16), cellCfg.ulCarrCfg.bw, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_UL_FREQ, sizeof(U16), cellCfg.ulCarrCfg.freq, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_ULK0, sizeof(U16), cellCfg.ulCarrCfg.k0[0], &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_UL_GRID_SIZE, sizeof(U16), cellCfg.ulCarrCfg.gridSize[0], &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_NUM_RX_ANT, sizeof(U16), cellCfg.ulCarrCfg.numAnt, &msgLen); - } - - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_FREQ_SHIFT_7P5KHZ, sizeof(U16), cellCfg.freqShft, &msgLen); - - /* Filling SSB configuration */ - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SS_PBCH_PWR, sizeof(U16), cellCfg.ssbCfg.ssbPbchPwr, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_BCH_PAYLOAD, sizeof(U16), cellCfg.ssbCfg.bchPayloadFlag, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SCS_COMM, sizeof(U16), cellCfg.ssbCfg.scsCmn, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SSB_OFFS_POINT_A, sizeof(U16), cellCfg.ssbCfg.ssbOffsetPointA, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_BETA_PSS, sizeof(U16), cellCfg.ssbCfg.betaPss, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SSB_PERIOD, sizeof(U16), cellCfg.ssbCfg.ssbPeriod, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SSB_SUBC_OFFS, sizeof(U16), cellCfg.ssbCfg.ssbScOffset, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_MIB, sizeof(U16), cellCfg.ssbCfg.mibPdu, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SSB_MASK, sizeof(U16), cellCfg.ssbCfg.ssbMask[0], &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SS_PBCH_MULT_CARR_BAND, sizeof(U16), cellCfg.ssbCfg.multCarrBand, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_MULT_CELL_SS_PBCH_CARR, sizeof(U16), cellCfg.ssbCfg.multCellCarr, &msgLen); - - /* Filling PRACH configuration */ - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_PRACH_SEQ_LEN, sizeof(U16), cellCfg.prachCfg.prachSeqLen, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_PRACH_SUBC_SPAC, sizeof(U16), cellCfg.prachCfg.prachSubcSpacing, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_RES_SET_CFG, sizeof(U16), cellCfg.prachCfg.prachRstSetCfg, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_NUM_PRACH_FD_OCC, sizeof(U16), cellCfg.prachCfg.prachFdm, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_PRACH_ROOT_SEQ_ID, sizeof(U16), cellCfg.prachCfg.fdm[0].rootSeqIdx, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_NUM_ROOT_SEQ, sizeof(U16), cellCfg.prachCfg.fdm[0].numRootSeq, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_K1, sizeof(U16), cellCfg.prachCfg.fdm[0].k1, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_PRACH_ZERO_CORR_CFG, sizeof(U16), cellCfg.prachCfg.fdm[0].zeroCorrZoneCfg, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_NUM_UNUSED_ROOT_SEQ, sizeof(U16), cellCfg.prachCfg.fdm[0].numUnusedRootSeq, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_UNUSED_ROOT_SEQ, sizeof(U16), *(cellCfg.prachCfg.fdm[0].unsuedRootSeq), &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SSB_PER_RACH, sizeof(U16), cellCfg.prachCfg.ssbPerRach, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_PRACH_MULT_CARR_BAND, sizeof(U16), cellCfg.prachCfg.prachMultCarrBand, &msgLen); - - /* Filling TDD configuration */ - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_TDD_PERIOD, sizeof(U16), cellCfg.tddCfg.tddPeriod, &msgLen); - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SLOT_CFG, sizeof(U16), cellCfg.tddCfg.slotCfg[0][0], &msgLen); - - /* Filling RSSI measurement configuration */ - fillConfigTLV(nextTlv, configTlvs, CFG_TAG_RSSI_MEAS, sizeof(U16), cellCfg.rssiUnit, &msgLen); - - msgLen = msgLen + sizeof(L1L2ConfigReq); - - /* Filling message header */ - fillMsgHdr(&FAPIConfigReq->hdr, 1, MSG_TYPE_CONFIG_REQ, msgLen); - - /* Sending msg to PHY */ - sendToPhy(MSG_TYPE_CONFIG_REQ, FAPIConfigReqSize, (void *)FAPIConfigReq); - - RETVALUE(ROK); -} - - -/******************************************************************* - * - * @brief Handles FAPI config response - * - * @details - * - * Function : rgClHndlCfgReq - * - * Functionality: - * -Handles FAPI config request - * - * @params[in] Message pointer - * - * @return void - * - *****************************************************************/ - -S16 rgClHndlCfgReq(void *msg) -{ - ClCellCb *cellCb = NULLP; - L1L2ConfigRsp *configRsp; - - configRsp = (L1L2ConfigRsp *)msg; - - if(configRsp->status != MSG_OK) - { - printf("\nPHY configuration failed"); - RETVALUE(RFAILED); - } - - if((cellCb = (ClCellCb *)rgClUtlGetCellCb(configRsp->carrierId)) != NULLP) - { - printf("\nCell Id[%d] not found", configRsp->carrierId); - RETVALUE(RFAILED); - } - - cellCb->phyState = PHY_STATE_CONFIGURED; - clGlobalCp.phyState = PHY_STATE_CONFIGURED; - - printf("\nReceived successful PHY configuration response"); - - SPutSBuf(0, 0, (Data *)msg, configRsp->hdr.msgLen ); - - RETVALUE(ROK); -} - -/******************************************************************* - * - * @brief Handles FAPI param response - * - * @details - * - * Function : lwrMacHndlParamReq - * - * Functionality: - * -Handles FAPI param request - * - * @params[in] Message pointer - * - * @return void - * - *****************************************************************/ -S16 lwrMacHndlParamReq(void *msg) -{ - ClCellCb *cellCb = NULLP; - fapi_param_resp_t *paramRsp; - - paramRsp = (fapi_param_resp_t *)msg; - - if(paramRsp->error_code != MSG_OK) - { - printf("\nPHY configuration failed"); - RETVALUE(RFAILED); - } - - if(paramRsp->tlvs[0].value == 0) - { - cellCb->phyState = PHY_STATE_IDLE; - clGlobalCp.phyState = PHY_STATE_IDLE; - } - - printf("\nReceived successful PHY configuration response"); - - SPutSBuf(0, 0, (Data *)msg, paramRsp->header.length); - - - RETVALUE(ROK); - -} - -/********************************************************************** - End of file -**********************************************************************/ diff --git a/src/5gnrmac/lwr_mac_phy.c b/src/5gnrmac/lwr_mac_phy.c index 3cb711d05..3def8a374 100644 --- a/src/5gnrmac/lwr_mac_phy.c +++ b/src/5gnrmac/lwr_mac_phy.c @@ -17,8 +17,9 @@ *******************************************************************************/ /* This file contains APIs to send/receive messages from PHY */ +#include +#include -#include "stdio.h" #include "envdep.h" #include "ssi.h" @@ -27,37 +28,7 @@ EXTERN S16 rgClHndlCfgReq ARGS((void *msg)); -EXTERN void macToPhy ARGS((U16 msgType, U32 msgLen, void *msg)); -EXTERN void processRequest ARGS((U16 msgType, U32 msgLen, void *msg)); -/****************************************************************** - * - * @brief Receives message to PHY - * - * @details - * - * Function : phyToMac - * - * Functionality: - * -Receives Msg from PHY - * - * @params[in] Message Pointer - * - * @return void - * - ******************************************************************/ - -void phyToMac(U16 msgType, U32 msgLen,void *msg) -{ - switch(msgType) - { - case MSG_TYPE_CONFIG_RSP: - rgClHndlCfgReq(msg); - break; - - default: - printf("\nInvalid message type[%x] from PHY", msgType); - } -} +EXTERN void processFapiRequest ARGS((uint8_t msgType, uint32_t msgLen, void *msg)); /******************************************************************* * @@ -78,9 +49,9 @@ void phyToMac(U16 msgType, U32 msgLen,void *msg) * ******************************************************************/ -PUBLIC S16 sendToPhy(U16 msgType, U32 msgLen, void *msg) +PUBLIC void sendToPhy(uint8_t msgType, uint32_t msgLen, void *msg) { -#if 0 +#ifdef WLS_MEM S8 ret; void *pMsg; @@ -92,9 +63,11 @@ PUBLIC S16 sendToPhy(U16 msgType, U32 msgLen, void *msg) printf("\nFailure in sending message to PHY"); RETVALUE(RFAILED); } -#endif +#else - processRequest(msgType, msgLen, msg); + processFapiRequest(msgType, msgLen, msg); + +#endif } /********************************************************************** diff --git a/src/5gnrmac/mac.h b/src/5gnrmac/mac.h new file mode 100644 index 000000000..f6b483fbf --- /dev/null +++ b/src/5gnrmac/mac.h @@ -0,0 +1,75 @@ +/******************************************************************************* +################################################################################ +# Copyright (c) [2017-2019] [Radisys] # +# # +# Licensed under the Apache License, Version 2.0 (the "License"); # +# you may not use this file except in compliance with the License. # +# You may obtain a copy of the License at # +# # +# http://www.apache.org/licenses/LICENSE-2.0 # +# # +# Unless required by applicable law or agreed to in writing, software # +# distributed under the License is distributed on an "AS IS" BASIS, # +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # +# See the License for the specific language governing permissions and # +# limitations under the License. # +################################################################################ + *******************************************************************************/ +#ifndef _MAC_H_ +#define _MAC_H_ + +#include + +/* header include files (.h) */ +#include "envopt.h" /* environment options */ +#include "envdep.h" /* environment dependent */ +#include "envind.h" /* environment independent */ +#include "gen.h" /* general */ +#include "ssi.h" /* system services */ +#include "cm_tkns.h" /* Common Token Defines */ +#include "cm_llist.h" /* Common Link List Defines */ +#include "cm_hash.h" /* Common Hash List Defines */ +#include "cm_lte.h" /* Common LTE Defines */ +#include "cm_mblk.h" /* Common LTE Defines */ +#include "tfu.h" /* RGU Interface defines */ +#include "lrg.h" +#include "du_app_mac_inf.h" +#include "mac_sch_interface.h" + +/* header/extern include files (.x) */ +#include "gen.x" /* general */ +#include "ssi.x" /* system services */ +#include "cm_tkns.x" /* Common Token Definitions */ +#include "cm_llist.x" /* Common Link List Definitions */ +#include "cm_lib.x" /* Common Library Definitions */ +#include "cm_hash.x" /* Common Hash List Definitions */ +#include "cm_lte.x" /* Common LTE Defines */ +#include "cm_mblk.x" /* Common LTE Defines */ +#include "tfu.x" /* RGU Interface includes */ +#include "lrg.x" + +#define MAX_SLOT_SUPPORTED 50 + +typedef struct macDlSlot +{ + DlBrdcstAlloc cellBroadcastInfo; + +}MacDlSlot; + +typedef struct macCellCb +{ + MacDlSlot dlSlot[MAX_SLOT_SUPPORTED]; +}MacCellCb; + +typedef struct macCb +{ + MacCellCb *macCell; +}MacCb; + +/* global variable */ +MacCb macCb; + +#endif +/********************************************************************** + End of file + **********************************************************************/ diff --git a/src/5gnrmac/mac_slot_ind.c b/src/5gnrmac/mac_slot_ind.c index 51b07f41f..cba1ccc20 100644 --- a/src/5gnrmac/mac_slot_ind.c +++ b/src/5gnrmac/mac_slot_ind.c @@ -40,11 +40,14 @@ #include "tfu.x" /* RGU Interface includes */ #include "lrg.x" #include "du_app_mac_inf.h" -#include "mac_sch_interface.h" +#include "mac.h" int MacProcDlBrdcstAlloc(Pst *pst, DlBrdcstAlloc *dlBrdcstAlloc) { - + if(dlBrdcstAlloc != NULLP) + { + memcpy(&macCb.macCell->dlSlot[0].cellBroadcastInfo, dlBrdcstAlloc, sizeof(DlBrdcstAlloc)); + } return ROK; } diff --git a/src/5gnrmac/rg_lmm.c b/src/5gnrmac/rg_lmm.c index 5c64f0328..7683a6d6b 100755 --- a/src/5gnrmac/rg_lmm.c +++ b/src/5gnrmac/rg_lmm.c @@ -77,7 +77,6 @@ static int RLOG_MODULE_ID=4096; #include "lrg.x" /* LRG Interface includes */ #include "rgr.x" /* LRG Interface includes */ #include "du_app_mac_inf.h" -#include "mac_sch_interface.h" #include "rg.x" /* MAC includes */ #ifdef SS_DIAG #include "ss_diag.h" /* Common log file */ @@ -86,7 +85,7 @@ static int RLOG_MODULE_ID=4096; #include "ss_rbuf.x" #include "lwr_mac.h" /* MAC CL defines */ - +#include "mac.h" #ifdef __cplusplus extern "C" { #endif /* __cplusplus */ @@ -2103,6 +2102,7 @@ int MacHdlCellCfgReq Pst cfmPst; int ret = ROK; RgCellCb *cellCb; + MacCellCb *macCellCb; Inst inst = pst->dstInst; cmMemset((U8 *)&cfmPst, 0, sizeof(Pst)); @@ -2117,6 +2117,13 @@ int MacHdlCellCfgReq memcpy(&cellCb->macCellCfg,macCellCfg,sizeof(MacCellCfg)); rgCb[inst].cell = cellCb; + MAC_ALLOC(macCellCb,sizeof(MacCellCb)); + if(macCellCb == NULLP) + { + DU_LOG("\nMAC : macCellCb is NULL at handling of macCellCfg\n"); + return RFAILED; + } + macCb.macCell = macCellCb; /* Send cell cfg to scheduler */ ret = MacSchCellCfgReq(pst, macCellCfg); if(ret != ROK) diff --git a/src/5gnrmac/rg_tom.c b/src/5gnrmac/rg_tom.c index dd3b1e043..63899952d 100755 --- a/src/5gnrmac/rg_tom.c +++ b/src/5gnrmac/rg_tom.c @@ -76,6 +76,7 @@ invoked by PHY towards MAC #include "rgm.x" /* layer management typedefs for MAC */ #include "rgm.h" /* layer management typedefs for MAC */ #include "du_app_mac_inf.h" +#include "mac.h" #include "rg.x" /* typedefs for MAC */ #ifdef MAC_RLC_UL_RBUF @@ -611,6 +612,12 @@ SlotIndInfo slotInd } } #endif + +/* Trigger for DL TTI REQ */ + CmLteTimingInfo dlTtiReqtimingInfo; + RGADDTOCRNTTIME(cellCb->crntTime, dlTtiReqtimingInfo, TFU_DELTA); + handleDlTtiReq(&dlTtiReqtimingInfo); + dlSf = &cellCb->subFrms[(slotInd.slot % RG_NUM_SUB_FRAMES)]; if((dlSf->txDone == TRUE) || diff --git a/src/cm/lphy_stub.h b/src/cm/lphy_stub.h index 67a3a2f28..7ef881bcf 100644 --- a/src/cm/lphy_stub.h +++ b/src/cm/lphy_stub.h @@ -9,5 +9,6 @@ #include "gen.x" /* General */ #include "ssi.x" /* System services */ -void duStartTtiThread(); +void duStartSlotIndicaion(); +void buildAndSendSlotIndication(); S16 duSendEgtpSlotInd(); diff --git a/src/du_app/du_msg_hdl.c b/src/du_app/du_msg_hdl.c index 2f77a76d9..5f819170c 100644 --- a/src/du_app/du_msg_hdl.c +++ b/src/du_app/du_msg_hdl.c @@ -1591,6 +1591,7 @@ uint16_t duHandleMacCellCfgCfm(MacCellCfgCfm *macCellCfgCfm) if(macCellCfgCfm->transId == duCb.duMacCellCfg->transId) { /* free the memory allocated during sending macCellCfg request */ + DU_FREE(duCb.duMacCellCfg->sib1Cfg.sib1Pdu, duCfgParam.srvdCellLst[0].duSysInfo.sib1Len); DU_FREE(duCb.duMacCellCfg,sizeof(MacCellCfg)); duCb.duMacCellCfg = NULLP; diff --git a/src/phy_stub/l1_bdy1.c b/src/phy_stub/l1_bdy1.c index 435903c68..3dfdc9e73 100644 --- a/src/phy_stub/l1_bdy1.c +++ b/src/phy_stub/l1_bdy1.c @@ -17,6 +17,7 @@ *******************************************************************************/ /*This file contains stub for PHY to handle messages to/from MAC CL */ +#include #include "envdep.h" #include "gen.h" @@ -28,20 +29,26 @@ #include "rg_cl_phy.h" #include "lwr_mac.h" #include "fapi.h" - - -EXTERN void phyToMac ARGS((U16 msgType, U32 msgLen,void *msg)); -EXTERN void fillTlvs ARGS((fapi_uint16_tlv_t *tlv, U16 tag, U16 length, U16 value, U16 *msgLen)); -EXTERN void fillMsgHeader ARGS((fapi_msg_t *hdr, U16 msgType, U16 msgLen)); -EXTERN S16 sendToLowerMac ARGS((U16 msgType, U32 msgLen,void *msg)); - +#include "lphy_stub.h" + +#define MAX_SLOT_VALUE 9 +#define MAX_SFN_VALUE 1023 + +uint16_t sfnValue = 0; +uint16_t slotValue = 0; +EXTERN void phyToMac ARGS((uint16_t msgType, uint32_t msgLen,void *msg)); +EXTERN void fillTlvs ARGS((fapi_uint16_tlv_t *tlv, uint16_t tag, uint16_t +length, uint16_t value, uint32_t *msgLen)); +EXTERN void fillMsgHeader ARGS((fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen)); +EXTERN void sendToLowerMac ARGS((uint16_t msgType, uint32_t msgLen,void *msg)); +EXTERN void handlePhyMessages ARGS((void *msg)); /******************************************************************* * * @brief Builds and sends param response to MAC CL * * @details * - * Function : lwrMacBldAndSndParamRsp + * Function : l1BldAndSndParamRsp * * Functionality: * - Builds and sends param response to MAC @@ -51,109 +58,98 @@ EXTERN S16 sendToLowerMac ARGS((U16 msgType, U32 msgLen,void *msg)); * RFAILED - failure * * ****************************************************************/ -S16 lwrMacBldAndSndParamRsp(void *msg) +S16 l1BldAndSndParamRsp(fapi_param_resp_t *fapiParamRsp) { - S16 index = 0; - U16 msgLen = 0; - fapi_param_resp_t *fapiParamRsp; - fapiParamRsp = (fapi_param_resp_t *)msg; -#if 0 - if(SGetSBuf(0, 0, (Data **)&fapiParamRsp, sizeof(fapi_param_resp_t)) != ROK) - { - printf("\nMemory allocation failed for PHY Config Response"); - RETVALUE(RFAILED); - } -#endif + uint8_t index = 0; + uint32_t msgLen = 0; + /* Cell Params */ - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_RELEASE_CAPABILITY_TAG, sizeof(U16), 1, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PHY_STATE_TAG, sizeof(U16), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SKIP_BLANK_DL_CONFIG_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SKIP_BLANK_UL_CONFIG_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG, sizeof(U8), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_RELEASE_CAPABILITY_TAG, sizeof(uint16_t), 1, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PHY_STATE_TAG, sizeof(uint16_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SKIP_BLANK_DL_CONFIG_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SKIP_BLANK_UL_CONFIG_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG, sizeof(uint8_t), 0, &msgLen); /* Carrier Params */ - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_CYCLIC_PREFIX_TAG, sizeof(U8), 1, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG, sizeof(U8), 1, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_BANDWIDTH_DL_TAG, sizeof(U16), 1, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_BANDWIDTH_UL_TAG, sizeof(U16), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_CYCLIC_PREFIX_TAG, sizeof(uint8_t), 1, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG, sizeof(uint8_t), 1, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_BANDWIDTH_DL_TAG, sizeof(uint16_t), 1, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_BANDWIDTH_UL_TAG, sizeof(uint16_t), 0, &msgLen); /* PDCCH Param*/ - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_CCE_MAPPING_TYPE_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRECODER_GRANULARITY_CORESET_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDCCH_MU_MIMO_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDCCH_PRECODER_CYCLING_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PDCCHS_PER_SLOT_TAG, sizeof(U8), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_CCE_MAPPING_TYPE_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRECODER_GRANULARITY_CORESET_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDCCH_MU_MIMO_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDCCH_PRECODER_CYCLING_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PDCCHS_PER_SLOT_TAG, sizeof(uint8_t), 0, &msgLen); /* PUCCH Param */ - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUCCH_FORMATS_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PUCCHS_PER_SLOT_TAG, sizeof(U8), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUCCH_FORMATS_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PUCCHS_PER_SLOT_TAG, sizeof(uint8_t), 0, &msgLen); /* PDSCH Param */ - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_MAPPING_TYPE_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_ALLOCATION_TYPES_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_CBG_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DMRS_MAX_LENGTH_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_MU_MIMO_USERS_DL_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PREMPTIONSUPPORT_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_NON_SLOT_SUPPORT_TAG, sizeof(U8), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_MAPPING_TYPE_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_ALLOCATION_TYPES_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_CBG_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DMRS_MAX_LENGTH_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_MU_MIMO_USERS_DL_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PREMPTIONSUPPORT_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_NON_SLOT_SUPPORT_TAG, sizeof(uint8_t), 0, &msgLen); /* PUSCH Param */ - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_UCI_ONLY_PUSCH_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_FREQUENCY_HOPPING_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_DMRS_MAX_LEN_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_CBG_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_MAPPING_TYPE_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_ALLOCATION_TYPES_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_MAX_PTRS_PORTS_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_MU_MIMO_USERS_UL_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_DFTS_OFDM_SUPPORT_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_AGGREGATION_FACTOR_TAG, sizeof(U8), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_UCI_ONLY_PUSCH_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_FREQUENCY_HOPPING_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_DMRS_MAX_LEN_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_CBG_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_MAPPING_TYPE_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_ALLOCATION_TYPES_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_MAX_PTRS_PORTS_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_MU_MIMO_USERS_UL_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_DFTS_OFDM_SUPPORT_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_AGGREGATION_FACTOR_TAG, sizeof(uint8_t), 0, &msgLen); /* PRACH Params */ - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRACH_LONG_FORMATS_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRACH_SHORT_FORMATS_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRACH_RESTRICTED_SETS_TAG, sizeof(U8), 0, &msgLen); - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG, sizeof(U8), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRACH_LONG_FORMATS_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRACH_SHORT_FORMATS_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRACH_RESTRICTED_SETS_TAG, sizeof(uint8_t), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG, sizeof(uint8_t), 0, &msgLen); /* MEASUREMENT TAG */ - fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_RSSI_MEASUREMENT_SUPPORT_TAG, sizeof(U8), 0, &msgLen); + fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_RSSI_MEASUREMENT_SUPPORT_TAG, sizeof(uint8_t), 0, &msgLen); fapiParamRsp->number_of_tlvs = index; msgLen = msgLen + sizeof(fapi_param_resp_t); fillMsgHeader(&fapiParamRsp->header, FAPI_PARAM_RESPONSE, msgLen); fapiParamRsp->error_code = MSG_OK; - if(sendToLowerMac(fapiParamRsp->header.message_type_id, sizeof(fapi_param_resp_t), (void *)fapiParamRsp) != ROK) - { - RETVALUE(RFAILED); - } - printf("\n Filled the Param Response successfully"); - RETVALUE(ROK); + printf("\nPHY_STUB: Sending Param Request to Lower Mac"); + sendToLowerMac(fapiParamRsp->header.message_type_id, sizeof(fapi_param_resp_t), (void *)fapiParamRsp); + return ROK; } /******************************************************************* * - * @brief Builds and sends config response to MAC CL + * @brief Builds and sends config response to lower mac * * @details * - * Function : l1BldAndSndCfgRsp + * Function : l1BldAndSndConfigRsp * * Functionality: * - Builds and sends config response to MAC @@ -164,40 +160,53 @@ S16 lwrMacBldAndSndParamRsp(void *msg) * * ****************************************************************/ -S16 l1BldAndSndCfgRsp(void *msg) +S16 l1BldAndSndConfigRsp(fapi_config_resp_t *fapiConfigRsp) { - L1L2ConfigReq *FAPIConfigReq; - L1L2ConfigRsp *FAPIConfigRsp; - U8 cci; + uint8_t index = 0; + uint32_t msgLen = 0; - FAPIConfigReq = (L1L2ConfigReq *)msg; - cci = FAPIConfigReq->carrierId; - SPutSBuf(0, 0, (Data *)msg, FAPIConfigReq->hdr.msgLen); - - if(SGetSBuf(0, 0, (Data **)&FAPIConfigRsp, sizeof(L1L2ConfigRsp)) != ROK) + if(fapiConfigRsp != NULL) { - printf("\nMemory allocation failed for PHY Config Response"); - RETVALUE(RFAILED); + fapiConfigRsp->number_of_invalid_tlvs = NULLP; + fapiConfigRsp->number_of_inv_tlvs_idle_only = NULLP; + fapiConfigRsp->number_of_missing_tlvs = NULLP; + fapiConfigRsp->error_code = MSG_OK; + msgLen += sizeof(fapi_config_resp_t); + fillMsgHeader(&fapiConfigRsp->header, FAPI_CONFIG_RESPONSE, msgLen); + printf("\nPHY_STUB: Sending Config Response to Lower Mac"); + sendToLowerMac(fapiConfigRsp->header.message_type_id, sizeof(fapi_config_resp_t), (void *)fapiConfigRsp); + return ROK; } +} - FAPIConfigRsp->hdr.nMsg = 1; - FAPIConfigRsp->hdr.msgType = MSG_TYPE_CONFIG_RSP; - FAPIConfigRsp->hdr.msgLen = sizeof(L1L2ConfigRsp); - - FAPIConfigRsp->carrierId = cci; - FAPIConfigRsp->status = MSG_OK; - FAPIConfigRsp->numUnsuppTlv = 0; - FAPIConfigRsp->unsuppTlvLst = NULLP; - FAPIConfigRsp->numInvTlvForPhySta = 0; - FAPIConfigRsp->phyIdleCfgTlvLst = NULLP; - FAPIConfigRsp->phyRunCfgTlvLst = NULLP; - FAPIConfigRsp->numMissingTlv = 0; - FAPIConfigRsp->missingTlvLst = NULLP; +/******************************************************************* + * + * @brief Handles param request received from MAC + * + * @details + * + * Function : l1HdlParamReq + * + * Functionality: + * -Handles param request received from MAC + * + * @params[in] Message length + * Param request message pointer + * + * @return void + * + * ****************************************************************/ - phyToMac(MSG_TYPE_CONFIG_RSP, sizeof(L1L2ConfigRsp), FAPIConfigRsp); +PUBLIC void l1HdlParamReq(uint32_t msgLen, void *msg) +{ + printf("\nPHY_STUB: Received Param Request in PHY"); - RETVALUE(ROK); -} + /* Handling PARAM RESPONSE */ + if(l1BldAndSndParamRsp(msg)!= ROK) + { + printf("\nPHY_STUB: Failed Sending Param Response"); + } +} /******************************************************************* * @@ -205,97 +214,156 @@ S16 l1BldAndSndCfgRsp(void *msg) * * @details * - * Function : l1HndlConfigReq + * Function : l1HdlConfigReq * * Functionality: * -Handles config request received from MAC * * @params[in] Message length - * Config request message pointer + * config request message pointer * * @return void * * ****************************************************************/ -void l1HndlConfigReq(U16 msgLen, void *msg) +PUBLIC void l1HdlConfigReq(uint32_t msgLen, void *msg) { - printf("\nReceived configuration request"); + printf("\nPHY_STUB: Received Config Request in PHY"); - /* TO DO : validate all received TLVs and send back any unsupported/missing TLV */ - - if(l1BldAndSndCfgRsp(msg) != ROK) - { - printf("\nFailed Sending config response"); - } + /* Handling CONFIG RESPONSE */ + if(l1BldAndSndConfigRsp(msg)!= ROK) + { + printf("\nPHY_STUB: Failed Sending config Response"); + } } /******************************************************************* * - * @brief Handles param request received from MAC + * @brief Builds and Send the Slot Indication message to MAC * * @details * - * Function : lwrMacHdlParamReq + * Function : buildAndSendSlotIndication * * Functionality: - * -Handles param request received from MAC + * -Send the Slot indication Message to MAC * * @params[in] Message length - * Param request message pointer + * config request message pointer * * @return void * * ****************************************************************/ - -PUBLIC void lwrMacHdlParamReq(U16 msgLen, void *msg) +PUBLIC void buildAndSendSlotIndication() { - printf("\n Received Param Request in PHY"); - - /* Handling PARAM RESPONSE */ - if(lwrMacBldAndSndParamRsp(msg)!= ROK) + fapi_slot_ind_t *slotIndMsg; + if(SGetSBuf(0, 0, (Data **)&slotIndMsg, sizeof(slotIndMsg)) != ROK) { - printf("\n Failed Sending Param Response"); + printf("\nPHY_STUB: Memory allocation failed for slot Indication Message"); + return RFAILED; } -} + else + { + slotValue++; + if(sfnValue >= MAX_SFN_VALUE && slotValue >= MAX_SLOT_VALUE) + { + sfnValue = 0; + slotValue = 0; + } + else if(slotValue >= MAX_SLOT_VALUE) + { + sfnValue++; + slotValue = 0; + } + slotIndMsg->sfn = sfnValue; + slotIndMsg->slot = slotValue; + fillMsgHeader(&slotIndMsg->header, FAPI_SLOT_INDICATION, sizeof(fapi_slot_ind_t)); + printf("\nPHY_STUB: Sending Slot Indication Msg to Lower Mac"); + handlePhyMessages((void*)slotIndMsg); + SPutSBuf(0, 0, (Data *)slotIndMsg, sizeof(slotIndMsg)); + } +} /******************************************************************* * - * @brief Receives message from MAC + * @brief Handles start request received from MAC * * @details * - * Function : macToPhy + * Function : l1HdlStartReq * * Functionality: - * - Receives message from MAC and calls handler + * -Handles start request received from MAC * - * @params[in] Message type - * Message length - * Message pointer + * @params[in] Message length + * config request message pointer * * @return void * * ****************************************************************/ -void macToPhy(U16 msgType, U32 msgLen, void *msg) +PUBLIC void l1HdlStartReq(uint32_t msgLen, void *msg) { - switch(msgType) + if(clGlobalCp.phyState == PHY_STATE_CONFIGURED) { - case MSG_TYPE_CONFIG_REQ: - l1HndlConfigReq(msgLen, msg); - break; - default: - printf("\nInvalid message type[%x] received at PHY", msgType); + duStartSlotIndicaion(); + SPutSBuf(0, 0, (Data *)msg, sizeof(fapi_start_req_t)); + + return ROK; + } + else + { + printf("\n PHY_STUB: Received Start Req in PHY State", clGlobalCp.phyState); + return RFAILED; } } +/******************************************************************* +* +* @brief Handles Dl Tti request received from MAC +* +* @details +* +* Function : l1HdlDlTtiReq +* +* Functionality: +* -Handles Dl Tti request received from MAC +* +* @params[in] Message length +* Dl Tti request message pointer +* +* @return void +* +* ****************************************************************/ + +PUBLIC void l1HdlDlTtiReq(uint16_t msgLen, void *msg) +{ + fapi_dl_tti_req_t *dlTtiReq; + dlTtiReq = (fapi_dl_tti_req_t *)msg; + printf("\nPHY_STUB: Received DL TTI Request in PHY"); + printf("\nPHY_STUB: SFN %d", dlTtiReq->sfn); + printf("\nPHY_STUB: SLOT %d", dlTtiReq->slot); + printf("\nPHY_STUB: nPdus %d", dlTtiReq->nPdus); + printf("\nPHY_STUB: nGroup %d", dlTtiReq->nGroup); + /* Printing SSB CONFIGURED VALUES */ + printf("\nPHY_STUB: physCellId %d", dlTtiReq->pdus->u.ssb_pdu.physCellId); + printf("\nPHY_STUB: betaPss %d", dlTtiReq->pdus->u.ssb_pdu.betaPss); + printf("\nPHY_STUB: ssbBlockIndex %d", dlTtiReq->pdus->u.ssb_pdu.ssbBlockIndex); + printf("\nPHY_STUB: ssbSubCarrierOffset %d", dlTtiReq->pdus->u.ssb_pdu.ssbSubCarrierOffset); + printf("\nPHY_STUB: ssbOffsetPointA %d", dlTtiReq->pdus->u.ssb_pdu.ssbOffsetPointA); + printf("\nPHY_STUB: bchPayloadFlag %d", dlTtiReq->pdus->u.ssb_pdu.bchPayloadFlag); + printf("\nPHY_STUB: bchPayload %x", dlTtiReq->pdus->u.ssb_pdu.bchPayload); + + SPutSBuf(0, 0, (Data *)dlTtiReq, sizeof(fapi_dl_tti_req_t)); + return ROK; +} /******************************************************************* * * @brief Receives message from MAC * * @details * - * Function : processRequest + * Function : processFapiRequest * * Functionality: * - Receives message from MAC and calls handler @@ -308,15 +376,24 @@ void macToPhy(U16 msgType, U32 msgLen, void *msg) * * ****************************************************************/ -void processRequest(U16 msgType, U32 msgLen, void *msg) +void processFapiRequest(uint8_t msgType, uint32_t msgLen, void *msg) { switch(msgType) { case FAPI_PARAM_REQUEST: - lwrMacHdlParamReq(msgLen, msg); + l1HdlParamReq(msgLen, msg); + break; + case FAPI_CONFIG_REQUEST: + l1HdlConfigReq(msgLen, msg); + break; + case FAPI_START_REQUEST: + l1HdlStartReq(msgLen, msg); + break; + case FAPI_DL_TTI_REQUEST: + l1HdlDlTtiReq(msgLen, msg); break; default: - printf("\n Invalid message type[%x] received at PHY", msgType); + printf("\nPHY_STUB: Invalid message type[%x] received at PHY", msgType); break; } } diff --git a/src/phy_stub/l1_bdy2.c b/src/phy_stub/l1_bdy2.c index 61b1f30d0..1877f3c33 100644 --- a/src/phy_stub/l1_bdy2.c +++ b/src/phy_stub/l1_bdy2.c @@ -1,18 +1,19 @@ /* This file handles TTI genertion */ - #include +#include #include #include "lphy_stub.h" void *GenerateTicks(void *arg) { - while(1) + uint8_t counter = 2; + while(counter) { sleep(1); - printf("\nPHY STUB : Slot indication"); - + printf("\nPHY_STUB: SLOT indication"); /* Send Slot indication indication to lower mac */ - //buildAndSendSlotIndication(); + buildAndSendSlotIndication(); + counter--; } } @@ -24,7 +25,7 @@ void duStartSlotIndicaion() ret = pthread_create(&thread, NULL, GenerateTicks, NULL); if(ret) { - printf("\nUnable to create thread"); + printf("\nPHY_STUB: Unable to create thread"); } }