################################################################################
*******************************************************************************/
#include <stdlib.h>
+#include <stdint.h>
+
+/* header include files -- defines (.h) */
+#include "envopt.h" /* environment options */
+#include "envdep.h" /* environment dependent */
+#include "envind.h" /* environment independent */
+#include "gen.h" /* general layer */
+#include "ssi.h" /* system service interface */
+#include "cm_hash.h" /* common hash list */
+#include "cm_mblk.h" /* common memory link list library */
+#include "cm_llist.h" /* common linked list library */
+#include "cm_err.h" /* common error */
+#include "cm_lte.h" /* common LTE */
+#include "lrg.h" /* Layer manager interface includes*/
+#include "crg.h" /* CRG interface includes*/
+#include "rgu.h" /* RGU interface includes*/
+#include "tfu.h" /* TFU interface includes */
+#include "rg_sch_inf.h" /* SCH interface includes */
+#include "rg_prg.h" /* PRG (MAC-MAC) interface includes*/
+#include "rg_env.h" /* MAC environmental includes*/
+#include "rg.h" /* MAC includes*/
+#include "rg_err.h" /* MAC error includes*/
+#include "du_log.h"
#include "lwr_mac_fsm.h"
-EXTERN void sendToPhy ARGS((U16 msgType, U32 msgLen, void *msg));
+/* header/extern include files (.x) */
+#include "gen.x" /* general layer typedefs */
+#include "ssi.x" /* system services typedefs */
+#include "cm5.x" /* common timers */
+#include "cm_hash.x" /* common hash list */
+#include "cm_lib.x" /* common library */
+#include "cm_llist.x" /* common linked list */
+#include "cm_mblk.x" /* memory management */
+#include "cm_tkns.x" /* common tokens */
+#include "cm_lte.x" /* common tokens */
+#include "rgu.x" /* RGU types */
+#include "tfu.x" /* RGU types */
+#include "lrg.x" /* layer management typedefs for MAC */
+#include "crg.x" /* CRG interface includes */
+#include "rg_sch_inf.x" /* SCH interface typedefs */
+#include "rg_prg.x" /* PRG (MAC-MAC) Interface typedefs */
+#include "du_app_mac_inf.h"
+#include "mac.h"
+#include "rg.x" /* typedefs for MAC */
+
+#define MIB_SFN_BITMASK 0xFC
+#define SSB_PDU_TYPE 3
+#define SETLENGTH(x, size) x += size
+
+
+EXTERN void sendToPhy ARGS((uint8_t msgType, uint32_t msgLen, void *msg));
+SlotIndInfo slotIndInfo; //global variable
/*******************************************************************
*
* ****************************************************************/
S16 lwr_mac_handleInvalidEvt(void *msg)
{
- printf("\n Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState);
+ printf("\nLOWER MAC: Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState);
RETVALUE(ROK);
}
* @return void
*
* ****************************************************************/
-PUBLIC void fillMsgHeader(fapi_msg_t *hdr, U16 msgType, U16 msgLen)
+PUBLIC void fillMsgHeader(fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen)
{
hdr->message_type_id = msgType;
hdr->length = msgLen;
* @return void
*
* ****************************************************************/
-PUBLIC void fillTlvs(fapi_uint16_tlv_t *tlv, U16 tag, U16 length, U16 value, U16 *msgLen)
+PUBLIC void fillTlvs(fapi_uint16_tlv_t *tlv, uint16_t tag, uint16_t length,
+uint16_t value, uint32_t *msgLen)
{
tlv->tl.tag = tag;
tlv->tl.length = length;
* @params[in] Pointer to ClCellParam
* Value to be compared
* @return void
- *
+ *
********************************************************************/
-PUBLIC void fillCyclicPrefix(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillCyclicPrefix(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_NORMAL_CYCLIC_PREFIX_MASK) == FAPI_NORMAL_CYCLIC_PREFIX_MASK)
{
*
* ****************************************************************/
-PUBLIC void fillSubcarrierSpaceDl(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillSubcarrierSpaceDl(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
{
*
* ****************************************************************/
-PUBLIC void fillBandwidthDl(U16 value, ClCellParam **cellPtr)
+PUBLIC void fillBandwidthDl(uint16_t value, ClCellParam **cellPtr)
{
if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
{
else if((value & FAPI_20MHZ_BW_MASK) == FAPI_20MHZ_BW_MASK)
{
(*cellPtr)->supportedBandwidthDl = BW_20MHZ;
- }
+ }
else if((value & FAPI_40MHZ_BW_MASK) == FAPI_40MHZ_BW_MASK)
{
(*cellPtr)->supportedBandwidthDl = BW_40MHZ;
*
* ****************************************************************/
-PUBLIC void fillSubcarrierSpaceUl(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillSubcarrierSpaceUl(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_15KHZ_MASK) == FAPI_15KHZ_MASK)
{
* Functionality:
* -checks the value with the bitmask and
* fills the cellPtr's UL Bandwidth
- *
+ *
*
*
* @params[in] Pointer to ClCellParam
* Value to be compared
* @return void
- *
+ *
*
* ****************************************************************/
-PUBLIC void fillBandwidthUl(U16 value, ClCellParam **cellPtr)
+PUBLIC void fillBandwidthUl(uint16_t value, ClCellParam **cellPtr)
{
if((value & FAPI_5MHZ_BW_MASK) == FAPI_5MHZ_BW_MASK)
{
*
* ****************************************************************/
-PUBLIC void fillCCEmaping(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillCCEmaping(uint8_t value, ClCellParam **cellPtr)
{
if ((value & FAPI_CCE_MAPPING_INTERLEAVED_MASK) == FAPI_CCE_MAPPING_INTERLEAVED_MASK)
{
*
* ****************************************************************/
-PUBLIC void fillPucchFormat(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPucchFormat(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
{
*
* ****************************************************************/
-PUBLIC void fillPdschMappingType(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPdschMappingType(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PDSCH_MAPPING_TYPE_A_MASK) == FAPI_PDSCH_MAPPING_TYPE_A_MASK)
{
*
* ****************************************************************/
-PUBLIC void fillPdschAllocationType(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPdschAllocationType(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PDSCH_ALLOC_TYPE_0_MASK) == FAPI_PDSCH_ALLOC_TYPE_0_MASK)
{
* @return void
*
******************************************************************/
-PUBLIC void fillPrbMappingType(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPrbMappingType(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PDSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
{
*
******************************************************************/
-PUBLIC void fillPdschDmrsConfigType(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPdschDmrsConfigType(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PDSCH_DMRS_CONFIG_TYPE_1_MASK)
{
* @return void
*
******************************************************************/
-PUBLIC void fillPdschDmrsLength(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPdschDmrsLength(uint8_t value, ClCellParam **cellPtr)
{
if(value == FAPI_PDSCH_DMRS_MAX_LENGTH_1)
{
*
******************************************************************/
-PUBLIC void fillPdschDmrsAddPos(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPdschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
{
* @return void
*
******************************************************************/
-PUBLIC void fillModulationOrderDl(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillModulationOrderDl(uint8_t value, ClCellParam **cellPtr)
{
if(value == 0 )
{
*
******************************************************************/
-PUBLIC void fillPuschDmrsConfig(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPuschDmrsConfig(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK) == FAPI_PUSCH_DMRS_CONFIG_TYPE_1_MASK)
{
*
******************************************************************/
-PUBLIC void fillPuschDmrsLength(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPuschDmrsLength(uint8_t value, ClCellParam **cellPtr)
{
if(value == FAPI_PUSCH_DMRS_MAX_LENGTH_1)
{
*
******************************************************************/
-PUBLIC void fillPuschDmrsAddPos(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPuschDmrsAddPos(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_DMRS_ADDITIONAL_POS_0_MASK) == FAPI_DMRS_ADDITIONAL_POS_0_MASK)
{
*
******************************************************************/
-PUBLIC void fillPuschMappingType(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPuschMappingType(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PUSCH_MAPPING_TYPE_A_MASK) == FAPI_PUSCH_MAPPING_TYPE_A_MASK)
{
*
******************************************************************/
-PUBLIC void fillPuschAllocationType(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPuschAllocationType(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PUSCH_ALLOC_TYPE_0_MASK) == FAPI_PUSCH_ALLOC_TYPE_0_MASK)
{
*
******************************************************************/
-PUBLIC void fillPuschPrbMappingType(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPuschPrbMappingType(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK) == FAPI_PUSCH_VRB_TO_PRB_MAP_NON_INTLV_MASK)
{
*
******************************************************************/
-PUBLIC void fillModulationOrderUl(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillModulationOrderUl(uint8_t value, ClCellParam **cellPtr)
{
if(value == 0)
{
*
******************************************************************/
-PUBLIC void fillPuschAggregationFactor(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPuschAggregationFactor(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_FORMAT_0_MASK) == FAPI_FORMAT_0_MASK)
{
*
******************************************************************/
-PUBLIC void fillPrachLongFormat(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPrachLongFormat(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PRACH_LF_FORMAT_0_MASK) == FAPI_PRACH_LF_FORMAT_0_MASK)
{
*
******************************************************************/
-PUBLIC void fillPrachShortFormat(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillPrachShortFormat(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_PRACH_SF_FORMAT_A1_MASK) == FAPI_PRACH_SF_FORMAT_A1_MASK)
{
*
******************************************************************/
-PUBLIC void fillFdOccasions(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillFdOccasions(uint8_t value, ClCellParam **cellPtr)
{
if(value == 0)
{
*
******************************************************************/
-PUBLIC void fillRssiMeas(U8 value, ClCellParam **cellPtr)
+PUBLIC void fillRssiMeas(uint8_t value, ClCellParam **cellPtr)
{
if((value & FAPI_RSSI_REPORT_IN_DBM_MASK) == FAPI_RSSI_REPORT_IN_DBM_MASK)
{
*
* ****************************************************************/
-S16 getParamValue(fapi_uint16_tlv_t *tlv, U16 type)
+uint32_t getParamValue(fapi_uint16_tlv_t *tlv, uint16_t type)
{
- U16 valueLen;
- void *temp, *posPtr;
+ uint16_t valueLen;
+ void *posPtr;
valueLen = tlv->tl.length;
posPtr = &tlv->tl.tag;
posPtr += sizeof(tlv->tl.tag);
/*TO DO: malloc to SSI memory */
if(type == FAPI_UINT_8)
{
- temp = (U8 *)malloc(valueLen * sizeof(U8));
- memcpy(temp, posPtr, valueLen);
- return(*(U8 *)temp);
+ //temp = (uint8_t *)malloc(valueLen * sizeof(U8));
+ //memcpy(temp, posPtr, valueLen);
+ return(*(uint8_t *)posPtr);
}
else if(type == FAPI_UINT_16)
{
- temp = (U16 *)malloc(valueLen * sizeof(U16));
- memcpy(temp, posPtr, valueLen);
- return(*(U16 *)temp);
+ return(*(uint16_t *)posPtr);
}
else if(type == FAPI_UINT_32)
{
- temp = (U32 *)malloc(valueLen * sizeof(U32));
- memcpy(temp, posPtr, valueLen);
- return(*(U32 *)temp);
+ return(*(uint32_t *)posPtr);
}
else
{
- printf("\n Value Extraction failed" );
- RETVALUE(RFAILED);
+ DU_LOG("\nLOWER MAC: Value Extraction failed" );
+ return RFAILED;
}
}
/*******************************************************************
S16 lwr_mac_handleParamReqEvt(void *msg)
{
/* startGuardTimer(); */
- fapi_param_req_t *paramReq = (fapi_param_req_t *)msg;
- if(SGetSBuf(0, 0, (Data **)¶mReq, sizeof(fapi_param_req_t)) != ROK)
- {
- printf("\nFailed to allocate memory for Param Request");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
+ uint32_t msgLen; //Length of message Body
+ msgLen = 0;
+ fapi_param_req_t *paramReq;
+ MAC_ALLOC(paramReq, sizeof(fapi_param_req_t));
+ if(paramReq != NULLP)
+ {
+ fillMsgHeader(¶mReq->header, FAPI_PARAM_REQUEST, msgLen);
+ DU_LOG("\nLOWER MAC: sending param Req to Phy");
+ sendToPhy(paramReq->header.message_type_id, sizeof(fapi_param_req_t), (void *)paramReq);
+ MAC_FREE(paramReq, sizeof(fapi_param_req_t));
+ return ROK;
}
else
{
- fillMsgHeader(¶mReq->header, FAPI_PARAM_REQUEST, 0);
- sendToPhy(paramReq->header.message_type_id, sizeof(fapi_param_req_t), (void *)paramReq);
- RETVALUE(ROK);
+ DU_LOG("\nLOWER MAC: Failed to allocate memory for Param Request");
+ return RFAILED;
}
}
/*******************************************************************
*
- * @brief Sends FAPI Param rsp to MAC via PHY
+ * @brief Sends FAPI Param Response to MAC via PHY
*
* @details
*
*
* ****************************************************************/
-S16 lwr_mac_handleParamRspEvt(fapi_param_resp_t *paramRsp)
+S16 lwr_mac_handleParamRspEvt(void *msg)
{
/* stopGuardTimer(); */
- U16 index;
- U32 encodedVal;
+ uint8_t index;
+ uint32_t encodedVal;
+ fapi_param_resp_t *paramRsp;
ClCellParam *cellParam = NULLP;
- if(paramRsp == NULLP)
- {
- printf("\n Param Request for State [%d] is unsuccessfull", clGlobalCp.phyState);
- RETVALUE(RFAILED);
- }
- printf("\n Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
- SPutSBuf(0, 0, (Data *)paramRsp, paramRsp->header.length);
- if(SGetSBuf(0, 0, (Data **)&cellParam, sizeof(ClCellParam)) != ROK)
- {
- printf("\nFailed to allocate memory for new cell");
- RETVALUE(LCM_REASON_MEM_NOAVAIL);
- }
- printf("\n Filling TLVS into MAC API");
- if(paramRsp->error_code == MSG_OK)
+ paramRsp = (fapi_param_resp_t *)msg;
+ DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
+
+ if(paramRsp != NULLP)
{
- for(index = 0; index < paramRsp->number_of_tlvs; index++)
+ MAC_ALLOC(cellParam, sizeof(ClCellParam));
+ if(cellParam != NULLP)
{
- switch(paramRsp->tlvs[index].tl.tag)
+ DU_LOG("\n LOWER MAC: Filling TLVS into MAC API");
+ if(paramRsp->error_code == MSG_OK)
{
- case FAPI_RELEASE_CAPABILITY_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
- if(encodedVal != RFAILED && (encodedVal & RELEASE_15) == RELEASE_15)
- {
- cellParam->releaseCapability = RELEASE_15;
- }
- break;
-
- case FAPI_PHY_STATE_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != clGlobalCp.phyState)
- {
- printf("\n PhyState mismatch [%d][%d]", clGlobalCp.phyState, clGlobalCp.event);
- RETVALUE(RFAILED);
- }
- break;
-
- case FAPI_SKIP_BLANK_DL_CONFIG_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->skipBlankDlConfig = SUPPORTED;
- }
- else
- {
- cellParam->skipBlankDlConfig = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_SKIP_BLANK_UL_CONFIG_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->skipBlankUlConfig = SUPPORTED;
- }
- else
- {
- cellParam->skipBlankUlConfig = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG:
- cellParam->numTlvsToReport = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
- break;
-
- case FAPI_CYCLIC_PREFIX_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillCyclicPrefix(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillSubcarrierSpaceDl(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_SUPPORTED_BANDWIDTH_DL_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
- if(encodedVal != RFAILED)
- {
- fillBandwidthDl(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillSubcarrierSpaceUl(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_SUPPORTED_BANDWIDTH_UL_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
- if(encodedVal != RFAILED)
- {
- fillBandwidthUl(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_CCE_MAPPING_TYPE_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillCCEmaping(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->coresetOutsideFirst3OfdmSymsOfSlot = SUPPORTED;
- }
- else
- {
- cellParam->coresetOutsideFirst3OfdmSymsOfSlot = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_PRECODER_GRANULARITY_CORESET_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->precoderGranularityCoreset = SUPPORTED;
- }
- else
- {
- cellParam->precoderGranularityCoreset = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_PDCCH_MU_MIMO_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->pdcchMuMimo = SUPPORTED;
- }
- else
- {
- cellParam->pdcchMuMimo = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_PDCCH_PRECODER_CYCLING_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->pdcchPrecoderCycling = SUPPORTED;
- }
- else
- {
- cellParam->pdcchPrecoderCycling = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_MAX_PDCCHS_PER_SLOT_TAG:
- cellParam->maxPdcchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- break;
-
- case FAPI_PUCCH_FORMATS_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPucchFormat(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_MAX_PUCCHS_PER_SLOT_TAG:
- cellParam->maxPucchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- break;
-
- case FAPI_PDSCH_MAPPING_TYPE_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPdschMappingType(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_PDSCH_ALLOCATION_TYPES_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPdschAllocationType(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPrbMappingType(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_PDSCH_CBG_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->pdschCbg = SUPPORTED;
- }
- else
- {
- cellParam->pdschCbg = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPdschDmrsConfigType(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_PDSCH_DMRS_MAX_LENGTH_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPdschDmrsLength(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPdschDmrsAddPos(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG:
- cellParam->maxPdschsTBsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- break;
-
- case FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal < FAPI_MAX_NUMBERMIMO_LAYERS_PDSCH)
- {
- cellParam->maxNumberMimoLayersPdsch = encodedVal;
- }
- break;
-
- case FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillModulationOrderDl(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_MAX_MU_MIMO_USERS_DL_TAG:
- cellParam->maxMuMimoUsersDl = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- break;
-
- case FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->pdschDataInDmrsSymbols = SUPPORTED;
- }
- else
- {
- cellParam->pdschDataInDmrsSymbols = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_PREMPTIONSUPPORT_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->premptionSupport = SUPPORTED;
- }
- else
- {
- cellParam->premptionSupport = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_PDSCH_NON_SLOT_SUPPORT_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->pdschNonSlotSupport = SUPPORTED;
- }
- else
- {
- cellParam->pdschNonSlotSupport = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->uciMuxUlschInPusch = SUPPORTED;
- }
- else
- {
- cellParam->uciMuxUlschInPusch = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_UCI_ONLY_PUSCH_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->uciOnlyPusch = SUPPORTED;
- }
- else
- {
- cellParam->uciOnlyPusch = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_PUSCH_FREQUENCY_HOPPING_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->puschFrequencyHopping = SUPPORTED;
- }
- else
+ for(index = 0; index < paramRsp->number_of_tlvs; index++)
+ {
+ switch(paramRsp->tlvs[index].tl.tag)
{
- cellParam->puschFrequencyHopping = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPuschDmrsConfig(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_PUSCH_DMRS_MAX_LEN_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPuschDmrsLength(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPuschDmrsAddPos(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_PUSCH_CBG_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->puschCbg = SUPPORTED;
+ case FAPI_RELEASE_CAPABILITY_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
+ if(encodedVal != RFAILED && (encodedVal & RELEASE_15) == RELEASE_15)
+ {
+ cellParam->releaseCapability = RELEASE_15;
+ }
+ break;
+
+ case FAPI_PHY_STATE_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != clGlobalCp.phyState)
+ {
+ printf("\n PhyState mismatch [%d][%d]", clGlobalCp.phyState, clGlobalCp.event);
+ RETVALUE(RFAILED);
+ }
+ break;
+
+ case FAPI_SKIP_BLANK_DL_CONFIG_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->skipBlankDlConfig = SUPPORTED;
+ }
+ else
+ {
+ cellParam->skipBlankDlConfig = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_SKIP_BLANK_UL_CONFIG_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->skipBlankUlConfig = SUPPORTED;
+ }
+ else
+ {
+ cellParam->skipBlankUlConfig = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG:
+ cellParam->numTlvsToReport = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
+ break;
+
+ case FAPI_CYCLIC_PREFIX_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillCyclicPrefix(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillSubcarrierSpaceDl(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_SUPPORTED_BANDWIDTH_DL_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
+ if(encodedVal != RFAILED)
+ {
+ fillBandwidthDl(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillSubcarrierSpaceUl(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_SUPPORTED_BANDWIDTH_UL_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16);
+ if(encodedVal != RFAILED)
+ {
+ fillBandwidthUl(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_CCE_MAPPING_TYPE_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillCCEmaping(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->coresetOutsideFirst3OfdmSymsOfSlot = SUPPORTED;
+ }
+ else
+ {
+ cellParam->coresetOutsideFirst3OfdmSymsOfSlot = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_PRECODER_GRANULARITY_CORESET_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->precoderGranularityCoreset = SUPPORTED;
+ }
+ else
+ {
+ cellParam->precoderGranularityCoreset = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_PDCCH_MU_MIMO_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->pdcchMuMimo = SUPPORTED;
+ }
+ else
+ {
+ cellParam->pdcchMuMimo = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_PDCCH_PRECODER_CYCLING_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->pdcchPrecoderCycling = SUPPORTED;
+ }
+ else
+ {
+ cellParam->pdcchPrecoderCycling = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_MAX_PDCCHS_PER_SLOT_TAG:
+ cellParam->maxPdcchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ break;
+
+ case FAPI_PUCCH_FORMATS_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPucchFormat(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_MAX_PUCCHS_PER_SLOT_TAG:
+ cellParam->maxPucchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ break;
+
+ case FAPI_PDSCH_MAPPING_TYPE_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPdschMappingType(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_PDSCH_ALLOCATION_TYPES_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPdschAllocationType(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPrbMappingType(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_PDSCH_CBG_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->pdschCbg = SUPPORTED;
+ }
+ else
+ {
+ cellParam->pdschCbg = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPdschDmrsConfigType(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_PDSCH_DMRS_MAX_LENGTH_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPdschDmrsLength(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPdschDmrsAddPos(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG:
+ cellParam->maxPdschsTBsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ break;
+
+ case FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal < FAPI_MAX_NUMBERMIMO_LAYERS_PDSCH)
+ {
+ cellParam->maxNumberMimoLayersPdsch = encodedVal;
+ }
+ break;
+
+ case FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillModulationOrderDl(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_MAX_MU_MIMO_USERS_DL_TAG:
+ cellParam->maxMuMimoUsersDl = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ break;
+
+ case FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->pdschDataInDmrsSymbols = SUPPORTED;
+ }
+ else
+ {
+ cellParam->pdschDataInDmrsSymbols = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_PREMPTIONSUPPORT_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->premptionSupport = SUPPORTED;
+ }
+ else
+ {
+ cellParam->premptionSupport = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_PDSCH_NON_SLOT_SUPPORT_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->pdschNonSlotSupport = SUPPORTED;
+ }
+ else
+ {
+ cellParam->pdschNonSlotSupport = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->uciMuxUlschInPusch = SUPPORTED;
+ }
+ else
+ {
+ cellParam->uciMuxUlschInPusch = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_UCI_ONLY_PUSCH_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->uciOnlyPusch = SUPPORTED;
+ }
+ else
+ {
+ cellParam->uciOnlyPusch = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_PUSCH_FREQUENCY_HOPPING_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->puschFrequencyHopping = SUPPORTED;
+ }
+ else
+ {
+ cellParam->puschFrequencyHopping = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPuschDmrsConfig(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_PUSCH_DMRS_MAX_LEN_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPuschDmrsLength(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPuschDmrsAddPos(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_PUSCH_CBG_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->puschCbg = SUPPORTED;
+ }
+ else
+ {
+ cellParam->puschCbg = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_PUSCH_MAPPING_TYPE_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPuschMappingType(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_PUSCH_ALLOCATION_TYPES_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPuschAllocationType(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPuschPrbMappingType(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_PUSCH_MAX_PTRS_PORTS_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal < FAPI_PUSCH_MAX_PTRS_PORTS_UB)
+ {
+ cellParam->puschMaxPtrsPorts = encodedVal;
+ }
+ break;
+
+ case FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG:
+ cellParam->maxPduschsTBsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ break;
+
+ case FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG:
+ cellParam->maxNumberMimoLayersNonCbPusch = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ break;
+
+ case FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillModulationOrderUl(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_MAX_MU_MIMO_USERS_UL_TAG:
+ cellParam->maxMuMimoUsersUl = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ break;
+
+ case FAPI_DFTS_OFDM_SUPPORT_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->dftsOfdmSupport = SUPPORTED;
+ }
+ else
+ {
+ cellParam->dftsOfdmSupport = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_PUSCH_AGGREGATION_FACTOR_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPuschAggregationFactor(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_PRACH_LONG_FORMATS_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPrachLongFormat(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_PRACH_SHORT_FORMATS_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillPrachShortFormat(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_PRACH_RESTRICTED_SETS_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED && encodedVal != 0)
+ {
+ cellParam->prachRestrictedSets = SUPPORTED;
+ }
+ else
+ {
+ cellParam->prachRestrictedSets = NOT_SUPPORTED;
+ }
+ break;
+
+ case FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillFdOccasions(encodedVal, &cellParam);
+ }
+ break;
+
+ case FAPI_RSSI_MEASUREMENT_SUPPORT_TAG:
+ encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
+ if(encodedVal != RFAILED)
+ {
+ fillRssiMeas(encodedVal, &cellParam);
+ }
+ break;
+ default:
+ //printf("\n Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index);
+ break;
}
- else
- {
- cellParam->puschCbg = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_PUSCH_MAPPING_TYPE_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPuschMappingType(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_PUSCH_ALLOCATION_TYPES_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPuschAllocationType(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPuschPrbMappingType(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_PUSCH_MAX_PTRS_PORTS_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal < FAPI_PUSCH_MAX_PTRS_PORTS_UB)
- {
- cellParam->puschMaxPtrsPorts = encodedVal;
- }
- break;
-
- case FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG:
- cellParam->maxPduschsTBsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- break;
-
- case FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG:
- cellParam->maxNumberMimoLayersNonCbPusch = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- break;
-
- case FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillModulationOrderUl(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_MAX_MU_MIMO_USERS_UL_TAG:
- cellParam->maxMuMimoUsersUl = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- break;
-
- case FAPI_DFTS_OFDM_SUPPORT_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->dftsOfdmSupport = SUPPORTED;
- }
- else
- {
- cellParam->dftsOfdmSupport = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_PUSCH_AGGREGATION_FACTOR_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPuschAggregationFactor(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_PRACH_LONG_FORMATS_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPrachLongFormat(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_PRACH_SHORT_FORMATS_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillPrachShortFormat(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_PRACH_RESTRICTED_SETS_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED && encodedVal != 0)
- {
- cellParam->prachRestrictedSets = SUPPORTED;
- }
- else
- {
- cellParam->prachRestrictedSets = NOT_SUPPORTED;
- }
- break;
-
- case FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillFdOccasions(encodedVal, &cellParam);
- }
- break;
-
- case FAPI_RSSI_MEASUREMENT_SUPPORT_TAG:
- encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
- if(encodedVal != RFAILED)
- {
- fillRssiMeas(encodedVal, &cellParam);
- }
- break;
-
- default:
- printf("\n Invalid value for TLV[%d]", paramRsp->tlvs[index].tl.tag);
- break;
- }
- }
- }
- else
- {
- printf("\n Error Indication Evnt received in state[%d] event[%d]", clGlobalCp.phyState, clGlobalCp.event);
- RETVALUE(RFAILED);
- }
- RETVALUE(ROK);
+ }
+ MAC_FREE(cellParam, sizeof(ClCellParam));
+ MAC_FREE(paramRsp, sizeof(fapi_param_resp_t));
+ return ROK;
+ }
+ else
+ {
+ DU_LOG("\n LOWER MAC: Invalid error code %d", paramRsp->error_code);
+ return RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nLOWER MAC: Failed to allocate memory for cell param");
+ return RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nLOWER MAC: Param Response received from PHY is NULL");
+ return RFAILED;
+ }
}
/*******************************************************************
S16 lwr_mac_handleConfigReqEvt(void *msg)
{
- RETVALUE(ROK);
+ uint8_t index = 0;
+ uint32_t msgLen = 0;
+ uint32_t configReqSize;
+ RgCellCb *cellParams;
+ MacCellCfg macCfgParams;
+ Inst inst = 0;
+
+ DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
+
+ fapi_config_req_t *configReq;
+ cellParams = rgCb[inst].cell;
+ macCfgParams = cellParams->macCellCfg;
+ configReqSize = sizeof(fapi_config_req_t) + (macCfgParams.numTlv * sizeof(fapi_uint16_tlv_t));
+ MAC_ALLOC(configReq, configReqSize);
+
+ if(configReq != NULL)
+ {
+ configReq->number_of_tlvs = macCfgParams.numTlv;
+
+ if(macCfgParams.dlCarrCfg.pres)
+ {
+ fillTlvs(&configReq->tlvs[index++], FAPI_DL_BANDWIDTH_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.bw, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_DL_FREQUENCY_TAG, sizeof(uint32_t), macCfgParams.dlCarrCfg.freq, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_DL_K0_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.k0[0], &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_DL_GRIDSIZE_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.gridSize[0], &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_NUM_TX_ANT_TAG, sizeof(uint16_t), macCfgParams.dlCarrCfg.numAnt, &msgLen);
+ }
+ if(macCfgParams.ulCarrCfg.pres)
+ {
+ fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_BANDWIDTH_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.bw, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_FREQUENCY_TAG, sizeof(uint32_t), macCfgParams.ulCarrCfg.freq, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_UL_K0_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.k0[0], &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_UL_GRID_SIZE_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.gridSize[0], &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_NUM_RX_ANT_TAG, sizeof(uint16_t), macCfgParams.ulCarrCfg.numAnt, &msgLen);
+ }
+ fillTlvs(&configReq->tlvs[index++], FAPI_FREQUENCY_SHIFT_7P5_KHZ_TAG, sizeof(uint8_t), macCfgParams.freqShft, &msgLen);
+
+ /* fill cell config */
+ fillTlvs(&configReq->tlvs[index++], FAPI_PHY_CELL_ID_TAG, sizeof(uint8_t), macCfgParams.phyCellId, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_FRAME_DUPLEX_TYPE_TAG, sizeof(uint8_t), macCfgParams.dupType, &msgLen);
+
+ /* fill SSB configuration */
+ fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_POWER_TAG, sizeof(uint32_t), macCfgParams.ssbCfg.ssbPbchPwr, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_BCH_PAYLOAD_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.bchPayloadFlag, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_SCS_COMMON_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.scsCmn, &msgLen);
+
+ /* fill PRACH configuration */
+ fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SEQUENCE_LENGTH_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachSeqLen, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SUBC_SPACING_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachSubcSpacing, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_RESTRICTED_SET_CONFIG_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachRstSetCfg, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_NUM_PRACH_FD_OCCASIONS_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachFdm, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ROOT_SEQUENCE_INDEX_TAG, sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].rootSeqIdx, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_NUM_ROOT_SEQUENCES_TAG, sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numRootSeq, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_K1_TAG, sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].k1, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ZERO_CORR_CONF_TAG , sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].zeroCorrZoneCfg, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_NUM_UNUSED_ROOT_SEQUENCES_TAG, sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numUnusedRootSeq, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_UNUSED_ROOT_SEQUENCES_TAG,
+ sizeof(uint8_t), *(macCfgParams.prachCfg.fdm[0].unsuedRootSeq), &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PER_RACH_TAG, sizeof(uint8_t), macCfgParams.prachCfg.ssbPerRach, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, sizeof(uint8_t), macCfgParams.prachCfg.prachMultCarrBand, &msgLen);
+
+ /* fill SSB table */
+ fillTlvs(&configReq->tlvs[index++], FAPI_SSB_OFFSET_POINT_A_TAG, sizeof(uint16_t), macCfgParams.ssbCfg.ssbOffsetPointA, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_BETA_PSS_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.betaPss, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PERIOD_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.ssbPeriod, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_SSB_SUBCARRIER_OFFSET_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.ssbScOffset, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_MIB_TAG , sizeof(uint32_t), macCfgParams.ssbCfg.mibPdu[0], &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_SSB_MASK_TAG, sizeof(uint32_t), macCfgParams.ssbCfg.ssbMask[0], &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_BEAM_ID_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.beamId[0], &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.multCarrBand, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_MULTIPLE_CELLS_SS_PBCH_IN_A_CARRIER_TAG, sizeof(uint8_t), macCfgParams.ssbCfg.multCellCarr, &msgLen);
+
+ /* fill TDD table */
+ fillTlvs(&configReq->tlvs[index++], FAPI_TDD_PERIOD_TAG, sizeof(uint8_t), macCfgParams.tddCfg.tddPeriod, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_SLOT_CONFIG_TAG, sizeof(uint8_t), macCfgParams.tddCfg.slotCfg[0][0], &msgLen);
+
+ /* fill measurement config */
+ fillTlvs(&configReq->tlvs[index++], FAPI_RSSI_MESUREMENT_TAG, sizeof(uint8_t), macCfgParams.rssiUnit, &msgLen);
+
+ fillMsgHeader(&configReq->header, FAPI_CONFIG_REQUEST, msgLen);
+ DU_LOG("\nLOWER_MAC: Sending Config Request to Phy");
+ sendToPhy(configReq->header.message_type_id, msgLen, (void *)configReq);
+ MAC_FREE(configReq, configReqSize);
+ return ROK;
+ }
+ else
+ {
+ DU_LOG("\nLOWER_MAC: Failed to allocate memory for config Request");
+ return RFAILED;
+ }
}
-S16 lwr_mac_handleConfigRspEvt(fapi_config_resp_t *configRsp)
+S16 lwr_mac_handleConfigRspEvt(void *msg)
{
- RETVALUE(ROK);
+ fapi_config_resp_t *configRsp;
+ configRsp = (fapi_config_resp_t *)msg;
+ DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState);
+
+ if(configRsp != NULL)
+ {
+ if(configRsp->error_code == MSG_OK)
+ {
+ DU_LOG("\nLOWER MAC: PHY has moved to Conigured state \n");
+ clGlobalCp.phyState = PHY_STATE_CONFIGURED;
+ MAC_FREE(configRsp, sizeof(fapi_config_resp_t));
+ return ROK;
+ }
+ else
+ {
+
+ DU_LOG("\n LOWER MAC: Invalid error code %d", configRsp->error_code);
+ return RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nLOWER_MAC: Config Response received from PHY is NULL");
+ return RFAILED;
+ }
}
S16 lwr_mac_handleStartReqEvt(void *msg)
{
- /*fapi_slot_ind_t *slotInd;
- slotInd->header.message_type_id = FAPI_SLOT_INDICATION;
- slotInd->sfn = 0;
- slotInd->slot = 1;
- phyToMac(slotInd->header.message_type_id, sizeof(fapi_slot_ind_t), (void *)slotInd);
- */
- RETVALUE(ROK);
+ uint32_t msgLen = 0;
+ fapi_start_req_t *startReq;
+ MAC_ALLOC(startReq, sizeof(fapi_start_req_t));
+
+ if(startReq != NULL)
+ {
+ fillMsgHeader(&startReq->header, FAPI_START_REQUEST, msgLen);
+ DU_LOG("\nLOWER MAC: Sending Start Request to PHY");
+ sendToPhy(startReq->header.message_type_id, sizeof(fapi_start_req_t), (void *)startReq);
+ MAC_FREE(startReq, sizeof(fapi_start_req_t));
+ return ROK;
+ }
+ else
+ {
+ DU_LOG("\nLOWER MAC: Failed to allocate memory for Start Request");
+ return RFAILED;
+ }
}
S16 lwr_mac_handleStopReqEvt(void *msg)
RETVALUE(ROK);
}
+/*******************************************************************
+ *
+ * @brief Modifes the received mibPdu to uint32 bit
+ * and stores it in MacCellCfg
+ *
+ * @details
+ *
+ * Function : setMibPdu
+ *
+ * Functionality:
+ * -Sets the MibPdu
+ *
+ * @params[in] Pointer to mibPdu
+ * pointer to modified value
+ ******************************************************************/
+
+PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val)
+{
+ *mibPdu |= (((uint8_t)(slotIndInfo.sfn >> 2)) & MIB_SFN_BITMASK);
+ *val = (mibPdu[0] << 24 | mibPdu[1] << 16 | mibPdu[2] << 8);
+ DU_LOG("\nLOWER MAC: value filled %x", *val);
+}
+
+/*******************************************************************
+ *
+ * @brief fills SSB PDU required for DL TTI info in MAC
+ *
+ * @details
+ *
+ * Function : fillSsbPdu
+ *
+ * Functionality:
+ * -Fills the SSB PDU info
+ * stored in MAC
+ *
+ * @params[in] Pointer to FAPI DL TTI Req
+ * Pointer to RgCellCb
+ * Pointer to msgLen of DL TTI Info
+ * @return ROK
+ *
+ ******************************************************************/
+
+S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg,
+uint32_t *msgLen)
+{
+ uint32_t mibPayload = 0;
+ if(dlTtiReqPdu != NULL)
+ {
+ dlTtiReqPdu->pduType = SSB_PDU_TYPE; /* SSB PDU */
+ dlTtiReqPdu->u.ssb_pdu.physCellId = macCellCfg->phyCellId;
+ dlTtiReqPdu->u.ssb_pdu.betaPss = macCellCfg->ssbCfg.betaPss;
+ dlTtiReqPdu->u.ssb_pdu.ssbBlockIndex = macCb.macCell->dlSlot[0].cellBroadcastInfo.ssbIdxSupported;
+ dlTtiReqPdu->u.ssb_pdu.ssbSubCarrierOffset = macCellCfg->ssbCfg.ssbScOffset;
+ /* ssbOfPdufstA to be filled in ssbCfg */
+ dlTtiReqPdu->u.ssb_pdu.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA;
+ dlTtiReqPdu->u.ssb_pdu.bchPayloadFlag = macCellCfg->ssbCfg.bchPayloadFlag;
+ /* Bit manipulation for SFN */
+ setMibPdu(macCellCfg->ssbCfg.mibPdu, &mibPayload);
+ dlTtiReqPdu->u.ssb_pdu.bchPayload.v.bchPayload = mibPayload;
+ dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.numPrgs = 0;
+ dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.prgSize = 0;
+ dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.digBfInterfaces = 0;
+ dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.pmi_bfi[0].pmIdx = 0;
+ dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming. \
+ pmi_bfi[0].beamIdx[0].beamidx = macCellCfg->ssbCfg.beamId[0];
+ dlTtiReqPdu->pduSize = sizeof(fapi_dl_ssb_pdu_t); /* Size of SSB PDU */
+ SETLENGTH(*msgLen, sizeof(fapi_dl_ssb_pdu_t));
+ return ROK;
+ }
+ else
+ {
+ return RFAILED;
+ }
+}
+
+/*******************************************************************
+ *
+ * @brief Sends DL TTI Request to PHY
+ *
+ * @details
+ *
+ * Function : handleDlTtiReq
+ *
+ * Functionality:
+ * -Sends FAPI Param req to PHY
+ *
+ * @params[in] RgDlSf *dlTtiReqSlot
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+S16 handleDlTtiReq(CmLteTimingInfo *dlTtiReqtimingInfo)
+{
+ uint32_t msgLen;
+ fapi_dl_tti_req_t *dlTtiReq;
+ fapi_dl_tti_req_pdu_t *dlTtiReqPdu;
+ RgCellCb *cellCbParams;
+ MacCellCfg macCellCfg;
+ Inst inst = 0;
+
+ cellCbParams = rgCb[inst].cell;
+ if(dlTtiReqtimingInfo != NULLP)
+ {
+ MAC_ALLOC(dlTtiReq, sizeof(fapi_dl_tti_req_t));
+ if(dlTtiReq != NULLP)
+ {
+ /* fill the SFN and slot value from crntTime */
+ dlTtiReq->sfn = dlTtiReqtimingInfo->sfn;
+ dlTtiReq->slot = dlTtiReqtimingInfo->slot;
+ dlTtiReq->nPdus = 0;
+ dlTtiReq->nGroup = 0;
+ if(macCb.macCell->dlSlot[0].cellBroadcastInfo.ssbTrans)
+ {
+ macCellCfg = cellCbParams->macCellCfg;
+
+ MAC_ALLOC(dlTtiReqPdu, sizeof(fapi_dl_tti_req_pdu_t));
+ if(dlTtiReqPdu != NULLP)
+ {
+ fillSsbPdu(dlTtiReqPdu, &macCellCfg, &msgLen);
+ dlTtiReq->pdus = dlTtiReqPdu;
+ }
+ (dlTtiReq->nPdus)++;
+ msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t);
+ fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen);
+ sendToPhy(dlTtiReq->header.message_type_id, msgLen, (void *)dlTtiReq);
+ MAC_FREE(dlTtiReqPdu, sizeof(fapi_dl_tti_req_pdu_t));
+ }
+ MAC_FREE(dlTtiReq, sizeof(fapi_dl_tti_req_t));
+ return ROK;
+ }
+ else
+ {
+ DU_LOG("\nLOWER MAC: Failed to allocate memory for DL TTI Request");
+ return RFAILED;
+ }
+ }
+ else
+ {
+ DU_LOG("\nLOWER MAC: Current TTI Info is NULL");
+ return RFAILED;
+ }
+}
+
lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] =
{
{
lwr_mac_handleConfigReqEvt,
lwr_mac_handleConfigRspEvt,
lwr_mac_handleInvalidEvt,
- lwr_mac_handleInvalidEvt
},
{
/* PHY_STATE_CONFIGURED */
lwr_mac_handleConfigReqEvt,
lwr_mac_handleConfigRspEvt,
lwr_mac_handleStartReqEvt,
- lwr_mac_handleInvalidEvt
},
{
/* PHY_STATE_RUNNING */
lwr_mac_handleConfigReqEvt,
lwr_mac_handleConfigRspEvt,
lwr_mac_handleInvalidEvt,
- lwr_mac_handleStopReqEvt
}
};
* @return void
*
******************************************************************/
-S16 sendToLowerMac(U16 msgType, U32 msgLen, void *msg)
+void sendToLowerMac(uint16_t msgType, uint32_t msgLen, void *msg)
{
clGlobalCp.event = msgType;
- fapiEvtHdlr[clGlobalCp.phyState][msgType](msg);
+ fapiEvtHdlr[clGlobalCp.phyState][clGlobalCp.event](msg);
}
/**********************************************************************
+++ /dev/null
-/*******************************************************************************
-################################################################################
-# Copyright (c) [2017-2019] [Radisys] #
-# #
-# Licensed under the Apache License, Version 2.0 (the "License"); #
-# you may not use this file except in compliance with the License. #
-# You may obtain a copy of the License at #
-# #
-# http://www.apache.org/licenses/LICENSE-2.0 #
-# #
-# Unless required by applicable law or agreed to in writing, software #
-# distributed under the License is distributed on an "AS IS" BASIS, #
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #
-# See the License for the specific language governing permissions and #
-# limitations under the License. #
-################################################################################
-*******************************************************************************/
-
-/* This file contains handler for FAPI messages to be sent or received from PHY */
-
-#include "envdep.h"
-#include "gen.h"
-#include "ssi.h"
-#include "cm_hash.h"
-
-#include "gen.x"
-#include "ssi.x"
-#include "cm_hash.x"
-
-#include "du_app_mac_inf.h"
-#include "lwr_mac.h"
-#include "rg_cl_phy.h"
-#include "fapi.h"
-/*#include "wls_lib.h"*/
-
-EXTERN S16 sendToPhy ARGS((U16 msgType, U32 msgLen, void *msg));
-
-/*******************************************************************
- *
- * @brief Fills FAPI message header
- *
- * @details
- *
- * Function : fillMsgHdr
- *
- * Functionality:
- * -Fills FAPI message header
- *
- * @params[in] Pointer to header
- * Number of messages
- * Messae Type
- * Length of message
- * @return void
- *
- * ****************************************************************/
-PUBLIC void fillMsgHdr(MsgHdr *hdr, U8 nMsg, U16 msgType, U32 msgLen)
-{
- hdr->nMsg = nMsg;
- hdr->msgType = msgType;
- hdr->msgLen = msgLen;
-}
-
- /*******************************************************************
- *
- * @brief Fills TLV
- *
- * @details
- *
- * Function : fillTlv
- *
- * Functionality:
- * -Fills TLV
- *
- * @params[in] Pointer to TLV
- * Tag
- * Length
- * Value
- * @return Void
- *
- * ****************************************************************/
-PUBLIC void fillTlv(L1L2Tlv *tlv, U16 tag, U16 len, U16 value)
-{
- tlv->tag = tag;
- tlv->length = len;
- tlv->value = value;
-}
-
-
- /*******************************************************************
- *
- * @brief Fills next config TLV
- *
- * @details
- *
- * Function : fillConfigTLV
- *
- * Functionality:
- * - Finds pointer to next TLV in config req
- * - Fills the TLV
- * - Calculates Message length
- *
- * @params[in]
- * @return ROK - void
- *
- * ****************************************************************/
-PUBLIC void fillConfigTLV(L1L2Tlv *nextTlv, U8 *configTlvs, U16 tag, U16 length, U16 value, U16 *msgLen)
-{
- nextTlv = (L1L2Tlv *)(configTlvs + *msgLen);
- fillTlv(nextTlv, tag, length, value);
- *msgLen = *msgLen + sizeof(tag) + sizeof(length) + length;
-}
-
-
- /*******************************************************************
- *
- * @brief Build and send FAPI config req to PHY
- *
- * @details
- *
- * Function : rgClBldAndSndFAPICfgReq
- *
- * Functionality:
- * -Build and send FAPI config req to PHY
- *
- * @params[in]
- * @return ROK - success
- * RFAILED - failure
- *
- * ****************************************************************/
-
-PUBLIC S16 rgClBldAndSndFAPICfgReq
-(
-ClCellCb *cellCb
-)
-{
- U16 msgLen;
- U32 FAPIConfigReqSize;
- U8 *configTlvs;
- L1L2ConfigReq *FAPIConfigReq;
- L1L2Tlv *nextTlv;
- MacCellCfg cellCfg;
-
- FAPIConfigReqSize = sizeof(L1L2ConfigReq)
- + (cellCb->cellCfg.numTlv * sizeof(L1L2Tlv));
-
- /* TO DO :Change SGetSBuf to SGetSBufWls() later */
- if(SGetSBuf(0,0,(Data **)&FAPIConfigReq, FAPIConfigReqSize) != ROK )
- {
- printf("\nMemory allocation failed for PHY Config Req");
- RETVALUE(RFAILED);
- }
-
- nextTlv = NULLP;
- msgLen = 0;
- cellCfg = cellCb->cellCfg;
- configTlvs = (U8 *)((U8 *)FAPIConfigReq + MSG_HDR_SIZE + 2);
-
- FAPIConfigReq->nTlv = cellCfg.numTlv;
- FAPIConfigReq->carrierId = cellCb->cellId;
-
- /* Filling cell configuration */
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_PHY_CELL_ID, sizeof(U16), cellCfg.phyCellId, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_FRAME_DUP_TYPE, sizeof(U16), cellCfg.dupType, &msgLen);
-
- /* Filling DL carrier configuration */
- if(cellCfg.dlCarrCfg.pres)
- {
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_DL_BW, sizeof(U16), cellCfg.dlCarrCfg.bw, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_DL_FREQ, sizeof(U16), cellCfg.dlCarrCfg.freq, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_DLK0, sizeof(U16),cellCfg.dlCarrCfg.k0[0], &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_DL_GRID_SIZE, sizeof(U16),cellCfg.dlCarrCfg.gridSize[0], &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_NUM_TX_ANT, sizeof(U16), cellCfg.dlCarrCfg.numAnt, &msgLen);
- }
-
- /* Filling UL carrier configuration */
- if(cellCfg.ulCarrCfg.pres)
- {
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_UL_BW, sizeof(U16), cellCfg.ulCarrCfg.bw, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_UL_FREQ, sizeof(U16), cellCfg.ulCarrCfg.freq, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_ULK0, sizeof(U16), cellCfg.ulCarrCfg.k0[0], &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_UL_GRID_SIZE, sizeof(U16), cellCfg.ulCarrCfg.gridSize[0], &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_NUM_RX_ANT, sizeof(U16), cellCfg.ulCarrCfg.numAnt, &msgLen);
- }
-
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_FREQ_SHIFT_7P5KHZ, sizeof(U16), cellCfg.freqShft, &msgLen);
-
- /* Filling SSB configuration */
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SS_PBCH_PWR, sizeof(U16), cellCfg.ssbCfg.ssbPbchPwr, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_BCH_PAYLOAD, sizeof(U16), cellCfg.ssbCfg.bchPayloadFlag, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SCS_COMM, sizeof(U16), cellCfg.ssbCfg.scsCmn, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SSB_OFFS_POINT_A, sizeof(U16), cellCfg.ssbCfg.ssbOffsetPointA, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_BETA_PSS, sizeof(U16), cellCfg.ssbCfg.betaPss, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SSB_PERIOD, sizeof(U16), cellCfg.ssbCfg.ssbPeriod, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SSB_SUBC_OFFS, sizeof(U16), cellCfg.ssbCfg.ssbScOffset, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_MIB, sizeof(U16), cellCfg.ssbCfg.mibPdu, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SSB_MASK, sizeof(U16), cellCfg.ssbCfg.ssbMask[0], &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SS_PBCH_MULT_CARR_BAND, sizeof(U16), cellCfg.ssbCfg.multCarrBand, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_MULT_CELL_SS_PBCH_CARR, sizeof(U16), cellCfg.ssbCfg.multCellCarr, &msgLen);
-
- /* Filling PRACH configuration */
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_PRACH_SEQ_LEN, sizeof(U16), cellCfg.prachCfg.prachSeqLen, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_PRACH_SUBC_SPAC, sizeof(U16), cellCfg.prachCfg.prachSubcSpacing, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_RES_SET_CFG, sizeof(U16), cellCfg.prachCfg.prachRstSetCfg, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_NUM_PRACH_FD_OCC, sizeof(U16), cellCfg.prachCfg.prachFdm, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_PRACH_ROOT_SEQ_ID, sizeof(U16), cellCfg.prachCfg.fdm[0].rootSeqIdx, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_NUM_ROOT_SEQ, sizeof(U16), cellCfg.prachCfg.fdm[0].numRootSeq, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_K1, sizeof(U16), cellCfg.prachCfg.fdm[0].k1, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_PRACH_ZERO_CORR_CFG, sizeof(U16), cellCfg.prachCfg.fdm[0].zeroCorrZoneCfg, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_NUM_UNUSED_ROOT_SEQ, sizeof(U16), cellCfg.prachCfg.fdm[0].numUnusedRootSeq, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_UNUSED_ROOT_SEQ, sizeof(U16), *(cellCfg.prachCfg.fdm[0].unsuedRootSeq), &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SSB_PER_RACH, sizeof(U16), cellCfg.prachCfg.ssbPerRach, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_PRACH_MULT_CARR_BAND, sizeof(U16), cellCfg.prachCfg.prachMultCarrBand, &msgLen);
-
- /* Filling TDD configuration */
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_TDD_PERIOD, sizeof(U16), cellCfg.tddCfg.tddPeriod, &msgLen);
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_SLOT_CFG, sizeof(U16), cellCfg.tddCfg.slotCfg[0][0], &msgLen);
-
- /* Filling RSSI measurement configuration */
- fillConfigTLV(nextTlv, configTlvs, CFG_TAG_RSSI_MEAS, sizeof(U16), cellCfg.rssiUnit, &msgLen);
-
- msgLen = msgLen + sizeof(L1L2ConfigReq);
-
- /* Filling message header */
- fillMsgHdr(&FAPIConfigReq->hdr, 1, MSG_TYPE_CONFIG_REQ, msgLen);
-
- /* Sending msg to PHY */
- sendToPhy(MSG_TYPE_CONFIG_REQ, FAPIConfigReqSize, (void *)FAPIConfigReq);
-
- RETVALUE(ROK);
-}
-
-
-/*******************************************************************
- *
- * @brief Handles FAPI config response
- *
- * @details
- *
- * Function : rgClHndlCfgReq
- *
- * Functionality:
- * -Handles FAPI config request
- *
- * @params[in] Message pointer
- *
- * @return void
- *
- *****************************************************************/
-
-S16 rgClHndlCfgReq(void *msg)
-{
- ClCellCb *cellCb = NULLP;
- L1L2ConfigRsp *configRsp;
-
- configRsp = (L1L2ConfigRsp *)msg;
-
- if(configRsp->status != MSG_OK)
- {
- printf("\nPHY configuration failed");
- RETVALUE(RFAILED);
- }
-
- if((cellCb = (ClCellCb *)rgClUtlGetCellCb(configRsp->carrierId)) != NULLP)
- {
- printf("\nCell Id[%d] not found", configRsp->carrierId);
- RETVALUE(RFAILED);
- }
-
- cellCb->phyState = PHY_STATE_CONFIGURED;
- clGlobalCp.phyState = PHY_STATE_CONFIGURED;
-
- printf("\nReceived successful PHY configuration response");
-
- SPutSBuf(0, 0, (Data *)msg, configRsp->hdr.msgLen );
-
- RETVALUE(ROK);
-}
-
-/*******************************************************************
- *
- * @brief Handles FAPI param response
- *
- * @details
- *
- * Function : lwrMacHndlParamReq
- *
- * Functionality:
- * -Handles FAPI param request
- *
- * @params[in] Message pointer
- *
- * @return void
- *
- *****************************************************************/
-S16 lwrMacHndlParamReq(void *msg)
-{
- ClCellCb *cellCb = NULLP;
- fapi_param_resp_t *paramRsp;
-
- paramRsp = (fapi_param_resp_t *)msg;
-
- if(paramRsp->error_code != MSG_OK)
- {
- printf("\nPHY configuration failed");
- RETVALUE(RFAILED);
- }
-
- if(paramRsp->tlvs[0].value == 0)
- {
- cellCb->phyState = PHY_STATE_IDLE;
- clGlobalCp.phyState = PHY_STATE_IDLE;
- }
-
- printf("\nReceived successful PHY configuration response");
-
- SPutSBuf(0, 0, (Data *)msg, paramRsp->header.length);
-
-
- RETVALUE(ROK);
-
-}
-
-/**********************************************************************
- End of file
-**********************************************************************/
*******************************************************************************/
/*This file contains stub for PHY to handle messages to/from MAC CL */
+#include <stdint.h>
#include "envdep.h"
#include "gen.h"
#include "rg_cl_phy.h"
#include "lwr_mac.h"
#include "fapi.h"
-
-
-EXTERN void phyToMac ARGS((U16 msgType, U32 msgLen,void *msg));
-EXTERN void fillTlvs ARGS((fapi_uint16_tlv_t *tlv, U16 tag, U16 length, U16 value, U16 *msgLen));
-EXTERN void fillMsgHeader ARGS((fapi_msg_t *hdr, U16 msgType, U16 msgLen));
-EXTERN S16 sendToLowerMac ARGS((U16 msgType, U32 msgLen,void *msg));
-
+#include "lphy_stub.h"
+
+#define MAX_SLOT_VALUE 9
+#define MAX_SFN_VALUE 1023
+
+uint16_t sfnValue = 0;
+uint16_t slotValue = 0;
+EXTERN void phyToMac ARGS((uint16_t msgType, uint32_t msgLen,void *msg));
+EXTERN void fillTlvs ARGS((fapi_uint16_tlv_t *tlv, uint16_t tag, uint16_t
+length, uint16_t value, uint32_t *msgLen));
+EXTERN void fillMsgHeader ARGS((fapi_msg_t *hdr, uint16_t msgType, uint16_t msgLen));
+EXTERN void sendToLowerMac ARGS((uint16_t msgType, uint32_t msgLen,void *msg));
+EXTERN void handlePhyMessages ARGS((void *msg));
/*******************************************************************
*
* @brief Builds and sends param response to MAC CL
*
* @details
*
- * Function : lwrMacBldAndSndParamRsp
+ * Function : l1BldAndSndParamRsp
*
* Functionality:
* - Builds and sends param response to MAC
* RFAILED - failure
*
* ****************************************************************/
-S16 lwrMacBldAndSndParamRsp(void *msg)
+S16 l1BldAndSndParamRsp(fapi_param_resp_t *fapiParamRsp)
{
- S16 index = 0;
- U16 msgLen = 0;
- fapi_param_resp_t *fapiParamRsp;
- fapiParamRsp = (fapi_param_resp_t *)msg;
-#if 0
- if(SGetSBuf(0, 0, (Data **)&fapiParamRsp, sizeof(fapi_param_resp_t)) != ROK)
- {
- printf("\nMemory allocation failed for PHY Config Response");
- RETVALUE(RFAILED);
- }
-#endif
+ uint8_t index = 0;
+ uint32_t msgLen = 0;
+
/* Cell Params */
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_RELEASE_CAPABILITY_TAG, sizeof(U16), 1, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PHY_STATE_TAG, sizeof(U16), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SKIP_BLANK_DL_CONFIG_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SKIP_BLANK_UL_CONFIG_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG, sizeof(U8), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_RELEASE_CAPABILITY_TAG, sizeof(uint16_t), 1, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PHY_STATE_TAG, sizeof(uint16_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SKIP_BLANK_DL_CONFIG_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SKIP_BLANK_UL_CONFIG_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_NUM_CONFIG_TLVS_TO_REPORT_TYPE_TAG, sizeof(uint8_t), 0, &msgLen);
/* Carrier Params */
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_CYCLIC_PREFIX_TAG, sizeof(U8), 1, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG, sizeof(U8), 1, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_BANDWIDTH_DL_TAG, sizeof(U16), 1, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_BANDWIDTH_UL_TAG, sizeof(U16), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_CYCLIC_PREFIX_TAG, sizeof(uint8_t), 1, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_SUBCARRIER_SPACING_DL_TAG, sizeof(uint8_t), 1, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_BANDWIDTH_DL_TAG, sizeof(uint16_t), 1, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_SUBCARRIER_SPACING_UL_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_BANDWIDTH_UL_TAG, sizeof(uint16_t), 0, &msgLen);
/* PDCCH Param*/
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_CCE_MAPPING_TYPE_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRECODER_GRANULARITY_CORESET_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDCCH_MU_MIMO_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDCCH_PRECODER_CYCLING_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PDCCHS_PER_SLOT_TAG, sizeof(U8), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_CCE_MAPPING_TYPE_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_CORESET_OUTSIDE_FIRST_3_OFDM_SYMS_OF_SLOT_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRECODER_GRANULARITY_CORESET_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDCCH_MU_MIMO_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDCCH_PRECODER_CYCLING_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PDCCHS_PER_SLOT_TAG, sizeof(uint8_t), 0, &msgLen);
/* PUCCH Param */
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUCCH_FORMATS_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PUCCHS_PER_SLOT_TAG, sizeof(U8), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUCCH_FORMATS_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PUCCHS_PER_SLOT_TAG, sizeof(uint8_t), 0, &msgLen);
/* PDSCH Param */
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_MAPPING_TYPE_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_ALLOCATION_TYPES_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_CBG_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DMRS_MAX_LENGTH_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_MU_MIMO_USERS_DL_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PREMPTIONSUPPORT_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_NON_SLOT_SUPPORT_TAG, sizeof(U8), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_MAPPING_TYPE_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_ALLOCATION_TYPES_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_VRB_TO_PRB_MAPPING_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_CBG_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DMRS_CONFIG_TYPES_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DMRS_MAX_LENGTH_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DMRS_ADDITIONAL_POS_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PDSCHS_TBS_PER_SLOT_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_NUMBER_MIMO_LAYERS_PDSCH_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_MAX_MODULATION_ORDER_DL_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_MU_MIMO_USERS_DL_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PREMPTIONSUPPORT_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PDSCH_NON_SLOT_SUPPORT_TAG, sizeof(uint8_t), 0, &msgLen);
/* PUSCH Param */
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_UCI_ONLY_PUSCH_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_FREQUENCY_HOPPING_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_DMRS_MAX_LEN_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_CBG_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_MAPPING_TYPE_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_ALLOCATION_TYPES_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_MAX_PTRS_PORTS_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_MU_MIMO_USERS_UL_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_DFTS_OFDM_SUPPORT_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_AGGREGATION_FACTOR_TAG, sizeof(U8), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_UCI_MUX_ULSCH_IN_PUSCH_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_UCI_ONLY_PUSCH_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_FREQUENCY_HOPPING_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_DMRS_CONFIG_TYPES_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_DMRS_MAX_LEN_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_DMRS_ADDITIONAL_POS_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_CBG_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_MAPPING_TYPE_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_ALLOCATION_TYPES_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_VRB_TO_PRB_MAPPING_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_MAX_PTRS_PORTS_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PDUSCHS_TBS_PER_SLOT_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_NUMBER_MIMO_LAYERS_NON_CB_PUSCH_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_SUPPORTED_MODULATION_ORDER_UL_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_MU_MIMO_USERS_UL_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_DFTS_OFDM_SUPPORT_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PUSCH_AGGREGATION_FACTOR_TAG, sizeof(uint8_t), 0, &msgLen);
/* PRACH Params */
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRACH_LONG_FORMATS_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRACH_SHORT_FORMATS_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRACH_RESTRICTED_SETS_TAG, sizeof(U8), 0, &msgLen);
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG, sizeof(U8), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRACH_LONG_FORMATS_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRACH_SHORT_FORMATS_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_PRACH_RESTRICTED_SETS_TAG, sizeof(uint8_t), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_MAX_PRACH_FD_OCCASIONS_IN_A_SLOT_TAG, sizeof(uint8_t), 0, &msgLen);
/* MEASUREMENT TAG */
- fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_RSSI_MEASUREMENT_SUPPORT_TAG, sizeof(U8), 0, &msgLen);
+ fillTlvs(&fapiParamRsp->tlvs[index++], FAPI_RSSI_MEASUREMENT_SUPPORT_TAG, sizeof(uint8_t), 0, &msgLen);
fapiParamRsp->number_of_tlvs = index;
msgLen = msgLen + sizeof(fapi_param_resp_t);
fillMsgHeader(&fapiParamRsp->header, FAPI_PARAM_RESPONSE, msgLen);
fapiParamRsp->error_code = MSG_OK;
- if(sendToLowerMac(fapiParamRsp->header.message_type_id, sizeof(fapi_param_resp_t), (void *)fapiParamRsp) != ROK)
- {
- RETVALUE(RFAILED);
- }
- printf("\n Filled the Param Response successfully");
- RETVALUE(ROK);
+ printf("\nPHY_STUB: Sending Param Request to Lower Mac");
+ sendToLowerMac(fapiParamRsp->header.message_type_id, sizeof(fapi_param_resp_t), (void *)fapiParamRsp);
+ return ROK;
}
/*******************************************************************
*
- * @brief Builds and sends config response to MAC CL
+ * @brief Builds and sends config response to lower mac
*
* @details
*
- * Function : l1BldAndSndCfgRsp
+ * Function : l1BldAndSndConfigRsp
*
* Functionality:
* - Builds and sends config response to MAC
*
* ****************************************************************/
-S16 l1BldAndSndCfgRsp(void *msg)
+S16 l1BldAndSndConfigRsp(fapi_config_resp_t *fapiConfigRsp)
{
- L1L2ConfigReq *FAPIConfigReq;
- L1L2ConfigRsp *FAPIConfigRsp;
- U8 cci;
+ uint8_t index = 0;
+ uint32_t msgLen = 0;
- FAPIConfigReq = (L1L2ConfigReq *)msg;
- cci = FAPIConfigReq->carrierId;
- SPutSBuf(0, 0, (Data *)msg, FAPIConfigReq->hdr.msgLen);
-
- if(SGetSBuf(0, 0, (Data **)&FAPIConfigRsp, sizeof(L1L2ConfigRsp)) != ROK)
+ if(fapiConfigRsp != NULL)
{
- printf("\nMemory allocation failed for PHY Config Response");
- RETVALUE(RFAILED);
+ fapiConfigRsp->number_of_invalid_tlvs = NULLP;
+ fapiConfigRsp->number_of_inv_tlvs_idle_only = NULLP;
+ fapiConfigRsp->number_of_missing_tlvs = NULLP;
+ fapiConfigRsp->error_code = MSG_OK;
+ msgLen += sizeof(fapi_config_resp_t);
+ fillMsgHeader(&fapiConfigRsp->header, FAPI_CONFIG_RESPONSE, msgLen);
+ printf("\nPHY_STUB: Sending Config Response to Lower Mac");
+ sendToLowerMac(fapiConfigRsp->header.message_type_id, sizeof(fapi_config_resp_t), (void *)fapiConfigRsp);
+ return ROK;
}
+}
- FAPIConfigRsp->hdr.nMsg = 1;
- FAPIConfigRsp->hdr.msgType = MSG_TYPE_CONFIG_RSP;
- FAPIConfigRsp->hdr.msgLen = sizeof(L1L2ConfigRsp);
-
- FAPIConfigRsp->carrierId = cci;
- FAPIConfigRsp->status = MSG_OK;
- FAPIConfigRsp->numUnsuppTlv = 0;
- FAPIConfigRsp->unsuppTlvLst = NULLP;
- FAPIConfigRsp->numInvTlvForPhySta = 0;
- FAPIConfigRsp->phyIdleCfgTlvLst = NULLP;
- FAPIConfigRsp->phyRunCfgTlvLst = NULLP;
- FAPIConfigRsp->numMissingTlv = 0;
- FAPIConfigRsp->missingTlvLst = NULLP;
+/*******************************************************************
+ *
+ * @brief Handles param request received from MAC
+ *
+ * @details
+ *
+ * Function : l1HdlParamReq
+ *
+ * Functionality:
+ * -Handles param request received from MAC
+ *
+ * @params[in] Message length
+ * Param request message pointer
+ *
+ * @return void
+ *
+ * ****************************************************************/
- phyToMac(MSG_TYPE_CONFIG_RSP, sizeof(L1L2ConfigRsp), FAPIConfigRsp);
+PUBLIC void l1HdlParamReq(uint32_t msgLen, void *msg)
+{
+ printf("\nPHY_STUB: Received Param Request in PHY");
- RETVALUE(ROK);
-}
+ /* Handling PARAM RESPONSE */
+ if(l1BldAndSndParamRsp(msg)!= ROK)
+ {
+ printf("\nPHY_STUB: Failed Sending Param Response");
+ }
+}
/*******************************************************************
*
*
* @details
*
- * Function : l1HndlConfigReq
+ * Function : l1HdlConfigReq
*
* Functionality:
* -Handles config request received from MAC
*
* @params[in] Message length
- * Config request message pointer
+ * config request message pointer
*
* @return void
*
* ****************************************************************/
-void l1HndlConfigReq(U16 msgLen, void *msg)
+PUBLIC void l1HdlConfigReq(uint32_t msgLen, void *msg)
{
- printf("\nReceived configuration request");
+ printf("\nPHY_STUB: Received Config Request in PHY");
- /* TO DO : validate all received TLVs and send back any unsupported/missing TLV */
-
- if(l1BldAndSndCfgRsp(msg) != ROK)
- {
- printf("\nFailed Sending config response");
- }
+ /* Handling CONFIG RESPONSE */
+ if(l1BldAndSndConfigRsp(msg)!= ROK)
+ {
+ printf("\nPHY_STUB: Failed Sending config Response");
+ }
}
/*******************************************************************
*
- * @brief Handles param request received from MAC
+ * @brief Builds and Send the Slot Indication message to MAC
*
* @details
*
- * Function : lwrMacHdlParamReq
+ * Function : buildAndSendSlotIndication
*
* Functionality:
- * -Handles param request received from MAC
+ * -Send the Slot indication Message to MAC
*
* @params[in] Message length
- * Param request message pointer
+ * config request message pointer
*
* @return void
*
* ****************************************************************/
-
-PUBLIC void lwrMacHdlParamReq(U16 msgLen, void *msg)
+PUBLIC void buildAndSendSlotIndication()
{
- printf("\n Received Param Request in PHY");
-
- /* Handling PARAM RESPONSE */
- if(lwrMacBldAndSndParamRsp(msg)!= ROK)
+ fapi_slot_ind_t *slotIndMsg;
+ if(SGetSBuf(0, 0, (Data **)&slotIndMsg, sizeof(slotIndMsg)) != ROK)
{
- printf("\n Failed Sending Param Response");
+ printf("\nPHY_STUB: Memory allocation failed for slot Indication Message");
+ return RFAILED;
}
-}
+ else
+ {
+ slotValue++;
+ if(sfnValue >= MAX_SFN_VALUE && slotValue >= MAX_SLOT_VALUE)
+ {
+ sfnValue = 0;
+ slotValue = 0;
+ }
+ else if(slotValue >= MAX_SLOT_VALUE)
+ {
+ sfnValue++;
+ slotValue = 0;
+ }
+ slotIndMsg->sfn = sfnValue;
+ slotIndMsg->slot = slotValue;
+ fillMsgHeader(&slotIndMsg->header, FAPI_SLOT_INDICATION, sizeof(fapi_slot_ind_t));
+ printf("\nPHY_STUB: Sending Slot Indication Msg to Lower Mac");
+ handlePhyMessages((void*)slotIndMsg);
+ SPutSBuf(0, 0, (Data *)slotIndMsg, sizeof(slotIndMsg));
+ }
+}
/*******************************************************************
*
- * @brief Receives message from MAC
+ * @brief Handles start request received from MAC
*
* @details
*
- * Function : macToPhy
+ * Function : l1HdlStartReq
*
* Functionality:
- * - Receives message from MAC and calls handler
+ * -Handles start request received from MAC
*
- * @params[in] Message type
- * Message length
- * Message pointer
+ * @params[in] Message length
+ * config request message pointer
*
* @return void
*
* ****************************************************************/
-void macToPhy(U16 msgType, U32 msgLen, void *msg)
+PUBLIC void l1HdlStartReq(uint32_t msgLen, void *msg)
{
- switch(msgType)
+ if(clGlobalCp.phyState == PHY_STATE_CONFIGURED)
{
- case MSG_TYPE_CONFIG_REQ:
- l1HndlConfigReq(msgLen, msg);
- break;
- default:
- printf("\nInvalid message type[%x] received at PHY", msgType);
+ duStartSlotIndicaion();
+ SPutSBuf(0, 0, (Data *)msg, sizeof(fapi_start_req_t));
+
+ return ROK;
+ }
+ else
+ {
+ printf("\n PHY_STUB: Received Start Req in PHY State", clGlobalCp.phyState);
+ return RFAILED;
}
}
+/*******************************************************************
+*
+* @brief Handles Dl Tti request received from MAC
+*
+* @details
+*
+* Function : l1HdlDlTtiReq
+*
+* Functionality:
+* -Handles Dl Tti request received from MAC
+*
+* @params[in] Message length
+* Dl Tti request message pointer
+*
+* @return void
+*
+* ****************************************************************/
+
+PUBLIC void l1HdlDlTtiReq(uint16_t msgLen, void *msg)
+{
+ fapi_dl_tti_req_t *dlTtiReq;
+ dlTtiReq = (fapi_dl_tti_req_t *)msg;
+ printf("\nPHY_STUB: Received DL TTI Request in PHY");
+ printf("\nPHY_STUB: SFN %d", dlTtiReq->sfn);
+ printf("\nPHY_STUB: SLOT %d", dlTtiReq->slot);
+ printf("\nPHY_STUB: nPdus %d", dlTtiReq->nPdus);
+ printf("\nPHY_STUB: nGroup %d", dlTtiReq->nGroup);
+ /* Printing SSB CONFIGURED VALUES */
+ printf("\nPHY_STUB: physCellId %d", dlTtiReq->pdus->u.ssb_pdu.physCellId);
+ printf("\nPHY_STUB: betaPss %d", dlTtiReq->pdus->u.ssb_pdu.betaPss);
+ printf("\nPHY_STUB: ssbBlockIndex %d", dlTtiReq->pdus->u.ssb_pdu.ssbBlockIndex);
+ printf("\nPHY_STUB: ssbSubCarrierOffset %d", dlTtiReq->pdus->u.ssb_pdu.ssbSubCarrierOffset);
+ printf("\nPHY_STUB: ssbOffsetPointA %d", dlTtiReq->pdus->u.ssb_pdu.ssbOffsetPointA);
+ printf("\nPHY_STUB: bchPayloadFlag %d", dlTtiReq->pdus->u.ssb_pdu.bchPayloadFlag);
+ printf("\nPHY_STUB: bchPayload %x", dlTtiReq->pdus->u.ssb_pdu.bchPayload);
+
+ SPutSBuf(0, 0, (Data *)dlTtiReq, sizeof(fapi_dl_tti_req_t));
+ return ROK;
+}
/*******************************************************************
*
* @brief Receives message from MAC
*
* @details
*
- * Function : processRequest
+ * Function : processFapiRequest
*
* Functionality:
* - Receives message from MAC and calls handler
*
* ****************************************************************/
-void processRequest(U16 msgType, U32 msgLen, void *msg)
+void processFapiRequest(uint8_t msgType, uint32_t msgLen, void *msg)
{
switch(msgType)
{
case FAPI_PARAM_REQUEST:
- lwrMacHdlParamReq(msgLen, msg);
+ l1HdlParamReq(msgLen, msg);
+ break;
+ case FAPI_CONFIG_REQUEST:
+ l1HdlConfigReq(msgLen, msg);
+ break;
+ case FAPI_START_REQUEST:
+ l1HdlStartReq(msgLen, msg);
+ break;
+ case FAPI_DL_TTI_REQUEST:
+ l1HdlDlTtiReq(msgLen, msg);
break;
default:
- printf("\n Invalid message type[%x] received at PHY", msgType);
+ printf("\nPHY_STUB: Invalid message type[%x] received at PHY", msgType);
break;
}
}
Code Review / o-du / l2.git / commitdiff