X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=src%2F5gnrmac%2Flwr_mac_fsm.c;h=794428ff4604b4c51ef195baea48a5aba47d8b43;hb=refs%2Fheads%2Foai-integration;hp=85914433470a4ae6b9fd9e3d7915f2d009b2781b;hpb=c183ff1a9e7f53b352ce7b3a00304c192b45660d;p=o-du%2Fl2.git diff --git a/src/5gnrmac/lwr_mac_fsm.c b/src/5gnrmac/lwr_mac_fsm.c index 859144334..794428ff4 100644 --- a/src/5gnrmac/lwr_mac_fsm.c +++ b/src/5gnrmac/lwr_mac_fsm.c @@ -37,6 +37,7 @@ #include "lwr_mac_phy.h" #include "lwr_mac_utils.h" #include "mac_utils.h" +#include "nfapi_interface.h" #define MIB_SFN_BITMASK 0xFC #define PDCCH_PDU_TYPE 0 @@ -51,7 +52,7 @@ /* Global variables */ LwrMacCb lwrMacCb; -uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX]; +extern uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX]; void fapiMacConfigRsp(uint16_t cellId); uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, MacDlSlot *dlSlot, p_fapi_api_queue_elem_t prevElem, fapi_vendor_tx_data_req_t *vendorTxDataReq); uint16_t fillUlTtiReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t prevElem, fapi_vendor_ul_tti_req_t* vendorUlTti); @@ -106,6 +107,16 @@ uint8_t lwr_mac_procInvalidEvt(void *msg) return ROK; } +uint16_t reverseBytes16(uint16_t num) { + return (num >> 8) | (num << 8); +} + +uint32_t reverseBytes32(uint32_t num) { + return ((num >> 24) & 0x000000FF) | + ((num >> 8) & 0x0000FF00) | + ((num << 8) & 0x00FF0000) | + ((num << 24) & 0xFF000000); +} #ifdef INTEL_FAPI /******************************************************************* * @@ -128,8 +139,13 @@ uint8_t lwr_mac_procInvalidEvt(void *msg) void fillMsgHeader(fapi_msg_t *hdr, uint16_t msgType, uint32_t msgLen) { memset(hdr, 0, sizeof(fapi_msg_t)); - hdr->msg_id = msgType; - hdr->length = msgLen; +#ifdef OAI_TESTING + hdr->msg_id = reverseBytes16(msgType); + hdr->length = reverseBytes32(msgLen); +#else + hdr->msg_id = (msgType); + hdr->length = (msgLen); +#endif } /******************************************************************* @@ -154,10 +170,17 @@ void fillMsgHeader(fapi_msg_t *hdr, uint16_t msgType, uint32_t msgLen) void fillTlvs(fapi_uint32_tlv_t *tlv, uint16_t tag, uint16_t length, uint32_t value, uint32_t *msgLen) { - tlv->tl.tag = tag; - tlv->tl.length = length; - tlv->value = value; +#ifdef OAI_TESTING + tlv->tl.tag = reverseBytes16(tag); + tlv->tl.length = reverseBytes16(length); + tlv->value = reverseBytes32(value); +#else + tlv->tl.tag = (tag); + tlv->tl.length = (length); + tlv->value = (value); +#endif *msgLen = *msgLen + sizeof(tag) + sizeof(length) + length; + } /******************************************************************* * @@ -1974,6 +1997,250 @@ uint8_t lwr_mac_procIqSamplesReqEvt(void *msg) return ROK; } #endif + +#ifdef OAI_TESTING +/******************************************************************* + * + * @brief Build FAPI Config Req as per OAI code and send to PHY + * + * @details + * + * Function : buildAndSendOAIConfigReqToL1 + * + * Functionality: + * -Build FAPI Config Req as per OAI code and send to PHY + * + * @params[in] void *msg + * @return ROK - success + * RFAILED - failure + * + * ****************************************************************/ +uint8_t buildAndSendOAIConfigReqToL1(void *msg) +{ +#ifdef INTEL_FAPI +#ifdef CALL_FLOW_DEBUG_LOG + DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : CONFIG_REQ\n"); +#endif +#ifdef NR_TDD + uint8_t slotIdx = 0; + uint8_t symbolIdx =0; +#endif + uint8_t totalTlv=0; + uint16_t index = 0; + uint16_t *cellId =NULLP; + uint16_t cellIdx =0; + uint32_t msgLen = 0; + uint32_t totalCfgReqMsgLen=0; + uint32_t mib = 0; + uint32_t dlFreq = 0, ulFreq = 0; + MacCellCfg macCfgParams; + fapi_config_req_t *configReq; + fapi_msg_header_t *msgHeader; + p_fapi_api_queue_elem_t headerElem; + p_fapi_api_queue_elem_t cfgReqQElem; + + DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \ + lwrMacCb.phyState); + + cellId = (uint16_t *)msg; + GET_CELL_IDX(*cellId, cellIdx); + macCfgParams = macCb.macCell[cellIdx]->macCellCfg; + + /* Fill Cell Configuration in lwrMacCb */ + memset(&lwrMacCb.cellCb[lwrMacCb.numCell], 0, sizeof(LwrMacCellCb)); + lwrMacCb.cellCb[lwrMacCb.numCell].cellId = macCfgParams.cellId; + lwrMacCb.cellCb[lwrMacCb.numCell].phyCellId = macCfgParams.cellCfg.phyCellId; + lwrMacCb.numCell++; + uint16_t psize=sizeof(fapi_api_queue_elem_t)+(sizeof(fapi_config_req_t)); + +#ifndef NR_TDD + totalTlv = 24; +#else + //configReq->number_of_tlvs = 25 + 1 + MAX_TDD_PERIODICITY_SLOTS * MAX_SYMB_PER_SLOT; + totalTlv = 24 + 1+ MAX_TDD_PERIODICITY_SLOTS * MAX_SYMB_PER_SLOT; +#endif + /* totalCfgReqMsgLen = size of config req's msg header + size of tlv supporting + size of tlv supporting *sizeof(fapi_uint32_tlv_t) */ + totalCfgReqMsgLen += sizeof(configReq->header) + sizeof( configReq->number_of_tlvs) + totalTlv*sizeof(fapi_uint32_tlv_t); + + /* Fill FAPI config req */ + LWR_MAC_ALLOC(cfgReqQElem,(sizeof(fapi_api_queue_elem_t)+totalCfgReqMsgLen)); + + if(!cfgReqQElem) + { + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for config req"); + return RFAILED; + } + FILL_FAPI_LIST_ELEM(cfgReqQElem, NULLP, FAPI_CONFIG_REQUEST, 1, totalCfgReqMsgLen); + configReq = (fapi_config_req_t *)(cfgReqQElem + 1); + memset(configReq, 0, sizeof(fapi_config_req_t)); + fillMsgHeader(&configReq->header, FAPI_CONFIG_REQUEST, totalCfgReqMsgLen); + configReq->number_of_tlvs = totalTlv; + msgLen = sizeof(configReq->number_of_tlvs); + + fillTlvs(&configReq->tlvs[index++], FAPI_DL_BANDWIDTH_TAG, \ + sizeof(uint16_t), macCfgParams.carrCfg.dlBw, &msgLen); + dlFreq = convertArfcnToFreqKhz(macCfgParams.carrCfg.arfcnDL); + fillTlvs(&configReq->tlvs[index++], FAPI_DL_FREQUENCY_TAG, \ + sizeof(uint32_t), dlFreq, &msgLen); + /* Due to bug in Intel FT code, commenting TLVs that are are not + * needed to avoid error. Must be uncommented when FT bug is fixed */ + //fillTlvs(&configReq->tlvs[index++], FAPI_DL_K0_TAG, \ + sizeof(uint16_t), macCfgParams.dlCarrCfg.k0[0], &msgLen); + //fillTlvs(&configReq->tlvs[index++], FAPI_DL_GRIDSIZE_TAG, \ + sizeof(uint16_t), macCfgParams.dlCarrCfg.gridSize[0], &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_NUM_TX_ANT_TAG, \ + sizeof(uint16_t), macCfgParams.carrCfg.numTxAnt, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_BANDWIDTH_TAG, \ + sizeof(uint16_t), macCfgParams.carrCfg.ulBw, &msgLen); + ulFreq = convertArfcnToFreqKhz(macCfgParams.carrCfg.arfcnUL); + fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_FREQUENCY_TAG, \ + sizeof(uint32_t), ulFreq, &msgLen); + //fillTlvs(&configReq->tlvs[index++], FAPI_UL_K0_TAG, \ + sizeof(uint16_t), macCfgParams.ulCarrCfg.k0[0], &msgLen); + //fillTlvs(&configReq->tlvs[index++], FAPI_UL_GRID_SIZE_TAG, \ + sizeof(uint16_t), macCfgParams.ulCarrCfg.gridSize[0], &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_NUM_RX_ANT_TAG, \ + sizeof(uint16_t), macCfgParams.carrCfg.numRxAnt, &msgLen); + //fillTlvs(&configReq->tlvs[index++], FAPI_FREQUENCY_SHIFT_7P5_KHZ_TAG, \ + sizeof(uint8_t), macCfgParams.freqShft, &msgLen); + + /* fill cell config */ + fillTlvs(&configReq->tlvs[index++], FAPI_PHY_CELL_ID_TAG, \ + sizeof(uint16_t), macCfgParams.cellCfg.phyCellId, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_FRAME_DUPLEX_TYPE_TAG, \ + sizeof(uint8_t), macCfgParams.cellCfg.dupType, &msgLen); + + /* fill SSB configuration */ + fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_POWER_TAG, \ + sizeof(uint32_t), macCfgParams.ssbCfg.ssbPbchPwr, &msgLen); + //fillTlvs(&configReq->tlvs[index++], FAPI_BCH_PAYLOAD_TAG, \ + sizeof(uint8_t), macCfgParams.ssbCfg.bchPayloadFlag, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_SCS_COMMON_TAG, \ + sizeof(uint8_t), macCfgParams.ssbCfg.scsCmn, &msgLen); + + /* fill PRACH configuration */ + //fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SEQUENCE_LENGTH_TAG, \ + sizeof(uint8_t), macCfgParams.prachCfg.prachSeqLen, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SUBC_SPACING_TAG, \ + sizeof(uint8_t), convertScsValToScsEnum(macCfgParams.prachCfg.prachSubcSpacing), &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_RESTRICTED_SET_CONFIG_TAG, \ + sizeof(uint8_t), macCfgParams.prachCfg.prachRstSetCfg, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_NUM_PRACH_FD_OCCASIONS_TAG, + sizeof(uint8_t), macCfgParams.prachCfg.msg1Fdm, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_CONFIG_INDEX_TAG, + sizeof(uint8_t), macCfgParams.prachCfg.prachCfgIdx, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ROOT_SEQUENCE_INDEX_TAG, \ + sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].rootSeqIdx, &msgLen); + //fillTlvs(&configReq->tlvs[index++], FAPI_NUM_ROOT_SEQUENCES_TAG, \ + sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numRootSeq, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_K1_TAG, \ + sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].k1, &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ZERO_CORR_CONF_TAG , \ + sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].zeroCorrZoneCfg, &msgLen); + //fillTlvs(&configReq->tlvs[index++], FAPI_NUM_UNUSED_ROOT_SEQUENCES_TAG, \ + sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numUnusedRootSeq, &msgLen); + /* if(macCfgParams.prachCfg.fdm[0].numUnusedRootSeq) + { + 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); + + setMibPdu(macCfgParams.ssbCfg.mibPdu, &mib, 0); + fillTlvs(&configReq->tlvs[index++], FAPI_MIB_TAG , \ + sizeof(uint32_t), mib, &msgLen); + + fillTlvs(&configReq->tlvs[index++], FAPI_SSB_MASK_TAG, \ + sizeof(uint32_t), macCfgParams.ssbCfg.ssbMask[0], &msgLen); + fillTlvs(&configReq->tlvs[index++], FAPI_BEAM_ID_TAG, \ + sizeof(uint8_t), macCfgParams.ssbCfg.beamId[0], &msgLen); + //fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, \ + sizeof(uint8_t), macCfgParams.ssbCfg.multCarrBand, &msgLen); + //fillTlvs(&configReq->tlvs[index++], FAPI_MULTIPLE_CELLS_SS_PBCH_IN_A_CARRIER_TAG, \ + sizeof(uint8_t), macCfgParams.ssbCfg.multCellCarr, &msgLen); + +#ifdef NR_TDD + /* fill TDD table */ + fillTlvs(&configReq->tlvs[index++], FAPI_TDD_PERIOD_TAG, \ + sizeof(uint8_t), macCfgParams.tddCfg.tddPeriod, &msgLen); + for(slotIdx =0 ;slotIdx < MAX_TDD_PERIODICITY_SLOTS; slotIdx++) + { + for(symbolIdx = 0; symbolIdx < MAX_SYMB_PER_SLOT; symbolIdx++) + { + /*Fill Full-DL Slots as well as DL symbols ini 1st Flexi Slo*/ + if(slotIdx < macCfgParams.tddCfg.nrOfDlSlots || \ + (slotIdx == macCfgParams.tddCfg.nrOfDlSlots && symbolIdx < macCfgParams.tddCfg.nrOfDlSymbols)) + { + fillTlvs(&configReq->tlvs[index++], FAPI_SLOT_CONFIG_TAG, \ + sizeof(uint8_t), DL_SYMBOL, &msgLen); + } + + /*Fill Full-FLEXI SLOT and as well as Flexi Symbols in 1 slot preceding FULL-UL slot*/ + else if(slotIdx < (MAX_TDD_PERIODICITY_SLOTS - macCfgParams.tddCfg.nrOfUlSlots -1) || \ + (slotIdx == (MAX_TDD_PERIODICITY_SLOTS - macCfgParams.tddCfg.nrOfUlSlots -1) && \ + symbolIdx < (MAX_SYMB_PER_SLOT - macCfgParams.tddCfg.nrOfUlSymbols))) + { + fillTlvs(&configReq->tlvs[index++], FAPI_SLOT_CONFIG_TAG, \ + sizeof(uint8_t), FLEXI_SYMBOL, &msgLen); + } + /*Fill Partial UL symbols and Full-UL slot*/ + else + { + fillTlvs(&configReq->tlvs[index++], FAPI_SLOT_CONFIG_TAG, \ + sizeof(uint8_t), UL_SYMBOL, &msgLen); + } + } + } +#endif + + /* fill measurement config */ + //fillTlvs(&configReq->tlvs[index++], FAPI_RSSI_MEASUREMENT_TAG, \ + sizeof(uint8_t), macCfgParams.rssiUnit, &msgLen); + + /* fill DMRS Type A Pos */ + // fillTlvs(&configReq->tlvs[index++], FAPI_DMRS_TYPE_A_POS_TAG, \ + sizeof(uint8_t), macCfgParams.ssbCfg.dmrsTypeAPos, &msgLen); + + /* Fill message header */ + LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t))); + if(!headerElem) + { + DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req"); + LWR_MAC_FREE(cfgReqQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_config_req_t))); + return RFAILED; + } + FILL_FAPI_LIST_ELEM(headerElem, cfgReqQElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \ + sizeof(fapi_msg_header_t)); + msgHeader = (fapi_msg_header_t*)(headerElem+1); + msgHeader->num_msg = 1; /* Config req msg */ + msgHeader->handle = 0; + + DU_LOG("\nDEBUG --> LWR_MAC: Sending Config Request to Phy"); + LwrMacSendToL1(headerElem); + return ROK; +#endif +} +#endif /******************************************************************* * @@ -1994,6 +2261,7 @@ uint8_t lwr_mac_procIqSamplesReqEvt(void *msg) uint8_t lwr_mac_procConfigReqEvt(void *msg) { +#ifndef OAI_TESTING #ifdef INTEL_FAPI #ifdef CALL_FLOW_DEBUG_LOG DU_LOG("\nCall Flow: ENTMAC -> ENTLWRMAC : CONFIG_REQ\n"); @@ -2242,7 +2510,9 @@ uint8_t lwr_mac_procConfigReqEvt(void *msg) DU_LOG("\nDEBUG --> LWR_MAC: Sending Config Request to Phy"); LwrMacSendToL1(headerElem); #endif - +#else + buildAndSendOAIConfigReqToL1(msg); +#endif return ROK; } /* lwr_mac_handleConfigReqEvt */ @@ -3807,7 +4077,7 @@ uint16_t fillDlTtiReq(SlotTimingInfo currTimingInfo) { GET_CELL_IDX(currTimingInfo.cellId, cellIdx); /* consider phy delay */ - ADD_DELTA_TO_TIME(currTimingInfo,dlTtiReqTimingInfo,PHY_DELTA_DL, macCb.macCell[cellIdx]->numOfSlots); + ADD_DELTA_TO_TIME(currTimingInfo,dlTtiReqTimingInfo,gConfigInfo.gPhyDeltaDl, macCb.macCell[cellIdx]->numOfSlots); dlTtiReqTimingInfo.cellId = currTimingInfo.cellId; macCellCfg = macCb.macCell[cellIdx]->macCellCfg; @@ -4201,33 +4471,42 @@ uint16_t sendTxDataReq(SlotTimingInfo currTimingInfo, MacDlSlot *dlSlot, p_fapi_ #ifdef INTEL_FAPI uint8_t getnPdus(fapi_ul_tti_req_t *ulTtiReq, MacUlSlot *currUlSlot) { - uint8_t pduCount = 0; + uint8_t pduCount = 0, ueIdx = 0; if(ulTtiReq && currUlSlot) { - if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH) + if(currUlSlot->ulSchInfo.dataType & SCH_DATATYPE_PRACH) { - pduCount++; - ulTtiReq->rachPresent++; + pduCount++; } - if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH) - { - pduCount++; - ulTtiReq->nUlsch++; - } - if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH_UCI) - { - pduCount++; - ulTtiReq->nUlsch++; - } - if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_UCI) + + for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++) { - pduCount++; - ulTtiReq->nUlcch++; + if(currUlSlot->ulSchInfo.dataType & SCH_DATATYPE_PUSCH) + { + if(currUlSlot->ulSchInfo.schPuschInfo[ueIdx].crnti != 0) + { + pduCount++; + } + } + if(currUlSlot->ulSchInfo.dataType & SCH_DATATYPE_PUSCH_UCI) + { + if(currUlSlot->ulSchInfo.schPuschUci[ueIdx].crnti != 0) + { + pduCount++; + } + } + if(currUlSlot->ulSchInfo.dataType & SCH_DATATYPE_UCI) + { + if(currUlSlot->ulSchInfo.schPucchInfo[ueIdx].crnti != 0) + { + pduCount++; + } + } } - if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_SRS) + if(currUlSlot->ulSchInfo.dataType & SCH_DATATYPE_SRS) { - pduCount++; + pduCount++; } } return pduCount; @@ -4286,12 +4565,12 @@ void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, Ma ulTtiReqPdu->pduType = PRACH_PDU_TYPE; ulTtiReqPdu->pdu.prach_pdu.physCellId = macCellCfg->cellCfg.phyCellId; ulTtiReqPdu->pdu.prach_pdu.numPrachOcas = \ - currUlSlot->ulInfo.prachSchInfo.numPrachOcas; + currUlSlot->ulSchInfo.prachSchInfo.numPrachOcas; ulTtiReqPdu->pdu.prach_pdu.prachFormat = \ - currUlSlot->ulInfo.prachSchInfo.prachFormat; - ulTtiReqPdu->pdu.prach_pdu.numRa = currUlSlot->ulInfo.prachSchInfo.numRa; + currUlSlot->ulSchInfo.prachSchInfo.prachFormat; + ulTtiReqPdu->pdu.prach_pdu.numRa = currUlSlot->ulSchInfo.prachSchInfo.numRa; ulTtiReqPdu->pdu.prach_pdu.prachStartSymbol = \ - currUlSlot->ulInfo.prachSchInfo.prachStartSymb; + currUlSlot->ulSchInfo.prachSchInfo.prachStartSymb; setNumCs(&ulTtiReqPdu->pdu.prach_pdu.numCs, macCellCfg); ulTtiReqPdu->pdu.prach_pdu.beamforming.numPrgs = 0; ulTtiReqPdu->pdu.prach_pdu.beamforming.prgSize = 0; @@ -4316,14 +4595,15 @@ void fillPrachPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, MacCellCfg *macCellCfg, Ma * RFAILED - failure * * ****************************************************************/ -void fillPuschPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, fapi_vendor_ul_tti_req_pdu_t *ulTtiVendorPdu, MacCellCfg *macCellCfg, MacUlSlot *currUlSlot) +void fillPuschPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, fapi_vendor_ul_tti_req_pdu_t *ulTtiVendorPdu, MacCellCfg *macCellCfg,\ + SchPuschInfo *puschInfo) { if(ulTtiReqPdu != NULLP) { ulTtiReqPdu->pduType = PUSCH_PDU_TYPE; memset(&ulTtiReqPdu->pdu.pusch_pdu, 0, sizeof(fapi_ul_pusch_pdu_t)); ulTtiReqPdu->pdu.pusch_pdu.pduBitMap = 1; - ulTtiReqPdu->pdu.pusch_pdu.rnti = currUlSlot->ulInfo.crnti; + ulTtiReqPdu->pdu.pusch_pdu.rnti = puschInfo->crnti; /* TODO : Fill handle in raCb when scheduling pusch and access here */ ulTtiReqPdu->pdu.pusch_pdu.handle = 100; ulTtiReqPdu->pdu.pusch_pdu.bwpSize = macCellCfg->cellCfg.initialUlBwp.bwp.numPrb; @@ -4333,48 +4613,48 @@ void fillPuschPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, fapi_vendor_ul_tti_req_pdu ulTtiReqPdu->pdu.pusch_pdu.cyclicPrefix = \ macCellCfg->cellCfg.initialUlBwp.bwp.cyclicPrefix; ulTtiReqPdu->pdu.pusch_pdu.targetCodeRate = 308; - ulTtiReqPdu->pdu.pusch_pdu.qamModOrder = currUlSlot->ulInfo.schPuschInfo.tbInfo.qamOrder; - ulTtiReqPdu->pdu.pusch_pdu.mcsIndex = currUlSlot->ulInfo.schPuschInfo.tbInfo.mcs; - ulTtiReqPdu->pdu.pusch_pdu.mcsTable = currUlSlot->ulInfo.schPuschInfo.tbInfo.mcsTable; + ulTtiReqPdu->pdu.pusch_pdu.qamModOrder = puschInfo->tbInfo.qamOrder; + ulTtiReqPdu->pdu.pusch_pdu.mcsIndex = puschInfo->tbInfo.mcs; + ulTtiReqPdu->pdu.pusch_pdu.mcsTable = puschInfo->tbInfo.mcsTable; ulTtiReqPdu->pdu.pusch_pdu.transformPrecoding = 1; - ulTtiReqPdu->pdu.pusch_pdu.dataScramblingId = currUlSlot->ulInfo.cellId; + ulTtiReqPdu->pdu.pusch_pdu.dataScramblingId = macCellCfg->cellId; ulTtiReqPdu->pdu.pusch_pdu.nrOfLayers = 1; ulTtiReqPdu->pdu.pusch_pdu.ulDmrsSymbPos = 4; ulTtiReqPdu->pdu.pusch_pdu.dmrsConfigType = 0; - ulTtiReqPdu->pdu.pusch_pdu.ulDmrsScramblingId = currUlSlot->ulInfo.cellId; + ulTtiReqPdu->pdu.pusch_pdu.ulDmrsScramblingId = macCellCfg->cellId; ulTtiReqPdu->pdu.pusch_pdu.scid = 0; ulTtiReqPdu->pdu.pusch_pdu.numDmrsCdmGrpsNoData = 1; ulTtiReqPdu->pdu.pusch_pdu.dmrsPorts = 0; ulTtiReqPdu->pdu.pusch_pdu.resourceAlloc = \ - currUlSlot->ulInfo.schPuschInfo.fdAlloc.resAllocType; + puschInfo->fdAlloc.resAllocType; ulTtiReqPdu->pdu.pusch_pdu.rbStart = \ - currUlSlot->ulInfo.schPuschInfo.fdAlloc.resAlloc.type1.startPrb; + puschInfo->fdAlloc.resAlloc.type1.startPrb; ulTtiReqPdu->pdu.pusch_pdu.rbSize = \ - currUlSlot->ulInfo.schPuschInfo.fdAlloc.resAlloc.type1.numPrb; + puschInfo->fdAlloc.resAlloc.type1.numPrb; ulTtiReqPdu->pdu.pusch_pdu.vrbToPrbMapping = 0; ulTtiReqPdu->pdu.pusch_pdu.frequencyHopping = 0; ulTtiReqPdu->pdu.pusch_pdu.txDirectCurrentLocation = 0; ulTtiReqPdu->pdu.pusch_pdu.uplinkFrequencyShift7p5khz = 0; ulTtiReqPdu->pdu.pusch_pdu.startSymbIndex = \ - currUlSlot->ulInfo.schPuschInfo.tdAlloc.startSymb; + puschInfo->tdAlloc.startSymb; ulTtiReqPdu->pdu.pusch_pdu.nrOfSymbols = \ - currUlSlot->ulInfo.schPuschInfo.tdAlloc.numSymb; + puschInfo->tdAlloc.numSymb; #ifdef INTEL_FAPI ulTtiReqPdu->pdu.pusch_pdu.mappingType = \ - currUlSlot->ulInfo.schPuschInfo.dmrsMappingType; + puschInfo->dmrsMappingType; ulTtiReqPdu->pdu.pusch_pdu.nrOfDmrsSymbols = \ - currUlSlot->ulInfo.schPuschInfo.nrOfDmrsSymbols; + puschInfo->nrOfDmrsSymbols; ulTtiReqPdu->pdu.pusch_pdu.dmrsAddPos = \ - currUlSlot->ulInfo.schPuschInfo.dmrsAddPos; + puschInfo->dmrsAddPos; #endif ulTtiReqPdu->pdu.pusch_pdu.puschData.rvIndex = \ - currUlSlot->ulInfo.schPuschInfo.tbInfo.rv; + puschInfo->tbInfo.rv; ulTtiReqPdu->pdu.pusch_pdu.puschData.harqProcessId = \ - currUlSlot->ulInfo.schPuschInfo.harqProcId; + puschInfo->harqProcId; ulTtiReqPdu->pdu.pusch_pdu.puschData.newDataIndicator = \ - currUlSlot->ulInfo.schPuschInfo.tbInfo.ndi; + puschInfo->tbInfo.ndi; ulTtiReqPdu->pdu.pusch_pdu.puschData.tbSize = \ - currUlSlot->ulInfo.schPuschInfo.tbInfo.tbSize; + puschInfo->tbInfo.tbSize; /* numCb is 0 for new transmission */ ulTtiReqPdu->pdu.pusch_pdu.puschData.numCb = 0; @@ -4407,50 +4687,50 @@ void fillPuschPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, fapi_vendor_ul_tti_req_pdu * * ****************************************************************/ void fillPucchPdu(fapi_ul_tti_req_pdu_t *ulTtiReqPdu, fapi_vendor_ul_tti_req_pdu_t *ulTtiVendorPdu, MacCellCfg *macCellCfg,\ - MacUlSlot *currUlSlot) + SchPucchInfo *pucchInfo) { if(ulTtiReqPdu != NULLP) { ulTtiReqPdu->pduType = PUCCH_PDU_TYPE; memset(&ulTtiReqPdu->pdu.pucch_pdu, 0, sizeof(fapi_ul_pucch_pdu_t)); - ulTtiReqPdu->pdu.pucch_pdu.rnti = currUlSlot->ulInfo.crnti; + ulTtiReqPdu->pdu.pucch_pdu.rnti = pucchInfo->crnti; /* TODO : Fill handle in raCb when scheduling pucch and access here */ ulTtiReqPdu->pdu.pucch_pdu.handle = 100; ulTtiReqPdu->pdu.pucch_pdu.bwpSize = macCellCfg->cellCfg.initialUlBwp.bwp.numPrb; ulTtiReqPdu->pdu.pucch_pdu.bwpStart = macCellCfg->cellCfg.initialUlBwp.bwp.firstPrb; ulTtiReqPdu->pdu.pucch_pdu.subCarrierSpacing = macCellCfg->cellCfg.initialUlBwp.bwp.scs; ulTtiReqPdu->pdu.pucch_pdu.cyclicPrefix = macCellCfg->cellCfg.initialUlBwp.bwp.cyclicPrefix; - ulTtiReqPdu->pdu.pucch_pdu.formatType = currUlSlot->ulInfo.schPucchInfo.pucchFormat; /* Supporting PUCCH Format 0 */ + ulTtiReqPdu->pdu.pucch_pdu.formatType = pucchInfo->pucchFormat; /* Supporting PUCCH Format 0 */ ulTtiReqPdu->pdu.pucch_pdu.multiSlotTxIndicator = 0; /* No Multi Slot transmission */ - ulTtiReqPdu->pdu.pucch_pdu.prbStart = currUlSlot->ulInfo.schPucchInfo.fdAlloc.startPrb; - ulTtiReqPdu->pdu.pucch_pdu.prbSize = currUlSlot->ulInfo.schPucchInfo.fdAlloc.numPrb; - ulTtiReqPdu->pdu.pucch_pdu.startSymbolIndex = currUlSlot->ulInfo.schPucchInfo.tdAlloc.startSymb; - ulTtiReqPdu->pdu.pucch_pdu.nrOfSymbols = currUlSlot->ulInfo.schPucchInfo.tdAlloc.numSymb; - ulTtiReqPdu->pdu.pucch_pdu.freqHopFlag = currUlSlot->ulInfo.schPucchInfo.intraFreqHop; - ulTtiReqPdu->pdu.pucch_pdu.secondHopPrb = currUlSlot->ulInfo.schPucchInfo.secondPrbHop; + ulTtiReqPdu->pdu.pucch_pdu.prbStart = pucchInfo->fdAlloc.startPrb; + ulTtiReqPdu->pdu.pucch_pdu.prbSize = pucchInfo->fdAlloc.numPrb; + ulTtiReqPdu->pdu.pucch_pdu.startSymbolIndex = pucchInfo->tdAlloc.startSymb; + ulTtiReqPdu->pdu.pucch_pdu.nrOfSymbols = pucchInfo->tdAlloc.numSymb; + ulTtiReqPdu->pdu.pucch_pdu.freqHopFlag = pucchInfo->intraFreqHop; + ulTtiReqPdu->pdu.pucch_pdu.secondHopPrb = pucchInfo->secondPrbHop; ulTtiReqPdu->pdu.pucch_pdu.groupHopFlag = 0; ulTtiReqPdu->pdu.pucch_pdu.sequenceHopFlag = 0; ulTtiReqPdu->pdu.pucch_pdu.hoppingId = 0; - ulTtiReqPdu->pdu.pucch_pdu.initialCyclicShift = currUlSlot->ulInfo.schPucchInfo.initialCyclicShift; + ulTtiReqPdu->pdu.pucch_pdu.initialCyclicShift = pucchInfo->initialCyclicShift; ulTtiReqPdu->pdu.pucch_pdu.dataScramblingId = 0; /* Valid for Format 2, 3, 4 */ - ulTtiReqPdu->pdu.pucch_pdu.timeDomainOccIdx = currUlSlot->ulInfo.schPucchInfo.timeDomOCC; - ulTtiReqPdu->pdu.pucch_pdu.preDftOccIdx = currUlSlot->ulInfo.schPucchInfo.occIdx; /* Valid for Format 4 only */ - ulTtiReqPdu->pdu.pucch_pdu.preDftOccLen = currUlSlot->ulInfo.schPucchInfo.occLen; /* Valid for Format 4 only */ - ulTtiReqPdu->pdu.pucch_pdu.pi2Bpsk = currUlSlot->ulInfo.schPucchInfo.pi2BPSK; - ulTtiReqPdu->pdu.pucch_pdu.addDmrsFlag = currUlSlot->ulInfo.schPucchInfo.addDmrs;/* Valid for Format 3, 4 only */ + ulTtiReqPdu->pdu.pucch_pdu.timeDomainOccIdx = pucchInfo->timeDomOCC; + ulTtiReqPdu->pdu.pucch_pdu.preDftOccIdx = pucchInfo->occIdx; /* Valid for Format 4 only */ + ulTtiReqPdu->pdu.pucch_pdu.preDftOccLen = pucchInfo->occLen; /* Valid for Format 4 only */ + ulTtiReqPdu->pdu.pucch_pdu.pi2Bpsk = pucchInfo->pi2BPSK; + ulTtiReqPdu->pdu.pucch_pdu.addDmrsFlag = pucchInfo->addDmrs;/* Valid for Format 3, 4 only */ ulTtiReqPdu->pdu.pucch_pdu.dmrsScramblingId = 0; /* Valid for Format 2 */ ulTtiReqPdu->pdu.pucch_pdu.dmrsCyclicShift = 0; /* Valid for Format 4 */ - ulTtiReqPdu->pdu.pucch_pdu.srFlag = currUlSlot->ulInfo.schPucchInfo.srFlag; - ulTtiReqPdu->pdu.pucch_pdu.bitLenHarq = currUlSlot->ulInfo.schPucchInfo.harqInfo.harqBitLength; + ulTtiReqPdu->pdu.pucch_pdu.srFlag = pucchInfo->srFlag; + ulTtiReqPdu->pdu.pucch_pdu.bitLenHarq = pucchInfo->harqInfo.harqBitLength; ulTtiReqPdu->pdu.pucch_pdu.bitLenCsiPart1 = 0; /* Valid for Format 2, 3, 4 */ ulTtiReqPdu->pdu.pucch_pdu.bitLenCsiPart2 = 0; /* Valid for Format 2, 3, 4 */ - ulTtiReqPdu->pdu.pucch_pdu.beamforming.numPrgs = currUlSlot->ulInfo.schPucchInfo.beamPucchInfo.numPrgs; - ulTtiReqPdu->pdu.pucch_pdu.beamforming.prgSize = currUlSlot->ulInfo.schPucchInfo.beamPucchInfo.prgSize; - ulTtiReqPdu->pdu.pucch_pdu.beamforming.digBfInterface = currUlSlot->ulInfo.schPucchInfo.beamPucchInfo.digBfInterfaces; - ulTtiReqPdu->pdu.pucch_pdu.beamforming.rx_bfi[0].beamIdx[0].beamidx = currUlSlot->ulInfo.schPucchInfo.beamPucchInfo.prg[0].beamIdx[0]; + ulTtiReqPdu->pdu.pucch_pdu.beamforming.numPrgs = pucchInfo->beamPucchInfo.numPrgs; + ulTtiReqPdu->pdu.pucch_pdu.beamforming.prgSize = pucchInfo->beamPucchInfo.prgSize; + ulTtiReqPdu->pdu.pucch_pdu.beamforming.digBfInterface = pucchInfo->beamPucchInfo.digBfInterfaces; + ulTtiReqPdu->pdu.pucch_pdu.beamforming.rx_bfi[0].beamIdx[0].beamidx = pucchInfo->beamPucchInfo.prg[0].beamIdx[0]; ulTtiReqPdu->pduSize = sizeof(fapi_ul_pucch_pdu_t); @@ -4492,6 +4772,7 @@ uint16_t fillUlTtiReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t pre #ifdef INTEL_FAPI uint16_t cellIdx =0; uint8_t pduIdx = -1; + uint8_t ueIdx = 0; SlotTimingInfo ulTtiReqTimingInfo; MacUlSlot *currUlSlot = NULLP; MacCellCfg macCellCfg; @@ -4504,67 +4785,83 @@ uint16_t fillUlTtiReq(SlotTimingInfo currTimingInfo, p_fapi_api_queue_elem_t pre macCellCfg = macCb.macCell[cellIdx]->macCellCfg; /* add PHY delta */ - ADD_DELTA_TO_TIME(currTimingInfo,ulTtiReqTimingInfo,PHY_DELTA_UL, macCb.macCell[cellIdx]->numOfSlots); + ADD_DELTA_TO_TIME(currTimingInfo,ulTtiReqTimingInfo,gConfigInfo.gPhyDeltaUl, macCb.macCell[cellIdx]->numOfSlots); currUlSlot = &macCb.macCell[cellIdx]->ulSlot[ulTtiReqTimingInfo.slot % macCb.macCell[cellIdx]->numOfSlots]; LWR_MAC_ALLOC(ulTtiElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_ul_tti_req_t))); if(ulTtiElem) { - FILL_FAPI_LIST_ELEM(ulTtiElem, NULLP, FAPI_UL_TTI_REQUEST, 1, \ - sizeof(fapi_ul_tti_req_t)); - ulTtiReq = (fapi_ul_tti_req_t *)(ulTtiElem +1); - memset(ulTtiReq, 0, sizeof(fapi_ul_tti_req_t)); - fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, sizeof(fapi_ul_tti_req_t)); - ulTtiReq->sfn = ulTtiReqTimingInfo.sfn; - ulTtiReq->slot = ulTtiReqTimingInfo.slot; - ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot); - vendorUlTti->num_ul_pdu = ulTtiReq->nPdus; - vendorUlTti->sym = 0; - ulTtiReq->nGroup = 0; - if(ulTtiReq->nPdus > 0) - { - /* Fill Prach Pdu */ - if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PRACH) - { - pduIdx++; - fillPrachPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot); - ulTtiReq->rachPresent++; - } - - /* Fill PUSCH PDU */ - if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_PUSCH) - { - pduIdx++; - fillPuschPdu(&ulTtiReq->pdus[pduIdx], &vendorUlTti->ul_pdus[pduIdx], &macCellCfg, currUlSlot); - ulTtiReq->nUlsch++; - } - /* Fill PUCCH PDU */ - if(currUlSlot->ulInfo.dataType & SCH_DATATYPE_UCI) - { - pduIdx++; - fillPucchPdu(&ulTtiReq->pdus[pduIdx], &vendorUlTti->ul_pdus[pduIdx], &macCellCfg, currUlSlot); - ulTtiReq->nUlcch++; - } - } + FILL_FAPI_LIST_ELEM(ulTtiElem, NULLP, FAPI_UL_TTI_REQUEST, 1, \ + sizeof(fapi_ul_tti_req_t)); + ulTtiReq = (fapi_ul_tti_req_t *)(ulTtiElem +1); + memset(ulTtiReq, 0, sizeof(fapi_ul_tti_req_t)); + fillMsgHeader(&ulTtiReq->header, FAPI_UL_TTI_REQUEST, sizeof(fapi_ul_tti_req_t)); + ulTtiReq->sfn = ulTtiReqTimingInfo.sfn; + ulTtiReq->slot = ulTtiReqTimingInfo.slot; + ulTtiReq->nPdus = getnPdus(ulTtiReq, currUlSlot); + vendorUlTti->num_ul_pdu = ulTtiReq->nPdus; + vendorUlTti->sym = 0; + ulTtiReq->nGroup = 0; + if(ulTtiReq->nPdus > 0) + { +#ifdef ODU_SLOT_IND_DEBUG_LOG + DU_LOG("\nDEBUG --> LWR_MAC: UL_TTI_REQ, datatype:%d, sfn/slot:%d/%d", currUlSlot->ulSchInfo.dataType, ulTtiReq->sfn, ulTtiReq->slot); +#endif + /* Fill Prach Pdu */ + if(currUlSlot->ulSchInfo.dataType & SCH_DATATYPE_PRACH) + { + pduIdx++; + fillPrachPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot); + ulTtiReq->rachPresent++; + } + for(ueIdx = 0; ueIdx < MAX_NUM_UE; ueIdx++) + { + /* Fill PUSCH PDU */ + if(currUlSlot->ulSchInfo.dataType & SCH_DATATYPE_PUSCH) + { + if(currUlSlot->ulSchInfo.schPuschInfo[ueIdx].crnti != 0) + { +#ifdef ODU_SLOT_IND_DEBUG_LOG + DU_LOG("\nDEBUG --> LWR_MAC: UL_TTI_REQ, PUSCH PDU ueId:%d", ueIdx); +#endif + pduIdx++; + fillPuschPdu(&ulTtiReq->pdus[pduIdx], &vendorUlTti->ul_pdus[pduIdx], &macCellCfg, &currUlSlot->ulSchInfo.schPuschInfo[ueIdx]); + ulTtiReq->nUlsch++; + } + } + /* Fill PUCCH PDU */ + if(currUlSlot->ulSchInfo.dataType & SCH_DATATYPE_UCI) + { + if(currUlSlot->ulSchInfo.schPucchInfo[ueIdx].crnti != 0) + { + pduIdx++; + fillPucchPdu(&ulTtiReq->pdus[pduIdx], &vendorUlTti->ul_pdus[pduIdx], &macCellCfg, &currUlSlot->ulSchInfo.schPucchInfo[ueIdx]); + ulTtiReq->nUlcch++; + } + } + } + ulTtiReq->ueGrpInfo[ulTtiReq->nGroup].nUe = MAX_NUM_UE_PER_TTI; + ulTtiReq->nGroup++; + } #ifdef ODU_SLOT_IND_DEBUG_LOG - DU_LOG("\nDEBUG --> LWR_MAC: Sending UL TTI Request"); + DU_LOG("\nDEBUG --> LWR_MAC: Sending UL TTI Request"); #endif - prevElem->p_next = ulTtiElem; + prevElem->p_next = ulTtiElem; - memset(currUlSlot, 0, sizeof(MacUlSlot)); - return ROK; + memset(currUlSlot, 0, sizeof(MacUlSlot)); + return ROK; } else { - DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for UL TTI Request"); - memset(currUlSlot, 0, sizeof(MacUlSlot)); - return RFAILED; + DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for UL TTI Request"); + memset(currUlSlot, 0, sizeof(MacUlSlot)); + return RFAILED; } } else { - lwr_mac_procInvalidEvt(&currTimingInfo); + lwr_mac_procInvalidEvt(&currTimingInfo); } #endif return ROK;