X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrmac%2Flwr_mac_fsm.c;h=bbc67cc13f156198d663e5a84d3c3b725a6f7ae8;hb=95d4c229dc30cec27c98ee66b5b689779a48dcc9;hp=091b4928ba5af4302841c6791b058a342266473d;hpb=fe3e15254e67fd96dbfabec4bf7245c3b64ee415;p=o-du%2Fl2.git diff --git a/src/5gnrmac/lwr_mac_fsm.c b/src/5gnrmac/lwr_mac_fsm.c index 091b4928b..bbc67cc13 100644 --- a/src/5gnrmac/lwr_mac_fsm.c +++ b/src/5gnrmac/lwr_mac_fsm.c @@ -16,76 +16,63 @@ ################################################################################ *******************************************************************************/ -#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" - -/* 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 "common_def.h" +#include "lrg.h" +#include "lrg.x" #include "du_app_mac_inf.h" +#include "mac_sch_interface.h" +#include "lwr_mac_upr_inf.h" #include "mac.h" -#include "rg.x" /* typedefs for MAC */ +#include "lwr_mac.h" +#ifdef INTEL_FAPI +#include "nr5g_fapi_internal.h" +#include "fapi_vendor_extension.h" +#endif +#ifdef INTEL_WLS_MEM +#include "wls_lib.h" +#endif +#include "lwr_mac_fsm.h" #include "lwr_mac_phy.h" -#include "math.h" +#include "mac_utils.h" #define MIB_SFN_BITMASK 0xFC #define PDCCH_PDU_TYPE 0 #define PDSCH_PDU_TYPE 1 #define SSB_PDU_TYPE 3 #define PRACH_PDU_TYPE 0 +#define PUSCH_PDU_TYPE 1 +#define PUCCH_PDU_TYPE 2 #define PDU_PRESENT 1 -#define SETLENGTH(x, size) x += size - -extern void fapiMacConfigRsp(); -extern uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX]; +#define SET_MSG_LEN(x, size) x += size /* Global variables */ -SlotIndInfo slotIndInfo; -uint8_t slotIndIdx; +LwrMacCb lwrMacCb; -void lwrMacInit() +uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX]; +void fapiMacConfigRsp(uint16_t cellId); +uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, MacDlSlot *dlSlot, p_fapi_api_queue_elem_t prevElem, fapi_vendor_tx_data_req_t *vendorTxDataReq); +uint16_t fillUlTtiReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t prevElem, fapi_vendor_ul_tti_req_t* vendorUlTti); +uint16_t fillUlDciReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t prevElem, fapi_vendor_ul_dci_req_t *vendorUlDciReq); +uint8_t lwr_mac_procStopReqEvt(SlotTimingInfo slotInfo, p_fapi_api_queue_elem_t prevElem, fapi_stop_req_vendor_msg_t *vendorMsg); + +void lwrMacLayerInit(Region region, Pool pool) { -#ifdef INTEL_WLS - uint8_t idx; +#ifdef INTEL_WLS_MEM + uint8_t idx; +#endif + + memset(&lwrMacCb, 0, sizeof(LwrMacCb)); + lwrMacCb.region = region; + lwrMacCb.pool = pool; + lwrMacCb.clCfgDone = TRUE; + lwrMacCb.numCell = 0; + lwrMacCb.phyState = PHY_STATE_IDLE; +#ifdef INTEL_WLS_MEM /* Initializing WLS free mem list */ - slotIndIdx = 1; + lwrMacCb.phySlotIndCntr = 1; for(idx = 0; idx < WLS_MEM_FREE_PRD; idx++) { cmLListInit(&wlsBlockToFreeList[idx]); @@ -93,98 +80,102 @@ void lwrMacInit() #endif } - /******************************************************************* - * - * @brief Handles Invalid Request Event - * - * @details - * - * Function : lwr_mac_handleInvalidEvt - * - * Functionality: - * - Displays the PHY state when the invalid event occurs - * - * @params[in] - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ -S16 lwr_mac_handleInvalidEvt(void *msg) -{ - printf("\nLOWER MAC: Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState); - RETVALUE(ROK); +/******************************************************************* + * + * @brief Handles Invalid Request Event + * + * @details + * + * Function : lwr_mac_procInvalidEvt + * + * Functionality: + * - Displays the PHY state when the invalid event occurs + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t lwr_mac_procInvalidEvt(void *msg) +{ +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : INVALID_EVENT\n"); +#endif + DU_LOG("\nERROR --> LWR_MAC: Error Indication Event[%d] received in state [%d]", lwrMacCb.event, lwrMacCb.phyState); + return ROK; } -#ifdef FAPI +#ifdef INTEL_FAPI /******************************************************************* - * - * @brief Fills FAPI message header - * - * @details - * - * Function : fillMsgHeader - * - * Functionality: - * -Fills FAPI message header - * - * @params[in] Pointer to header - * Number of messages - * Messae Type - * Length of message - * @return void - * - * ****************************************************************/ -PUBLIC void fillMsgHeader(fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen) -{ - hdr->message_type_id = msgType; + * + * @brief Fills FAPI message header + * + * @details + * + * Function : fillMsgHeader + * + * Functionality: + * -Fills FAPI message header + * + * @params[in] Pointer to header + * Number of messages + * Messae Type + * Length of message + * @return void + * + * ****************************************************************/ +void fillMsgHeader(fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen) +{ + memset(hdr, 0, sizeof(fapi_msg_t)); + hdr->msg_id = msgType; hdr->length = msgLen; } /******************************************************************* - * - * @brief Fills FAPI Config Request message header - * - * @details - * - * Function : fillTlvs - * - * Functionality: - * -Fills FAPI Config Request message header - * - * @params[in] Pointer to TLV - * Tag - * Length - * Value - * MsgLen - * @return void - * - * ****************************************************************/ -PUBLIC void fillTlvs(fapi_uint16_tlv_t *tlv, uint16_t tag, uint16_t length, -uint16_t value, uint32_t *msgLen) + * + * @brief Fills FAPI Config Request message header + * + * @details + * + * Function : fillTlvs + * + * Functionality: + * -Fills FAPI Config Request message header + * + * @params[in] Pointer to TLV + * Tag + * Length + * Value + * MsgLen + * @return void + * + * ****************************************************************/ +void fillTlvs(fapi_uint32_tlv_t *tlv, uint16_t tag, uint16_t length, + uint32_t value, uint32_t *msgLen) { tlv->tl.tag = tag; tlv->tl.length = length; tlv->value = value; *msgLen = *msgLen + sizeof(tag) + sizeof(length) + length; } - /******************************************************************* - * - * @brief fills the cyclic prefix by comparing the bitmask - * - * @details - * - * Function : fillCyclicPrefix - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's cyclic prefix. - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ********************************************************************/ -PUBLIC void fillCyclicPrefix(uint8_t value, ClCellParam **cellPtr) +/******************************************************************* + * + * @brief fills the cyclic prefix by comparing the bitmask + * + * @details + * + * Function : fillCyclicPrefix + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's cyclic prefix. + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ********************************************************************/ +void fillCyclicPrefix(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_NORMAL_CYCLIC_PREFIX_MASK) == FAPI_NORMAL_CYCLIC_PREFIX_MASK) { @@ -200,25 +191,25 @@ PUBLIC void fillCyclicPrefix(uint8_t value, ClCellParam **cellPtr) } } - /******************************************************************* - * - * @brief fills the subcarrier spacing of Downlink by comparing the bitmask - * - * @details - * - * Function : fillSubcarrierSpaceDl - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's subcarrier spacing in DL - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - * ****************************************************************/ - -PUBLIC void fillSubcarrierSpaceDl(uint8_t value, ClCellParam **cellPtr) +/******************************************************************* + * + * @brief fills the subcarrier spacing of Downlink by comparing the bitmask + * + * @details + * + * Function : fillSubcarrierSpaceDl + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's subcarrier spacing in DL + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + * ****************************************************************/ + +void fillSubcarrierSpaceDl(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK) { @@ -242,25 +233,25 @@ PUBLIC void fillSubcarrierSpaceDl(uint8_t value, ClCellParam **cellPtr) } } - /******************************************************************* - * - * @brief fills the downlink bandwidth by comparing the bitmask - * - * @details - * - * Function : fillBandwidthDl - * - * Functionality: - * -checks the value with the bitmask and - * -fills the cellPtr's DL Bandwidth - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - * ****************************************************************/ - -PUBLIC void fillBandwidthDl(uint16_t value, ClCellParam **cellPtr) +/******************************************************************* + * + * @brief fills the downlink bandwidth by comparing the bitmask + * + * @details + * + * Function : fillBandwidthDl + * + * Functionality: + * -checks the value with the bitmask and + * -fills the cellPtr's DL Bandwidth + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + * ****************************************************************/ + +void fillBandwidthDl(uint16_t value, ClCellParam **cellPtr) { if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK) { @@ -320,25 +311,25 @@ PUBLIC void fillBandwidthDl(uint16_t value, ClCellParam **cellPtr) } } - /******************************************************************* - * - * @brief fills the subcarrier spacing of Uplink by comparing the bitmask - * - * @details - * - * Function : fillSubcarrierSpaceUl - * - * Functionality: - * -checks the value with the bitmask and - * -fills cellPtr's subcarrier spacing in UL - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - * ****************************************************************/ - -PUBLIC void fillSubcarrierSpaceUl(uint8_t value, ClCellParam **cellPtr) +/******************************************************************* + * + * @brief fills the subcarrier spacing of Uplink by comparing the bitmask + * + * @details + * + * Function : fillSubcarrierSpaceUl + * + * Functionality: + * -checks the value with the bitmask and + * -fills cellPtr's subcarrier spacing in UL + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + * ****************************************************************/ + +void fillSubcarrierSpaceUl(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK) { @@ -362,28 +353,28 @@ PUBLIC void fillSubcarrierSpaceUl(uint8_t value, ClCellParam **cellPtr) } } - /******************************************************************* - * - * @brief fills the uplink bandwidth by comparing the bitmask - * - * @details - * - * Function : fillBandwidthUl - * - * 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(uint16_t value, ClCellParam **cellPtr) +/******************************************************************* + * + * @brief fills the uplink bandwidth by comparing the bitmask + * + * @details + * + * Function : fillBandwidthUl + * + * 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 + * + * + * ****************************************************************/ + +void fillBandwidthUl(uint16_t value, ClCellParam **cellPtr) { if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK) { @@ -442,26 +433,26 @@ PUBLIC void fillBandwidthUl(uint16_t value, ClCellParam **cellPtr) (*cellPtr)->supportedBandwidthUl = INVALID_VALUE; } } - /******************************************************************* - * - * @brief fills the CCE maping by comparing the bitmask - * - * @details - * - * Function : fillCCEmaping - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's CCE Mapping Type - * - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - * ****************************************************************/ - -PUBLIC void fillCCEmaping(uint8_t value, ClCellParam **cellPtr) +/******************************************************************* + * + * @brief fills the CCE maping by comparing the bitmask + * + * @details + * + * Function : fillCCEmaping + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's CCE Mapping Type + * + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + * ****************************************************************/ + +void fillCCEmaping(uint8_t value, ClCellParam **cellPtr) { if ((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_INTERLEAVED_MASK) { @@ -477,26 +468,26 @@ PUBLIC void fillCCEmaping(uint8_t value, ClCellParam **cellPtr) } } - /******************************************************************* - * - * @brief fills the PUCCH format by comparing the bitmask - * - * @details - * - * Function : fillPucchFormat - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's pucch format - * - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - * ****************************************************************/ - -PUBLIC void fillPucchFormat(uint8_t value, ClCellParam **cellPtr) +/******************************************************************* + * + * @brief fills the PUCCH format by comparing the bitmask + * + * @details + * + * Function : fillPucchFormat + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's pucch format + * + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + * ****************************************************************/ + +void fillPucchFormat(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK) { @@ -524,25 +515,25 @@ PUBLIC void fillPucchFormat(uint8_t value, ClCellParam **cellPtr) } } - /******************************************************************* - * - * @brief fills the PDSCH Mapping Type by comparing the bitmask - * - * @details - * - * Function : fillPdschMappingType - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's PDSCH MappingType - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - * ****************************************************************/ - -PUBLIC void fillPdschMappingType(uint8_t value, ClCellParam **cellPtr) +/******************************************************************* + * + * @brief fills the PDSCH Mapping Type by comparing the bitmask + * + * @details + * + * Function : fillPdschMappingType + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's PDSCH MappingType + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + * ****************************************************************/ + +void fillPdschMappingType(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PDSCH_MAPPING_TYPE_A_MASK) == FAPI_PDSCH_MAPPING_TYPE_A_MASK) { @@ -559,24 +550,24 @@ PUBLIC void fillPdschMappingType(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the PDSCH Allocation Type by comparing the bitmask - * - * @details - * - * Function : fillPdschAllocationType - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's PDSCH AllocationType - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - * ****************************************************************/ - -PUBLIC void fillPdschAllocationType(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the PDSCH Allocation Type by comparing the bitmask + * + * @details + * + * Function : fillPdschAllocationType + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's PDSCH AllocationType + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + * ****************************************************************/ + +void fillPdschAllocationType(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PDSCH_ALLOC_TYPE_0_MASK) == FAPI_PDSCH_ALLOC_TYPE_0_MASK) { @@ -593,23 +584,23 @@ PUBLIC void fillPdschAllocationType(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the PDSCH PRB Mapping Type by comparing the bitmask - * - * @details - * - * Function : fillPrbMappingType - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's PRB Mapping Type - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ -PUBLIC void fillPrbMappingType(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the PDSCH PRB Mapping Type by comparing the bitmask + * + * @details + * + * Function : fillPrbMappingType + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's PRB Mapping Type + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ +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) { @@ -626,57 +617,57 @@ PUBLIC void fillPrbMappingType(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the PDSCH DmrsConfig Type by comparing the bitmask - * - * @details - * - * Function : fillPdschDmrsConfigType - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's DmrsConfig Type - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ - -PUBLIC void fillPdschDmrsConfigType(uint8_t value, ClCellParam **cellPtr) -{ - if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) - { - (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_1; - } - else if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK) - { - (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_2; - } - else - { - (*cellPtr)->pdschDmrsConfigTypes = INVALID_VALUE; - } + * + * @brief fills the PDSCH DmrsConfig Type by comparing the bitmask + * + * @details + * + * Function : fillPdschDmrsConfigType + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's DmrsConfig Type + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ + +void fillPdschDmrsConfigType(uint8_t value, ClCellParam **cellPtr) +{ + if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) + { + (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_1; + } + else if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_2_MASK) + { + (*cellPtr)->pdschDmrsConfigTypes = DMRS_CONFIG_TYPE_2; + } + else + { + (*cellPtr)->pdschDmrsConfigTypes = INVALID_VALUE; + } } /******************************************************************* - * - * @brief fills the PDSCH DmrsLength by comparing the bitmask - * - * @details - * - * Function : fillPdschDmrsLength - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's PdschDmrsLength - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ -PUBLIC void fillPdschDmrsLength(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the PDSCH DmrsLength by comparing the bitmask + * + * @details + * + * Function : fillPdschDmrsLength + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's PdschDmrsLength + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ +void fillPdschDmrsLength(uint8_t value, ClCellParam **cellPtr) { if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_1) { @@ -693,24 +684,24 @@ PUBLIC void fillPdschDmrsLength(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the PDSCH Dmrs Additional Pos by comparing the bitmask - * - * @details - * - * Function : fillPdschDmrsAddPos - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's Pdsch DmrsAddPos - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ - -PUBLIC void fillPdschDmrsAddPos(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the PDSCH Dmrs Additional Pos by comparing the bitmask + * + * @details + * + * Function : fillPdschDmrsAddPos + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's Pdsch DmrsAddPos + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ + +void fillPdschDmrsAddPos(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK) { @@ -735,23 +726,23 @@ PUBLIC void fillPdschDmrsAddPos(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the Modulation Order in DL by comparing the bitmask - * - * @details - * - * Function : fillModulationOrderDl - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's ModulationOrder in DL. - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ -PUBLIC void fillModulationOrderDl(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the Modulation Order in DL by comparing the bitmask + * + * @details + * + * Function : fillModulationOrderDl + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's ModulationOrder in DL. + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ +void fillModulationOrderDl(uint8_t value, ClCellParam **cellPtr) { if(value == 0 ) { @@ -776,24 +767,24 @@ PUBLIC void fillModulationOrderDl(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the PUSCH DmrsConfig Type by comparing the bitmask - * - * @details - * - * Function : fillPuschDmrsConfigType - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's PUSCH DmrsConfigType - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ - -PUBLIC void fillPuschDmrsConfig(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the PUSCH DmrsConfig Type by comparing the bitmask + * + * @details + * + * Function : fillPuschDmrsConfigType + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's PUSCH DmrsConfigType + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ + +void fillPuschDmrsConfig(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK) { @@ -810,24 +801,24 @@ PUBLIC void fillPuschDmrsConfig(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the PUSCH DmrsLength by comparing the bitmask - * - * @details - * - * Function : fillPuschDmrsLength - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's PUSCH DmrsLength - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ - -PUBLIC void fillPuschDmrsLength(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the PUSCH DmrsLength by comparing the bitmask + * + * @details + * + * Function : fillPuschDmrsLength + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's PUSCH DmrsLength + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ + +void fillPuschDmrsLength(uint8_t value, ClCellParam **cellPtr) { if(value == FAPI_PUSCH_DMRS_MAX_LENGTH_1) { @@ -844,24 +835,24 @@ PUBLIC void fillPuschDmrsLength(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the PUSCH Dmrs Additional position by comparing the bitmask - * - * @details - * - * Function : fillPuschDmrsAddPos - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's PUSCH DmrsAddPos - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ - -PUBLIC void fillPuschDmrsAddPos(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the PUSCH Dmrs Additional position by comparing the bitmask + * + * @details + * + * Function : fillPuschDmrsAddPos + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's PUSCH DmrsAddPos + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ + +void fillPuschDmrsAddPos(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK) { @@ -886,31 +877,31 @@ PUBLIC void fillPuschDmrsAddPos(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the PUSCH Mapping Type by comparing the bitmask - * - * @details - * - * Function : fillPuschMappingType - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's PUSCH MappingType - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ - -PUBLIC void fillPuschMappingType(uint8_t value, ClCellParam **cellPtr) -{ - if((value & FAPI_PUSCH_MAPPING_TYPE_A_MASK) == FAPI_PUSCH_MAPPING_TYPE_A_MASK) - { - (*cellPtr)->puschMappingType = MAPPING_TYPE_A; - } - else if((value & FAPI_PUSCH_MAPPING_TYPE_B_MASK) == FAPI_PUSCH_MAPPING_TYPE_B_MASK) - { + * + * @brief fills the PUSCH Mapping Type by comparing the bitmask + * + * @details + * + * Function : fillPuschMappingType + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's PUSCH MappingType + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ + +void fillPuschMappingType(uint8_t value, ClCellParam **cellPtr) +{ + if((value & FAPI_PUSCH_MAPPING_TYPE_A_MASK) == FAPI_PUSCH_MAPPING_TYPE_A_MASK) + { + (*cellPtr)->puschMappingType = MAPPING_TYPE_A; + } + else if((value & FAPI_PUSCH_MAPPING_TYPE_B_MASK) == FAPI_PUSCH_MAPPING_TYPE_B_MASK) + { (*cellPtr)->puschMappingType = MAPPING_TYPE_B; } else @@ -920,24 +911,24 @@ PUBLIC void fillPuschMappingType(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the PUSCH Allocation Type by comparing the bitmask - * - * @details - * - * Function : fillPuschAllocationType - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's PUSCH AllocationType - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ - -PUBLIC void fillPuschAllocationType(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the PUSCH Allocation Type by comparing the bitmask + * + * @details + * + * Function : fillPuschAllocationType + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's PUSCH AllocationType + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ + +void fillPuschAllocationType(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK) { @@ -954,24 +945,24 @@ PUBLIC void fillPuschAllocationType(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the PUSCH PRB Mapping Type by comparing the bitmask - * - * @details - * - * Function : fillPuschPrbMappingType - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's PUSCH PRB MApping Type - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ - -PUBLIC void fillPuschPrbMappingType(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the PUSCH PRB Mapping Type by comparing the bitmask + * + * @details + * + * Function : fillPuschPrbMappingType + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's PUSCH PRB MApping Type + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ + +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) { @@ -988,24 +979,24 @@ PUBLIC void fillPuschPrbMappingType(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the Modulation Order in Ul by comparing the bitmask - * - * @details - * - * Function : fillModulationOrderUl - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's Modualtsion Order in UL. - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ - -PUBLIC void fillModulationOrderUl(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the Modulation Order in Ul by comparing the bitmask + * + * @details + * + * Function : fillModulationOrderUl + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's Modualtsion Order in UL. + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ + +void fillModulationOrderUl(uint8_t value, ClCellParam **cellPtr) { if(value == 0) { @@ -1030,24 +1021,24 @@ PUBLIC void fillModulationOrderUl(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the PUSCH Aggregation Factor by comparing the bitmask - * - * @details - * - * Function : fillPuschAggregationFactor - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's PUSCH Aggregation Factor - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ - -PUBLIC void fillPuschAggregationFactor(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the PUSCH Aggregation Factor by comparing the bitmask + * + * @details + * + * Function : fillPuschAggregationFactor + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's PUSCH Aggregation Factor + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ + +void fillPuschAggregationFactor(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK) { @@ -1072,24 +1063,24 @@ PUBLIC void fillPuschAggregationFactor(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the PRACH Long Format by comparing the bitmask - * - * @details - * - * Function : fillPrachLongFormat - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's PRACH Long Format - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ - -PUBLIC void fillPrachLongFormat(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the PRACH Long Format by comparing the bitmask + * + * @details + * + * Function : fillPrachLongFormat + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's PRACH Long Format + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ + +void fillPrachLongFormat(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PRACH_LF_FORMAT_0_MASK) == FAPI_PRACH_LF_FORMAT_0_MASK) { @@ -1114,24 +1105,24 @@ PUBLIC void fillPrachLongFormat(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the PRACH Short Format by comparing the bitmask - * - * @details - * - * Function : fillPrachShortFormat - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's PRACH ShortFormat - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ - -PUBLIC void fillPrachShortFormat(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the PRACH Short Format by comparing the bitmask + * + * @details + * + * Function : fillPrachShortFormat + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's PRACH ShortFormat + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ + +void fillPrachShortFormat(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_PRACH_SF_FORMAT_A1_MASK) == FAPI_PRACH_SF_FORMAT_A1_MASK) { @@ -1176,24 +1167,24 @@ PUBLIC void fillPrachShortFormat(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the Fd Occasions Type by comparing the bitmask - * - * @details - * - * Function : fillFdOccasions - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's Fd Occasions - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ - -PUBLIC void fillFdOccasions(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the Fd Occasions Type by comparing the bitmask + * + * @details + * + * Function : fillFdOccasions + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's Fd Occasions + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ + +void fillFdOccasions(uint8_t value, ClCellParam **cellPtr) { if(value == 0) { @@ -1218,24 +1209,24 @@ PUBLIC void fillFdOccasions(uint8_t value, ClCellParam **cellPtr) } /******************************************************************* - * - * @brief fills the RSSI Measurement by comparing the bitmask - * - * @details - * - * Function : fillRssiMeas - * - * Functionality: - * -checks the value with the bitmask and - * fills the cellPtr's RSSI Measurement report - * - * @params[in] Pointer to ClCellParam - * Value to be compared - * @return void - * - ******************************************************************/ - -PUBLIC void fillRssiMeas(uint8_t value, ClCellParam **cellPtr) + * + * @brief fills the RSSI Measurement by comparing the bitmask + * + * @details + * + * Function : fillRssiMeas + * + * Functionality: + * -checks the value with the bitmask and + * fills the cellPtr's RSSI Measurement report + * + * @params[in] Pointer to ClCellParam + * Value to be compared + * @return void + * + ******************************************************************/ + +void fillRssiMeas(uint8_t value, ClCellParam **cellPtr) { if((value & FAPI_RSSI_REPORT_IN_DBM_MASK) == FAPI_RSSI_REPORT_IN_DBM_MASK) { @@ -1251,850 +1242,1196 @@ PUBLIC void fillRssiMeas(uint8_t value, ClCellParam **cellPtr) } } - /******************************************************************* - * - * @brief Returns the TLVs value - * - * @details - * - * Function : getParamValue - * - * Functionality: - * -return TLVs value - * - * @params[in] - * @return ROK - temp - * RFAILED - failure - * - * ****************************************************************/ +/******************************************************************* + * + * @brief Returns the TLVs value + * + * @details + * + * Function : getParamValue + * + * Functionality: + * -return TLVs value + * + * @params[in] + * @return ROK - temp + * RFAILED - failure + * + * ****************************************************************/ uint32_t getParamValue(fapi_uint16_tlv_t *tlv, uint16_t type) { - //uint16_t valueLen; - void *posPtr; - //valueLen = tlv->tl.length; - posPtr = &tlv->tl.tag; - posPtr += sizeof(tlv->tl.tag); - posPtr += sizeof(tlv->tl.length); - /*TO DO: malloc to SSI memory */ - if(type == FAPI_UINT_8) - { - //temp = (uint8_t *)malloc(valueLen * sizeof(U8)); - //memcpy(temp, posPtr, valueLen); - return(*(uint8_t *)posPtr); - } - else if(type == FAPI_UINT_16) - { - return(*(uint16_t *)posPtr); - } - else if(type == FAPI_UINT_32) - { - return(*(uint32_t *)posPtr); - } - else - { - DU_LOG("\nLOWER MAC: Value Extraction failed" ); + void *posPtr; + posPtr = &tlv->tl.tag; + posPtr += sizeof(tlv->tl.tag); + posPtr += sizeof(tlv->tl.length); + /*TO DO: malloc to SSI memory */ + if(type == FAPI_UINT_8) + { + return(*(uint8_t *)posPtr); + } + else if(type == FAPI_UINT_16) + { + return(*(uint16_t *)posPtr); + } + else if(type == FAPI_UINT_32) + { + return(*(uint32_t *)posPtr); + } + else + { + DU_LOG("\nERROR --> LWR_MAC: Value Extraction failed" ); return RFAILED; - } + } } #endif /* FAPI */ - /******************************************************************* - * - * @brief Sends FAPI Param req to PHY - * - * @details - * - * Function : lwr_mac_handleParamReqEvt - * - * Functionality: - * -Sends FAPI Param req to PHY - * - * @params[in] - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ - -S16 lwr_mac_handleParamReqEvt(void *msg) -{ -#ifdef FAPI + +/******************************************************************* + * + * @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 + ******************************************************************/ +void setMibPdu(uint8_t *mibPdu, uint32_t *val, uint16_t sfn) +{ + *mibPdu |= (((uint8_t)(sfn << 2)) & MIB_SFN_BITMASK); + *val = (mibPdu[0] << 24 | mibPdu[1] << 16 | mibPdu[2] << 8); + DU_LOG("\nDEBUG --> LWR_MAC: MIB PDU %x", *val); +} + +/******************************************************************* + * + * @brief Sends FAPI Param req to PHY + * + * @details + * + * Function : lwr_mac_procParamReqEvt + * + * Functionality: + * -Sends FAPI Param req to PHY + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t lwr_mac_procParamReqEvt(void *msg) +{ +#ifdef INTEL_FAPI +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : PARAM_REQ\n"); +#endif + /* startGuardTimer(); */ - uint32_t msgLen; //Length of message Body - msgLen = 0; - fapi_param_req_t *paramReq; - LWR_MAC_ALLOC(paramReq, sizeof(fapi_param_req_t)); - if(paramReq != NULLP) - { - fillMsgHeader(¶mReq->header, FAPI_PARAM_REQUEST, msgLen); - DU_LOG("\nLOWER MAC: Sending Param Request to Phy"); - LwrMacSendToPhy(paramReq->header.message_type_id, sizeof(fapi_param_req_t), (void *)paramReq); - return ROK; + fapi_param_req_t *paramReq = NULL; + fapi_msg_header_t *msgHeader; + p_fapi_api_queue_elem_t paramReqElem; + p_fapi_api_queue_elem_t headerElem; + + LWR_MAC_ALLOC(paramReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_param_req_t))); + if(paramReq != NULL) + { + FILL_FAPI_LIST_ELEM(paramReqElem, NULLP, FAPI_PARAM_REQUEST, 1, \ + sizeof(fapi_tx_data_req_t)); + paramReq = (fapi_param_req_t *)(paramReqElem +1); + memset(paramReq, 0, sizeof(fapi_param_req_t)); + fillMsgHeader(¶mReq->header, FAPI_PARAM_REQUEST, sizeof(fapi_param_req_t)); + + /* Fill message header */ + LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t))); + if(!headerElem) + { + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for param req header"); + LWR_MAC_FREE(paramReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_param_req_t))); + return RFAILED; + } + FILL_FAPI_LIST_ELEM(headerElem, paramReqElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \ + sizeof(fapi_msg_header_t)); + msgHeader = (fapi_msg_header_t *)(headerElem + 1); + msgHeader->num_msg = 1; + msgHeader->handle = 0; + + DU_LOG("\nDEBUG --> LWR_MAC: Sending Param Request to Phy"); + LwrMacSendToL1(headerElem); } else { - DU_LOG("\nLOWER MAC: Failed to allocate memory for Param Request"); + DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for Param Request"); return RFAILED; } -#else - return ROK; #endif + return ROK; } - /******************************************************************* - * - * @brief Sends FAPI Param Response to MAC via PHY - * - * @details - * - * Function : lwr_mac_handleParamRspEvt - * - * Functionality: - * -Sends FAPI Param rsp to MAC via PHY - * - * @params[in] - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ - -S16 lwr_mac_handleParamRspEvt(void *msg) -{ -#ifdef FAPI - /* stopGuardTimer(); */ +/******************************************************************* + * + * @brief Sends FAPI Param Response to MAC via PHY + * + * @details + * + * Function : lwr_mac_procParamRspEvt + * + * Functionality: + * -Sends FAPI Param rsp to MAC via PHY + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t lwr_mac_procParamRspEvt(void *msg) +{ +#ifdef INTEL_FAPI + /* stopGuardTimer(); */ uint8_t index; uint32_t encodedVal; - fapi_param_resp_t *paramRsp; + fapi_param_resp_t *paramRsp; ClCellParam *cellParam = NULLP; paramRsp = (fapi_param_resp_t *)msg; - DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState); + DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, lwrMacCb.phyState); if(paramRsp != NULLP) { MAC_ALLOC(cellParam, sizeof(ClCellParam)); if(cellParam != NULLP) { - DU_LOG("\n LOWER MAC: Filling TLVS into MAC API"); - if(paramRsp->error_code == MSG_OK) - { - for(index = 0; index < paramRsp->number_of_tlvs; index++) - { - switch(paramRsp->tlvs[index].tl.tag) - { - 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; + DU_LOG("\nDEBUG --> LWR_MAC: Filling TLVS into MAC API"); + if(paramRsp->error_code == MSG_OK) + { + for(index = 0; index < paramRsp->number_of_tlvs; index++) + { + switch(paramRsp->tlvs[index].tl.tag) + { + 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 != lwrMacCb.phyState) + { + DU_LOG("\nERROR --> PhyState mismatch [%d][%d]", lwrMacCb.phyState, lwrMacCb.event); + return 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: + //DU_LOG("\nERROR --> Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index); + break; + } + } + MAC_FREE(cellParam, sizeof(ClCellParam)); + sendToLowerMac(FAPI_CONFIG_REQUEST, 0, (void *)NULL); + return ROK; + } + else + { + DU_LOG("\nERROR --> LWR_MAC: Invalid error code %d", paramRsp->error_code); + return RFAILED; + } + } + else + { + DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for cell param"); + return RFAILED; + } + } + else + { + DU_LOG("\nERROR --> LWR_MAC: Param Response received from PHY is NULL"); + return RFAILED; + } +#else + return ROK; +#endif +} - 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; +#ifdef INTEL_TIMER_MODE +uint8_t lwr_mac_procIqSamplesReqEvt(void *msg) +{ + void * wlsHdlr = NULLP; + fapi_msg_header_t *msgHeader; + fapi_vendor_ext_iq_samples_req_t *iqSampleReq; + p_fapi_api_queue_elem_t headerElem; + p_fapi_api_queue_elem_t iqSampleElem; + char filename[100] = "/root/intel/FlexRAN/testcase/ul/mu0_20mhz/2/uliq00_prach_tst2.bin"; - 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; + uint8_t buffer[] ={0,0,0,0,0,2,11,0,212,93,40,0,20,137,38,0,20,0,20,0,0,8,0,8,0,0,0,0,0,0,0,0,2,0,0,0,0,0,0,0,0,0,0,0,255,0,0,0,0,0,0,0,2,2,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,128,1,0,0,0,0,0,0,1,0,2,0,0,0,0,0,0,0,1,0}; - 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; + size_t bufferSize = sizeof(buffer) / sizeof(buffer[0]); - case FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG: - cellParam->numTlvsToReport = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16); - break; + /* Fill IQ sample req */ + mtGetWlsHdl(&wlsHdlr); + //iqSampleElem = (p_fapi_api_queue_elem_t)WLS_Alloc(wlsHdlr, \ + (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_ext_iq_samples_req_t))); + LWR_MAC_ALLOC(iqSampleElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_ext_iq_samples_req_t))); + if(!iqSampleElem) + { + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for IQ sample req"); + return RFAILED; + } + FILL_FAPI_LIST_ELEM(iqSampleElem, NULLP, FAPI_VENDOR_EXT_UL_IQ_SAMPLES, 1, \ + sizeof(fapi_vendor_ext_iq_samples_req_t)); - case FAPI_CYCLIC_PREFIX_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillCyclicPrefix(encodedVal, &cellParam); - } - break; + iqSampleReq = (fapi_vendor_ext_iq_samples_req_t *)(iqSampleElem + 1); + memset(iqSampleReq, 0, sizeof(fapi_vendor_ext_iq_samples_req_t)); + fillMsgHeader(&iqSampleReq->header, FAPI_VENDOR_EXT_UL_IQ_SAMPLES, \ + sizeof(fapi_vendor_ext_iq_samples_req_t)); - case FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillSubcarrierSpaceDl(encodedVal, &cellParam); - } - break; + iqSampleReq->iq_samples_info.carrNum = 0; + iqSampleReq->iq_samples_info.numSubframes = 40; + iqSampleReq->iq_samples_info.nIsRadioMode = 0; + iqSampleReq->iq_samples_info.timerModeFreqDomain = 0; + iqSampleReq->iq_samples_info.phaseCompensationEnable = 0; + iqSampleReq->iq_samples_info.startFrameNum = 0; + iqSampleReq->iq_samples_info.startSlotNum = 0; + iqSampleReq->iq_samples_info.startSymNum = 0; + strncpy(iqSampleReq->iq_samples_info.filename_in_ul_iq[0], filename, 100); + memcpy(iqSampleReq->iq_samples_info.buffer, buffer, bufferSize); - case FAPI_SUPPORTED_BANDWIDTH_DL_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16); - if(encodedVal != RFAILED) - { - fillBandwidthDl(encodedVal, &cellParam); - } - break; + /* TODO : Fill remaining parameters */ - case FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillSubcarrierSpaceUl(encodedVal, &cellParam); - } - break; + /* Fill message header */ + LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t))); + if(!headerElem) + { + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for FAPI header in lwr_mac_procIqSamplesReqEvt"); + return RFAILED; + } + FILL_FAPI_LIST_ELEM(headerElem, iqSampleElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \ + sizeof(fapi_msg_header_t)); + msgHeader = (fapi_msg_header_t *)(headerElem + 1); + msgHeader->num_msg = 1; + msgHeader->handle = 0; - case FAPI_SUPPORTED_BANDWIDTH_UL_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16); - if(encodedVal != RFAILED) - { - fillBandwidthUl(encodedVal, &cellParam); - } - break; + DU_LOG("\nINFO --> LWR_MAC: Sending IQ Sample request to Phy"); + LwrMacSendToL1(headerElem); + return ROK; +} +#endif - case FAPI_CCE_MAPPING_TYPE_TAG: - encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); - if(encodedVal != RFAILED) - { - fillCCEmaping(encodedVal, &cellParam); - } - break; +/******************************************************************* + * + * @brief Sends FAPI Config req to PHY + * + * @details + * + * Function : lwr_mac_procConfigReqEvt + * + * Functionality: + * -Sends FAPI Config Req to PHY + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ - 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; +uint8_t lwr_mac_procConfigReqEvt(void *msg) +{ +#ifdef INTEL_FAPI +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : CONFIG_REQ\n"); +#endif +#ifdef NR_TDD + uint8_t slotIdx = 0; + uint8_t symbolIdx =0; +#endif + uint16_t index = 0; + uint16_t *cellId =NULLP; + uint16_t cellIdx =0; + uint32_t msgLen = 0; + uint32_t mib = 0; + MacCellCfg macCfgParams; + fapi_vendor_msg_t *vendorMsg; + fapi_config_req_t *configReq; + fapi_msg_header_t *msgHeader; + p_fapi_api_queue_elem_t headerElem; + p_fapi_api_queue_elem_t vendorMsgQElem; + p_fapi_api_queue_elem_t cfgReqQElem; - 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; + DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \ + lwrMacCb.phyState); - 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; + cellId = (uint16_t *)msg; + GET_CELL_IDX(*cellId, cellIdx); + macCfgParams = macCb.macCell[cellIdx]->macCellCfg; - 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; + /* Fill Cell Configuration in lwrMacCb */ + memset(&lwrMacCb.cellCb[lwrMacCb.numCell], 0, sizeof(LwrMacCellCb)); + lwrMacCb.cellCb[lwrMacCb.numCell].cellId = macCfgParams.cellId; + lwrMacCb.cellCb[lwrMacCb.numCell].phyCellId = macCfgParams.cellCfg.phyCellId; + lwrMacCb.numCell++; - 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; - } - } - MAC_FREE(cellParam, sizeof(ClCellParam)); - sendToLowerMac(FAPI_CONFIG_REQUEST, 0, (void *)NULL); - 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; - } + /* Allocte And fill Vendor msg */ + LWR_MAC_ALLOC(vendorMsgQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t))); + if(!vendorMsgQElem) + { + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req"); + return RFAILED; } - else + FILL_FAPI_LIST_ELEM(vendorMsgQElem, NULLP, FAPI_VENDOR_MESSAGE, 1, sizeof(fapi_vendor_msg_t)); + vendorMsg = (fapi_vendor_msg_t *)(vendorMsgQElem + 1); + fillMsgHeader(&vendorMsg->header, FAPI_VENDOR_MESSAGE, sizeof(fapi_vendor_msg_t)); + vendorMsg->config_req_vendor.hopping_id = 0; + vendorMsg->config_req_vendor.carrier_aggregation_level = 0; + vendorMsg->config_req_vendor.group_hop_flag = 0; + vendorMsg->config_req_vendor.sequence_hop_flag = 0; + vendorMsg->config_req_vendor.urllc_capable = 0; + vendorMsg->config_req_vendor.urllc_mini_slot_mask =0; + vendorMsg->config_req_vendor.nr_of_dl_ports =1; + vendorMsg->config_req_vendor.nr_of_ul_ports =1; + vendorMsg->config_req_vendor.prach_nr_of_rx_ru =1; + vendorMsg->config_req_vendor.ssb_subc_spacing =1; + vendorMsg->config_req_vendor.use_vendor_EpreXSSB = USE_VENDOR_EPREXSSB; + vendorMsg->start_req_vendor.sfn = 0; + vendorMsg->start_req_vendor.slot = 0; + vendorMsg->start_req_vendor.mode = 4; +#ifdef DEBUG_MODE + vendorMsg->start_req_vendor.count = 0; + vendorMsg->start_req_vendor.period = 1; +#endif + /* Fill FAPI config req */ + LWR_MAC_ALLOC(cfgReqQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_config_req_t))); + if(!cfgReqQElem) { - DU_LOG("\nLOWER MAC: Param Response received from PHY is NULL"); - return RFAILED; + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for config req"); + LWR_MAC_FREE(vendorMsgQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t))); + return RFAILED; } + FILL_FAPI_LIST_ELEM(cfgReqQElem, vendorMsgQElem, FAPI_CONFIG_REQUEST, 1, \ + sizeof(fapi_config_req_t)); + + configReq = (fapi_config_req_t *)(cfgReqQElem + 1); + memset(configReq, 0, sizeof(fapi_config_req_t)); + fillMsgHeader(&configReq->header, FAPI_CONFIG_REQUEST, sizeof(fapi_config_req_t)); +#ifndef NR_TDD + configReq->number_of_tlvs = 25; #else - return ROK; + configReq->number_of_tlvs = 25 + 1 + MAX_TDD_PERIODICITY_SLOTS * MAX_SYMB_PER_SLOT; #endif -} - - /******************************************************************* - * - * @brief Sends FAPI Config req to PHY - * - * @details - * - * Function : lwr_mac_handleConfigReqEvt - * - * Functionality: - * -Sends FAPI Config Req to PHY - * - * @params[in] - * @return ROK - success - * RFAILED - failure - * - * ****************************************************************/ - -S16 lwr_mac_handleConfigReqEvt(void *msg) -{ -#ifdef FAPI - 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)); - LWR_MAC_ALLOC(configReq, configReqSize); - if(configReq != NULL) - { - configReq->number_of_tlvs = macCfgParams.numTlv; - - if(macCfgParams.dlCarrCfg.pres) + msgLen = sizeof(configReq->number_of_tlvs); + + fillTlvs(&configReq->tlvs[index++], FAPI_DL_BANDWIDTH_TAG, \ + sizeof(uint32_t), macCfgParams.carrCfg.dlBw, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_DL_FREQUENCY_TAG, \ + sizeof(uint32_t), macCfgParams.carrCfg.dlFreq, &msgLen); + /* Due to bug in Intel FT code, commenting TLVs that are are not + * needed to avoid error. Must be uncommented when FT bug is fixed */ + //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.carrCfg.numTxAnt, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_BANDWIDTH_TAG, \ + sizeof(uint32_t), macCfgParams.carrCfg.ulBw, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_FREQUENCY_TAG, \ + sizeof(uint32_t), macCfgParams.carrCfg.ulFreq, &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.carrCfg.numRxAnt, &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.cellCfg.phyCellId, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_FRAME_DUPLEX_TYPE_TAG, \ + sizeof(uint8_t), macCfgParams.cellCfg.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), convertScsValToScsEnum(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.msg1Fdm, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_CONFIG_INDEX_TAG, + sizeof(uint8_t), macCfgParams.prachCfg.prachCfgIdx, &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); + /* if(macCfgParams.prachCfg.fdm[0].numUnusedRootSeq) { - 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); + for(idx = 0; idx < macCfgParams.prachCfg.fdm[0].numUnusedRootSeq; idx++) + fillTlvs(&configReq->tlvs[index++], FAPI_UNUSED_ROOT_SEQUENCES_TAG, \ + sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].unsuedRootSeq[idx], \ + &msgLen); } - if(macCfgParams.ulCarrCfg.pres) + else + { + macCfgParams.prachCfg.fdm[0].unsuedRootSeq = NULL; + }*/ + + 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); + + setMibPdu(macCfgParams.ssbCfg.mibPdu, &mib, 0); + fillTlvs(&configReq->tlvs[index++], FAPI_MIB_TAG , \ + sizeof(uint32_t), mib, &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); + +#ifdef NR_TDD + /* fill TDD table */ + fillTlvs(&configReq->tlvs[index++], FAPI_TDD_PERIOD_TAG, \ + sizeof(uint8_t), macCfgParams.tddCfg.tddPeriod, &msgLen); + + for(slotIdx =0 ;slotIdx < MAX_TDD_PERIODICITY_SLOTS; slotIdx++) + { + for(symbolIdx = 0; symbolIdx < MAX_SYMB_PER_SLOT; symbolIdx++) { - 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); + /*Fill Full-DL Slots as well as DL symbols ini 1st Flexi Slo*/ + if(slotIdx < macCfgParams.tddCfg.nrOfDlSlots || \ + (slotIdx == macCfgParams.tddCfg.nrOfDlSlots && symbolIdx < macCfgParams.tddCfg.nrOfDlSymbols)) + { + fillTlvs(&configReq->tlvs[index++], FAPI_SLOT_CONFIG_TAG, \ + sizeof(uint8_t), DL_SYMBOL, &msgLen); + } + + /*Fill Full-FLEXI SLOT and as well as Flexi Symbols in 1 slot preceding FULL-UL slot*/ + else if(slotIdx < (MAX_TDD_PERIODICITY_SLOTS - macCfgParams.tddCfg.nrOfUlSlots -1) || \ + (slotIdx == (MAX_TDD_PERIODICITY_SLOTS - macCfgParams.tddCfg.nrOfUlSlots -1) && \ + symbolIdx < (MAX_SYMB_PER_SLOT - macCfgParams.tddCfg.nrOfUlSymbols))) + { + fillTlvs(&configReq->tlvs[index++], FAPI_SLOT_CONFIG_TAG, \ + sizeof(uint8_t), FLEXI_SYMBOL, &msgLen); + } + /*Fill Partial UL symbols and Full-UL slot*/ + else + { + fillTlvs(&configReq->tlvs[index++], FAPI_SLOT_CONFIG_TAG, \ + sizeof(uint8_t), UL_SYMBOL, &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.msg1Fdm, &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); - if(macCfgParams.prachCfg.fdm[0].numUnusedRootSeq) - { - LWR_MAC_ALLOC(macCfgParams.prachCfg.fdm[0].unsuedRootSeq , - sizeof(uint8_t)*macCfgParams.prachCfg.fdm[0].numUnusedRootSeq); - fillTlvs(&configReq->tlvs[index++], FAPI_UNUSED_ROOT_SEQUENCES_TAG,\ - sizeof(uint8_t), *(macCfgParams.prachCfg.fdm[0].unsuedRootSeq), &msgLen); - } - else - { - macCfgParams.prachCfg.fdm[0].unsuedRootSeq = NULL; - } - - 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"); - /* TODO : Recheck the size / msglen to be sent to WLS_Put*/ - LwrMacSendToPhy(configReq->header.message_type_id, msgLen, (void *)configReq); - return ROK; } - else +#endif + + /* fill measurement config */ + //fillTlvs(&configReq->tlvs[index++], FAPI_RSSI_MEASUREMENT_TAG, \ + sizeof(uint8_t), macCfgParams.rssiUnit, &msgLen); + + /* fill DMRS Type A Pos */ + fillTlvs(&configReq->tlvs[index++], FAPI_DMRS_TYPE_A_POS_TAG, \ + sizeof(uint8_t), macCfgParams.ssbCfg.dmrsTypeAPos, &msgLen); + + /* Fill message header */ + LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t))); + if(!headerElem) { - DU_LOG("\nLOWER_MAC: Failed to allocate memory for config Request"); + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req"); + LWR_MAC_FREE(cfgReqQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_config_req_t))); + LWR_MAC_FREE(vendorMsgQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t))); return RFAILED; } -#else - return ROK; + FILL_FAPI_LIST_ELEM(headerElem, cfgReqQElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \ + sizeof(fapi_msg_header_t)); + msgHeader = (fapi_msg_header_t *)(headerElem + 1); + msgHeader->num_msg = 2; /* Config req msg and vendor specific msg */ + msgHeader->handle = 0; + + DU_LOG("\nDEBUG --> LWR_MAC: Sending Config Request to Phy"); + LwrMacSendToL1(headerElem); #endif -} -S16 lwr_mac_handleConfigRspEvt(void *msg) + return ROK; +} /* lwr_mac_handleConfigReqEvt */ + +/******************************************************************* + * + * @brief Processes config response from phy + * + * @details + * + * Function : lwr_mac_procConfigRspEvt + * + * Functionality: + * Processes config response from phy + * + * @params[in] FAPI message pointer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ + +uint8_t lwr_mac_procConfigRspEvt(void *msg) { -#ifdef FAPI +#ifdef INTEL_FAPI 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); + configRsp = (fapi_config_resp_t *)msg; + + DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \ + lwrMacCb.phyState); if(configRsp != NULL) { if(configRsp->error_code == MSG_OK) { - DU_LOG("\nLOWER MAC: PHY has moved to Configured state \n"); - clGlobalCp.phyState = PHY_STATE_CONFIGURED; - /* TODO : - * Store config response into an intermediate struture and send to MAC - * Support LC and LWLC for sending config rsp to MAC - */ - fapiMacConfigRsp(); - return ROK; + DU_LOG("\nDEBUG --> LWR_MAC: PHY has moved to Configured state \n"); + lwrMacCb.phyState = PHY_STATE_CONFIGURED; + lwrMacCb.cellCb[0].state = PHY_STATE_CONFIGURED; + /* TODO : + * Store config response into an intermediate struture and send to MAC + * Support LC and LWLC for sending config rsp to MAC + */ + fapiMacConfigRsp(lwrMacCb.cellCb[0].cellId); } else { - - DU_LOG("\n LOWER MAC: Invalid error code %d", configRsp->error_code); - return RFAILED; + DU_LOG("\nERROR --> LWR_MAC: Invalid error code %d", configRsp->error_code); + return RFAILED; } } else { - DU_LOG("\nLOWER_MAC: Config Response received from PHY is NULL"); + DU_LOG("\nERROR --> LWR_MAC: Config Response received from PHY is NULL"); return RFAILED; } -#else - return ROK; #endif -} -S16 lwr_mac_handleStartReqEvt(void *msg) + return ROK; +} /* lwr_mac_procConfigRspEvt */ + +/******************************************************************* + * + * @brief Build and send start request to phy + * + * @details + * + * Function : lwr_mac_procStartReqEvt + * + * Functionality: + * Build and send start request to phy + * + * @params[in] FAPI message pointer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t lwr_mac_procStartReqEvt(void *msg) { -#ifdef FAPI - uint32_t msgLen = 0; +#ifdef INTEL_FAPI +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : START_REQ\n"); +#endif + fapi_msg_header_t *msgHeader; fapi_start_req_t *startReq; + fapi_vendor_msg_t *vendorMsg; + p_fapi_api_queue_elem_t headerElem; + p_fapi_api_queue_elem_t startReqElem; + p_fapi_api_queue_elem_t vendorMsgElem; - LWR_MAC_ALLOC(startReq, sizeof(fapi_start_req_t)); - if(startReq != NULL) + /* Allocte And fill Vendor msg */ + LWR_MAC_ALLOC(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t))); + if(!vendorMsgElem) { - fillMsgHeader(&startReq->header, FAPI_START_REQUEST, msgLen); - DU_LOG("\nLOWER MAC: Sending Start Request to PHY"); - LwrMacSendToPhy(startReq->header.message_type_id, sizeof(fapi_start_req_t), (void *)startReq); - return ROK; + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in start req"); + return RFAILED; } - else + FILL_FAPI_LIST_ELEM(vendorMsgElem, NULLP, FAPI_VENDOR_MESSAGE, 1, sizeof(fapi_vendor_msg_t)); + vendorMsg = (fapi_vendor_msg_t *)(vendorMsgElem + 1); + fillMsgHeader(&vendorMsg->header, FAPI_VENDOR_MESSAGE, sizeof(fapi_vendor_msg_t)); + vendorMsg->start_req_vendor.sfn = 0; + vendorMsg->start_req_vendor.slot = 0; + vendorMsg->start_req_vendor.mode = 4; /* for Radio mode */ +#ifdef DEBUG_MODE + vendorMsg->start_req_vendor.count = 0; + vendorMsg->start_req_vendor.period = 1; +#endif + + /* Fill FAPI config req */ + LWR_MAC_ALLOC(startReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_start_req_t))); + if(!startReqElem) { - DU_LOG("\nLOWER MAC: Failed to allocate memory for Start Request"); + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for start req"); + LWR_MAC_FREE(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t))); return RFAILED; } -#else - return ROK; -#endif -} + FILL_FAPI_LIST_ELEM(startReqElem, vendorMsgElem, FAPI_START_REQUEST, 1, \ + sizeof(fapi_start_req_t)); -S16 lwr_mac_handleStopReqEvt(void *msg) -{ -#ifdef FAPI - /* stop TX and RX operation return PHy to configured State - send stop.indication to l2/l3 */ + startReq = (fapi_start_req_t *)(startReqElem + 1); + memset(startReq, 0, sizeof(fapi_start_req_t)); + fillMsgHeader(&startReq->header, FAPI_START_REQUEST, sizeof(fapi_start_req_t)); + + /* Fill message header */ + LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t))); + if(!headerElem) + { + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req"); + LWR_MAC_FREE(startReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_start_req_t))); + LWR_MAC_FREE(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t))); + return RFAILED; + } + FILL_FAPI_LIST_ELEM(headerElem, startReqElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \ + sizeof(fapi_msg_header_t)); + msgHeader = (fapi_msg_header_t *)(headerElem + 1); + msgHeader->num_msg = 2; /* Start req msg and vendor specific msg */ + msgHeader->handle = 0; + + /* Send to PHY */ + DU_LOG("\nDEBUG --> LWR_MAC: Sending Start Request to Phy"); + LwrMacSendToL1(headerElem); #endif return ROK; -} +} /* lwr_mac_procStartReqEvt */ /******************************************************************* * - * @brief Modifes the received mibPdu to uint32 bit - * and stores it in MacCellCfg + * @brief Sends FAPI Stop Req to PHY * * @details * - * Function : setMibPdu + * Function : lwr_mac_procStopReqEvt * * Functionality: - * -Sets the MibPdu + * -Sends FAPI Stop Req to PHY * - * @params[in] Pointer to mibPdu - * pointer to modified value - ******************************************************************/ + * @params[in] + * @return ROK - success + * RFAILED - failure + * + ********************************************************************/ -PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val) +uint8_t lwr_mac_procStopReqEvt(SlotTimingInfo slotInfo, p_fapi_api_queue_elem_t prevElem, fapi_stop_req_vendor_msg_t *vendorMsg) { - *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); +#ifdef INTEL_FAPI +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : STOP_REQ\n"); +#endif + + fapi_stop_req_t *stopReq; + p_fapi_api_queue_elem_t stopReqElem; + + vendorMsg->sfn = slotInfo.sfn; + vendorMsg->slot = slotInfo.slot; + + /* Fill FAPI stop req */ + LWR_MAC_ALLOC(stopReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_stop_req_t))); + if(!stopReqElem) + { + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for stop req"); + return RFAILED; + } + FILL_FAPI_LIST_ELEM(stopReqElem, NULLP, FAPI_STOP_REQUEST, 1, sizeof(fapi_stop_req_t)); + stopReq = (fapi_stop_req_t *)(stopReqElem + 1); + memset(stopReq, 0, sizeof(fapi_stop_req_t)); + fillMsgHeader(&stopReq->header, FAPI_STOP_REQUEST, sizeof(fapi_stop_req_t)); + + /* Send to PHY */ + DU_LOG("\nINFO --> LWR_MAC: Sending Stop Request to Phy"); + prevElem->p_next = stopReqElem; + +#endif + return ROK; } -#ifdef FAPI +#ifdef INTEL_FAPI /******************************************************************* * * @brief fills SSB PDU required for DL TTI info in MAC @@ -2114,38 +2451,33 @@ PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val) * ******************************************************************/ -S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg, - MacDlSlot *currDlSlot, - uint32_t *msgLen, uint8_t ssbIdxCount) +uint8_t fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg, + MacDlSlot *currDlSlot, uint8_t ssbIdxCount, uint16_t sfn) { 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 = currDlSlot->dlInfo.brdcstAlloc.ssbInfo[ssbIdxCount].ssbIdx; - dlTtiReqPdu->u.ssb_pdu.ssbSubCarrierOffset = macCellCfg->ssbCfg.ssbScOffset; + dlTtiReqPdu->pdu.ssb_pdu.physCellId = macCellCfg->cellCfg.phyCellId; + dlTtiReqPdu->pdu.ssb_pdu.betaPss = macCellCfg->ssbCfg.betaPss; + dlTtiReqPdu->pdu.ssb_pdu.ssbBlockIndex = currDlSlot->dlInfo.brdcstAlloc.ssbInfo[ssbIdxCount].ssbIdx; + dlTtiReqPdu->pdu.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; + dlTtiReqPdu->pdu.ssb_pdu.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA;; + dlTtiReqPdu->pdu.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]; + setMibPdu(macCellCfg->ssbCfg.mibPdu, &mibPayload, sfn); + dlTtiReqPdu->pdu.ssb_pdu.bchPayload.bchPayload = mibPayload; + dlTtiReqPdu->pdu.ssb_pdu.preCodingAndBeamforming.numPrgs = 0; + dlTtiReqPdu->pdu.ssb_pdu.preCodingAndBeamforming.prgSize = 0; + dlTtiReqPdu->pdu.ssb_pdu.preCodingAndBeamforming.digBfInterfaces = 0; + dlTtiReqPdu->pdu.ssb_pdu.preCodingAndBeamforming.pmi_bfi[0].pmIdx = 0; + dlTtiReqPdu->pdu.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; - } + } + return RFAILED; } /******************************************************************* @@ -2169,24 +2501,24 @@ void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo) { if(dlDciPtr != NULLP) { - uint8_t numBytes; - uint8_t bytePos; - uint8_t bitPos; - - uint16_t coreset0Size; - uint16_t rbStart; - uint16_t rbLen; - uint32_t freqDomResAssign; - uint32_t timeDomResAssign; - uint8_t VRB2PRBMap; - uint32_t modNCodScheme; - uint8_t redundancyVer; - uint32_t sysInfoInd; - uint32_t reserved; + uint8_t numBytes=0; + uint8_t bytePos=0; + uint8_t bitPos=0; + + uint16_t coreset0Size=0; + uint16_t rbStart=0; + uint16_t rbLen=0; + uint32_t freqDomResAssign=0; + uint32_t timeDomResAssign=0; + uint8_t VRB2PRBMap=0; + uint32_t modNCodScheme=0; + uint8_t redundancyVer=0; + uint32_t sysInfoInd=0; + uint32_t reserved=0; /* Size(in bits) of each field in DCI format 0_1 - * as mentioned in spec 38.214 */ - uint8_t freqDomResAssignSize; + * as mentioned in spec 38.214 */ + uint8_t freqDomResAssignSize = 0; uint8_t timeDomResAssignSize = 4; uint8_t VRB2PRBMapSize = 1; uint8_t modNCodSchemeSize = 5; @@ -2204,8 +2536,8 @@ void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo) dlDciPtr->pc_and_bform.digBfInterfaces = sib1PdcchInfo->dci.beamPdcchInfo.digBfInterfaces; dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = sib1PdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx; dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = sib1PdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0]; - dlDciPtr->beta_pdcch_1_0 = sib1PdcchInfo->dci.txPdcchPower.powerValue; - dlDciPtr->powerControlOfssetSS = sib1PdcchInfo->dci.txPdcchPower.powerControlOffsetSS; + dlDciPtr->beta_pdcch_1_0 = sib1PdcchInfo->dci.txPdcchPower.beta_pdcch_1_0; + dlDciPtr->powerControlOffsetSS = sib1PdcchInfo->dci.txPdcchPower.powerControlOffsetSS; /* Calculating freq domain resource allocation field value and size * coreset0Size = Size of coreset 0 @@ -2213,29 +2545,26 @@ void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo) * RBLen = length of contiguously allocted RBs * Spec 38.214 Sec 5.1.2.2.2 */ - coreset0Size= sib1PdcchInfo->coreset0Cfg.coreSet0Size; - rbStart = 0; /* For SIB1 */ - //rbStart = sib1PdcchInfo->dci.pdschCfg->freqAlloc.rbStart; - rbLen = sib1PdcchInfo->dci.pdschCfg->freqAlloc.rbSize; + coreset0Size= sib1PdcchInfo->coresetCfg.coreSetSize; + rbStart = sib1PdcchInfo->dci.pdschCfg.pdschFreqAlloc.startPrb; + rbLen = sib1PdcchInfo->dci.pdschCfg.pdschFreqAlloc.numPrb; if((rbLen >=1) && (rbLen <= coreset0Size - rbStart)) { - if((rbLen - 1) <= floor(coreset0Size / 2)) - freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart; - else - freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \ - + (coreset0Size - 1 - rbStart); + if((rbLen - 1) <= floor(coreset0Size / 2)) + freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart; + else + freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \ + + (coreset0Size - 1 - rbStart); - freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2)); + freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2)); } /* Fetching DCI field values */ - timeDomResAssign = sib1PdcchInfo->dci.pdschCfg->timeAlloc. - rowIndex -1; - VRB2PRBMap = sib1PdcchInfo->dci.pdschCfg->freqAlloc.\ - vrbPrbMapping; - modNCodScheme = sib1PdcchInfo->dci.pdschCfg->codeword[0].mcsIndex; - redundancyVer = sib1PdcchInfo->dci.pdschCfg->codeword[0].rvIndex; + timeDomResAssign = sib1PdcchInfo->dci.pdschCfg.pdschTimeAlloc.rowIndex -1; + VRB2PRBMap = sib1PdcchInfo->dci.pdschCfg.pdschFreqAlloc.vrbPrbMapping; + modNCodScheme = sib1PdcchInfo->dci.pdschCfg.codeword[0].mcsIndex; + redundancyVer = sib1PdcchInfo->dci.pdschCfg.codeword[0].rvIndex; sysInfoInd = 0; /* 0 for SIB1; 1 for SI messages */ reserved = 0; @@ -2247,234 +2576,739 @@ void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo) redundancyVer = reverseBits(redundancyVer, redundancyVerSize); sysInfoInd = reverseBits(sysInfoInd, sysInfoIndSize); - /* Calulating total number of bytes in buffer */ - dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\ - + VRB2PRBMapSize + modNCodSchemeSize + redundancyVerSize\ - + sysInfoIndSize + reservedSize; - - numBytes = dlDciPtr->payloadSizeBits / 8; - if(dlDciPtr->payloadSizeBits % 8) - numBytes += 1; - - if(numBytes > DCI_PAYLOAD_BYTE_LEN) - { - DU_LOG("\nLOWER MAC : Total bytes for DCI is more than expected"); - return; - } - - /* Initialize buffer */ - for(bytePos = 0; bytePos < numBytes; bytePos++) - dlDciPtr->payload[bytePos] = 0; - - bytePos = numBytes - 1; - bitPos = 0; - - /* Packing DCI format fields */ - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - freqDomResAssign, freqDomResAssignSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - timeDomResAssign, timeDomResAssignSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - VRB2PRBMap, VRB2PRBMapSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - modNCodScheme, modNCodSchemeSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - redundancyVer, redundancyVerSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - sysInfoInd, sysInfoIndSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - reserved, reservedSize); + /* Calulating total number of bytes in buffer */ + dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\ + + VRB2PRBMapSize + modNCodSchemeSize + redundancyVerSize\ + + sysInfoIndSize + reservedSize; + + numBytes = dlDciPtr->payloadSizeBits / 8; + if(dlDciPtr->payloadSizeBits % 8) + numBytes += 1; + + if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN) + { + DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected"); + return; + } + + /* Initialize buffer */ + for(bytePos = 0; bytePos < numBytes; bytePos++) + dlDciPtr->payload[bytePos] = 0; + + bytePos = numBytes - 1; + bitPos = 0; + + /* Packing DCI format fields */ + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + freqDomResAssign, freqDomResAssignSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + timeDomResAssign, timeDomResAssignSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + VRB2PRBMap, VRB2PRBMapSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + modNCodScheme, modNCodSchemeSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + redundancyVer, redundancyVerSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + sysInfoInd, sysInfoIndSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + reserved, reservedSize); } } /* fillSib1DlDciPdu */ + /******************************************************************* * - * @brief fills Dl DCI PDU required for DL TTI info in MAC + * @brief fills Dl DCI PDU for Paging required for DL TTI info in MAC * * @details * - * Function : fillRarDlDciPdu + * Function : fillPageDlDciPdu * * Functionality: - * -Fills the Dl DCI PDU + * -Fills the Dl DCI PDU for Paging * * @params[in] Pointer to fapi_dl_dci_t - * Pointer to PdcchCfg + * Pointer to dlPageAlloc * @return ROK * ******************************************************************/ -void fillRarDlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *rarPdcchInfo) +void fillPageDlDciPdu(fapi_dl_dci_t *dlDciPtr, DlPageAlloc *dlPageAlloc, MacCellCfg *macCellCfg) { - if(dlDciPtr != NULLP) - { - uint8_t numBytes; - uint8_t bytePos; - uint8_t bitPos; - - uint16_t coreset0Size; - uint16_t rbStart; - uint16_t rbLen; - uint32_t freqDomResAssign; - uint8_t timeDomResAssign; - uint8_t VRB2PRBMap; - uint8_t modNCodScheme; - uint8_t tbScaling; - uint32_t reserved; - - /* Size(in bits) of each field in DCI format 1_0 */ - uint8_t freqDomResAssignSize; - uint8_t timeDomResAssignSize = 4; - uint8_t VRB2PRBMapSize = 1; - uint8_t modNCodSchemeSize = 5; - uint8_t tbScalingSize = 2; - uint8_t reservedSize = 16; - - dlDciPtr->rnti = rarPdcchInfo->dci.rnti; - dlDciPtr->scramblingId = rarPdcchInfo->dci.scramblingId; - dlDciPtr->scramblingRnti = rarPdcchInfo->dci.scramblingRnti; - dlDciPtr->cceIndex = rarPdcchInfo->dci.cceIndex; - dlDciPtr->aggregationLevel = rarPdcchInfo->dci.aggregLevel; - dlDciPtr->pc_and_bform.numPrgs = rarPdcchInfo->dci.beamPdcchInfo.numPrgs; - dlDciPtr->pc_and_bform.prgSize = rarPdcchInfo->dci.beamPdcchInfo.prgSize; - dlDciPtr->pc_and_bform.digBfInterfaces = rarPdcchInfo->dci.beamPdcchInfo.digBfInterfaces; - dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx; - dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0]; - dlDciPtr->beta_pdcch_1_0 = rarPdcchInfo->dci.txPdcchPower.powerValue; - dlDciPtr->powerControlOfssetSS = rarPdcchInfo->dci.txPdcchPower.powerControlOffsetSS; - - /* Calculating freq domain resource allocation field value and size - * coreset0Size = Size of coreset 0 - * RBStart = Starting Virtual Rsource block - * RBLen = length of contiguously allocted RBs - * Spec 38.214 Sec 5.1.2.2.2 - */ - - /* TODO: Fill values of coreset0Size, rbStart and rbLen */ - coreset0Size= rarPdcchInfo->coreset0Cfg.coreSet0Size; - rbStart = 0; /* For SIB1 */ - //rbStart = rarPdcchInfo->dci.pdschCfg->freqAlloc.rbStart; - rbLen = rarPdcchInfo->dci.pdschCfg->freqAlloc.rbSize; - - if((rbLen >=1) && (rbLen <= coreset0Size - rbStart)) - { - if((rbLen - 1) <= floor(coreset0Size / 2)) - freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart; - else - freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \ - + (coreset0Size - 1 - rbStart); - - freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2)); - } - - /* Fetching DCI field values */ - timeDomResAssign = rarPdcchInfo->dci.pdschCfg->timeAlloc.rowIndex -1; - VRB2PRBMap = rarPdcchInfo->dci.pdschCfg->freqAlloc.vrbPrbMapping; - modNCodScheme = rarPdcchInfo->dci.pdschCfg->codeword[0].mcsIndex; - tbScaling = 0; /* configured to 0 scaling */ - reserved = 0; - - /* Reversing bits in each DCI field */ - freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize); - timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize); - VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize); - modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize); - tbScaling = reverseBits(tbScaling, tbScalingSize); - - /* Calulating total number of bytes in buffer */ - dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\ - + VRB2PRBMapSize + modNCodSchemeSize + tbScalingSize + reservedSize; - - numBytes = dlDciPtr->payloadSizeBits / 8; - if(dlDciPtr->payloadSizeBits % 8) - numBytes += 1; - - if(numBytes > DCI_PAYLOAD_BYTE_LEN) - { - DU_LOG("\nLOWER MAC : Total bytes for DCI is more than expected"); - return; - } - - /* Initialize buffer */ - for(bytePos = 0; bytePos < numBytes; bytePos++) - dlDciPtr->payload[bytePos] = 0; - - bytePos = numBytes - 1; - bitPos = 0; - - /* Packing DCI format fields */ - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - freqDomResAssign, freqDomResAssignSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - timeDomResAssign, timeDomResAssignSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - VRB2PRBMap, VRB2PRBMapSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - modNCodScheme, modNCodSchemeSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - tbScaling, tbScalingSize); - fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ - reserved, reservedSize); - } -} /* fillRarDlDciPdu */ + if(dlDciPtr != NULLP) + { + uint8_t numBytes=0; + uint8_t bytePos=0; + uint8_t bitPos=0; + + uint16_t coreset0Size = 0; + uint16_t rbStart = 0; + uint16_t rbLen = 0; + uint8_t shortMsgInd = 0; + uint8_t shortMsg = 0; + uint32_t freqDomResAssign = 0; + uint32_t timeDomResAssign = 0; + uint8_t VRB2PRBMap = 0; + uint32_t modNCodScheme = 0; + uint8_t tbScaling = 0; + uint32_t reserved = 0; + + /* Size(in bits) of each field in DCI format 1_0 + * as mentioned in spec 38.214 */ + uint8_t shortMsgIndSize = 2; + uint8_t shortMsgSize = 8; + uint8_t freqDomResAssignSize = 0; + uint8_t timeDomResAssignSize = 4; + uint8_t VRB2PRBMapSize = 1; + uint8_t modNCodSchemeSize = 5; + uint8_t tbScalingSize = 2; + uint8_t reservedSize = 6; + + dlDciPtr->rnti = P_RNTI; + dlDciPtr->scramblingId = macCellCfg->cellCfg.phyCellId; + dlDciPtr->scramblingRnti = 0; + dlDciPtr->cceIndex = dlPageAlloc->pageDlDci.cceIndex; + dlDciPtr->aggregationLevel = dlPageAlloc->pageDlDci.aggregLevel; + dlDciPtr->pc_and_bform.numPrgs = 1; + dlDciPtr->pc_and_bform.prgSize = 1; + dlDciPtr->pc_and_bform.digBfInterfaces = 0; + dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = 0; + dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = 0; + dlDciPtr->beta_pdcch_1_0 = 0; + dlDciPtr->powerControlOffsetSS = 0; -/******************************************************************* - * - * @brief fills PDCCH PDU required for DL TTI info in MAC - * - * @details - * - * Function : fillPdcchPdu - * - * Functionality: - * -Fills the Pdcch PDU info - * stored in MAC - * - * @params[in] Pointer to FAPI DL TTI Req - * Pointer to PdcchCfg - * Pointer to msgLen of DL TTI Info - * @return ROK - * - ******************************************************************/ + /* Calculating freq domain resource allocation field value and size + * coreset0Size = Size of coreset 0 + * RBStart = Starting Virtual Rsource block + * RBLen = length of contiguously allocted RBs + * Spec 38.214 Sec 5.1.2.2.2 + */ + coreset0Size = dlPageAlloc->pageDlDci.coreSetSize; + rbStart = dlPageAlloc->pageDlSch.freqAlloc.startPrb; + rbLen = dlPageAlloc->pageDlSch.freqAlloc.numPrb; -S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdcchCfg *pdcchInfo, -uint32_t *msgLen) -{ - if(dlTtiReqPdu != NULLP) - { - dlTtiReqPdu->pduType = PDCCH_PDU_TYPE; - dlTtiReqPdu->u.pdcch_pdu.bwpSize = pdcchInfo->pdcchBwpCfg.BWPSize; - dlTtiReqPdu->u.pdcch_pdu.bwpPart = pdcchInfo->pdcchBwpCfg.BWPStart; - dlTtiReqPdu->u.pdcch_pdu.subCarrierSpacing = pdcchInfo->pdcchBwpCfg.subcarrierSpacing; - dlTtiReqPdu->u.pdcch_pdu.cyclicPrefix = pdcchInfo->pdcchBwpCfg.cyclicPrefix; - dlTtiReqPdu->u.pdcch_pdu.startSymbolIndex = pdcchInfo->coreset0Cfg.startSymbolIndex; - dlTtiReqPdu->u.pdcch_pdu.durationSymbols = pdcchInfo->coreset0Cfg.durationSymbols; - memcpy(dlTtiReqPdu->u.pdcch_pdu.freqDomainResource, pdcchInfo->coreset0Cfg.freqDomainResource, 6); - dlTtiReqPdu->u.pdcch_pdu.cceRegMappingType = pdcchInfo->coreset0Cfg.cceRegMappingType; - dlTtiReqPdu->u.pdcch_pdu.regBundleSize = pdcchInfo->coreset0Cfg.regBundleSize; - dlTtiReqPdu->u.pdcch_pdu.interleaverSize = pdcchInfo->coreset0Cfg.interleaverSize; - dlTtiReqPdu->u.pdcch_pdu.coreSetSize = pdcchInfo->coreset0Cfg.coreSetType; - dlTtiReqPdu->u.pdcch_pdu.shiftIndex = pdcchInfo->coreset0Cfg.shiftIndex; - dlTtiReqPdu->u.pdcch_pdu.precoderGranularity = pdcchInfo->coreset0Cfg.precoderGranularity; - dlTtiReqPdu->u.pdcch_pdu.numDlDci = pdcchInfo->numDlDci; - LWR_MAC_ALLOC(dlTtiReqPdu->u.pdcch_pdu.dlDci, sizeof(fapi_dl_dci_t)); - if(pdcchInfo->dci.rnti == SI_RNTI) - { - fillSib1DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo); - } - else - { - fillRarDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo); - } - - dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t); - SETLENGTH(*msgLen, sizeof(fapi_dl_pdcch_pdu_t)); - - } - return ROK; + if((rbLen >=1) && (rbLen <= coreset0Size - rbStart)) + { + if((rbLen - 1) <= floor(coreset0Size / 2)) + freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart; + else + freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \ + + (coreset0Size - 1 - rbStart); -} + freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2)); + } + + /*Fetching DCI field values */ + + /*Refer:38.212 - Table 7.3.1.2.1-1: Short Message indicator >*/ + if(dlPageAlloc->shortMsgInd != TRUE) + { + /*When Short Msg is absent*/ + shortMsgInd = 1; + shortMsg = 0; + } + else + { + /*Short Msg is Present*/ + if(dlPageAlloc->pageDlSch.dlPagePduLen == 0 || dlPageAlloc->pageDlSch.dlPagePdu == NULLP) + { + /*When Paging Msg is absent*/ + shortMsgInd = 2; + } + else + { + /*Both Short and Paging is present*/ + shortMsgInd = 3; + } + shortMsg = dlPageAlloc->shortMsg; + } + + timeDomResAssign = 0; + VRB2PRBMap = dlPageAlloc->pageDlSch.vrbPrbMapping; + modNCodScheme = dlPageAlloc->pageDlSch.tbInfo.mcs; + tbScaling = 0; + reserved = 0; + + /* Reversing bits in each DCI field */ + shortMsgInd = reverseBits(shortMsgInd, shortMsgIndSize); + shortMsg = reverseBits(shortMsg, shortMsgSize); + timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize); + freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize); + timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize); + VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize); + modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize); + tbScaling = reverseBits(tbScaling, tbScalingSize); + + /* Calulating total number of bytes in buffer */ + dlDciPtr->payloadSizeBits = shortMsgIndSize + shortMsgSize + freqDomResAssignSize\ + + timeDomResAssignSize + VRB2PRBMapSize + modNCodSchemeSize\ + + tbScaling + reservedSize; + + numBytes = dlDciPtr->payloadSizeBits / 8; + if(dlDciPtr->payloadSizeBits % 8) + { + numBytes += 1; + } + + if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN) + { + DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected"); + return; + } + + /* Initialize buffer */ + for(bytePos = 0; bytePos < numBytes; bytePos++) + { + dlDciPtr->payload[bytePos] = 0; + } + + bytePos = numBytes - 1; + bitPos = 0; + + /* Packing DCI format fields */ + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + shortMsgInd, shortMsgIndSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + shortMsg, shortMsgSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + freqDomResAssign, freqDomResAssignSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + timeDomResAssign, timeDomResAssignSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + VRB2PRBMap, VRB2PRBMapSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + modNCodScheme, modNCodSchemeSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + tbScaling, tbScalingSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + reserved, reservedSize); + } +} /* fillPageDlDciPdu */ + +/******************************************************************* + * + * @brief fills Dl DCI PDU required for DL TTI info in MAC + * + * @details + * + * Function : fillRarDlDciPdu + * + * Functionality: + * -Fills the Dl DCI PDU + * + * @params[in] Pointer to fapi_dl_dci_t + * Pointer to PdcchCfg + * @return ROK + * + ******************************************************************/ + +void fillRarDlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *rarPdcchInfo) +{ + if(dlDciPtr != NULLP) + { + uint8_t numBytes =0; + uint8_t bytePos =0; + uint8_t bitPos =0; + + uint16_t coreset0Size =0; + uint16_t rbStart =0; + uint16_t rbLen =0; + uint32_t freqDomResAssign =0; + uint8_t timeDomResAssign =0; + uint8_t VRB2PRBMap =0; + uint8_t modNCodScheme =0; + uint8_t tbScaling =0; + uint32_t reserved =0; + + /* Size(in bits) of each field in DCI format 1_0 */ + uint8_t freqDomResAssignSize = 0; + uint8_t timeDomResAssignSize = 4; + uint8_t VRB2PRBMapSize = 1; + uint8_t modNCodSchemeSize = 5; + uint8_t tbScalingSize = 2; + uint8_t reservedSize = 16; + + dlDciPtr->rnti = rarPdcchInfo->dci.rnti; + dlDciPtr->scramblingId = rarPdcchInfo->dci.scramblingId; + dlDciPtr->scramblingRnti = rarPdcchInfo->dci.scramblingRnti; + dlDciPtr->cceIndex = rarPdcchInfo->dci.cceIndex; + dlDciPtr->aggregationLevel = rarPdcchInfo->dci.aggregLevel; + dlDciPtr->pc_and_bform.numPrgs = rarPdcchInfo->dci.beamPdcchInfo.numPrgs; + dlDciPtr->pc_and_bform.prgSize = rarPdcchInfo->dci.beamPdcchInfo.prgSize; + dlDciPtr->pc_and_bform.digBfInterfaces = rarPdcchInfo->dci.beamPdcchInfo.digBfInterfaces; + dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx; + dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0]; + dlDciPtr->beta_pdcch_1_0 = rarPdcchInfo->dci.txPdcchPower.beta_pdcch_1_0; + dlDciPtr->powerControlOffsetSS = rarPdcchInfo->dci.txPdcchPower.powerControlOffsetSS; + + /* Calculating freq domain resource allocation field value and size + * coreset0Size = Size of coreset 0 + * RBStart = Starting Virtual Rsource block + * RBLen = length of contiguously allocted RBs + * Spec 38.214 Sec 5.1.2.2.2 + */ + + /* TODO: Fill values of coreset0Size, rbStart and rbLen */ + coreset0Size= rarPdcchInfo->coresetCfg.coreSetSize; + rbStart = rarPdcchInfo->dci.pdschCfg.pdschFreqAlloc.startPrb; + rbLen = rarPdcchInfo->dci.pdschCfg.pdschFreqAlloc.numPrb; + + if((rbLen >=1) && (rbLen <= coreset0Size - rbStart)) + { + if((rbLen - 1) <= floor(coreset0Size / 2)) + freqDomResAssign = (coreset0Size * (rbLen-1)) + rbStart; + else + freqDomResAssign = (coreset0Size * (coreset0Size - rbLen + 1)) \ + + (coreset0Size - 1 - rbStart); + + freqDomResAssignSize = ceil(log2(coreset0Size * (coreset0Size + 1) / 2)); + } + + /* Fetching DCI field values */ + timeDomResAssign = rarPdcchInfo->dci.pdschCfg.pdschTimeAlloc.rowIndex; + VRB2PRBMap = rarPdcchInfo->dci.pdschCfg.pdschFreqAlloc.vrbPrbMapping; + modNCodScheme = rarPdcchInfo->dci.pdschCfg.codeword[0].mcsIndex; + tbScaling = 0; /* configured to 0 scaling */ + reserved = 0; + + /* Reversing bits in each DCI field */ + freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize); + timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize); + VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize); + modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize); + tbScaling = reverseBits(tbScaling, tbScalingSize); + + /* Calulating total number of bytes in buffer */ + dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\ + + VRB2PRBMapSize + modNCodSchemeSize + tbScalingSize + reservedSize; + + numBytes = dlDciPtr->payloadSizeBits / 8; + if(dlDciPtr->payloadSizeBits % 8) + numBytes += 1; + + if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN) + { + DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected"); + return; + } + + /* Initialize buffer */ + for(bytePos = 0; bytePos < numBytes; bytePos++) + dlDciPtr->payload[bytePos] = 0; + + bytePos = numBytes - 1; + bitPos = 0; + + /* Packing DCI format fields */ + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + freqDomResAssign, freqDomResAssignSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + timeDomResAssign, timeDomResAssignSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + VRB2PRBMap, VRB2PRBMapSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + modNCodScheme, modNCodSchemeSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + tbScaling, tbScalingSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + reserved, reservedSize); + } +} /* fillRarDlDciPdu */ + +/******************************************************************* + * + * @brief fills DL DCI PDU required for DL TTI info in MAC + * + * @details + * + * Function : fillDlMsgDlDciPdu + * + * Functionality: + * -Fills the Dl DCI PDU + * + * @params[in] Pointer to fapi_dl_dci_t + * Pointer to PdcchCfg + * @return ROK + * + ******************************************************************/ +void fillDlMsgDlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *pdcchInfo,\ + DlMsgSchInfo *dlMsgSchInfo) +{ + if(dlDciPtr != NULLP) + { + uint8_t numBytes; + uint8_t bytePos; + uint8_t bitPos; + + uint16_t coresetSize = 0; + uint16_t rbStart = 0; + uint16_t rbLen = 0; + uint8_t dciFormatId; + uint32_t freqDomResAssign; + uint8_t timeDomResAssign; + uint8_t VRB2PRBMap; + uint8_t modNCodScheme; + uint8_t ndi = 0; + uint8_t redundancyVer = 0; + uint8_t harqProcessNum = 0; + uint8_t dlAssignmentIdx = 0; + uint8_t pucchTpc = 0; + uint8_t pucchResoInd = 0; + uint8_t harqFeedbackInd = 0; + + /* Size(in bits) of each field in DCI format 1_0 */ + uint8_t dciFormatIdSize = 1; + uint8_t freqDomResAssignSize = 0; + uint8_t timeDomResAssignSize = 4; + uint8_t VRB2PRBMapSize = 1; + uint8_t modNCodSchemeSize = 5; + uint8_t ndiSize = 1; + uint8_t redundancyVerSize = 2; + uint8_t harqProcessNumSize = 4; + uint8_t dlAssignmentIdxSize = 2; + uint8_t pucchTpcSize = 2; + uint8_t pucchResoIndSize = 3; + uint8_t harqFeedbackIndSize = 3; + + dlDciPtr->rnti = pdcchInfo->dci.rnti; + dlDciPtr->scramblingId = pdcchInfo->dci.scramblingId; + dlDciPtr->scramblingRnti = pdcchInfo->dci.scramblingRnti; + dlDciPtr->cceIndex = pdcchInfo->dci.cceIndex; + dlDciPtr->aggregationLevel = pdcchInfo->dci.aggregLevel; + dlDciPtr->pc_and_bform.numPrgs = pdcchInfo->dci.beamPdcchInfo.numPrgs; + dlDciPtr->pc_and_bform.prgSize = pdcchInfo->dci.beamPdcchInfo.prgSize; + dlDciPtr->pc_and_bform.digBfInterfaces = pdcchInfo->dci.beamPdcchInfo.digBfInterfaces; + dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = pdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx; + dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = pdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0]; + dlDciPtr->beta_pdcch_1_0 = pdcchInfo->dci.txPdcchPower.beta_pdcch_1_0; + dlDciPtr->powerControlOffsetSS = pdcchInfo->dci.txPdcchPower.powerControlOffsetSS; + + /* Calculating freq domain resource allocation field value and size + * coreset0Size = Size of coreset 0 + * RBStart = Starting Virtual Rsource block + * RBLen = length of contiguously allocted RBs + * Spec 38.214 Sec 5.1.2.2.2 + */ + coresetSize = pdcchInfo->coresetCfg.coreSetSize; + rbStart = pdcchInfo->dci.pdschCfg.pdschFreqAlloc.startPrb; + rbLen = pdcchInfo->dci.pdschCfg.pdschFreqAlloc.numPrb; + + if((rbLen >=1) && (rbLen <= coresetSize - rbStart)) + { + if((rbLen - 1) <= floor(coresetSize / 2)) + freqDomResAssign = (coresetSize * (rbLen-1)) + rbStart; + else + freqDomResAssign = (coresetSize * (coresetSize - rbLen + 1)) \ + + (coresetSize - 1 - rbStart); + + freqDomResAssignSize = ceil(log2(coresetSize * (coresetSize + 1) / 2)); + } + + /* Fetching DCI field values */ + dciFormatId = dlMsgSchInfo->dciFormatId; /* Always set to 1 for DL */ + timeDomResAssign = pdcchInfo->dci.pdschCfg.pdschTimeAlloc.rowIndex -1; + VRB2PRBMap = pdcchInfo->dci.pdschCfg.pdschFreqAlloc.vrbPrbMapping; + modNCodScheme = pdcchInfo->dci.pdschCfg.codeword[0].mcsIndex; + ndi = dlMsgSchInfo->transportBlock[0].ndi; + redundancyVer = pdcchInfo->dci.pdschCfg.codeword[0].rvIndex; + harqProcessNum = dlMsgSchInfo->harqProcNum; + dlAssignmentIdx = dlMsgSchInfo->dlAssignIdx; + pucchTpc = dlMsgSchInfo->pucchTpc; + pucchResoInd = dlMsgSchInfo->pucchResInd; + harqFeedbackInd = dlMsgSchInfo->harqFeedbackInd; + + /* Reversing bits in each DCI field */ + dciFormatId = reverseBits(dciFormatId, dciFormatIdSize); + freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize); + timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize); + VRB2PRBMap = reverseBits(VRB2PRBMap, VRB2PRBMapSize); + modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize); + ndi = reverseBits(ndi, ndiSize); + redundancyVer = reverseBits(redundancyVer, redundancyVerSize); + harqProcessNum = reverseBits(harqProcessNum, harqProcessNumSize); + dlAssignmentIdx = reverseBits(dlAssignmentIdx , dlAssignmentIdxSize); + pucchTpc = reverseBits(pucchTpc, pucchTpcSize); + pucchResoInd = reverseBits(pucchResoInd, pucchResoIndSize); + harqFeedbackInd = reverseBits(harqFeedbackInd, harqFeedbackIndSize); + + + /* Calulating total number of bytes in buffer */ + dlDciPtr->payloadSizeBits = (dciFormatIdSize + freqDomResAssignSize\ + + timeDomResAssignSize + VRB2PRBMapSize + modNCodSchemeSize\ + + ndiSize + redundancyVerSize + harqProcessNumSize + dlAssignmentIdxSize\ + + pucchTpcSize + pucchResoIndSize + harqFeedbackIndSize); + + numBytes = dlDciPtr->payloadSizeBits / 8; + if(dlDciPtr->payloadSizeBits % 8) + numBytes += 1; + + if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN) + { + DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected"); + return; + } + + /* Initialize buffer */ + for(bytePos = 0; bytePos < numBytes; bytePos++) + dlDciPtr->payload[bytePos] = 0; + + bytePos = numBytes - 1; + bitPos = 0; + + /* Packing DCI format fields */ + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + dciFormatId, dciFormatIdSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + freqDomResAssign, freqDomResAssignSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + timeDomResAssign, timeDomResAssignSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + VRB2PRBMap, VRB2PRBMapSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + modNCodScheme, modNCodSchemeSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + ndi, ndiSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + redundancyVer, redundancyVerSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + redundancyVer, redundancyVerSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + harqProcessNum, harqProcessNumSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + dlAssignmentIdx, dlAssignmentIdxSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + pucchTpc, pucchTpcSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + pucchResoInd, pucchResoIndSize); + fillDlDciPayload(dlDciPtr->payload, &bytePos, &bitPos,\ + harqFeedbackInd, harqFeedbackIndSize); + } +} + +/******************************************************************* + * + * @brief fills Dl PDCCH Info from DL PageAlloc + * + * @details + * + * Function : fillPdcchInfoFrmPageAlloc + * + * Functionality: + * -Fills the PdcchInfo + * + * @params[in] Pointer to DlPageAlloc + * Pointer to PdcchCfg + * @return ROK + * + ******************************************************************/ +void fillPagePdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, fapi_vendor_dl_tti_req_pdu_t *dlTtiVendorPdu, DlPageAlloc *pageAlloc, MacCellCfg *macCellCfg) +{ + if(dlTtiReqPdu != NULLP) + { + BwpCfg *bwp = NULLP; + + memset(&dlTtiReqPdu->pdu.pdcch_pdu, 0, sizeof(fapi_dl_pdcch_pdu_t)); + bwp = &pageAlloc->bwp; + fillPageDlDciPdu(dlTtiReqPdu->pdu.pdcch_pdu.dlDci, pageAlloc, macCellCfg); + + dlTtiReqPdu->pduType = PDCCH_PDU_TYPE; + + dlTtiReqPdu->pdu.pdcch_pdu.bwpSize = bwp->freqAlloc.numPrb; + dlTtiReqPdu->pdu.pdcch_pdu.bwpStart = bwp->freqAlloc.startPrb; + dlTtiReqPdu->pdu.pdcch_pdu.subCarrierSpacing = bwp->subcarrierSpacing; + dlTtiReqPdu->pdu.pdcch_pdu.cyclicPrefix = bwp->cyclicPrefix; + + dlTtiReqPdu->pdu.pdcch_pdu.startSymbolIndex = pageAlloc->pageDlDci.ssStartSymbolIndex; + dlTtiReqPdu->pdu.pdcch_pdu.durationSymbols = pageAlloc->pageDlDci.durationSymbols; + memcpy(dlTtiReqPdu->pdu.pdcch_pdu.freqDomainResource, pageAlloc->pageDlDci.freqDomainResource, 6*sizeof(uint8_t)); + dlTtiReqPdu->pdu.pdcch_pdu.cceRegMappingType = pageAlloc->pageDlDci.cceRegMappingType; + dlTtiReqPdu->pdu.pdcch_pdu.regBundleSize = pageAlloc->pageDlDci.cceReg.interleaved.regBundleSize; + dlTtiReqPdu->pdu.pdcch_pdu.interleaverSize = pageAlloc->pageDlDci.cceReg.interleaved.interleaverSize; + dlTtiReqPdu->pdu.pdcch_pdu.shiftIndex = pageAlloc->pageDlDci.cceReg.interleaved.shiftIndex; + dlTtiReqPdu->pdu.pdcch_pdu.precoderGranularity = pageAlloc->pageDlDci.precoderGranularity; + dlTtiReqPdu->pdu.pdcch_pdu.numDlDci = 1; + dlTtiReqPdu->pdu.pdcch_pdu.coreSetType = CORESET_TYPE0; + + /* Calculating PDU length. Considering only one dl dci pdu for now */ + dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t); + + /* Filling Vendor message PDU */ + dlTtiVendorPdu->pdu_type = FAPI_PDCCH_PDU_TYPE; + dlTtiVendorPdu->pdu_size = sizeof(fapi_vendor_dl_pdcch_pdu_t); + dlTtiVendorPdu->pdu.pdcch_pdu.num_dl_dci = dlTtiReqPdu->pdu.pdcch_pdu.numDlDci; + dlTtiVendorPdu->pdu.pdcch_pdu.dl_dci[0].epre_ratio_of_pdcch_to_ssb = 0; + dlTtiVendorPdu->pdu.pdcch_pdu.dl_dci[0].epre_ratio_of_dmrs_to_ssb = 0; + } +} + +/******************************************************************* + * + * @brief fills PDCCH PDU required for DL TTI info in MAC + * + * @details + * + * Function : fillPdcchPdu + * + * Functionality: + * -Fills the Pdcch PDU info + * stored in MAC + * + * @params[in] Pointer to FAPI DL TTI Req + * Pointer to PdcchCfg + * @return ROK + * + ******************************************************************/ +uint8_t fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, fapi_vendor_dl_tti_req_pdu_t *dlTtiVendorPdu, MacDlSlot *dlSlot, int8_t dlMsgSchInfoIdx, \ + RntiType rntiType, uint8_t coreSetType, uint8_t ueIdx) +{ + if(dlTtiReqPdu != NULLP) + { + PdcchCfg *pdcchInfo = NULLP; + BwpCfg *bwp = NULLP; + + memset(&dlTtiReqPdu->pdu.pdcch_pdu, 0, sizeof(fapi_dl_pdcch_pdu_t)); + if(rntiType == SI_RNTI_TYPE) + { + pdcchInfo = dlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdcchCfg; + bwp = &dlSlot->dlInfo.brdcstAlloc.sib1Alloc.bwp; + fillSib1DlDciPdu(dlTtiReqPdu->pdu.pdcch_pdu.dlDci, pdcchInfo); + } + else if(rntiType == RA_RNTI_TYPE) + { + pdcchInfo = dlSlot->dlInfo.rarAlloc[ueIdx]->rarPdcchCfg; + bwp = &dlSlot->dlInfo.rarAlloc[ueIdx]->bwp; + fillRarDlDciPdu(dlTtiReqPdu->pdu.pdcch_pdu.dlDci, pdcchInfo); + } + else if(rntiType == TC_RNTI_TYPE || rntiType == C_RNTI_TYPE) + { + pdcchInfo = dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdcchCfg; + bwp = &dlSlot->dlInfo.dlMsgAlloc[ueIdx]->bwp; + fillDlMsgDlDciPdu(dlTtiReqPdu->pdu.pdcch_pdu.dlDci, pdcchInfo,\ + dlSlot->dlInfo.dlMsgAlloc[ueIdx]); + } + else + { + DU_LOG("\nERROR --> LWR_MAC: Failed filling PDCCH Pdu"); + return RFAILED; + } + + dlTtiReqPdu->pduType = PDCCH_PDU_TYPE; + dlTtiReqPdu->pdu.pdcch_pdu.bwpSize = bwp->freqAlloc.numPrb; + dlTtiReqPdu->pdu.pdcch_pdu.bwpStart = bwp->freqAlloc.startPrb; + dlTtiReqPdu->pdu.pdcch_pdu.subCarrierSpacing = bwp->subcarrierSpacing; + dlTtiReqPdu->pdu.pdcch_pdu.cyclicPrefix = bwp->cyclicPrefix; + + dlTtiReqPdu->pdu.pdcch_pdu.startSymbolIndex = pdcchInfo->coresetCfg.startSymbolIndex; + dlTtiReqPdu->pdu.pdcch_pdu.durationSymbols = pdcchInfo->coresetCfg.durationSymbols; + memcpy(dlTtiReqPdu->pdu.pdcch_pdu.freqDomainResource, pdcchInfo->coresetCfg.freqDomainResource, 6); + dlTtiReqPdu->pdu.pdcch_pdu.cceRegMappingType = pdcchInfo->coresetCfg.cceRegMappingType; + dlTtiReqPdu->pdu.pdcch_pdu.regBundleSize = pdcchInfo->coresetCfg.regBundleSize; + dlTtiReqPdu->pdu.pdcch_pdu.interleaverSize = pdcchInfo->coresetCfg.interleaverSize; + dlTtiReqPdu->pdu.pdcch_pdu.shiftIndex = pdcchInfo->coresetCfg.shiftIndex; + dlTtiReqPdu->pdu.pdcch_pdu.precoderGranularity = pdcchInfo->coresetCfg.precoderGranularity; + dlTtiReqPdu->pdu.pdcch_pdu.numDlDci = pdcchInfo->numDlDci; + dlTtiReqPdu->pdu.pdcch_pdu.coreSetType = coreSetType; + + /* Calculating PDU length. Considering only one dl dci pdu for now */ + dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t); + + /* Filling Vendor message PDU */ + dlTtiVendorPdu->pdu_type = FAPI_PDCCH_PDU_TYPE; + dlTtiVendorPdu->pdu_size = sizeof(fapi_vendor_dl_pdcch_pdu_t); + dlTtiVendorPdu->pdu.pdcch_pdu.num_dl_dci = dlTtiReqPdu->pdu.pdcch_pdu.numDlDci; + dlTtiVendorPdu->pdu.pdcch_pdu.dl_dci[0].epre_ratio_of_pdcch_to_ssb = 0; + dlTtiVendorPdu->pdu.pdcch_pdu.dl_dci[0].epre_ratio_of_dmrs_to_ssb = 0; + } + + return ROK; +} + +/******************************************************************* + * + * @brief fills PDSCH PDU from PageAlloc required for DL TTI info in MAC + * + * @details + * + * Function : fillPagePdschPdu + * + * Functionality: + * -Fills the Pdsch PDU info + * stored in MAC + * + * @params[in] Pointer to FAPI DL TTI Req + * Pointer to PdschCfg + * Pointer to msgLen of DL TTI Info + * @return ROK + * + ******************************************************************/ +void fillPagePdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, fapi_vendor_dl_tti_req_pdu_t *dlTtiVendorPdu, DlPageAlloc *pageAlloc, + uint16_t pduIndex, MacCellCfg *macCellCfg) +{ + uint8_t idx; + + if(dlTtiReqPdu != NULLP) + { + dlTtiReqPdu->pduType = PDSCH_PDU_TYPE; + memset(&dlTtiReqPdu->pdu.pdsch_pdu, 0, sizeof(fapi_dl_pdsch_pdu_t)); + dlTtiReqPdu->pdu.pdsch_pdu.pduBitMap = 0; /* PTRS and CBG params are excluded */ + dlTtiReqPdu->pdu.pdsch_pdu.rnti = P_RNTI; + dlTtiReqPdu->pdu.pdsch_pdu.pdu_index = pduIndex; + dlTtiReqPdu->pdu.pdsch_pdu.bwpSize = pageAlloc->bwp.freqAlloc.numPrb; + dlTtiReqPdu->pdu.pdsch_pdu.bwpStart = pageAlloc->bwp.freqAlloc.startPrb; + dlTtiReqPdu->pdu.pdsch_pdu.subCarrierSpacing = pageAlloc->bwp.subcarrierSpacing; + dlTtiReqPdu->pdu.pdsch_pdu.cyclicPrefix = pageAlloc->bwp.cyclicPrefix; + dlTtiReqPdu->pdu.pdsch_pdu.nrOfCodeWords = 1; + for(idx = 0; idx < MAX_CODEWORDS ; idx++) + { + dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].targetCodeRate = 308; + dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].qamModOrder = 2; + dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].mcsIndex = pageAlloc->pageDlSch.tbInfo.mcs; + dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].mcsTable = 0; + dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].rvIndex = 0; + dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].tbSize = pageAlloc->pageDlSch.tbInfo.tbSize; + } + dlTtiReqPdu->pdu.pdsch_pdu.dataScramblingId = macCellCfg->cellCfg.phyCellId; + dlTtiReqPdu->pdu.pdsch_pdu.nrOfLayers = 1; + dlTtiReqPdu->pdu.pdsch_pdu.transmissionScheme = 0; + dlTtiReqPdu->pdu.pdsch_pdu.refPoint = 0; + dlTtiReqPdu->pdu.pdsch_pdu.dlDmrsSymbPos = DL_DMRS_SYMBOL_POS; + dlTtiReqPdu->pdu.pdsch_pdu.dmrsConfigType = pageAlloc->pageDlSch.dmrs.dmrsType; + dlTtiReqPdu->pdu.pdsch_pdu.dlDmrsScramblingId = macCellCfg->cellCfg.phyCellId; + dlTtiReqPdu->pdu.pdsch_pdu.scid = 0; + dlTtiReqPdu->pdu.pdsch_pdu.numDmrsCdmGrpsNoData = 1; + dlTtiReqPdu->pdu.pdsch_pdu.dmrsPorts = 0x0001; + dlTtiReqPdu->pdu.pdsch_pdu.resourceAlloc = 1; + /* since we are using type-1, hence rbBitmap excluded */ + dlTtiReqPdu->pdu.pdsch_pdu.rbStart = pageAlloc->pageDlSch.freqAlloc.startPrb; + dlTtiReqPdu->pdu.pdsch_pdu.rbSize = pageAlloc->pageDlSch.freqAlloc.numPrb; + dlTtiReqPdu->pdu.pdsch_pdu.vrbToPrbMapping = pageAlloc->pageDlSch.vrbPrbMapping; + dlTtiReqPdu->pdu.pdsch_pdu.startSymbIndex = pageAlloc->pageDlSch.timeAlloc.startSymb; + dlTtiReqPdu->pdu.pdsch_pdu.nrOfSymbols = pageAlloc->pageDlSch.timeAlloc.numSymb; + dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.numPrgs = 1; + dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.prgSize = 0; + dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = 0; + dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0].pmIdx = 0; + dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0].beamIdx[0].beamidx = 0; + dlTtiReqPdu->pdu.pdsch_pdu.powerControlOffset = 0; + dlTtiReqPdu->pdu.pdsch_pdu.powerControlOffsetSS = 0; + dlTtiReqPdu->pdu.pdsch_pdu.mappingType = pageAlloc->pageDlSch.timeAlloc.mappingType; + dlTtiReqPdu->pdu.pdsch_pdu.nrOfDmrsSymbols = pageAlloc->pageDlSch.dmrs.nrOfDmrsSymbols; + dlTtiReqPdu->pdu.pdsch_pdu.dmrsAddPos = pageAlloc->pageDlSch.dmrs.dmrsAddPos; + + dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdsch_pdu_t); + + /* DL TTI Request vendor message */ + dlTtiVendorPdu->pdu_type = FAPI_PDSCH_PDU_TYPE; + dlTtiVendorPdu->pdu_size = sizeof(fapi_vendor_dl_pdsch_pdu_t); + dlTtiVendorPdu->pdu.pdsch_pdu.nr_of_antenna_ports = 1; + for(int i =0; i< FAPI_VENDOR_MAX_TXRU_NUM; i++) + { + dlTtiVendorPdu->pdu.pdsch_pdu.tx_ru_idx[i] =0; + } + } +} /******************************************************************* * @@ -2495,62 +3329,73 @@ uint32_t *msgLen) * ******************************************************************/ -void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdschCfg *pdschInfo, -uint32_t *msgLen) -{ - uint8_t idx; - - if(dlTtiReqPdu != NULLP) - { - dlTtiReqPdu->pduType = PDSCH_PDU_TYPE; - dlTtiReqPdu->u.pdsch_pdu.pduBitMap = pdschInfo->pduBitmap; - dlTtiReqPdu->u.pdsch_pdu.rnti = pdschInfo->rnti; - dlTtiReqPdu->u.pdsch_pdu.pduIndex = pdschInfo->pduIndex; - dlTtiReqPdu->u.pdsch_pdu.bwpSize = pdschInfo->pdschBwpCfg.BWPSize; - dlTtiReqPdu->u.pdsch_pdu.bwpStart = pdschInfo->pdschBwpCfg.BWPStart; - dlTtiReqPdu->u.pdsch_pdu.subCarrierSpacing = pdschInfo->pdschBwpCfg.subcarrierSpacing; - dlTtiReqPdu->u.pdsch_pdu.cyclicPrefix = pdschInfo->pdschBwpCfg.cyclicPrefix; - dlTtiReqPdu->u.pdsch_pdu.nrOfCodeWords = pdschInfo->numCodewords; - for(idx = 0; idx < MAX_CODEWORDS ; idx++) - { - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].targetCodeRate = pdschInfo->codeword[idx].targetCodeRate; - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].qamModOrder = pdschInfo->codeword[idx].qamModOrder; - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsIndex = pdschInfo->codeword[idx].mcsIndex; - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsTable = pdschInfo->codeword[idx].mcsTable; - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].rvIndex = pdschInfo->codeword[idx].rvIndex; - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].tbSize = pdschInfo->codeword[idx].tbSize; - } - dlTtiReqPdu->u.pdsch_pdu.dataScramblingId = pdschInfo->dataScramblingId; - dlTtiReqPdu->u.pdsch_pdu.nrOfLayers = pdschInfo->numLayers; - dlTtiReqPdu->u.pdsch_pdu.transmissionScheme = pdschInfo->transmissionScheme; - dlTtiReqPdu->u.pdsch_pdu.refPoint = pdschInfo->refPoint; - dlTtiReqPdu->u.pdsch_pdu.dlDmrsSymbPos = pdschInfo->dmrs.dlDmrsSymbPos; - dlTtiReqPdu->u.pdsch_pdu.dmrsConfigType = pdschInfo->dmrs.dmrsConfigType; - dlTtiReqPdu->u.pdsch_pdu.dlDmrsScramblingId = pdschInfo->dmrs.dlDmrsScramblingId; - dlTtiReqPdu->u.pdsch_pdu.scid = pdschInfo->dmrs.scid; - dlTtiReqPdu->u.pdsch_pdu.numDmrsCdmGrpsNoData = pdschInfo->dmrs.numDmrsCdmGrpsNoData; - dlTtiReqPdu->u.pdsch_pdu.dmrsPorts = pdschInfo->dmrs.dmrsPorts; - dlTtiReqPdu->u.pdsch_pdu.resourceAlloc = pdschInfo->freqAlloc.resourceAlloc; - /* since we are using type-1, hence rbBitmap excluded */ - dlTtiReqPdu->u.pdsch_pdu.rbStart = pdschInfo->freqAlloc.rbStart; - dlTtiReqPdu->u.pdsch_pdu.rbSize = pdschInfo->freqAlloc.rbSize; - dlTtiReqPdu->u.pdsch_pdu.vrbToPrbMapping = pdschInfo->freqAlloc.vrbPrbMapping; - dlTtiReqPdu->u.pdsch_pdu.startSymbIndex = pdschInfo->timeAlloc.startSymbolIndex; - dlTtiReqPdu->u.pdsch_pdu.nrOfSymbols = pdschInfo->timeAlloc.numSymbols; - dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.numPrgs = pdschInfo->beamPdschInfo.numPrgs; - dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.prgSize = pdschInfo->beamPdschInfo.prgSize; - dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = pdschInfo->beamPdschInfo.digBfInterfaces; - dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \ - pmIdx = pdschInfo->beamPdschInfo.prg[0].pmIdx; - dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \ - beamIdx[0].beamidx = pdschInfo->beamPdschInfo.prg[0].beamIdx[0]; - dlTtiReqPdu->u.pdsch_pdu.powerControlOffset = pdschInfo->txPdschPower.powerControlOffset; - dlTtiReqPdu->u.pdsch_pdu.powerControlOffsetSS = pdschInfo->txPdschPower.powerControlOffsetSS; - dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdsch_pdu_t); - SETLENGTH(*msgLen, sizeof(fapi_dl_pdsch_pdu_t)); - - } +void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, fapi_vendor_dl_tti_req_pdu_t *dlTtiVendorPdu, PdschCfg *pdschInfo, + BwpCfg bwp, uint16_t pduIndex) +{ + uint8_t idx; + if(dlTtiReqPdu != NULLP) + { + dlTtiReqPdu->pduType = PDSCH_PDU_TYPE; + memset(&dlTtiReqPdu->pdu.pdsch_pdu, 0, sizeof(fapi_dl_pdsch_pdu_t)); + dlTtiReqPdu->pdu.pdsch_pdu.pduBitMap = pdschInfo->pduBitmap; + dlTtiReqPdu->pdu.pdsch_pdu.rnti = pdschInfo->rnti; + dlTtiReqPdu->pdu.pdsch_pdu.pdu_index = pduIndex; + dlTtiReqPdu->pdu.pdsch_pdu.bwpSize = bwp.freqAlloc.numPrb; + dlTtiReqPdu->pdu.pdsch_pdu.bwpStart = bwp.freqAlloc.startPrb; + dlTtiReqPdu->pdu.pdsch_pdu.subCarrierSpacing = bwp.subcarrierSpacing; + dlTtiReqPdu->pdu.pdsch_pdu.cyclicPrefix = bwp.cyclicPrefix; + dlTtiReqPdu->pdu.pdsch_pdu.nrOfCodeWords = pdschInfo->numCodewords; + for(idx = 0; idx < MAX_CODEWORDS ; idx++) + { + dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].targetCodeRate = pdschInfo->codeword[idx].targetCodeRate; + dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].qamModOrder = pdschInfo->codeword[idx].qamModOrder; + dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].mcsIndex = pdschInfo->codeword[idx].mcsIndex; + dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].mcsTable = pdschInfo->codeword[idx].mcsTable; + dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].rvIndex = pdschInfo->codeword[idx].rvIndex; + dlTtiReqPdu->pdu.pdsch_pdu.cwInfo[idx].tbSize = pdschInfo->codeword[idx].tbSize; + } + dlTtiReqPdu->pdu.pdsch_pdu.dataScramblingId = pdschInfo->dataScramblingId; + dlTtiReqPdu->pdu.pdsch_pdu.nrOfLayers = pdschInfo->numLayers; + dlTtiReqPdu->pdu.pdsch_pdu.transmissionScheme = pdschInfo->transmissionScheme; + dlTtiReqPdu->pdu.pdsch_pdu.refPoint = pdschInfo->refPoint; + dlTtiReqPdu->pdu.pdsch_pdu.dlDmrsSymbPos = pdschInfo->dmrs.dlDmrsSymbPos; + dlTtiReqPdu->pdu.pdsch_pdu.dmrsConfigType = pdschInfo->dmrs.dmrsConfigType; + dlTtiReqPdu->pdu.pdsch_pdu.dlDmrsScramblingId = pdschInfo->dmrs.dlDmrsScramblingId; + dlTtiReqPdu->pdu.pdsch_pdu.scid = pdschInfo->dmrs.scid; + dlTtiReqPdu->pdu.pdsch_pdu.numDmrsCdmGrpsNoData = pdschInfo->dmrs.numDmrsCdmGrpsNoData; + dlTtiReqPdu->pdu.pdsch_pdu.dmrsPorts = pdschInfo->dmrs.dmrsPorts; + dlTtiReqPdu->pdu.pdsch_pdu.resourceAlloc = pdschInfo->pdschFreqAlloc.resourceAllocType; + /* since we are using type-1, hence rbBitmap excluded */ + dlTtiReqPdu->pdu.pdsch_pdu.rbStart = pdschInfo->pdschFreqAlloc.startPrb; + dlTtiReqPdu->pdu.pdsch_pdu.rbSize = pdschInfo->pdschFreqAlloc.numPrb; + dlTtiReqPdu->pdu.pdsch_pdu.vrbToPrbMapping = pdschInfo->pdschFreqAlloc.vrbPrbMapping; + dlTtiReqPdu->pdu.pdsch_pdu.startSymbIndex = pdschInfo->pdschTimeAlloc.startSymb; + dlTtiReqPdu->pdu.pdsch_pdu.nrOfSymbols = pdschInfo->pdschTimeAlloc.numSymb; + dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.numPrgs = pdschInfo->beamPdschInfo.numPrgs; + dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.prgSize = pdschInfo->beamPdschInfo.prgSize; + dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = pdschInfo->beamPdschInfo.digBfInterfaces; + dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \ + pmIdx = pdschInfo->beamPdschInfo.prg[0].pmIdx; + dlTtiReqPdu->pdu.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \ + beamIdx[0].beamidx = pdschInfo->beamPdschInfo.prg[0].beamIdx[0]; + dlTtiReqPdu->pdu.pdsch_pdu.powerControlOffset = pdschInfo->txPdschPower.powerControlOffset; + dlTtiReqPdu->pdu.pdsch_pdu.powerControlOffsetSS = pdschInfo->txPdschPower.powerControlOffsetSS; + dlTtiReqPdu->pdu.pdsch_pdu.mappingType = pdschInfo->dmrs.mappingType; + dlTtiReqPdu->pdu.pdsch_pdu.nrOfDmrsSymbols = pdschInfo->dmrs.nrOfDmrsSymbols; + dlTtiReqPdu->pdu.pdsch_pdu.dmrsAddPos = pdschInfo->dmrs.dmrsAddPos; + + dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdsch_pdu_t); + + /* DL TTI Request vendor message */ + dlTtiVendorPdu->pdu_type = FAPI_PDSCH_PDU_TYPE; + dlTtiVendorPdu->pdu_size = sizeof(fapi_vendor_dl_pdsch_pdu_t); + dlTtiVendorPdu->pdu.pdsch_pdu.nr_of_antenna_ports = 1; + for(int i =0; i< FAPI_VENDOR_MAX_TXRU_NUM; i++) + { + dlTtiVendorPdu->pdu.pdsch_pdu.tx_ru_idx[i] =0; + } + } } /*********************************************************************** @@ -2559,316 +3404,765 @@ uint32_t *msgLen) * * @details * - * Function : calculatePduCount + * Function : calcDlTtiReqPduCount * * Functionality: * -calculates the total pdu count to be allocated for DL TTI Req * - * @params[in] DlBrdcstAlloc *cellBroadcastInfo + * @params[in] MacDlSlot *dlSlot * @return count * * ********************************************************************/ -uint8_t calculatePduCount(DlAlloc *dlInfo) +uint8_t calcDlTtiReqPduCount(MacDlSlot *dlSlot) { uint8_t count = 0; - uint8_t idx = 0; - if(dlInfo->isBroadcastPres) - { - if(dlInfo->brdcstAlloc.ssbTrans) + uint8_t idx = 0, ueIdx=0; + + if(dlSlot->dlInfo.isBroadcastPres) + { + if(dlSlot->dlInfo.brdcstAlloc.ssbTransmissionMode) { - for(idx = 0; idx < dlInfo->brdcstAlloc.ssbIdxSupported; idx++) + for(idx = 0; idx < dlSlot->dlInfo.brdcstAlloc.ssbIdxSupported; idx++) { + /* SSB PDU is filled */ count++; } } - if(dlInfo->brdcstAlloc.sib1Trans) + if(dlSlot->dlInfo.brdcstAlloc.sib1TransmissionMode) { + /* PDCCH and PDSCH PDU is filled */ count += 2; } } - if(dlInfo->isRarPres) - { - count += 2; - } - return count; + + if(dlSlot->pageAllocInfo) + { + /* PDCCH and PDSCH PDU is filled */ + count += 2; + } + + for(ueIdx=0; ueIdxdlInfo.rarAlloc[ueIdx] != NULLP) + { + /* PDCCH and PDSCH PDU is filled */ + if(dlSlot->dlInfo.rarAlloc[ueIdx]->rarPdschCfg && dlSlot->dlInfo.rarAlloc[ueIdx]->rarPdcchCfg) + count += 2; + else + count += 1; + } + + if(dlSlot->dlInfo.dlMsgAlloc[ueIdx] != NULLP) + { + /* PDCCH and PDSCH PDU is filled */ + if(dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdcchCfg) + count += 1; + if(dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdschCfg) + count += 1; + } + } + return count; +} + +/*********************************************************************** + * + * @brief calculates the total size to be allocated for DL TTI Req + * + * @details + * + * Function : calcTxDataReqPduCount + * + * Functionality: + * -calculates the total pdu count to be allocated for DL TTI Req + * + * @params[in] DlBrdcstAlloc *cellBroadcastInfo + * @return count + * + * ********************************************************************/ +uint8_t calcTxDataReqPduCount(MacDlSlot *dlSlot) +{ + uint8_t count = 0, ueIdx=0; + + if(dlSlot->dlInfo.isBroadcastPres && dlSlot->dlInfo.brdcstAlloc.sib1TransmissionMode) + { + count++; + } + if(dlSlot->pageAllocInfo) + { + count++; + } + + for(ueIdx=0; ueIdxdlInfo.rarAlloc[ueIdx] != NULLP) && (dlSlot->dlInfo.rarAlloc[ueIdx]->rarPdschCfg)) + count++; + + if(dlSlot->dlInfo.dlMsgAlloc[ueIdx] != NULLP) + { + if(dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdschCfg) + count++; + } + } + return count; +} + +/*********************************************************************** + * + * @brief fills the SIB1 TX-DATA request message + * + * @details + * + * Function : fillSib1TxDataReq + * + * Functionality: + * - fills the SIB1 TX-DATA request message + * + * @params[in] fapi_tx_pdu_desc_t *pduDesc + * @params[in] macCellCfg consist of SIB1 pdu + * @params[in] uint32_t *msgLen + * @params[in] uint16_t pduIndex + * @return ROK + * + * ********************************************************************/ +uint8_t fillSib1TxDataReq(fapi_tx_pdu_desc_t *pduDesc, uint16_t pduIndex, MacCellCfg *macCellCfg, + PdschCfg *pdschCfg) +{ + uint32_t payloadSize = 0; + uint8_t *sib1Payload = NULLP; + fapi_api_queue_elem_t *payloadElem = NULLP; +#ifdef INTEL_WLS_MEM + void * wlsHdlr = NULLP; +#endif + + pduDesc[pduIndex].pdu_index = pduIndex; + pduDesc[pduIndex].num_tlvs = 1; + + /* fill the TLV */ + payloadSize = pdschCfg->codeword[0].tbSize; + pduDesc[pduIndex].tlvs[0].tl.tag = ((payloadSize & 0xff0000) >> 8) | FAPI_TX_DATA_PTR_TO_PAYLOAD_64; + pduDesc[pduIndex].tlvs[0].tl.length = (payloadSize & 0x0000ffff); + LWR_MAC_ALLOC(sib1Payload, payloadSize); + if(sib1Payload == NULLP) + { + return RFAILED; + } + payloadElem = (fapi_api_queue_elem_t *)sib1Payload; + FILL_FAPI_LIST_ELEM(payloadElem, NULLP, FAPI_VENDOR_MSG_PHY_ZBC_BLOCK_REQ, 1, \ + macCellCfg->cellCfg.sib1Cfg.sib1PduLen); + memcpy(sib1Payload + TX_PAYLOAD_HDR_LEN, macCellCfg->cellCfg.sib1Cfg.sib1Pdu, macCellCfg->cellCfg.sib1Cfg.sib1PduLen); + +#ifdef INTEL_WLS_MEM + mtGetWlsHdl(&wlsHdlr); + pduDesc[pduIndex].tlvs[0].value = (uint8_t *)(WLS_VA2PA(wlsHdlr, sib1Payload)); +#else + pduDesc[pduIndex].tlvs[0].value = sib1Payload; +#endif + pduDesc[pduIndex].pdu_length = payloadSize; + +#ifdef INTEL_WLS_MEM + addWlsBlockToFree(sib1Payload, payloadSize, (lwrMacCb.phySlotIndCntr-1)); +#else + LWR_MAC_FREE(sib1Payload, payloadSize); +#endif + + return ROK; +} + +/*********************************************************************** + * + * @brief fills the PAGE TX-DATA request message + * + * @details + * + * Function : fillPageTxDataReq + * + * Functionality: + * - fills the Page TX-DATA request message + * + * @params[in] fapi_tx_pdu_desc_t *pduDesc + * @params[in] macCellCfg consist of SIB1 pdu + * @params[in] uint32_t *msgLen + * @params[in] uint16_t pduIndex + * @return ROK + * + * ********************************************************************/ +uint8_t fillPageTxDataReq(fapi_tx_pdu_desc_t *pduDesc, uint16_t pduIndex, DlPageAlloc *pageAllocInfo) +{ + uint32_t payloadSize = 0; + uint8_t *pagePayload = NULLP; + fapi_api_queue_elem_t *payloadElem = NULLP; +#ifdef INTEL_WLS_MEM + void * wlsHdlr = NULLP; +#endif + + pduDesc[pduIndex].pdu_index = pduIndex; + pduDesc[pduIndex].num_tlvs = 1; + + /* fill the TLV */ + payloadSize = pageAllocInfo->pageDlSch.tbInfo.tbSize; + pduDesc[pduIndex].tlvs[0].tl.tag = ((payloadSize & 0xff0000) >> 8) | FAPI_TX_DATA_PTR_TO_PAYLOAD_64; + pduDesc[pduIndex].tlvs[0].tl.length = (payloadSize & 0x0000ffff); + LWR_MAC_ALLOC(pagePayload, payloadSize); + if(pagePayload == NULLP) + { + return RFAILED; + } + payloadElem = (fapi_api_queue_elem_t *)pagePayload; + FILL_FAPI_LIST_ELEM(payloadElem, NULLP, FAPI_VENDOR_MSG_PHY_ZBC_BLOCK_REQ, 1, \ + pageAllocInfo->pageDlSch.dlPagePduLen); + memcpy(pagePayload + TX_PAYLOAD_HDR_LEN, pageAllocInfo->pageDlSch.dlPagePdu, pageAllocInfo->pageDlSch.dlPagePduLen); + +#ifdef INTEL_WLS_MEM + mtGetWlsHdl(&wlsHdlr); + pduDesc[pduIndex].tlvs[0].value = (uint8_t *)(WLS_VA2PA(wlsHdlr, pagePayload)); +#else + pduDesc[pduIndex].tlvs[0].value = pagePayload; +#endif + pduDesc[pduIndex].pdu_length = payloadSize; + +#ifdef INTEL_WLS_MEM + addWlsBlockToFree(pagePayload, payloadSize, (lwrMacCb.phySlotIndCntr-1)); +#else + LWR_MAC_FREE(pagePayload, payloadSize); +#endif + + return ROK; +} + +/*********************************************************************** + * + * @brief fills the RAR TX-DATA request message + * + * @details + * + * Function : fillRarTxDataReq + * + * Functionality: + * - fills the RAR TX-DATA request message + * + * @params[in] fapi_tx_pdu_desc_t *pduDesc + * @params[in] RarInfo *rarInfo + * @params[in] uint32_t *msgLen + * @params[in] uint16_t pduIndex + * @return ROK + * + * ********************************************************************/ +uint8_t fillRarTxDataReq(fapi_tx_pdu_desc_t *pduDesc, uint16_t pduIndex, RarInfo *rarInfo, PdschCfg *pdschCfg) +{ + uint16_t payloadSize; + uint8_t *rarPayload = NULLP; + fapi_api_queue_elem_t *payloadElem = NULLP; +#ifdef INTEL_WLS_MEM + void * wlsHdlr = NULLP; +#endif + + pduDesc[pduIndex].pdu_index = pduIndex; + pduDesc[pduIndex].num_tlvs = 1; + + /* fill the TLV */ + payloadSize = pdschCfg->codeword[0].tbSize; + pduDesc[pduIndex].tlvs[0].tl.tag = FAPI_TX_DATA_PTR_TO_PAYLOAD_64; + pduDesc[pduIndex].tlvs[0].tl.length = payloadSize; + LWR_MAC_ALLOC(rarPayload, payloadSize); + if(rarPayload == NULLP) + { + return RFAILED; + } + payloadElem = (fapi_api_queue_elem_t *)rarPayload; + FILL_FAPI_LIST_ELEM(payloadElem, NULLP, FAPI_VENDOR_MSG_PHY_ZBC_BLOCK_REQ, 1, rarInfo->rarPduLen); + memcpy(rarPayload + TX_PAYLOAD_HDR_LEN, rarInfo->rarPdu, rarInfo->rarPduLen); + +#ifdef INTEL_WLS_MEM + mtGetWlsHdl(&wlsHdlr); + pduDesc[pduIndex].tlvs[0].value = (uint8_t *)(WLS_VA2PA(wlsHdlr, rarPayload)); +#else + pduDesc[pduIndex].tlvs[0].value = rarPayload; +#endif + pduDesc[pduIndex].pdu_length = payloadSize; + +#ifdef INTEL_WLS_MEM + addWlsBlockToFree(rarPayload, payloadSize, (lwrMacCb.phySlotIndCntr-1)); +#else + LWR_MAC_FREE(rarPayload, payloadSize); +#endif + return ROK; } /*********************************************************************** * - * @brief fills the SIB1 TX-DATA request message + * @brief fills the DL dedicated Msg TX-DATA request message * * @details * - * Function : fillSib1TxDataReq + * Function : fillDlMsgTxDataReq * * Functionality: - * - fills the SIB1 TX-DATA request message + * - fills the Dl Dedicated Msg TX-DATA request message * * @params[in] fapi_tx_pdu_desc_t *pduDesc - * @params[in] MacCellCfg *macCellCfg - * @params[in] uint16_t pduIndex + * @params[in] DlMsgInfo *dlMsgInfo * @params[in] uint32_t *msgLen + * @params[in] uint16_t pduIndex * @return ROK * * ********************************************************************/ -uint8_t fillSib1TxDataReq(fapi_tx_pdu_desc_t *pduDesc,MacCellCfg *macCellCfg, - uint16_t pduIndex, uint32_t *msgLen) -{ - uint32_t pduLen = 0; - uint32_t *sib1TxdataValue = NULLP; - - pduDesc->pduIndex = pduIndex; - pduDesc->numTlvs = 1; - - /* fill the TLV */ - /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */ - pduDesc->tlvs[0].tl.tag = 1; /* pointer to be sent */ - pduDesc->tlvs[0].tl.length = macCellCfg->sib1Cfg.sib1PduLen; - LWR_MAC_ALLOC(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen); - if(sib1TxdataValue == NULLP) - { - return RFAILED; - } - memcpy(sib1TxdataValue,macCellCfg->sib1Cfg.sib1Pdu, - macCellCfg->sib1Cfg.sib1PduLen); - pduDesc->tlvs[0].value = sib1TxdataValue; - - /* The total length of the PDU description and PDU data */ - pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */ - pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */ - pduDesc->pduLength = pduLen; - msgLen += pduLen; - -#ifndef INTEL_WLS - MAC_FREE(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen); +uint8_t fillDlMsgTxDataReq(fapi_tx_pdu_desc_t *pduDesc, uint16_t pduIndex, DlMsgSchInfo *dlMsgSchInfo, PdschCfg *pdschCfg) +{ + uint16_t payloadSize; + uint8_t *dlMsgPayload = NULLP; + fapi_api_queue_elem_t *payloadElem = NULLP; +#ifdef INTEL_WLS_MEM + void * wlsHdlr = NULLP; #endif + pduDesc[pduIndex].pdu_index = pduIndex; + pduDesc[pduIndex].num_tlvs = 1; - return ROK; + /* fill the TLV */ + payloadSize = pdschCfg->codeword[0].tbSize; + pduDesc[pduIndex].tlvs[0].tl.tag = FAPI_TX_DATA_PTR_TO_PAYLOAD_64; + pduDesc[pduIndex].tlvs[0].tl.length = payloadSize; + LWR_MAC_ALLOC(dlMsgPayload, payloadSize); + if(dlMsgPayload == NULLP) + { + return RFAILED; + } + payloadElem = (fapi_api_queue_elem_t *)dlMsgPayload; + FILL_FAPI_LIST_ELEM(payloadElem, NULLP, FAPI_VENDOR_MSG_PHY_ZBC_BLOCK_REQ, 1, dlMsgSchInfo->dlMsgPduLen); + memcpy(dlMsgPayload + TX_PAYLOAD_HDR_LEN, dlMsgSchInfo->dlMsgPdu, dlMsgSchInfo->dlMsgPduLen); + +#ifdef INTEL_WLS_MEM + mtGetWlsHdl(&wlsHdlr); + pduDesc[pduIndex].tlvs[0].value = (uint8_t *)(WLS_VA2PA(wlsHdlr, dlMsgPayload)); +#else + pduDesc[pduIndex].tlvs[0].value = dlMsgPayload; +#endif + pduDesc[pduIndex].pdu_length = payloadSize; + +#ifdef INTEL_WLS_MEM + addWlsBlockToFree(dlMsgPayload, payloadSize, (lwrMacCb.phySlotIndCntr-1)); +#else + LWR_MAC_FREE(dlMsgPayload, payloadSize); +#endif + return ROK; } -/*********************************************************************** +#endif /* FAPI */ + +/******************************************************************* * - * @brief fills the RAR TX-DATA request message + * @brief Sends DL TTI Request to PHY * * @details * - * Function : fillRarTxDataReq + * Function : fillDlTtiReq * * Functionality: - * - fills the RAR TX-DATA request message + * -Sends FAPI DL TTI req to PHY * - * @params[in] fapi_tx_pdu_desc_t *pduDesc - * @params[in] RarInfo *rarInfo - * @params[in] uint16_t pduIndex - * @params[in] uint32_t *msgLen - * @return ROK + * @params[in] timing info + * @return ROK - success + * RFAILED - failure * - * ********************************************************************/ -uint8_t fillRarTxDataReq(fapi_tx_pdu_desc_t *pduDesc, RarInfo *rarInfo, - uint16_t pduIndex, uint32_t *msgLen) -{ - uint32_t pduLen = 0; - uint32_t *rarTxdataValue = NULLP; - - pduDesc[pduIndex].pduIndex = pduIndex; - pduDesc[pduIndex].numTlvs = 1; - - /* fill the TLV */ - /* as of now, memory is allocated from SSI, later WLS memory needs to be taken */ - pduDesc[pduIndex].tlvs[0].tl.tag = 1; /* pointer to be sent */ - pduDesc[pduIndex].tlvs[0].tl.length = rarInfo->rarPduLen; - LWR_MAC_ALLOC(rarTxdataValue,rarInfo->rarPduLen); - if(rarTxdataValue == NULLP) - { - return RFAILED; - } - memcpy(rarTxdataValue,rarInfo->rarPdu,rarInfo->rarPduLen); - pduDesc[pduIndex].tlvs[0].value = (uint32_t)rarTxdataValue; - - /* The total length of the PDU description and PDU data */ - pduLen += 8; /* size of PDU length 2 bytes, PDU index 2 bytes, numTLV 4 bytes */ - pduLen += sizeof(fapi_uint32_tlv_t); /* only 1 TLV is present */ - pduDesc[pduIndex].pduLength = pduLen; - msgLen += pduLen; - -/* TODO: The pointer value which was stored, needs to be free-ed at PHY * - * But since we did not implement WLS, this has to be done here - */ -#ifndef INTEL_WLS - MAC_FREE(rarTxdataValue,rarInfo->rarPduLen); + * ****************************************************************/ +uint16_t fillDlTtiReq(SlotTimingInfo currTimingInfo) +{ +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : DL_TTI_REQUEST\n"); #endif - return ROK; -} +#ifdef INTEL_FAPI + uint8_t idx =0; + uint8_t nPdu = 0; + uint8_t numPduEncoded = 0; + uint8_t ueIdx; + uint16_t cellIdx =0; + uint16_t pduIndex = 0; + + SlotTimingInfo dlTtiReqTimingInfo; + MacDlSlot *currDlSlot = NULLP; + MacCellCfg macCellCfg; + RntiType rntiType; + fapi_dl_tti_req_t *dlTtiReq = NULLP; + fapi_msg_header_t *msgHeader = NULLP; + p_fapi_api_queue_elem_t dlTtiElem; + p_fapi_api_queue_elem_t headerElem; + p_fapi_api_queue_elem_t prevElem; + if(lwrMacCb.phyState == PHY_STATE_RUNNING) + { + GET_CELL_IDX(currTimingInfo.cellId, cellIdx); + /* consider phy delay */ + ADD_DELTA_TO_TIME(currTimingInfo,dlTtiReqTimingInfo,PHY_DELTA_DL, macCb.macCell[cellIdx]->numOfSlots); + dlTtiReqTimingInfo.cellId = currTimingInfo.cellId; + + macCellCfg = macCb.macCell[cellIdx]->macCellCfg; + + currDlSlot = &macCb.macCell[cellIdx]->dlSlot[dlTtiReqTimingInfo.slot]; + + /* Vendor Message */ + fapi_vendor_msg_t *vendorMsg; + p_fapi_api_queue_elem_t vendorMsgQElem; + /* Allocte And fill Vendor msg */ + LWR_MAC_ALLOC(vendorMsgQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t))); + if(!vendorMsgQElem) + { + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req"); + return RFAILED; + } + FILL_FAPI_LIST_ELEM(vendorMsgQElem, NULLP, FAPI_VENDOR_MESSAGE, 1, sizeof(fapi_vendor_msg_t)); + vendorMsg = (fapi_vendor_msg_t *)(vendorMsgQElem + 1); + fillMsgHeader(&vendorMsg->header, FAPI_VENDOR_MESSAGE, sizeof(fapi_vendor_msg_t)); + + LWR_MAC_ALLOC(dlTtiElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_dl_tti_req_t))); + if(dlTtiElem) + { + FILL_FAPI_LIST_ELEM(dlTtiElem, NULLP, FAPI_DL_TTI_REQUEST, 1, \ + sizeof(fapi_dl_tti_req_t)); + /* Fill message header */ + LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t))); + if(!headerElem) + { + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for header in DL TTI req"); + LWR_MAC_FREE(dlTtiElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_dl_tti_req_t))); + return RFAILED; + } + + FILL_FAPI_LIST_ELEM(headerElem, dlTtiElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \ + sizeof(fapi_msg_header_t)); + msgHeader = (fapi_msg_header_t *)(headerElem + 1); + msgHeader->num_msg = 2; + msgHeader->handle = 0; + + /* Fill Dl TTI Request */ + dlTtiReq = (fapi_dl_tti_req_t *)(dlTtiElem +1); + memset(dlTtiReq, 0, sizeof(fapi_dl_tti_req_t)); + fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, sizeof(fapi_dl_tti_req_t)); + + dlTtiReq->sfn = dlTtiReqTimingInfo.sfn; + dlTtiReq->slot = dlTtiReqTimingInfo.slot; + dlTtiReq->nPdus = calcDlTtiReqPduCount(currDlSlot); /* get total Pdus */ + nPdu = dlTtiReq->nPdus; + + vendorMsg->p7_req_vendor.dl_tti_req.num_pdus = nPdu; + vendorMsg->p7_req_vendor.dl_tti_req.sym = 0; + + dlTtiReq->nGroup = 0; + if(dlTtiReq->nPdus > 0) + { + if(currDlSlot->dlInfo.isBroadcastPres) + { + if(currDlSlot->dlInfo.brdcstAlloc.ssbTransmissionMode) + { + if(dlTtiReq->pdus != NULLP) + { + for(idx = 0; idx < currDlSlot->dlInfo.brdcstAlloc.ssbIdxSupported; idx++) + { + fillSsbPdu(&dlTtiReq->pdus[numPduEncoded], &macCellCfg,\ + currDlSlot, idx, dlTtiReq->sfn); + numPduEncoded++; + } + } + DU_LOG("\033[1;31m"); + DU_LOG("\nDEBUG --> LWR_MAC: MIB sent.."); + DU_LOG("\033[0m"); + } + + if(currDlSlot->dlInfo.brdcstAlloc.sib1TransmissionMode) + { + /* Filling SIB1 param */ + if(numPduEncoded != nPdu) + { + if(currDlSlot->dlInfo.brdcstAlloc.crnti == SI_RNTI) + rntiType = SI_RNTI_TYPE; + + /* PDCCH PDU */ + fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], &vendorMsg->p7_req_vendor.dl_tti_req.pdus[numPduEncoded], + currDlSlot, -1, rntiType, CORESET_TYPE0, MAX_NUM_UE); + numPduEncoded++; + + /* PDSCH PDU */ + fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], &vendorMsg->p7_req_vendor.dl_tti_req.pdus[numPduEncoded], + &currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdcchCfg->dci.pdschCfg, + currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.bwp, + pduIndex); + dlTtiReq->ue_grp_info[dlTtiReq->nGroup].pduIdx[pduIndex] = pduIndex; + pduIndex++; + numPduEncoded++; + } + DU_LOG("\033[1;34m"); + DU_LOG("\nDEBUG --> LWR_MAC: SIB1 sent..."); + DU_LOG("\033[0m"); + } + } + + if(currDlSlot->pageAllocInfo != NULLP) + { + /* Filling DL Paging Alloc param */ + if(numPduEncoded != nPdu) + { + rntiType = P_RNTI_TYPE; + fillPagePdcchPdu(&dlTtiReq->pdus[numPduEncoded], &vendorMsg->p7_req_vendor.dl_tti_req.pdus[numPduEncoded], \ + currDlSlot->pageAllocInfo, &macCellCfg); + numPduEncoded++; + fillPagePdschPdu(&dlTtiReq->pdus[numPduEncoded], &vendorMsg->p7_req_vendor.dl_tti_req.pdus[numPduEncoded], + currDlSlot->pageAllocInfo, pduIndex, &macCellCfg); + dlTtiReq->ue_grp_info[dlTtiReq->nGroup].pduIdx[pduIndex] = pduIndex; + pduIndex++; + numPduEncoded++; + } + DU_LOG("\033[1;34m"); + DU_LOG("\nDEBUG --> LWR_MAC: PAGE sent..."); + DU_LOG("\033[0m"); + } + + for(ueIdx=0; ueIdxdlInfo.rarAlloc[ueIdx] != NULLP) + { + /* Filling RAR param */ + rntiType = RA_RNTI_TYPE; + if(currDlSlot->dlInfo.rarAlloc[ueIdx]->rarPdcchCfg) + { + fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], &vendorMsg->p7_req_vendor.dl_tti_req.pdus[numPduEncoded], + currDlSlot, -1, rntiType, CORESET_TYPE0, ueIdx); + numPduEncoded++; + MAC_FREE(currDlSlot->dlInfo.rarAlloc[ueIdx]->rarPdcchCfg, sizeof(PdcchCfg)); + } + if(currDlSlot->dlInfo.rarAlloc[ueIdx]->rarPdschCfg) + { + fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], &vendorMsg->p7_req_vendor.dl_tti_req.pdus[numPduEncoded], + currDlSlot->dlInfo.rarAlloc[ueIdx]->rarPdschCfg, + currDlSlot->dlInfo.rarAlloc[ueIdx]->bwp, + pduIndex); + numPduEncoded++; + pduIndex++; + + DU_LOG("\033[1;32m"); + DU_LOG("\nDEBUG --> LWR_MAC: RAR sent..."); + DU_LOG("\033[0m"); + } + } + + if(currDlSlot->dlInfo.dlMsgAlloc[ueIdx] != NULLP) + { + if(currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdcchCfg) \ + { + rntiType = C_RNTI_TYPE; + fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], &vendorMsg->p7_req_vendor.dl_tti_req.pdus[numPduEncoded], + currDlSlot, idx, rntiType, currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdcchCfg->coresetCfg.coreSetType, ueIdx); + numPduEncoded++; + } + + if(currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdu != NULLP) + { + if(currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdschCfg) + { + fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], &vendorMsg->p7_req_vendor.dl_tti_req.pdus[numPduEncoded], \ + currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdschCfg,\ + currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->bwp, pduIndex); + numPduEncoded++; + pduIndex++; + + DU_LOG("\033[1;32m"); + if((macCb.macCell[cellIdx]->macRaCb[ueIdx].macMsg4Status)) + { + DU_LOG("\nDEBUG --> LWR_MAC: MSG4 sent..."); + MAC_FREE(macCb.macCell[cellIdx]->macRaCb[ueIdx].macMsg4Status, sizeof(bool)); + } + else + { + DU_LOG("\nDEBUG --> LWR_MAC: DL MSG sent..."); + } + DU_LOG("\033[0m"); + } + } + MAC_FREE(currDlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdcchCfg,sizeof(PdcchCfg)); + /* else + { + MAC_FREE(currDlSlot->dlInfo.dlMsgAlloc[ueIdx], sizeof(DlMsgAlloc)); + currDlSlot->dlInfo.dlMsgAlloc[ueIdx] = NULLP; + } + */ + } + } + + dlTtiReq->ue_grp_info[dlTtiReq->nGroup].nUe = MAX_NUM_UE_PER_TTI; + dlTtiReq->nGroup++; + +#ifdef ODU_SLOT_IND_DEBUG_LOG + DU_LOG("\nDEBUG --> LWR_MAC: Sending DL TTI Request"); +#endif + + /* Intel L1 expects UL_TTI.request following DL_TTI.request */ + fillUlTtiReq(currTimingInfo, dlTtiElem, &(vendorMsg->p7_req_vendor.ul_tti_req)); + msgHeader->num_msg++; + + /* Intel L1 expects UL_DCI.request following DL_TTI.request */ + fillUlDciReq(dlTtiReqTimingInfo, dlTtiElem->p_next, &(vendorMsg->p7_req_vendor.ul_dci_req)); + msgHeader->num_msg++; + + /* send Tx-DATA req message */ + sendTxDataReq(dlTtiReqTimingInfo, currDlSlot, dlTtiElem->p_next->p_next, &(vendorMsg->p7_req_vendor.tx_data_req)); + if(dlTtiElem->p_next->p_next->p_next) + { + msgHeader->num_msg++; + prevElem = dlTtiElem->p_next->p_next->p_next; + } + else + prevElem = dlTtiElem->p_next->p_next; + } + else + { +#ifdef ODU_SLOT_IND_DEBUG_LOG + DU_LOG("\nDEBUG --> LWR_MAC: Sending DL TTI Request"); +#endif + /* Intel L1 expects UL_TTI.request following DL_TTI.request */ + fillUlTtiReq(currTimingInfo, dlTtiElem, &(vendorMsg->p7_req_vendor.ul_tti_req)); + msgHeader->num_msg++; + + /* Intel L1 expects UL_DCI.request following DL_TTI.request */ + fillUlDciReq(dlTtiReqTimingInfo, dlTtiElem->p_next, &(vendorMsg->p7_req_vendor.ul_dci_req)); + msgHeader->num_msg++; + + prevElem = dlTtiElem->p_next->p_next; + } + + if(macCb.macCell[cellIdx]->state == CELL_TO_BE_STOPPED) + { + /* Intel L1 expects UL_DCI.request following DL_TTI.request */ + lwr_mac_procStopReqEvt(currTimingInfo, prevElem, &(vendorMsg->stop_req_vendor)); + msgHeader->num_msg++; + macCb.macCell[cellIdx]->state = CELL_STOP_IN_PROGRESS; + prevElem = prevElem->p_next; + } + prevElem->p_next = vendorMsgQElem; + LwrMacSendToL1(headerElem); + memset(currDlSlot, 0, sizeof(MacDlSlot)); + return ROK; + } + else + { + DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for DL TTI Request"); + memset(currDlSlot, 0, sizeof(MacDlSlot)); + return RFAILED; + } + } + else + { + lwr_mac_procInvalidEvt(&currTimingInfo); + return RFAILED; + } #endif + return ROK; +} /******************************************************************* * - * @brief Sends DL TTI Request to PHY + * @brief Sends TX data Request to PHY * * @details * - * Function : handleDlTtiReq + * Function : sendTxDataReq * * Functionality: - * -Sends FAPI Param req to PHY + * -Sends FAPI TX data req to PHY * - * @params[in] RgDlSf *dlTtiReqSlot + * @params[in] timing info * @return ROK - success * RFAILED - failure * * ****************************************************************/ -uint16_t handleDlTtiReq(CmLteTimingInfo *dlTtiReqtimingInfo) -{ -#ifdef FAPI - uint8_t idx; - uint8_t nPdu = 0; - uint8_t numPduEncoded = 0; - uint32_t msgLen = 0; - fapi_dl_tti_req_t *dlTtiReq = NULLP; - fapi_tx_data_req_t *txDataReq = NULLP; - RgCellCb *cellCbParams = NULLP; - MacDlSlot *currDlSlot = NULLP; - MacCellCfg macCellCfg; - memset(&macCellCfg, 0, sizeof(MacCellCfg)); - Inst inst = 0; - - if(clGlobalCp.phyState == PHY_STATE_RUNNING) - { - cellCbParams = rgCb[inst].cell; - macCellCfg = cellCbParams->macCellCfg; - - if(dlTtiReqtimingInfo != NULLP) - { - LWR_MAC_ALLOC(dlTtiReq, sizeof(fapi_dl_tti_req_t)); - if(dlTtiReq != NULLP) - { - dlTtiReq->sfn = dlTtiReqtimingInfo->sfn; - dlTtiReq->slot = dlTtiReqtimingInfo->slot; - currDlSlot = &macCb.macCell->dlSlot[dlTtiReq->slot % MAX_SLOT_SUPPORTED]; - dlTtiReq->nPdus = calculatePduCount(&currDlSlot->dlInfo); /* get total Pdus */ - nPdu = dlTtiReq->nPdus; - dlTtiReq->nGroup = 0; - if(dlTtiReq->nPdus > 0) - { - LWR_MAC_ALLOC(dlTtiReq->pdus, (nPdu * sizeof(fapi_dl_tti_req_pdu_t))); - if(!dlTtiReq->pdus) - { - DU_LOG("\nLOWER MAC: Memory allocation failed"); - return RFAILED; - } - - if(currDlSlot->dlInfo.isBroadcastPres) - { - if(currDlSlot->dlInfo.brdcstAlloc.ssbTrans) - { - if(dlTtiReq->pdus != NULLP) - { - for(idx = 0; idx < currDlSlot->dlInfo.brdcstAlloc.ssbIdxSupported; idx++) - { - if(idx > 0) - dlTtiReq->pdus++; - fillSsbPdu(&dlTtiReq->pdus[numPduEncoded], &macCellCfg, currDlSlot, &msgLen, idx); - numPduEncoded++; - } - } - DU_LOG("\nLOWER MAC: MIB sent.."); - } - if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans) - { - /* Filling SIB1 param */ - if(numPduEncoded != nPdu) - { - fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo.brdcstAlloc.\ - sib1Alloc.sib1PdcchCfg, &msgLen); - numPduEncoded++; - fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo.brdcstAlloc.\ - sib1Alloc.sib1PdschCfg, &msgLen); - numPduEncoded++; - } - DU_LOG("\nLOWER MAC: SIB1 sent..."); - } - } - if(currDlSlot->dlInfo.isRarPres) - { - /* Filling RAR param */ - fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], &currDlSlot->dlInfo.rarAlloc.rarPdcchCfg, &msgLen); - numPduEncoded++; - fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], &currDlSlot->dlInfo.rarAlloc.rarPdschCfg, &msgLen); - numPduEncoded++; - DU_LOG("\nLOWER MAC: RAR sent..."); - } - - msgLen += sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t); - fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen); - /* TODO : Recheck the size / msglen to be sent to WLS_Put*/ - LwrMacSendToPhy(dlTtiReq->header.message_type_id, msgLen, (void *)dlTtiReq); - - /* send TX_Data request message */ - if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans) - { - msgLen = 0; - LWR_MAC_ALLOC(txDataReq,sizeof(fapi_tx_data_req_t)); - txDataReq->sfn = dlTtiReqtimingInfo->sfn; - txDataReq->slot = dlTtiReqtimingInfo->slot; - txDataReq->numPdus = 1; - LWR_MAC_ALLOC(txDataReq->pduDesc, (txDataReq->numPdus * \ - sizeof(fapi_tx_pdu_desc_t))); - fillSib1TxDataReq( - txDataReq->pduDesc, - &rgCb[inst].cell->macCellCfg, - currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdschCfg.pduIndex, - &msgLen); - msgLen += sizeof(fapi_tx_data_req_t) - sizeof(fapi_msg_t); - fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, msgLen); - LwrMacSendToPhy(txDataReq->header.message_type_id, msgLen,(void *)txDataReq); - } - if(currDlSlot->dlInfo.isRarPres) - { - msgLen = 0; - /* mux and form RAR pdu */ - fillRarPdu(&currDlSlot->dlInfo.rarAlloc.rarInfo); - LWR_MAC_ALLOC(txDataReq,sizeof(fapi_tx_data_req_t)); - txDataReq->sfn = dlTtiReqtimingInfo->sfn; - txDataReq->slot = dlTtiReqtimingInfo->slot; - txDataReq->numPdus = 1; - LWR_MAC_ALLOC(txDataReq->pduDesc, (txDataReq->numPdus * \ - sizeof(fapi_tx_pdu_desc_t))); - fillRarTxDataReq( - txDataReq->pduDesc, - &currDlSlot->dlInfo.rarAlloc.rarInfo, - currDlSlot->dlInfo.rarAlloc.rarPdschCfg.pduIndex, - &msgLen); - fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, msgLen); - LwrMacSendToPhy(txDataReq->header.message_type_id, msgLen,(void *)txDataReq); - } - } - else - { - msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t); - fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen); - /* TODO : Recheck the size / msglen to be sent to WLS_Put*/ - LwrMacSendToPhy(dlTtiReq->header.message_type_id, msgLen, (void *)dlTtiReq); - } - return ROK; - } - else - { - DU_LOG("\nLOWER MAC: Failed to allocate memory for DL TTI Request"); - return RFAILED; - } - } - else +uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, MacDlSlot *dlSlot, p_fapi_api_queue_elem_t prevElem, fapi_vendor_tx_data_req_t *vendorTxDataReq) +{ +#ifdef INTEL_FAPI +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : TX_DATA_REQ\n"); +#endif + + uint8_t nPdu = 0; + uint8_t ueIdx=0; + uint16_t cellIdx=0; + uint16_t pduIndex = 0; + fapi_tx_data_req_t *txDataReq =NULLP; + p_fapi_api_queue_elem_t txDataElem = 0; + + GET_CELL_IDX(currTimingInfo.cellId, cellIdx); + + /* send TX_Data request message */ + nPdu = calcTxDataReqPduCount(dlSlot); + if(nPdu > 0) + { + LWR_MAC_ALLOC(txDataElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_tx_data_req_t))); + if(txDataElem == NULLP) { - DU_LOG("\nLOWER MAC: Current TTI Info is NULL"); + DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for TX data Request"); return RFAILED; } - } - else - { - lwr_mac_handleInvalidEvt(dlTtiReqtimingInfo); + + FILL_FAPI_LIST_ELEM(txDataElem, NULLP, FAPI_TX_DATA_REQUEST, 1, \ + sizeof(fapi_tx_data_req_t)); + txDataReq = (fapi_tx_data_req_t *)(txDataElem +1); + memset(txDataReq, 0, sizeof(fapi_tx_data_req_t)); + fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, sizeof(fapi_tx_data_req_t)); + + vendorTxDataReq->sym = 0; + + txDataReq->sfn = currTimingInfo.sfn; + txDataReq->slot = currTimingInfo.slot; + if(dlSlot->dlInfo.brdcstAlloc.sib1TransmissionMode) + { + fillSib1TxDataReq(txDataReq->pdu_desc, pduIndex, &macCb.macCell[cellIdx]->macCellCfg, \ + &dlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdcchCfg->dci.pdschCfg); + pduIndex++; + MAC_FREE(dlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdcchCfg,sizeof(PdcchCfg)); + txDataReq->num_pdus++; + } + if(dlSlot->pageAllocInfo != NULLP) + { + fillPageTxDataReq(txDataReq->pdu_desc, pduIndex, dlSlot->pageAllocInfo); + pduIndex++; + txDataReq->num_pdus++; + MAC_FREE(dlSlot->pageAllocInfo->pageDlSch.dlPagePdu, sizeof(dlSlot->pageAllocInfo->pageDlSch.dlPagePduLen)); + MAC_FREE(dlSlot->pageAllocInfo,sizeof(DlPageAlloc)); + } + + for(ueIdx=0; ueIdxdlInfo.rarAlloc[ueIdx] != NULLP) + { + if((dlSlot->dlInfo.rarAlloc[ueIdx]->rarPdschCfg)) + { + fillRarTxDataReq(txDataReq->pdu_desc, pduIndex, &dlSlot->dlInfo.rarAlloc[ueIdx]->rarInfo,\ + dlSlot->dlInfo.rarAlloc[ueIdx]->rarPdschCfg); + pduIndex++; + txDataReq->num_pdus++; + MAC_FREE(dlSlot->dlInfo.rarAlloc[ueIdx]->rarPdschCfg, sizeof(PdschCfg)); + } + MAC_FREE(dlSlot->dlInfo.rarAlloc[ueIdx],sizeof(RarAlloc)); + } + + if(dlSlot->dlInfo.dlMsgAlloc[ueIdx] != NULLP) + { + if(dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdschCfg) + { + fillDlMsgTxDataReq(txDataReq->pdu_desc, pduIndex, \ + dlSlot->dlInfo.dlMsgAlloc[ueIdx], \ + dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdschCfg); + pduIndex++; + txDataReq->num_pdus++; + MAC_FREE(dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdschCfg,sizeof(PdschCfg)); + } + MAC_FREE(dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdu, \ + dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPduLen); + dlSlot->dlInfo.dlMsgAlloc[ueIdx]->dlMsgPdu = NULLP; + MAC_FREE(dlSlot->dlInfo.dlMsgAlloc[ueIdx], sizeof(DlMsgSchInfo)); + } + } + + /* Fill message header */ + DU_LOG("\nDEBUG --> LWR_MAC: Sending TX DATA Request"); + prevElem->p_next = txDataElem; } #endif return ROK; @@ -2889,36 +4183,41 @@ uint16_t handleDlTtiReq(CmLteTimingInfo *dlTtiReqtimingInfo) * Pointer to CurrUlSlot * @return count * ********************************************************************/ -#ifdef FAPI +#ifdef INTEL_FAPI uint8_t getnPdus(fapi_ul_tti_req_t *ulTtiReq, MacUlSlot *currUlSlot) { - uint8_t pduCount = 0; + uint8_t pduCount = 0; - if(currUlSlot != NULLP) + if(ulTtiReq && currUlSlot) { - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH) - { - pduCount++; - ulTtiReq->rachPresent = PDU_PRESENT; - } - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH_UCI) - { - pduCount++; - ulTtiReq->nUlsch = PDU_PRESENT; - } - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_UCI) - { - pduCount++; - ulTtiReq->nUlcch = PDU_PRESENT; - } - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_SRS) - { - pduCount++; - } - } - return pduCount; -} -#endif + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH) + { + pduCount++; + ulTtiReq->rachPresent++; + } + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH) + { + pduCount++; + ulTtiReq->nUlsch++; + } + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH_UCI) + { + pduCount++; + ulTtiReq->nUlsch++; + } + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_UCI) + { + pduCount++; + ulTtiReq->nUlcch++; + } + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_SRS) + { + pduCount++; + } + } + return pduCount; +} +#endif /*********************************************************************** * @@ -2935,15 +4234,15 @@ uint8_t getnPdus(fapi_ul_tti_req_t *ulTtiReq, MacUlSlot *currUlSlot) * Pointer to MacCellCfg * ********************************************************************/ -void setNumCs(uint8_t *numCs, MacCellCfg *macCellCfg) +void setNumCs(uint16_t *numCs, MacCellCfg *macCellCfg) { -#ifdef FAPI +#ifdef INTEL_FAPI uint8_t idx; - if(macCellCfg != NULLP) - { - idx = macCellCfg->prachCfg.fdm[0].zeroCorrZoneCfg; - *numCs = UnrestrictedSetNcsTable[idx]; - } + if(macCellCfg != NULLP) + { + idx = macCellCfg->prachCfg.fdm[0].zeroCorrZoneCfg; + *numCs = UnrestrictedSetNcsTable[idx]; + } #endif } @@ -2964,29 +4263,193 @@ void setNumCs(uint8_t *numCs, MacCellCfg *macCellCfg) * Pointer to msgLen * ********************************************************************/ -#ifdef FAPI -void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, MacUlSlot *currUlSlot, uint32_t *msgLen) +#ifdef INTEL_FAPI +void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, MacUlSlot *currUlSlot) { if(ulTtiReqPdu != NULLP) { ulTtiReqPdu->pduType = PRACH_PDU_TYPE; - ulTtiReqPdu->u.prach_pdu.physCellId = macCellCfg->phyCellId; - ulTtiReqPdu->u.prach_pdu.numPrachOcas = currUlSlot->ulCellInfo.prachSchInfo.numPrachOcas; - ulTtiReqPdu->u.prach_pdu.prachFormat = \ - currUlSlot->ulCellInfo.prachSchInfo.prachFormat; - ulTtiReqPdu->u.prach_pdu.numRa = currUlSlot->ulCellInfo.prachSchInfo.numRa; - ulTtiReqPdu->u.prach_pdu.prachStartSymbol = \ - currUlSlot->ulCellInfo.prachSchInfo.prachStartSymb; - setNumCs(&ulTtiReqPdu->u.prach_pdu.numCs, macCellCfg); - ulTtiReqPdu->u.prach_pdu.beamforming.numPrgs = 0; - ulTtiReqPdu->u.prach_pdu.beamforming.prgSize = 0; - ulTtiReqPdu->u.prach_pdu.beamforming.digBfInterfaces = 0; - ulTtiReqPdu->u.prach_pdu.beamforming.pmi_bfi[0].pmIdx = 0; - ulTtiReqPdu->u.prach_pdu.beamforming.pmi_bfi[0].beamIdx[0].beamidx = 0; + ulTtiReqPdu->pdu.prach_pdu.physCellId = macCellCfg->cellCfg.phyCellId; + ulTtiReqPdu->pdu.prach_pdu.numPrachOcas = \ + currUlSlot->ulInfo.prachSchInfo.numPrachOcas; + ulTtiReqPdu->pdu.prach_pdu.prachFormat = \ + currUlSlot->ulInfo.prachSchInfo.prachFormat; + ulTtiReqPdu->pdu.prach_pdu.numRa = currUlSlot->ulInfo.prachSchInfo.numRa; + ulTtiReqPdu->pdu.prach_pdu.prachStartSymbol = \ + currUlSlot->ulInfo.prachSchInfo.prachStartSymb; + setNumCs(&ulTtiReqPdu->pdu.prach_pdu.numCs, macCellCfg); + ulTtiReqPdu->pdu.prach_pdu.beamforming.numPrgs = 0; + ulTtiReqPdu->pdu.prach_pdu.beamforming.prgSize = 0; + ulTtiReqPdu->pdu.prach_pdu.beamforming.digBfInterface = 0; + ulTtiReqPdu->pdu.prach_pdu.beamforming.rx_bfi[0].beamIdx[0].beamidx = 0; ulTtiReqPdu->pduSize = sizeof(fapi_ul_prach_pdu_t); - SETLENGTH(*msgLen, sizeof(fapi_dl_pdsch_pdu_t)); } } + +/******************************************************************* + * + * @brief Filling PUSCH PDU in UL TTI Request + * + * @details + * + * Function : fillPuschPdu + * + * Functionality: Filling PUSCH PDU in UL TTI Request + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +void fillPuschPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, fapi_vendor_ul_tti_req_pdu_t *ulTtiVendorPdu, MacCellCfg *macCellCfg, MacUlSlot *currUlSlot) +{ + if(ulTtiReqPdu != NULLP) + { + ulTtiReqPdu->pduType = PUSCH_PDU_TYPE; + memset(&ulTtiReqPdu->pdu.pusch_pdu, 0, sizeof(fapi_ul_pusch_pdu_t)); + ulTtiReqPdu->pdu.pusch_pdu.pduBitMap = 1; + ulTtiReqPdu->pdu.pusch_pdu.rnti = currUlSlot->ulInfo.crnti; + /* TODO : Fill handle in raCb when scheduling pusch and access here */ + ulTtiReqPdu->pdu.pusch_pdu.handle = 100; + ulTtiReqPdu->pdu.pusch_pdu.bwpSize = macCellCfg->cellCfg.initialUlBwp.bwp.numPrb; + ulTtiReqPdu->pdu.pusch_pdu.bwpStart = macCellCfg->cellCfg.initialUlBwp.bwp.firstPrb; + ulTtiReqPdu->pdu.pusch_pdu.subCarrierSpacing = \ + macCellCfg->cellCfg.initialUlBwp.bwp.scs; + ulTtiReqPdu->pdu.pusch_pdu.cyclicPrefix = \ + macCellCfg->cellCfg.initialUlBwp.bwp.cyclicPrefix; + ulTtiReqPdu->pdu.pusch_pdu.targetCodeRate = 308; + ulTtiReqPdu->pdu.pusch_pdu.qamModOrder = currUlSlot->ulInfo.schPuschInfo.tbInfo.qamOrder; + ulTtiReqPdu->pdu.pusch_pdu.mcsIndex = currUlSlot->ulInfo.schPuschInfo.tbInfo.mcs; + ulTtiReqPdu->pdu.pusch_pdu.mcsTable = currUlSlot->ulInfo.schPuschInfo.tbInfo.mcsTable; + ulTtiReqPdu->pdu.pusch_pdu.transformPrecoding = 1; + ulTtiReqPdu->pdu.pusch_pdu.dataScramblingId = currUlSlot->ulInfo.cellId; + ulTtiReqPdu->pdu.pusch_pdu.nrOfLayers = 1; + ulTtiReqPdu->pdu.pusch_pdu.ulDmrsSymbPos = 4; + ulTtiReqPdu->pdu.pusch_pdu.dmrsConfigType = 0; + ulTtiReqPdu->pdu.pusch_pdu.ulDmrsScramblingId = currUlSlot->ulInfo.cellId; + ulTtiReqPdu->pdu.pusch_pdu.scid = 0; + ulTtiReqPdu->pdu.pusch_pdu.numDmrsCdmGrpsNoData = 1; + ulTtiReqPdu->pdu.pusch_pdu.dmrsPorts = 0; + ulTtiReqPdu->pdu.pusch_pdu.resourceAlloc = \ + currUlSlot->ulInfo.schPuschInfo.fdAlloc.resAllocType; + ulTtiReqPdu->pdu.pusch_pdu.rbStart = \ + currUlSlot->ulInfo.schPuschInfo.fdAlloc.resAlloc.type1.startPrb; + ulTtiReqPdu->pdu.pusch_pdu.rbSize = \ + currUlSlot->ulInfo.schPuschInfo.fdAlloc.resAlloc.type1.numPrb; + ulTtiReqPdu->pdu.pusch_pdu.vrbToPrbMapping = 0; + ulTtiReqPdu->pdu.pusch_pdu.frequencyHopping = 0; + ulTtiReqPdu->pdu.pusch_pdu.txDirectCurrentLocation = 0; + ulTtiReqPdu->pdu.pusch_pdu.uplinkFrequencyShift7p5khz = 0; + ulTtiReqPdu->pdu.pusch_pdu.startSymbIndex = \ + currUlSlot->ulInfo.schPuschInfo.tdAlloc.startSymb; + ulTtiReqPdu->pdu.pusch_pdu.nrOfSymbols = \ + currUlSlot->ulInfo.schPuschInfo.tdAlloc.numSymb; +#ifdef INTEL_FAPI + ulTtiReqPdu->pdu.pusch_pdu.mappingType = \ + currUlSlot->ulInfo.schPuschInfo.dmrsMappingType; + ulTtiReqPdu->pdu.pusch_pdu.nrOfDmrsSymbols = \ + currUlSlot->ulInfo.schPuschInfo.nrOfDmrsSymbols; + ulTtiReqPdu->pdu.pusch_pdu.dmrsAddPos = \ + currUlSlot->ulInfo.schPuschInfo.dmrsAddPos; +#endif + ulTtiReqPdu->pdu.pusch_pdu.puschData.rvIndex = \ + currUlSlot->ulInfo.schPuschInfo.tbInfo.rv; + ulTtiReqPdu->pdu.pusch_pdu.puschData.harqProcessId = \ + currUlSlot->ulInfo.schPuschInfo.harqProcId; + ulTtiReqPdu->pdu.pusch_pdu.puschData.newDataIndicator = \ + currUlSlot->ulInfo.schPuschInfo.tbInfo.ndi; + ulTtiReqPdu->pdu.pusch_pdu.puschData.tbSize = \ + currUlSlot->ulInfo.schPuschInfo.tbInfo.tbSize; + /* numCb is 0 for new transmission */ + ulTtiReqPdu->pdu.pusch_pdu.puschData.numCb = 0; + + ulTtiReqPdu->pduSize = sizeof(fapi_ul_pusch_pdu_t); + + /* UL TTI Vendor PDU */ + ulTtiVendorPdu->pdu_type = FAPI_PUSCH_PDU_TYPE; + ulTtiVendorPdu->pdu.pusch_pdu.nr_of_antenna_ports=1; + ulTtiVendorPdu->pdu.pusch_pdu.nr_of_rx_ru=1; + for(int i =0; i< FAPI_VENDOR_MAX_RXRU_NUM; i++) + { + ulTtiVendorPdu->pdu.pusch_pdu.rx_ru_idx[i]=0; + } + } +} + +/******************************************************************* + * + * @brief Fill PUCCH PDU in Ul TTI Request + * + * @details + * + * Function : fillPucchPdu + * + * Functionality: Fill PUCCH PDU in Ul TTI Request + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +void fillPucchPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, fapi_vendor_ul_tti_req_pdu_t *ulTtiVendorPdu, MacCellCfg *macCellCfg,\ + MacUlSlot *currUlSlot) +{ + if(ulTtiReqPdu != NULLP) + { + ulTtiReqPdu->pduType = PUCCH_PDU_TYPE; + memset(&ulTtiReqPdu->pdu.pucch_pdu, 0, sizeof(fapi_ul_pucch_pdu_t)); + ulTtiReqPdu->pdu.pucch_pdu.rnti = currUlSlot->ulInfo.crnti; + /* TODO : Fill handle in raCb when scheduling pucch and access here */ + ulTtiReqPdu->pdu.pucch_pdu.handle = 100; + ulTtiReqPdu->pdu.pucch_pdu.bwpSize = macCellCfg->cellCfg.initialUlBwp.bwp.numPrb; + ulTtiReqPdu->pdu.pucch_pdu.bwpStart = macCellCfg->cellCfg.initialUlBwp.bwp.firstPrb; + ulTtiReqPdu->pdu.pucch_pdu.subCarrierSpacing = macCellCfg->cellCfg.initialUlBwp.bwp.scs; + ulTtiReqPdu->pdu.pucch_pdu.cyclicPrefix = macCellCfg->cellCfg.initialUlBwp.bwp.cyclicPrefix; + ulTtiReqPdu->pdu.pucch_pdu.formatType = currUlSlot->ulInfo.schPucchInfo.pucchFormat; /* Supporting PUCCH Format 0 */ + ulTtiReqPdu->pdu.pucch_pdu.multiSlotTxIndicator = 0; /* No Multi Slot transmission */ + + ulTtiReqPdu->pdu.pucch_pdu.prbStart = currUlSlot->ulInfo.schPucchInfo.fdAlloc.startPrb; + ulTtiReqPdu->pdu.pucch_pdu.prbSize = currUlSlot->ulInfo.schPucchInfo.fdAlloc.numPrb; + ulTtiReqPdu->pdu.pucch_pdu.startSymbolIndex = currUlSlot->ulInfo.schPucchInfo.tdAlloc.startSymb; + ulTtiReqPdu->pdu.pucch_pdu.nrOfSymbols = currUlSlot->ulInfo.schPucchInfo.tdAlloc.numSymb; + ulTtiReqPdu->pdu.pucch_pdu.freqHopFlag = currUlSlot->ulInfo.schPucchInfo.intraFreqHop; + ulTtiReqPdu->pdu.pucch_pdu.secondHopPrb = currUlSlot->ulInfo.schPucchInfo.secondPrbHop; + ulTtiReqPdu->pdu.pucch_pdu.groupHopFlag = 0; + ulTtiReqPdu->pdu.pucch_pdu.sequenceHopFlag = 0; + ulTtiReqPdu->pdu.pucch_pdu.hoppingId = 0; + + ulTtiReqPdu->pdu.pucch_pdu.initialCyclicShift = currUlSlot->ulInfo.schPucchInfo.initialCyclicShift; + + ulTtiReqPdu->pdu.pucch_pdu.dataScramblingId = 0; /* Valid for Format 2, 3, 4 */ + ulTtiReqPdu->pdu.pucch_pdu.timeDomainOccIdx = currUlSlot->ulInfo.schPucchInfo.timeDomOCC; + ulTtiReqPdu->pdu.pucch_pdu.preDftOccIdx = currUlSlot->ulInfo.schPucchInfo.occIdx; /* Valid for Format 4 only */ + ulTtiReqPdu->pdu.pucch_pdu.preDftOccLen = currUlSlot->ulInfo.schPucchInfo.occLen; /* Valid for Format 4 only */ + ulTtiReqPdu->pdu.pucch_pdu.pi2Bpsk = currUlSlot->ulInfo.schPucchInfo.pi2BPSK; + ulTtiReqPdu->pdu.pucch_pdu.addDmrsFlag = currUlSlot->ulInfo.schPucchInfo.addDmrs;/* Valid for Format 3, 4 only */ + ulTtiReqPdu->pdu.pucch_pdu.dmrsScramblingId = 0; /* Valid for Format 2 */ + ulTtiReqPdu->pdu.pucch_pdu.dmrsCyclicShift = 0; /* Valid for Format 4 */ + ulTtiReqPdu->pdu.pucch_pdu.srFlag = currUlSlot->ulInfo.schPucchInfo.srFlag; + ulTtiReqPdu->pdu.pucch_pdu.bitLenHarq = currUlSlot->ulInfo.schPucchInfo.harqInfo.harqBitLength; + ulTtiReqPdu->pdu.pucch_pdu.bitLenCsiPart1 = 0; /* Valid for Format 2, 3, 4 */ + ulTtiReqPdu->pdu.pucch_pdu.bitLenCsiPart2 = 0; /* Valid for Format 2, 3, 4 */ + ulTtiReqPdu->pdu.pucch_pdu.beamforming.numPrgs = currUlSlot->ulInfo.schPucchInfo.beamPucchInfo.numPrgs; + ulTtiReqPdu->pdu.pucch_pdu.beamforming.prgSize = currUlSlot->ulInfo.schPucchInfo.beamPucchInfo.prgSize; + ulTtiReqPdu->pdu.pucch_pdu.beamforming.digBfInterface = currUlSlot->ulInfo.schPucchInfo.beamPucchInfo.digBfInterfaces; + ulTtiReqPdu->pdu.pucch_pdu.beamforming.rx_bfi[0].beamIdx[0].beamidx = currUlSlot->ulInfo.schPucchInfo.beamPucchInfo.prg[0].beamIdx[0]; + + ulTtiReqPdu->pduSize = sizeof(fapi_ul_pucch_pdu_t); + + /* UL TTI Vendor PDU */ + ulTtiVendorPdu->pdu_type = FAPI_PUCCH_PDU_TYPE; + ulTtiVendorPdu->pdu.pucch_pdu.nr_of_rx_ru=1; + ulTtiVendorPdu->pdu.pucch_pdu.group_id=0; + for(int i =0; ipdu.pucch_pdu.rx_ru_idx[i]=0; + } + } +} + #endif /******************************************************************* @@ -2995,7 +4458,7 @@ void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, Ma * * @details * - * Function : handleUlTtiReq + * Function : fillUlTtiReq * * Functionality: * -Sends FAPI Param req to PHY @@ -3005,75 +4468,364 @@ void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, Ma * RFAILED - failure * ******************************************************************/ -S16 handleUlTtiReq(CmLteTimingInfo *currTimingInfo) +uint16_t fillUlTtiReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t prevElem, fapi_vendor_ul_tti_req_t* vendorUlTti) { -#ifdef FAPI - uint32_t msgLen = 0; - fapi_ul_tti_req_t *ulTtiReq = NULLP; - fapi_ul_tti_req_pdu_t *ulTtiReqPdu = NULLP; - RgCellCb *cellCbParams = NULLP; +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : UL_TTI_REQUEST\n"); +#endif + +#ifdef INTEL_FAPI + uint16_t cellIdx =0; + uint8_t pduIdx = -1; + SlotTimingInfo ulTtiReqTimingInfo; MacUlSlot *currUlSlot = NULLP; MacCellCfg macCellCfg; - memset(&macCellCfg, 0, sizeof(MacCellCfg)); - Inst inst = 0; + fapi_ul_tti_req_t *ulTtiReq = NULLP; + p_fapi_api_queue_elem_t ulTtiElem; + + if(lwrMacCb.phyState == PHY_STATE_RUNNING) + { + GET_CELL_IDX(currTimingInfo.cellId, cellIdx); + macCellCfg = macCb.macCell[cellIdx]->macCellCfg; + + /* add PHY delta */ + ADD_DELTA_TO_TIME(currTimingInfo,ulTtiReqTimingInfo,PHY_DELTA_UL, macCb.macCell[cellIdx]->numOfSlots); + currUlSlot = &macCb.macCell[cellIdx]->ulSlot[ulTtiReqTimingInfo.slot % macCb.macCell[cellIdx]->numOfSlots]; + + LWR_MAC_ALLOC(ulTtiElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_ul_tti_req_t))); + if(ulTtiElem) + { + FILL_FAPI_LIST_ELEM(ulTtiElem, NULLP, FAPI_UL_TTI_REQUEST, 1, \ + sizeof(fapi_ul_tti_req_t)); + ulTtiReq = (fapi_ul_tti_req_t *)(ulTtiElem +1); + memset(ulTtiReq, 0, sizeof(fapi_ul_tti_req_t)); + fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, sizeof(fapi_ul_tti_req_t)); + ulTtiReq->sfn = ulTtiReqTimingInfo.sfn; + ulTtiReq->slot = ulTtiReqTimingInfo.slot; + ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot); + vendorUlTti->num_ul_pdu = ulTtiReq->nPdus; + vendorUlTti->sym = 0; + ulTtiReq->nGroup = 0; + if(ulTtiReq->nPdus > 0) + { + /* Fill Prach Pdu */ + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH) + { + pduIdx++; + fillPrachPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot); + ulTtiReq->rachPresent++; + } + + /* Fill PUSCH PDU */ + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH) + { + pduIdx++; + fillPuschPdu(&ulTtiReq->pdus[pduIdx], &vendorUlTti->ul_pdus[pduIdx], &macCellCfg, currUlSlot); + ulTtiReq->nUlsch++; + } + /* Fill PUCCH PDU */ + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_UCI) + { + pduIdx++; + fillPucchPdu(&ulTtiReq->pdus[pduIdx], &vendorUlTti->ul_pdus[pduIdx], &macCellCfg, currUlSlot); + ulTtiReq->nUlcch++; + } + } + +#ifdef ODU_SLOT_IND_DEBUG_LOG + DU_LOG("\nDEBUG --> LWR_MAC: Sending UL TTI Request"); +#endif + prevElem->p_next = ulTtiElem; - if(clGlobalCp.phyState == PHY_STATE_RUNNING) + memset(currUlSlot, 0, sizeof(MacUlSlot)); + return ROK; + } + else + { + DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for UL TTI Request"); + memset(currUlSlot, 0, sizeof(MacUlSlot)); + return RFAILED; + } + } + else { - cellCbParams = rgCb[inst].cell; - macCellCfg = cellCbParams->macCellCfg; + lwr_mac_procInvalidEvt(&currTimingInfo); + } +#endif + return ROK; +} + +#ifdef INTEL_FAPI +/******************************************************************* + * + * @brief fills bsr Ul DCI PDU required for UL DCI Request to PHY + * + * @details + * + * Function : fillUlDciPdu + * + * Functionality: + * -Fills the Ul DCI PDU, spec Ref:38.212, Table 7.3.1-1 + * + * @params[in] Pointer to fapi_dl_dci_t + * Pointer to DciInfo + * @return ROK + * + ******************************************************************/ +void fillUlDciPdu(fapi_dl_dci_t *ulDciPtr, DciInfo *schDciInfo) +{ +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : UL_DCI_REQUEST\n"); +#endif + if(ulDciPtr != NULLP) + { + uint8_t numBytes =0; + uint8_t bytePos =0; + uint8_t bitPos =0; + + uint8_t coreset1Size = 0; + uint16_t rbStart = 0; + uint16_t rbLen = 0; + uint8_t dciFormatId = 0; + uint32_t freqDomResAssign =0; + uint8_t timeDomResAssign =0; + uint8_t freqHopFlag =0; + uint8_t modNCodScheme =0; + uint8_t ndi =0; + uint8_t redundancyVer = 0; + uint8_t harqProcessNum = 0; + uint8_t puschTpc = 0; + uint8_t ul_SlInd = 0; + + /* Size(in bits) of each field in DCI format 0_0 */ + uint8_t dciFormatIdSize = 1; + uint8_t freqDomResAssignSize = 0; + uint8_t timeDomResAssignSize = 4; + uint8_t freqHopFlagSize = 1; + uint8_t modNCodSchemeSize = 5; + uint8_t ndiSize = 1; + uint8_t redundancyVerSize = 2; + uint8_t harqProcessNumSize = 4; + uint8_t puschTpcSize = 2; + uint8_t ul_SlIndSize = 1; + + ulDciPtr->rnti = schDciInfo->dciInfo.rnti; + ulDciPtr->scramblingId = schDciInfo->dciInfo.scramblingId; + ulDciPtr->scramblingRnti = schDciInfo->dciInfo.scramblingRnti; + ulDciPtr->cceIndex = schDciInfo->dciInfo.cceIndex; + ulDciPtr->aggregationLevel = schDciInfo->dciInfo.aggregLevel; + ulDciPtr->pc_and_bform.numPrgs = schDciInfo->dciInfo.beamPdcchInfo.numPrgs; + ulDciPtr->pc_and_bform.prgSize = schDciInfo->dciInfo.beamPdcchInfo.prgSize; + ulDciPtr->pc_and_bform.digBfInterfaces = schDciInfo->dciInfo.beamPdcchInfo.digBfInterfaces; + ulDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = schDciInfo->dciInfo.beamPdcchInfo.prg[0].pmIdx; + ulDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = schDciInfo->dciInfo.beamPdcchInfo.prg[0].beamIdx[0]; + ulDciPtr->beta_pdcch_1_0 = schDciInfo->dciInfo.txPdcchPower.beta_pdcch_1_0; + ulDciPtr->powerControlOffsetSS = schDciInfo->dciInfo.txPdcchPower.powerControlOffsetSS; - if(currTimingInfo != NULLP) + /* Calculating freq domain resource allocation field value and size + * coreset1Size = Size of coreset 1 + * RBStart = Starting Virtual Rsource block + * RBLen = length of contiguously allocted RBs + * Spec 38.214 Sec 5.1.2.2.2 + */ + if(schDciInfo->dciFormatInfo.formatType == FORMAT0_0) { - LWR_MAC_ALLOC(ulTtiReq, sizeof(fapi_ul_tti_req_t)); - if(ulTtiReq != NULLP) + coreset1Size = schDciInfo->coresetCfg.coreSetSize; + rbLen = schDciInfo->dciFormatInfo.format.format0_0.freqAlloc.resAlloc.type1.numPrb; + rbStart = schDciInfo->dciFormatInfo.format.format0_0.freqAlloc.resAlloc.type1.startPrb; + + if((rbLen >=1) && (rbLen <= coreset1Size - rbStart)) { - ulTtiReq->sfn = currTimingInfo->sfn; - ulTtiReq->slot = currTimingInfo->slot; - currUlSlot = &macCb.macCell->ulSlot[ulTtiReq->slot % MAX_SLOT_SUPPORTED]; - ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot); - ulTtiReq->nGroup = 0; - if(ulTtiReq->nPdus > 0) - { - LWR_MAC_ALLOC(ulTtiReqPdu, (ulTtiReq->nPdus * - sizeof(fapi_ul_tti_req_pdu_t))); - /* Fill Prach Pdu */ - if(ulTtiReq->rachPresent) - { - if(ulTtiReqPdu != NULLP) - { - fillPrachPdu(ulTtiReqPdu, &macCellCfg, currUlSlot, &msgLen); - ulTtiReq->pdus = ulTtiReqPdu; - } - msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t); - fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen); - DU_LOG("\nLOWER MAC: Sending UL TTI Request"); - LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgLen, (void *)ulTtiReq); - } - } + if((rbLen - 1) <= floor(coreset1Size / 2)) + freqDomResAssign = (coreset1Size * (rbLen-1)) + rbStart; else - { - msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t); - fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen); - DU_LOG("\nLOWER MAC: Sending UL TTI Request"); - LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgLen, (void *)ulTtiReq); - } - return ROK; - } - else - { - DU_LOG("\nLOWER MAC: Failed to allocate memory for UL TTI Request"); - return RFAILED; + freqDomResAssign = (coreset1Size * (coreset1Size - rbLen + 1)) \ + + (coreset1Size - 1 - rbStart); + + freqDomResAssignSize = ceil(log2(coreset1Size * (coreset1Size + 1) / 2)); } + /* Fetching DCI field values */ + dciFormatId = schDciInfo->dciFormatInfo.formatType; /* DCI indentifier for UL DCI */ + timeDomResAssign = schDciInfo->dciFormatInfo.format.format0_0.rowIndex; + freqHopFlag = schDciInfo->dciFormatInfo.format.format0_0.freqHopFlag; + modNCodScheme = schDciInfo->dciFormatInfo.format.format0_0.mcs; + ndi = schDciInfo->dciFormatInfo.format.format0_0.ndi; + redundancyVer = schDciInfo->dciFormatInfo.format.format0_0.rvIndex; + harqProcessNum = schDciInfo->dciFormatInfo.format.format0_0.harqProcId; + puschTpc = schDciInfo->dciFormatInfo.format.format0_0.tpcCmd; + ul_SlInd = schDciInfo->dciFormatInfo.format.format0_0.sulIndicator; + + /* Reversing bits in each DCI field */ + dciFormatId = reverseBits(dciFormatId, dciFormatIdSize); + freqDomResAssign = reverseBits(freqDomResAssign, freqDomResAssignSize); + timeDomResAssign = reverseBits(timeDomResAssign, timeDomResAssignSize); + modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize); + redundancyVer = reverseBits(redundancyVer, redundancyVerSize); + harqProcessNum = reverseBits(harqProcessNum, harqProcessNumSize); + puschTpc = reverseBits(puschTpc, puschTpcSize); + ul_SlInd = reverseBits(ul_SlInd, ul_SlIndSize); } - else + /* Calulating total number of bytes in buffer */ + ulDciPtr->payloadSizeBits = (dciFormatIdSize + freqDomResAssignSize\ + + timeDomResAssignSize + freqHopFlagSize + modNCodSchemeSize + ndi \ + + redundancyVerSize + harqProcessNumSize + puschTpcSize + ul_SlIndSize); + + numBytes = ulDciPtr->payloadSizeBits / 8; + if(ulDciPtr->payloadSizeBits % 8) + numBytes += 1; + + if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN) { - DU_LOG("\nLOWER MAC: Current TTI Info in UL is NULL"); - return RFAILED; + DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected"); + return; + } + + /* Initialize buffer */ + for(bytePos = 0; bytePos < numBytes; bytePos++) + ulDciPtr->payload[bytePos] = 0; + + bytePos = numBytes - 1; + bitPos = 0; + + /* Packing DCI format fields */ + fillDlDciPayload(ulDciPtr->payload, &bytePos, &bitPos,\ + dciFormatId, dciFormatIdSize); + fillDlDciPayload(ulDciPtr->payload, &bytePos, &bitPos,\ + freqDomResAssign, freqDomResAssignSize); + fillDlDciPayload(ulDciPtr->payload, &bytePos, &bitPos,\ + timeDomResAssign, timeDomResAssignSize); + fillDlDciPayload(ulDciPtr->payload, &bytePos, &bitPos,\ + freqHopFlag, freqHopFlagSize); + fillDlDciPayload(ulDciPtr->payload, &bytePos, &bitPos,\ + modNCodScheme, modNCodSchemeSize); + fillDlDciPayload(ulDciPtr->payload, &bytePos, &bitPos,\ + ndi, ndiSize); + fillDlDciPayload(ulDciPtr->payload, &bytePos, &bitPos,\ + redundancyVer, redundancyVerSize); + fillDlDciPayload(ulDciPtr->payload, &bytePos, &bitPos,\ + harqProcessNum, harqProcessNumSize); + fillDlDciPayload(ulDciPtr->payload, &bytePos, &bitPos,\ + puschTpc, puschTpcSize); + fillDlDciPayload(ulDciPtr->payload, &bytePos, &bitPos,\ + ul_SlInd, ul_SlIndSize); + } +} /* fillUlDciPdu */ + +/******************************************************************* + * + * @brief fills PDCCH PDU required for UL DCI REQ to PHY + * + * @details + * + * Function : fillUlDciPdcchPdu + * + * Functionality: + * -Fills the Pdcch PDU info + * + * @params[in] Pointer to FAPI DL TTI Req + * Pointer to PdcchCfg + * @return ROK + * + ******************************************************************/ +uint8_t fillUlDciPdcchPdu(fapi_dci_pdu_t *ulDciReqPdu, fapi_vendor_dci_pdu_t *vendorUlDciPdu, DlSchedInfo *dlInfo, uint8_t coreSetType) +{ + if(ulDciReqPdu != NULLP) + { + memset(&ulDciReqPdu->pdcchPduConfig, 0, sizeof(fapi_dl_pdcch_pdu_t)); + fillUlDciPdu(ulDciReqPdu->pdcchPduConfig.dlDci, dlInfo->ulGrant); + ulDciReqPdu->pduType = PDCCH_PDU_TYPE; + ulDciReqPdu->pdcchPduConfig.bwpSize = dlInfo->ulGrant->bwpCfg.freqAlloc.numPrb; + ulDciReqPdu->pdcchPduConfig.bwpStart = dlInfo->ulGrant->bwpCfg.freqAlloc.startPrb; + ulDciReqPdu->pdcchPduConfig.subCarrierSpacing = dlInfo->ulGrant->bwpCfg.subcarrierSpacing; + ulDciReqPdu->pdcchPduConfig.cyclicPrefix = dlInfo->ulGrant->bwpCfg.cyclicPrefix; + ulDciReqPdu->pdcchPduConfig.startSymbolIndex = dlInfo->ulGrant->coresetCfg.startSymbolIndex; + ulDciReqPdu->pdcchPduConfig.durationSymbols = dlInfo->ulGrant->coresetCfg.durationSymbols; + memcpy(ulDciReqPdu->pdcchPduConfig.freqDomainResource, dlInfo->ulGrant->coresetCfg.freqDomainResource, 6); + ulDciReqPdu->pdcchPduConfig.cceRegMappingType = dlInfo->ulGrant->coresetCfg.cceRegMappingType; + ulDciReqPdu->pdcchPduConfig.regBundleSize = dlInfo->ulGrant->coresetCfg.regBundleSize; + ulDciReqPdu->pdcchPduConfig.interleaverSize = dlInfo->ulGrant->coresetCfg.interleaverSize; + ulDciReqPdu->pdcchPduConfig.shiftIndex = dlInfo->ulGrant->coresetCfg.shiftIndex; + ulDciReqPdu->pdcchPduConfig.precoderGranularity = dlInfo->ulGrant->coresetCfg.precoderGranularity; + ulDciReqPdu->pdcchPduConfig.numDlDci = 1; + ulDciReqPdu->pdcchPduConfig.coreSetType = coreSetType; + + /* Calculating PDU length. Considering only one Ul dci pdu for now */ + ulDciReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t); + + /* Vendor UL DCI PDU */ + vendorUlDciPdu->pdcch_pdu_config.num_dl_dci = ulDciReqPdu->pdcchPduConfig.numDlDci; + vendorUlDciPdu->pdcch_pdu_config.dl_dci[0].epre_ratio_of_pdcch_to_ssb = 0; + vendorUlDciPdu->pdcch_pdu_config.dl_dci[0].epre_ratio_of_dmrs_to_ssb = 0; + } + return ROK; +} +#endif +/******************************************************************* + * + * @brief Sends UL DCI Request to PHY + * + * @details + * + * Function : fillUlDciReq + * + * Functionality: + * -Sends FAPI Ul Dci req to PHY + * + * @params[in] Pointer to CmLteTimingInfo + * @return ROK - success + * RFAILED - failure + * + ******************************************************************/ +uint16_t fillUlDciReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t prevElem, fapi_vendor_ul_dci_req_t *vendorUlDciReq) +{ +#ifdef INTEL_FAPI + uint8_t cellIdx =0; + uint8_t numPduEncoded = 0; + SlotTimingInfo ulDciReqTimingInfo ={0}; + MacDlSlot *currDlSlot = NULLP; + fapi_ul_dci_req_t *ulDciReq =NULLP; + p_fapi_api_queue_elem_t ulDciElem; + + if(lwrMacCb.phyState == PHY_STATE_RUNNING) + { + GET_CELL_IDX(currTimingInfo.cellId, cellIdx); + memcpy(&ulDciReqTimingInfo, &currTimingInfo, sizeof(SlotTimingInfo)); + currDlSlot = &macCb.macCell[cellIdx]->dlSlot[ulDciReqTimingInfo.slot % macCb.macCell[cellIdx]->numOfSlots]; + + LWR_MAC_ALLOC(ulDciElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_ul_dci_req_t))); + if(ulDciElem) + { + FILL_FAPI_LIST_ELEM(ulDciElem, NULLP, FAPI_UL_DCI_REQUEST, 1, \ + sizeof(fapi_ul_dci_req_t)); + ulDciReq = (fapi_ul_dci_req_t *)(ulDciElem +1); + memset(ulDciReq, 0, sizeof(fapi_ul_dci_req_t)); + fillMsgHeader(&ulDciReq->header, FAPI_UL_DCI_REQUEST, sizeof(fapi_ul_dci_req_t)); + + ulDciReq->sfn = ulDciReqTimingInfo.sfn; + ulDciReq->slot = ulDciReqTimingInfo.slot; + if(currDlSlot->dlInfo.ulGrant != NULLP) + { + vendorUlDciReq->sym = 0; + ulDciReq->numPdus = 1; // No. of PDCCH PDUs + vendorUlDciReq->num_pdus = ulDciReq->numPdus; + if(ulDciReq->numPdus > 0) + { + /* Fill PDCCH configuration Pdu */ + fillUlDciPdcchPdu(&ulDciReq->pdus[numPduEncoded], &vendorUlDciReq->pdus[numPduEncoded], &currDlSlot->dlInfo, CORESET_TYPE1); + numPduEncoded++; + /* free UL GRANT at SCH */ + MAC_FREE(currDlSlot->dlInfo.ulGrant, sizeof(DciInfo)); + } +#ifdef ODU_SLOT_IND_DEBUG_LOG + DU_LOG("\nDEBUG --> LWR_MAC: Sending UL DCI Request"); +#endif + } + prevElem->p_next = ulDciElem; } } else { - lwr_mac_handleInvalidEvt(currTimingInfo); + lwr_mac_procInvalidEvt(&currTimingInfo); } #endif return ROK; @@ -3083,33 +4835,45 @@ lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] = { { /* PHY_STATE_IDLE */ - lwr_mac_handleParamReqEvt, - lwr_mac_handleParamRspEvt, - lwr_mac_handleConfigReqEvt, - lwr_mac_handleConfigRspEvt, - lwr_mac_handleInvalidEvt, +#ifdef INTEL_TIMER_MODE + lwr_mac_procIqSamplesReqEvt, +#endif + lwr_mac_procParamReqEvt, + lwr_mac_procParamRspEvt, + lwr_mac_procConfigReqEvt, + lwr_mac_procConfigRspEvt, + lwr_mac_procInvalidEvt, + lwr_mac_procInvalidEvt, }, { - /* PHY_STATE_CONFIGURED */ - lwr_mac_handleParamReqEvt, - lwr_mac_handleParamRspEvt, - lwr_mac_handleConfigReqEvt, - lwr_mac_handleConfigRspEvt, - lwr_mac_handleStartReqEvt, + /* PHY_STATE_CONFIGURED */ +#ifdef INTEL_TIMER_MODE + lwr_mac_procInvalidEvt, +#endif + lwr_mac_procParamReqEvt, + lwr_mac_procParamRspEvt, + lwr_mac_procConfigReqEvt, + lwr_mac_procConfigRspEvt, + lwr_mac_procStartReqEvt, + lwr_mac_procInvalidEvt, }, { - /* PHY_STATE_RUNNING */ - lwr_mac_handleInvalidEvt, - lwr_mac_handleInvalidEvt, - lwr_mac_handleConfigReqEvt, - lwr_mac_handleConfigRspEvt, - lwr_mac_handleInvalidEvt, + /* PHY_STATE_RUNNING */ +#ifdef INTEL_TIMER_MODE + lwr_mac_procInvalidEvt, +#endif + lwr_mac_procInvalidEvt, + lwr_mac_procInvalidEvt, + lwr_mac_procConfigReqEvt, + lwr_mac_procConfigRspEvt, + lwr_mac_procInvalidEvt, + lwr_mac_procInvalidEvt, } }; /******************************************************************* * - * @brief Sends message to Lower Mac Fsm Event Handler + * @brief Sends message to LWR_MAC Fsm Event Handler * * @details * @@ -3124,12 +4888,13 @@ lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] = * * @return void * -******************************************************************/ + ******************************************************************/ void sendToLowerMac(uint16_t msgType, uint32_t msgLen, void *msg) { - clGlobalCp.event = msgType; - fapiEvtHdlr[clGlobalCp.phyState][clGlobalCp.event](msg); + lwrMacCb.event = msgType; + fapiEvtHdlr[lwrMacCb.phyState][lwrMacCb.event](msg); } + /********************************************************************** - End of file -**********************************************************************/ + End of file + **********************************************************************/