X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrmac%2Flwr_mac_fsm.c;h=56224e16f226a09ef8262c3fcd3940c8cba84710;hb=22dec8bbab96f5bfad385f0a23cd33c95edb2e1f;hp=9e286b646388148700f3c234dc4740517ef9f122;hpb=b490cd1231cfcc837e8bfccc40c6bb106dceef7c;p=o-du%2Fl2.git diff --git a/src/5gnrmac/lwr_mac_fsm.c b/src/5gnrmac/lwr_mac_fsm.c index 9e286b646..56224e16f 100644 --- a/src/5gnrmac/lwr_mac_fsm.c +++ b/src/5gnrmac/lwr_mac_fsm.c @@ -18,6 +18,7 @@ #include #include +#include /* header include files -- defines (.h) */ #include "envopt.h" /* environment options */ @@ -62,6 +63,7 @@ #include "mac.h" #include "rg.x" /* typedefs for MAC */ #include "lwr_mac_phy.h" +#include "common_def.h" #include "math.h" #define MIB_SFN_BITMASK 0xFC @@ -69,15 +71,16 @@ #define PDSCH_PDU_TYPE 1 #define SSB_PDU_TYPE 3 #define PRACH_PDU_TYPE 0 +#define PUSCH_PDU_TYPE 1 #define PDU_PRESENT 1 -#define SETLENGTH(x, size) x += size +#define SET_MSG_LEN(x, size) x += size extern void fapiMacConfigRsp(); extern uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX]; /* Global variables */ -SlotIndInfo slotIndInfo; uint8_t slotIndIdx; +uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo); void lwrMacInit() { @@ -111,8 +114,8 @@ void lwrMacInit() * ****************************************************************/ S16 lwr_mac_handleInvalidEvt(void *msg) { - printf("\nLOWER MAC: Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState); - RETVALUE(ROK); + printf("\nLWR_MAC: Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState); + RETVALUE(ROK); } #ifdef FAPI @@ -645,18 +648,18 @@ PUBLIC void fillPrbMappingType(uint8_t 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) - { - (*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; - } + 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; + } } /******************************************************************* @@ -1270,32 +1273,32 @@ PUBLIC void fillRssiMeas(uint8_t value, ClCellParam **cellPtr) 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" ); - return RFAILED; - } + //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("\nLWR_MAC: Value Extraction failed" ); + return RFAILED; + } } #endif /* FAPI */ /******************************************************************* @@ -1319,31 +1322,25 @@ S16 lwr_mac_handleParamReqEvt(void *msg) { #ifdef FAPI /* startGuardTimer(); */ - uint32_t msgLen; //Length of message Body - msgLen = 0; - fapi_param_req_t *paramReq; -#ifdef INTEL_WLS - WLS_MEM_ALLOC(paramReq, sizeof(fapi_param_req_t)); -#else - MAC_ALLOC(paramReq, sizeof(fapi_param_req_t)); -#endif - - if(paramReq != NULLP) + uint32_t msgLen = 0; //Length of message Body + fapi_param_req_t *paramReq = NULL; + + LWR_MAC_ALLOC(paramReq, sizeof(fapi_param_req_t)); + if(paramReq != NULL) { 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); - MAC_FREE(paramReq, sizeof(fapi_param_req_t)); - return ROK; + + DU_LOG("\nLWR_MAC: Sending Param Request to Phy"); + LwrMacSendToPhy(paramReq->header.message_type_id, \ + sizeof(fapi_param_req_t), (void *)paramReq); } else { - DU_LOG("\nLOWER MAC: Failed to allocate memory for Param Request"); + DU_LOG("\nLWR_MAC: Failed to allocate memory for Param Request"); return RFAILED; } -#else - return ROK; #endif + return ROK; } /******************************************************************* @@ -1369,18 +1366,18 @@ S16 lwr_mac_handleParamRspEvt(void *msg) /* 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("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState); if(paramRsp != NULLP) { MAC_ALLOC(cellParam, sizeof(ClCellParam)); if(cellParam != NULLP) { - DU_LOG("\n LOWER MAC: Filling TLVS into MAC API"); + DU_LOG("\n LWR_MAC: Filling TLVS into MAC API"); if(paramRsp->error_code == MSG_OK) { for(index = 0; index < paramRsp->number_of_tlvs; index++) @@ -1391,7 +1388,7 @@ S16 lwr_mac_handleParamRspEvt(void *msg) encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_16); if(encodedVal != RFAILED && (encodedVal & RELEASE_15) == RELEASE_15) { - cellParam->releaseCapability = RELEASE_15; + cellParam->releaseCapability = RELEASE_15; } break; @@ -1400,7 +1397,7 @@ S16 lwr_mac_handleParamRspEvt(void *msg) if(encodedVal != RFAILED && encodedVal != clGlobalCp.phyState) { printf("\n PhyState mismatch [%d][%d]", clGlobalCp.phyState, clGlobalCp.event); - RETVALUE(RFAILED); + RETVALUE(RFAILED); } break; @@ -1408,11 +1405,11 @@ S16 lwr_mac_handleParamRspEvt(void *msg) encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); if(encodedVal != RFAILED && encodedVal != 0) { - cellParam->skipBlankDlConfig = SUPPORTED; + cellParam->skipBlankDlConfig = SUPPORTED; } else { - cellParam->skipBlankDlConfig = NOT_SUPPORTED; + cellParam->skipBlankDlConfig = NOT_SUPPORTED; } break; @@ -1420,11 +1417,11 @@ S16 lwr_mac_handleParamRspEvt(void *msg) encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); if(encodedVal != RFAILED && encodedVal != 0) { - cellParam->skipBlankUlConfig = SUPPORTED; + cellParam->skipBlankUlConfig = SUPPORTED; } else { - cellParam->skipBlankUlConfig = NOT_SUPPORTED; + cellParam->skipBlankUlConfig = NOT_SUPPORTED; } break; @@ -1541,7 +1538,7 @@ S16 lwr_mac_handleParamRspEvt(void *msg) break; case FAPI_MAX_PUCCHS_PER_SLOT_TAG: - cellParam->maxPucchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + cellParam->maxPucchsPerSlot = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); break; case FAPI_PDSCH_MAPPING_TYPE_TAG: @@ -1625,7 +1622,8 @@ S16 lwr_mac_handleParamRspEvt(void *msg) break; case FAPI_MAX_MU_MIMO_USERS_DL_TAG: - cellParam->maxMuMimoUsersDl = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); + cellParam->maxMuMimoUsersDl = \ + getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); break; case FAPI_PDSCH_DATA_IN_DMRS_SYMBOLS_TAG: @@ -1764,7 +1762,7 @@ S16 lwr_mac_handleParamRspEvt(void *msg) encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8); if(encodedVal != RFAILED && encodedVal < FAPI_PUSCH_MAX_PTRS_PORTS_UB) { - cellParam->puschMaxPtrsPorts = encodedVal; + cellParam->puschMaxPtrsPorts = encodedVal; } break; @@ -1853,30 +1851,28 @@ S16 lwr_mac_handleParamRspEvt(void *msg) break; default: //printf("\n Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index); - break; + break; } } MAC_FREE(cellParam, sizeof(ClCellParam)); - MAC_FREE(paramRsp, sizeof(fapi_param_resp_t)); - sendToLowerMac(FAPI_CONFIG_REQUEST, 0, (void *)NULL); return ROK; } else { - DU_LOG("\n LOWER MAC: Invalid error code %d", paramRsp->error_code); + DU_LOG("\n LWR_MAC: Invalid error code %d", paramRsp->error_code); return RFAILED; } } else { - DU_LOG("\nLOWER MAC: Failed to allocate memory for cell param"); + DU_LOG("\nLWR_MAC: Failed to allocate memory for cell param"); return RFAILED; } } else { - DU_LOG("\nLOWER MAC: Param Response received from PHY is NULL"); + DU_LOG("\nLWR_MAC: Param Response received from PHY is NULL"); return RFAILED; } #else @@ -1904,182 +1900,284 @@ S16 lwr_mac_handleParamRspEvt(void *msg) S16 lwr_mac_handleConfigReqEvt(void *msg) { #ifdef FAPI + Inst inst = 0; + uint8_t idx = 0; uint8_t index = 0; uint32_t msgLen = 0; uint32_t configReqSize; RgCellCb *cellParams; MacCellCfg macCfgParams; - Inst inst = 0; + fapi_config_req_t *configReq; - DU_LOG("\nLOWER MAC: Received EVENT[%d] at STATE[%d]", clGlobalCp.event, clGlobalCp.phyState); + DU_LOG("\nLWR_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)); -#ifdef INTEL_WLS - WLS_MEM_ALLOC(configReq, configReqSize); -#else - MAC_ALLOC(configReq, configReqSize); -#endif + configReqSize = sizeof(fapi_config_req_t); + LWR_MAC_ALLOC(configReq, configReqSize); if(configReq != NULL) { + msgLen = sizeof(macCfgParams.numTlv); 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); + 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_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); + 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); + 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); + 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_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); - //MAC_ALLOC(macCfgParams.prachCfg.fdm[0].unsuedRootSeq, \ - sizeof(uint8_t)*macCfgParams.prachCfg.fdm[0].numUnusedRootSeq); - macCfgParams.prachCfg.fdm[0].unsuedRootSeq = (uint8_t *)malloc(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); - 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); + 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) + { + 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); + } + 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); + 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); + 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); + fillTlvs(&configReq->tlvs[index++], FAPI_RSSI_MESUREMENT_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.dmrsTypeAPos, &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); - MAC_FREE(configReq, configReqSize); - return ROK; + + DU_LOG("\nLWR_MAC: Sending Config Request to Phy"); + LwrMacSendToPhy(configReq->header.message_type_id, configReqSize, (void *)configReq); } else { - DU_LOG("\nLOWER_MAC: Failed to allocate memory for config Request"); + DU_LOG("\nLWR_MAC: Failed to allocate memory for config Request"); return RFAILED; } -#else - return ROK; #endif -} + + return ROK; +} /* lwr_mac_handleConfigReqEvt */ + +/******************************************************************* + * + * @brief Processes config response from phy + * + * @details + * + * Function : lwr_mac_handleConfigRspEvt + * + * Functionality: + * Processes config response from phy + * + * @params[in] FAPI message pointer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ S16 lwr_mac_handleConfigRspEvt(void *msg) { #ifdef 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("\nLWR_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"); + DU_LOG("\nLWR_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(); - MAC_FREE(configRsp, sizeof(fapi_config_resp_t)); - return ROK; } else { - - DU_LOG("\n LOWER MAC: Invalid error code %d", configRsp->error_code); + DU_LOG("\n 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("\nLWR_MAC: Config Response received from PHY is NULL"); return RFAILED; } -#else - return ROK; #endif -} + return ROK; +} /* lwr_mac_handleConfigRspEvt */ + +/******************************************************************* + * + * @brief Build and send start request to phy + * + * @details + * + * Function : lwr_mac_handleStartReqEvt + * + * Functionality: + * Build and send start request to phy + * + * @params[in] FAPI message pointer + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ S16 lwr_mac_handleStartReqEvt(void *msg) { #ifdef FAPI uint32_t msgLen = 0; fapi_start_req_t *startReq; -#ifdef INTEL_WLS - WLS_MEM_ALLOC(startReq, sizeof(fapi_start_req_t)); -#else - MAC_ALLOC(startReq, sizeof(fapi_start_req_t)); -#endif + LWR_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"); - LwrMacSendToPhy(startReq->header.message_type_id, sizeof(fapi_start_req_t), (void *)startReq); - MAC_FREE(startReq, sizeof(fapi_start_req_t)); - return ROK; + + DU_LOG("\nLWR_MAC: Sending Start Request to PHY"); + LwrMacSendToPhy(startReq->header.message_type_id, sizeof(fapi_start_req_t),\ + (void *)startReq); } else { - DU_LOG("\nLOWER MAC: Failed to allocate memory for Start Request"); + DU_LOG("\nLWR_MAC: Failed to allocate memory for Start Request"); return RFAILED; } -#else - return ROK; #endif -} + return ROK; +} /* lwr_mac_handleStartReqEvt */ + + /******************************************************************* + * + * @brief Sends FAPI Stop Req to PHY + * + * @details + * + * Function : lwr_mac_handleStopReqEvt + * + * Functionality: + * -Sends FAPI Stop Req to PHY + * + * @params[in] + * @return ROK - success + * RFAILED - failure + * + ********************************************************************/ S16 lwr_mac_handleStopReqEvt(void *msg) { #ifdef FAPI - /* stop TX and RX operation return PHy to configured State - send stop.indication to l2/l3 */ + uint32_t msgLen = 0; + fapi_stop_req_t *stopReq = NULLP; + LWR_MAC_ALLOC(stopReq, sizeof(fapi_stop_req_t)); + if(stopReq != NULLP) + { + fillMsgHeader(&stopReq->header, FAPI_STOP_REQUEST, msgLen); + DU_LOG("\nLOWER MAC: Sending Stop Request to PHY"); + LwrMacSendToPhy(stopReq->header.message_type_id, sizeof(fapi_stop_req_t), (void *)stopReq); + } + else + { + DU_LOG("\nLOWER MAC: Failed to allocate memory for Stop Request"); + return RFAILED; + } #endif return ROK; } @@ -2100,11 +2198,11 @@ S16 lwr_mac_handleStopReqEvt(void *msg) * pointer to modified value ******************************************************************/ -PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val) +PUBLIC void setMibPdu(uint8_t *mibPdu, uint32_t *val, uint16_t sfn) { - *mibPdu |= (((uint8_t)(slotIndInfo.sfn >> 2)) & MIB_SFN_BITMASK); + *mibPdu |= (((uint8_t)(sfn >> 2)) & MIB_SFN_BITMASK); *val = (mibPdu[0] << 24 | mibPdu[1] << 16 | mibPdu[2] << 8); - DU_LOG("\nLOWER MAC: value filled %x", *val); + DU_LOG("\nLWR_MAC: MIB PDU %x", *val); } #ifdef FAPI @@ -2128,8 +2226,7 @@ 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) + MacDlSlot *currDlSlot, uint32_t *msgLen, uint8_t ssbIdxCount, uint16_t sfn) { uint32_t mibPayload = 0; if(dlTtiReqPdu != NULL) @@ -2137,13 +2234,13 @@ S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg, 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->cellBroadcastInfo.ssbInfo[ssbIdxCount].ssbIdx; + dlTtiReqPdu->u.ssb_pdu.ssbBlockIndex = currDlSlot->dlInfo.brdcstAlloc.ssbInfo[ssbIdxCount].ssbIdx; 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); + setMibPdu(macCellCfg->ssbCfg.mibPdu, &mibPayload, sfn); dlTtiReqPdu->u.ssb_pdu.bchPayload.v.bchPayload = mibPayload; dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.numPrgs = 0; dlTtiReqPdu->u.ssb_pdu.preCodingAndBeamforming.prgSize = 0; @@ -2152,7 +2249,8 @@ S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg, 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)); + SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \ + sizeof(dlTtiReqPdu->pduSize) + sizeof(fapi_dl_ssb_pdu_t))); return ROK; } else @@ -2167,18 +2265,18 @@ S16 fillSsbPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, MacCellCfg *macCellCfg, * * @details * - * Function : fillDlDciPdu + * Function : fillSib1DlDciPdu * * Functionality: * -Fills the Dl DCI PDU * * @params[in] Pointer to fapi_dl_dci_t - * Pointer to Sib1PdcchCfg + * Pointer to PdcchCfg * @return ROK * ******************************************************************/ -void fillDlDciPdu(fapi_dl_dci_t *dlDciPtr, Sib1PdcchCfg *sib1PdcchInfo) +void fillSib1DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *sib1PdcchInfo) { if(dlDciPtr != NULLP) { @@ -2198,7 +2296,7 @@ void fillDlDciPdu(fapi_dl_dci_t *dlDciPtr, Sib1PdcchCfg *sib1PdcchInfo) uint32_t reserved; /* Size(in bits) of each field in DCI format 0_1 - * as mentioned in spec 38.214 */ + * as mentioned in spec 38.214 */ uint8_t freqDomResAssignSize; uint8_t timeDomResAssignSize = 4; uint8_t VRB2PRBMapSize = 1; @@ -2207,18 +2305,18 @@ void fillDlDciPdu(fapi_dl_dci_t *dlDciPtr, Sib1PdcchCfg *sib1PdcchInfo) uint8_t sysInfoIndSize = 1; uint8_t reservedSize = 15; - dlDciPtr->rnti = sib1PdcchInfo->sib1DlDci.rnti; - dlDciPtr->scramblingId = sib1PdcchInfo->sib1DlDci.scramblingId; - dlDciPtr->scramblingRnti = sib1PdcchInfo->sib1DlDci.scramblingRnti; - dlDciPtr->cceIndex = sib1PdcchInfo->sib1DlDci.cceIndex; - dlDciPtr->aggregationLevel = sib1PdcchInfo->sib1DlDci.aggregLevel; - dlDciPtr->pc_and_bform.numPrgs = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.numPrgs; - dlDciPtr->pc_and_bform.prgSize = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.prgSize; - dlDciPtr->pc_and_bform.digBfInterfaces = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.digBfInterfaces; - dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.prg[0].pmIdx; - dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = sib1PdcchInfo->sib1DlDci.beamPdcchInfo.prg[0].beamIdx[0]; - dlDciPtr->beta_pdcch_1_0 = sib1PdcchInfo->sib1DlDci.txPdcchPower.powerValue; - dlDciPtr->powerControlOfssetSS = sib1PdcchInfo->sib1DlDci.txPdcchPower.powerControlOffsetSS; + dlDciPtr->rnti = sib1PdcchInfo->dci.rnti; + dlDciPtr->scramblingId = sib1PdcchInfo->dci.scramblingId; + dlDciPtr->scramblingRnti = sib1PdcchInfo->dci.scramblingRnti; + dlDciPtr->cceIndex = sib1PdcchInfo->dci.cceIndex; + dlDciPtr->aggregationLevel = sib1PdcchInfo->dci.aggregLevel; + dlDciPtr->pc_and_bform.numPrgs = sib1PdcchInfo->dci.beamPdcchInfo.numPrgs; + dlDciPtr->pc_and_bform.prgSize = sib1PdcchInfo->dci.beamPdcchInfo.prgSize; + 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; /* Calculating freq domain resource allocation field value and size * coreset0Size = Size of coreset 0 @@ -2226,10 +2324,10 @@ void fillDlDciPdu(fapi_dl_dci_t *dlDciPtr, Sib1PdcchCfg *sib1PdcchInfo) * RBLen = length of contiguously allocted RBs * Spec 38.214 Sec 5.1.2.2.2 */ - coreset0Size= sib1PdcchInfo->sib1Coreset0Cfg.coreSet0Size; - rbStart = 0; /* For SIB1 */ - //rbStart = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1FreqAlloc.rbStart; - rbLen = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1FreqAlloc.rbSize; + coreset0Size= sib1PdcchInfo->coreset0Cfg.coreSet0Size; + rbStart = 0; /* For SIB1 */ + //rbStart = sib1PdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.startPrb; + rbLen = sib1PdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.numPrb; if((rbLen >=1) && (rbLen <= coreset0Size - rbStart)) { @@ -2243,12 +2341,12 @@ void fillDlDciPdu(fapi_dl_dci_t *dlDciPtr, Sib1PdcchCfg *sib1PdcchInfo) } /* Fetching DCI field values */ - timeDomResAssign = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1TimeAlloc. + timeDomResAssign = sib1PdcchInfo->dci.pdschCfg->pdschTimeAlloc. rowIndex -1; - VRB2PRBMap = sib1PdcchInfo->sib1DlDci.pdschCfg->sib1FreqAlloc.\ + VRB2PRBMap = sib1PdcchInfo->dci.pdschCfg->pdschFreqAlloc.\ vrbPrbMapping; - modNCodScheme = sib1PdcchInfo->sib1DlDci.pdschCfg->codeword[0].mcsIndex; - redundancyVer = sib1PdcchInfo->sib1DlDci.pdschCfg->codeword[0].rvIndex; + 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; @@ -2259,7 +2357,6 @@ void fillDlDciPdu(fapi_dl_dci_t *dlDciPtr, Sib1PdcchCfg *sib1PdcchInfo) modNCodScheme = reverseBits(modNCodScheme, modNCodSchemeSize); redundancyVer = reverseBits(redundancyVer, redundancyVerSize); sysInfoInd = reverseBits(sysInfoInd, sysInfoIndSize); - reserved = reverseBits(reserved, reservedSize); /* Calulating total number of bytes in buffer */ dlDciPtr->payloadSizeBits = freqDomResAssignSize + timeDomResAssignSize\ @@ -2272,7 +2369,7 @@ void fillDlDciPdu(fapi_dl_dci_t *dlDciPtr, Sib1PdcchCfg *sib1PdcchInfo) if(numBytes > DCI_PAYLOAD_BYTE_LEN) { - DU_LOG("\nLOWER MAC : Total bytes for DCI is more than expected"); + DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected"); return; } @@ -2300,173 +2397,717 @@ void fillDlDciPdu(fapi_dl_dci_t *dlDciPtr, Sib1PdcchCfg *sib1PdcchInfo) reserved, reservedSize); } -} /* fillDlDciPdu */ +} /* fillSib1DlDciPdu */ /******************************************************************* * - * @brief fills PDCCH PDU required for DL TTI info in MAC + * @brief fills Dl DCI PDU required for DL TTI info in MAC * * @details * - * Function : fillPdcchPdu + * Function : fillRarDlDciPdu * * Functionality: - * -Fills the Pdcch PDU info - * stored in MAC + * -Fills the Dl DCI PDU * - * @params[in] Pointer to FAPI DL TTI Req - * Pointer to Sib1PdcchCfg - * Pointer to msgLen of DL TTI Info + * @params[in] Pointer to fapi_dl_dci_t + * Pointer to PdcchCfg * @return ROK * ******************************************************************/ -S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, Sib1PdcchCfg *sib1PdcchInfo, -uint32_t *msgLen) +void fillRarDlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *rarPdcchInfo) { - if(dlTtiReqPdu != NULLP) - { - dlTtiReqPdu->pduType = PDCCH_PDU_TYPE; - dlTtiReqPdu->u.pdcch_pdu.bwpSize = sib1PdcchInfo->sib1PdcchBwpCfg.BWPSize; - dlTtiReqPdu->u.pdcch_pdu.bwpPart = sib1PdcchInfo->sib1PdcchBwpCfg.BWPStart; - dlTtiReqPdu->u.pdcch_pdu.subCarrierSpacing = sib1PdcchInfo->sib1PdcchBwpCfg.subcarrierSpacing; - dlTtiReqPdu->u.pdcch_pdu.cyclicPrefix = sib1PdcchInfo->sib1PdcchBwpCfg.cyclicPrefix; - dlTtiReqPdu->u.pdcch_pdu.startSymbolIndex = sib1PdcchInfo->sib1Coreset0Cfg.startSymbolIndex; - dlTtiReqPdu->u.pdcch_pdu.durationSymbols = sib1PdcchInfo->sib1Coreset0Cfg.durationSymbols; - memcpy(dlTtiReqPdu->u.pdcch_pdu.freqDomainResource, sib1PdcchInfo->sib1Coreset0Cfg.freqDomainResource, 6); - dlTtiReqPdu->u.pdcch_pdu.cceRegMappingType = sib1PdcchInfo->sib1Coreset0Cfg.cceRegMappingType; - dlTtiReqPdu->u.pdcch_pdu.regBundleSize = sib1PdcchInfo->sib1Coreset0Cfg.regBundleSize; - dlTtiReqPdu->u.pdcch_pdu.interleaverSize = sib1PdcchInfo->sib1Coreset0Cfg.interleaverSize; - dlTtiReqPdu->u.pdcch_pdu.coreSetSize = sib1PdcchInfo->sib1Coreset0Cfg.coreSetType; - dlTtiReqPdu->u.pdcch_pdu.shiftIndex = sib1PdcchInfo->sib1Coreset0Cfg.shiftIndex; - dlTtiReqPdu->u.pdcch_pdu.precoderGranularity = sib1PdcchInfo->sib1Coreset0Cfg.precoderGranularity; - dlTtiReqPdu->u.pdcch_pdu.numDlDci = sib1PdcchInfo->numDlDci; -#ifdef INTEL_WLS - WLS_MEM_ALLOC(dlTtiReqPdu->u.pdcch_pdu.dlDci, sizeof(fapi_dl_dci_t)); -#else - MAC_ALLOC(dlTtiReqPdu->u.pdcch_pdu.dlDci, sizeof(fapi_dl_dci_t)); -#endif - fillDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, sib1PdcchInfo); - dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t); - SETLENGTH(*msgLen, sizeof(fapi_dl_pdcch_pdu_t)); + if(dlDciPtr != NULLP) + { + uint8_t numBytes; + uint8_t bytePos; + uint8_t bitPos; - } - return ROK; + 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->pdschFreqAlloc.freqAlloc.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 -1; + 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 > DCI_PAYLOAD_BYTE_LEN) + { + DU_LOG("\nLWR_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 PDSCH PDU required for DL TTI info in MAC + * @brief fills msg4 Dl DCI PDU required for DL TTI info in MAC * * @details * - * Function : fillPdschPdu + * Function : fillMsg4DlDciPdu * * Functionality: - * -Fills the Pdsch PDU info - * stored in MAC + * -Fills the Msg4 Dl DCI PDU * - * @params[in] Pointer to FAPI DL TTI Req - * Pointer to Sib1PdschCfg - * Pointer to msgLen of DL TTI Info + * @params[in] Pointer to fapi_dl_dci_t + * Pointer to PdcchCfg * @return ROK * ******************************************************************/ - -void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, Sib1PdschCfg *sib1PdschInfo, -uint32_t *msgLen) +void fillMsg4DlDciPdu(fapi_dl_dci_t *dlDciPtr, PdcchCfg *msg4PdcchInfo,\ +Msg4Info *msg4Info) { - uint8_t idx; + if(dlDciPtr != NULLP) + { + uint8_t numBytes; + uint8_t bytePos; + uint8_t bitPos; - if(dlTtiReqPdu != NULLP) - { - dlTtiReqPdu->pduType = PDSCH_PDU_TYPE; - dlTtiReqPdu->u.pdsch_pdu.pduBitMap = sib1PdschInfo->pduBitmap; - dlTtiReqPdu->u.pdsch_pdu.rnti = sib1PdschInfo->rnti; - dlTtiReqPdu->u.pdsch_pdu.pduIndex = sib1PdschInfo->pduIndex; - dlTtiReqPdu->u.pdsch_pdu.bwpSize = sib1PdschInfo->sib1PdschBwpCfg.BWPSize; - dlTtiReqPdu->u.pdsch_pdu.bwpStart = sib1PdschInfo->sib1PdschBwpCfg.BWPStart; - dlTtiReqPdu->u.pdsch_pdu.subCarrierSpacing = sib1PdschInfo->sib1PdschBwpCfg.subcarrierSpacing; - dlTtiReqPdu->u.pdsch_pdu.cyclicPrefix = sib1PdschInfo->sib1PdschBwpCfg.cyclicPrefix; - dlTtiReqPdu->u.pdsch_pdu.nrOfCodeWords = sib1PdschInfo->numCodewords; - for(idx = 0; idx < MAX_CODEWORDS ; idx++) - { - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].targetCodeRate = sib1PdschInfo->codeword[idx].targetCodeRate; - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].qamModOrder = sib1PdschInfo->codeword[idx].qamModOrder; - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsIndex = sib1PdschInfo->codeword[idx].mcsIndex; - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].mcsTable = sib1PdschInfo->codeword[idx].mcsTable; - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].rvIndex = sib1PdschInfo->codeword[idx].rvIndex; - dlTtiReqPdu->u.pdsch_pdu.cwInfo[idx].tbSize = sib1PdschInfo->codeword[idx].tbSize; - } - dlTtiReqPdu->u.pdsch_pdu.dataScramblingId = sib1PdschInfo->dataScramblingId; - dlTtiReqPdu->u.pdsch_pdu.nrOfLayers = sib1PdschInfo->numLayers; - dlTtiReqPdu->u.pdsch_pdu.transmissionScheme = sib1PdschInfo->transmissionScheme; - dlTtiReqPdu->u.pdsch_pdu.refPoint = sib1PdschInfo->refPoint; - dlTtiReqPdu->u.pdsch_pdu.dlDmrsSymbPos = sib1PdschInfo->dmrs.dlDmrsSymbPos; - dlTtiReqPdu->u.pdsch_pdu.dmrsConfigType = sib1PdschInfo->dmrs.dmrsConfigType; - dlTtiReqPdu->u.pdsch_pdu.dlDmrsScramblingId = sib1PdschInfo->dmrs.dlDmrsScramblingId; - dlTtiReqPdu->u.pdsch_pdu.scid = sib1PdschInfo->dmrs.scid; - dlTtiReqPdu->u.pdsch_pdu.numDmrsCdmGrpsNoData = sib1PdschInfo->dmrs.numDmrsCdmGrpsNoData; - dlTtiReqPdu->u.pdsch_pdu.dmrsPorts = sib1PdschInfo->dmrs.dmrsPorts; - dlTtiReqPdu->u.pdsch_pdu.resourceAlloc = sib1PdschInfo->sib1FreqAlloc.resourceAlloc; - /* since we are using type-1, hence rbBitmap excluded */ - dlTtiReqPdu->u.pdsch_pdu.rbStart = sib1PdschInfo->sib1FreqAlloc.rbStart; - dlTtiReqPdu->u.pdsch_pdu.rbSize = sib1PdschInfo->sib1FreqAlloc.rbSize; - dlTtiReqPdu->u.pdsch_pdu.vrbToPrbMapping = sib1PdschInfo->sib1FreqAlloc.vrbPrbMapping; - dlTtiReqPdu->u.pdsch_pdu.startSymbIndex = sib1PdschInfo->sib1TimeAlloc.startSymbolIndex; - dlTtiReqPdu->u.pdsch_pdu.nrOfSymbols = sib1PdschInfo->sib1TimeAlloc.numSymbols; - dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.numPrgs = sib1PdschInfo->beamPdschInfo.numPrgs; - dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.prgSize = sib1PdschInfo->beamPdschInfo.prgSize; - dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.digBfInterfaces = sib1PdschInfo->beamPdschInfo.digBfInterfaces; - dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \ - pmIdx = sib1PdschInfo->beamPdschInfo.prg[0].pmIdx; - dlTtiReqPdu->u.pdsch_pdu.preCodingAndBeamforming.pmi_bfi[0]. \ - beamIdx[0].beamidx = sib1PdschInfo->beamPdschInfo.prg[0].beamIdx[0]; - dlTtiReqPdu->u.pdsch_pdu.powerControlOffset = sib1PdschInfo->txPdschPower.powerControlOffset; - dlTtiReqPdu->u.pdsch_pdu.powerControlOffsetSS = sib1PdschInfo->txPdschPower.powerControlOffsetSS; - dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdsch_pdu_t); - SETLENGTH(*msgLen, sizeof(fapi_dl_pdsch_pdu_t)); + uint16_t coreset0Size = 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; + 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 = msg4PdcchInfo->dci.rnti; + dlDciPtr->scramblingId = msg4PdcchInfo->dci.scramblingId; + dlDciPtr->scramblingRnti = msg4PdcchInfo->dci.scramblingRnti; + dlDciPtr->cceIndex = msg4PdcchInfo->dci.cceIndex; + dlDciPtr->aggregationLevel = msg4PdcchInfo->dci.aggregLevel; + dlDciPtr->pc_and_bform.numPrgs = msg4PdcchInfo->dci.beamPdcchInfo.numPrgs; + dlDciPtr->pc_and_bform.prgSize = msg4PdcchInfo->dci.beamPdcchInfo.prgSize; + dlDciPtr->pc_and_bform.digBfInterfaces = msg4PdcchInfo->dci.beamPdcchInfo.digBfInterfaces; + dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = msg4PdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx; + dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = msg4PdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0]; + dlDciPtr->beta_pdcch_1_0 = msg4PdcchInfo->dci.txPdcchPower.powerValue; + dlDciPtr->powerControlOfssetSS = msg4PdcchInfo->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 = msg4PdcchInfo->coreset0Cfg.coreSet0Size; + //rbStart = msg4PdcchInfo->dci.pdschCfg->freqAlloc.rbStart; + rbLen = msg4PdcchInfo->dci.pdschCfg->pdschFreqAlloc.freqAlloc.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 */ + dciFormatId = msg4Info->dciFormatId; /* DCI indentifier for DL */ + timeDomResAssign = msg4PdcchInfo->dci.pdschCfg->pdschTimeAlloc.rowIndex -1; + VRB2PRBMap = msg4PdcchInfo->dci.pdschCfg->pdschFreqAlloc.vrbPrbMapping; + modNCodScheme = msg4PdcchInfo->dci.pdschCfg->codeword[0].mcsIndex; + ndi = msg4Info->ndi; + redundancyVer = msg4PdcchInfo->dci.pdschCfg->codeword[0].rvIndex; + harqProcessNum = msg4Info->harqProcNum; + dlAssignmentIdx = msg4Info->dlAssignIdx; + pucchTpc = msg4Info->pucchTpc; + pucchResoInd = msg4Info->pucchResInd; + harqFeedbackInd = msg4Info->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 > DCI_PAYLOAD_BYTE_LEN) + { + DU_LOG("\nLWR_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); + } +} /* fillMsg4DlDciPdu */ + +/******************************************************************* * - * @brief calculates the total size to be allocated for DL TTI Req + * @brief fills PDCCH PDU required for DL TTI info in MAC * * @details * - * Function : calculatePduCount + * Function : fillPdcchPdu * * Functionality: - * -calculates the total pdu count to be allocated for DL TTI Req + * -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 + * + ******************************************************************/ +S16 fillPdcchPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, DlSchedInfo *dlInfo, uint32_t *msgLen, RntiType rntiType) +{ + if(dlTtiReqPdu != NULLP) + { + PdcchCfg *pdcchInfo = NULLP; + BwpCfg *bwp = NULLP; + + dlTtiReqPdu->u.pdcch_pdu.dlDci = (fapi_dl_dci_t *)(dlTtiReqPdu + \ + (sizeof(fapi_dl_tti_req_pdu_t) - sizeof(dlTtiReqPdu->u)) + \ + (sizeof(fapi_dl_pdcch_pdu_t) - sizeof(fapi_dl_dci_t*))); + + if(rntiType == SI_RNTI_TYPE) + { + pdcchInfo = &dlInfo->brdcstAlloc.sib1Alloc.sib1PdcchCfg; + bwp = &dlInfo->brdcstAlloc.sib1Alloc.bwp; + fillSib1DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo); + } + else if(rntiType == RA_RNTI_TYPE) + { + pdcchInfo = &dlInfo->rarAlloc->rarPdcchCfg; + bwp = &dlInfo->rarAlloc->bwp; + fillRarDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo); + } + else if(rntiType == TC_RNTI_TYPE) + { + pdcchInfo = &dlInfo->msg4Alloc->msg4PdcchCfg; + bwp = &dlInfo->msg4Alloc->bwp; + fillMsg4DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo,\ + &dlInfo->msg4Alloc->msg4Info); + } + else + { + DU_LOG("\nLWR_MAC: Failed filling PDCCH Pdu"); + return RFAILED;; + } + dlTtiReqPdu->pduType = PDCCH_PDU_TYPE; + dlTtiReqPdu->u.pdcch_pdu.bwpSize = bwp->freqAlloc.numPrb; + dlTtiReqPdu->u.pdcch_pdu.bwpPart = bwp->freqAlloc.startPrb; + dlTtiReqPdu->u.pdcch_pdu.subCarrierSpacing = bwp->subcarrierSpacing; + dlTtiReqPdu->u.pdcch_pdu.cyclicPrefix = bwp->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; + + /* Calculating PDU length. Considering only one dl dci pdu for now */ + dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t) + sizeof(fapi_dl_dci_t); + SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \ + sizeof(dlTtiReqPdu->pduSize) + dlTtiReqPdu->pduSize)); + + } + + return ROK; +} + +/******************************************************************* + * + * @brief fills PDSCH PDU required for DL TTI info in MAC + * + * @details + * + * Function : fillPdschPdu + * + * 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 fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdschCfg *pdschInfo, + BwpCfg bwp,uint32_t *msgLen, uint16_t pduIndex) +{ + 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 = pduIndex; + dlTtiReqPdu->u.pdsch_pdu.bwpSize = bwp.freqAlloc.numPrb; + dlTtiReqPdu->u.pdsch_pdu.bwpStart = bwp.freqAlloc.startPrb; + dlTtiReqPdu->u.pdsch_pdu.subCarrierSpacing = bwp.subcarrierSpacing; + dlTtiReqPdu->u.pdsch_pdu.cyclicPrefix = bwp.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->pdschFreqAlloc.resourceAllocType; + /* since we are using type-1, hence rbBitmap excluded */ + dlTtiReqPdu->u.pdsch_pdu.rbStart = pdschInfo->pdschFreqAlloc.freqAlloc.startPrb; + dlTtiReqPdu->u.pdsch_pdu.rbSize = pdschInfo->pdschFreqAlloc.freqAlloc.numPrb; + dlTtiReqPdu->u.pdsch_pdu.vrbToPrbMapping = pdschInfo->pdschFreqAlloc.vrbPrbMapping; + dlTtiReqPdu->u.pdsch_pdu.startSymbIndex = pdschInfo->pdschTimeAlloc.timeAlloc.startSymb; + dlTtiReqPdu->u.pdsch_pdu.nrOfSymbols = pdschInfo->pdschTimeAlloc.timeAlloc.numSymb; + 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); + + SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \ + sizeof(dlTtiReqPdu->pduSize) + sizeof(fapi_dl_pdsch_pdu_t))); + + } + +} + +/*********************************************************************** + * + * @brief calculates the total size to be allocated for DL TTI Req + * + * @details + * + * Function : calcDlTtiReqPduCount + * + * Functionality: + * -calculates the total pdu count to be allocated for DL TTI Req * * @params[in] DlBrdcstAlloc *cellBroadcastInfo * @return count * * ********************************************************************/ -uint8_t calculatePduCount(DlBrdcstAlloc *cellBroadcastInfo) +uint8_t calcDlTtiReqPduCount(DlSchedInfo *dlInfo) { uint8_t count = 0; uint8_t idx = 0; - if(cellBroadcastInfo->ssbTrans) + + if(dlInfo->isBroadcastPres) { - for(idx = 0; idx < cellBroadcastInfo->ssbIdxSupported; idx++) + if(dlInfo->brdcstAlloc.ssbTrans) + { + for(idx = 0; idx < dlInfo->brdcstAlloc.ssbIdxSupported; idx++) + { + /* SSB PDU is filled */ + count++; + } + } + if(dlInfo->brdcstAlloc.sib1Trans) { - count++; + /* PDCCH and PDSCH PDU is filled */ + count += 2; } } - if(cellBroadcastInfo->sib1Trans) + if(dlInfo->rarAlloc != NULLP) { + /* PDCCH and PDSCH PDU is filled */ count += 2; } + if(dlInfo->msg4Alloc != NULLP) + { + /* PDCCH and PDSCH PDU is filled */ + count += 2; + } + + 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(DlSchedInfo *dlInfo) +{ + uint8_t count = 0; + + if(dlInfo->isBroadcastPres && dlInfo->brdcstAlloc.sib1Trans) + { + count++; + } + if(dlInfo->rarAlloc != NULLP) + { + count++; + } + if(dlInfo->msg4Alloc != NULLP) + { + 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,MacCellCfg *macCellCfg, + uint32_t *msgLen, uint16_t pduIndex) +{ + uint32_t pduLen = 0; + uint32_t *sib1TxdataValue = 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 = macCellCfg->sib1Cfg.sib1PduLen; + LWR_MAC_ALLOC(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen); + if(sib1TxdataValue == NULLP) + { + return RFAILED; + } + memcpy(sib1TxdataValue,macCellCfg->sib1Cfg.sib1Pdu, + macCellCfg->sib1Cfg.sib1PduLen); + pduDesc[pduIndex].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[pduIndex].pduLength = pduLen; + msgLen += pduLen; + +#ifndef INTEL_WLS + MAC_FREE(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen); +#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, RarInfo *rarInfo, + uint32_t *msgLen, uint16_t pduIndex) +{ + 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); #endif + return ROK; +} + +/*********************************************************************** + * + * @brief fills the Msg4 TX-DATA request message + * + * @details + * + * Function : fillMsg4TxDataReq + * + * Functionality: + * - fills the Msg4 TX-DATA request message + * + * @params[in] fapi_tx_pdu_desc_t *pduDesc + * @params[in] Msg4Info *msg4Info + * @params[in] uint32_t *msgLen + * @params[in] uint16_t pduIndex + * @return ROK + * + * ********************************************************************/ +uint8_t fillMsg4TxDataReq(fapi_tx_pdu_desc_t *pduDesc, Msg4Info *msg4Info, + uint32_t *msgLen, uint16_t pduIndex) +{ + uint32_t pduLen = 0; + uint32_t *msg4TxDataValue = 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 = msg4Info->msg4PduLen; + LWR_MAC_ALLOC(msg4TxDataValue, msg4Info->msg4PduLen); + if(msg4TxDataValue == NULLP) + { + return RFAILED; + } + memcpy(msg4TxDataValue, msg4Info->msg4Pdu, msg4Info->msg4PduLen); + pduDesc[pduIndex].tlvs[0].value = (uint32_t)msg4TxDataValue; + + /* 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(msg4TxDataValue, msg4Info->msg4PduLen); + #endif + + return ROK; +} + +#endif /* FAPI */ /******************************************************************* * * @brief Sends DL TTI Request to PHY @@ -2476,138 +3117,276 @@ uint8_t calculatePduCount(DlBrdcstAlloc *cellBroadcastInfo) * Function : handleDlTtiReq * * Functionality: - * -Sends FAPI Param req to PHY + * -Sends FAPI DL TTI req to PHY * - * @params[in] RgDlSf *dlTtiReqSlot + * @params[in] timing info * @return ROK - success * RFAILED - failure * * ****************************************************************/ -S16 handleDlTtiReq(CmLteTimingInfo *dlTtiReqtimingInfo) +uint16_t handleDlTtiReq(SlotIndInfo currTimingInfo) { #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_dl_tti_req_pdu_t *dlTtiReqPdu = 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; + uint8_t idx; + uint8_t nPdu = 0; + uint8_t numPduEncoded = 0; + uint16_t pduIndex = 0; + uint32_t msgLen = 0; + uint32_t dlTtiReqMsgSize = 0; + + fapi_dl_tti_req_t *dlTtiReq = NULLP; + SlotIndInfo dlTtiReqTimingInfo; + + RgCellCb *cellCbParams = NULLP; + MacDlSlot *currDlSlot = NULLP; + MacCellCfg macCellCfg; + memset(&macCellCfg, 0, sizeof(MacCellCfg)); + Inst inst = 0; + RntiType rntiType; + + if(clGlobalCp.phyState == PHY_STATE_RUNNING) + { + /* consider phy delay */ + ADD_DELTA_TO_TIME(currTimingInfo,dlTtiReqTimingInfo,PHY_DELTA); + + cellCbParams = rgCb[inst].cell; macCellCfg = cellCbParams->macCellCfg; - if(dlTtiReqtimingInfo != NULLP) + currDlSlot = &macCb.macCell->dlSlot[dlTtiReqTimingInfo.slot]; + nPdu = calcDlTtiReqPduCount(&currDlSlot->dlInfo); + dlTtiReqMsgSize = sizeof(fapi_dl_tti_req_t) + (nPdu * \ + sizeof(fapi_dl_tti_req_pdu_t)); + if(nPdu > 0) { -#ifdef INTEL_WLS - WLS_MEM_ALLOC(dlTtiReq, sizeof(fapi_dl_tti_req_t)); -#else - MAC_ALLOC(dlTtiReq, sizeof(fapi_dl_tti_req_t)); -#endif - if(dlTtiReq != NULLP) + if(currDlSlot->dlInfo.isBroadcastPres) { - dlTtiReq->sfn = dlTtiReqtimingInfo->sfn; - dlTtiReq->slot = dlTtiReqtimingInfo->slot; - currDlSlot = &macCb.macCell->dlSlot[dlTtiReq->slot % MAX_SLOT_SUPPORTED]; - dlTtiReq->nPdus = calculatePduCount(&currDlSlot->cellBroadcastInfo); /* get total Pdus */ - nPdu = dlTtiReq->nPdus; - dlTtiReq->nGroup = 0; - if(dlTtiReq->nPdus > 0) + if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans) { -#ifdef INTEL_WLS - WLS_MEM_ALLOC(dlTtiReqPdu, (nPdu * sizeof(fapi_dl_tti_req_pdu_t))); -#else - MAC_ALLOC(dlTtiReqPdu, (nPdu * sizeof(fapi_dl_tti_req_pdu_t))); -#endif - if(currDlSlot->cellBroadcastInfo.ssbTrans) + dlTtiReqMsgSize += sizeof(fapi_dl_dci_t); + } + } + if(currDlSlot->dlInfo.rarAlloc != NULLP) + { + dlTtiReqMsgSize += sizeof(fapi_dl_dci_t); + } + if(currDlSlot->dlInfo.msg4Alloc != NULLP) + { + dlTtiReqMsgSize += sizeof(fapi_dl_dci_t); + } + } + LWR_MAC_ALLOC(dlTtiReq, dlTtiReqMsgSize); + if(dlTtiReq != NULLP) + { + memset(dlTtiReq, 0, dlTtiReqMsgSize); + dlTtiReq->sfn = dlTtiReqTimingInfo.sfn; + dlTtiReq->slot = dlTtiReqTimingInfo.slot; + dlTtiReq->nPdus = calcDlTtiReqPduCount(&currDlSlot->dlInfo); /* get total Pdus */ + nPdu = dlTtiReq->nPdus; + dlTtiReq->nGroup = 0; + + if(dlTtiReq->nPdus > 0) + { + dlTtiReq->pdus = (fapi_dl_tti_req_pdu_t*)(dlTtiReq + \ + (sizeof(fapi_dl_tti_req_t) - sizeof(fapi_dl_tti_req_pdu_t*))); + if(!dlTtiReq->pdus) + { + DU_LOG("\nLWR_MAC: Memory allocation failed"); + return RFAILED; + } + + if(currDlSlot->dlInfo.isBroadcastPres) + { + if(currDlSlot->dlInfo.brdcstAlloc.ssbTrans) { - if(dlTtiReqPdu != NULLP) + if(dlTtiReq->pdus != NULLP) { - for(idx = 0; idx < currDlSlot->cellBroadcastInfo.ssbIdxSupported; idx++) + for(idx = 0; idx < currDlSlot->dlInfo.brdcstAlloc.ssbIdxSupported; idx++) { - if(idx > 0) - dlTtiReq->pdus++; - fillSsbPdu(dlTtiReqPdu, &macCellCfg, currDlSlot, &msgLen, idx); - dlTtiReq->pdus = dlTtiReqPdu; + fillSsbPdu(&dlTtiReq->pdus[numPduEncoded], &macCellCfg,\ + currDlSlot, &msgLen, idx, dlTtiReq->sfn); numPduEncoded++; } } + printf("\033[1;31m"); + DU_LOG("\nLWR_MAC: MIB sent.."); + printf("\033[0m"); } - if(currDlSlot->cellBroadcastInfo.sib1Trans) + if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans) { /* Filling SIB1 param */ - if(dlTtiReqPdu != NULLP) - { - if(numPduEncoded != nPdu) - { - dlTtiReq->pdus++; - dlTtiReqPdu = dlTtiReq->pdus; - fillPdcchPdu(dlTtiReqPdu, &currDlSlot->cellBroadcastInfo.\ - sib1Alloc.sib1PdcchCfg, &msgLen); - dlTtiReq->pdus = dlTtiReqPdu; - numPduEncoded++; - dlTtiReq->pdus++; - dlTtiReqPdu = dlTtiReq->pdus; - fillPdschPdu(dlTtiReqPdu,&currDlSlot->cellBroadcastInfo.\ - sib1Alloc.sib1PdschCfg, &msgLen); - dlTtiReq->pdus = dlTtiReqPdu; - numPduEncoded++; - } - } - } - 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); - if(currDlSlot->cellBroadcastInfo.sib1Trans) - { - if(currDlSlot->cellBroadcastInfo.ssbTrans) + if(numPduEncoded != nPdu) { - - MAC_FREE(dlTtiReq->pdus[1].u.pdcch_pdu.dlDci, - sizeof(fapi_dl_dci_t)); - } - else - { - - MAC_FREE(dlTtiReq->pdus[0].u.pdcch_pdu.dlDci, - sizeof(fapi_dl_dci_t)); + rntiType = SI_RNTI_TYPE; + fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo,\ + &msgLen, rntiType); + numPduEncoded++; + fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], + &currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdschCfg, + currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.bwp, + &msgLen, pduIndex); + pduIndex++; + numPduEncoded++; } + printf("\033[1;34m"); + DU_LOG("\nLWR_MAC: SIB1 sent..."); + printf("\033[0m"); } - - MAC_FREE(dlTtiReqPdu, (nPdu * sizeof(fapi_dl_tti_req_pdu_t))); } - else + if(currDlSlot->dlInfo.rarAlloc != NULLP) { - 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); + /* Filling RAR param */ + rntiType = RA_RNTI_TYPE; + fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \ + &currDlSlot->dlInfo, &msgLen, rntiType); + numPduEncoded++; + fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], + &currDlSlot->dlInfo.rarAlloc->rarPdschCfg, + currDlSlot->dlInfo.rarAlloc->bwp, + &msgLen, pduIndex); + numPduEncoded++; + pduIndex++; + + printf("\033[1;32m"); + DU_LOG("\nLWR_MAC: RAR sent..."); + printf("\033[0m"); } - MAC_FREE(dlTtiReq, sizeof(fapi_dl_tti_req_t)); - return ROK; + if(currDlSlot->dlInfo.msg4Alloc != NULLP) + { + /* Filling Msg4 param */ + rntiType = TC_RNTI_TYPE; + fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \ + &currDlSlot->dlInfo, &msgLen, rntiType); + numPduEncoded++; + fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], + &currDlSlot->dlInfo.msg4Alloc->msg4PdschCfg, + currDlSlot->dlInfo.msg4Alloc->bwp, + &msgLen, pduIndex); + numPduEncoded++; + pduIndex++; + + printf("\033[1;32m"); + DU_LOG("\nLWR_MAC: MSG4 sent..."); + printf("\033[0m"); + } + msgLen += sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t); + fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen); + LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, \ + (void *)dlTtiReq); + + /* send Tx-DATA req message */ + sendTxDataReq(currTimingInfo, &currDlSlot->dlInfo); } else { - DU_LOG("\nLOWER MAC: Failed to allocate memory for DL TTI Request"); - return RFAILED; + msgLen = sizeof(fapi_dl_tti_req_t) - sizeof(fapi_msg_t); + fillMsgHeader(&dlTtiReq->header, FAPI_DL_TTI_REQUEST, msgLen); + LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, (void *)dlTtiReq); } + return ROK; } - else + else + { + DU_LOG("\nLWR_MAC: Failed to allocate memory for DL TTI Request"); + return RFAILED; + } + } + else + { + lwr_mac_handleInvalidEvt(&currTimingInfo); + return RFAILED; + } +#endif + return ROK; +} + +/******************************************************************* + * + * @brief Sends TX data Request to PHY + * + * @details + * + * Function : sendTxDataReq + * + * Functionality: + * -Sends FAPI TX data req to PHY + * + * @params[in] timing info + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo) +{ +#ifdef FAPI + uint8_t nPdu = 0; + uint32_t msgLen = 0; + uint16_t pduIndex = 0; + uint32_t txDataReqMsgSize = 0; + fapi_tx_data_req_t *txDataReq = NULLP; + Inst inst = 0; + + /* send TX_Data request message */ + nPdu = calcTxDataReqPduCount(dlInfo); + if(nPdu > 0) + { + txDataReqMsgSize = sizeof(fapi_tx_data_req_t) + \ + (nPdu * sizeof(fapi_tx_pdu_desc_t)); + if(dlInfo->brdcstAlloc.sib1Trans) { - DU_LOG("\nLOWER MAC: Current TTI Info is NULL"); + txDataReqMsgSize += rgCb[inst].cell->macCellCfg.sib1Cfg.sib1PduLen; + } + if(dlInfo->rarAlloc != NULLP) + { + txDataReqMsgSize += dlInfo->rarAlloc->rarInfo.rarPduLen; + } + if(dlInfo->msg4Alloc != NULLP) + { + txDataReqMsgSize += dlInfo->msg4Alloc->msg4Info.msg4PduLen; + } + + LWR_MAC_ALLOC(txDataReq, txDataReqMsgSize); + if(txDataReq == NULLP) + { + DU_LOG("\nLWR_MAC: Failed to allocate memory for TX data Request"); return RFAILED; } - } - else - { - lwr_mac_handleInvalidEvt(dlTtiReqtimingInfo); + + memset(txDataReq, 0, txDataReqMsgSize); + txDataReq->sfn = currTimingInfo.sfn; + txDataReq->slot = currTimingInfo.slot; + txDataReq->pduDesc = (fapi_tx_pdu_desc_t *)(txDataReq + \ + (sizeof(fapi_tx_data_req_t) - sizeof(fapi_tx_pdu_desc_t *))); + + if(dlInfo->brdcstAlloc.sib1Trans) + { + fillSib1TxDataReq(txDataReq->pduDesc, + &rgCb[inst].cell->macCellCfg, &msgLen, pduIndex); + pduIndex++; + txDataReq->numPdus++; + } + if(dlInfo->rarAlloc != NULLP) + { + fillRarTxDataReq(txDataReq->pduDesc, &dlInfo->rarAlloc->rarInfo, &msgLen, pduIndex); + pduIndex++; + txDataReq->numPdus++; + + MAC_FREE(dlInfo->rarAlloc,sizeof(RarAlloc)); + dlInfo->rarAlloc = NULLP; + } + if(dlInfo->msg4Alloc != NULLP) + { + fillMsg4TxDataReq(txDataReq->pduDesc, &dlInfo->msg4Alloc->\ + msg4Info, &msgLen, pduIndex); + pduIndex++; + txDataReq->numPdus++; + + MAC_FREE(dlInfo->msg4Alloc,sizeof(Msg4Alloc)); + dlInfo->msg4Alloc = NULLP; + } + 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, txDataReqMsgSize, \ + (void *)txDataReq); } #endif return ROK; @@ -2631,33 +3410,39 @@ S16 handleDlTtiReq(CmLteTimingInfo *dlTtiReqtimingInfo) #ifdef FAPI uint8_t getnPdus(fapi_ul_tti_req_t *ulTtiReq, MacUlSlot *currUlSlot) { - uint8_t pduCount = 0; + uint8_t pduCount = 0; - if(currUlSlot != NULLP) - { - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH) - { - pduCount++; - ulTtiReq->rachPresent = PDU_PRESENT; + if(ulTtiReq && currUlSlot) + { + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH) + { + pduCount++; + ulTtiReq->rachPresent = PDU_PRESENT; + } + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH) + { + pduCount++; + ulTtiReq->nUlsch++; } - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH_UCI) + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH_UCI) { - pduCount++; + pduCount++; + ulTtiReq->nUlsch++; ulTtiReq->nUlsch = PDU_PRESENT; } - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_UCI) + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_UCI) { - pduCount++; + pduCount++; ulTtiReq->nUlcch = PDU_PRESENT; } - if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_SRS) + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_SRS) { - pduCount++; + pduCount++; } - } - return pduCount; -} -#endif + } + return pduCount; +} +#endif /*********************************************************************** * @@ -2678,11 +3463,11 @@ void setNumCs(uint8_t *numCs, MacCellCfg *macCellCfg) { #ifdef 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 } @@ -2710,12 +3495,12 @@ void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, Ma { 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.numPrachOcas = currUlSlot->ulInfo.prachSchInfo.numPrachOcas; ulTtiReqPdu->u.prach_pdu.prachFormat = \ - currUlSlot->ulCellInfo.prachSchInfo.prachFormat; - ulTtiReqPdu->u.prach_pdu.numRa = currUlSlot->ulCellInfo.prachSchInfo.numRa; + currUlSlot->ulInfo.prachSchInfo.prachFormat; + ulTtiReqPdu->u.prach_pdu.numRa = currUlSlot->ulInfo.prachSchInfo.numRa; ulTtiReqPdu->u.prach_pdu.prachStartSymbol = \ - currUlSlot->ulCellInfo.prachSchInfo.prachStartSymb; + currUlSlot->ulInfo.prachSchInfo.prachStartSymb; setNumCs(&ulTtiReqPdu->u.prach_pdu.numCs, macCellCfg); ulTtiReqPdu->u.prach_pdu.beamforming.numPrgs = 0; ulTtiReqPdu->u.prach_pdu.beamforming.prgSize = 0; @@ -2723,7 +3508,70 @@ void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, Ma ulTtiReqPdu->u.prach_pdu.beamforming.pmi_bfi[0].pmIdx = 0; ulTtiReqPdu->u.prach_pdu.beamforming.pmi_bfi[0].beamIdx[0].beamidx = 0; ulTtiReqPdu->pduSize = sizeof(fapi_ul_prach_pdu_t); - SETLENGTH(*msgLen, sizeof(fapi_dl_pdsch_pdu_t)); + + SET_MSG_LEN(*msgLen, (sizeof(ulTtiReqPdu->pduType) + \ + sizeof(ulTtiReqPdu->pduSize) + sizeof(fapi_ul_prach_pdu_t))); + } +} + +void fillPuschPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, MacUlSlot *currUlSlot, uint32_t *msgLen) +{ + if(ulTtiReqPdu != NULLP) + { + ulTtiReqPdu->pduType = PUSCH_PDU_TYPE; + ulTtiReqPdu->u.pusch_pdu.pduBitMap = 1; + ulTtiReqPdu->u.pusch_pdu.rnti = currUlSlot->ulInfo.crnti; + /* TODO : Fill handle in raCb when scheduling pusch and access here */ + ulTtiReqPdu->u.pusch_pdu.handle = 100; + ulTtiReqPdu->u.pusch_pdu.bwpSize = macCellCfg->initialUlBwp.bwp.numPrb; + ulTtiReqPdu->u.pusch_pdu.bwpStart = macCellCfg->initialUlBwp.bwp.firstPrb; + ulTtiReqPdu->u.pusch_pdu.subCarrierSpacing = \ + macCellCfg->initialUlBwp.bwp.scs; + ulTtiReqPdu->u.pusch_pdu.cyclicPrefix = \ + macCellCfg->initialUlBwp.bwp.cyclicPrefix; + ulTtiReqPdu->u.pusch_pdu.targetCodeRate = 308; + ulTtiReqPdu->u.pusch_pdu.qamModOrder = 2; + ulTtiReqPdu->u.pusch_pdu.mcsIndex = \ + currUlSlot->ulInfo.schPuschInfo.tbInfo.mcs; + ulTtiReqPdu->u.pusch_pdu.mcsTable = 0; + ulTtiReqPdu->u.pusch_pdu.transformPrecoding = 1; + ulTtiReqPdu->u.pusch_pdu.dataScramblingId = currUlSlot->ulInfo.cellId; + ulTtiReqPdu->u.pusch_pdu.nrOfLayers = 1; + ulTtiReqPdu->u.pusch_pdu.ulDmrsSymbPos = 4; + ulTtiReqPdu->u.pusch_pdu.dmrsConfigType = 0; + ulTtiReqPdu->u.pusch_pdu.ulDmrsScramblingId = currUlSlot->ulInfo.cellId; + ulTtiReqPdu->u.pusch_pdu.scid = 0; + ulTtiReqPdu->u.pusch_pdu.numDmrsCdmGrpsNoData = 1; + ulTtiReqPdu->u.pusch_pdu.dmrsPorts = 0; + ulTtiReqPdu->u.pusch_pdu.resourceAlloc = \ + currUlSlot->ulInfo.schPuschInfo.resAllocType; + ulTtiReqPdu->u.pusch_pdu.rbStart = \ + currUlSlot->ulInfo.schPuschInfo.fdAlloc.startPrb; + ulTtiReqPdu->u.pusch_pdu.rbSize = \ + currUlSlot->ulInfo.schPuschInfo.fdAlloc.numPrb; + ulTtiReqPdu->u.pusch_pdu.vrbToPrbMapping = 0; + ulTtiReqPdu->u.pusch_pdu.frequencyHopping = 0; + ulTtiReqPdu->u.pusch_pdu.txDirectCurrentLocation = 0; + ulTtiReqPdu->u.pusch_pdu.uplinkFrequencyShift7p5khz = 0; + ulTtiReqPdu->u.pusch_pdu.startSymbIndex = \ + currUlSlot->ulInfo.schPuschInfo.tdAlloc.startSymb; + ulTtiReqPdu->u.pusch_pdu.nrOfSymbols = \ + currUlSlot->ulInfo.schPuschInfo.tdAlloc.numSymb; + ulTtiReqPdu->u.pusch_pdu.puschData.rvIndex = \ + currUlSlot->ulInfo.schPuschInfo.tbInfo.rv; + ulTtiReqPdu->u.pusch_pdu.puschData.harqProcessId = \ + currUlSlot->ulInfo.schPuschInfo.harqProcId; + ulTtiReqPdu->u.pusch_pdu.puschData.newDataIndicator = \ + currUlSlot->ulInfo.schPuschInfo.tbInfo.ndi; + ulTtiReqPdu->u.pusch_pdu.puschData.tbSize = \ + currUlSlot->ulInfo.schPuschInfo.tbInfo.tbSize; + /* numCb is 0 for new transmission */ + ulTtiReqPdu->u.pusch_pdu.puschData.numCb = 0; + + ulTtiReqPdu->pduSize = sizeof(fapi_ul_pusch_pdu_t); + + SET_MSG_LEN(*msgLen, (sizeof(ulTtiReqPdu->pduType) + \ + sizeof(ulTtiReqPdu->pduSize) + sizeof(fapi_ul_pusch_pdu_t))); } } #endif @@ -2744,84 +3592,91 @@ void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, Ma * RFAILED - failure * ******************************************************************/ -S16 handleUlTtiReq(CmLteTimingInfo *currTimingInfo) +uint16_t handleUlTtiReq(SlotIndInfo currTimingInfo) { #ifdef FAPI - uint32_t msgLen = 0; + uint8_t pduIdx = -1; + uint8_t numPdu = 0; + uint32_t msgLen = 0; + uint32_t msgSize = 0; + fapi_ul_tti_req_t *ulTtiReq = NULLP; - fapi_ul_tti_req_pdu_t *ulTtiReqPdu = NULLP; + SlotIndInfo ulTtiReqTimingInfo; + RgCellCb *cellCbParams = NULLP; MacUlSlot *currUlSlot = NULLP; MacCellCfg macCellCfg; - memset(&macCellCfg, 0, sizeof(MacCellCfg)); Inst inst = 0; if(clGlobalCp.phyState == PHY_STATE_RUNNING) - { - cellCbParams = rgCb[inst].cell; - macCellCfg = cellCbParams->macCellCfg; + { + cellCbParams = rgCb[inst].cell; + macCellCfg = cellCbParams->macCellCfg; - if(currTimingInfo != NULLP) - { -#ifdef INTEL_WLS - WLS_MEM_ALLOC(ulTtiReq, sizeof(fapi_ul_tti_req_t)); -#else - MAC_ALLOC(ulTtiReq, sizeof(fapi_ul_tti_req_t)); -#endif - if(ulTtiReq != NULLP) - { - 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) - { -#ifdef INTEL_WLS - WLS_MEM_ALLOC(ulTtiReqPdu, (ulTtiReq->nPdus * sizeof(fapi_ul_tti_req_pdu_t))); -#else - MAC_ALLOC(ulTtiReqPdu, (ulTtiReq->nPdus * sizeof(fapi_ul_tti_req_pdu_t))); -#endif - /* 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); - MAC_FREE(ulTtiReqPdu, (ulTtiReq->nPdus * sizeof(fapi_ul_tti_req_pdu_t))); - } - } - 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); - } - MAC_FREE(ulTtiReq, sizeof(fapi_ul_tti_req_t)); - return ROK; - } - else - { - DU_LOG("\nLOWER MAC: Failed to allocate memory for UL TTI Request"); - return RFAILED; - } - } - else - { - DU_LOG("\nLOWER MAC: Current TTI Info in UL is NULL"); - return RFAILED; - } - } + /* add PHY delta */ + ADD_DELTA_TO_TIME(currTimingInfo,ulTtiReqTimingInfo,PHY_DELTA); + + currUlSlot = &macCb.macCell->ulSlot[ulTtiReqTimingInfo.slot % MAX_SLOT_SUPPORTED]; + numPdu = getnPdus(NULL, currUlSlot); + msgSize = sizeof(fapi_ul_tti_req_t) + (numPdu*sizeof(fapi_ul_tti_req_pdu_t)); + LWR_MAC_ALLOC(ulTtiReq, msgSize); + + if(ulTtiReq != NULLP) + { + memset(ulTtiReq, 0, msgSize); + ulTtiReq->sfn = currTimingInfo.sfn; + ulTtiReq->slot = currTimingInfo.slot; + ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot); + ulTtiReq->nGroup = 0; + if(ulTtiReq->nPdus > 0) + { + ulTtiReq->pdus = (fapi_ul_tti_req_pdu_t *)(ulTtiReq + \ + (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_ul_tti_req_pdu_t*))); + /* Fill Prach Pdu */ + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH) + { + pduIdx++; + fillPrachPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen); + } + + /* Fill PUSCH PDU */ + if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH) + { + pduIdx++; + fillPuschPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen); + } + + if((currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH) || \ + (currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH)) + { + msgLen += (sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t)); + fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen); + + DU_LOG("\nLWR_MAC: Sending UL TTI Request"); + LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq); + } + } + else + { + msgLen = sizeof(fapi_ul_tti_req_t) - sizeof(fapi_msg_t); + fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, msgLen); + + DU_LOG("\nLWR_MAC: Sending UL TTI Request"); + LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (void *)ulTtiReq); + } + memset(&currUlSlot, 0, sizeof(MacUlSlot)); + return ROK; + } + else + { + DU_LOG("\nLWR_MAC: Failed to allocate memory for UL TTI Request"); + memset(&currUlSlot, 0, sizeof(MacUlSlot)); + return RFAILED; + } + } else { - lwr_mac_handleInvalidEvt(currTimingInfo); + lwr_mac_handleInvalidEvt(&currTimingInfo); } #endif return ROK; @@ -2836,6 +3691,7 @@ lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] = lwr_mac_handleConfigReqEvt, lwr_mac_handleConfigRspEvt, lwr_mac_handleInvalidEvt, + lwr_mac_handleInvalidEvt, }, { /* PHY_STATE_CONFIGURED */ @@ -2844,6 +3700,7 @@ lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] = lwr_mac_handleConfigReqEvt, lwr_mac_handleConfigRspEvt, lwr_mac_handleStartReqEvt, + lwr_mac_handleInvalidEvt, }, { /* PHY_STATE_RUNNING */ @@ -2852,12 +3709,13 @@ lwrMacFsmHdlr fapiEvtHdlr[MAX_STATE][MAX_EVENT] = lwr_mac_handleConfigReqEvt, lwr_mac_handleConfigRspEvt, lwr_mac_handleInvalidEvt, + lwr_mac_handleStopReqEvt, } }; /******************************************************************* * - * @brief Sends message to Lower Mac Fsm Event Handler + * @brief Sends message to LWR_MAC Fsm Event Handler * * @details *