#include "mac_sch_interface.h"
#include "lwr_mac_upr_inf.h"
#include "mac.h"
-#include "lwr_mac_phy.h"
#include "lwr_mac.h"
#ifdef INTEL_FAPI
#include "fapi.h"
#include "wls_lib.h"
#endif
#include "lwr_mac_fsm.h"
+#include "lwr_mac_phy.h"
#include "mac_utils.h"
#define MIB_SFN_BITMASK 0xFC
#define PDU_PRESENT 1
#define SET_MSG_LEN(x, size) x += size
-void fapiMacConfigRsp(uint16_t cellId);
-uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX];
-
/* Global variables */
-uint8_t slotIndIdx;
-uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo);
+LwrMacCb lwrMacCb;
-void lwrMacLayerInit()
+uint8_t UnrestrictedSetNcsTable[MAX_ZERO_CORR_CFG_IDX];
+void fapiMacConfigRsp(uint16_t cellId);
+uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo, p_fapi_api_queue_elem_t prevElem);
+uint16_t fillUlTtiReq(SlotIndInfo currTimingInfo, p_fapi_api_queue_elem_t prevElem);
+
+void lwrMacLayerInit(Region region, Pool pool)
{
#ifdef INTEL_WLS_MEM
- uint8_t idx;
+ uint8_t idx;
+#endif
+
+ memset(&lwrMacCb, 0, sizeof(LwrMacCb));
+ lwrMacCb.region = region;
+ lwrMacCb.pool = pool;
+ lwrMacCb.clCfgDone = TRUE;
+ lwrMacCb.numCell = 0;
+ lwrMacCb.phyState = PHY_STATE_IDLE;
+#ifdef INTEL_WLS_MEM
/* Initializing WLS free mem list */
- slotIndIdx = 1;
+ lwrMacCb.phySlotIndCntr = 1;
for(idx = 0; idx < WLS_MEM_FREE_PRD; idx++)
{
cmLListInit(&wlsBlockToFreeList[idx]);
* ****************************************************************/
uint8_t lwr_mac_procInvalidEvt(void *msg)
{
- printf("\nLWR_MAC: Error Indication Event[%d] received in state [%d]", lwrMacCb.event, lwrMacCb.phyState);
+ DU_LOG("\nERROR --> LWR_MAC: Error Indication Event[%d] received in state [%d]", lwrMacCb.event, lwrMacCb.phyState);
return ROK;
}
}
else
{
- DU_LOG("\nLWR_MAC: Value Extraction failed" );
+ DU_LOG("\nERROR --> LWR_MAC: Value Extraction failed" );
return RFAILED;
}
}
******************************************************************/
void setMibPdu(uint8_t *mibPdu, uint32_t *val, uint16_t sfn)
{
- *mibPdu |= (((uint8_t)(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("\nLWR_MAC: MIB PDU %x", *val);
+ DU_LOG("\nDEBUG --> LWR_MAC: MIB PDU %x", *val);
}
/*******************************************************************
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for param req header");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for param req header");
LWR_MAC_FREE(paramReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_param_req_t)));
return RFAILED;
}
msgHeader->num_msg = 1;
msgHeader->handle = 0;
- DU_LOG("\nLWR_MAC: Sending Param Request to Phy");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending Param Request to Phy");
LwrMacSendToL1(headerElem);
}
else
{
- DU_LOG("\nLWR_MAC: Failed to allocate memory for Param Request");
+ DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for Param Request");
return RFAILED;
}
#endif
ClCellParam *cellParam = NULLP;
paramRsp = (fapi_param_resp_t *)msg;
- DU_LOG("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, lwrMacCb.phyState);
+ DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, lwrMacCb.phyState);
if(paramRsp != NULLP)
{
MAC_ALLOC(cellParam, sizeof(ClCellParam));
if(cellParam != NULLP)
{
- DU_LOG("\n LWR_MAC: Filling TLVS into MAC API");
+ DU_LOG("\nDEBUG --> LWR_MAC: Filling TLVS into MAC API");
if(paramRsp->error_code == MSG_OK)
{
for(index = 0; index < paramRsp->number_of_tlvs; index++)
encodedVal = getParamValue(¶mRsp->tlvs[index], FAPI_UINT_8);
if(encodedVal != RFAILED && encodedVal != lwrMacCb.phyState)
{
- printf("\n PhyState mismatch [%d][%d]", lwrMacCb.phyState, lwrMacCb.event);
+ DU_LOG("\nERROR --> PhyState mismatch [%d][%d]", lwrMacCb.phyState, lwrMacCb.event);
return RFAILED;
}
break;
}
break;
default:
- //printf("\n Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index);
+ //DU_LOG("\nERROR --> Invalid value for TLV[%x] at index[%d]", paramRsp->tlvs[index].tl.tag, index);
break;
}
}
}
else
{
- DU_LOG("\n LWR_MAC: Invalid error code %d", paramRsp->error_code);
+ DU_LOG("\nERROR --> LWR_MAC: Invalid error code %d", paramRsp->error_code);
return RFAILED;
}
}
else
{
- DU_LOG("\nLWR_MAC: Failed to allocate memory for cell param");
+ DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for cell param");
return RFAILED;
}
}
else
{
- DU_LOG("\nLWR_MAC: Param Response received from PHY is NULL");
+ DU_LOG("\nERROR --> LWR_MAC: Param Response received from PHY is NULL");
return RFAILED;
}
#else
LWR_MAC_ALLOC(iqSampleElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_ext_iq_samples_req_t)));
if(!iqSampleElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for IQ sample req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for IQ sample req");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(iqSampleElem, NULLP, FAPI_VENDOR_EXT_UL_IQ_SAMPLES, 1, \
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for FAPI header in lwr_mac_procIqSamplesReqEvt");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for FAPI header in lwr_mac_procIqSamplesReqEvt");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(headerElem, iqSampleElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \
msgHeader->num_msg = 1;
msgHeader->handle = 0;
- DU_LOG("\nLWR_MAC: Sending IQ Sample request to Phy");
+ DU_LOG("\nINFO --> LWR_MAC: Sending IQ Sample request to Phy");
LwrMacSendToL1(headerElem);
return ROK;
}
uint8_t lwr_mac_procConfigReqEvt(void *msg)
{
#ifdef INTEL_FAPI
- //uint8_t idx = 0;
+#ifdef NR_TDD
+ uint8_t slotIdx = 0;
+ uint8_t symbolIdx =0;
+#endif
uint8_t index = 0;
- uint16_t *cellId;
- uint16_t cellIdx;
+ uint16_t *cellId =NULLP;
+ uint16_t cellIdx =0;
uint32_t msgLen = 0;
uint32_t mib = 0;
MacCellCfg macCfgParams;
p_fapi_api_queue_elem_t vendorMsgQElem;
p_fapi_api_queue_elem_t cfgReqQElem;
- DU_LOG("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \
+ DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \
lwrMacCb.phyState);
cellId = (uint16_t *)msg;
LWR_MAC_ALLOC(vendorMsgQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
if(!vendorMsgQElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for vendor msg in config req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(vendorMsgQElem, NULLP, FAPI_VENDOR_MESSAGE, 1, sizeof(fapi_vendor_msg_t));
vendorMsg->config_req_vendor.carrier_aggregation_level = 0;
vendorMsg->config_req_vendor.group_hop_flag = 0;
vendorMsg->config_req_vendor.sequence_hop_flag = 0;
-
+ vendorMsg->start_req_vendor.sfn = 0;
+ vendorMsg->start_req_vendor.slot = 0;
+ vendorMsg->start_req_vendor.mode = 4;
+#ifdef DEBUG_MODE
+ vendorMsg->start_req_vendor.count = 0;
+ vendorMsg->start_req_vendor.period = 1;
+#endif
/* Fill FAPI config req */
LWR_MAC_ALLOC(cfgReqQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_config_req_t)));
if(!cfgReqQElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for config req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for config req");
LWR_MAC_ALLOC(vendorMsgQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
}
//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, \
+ 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);
-
+ for(slotIdx =0 ;slotIdx< MAX_TDD_PERIODICITY_SLOTS; slotIdx++)
+ {
+ for(symbolIdx = 0; symbolIdx< MAX_SYMB_PER_SLOT; symbolIdx++)
+ {
+ fillTlvs(&configReq->tlvs[index++], FAPI_SLOT_CONFIG_TAG, \
+ sizeof(uint8_t), macCfgParams.tddCfg.slotCfg[slotIdx][symbolIdx], &msgLen);
+ }
+ }
+#endif
+
/* fill measurement config */
//fillTlvs(&configReq->tlvs[index++], FAPI_RSSI_MEASUREMENT_TAG, \
sizeof(uint8_t), macCfgParams.rssiUnit, &msgLen);
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for vendor msg in config req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req");
LWR_MAC_ALLOC(cfgReqQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_config_req_t)));
LWR_MAC_ALLOC(vendorMsgQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
msgHeader->num_msg = 2; /* Config req msg and vendor specific msg */
msgHeader->handle = 0;
- DU_LOG("\nLWR_MAC: Sending Config Request to Phy");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending Config Request to Phy");
LwrMacSendToL1(headerElem);
#endif
fapi_config_resp_t *configRsp;
configRsp = (fapi_config_resp_t *)msg;
- DU_LOG("\nLWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \
+ DU_LOG("\nINFO --> LWR_MAC: Received EVENT[%d] at STATE[%d]", lwrMacCb.event, \
lwrMacCb.phyState);
if(configRsp != NULL)
{
if(configRsp->error_code == MSG_OK)
{
- DU_LOG("\nLWR_MAC: PHY has moved to Configured state \n");
+ DU_LOG("\nDEBUG --> LWR_MAC: PHY has moved to Configured state \n");
lwrMacCb.phyState = PHY_STATE_CONFIGURED;
lwrMacCb.cellCb[0].state = PHY_STATE_CONFIGURED;
/* TODO :
}
else
{
- DU_LOG("\n LWR_MAC: Invalid error code %d", configRsp->error_code);
+ DU_LOG("\nERROR --> LWR_MAC: Invalid error code %d", configRsp->error_code);
return RFAILED;
}
}
else
{
- DU_LOG("\nLWR_MAC: Config Response received from PHY is NULL");
+ DU_LOG("\nERROR --> LWR_MAC: Config Response received from PHY is NULL");
return RFAILED;
}
#endif
LWR_MAC_ALLOC(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
if(!vendorMsgElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for vendor msg in start req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in start req");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(vendorMsgElem, NULLP, FAPI_VENDOR_MESSAGE, 1, sizeof(fapi_vendor_msg_t));
fillMsgHeader(&vendorMsg->header, FAPI_VENDOR_MESSAGE, sizeof(fapi_vendor_msg_t));
vendorMsg->start_req_vendor.sfn = 0;
vendorMsg->start_req_vendor.slot = 0;
- vendorMsg->start_req_vendor.mode = 1; /* for FDD */
+ vendorMsg->start_req_vendor.mode = 4; /* for Radio mode */
#ifdef DEBUG_MODE
vendorMsg->start_req_vendor.count = 0;
vendorMsg->start_req_vendor.period = 1;
LWR_MAC_ALLOC(startReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_start_req_t)));
if(!startReqElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for start req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for start req");
LWR_MAC_ALLOC(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
}
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for vendor msg in config req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in config req");
LWR_MAC_ALLOC(startReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_start_req_t)));
LWR_MAC_ALLOC(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
msgHeader->handle = 0;
/* Send to PHY */
- DU_LOG("\nLWR_MAC: Sending Start Request to Phy");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending Start Request to Phy");
LwrMacSendToL1(headerElem);
#endif
return ROK;
LWR_MAC_ALLOC(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
if(!vendorMsgElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for vendor msg in stop req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for vendor msg in stop req");
return RFAILED;
}
FILL_FAPI_LIST_ELEM(vendorMsgElem, NULLP, FAPI_VENDOR_MESSAGE, 1, sizeof(fapi_vendor_msg_t));
LWR_MAC_ALLOC(stopReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_stop_req_t)));
if(!stopReqElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for stop req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for stop req");
LWR_MAC_FREE(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
}
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for header in stop req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for header in stop req");
LWR_MAC_FREE(stopReqElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_stop_req_t)));
LWR_MAC_FREE(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
return RFAILED;
msgHeader->handle = 0;
/* Send to PHY */
- DU_LOG("\nLWR_MAC: Sending Stop Request to Phy");
+ DU_LOG("\nINFO --> LWR_MAC: Sending Stop Request to Phy");
LwrMacSendToL1(headerElem);
#endif
if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN)
{
- DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
+ DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected");
return;
}
if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN)
{
- DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
+ DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected");
return;
}
if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN)
{
- DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
+ DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected");
return;
}
}
else
{
- DU_LOG("\nLWR_MAC: Failed filling PDCCH Pdu");
+ DU_LOG("\nERROR --> LWR_MAC: Failed filling PDCCH Pdu");
return RFAILED;
}
dlTtiReqPdu->pduType = PDCCH_PDU_TYPE;
dlTtiReqPdu->pdu.pdcch_pdu.precoderGranularity = pdcchInfo->coresetCfg.precoderGranularity;
dlTtiReqPdu->pdu.pdcch_pdu.numDlDci = pdcchInfo->numDlDci;
dlTtiReqPdu->pdu.pdcch_pdu.coreSetType = coreSetType;
-
+
/* Calculating PDU length. Considering only one dl dci pdu for now */
dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t);
}
* @return ROK
*
* ********************************************************************/
-uint8_t fillSib1TxDataReq(fapi_tx_pdu_desc_t *pduDesc,MacCellCfg *macCellCfg,
- uint16_t pduIndex)
+uint8_t fillSib1TxDataReq(fapi_tx_pdu_desc_t *pduDesc, uint16_t pduIndex, MacCellCfg *macCellCfg,
+ PdschCfg pdschCfg)
{
- uint32_t pduLen = 0;
- uint8_t *sib1TxdataValue = NULLP;
+ uint16_t payloadSize = 0;
+ uint8_t *sib1Payload = NULLP;
+ fapi_api_queue_elem_t *payloadElem = NULLP;
+#ifdef INTEL_WLS_MEM
+ void * wlsHdlr = NULLP;
+#endif
pduDesc[pduIndex].pdu_index = pduIndex;
pduDesc[pduIndex].num_tlvs = 1;
/* fill the TLV */
- /* 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)
+ payloadSize = pdschCfg.codeword[0].tbSize;
+ pduDesc[pduIndex].tlvs[0].tl.tag = FAPI_TX_DATA_PTR_TO_PAYLOAD_64;
+ pduDesc[pduIndex].tlvs[0].tl.length = payloadSize;
+ LWR_MAC_ALLOC(sib1Payload, payloadSize);
+ if(sib1Payload == NULLP)
{
return RFAILED;
}
- memcpy(sib1TxdataValue,macCellCfg->sib1Cfg.sib1Pdu,
- macCellCfg->sib1Cfg.sib1PduLen);
- pduDesc[pduIndex].tlvs[0].value = sib1TxdataValue;
+ payloadElem = (fapi_api_queue_elem_t *)sib1Payload;
+ FILL_FAPI_LIST_ELEM(payloadElem, NULLP, FAPI_VENDOR_MSG_PHY_ZBC_BLOCK_REQ, 1, \
+ macCellCfg->sib1Cfg.sib1PduLen);
+ memcpy(sib1Payload + TX_PAYLOAD_HDR_LEN, macCellCfg->sib1Cfg.sib1Pdu, macCellCfg->sib1Cfg.sib1PduLen);
- /* 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_uint8_ptr_tlv_t); /* only 1 TLV is present */
- pduDesc[pduIndex].pdu_length = pduLen;
+#ifdef INTEL_WLS_MEM
+ mtGetWlsHdl(&wlsHdlr);
+ pduDesc[pduIndex].tlvs[0].value = WLS_VA2PA(wlsHdlr, sib1Payload);
+#else
+ pduDesc[pduIndex].tlvs[0].value = sib1Payload;
+#endif
+ pduDesc[pduIndex].pdu_length = payloadSize;
#ifdef INTEL_WLS_MEM
- addWlsBlockToFree(sib1TxdataValue, macCellCfg->sib1Cfg.sib1PduLen, (slotIndIdx-1));
+ addWlsBlockToFree(sib1Payload, payloadSize, (lwrMacCb.phySlotIndCntr-1));
#else
- LWR_MAC_FREE(sib1TxdataValue, macCellCfg->sib1Cfg.sib1PduLen);
+ LWR_MAC_FREE(sib1Payload, payloadSize);
#endif
return ROK;
* @return ROK
*
* ********************************************************************/
-uint8_t fillRarTxDataReq(fapi_tx_pdu_desc_t *pduDesc, RarInfo *rarInfo,
- uint16_t pduIndex)
+uint8_t fillRarTxDataReq(fapi_tx_pdu_desc_t *pduDesc, uint16_t pduIndex, RarInfo *rarInfo, PdschCfg pdschCfg)
{
- uint32_t pduLen = 0;
- uint8_t *rarTxdataValue = NULLP;
+ uint16_t payloadSize;
+ uint8_t *rarPayload = NULLP;
+ fapi_api_queue_elem_t *payloadElem = NULLP;
+#ifdef INTEL_WLS_MEM
+ void * wlsHdlr = NULLP;
+#endif
pduDesc[pduIndex].pdu_index = pduIndex;
pduDesc[pduIndex].num_tlvs = 1;
/* fill the TLV */
- /* 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)
+ payloadSize = pdschCfg.codeword[0].tbSize;
+ pduDesc[pduIndex].tlvs[0].tl.tag = FAPI_TX_DATA_PTR_TO_PAYLOAD_64;
+ pduDesc[pduIndex].tlvs[0].tl.length = payloadSize;
+ LWR_MAC_ALLOC(rarPayload, payloadSize);
+ if(rarPayload == NULLP)
{
return RFAILED;
}
- memcpy(rarTxdataValue,rarInfo->rarPdu,rarInfo->rarPduLen);
- pduDesc[pduIndex].tlvs[0].value = rarTxdataValue;
+ payloadElem = (fapi_api_queue_elem_t *)rarPayload;
+ FILL_FAPI_LIST_ELEM(payloadElem, NULLP, FAPI_VENDOR_MSG_PHY_ZBC_BLOCK_REQ, 1, rarInfo->rarPduLen);
+ memcpy(rarPayload + TX_PAYLOAD_HDR_LEN, rarInfo->rarPdu, rarInfo->rarPduLen);
- /* 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_uint8_ptr_tlv_t); /* only 1 TLV is present */
- pduDesc[pduIndex].pdu_length = 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
- */
-#ifdef INTEL_WLS_MEM
- addWlsBlockToFree(rarTxdataValue, rarInfo->rarPduLen, (slotIndIdx-1));
+#ifdef INTEL_WLS_MEM
+ mtGetWlsHdl(&wlsHdlr);
+ pduDesc[pduIndex].tlvs[0].value = WLS_VA2PA(wlsHdlr, rarPayload);
#else
- LWR_MAC_FREE(rarTxdataValue, rarInfo->rarPduLen);
+ pduDesc[pduIndex].tlvs[0].value = rarPayload;
#endif
+ pduDesc[pduIndex].pdu_length = payloadSize;
+#ifdef INTEL_WLS_MEM
+ addWlsBlockToFree(rarPayload, payloadSize, (lwrMacCb.phySlotIndCntr-1));
+#else
+ LWR_MAC_FREE(rarPayload, payloadSize);
+#endif
return ROK;
}
* @return ROK
*
* ********************************************************************/
-uint8_t fillDlMsgTxDataReq(fapi_tx_pdu_desc_t *pduDesc, DlMsgInfo *dlMsgInfo,
- uint16_t pduIndex)
+uint8_t fillDlMsgTxDataReq(fapi_tx_pdu_desc_t *pduDesc, uint16_t pduIndex, DlMsgInfo *dlMsgInfo, PdschCfg pdschCfg)
{
- uint32_t pduLen = 0;
- uint8_t *dedMsgTxDataValue = NULLP;
+ uint16_t payloadSize;
+ uint8_t *dlMsgPayload = NULLP;
+ fapi_api_queue_elem_t *payloadElem = NULLP;
+#ifdef INTEL_WLS_MEM
+ void * wlsHdlr = NULLP;
+#endif
pduDesc[pduIndex].pdu_index = pduIndex;
pduDesc[pduIndex].num_tlvs = 1;
/* 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 = dlMsgInfo->dlMsgPduLen;
- LWR_MAC_ALLOC(dedMsgTxDataValue, dlMsgInfo->dlMsgPduLen);
- if(dedMsgTxDataValue == NULLP)
+ payloadSize = pdschCfg.codeword[0].tbSize;
+ pduDesc[pduIndex].tlvs[0].tl.tag = FAPI_TX_DATA_PTR_TO_PAYLOAD_64;
+ pduDesc[pduIndex].tlvs[0].tl.length = payloadSize;
+ LWR_MAC_ALLOC(dlMsgPayload, payloadSize);
+ if(dlMsgPayload == NULLP)
{
return RFAILED;
}
- memcpy(dedMsgTxDataValue, dlMsgInfo->dlMsgPdu, dlMsgInfo->dlMsgPduLen);
- pduDesc[pduIndex].tlvs[0].value = dedMsgTxDataValue;
-
- /* 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_uint8_ptr_tlv_t); /* only 1 TLV is present */
- pduDesc[pduIndex].pdu_length = pduLen;
+ payloadElem = (fapi_api_queue_elem_t *)dlMsgPayload;
+ FILL_FAPI_LIST_ELEM(payloadElem, NULLP, FAPI_VENDOR_MSG_PHY_ZBC_BLOCK_REQ, 1, dlMsgInfo->dlMsgPduLen);
+ memcpy(dlMsgPayload + TX_PAYLOAD_HDR_LEN, dlMsgInfo->dlMsgPdu, dlMsgInfo->dlMsgPduLen);
- /* 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
- */
-#ifdef INTEL_WLS_MEM
- addWlsBlockToFree(dedMsgTxDataValue, dlMsgInfo->dlMsgPduLen, (slotIndIdx-1));
+#ifdef INTEL_WLS_MEM
+ mtGetWlsHdl(&wlsHdlr);
+ pduDesc[pduIndex].tlvs[0].value = WLS_VA2PA(wlsHdlr, dlMsgPayload);
#else
- LWR_MAC_FREE(dedMsgTxDataValue, dlMsgInfo->dlMsgPduLen);
+ pduDesc[pduIndex].tlvs[0].value = dlMsgPayload;
#endif
+ pduDesc[pduIndex].pdu_length = payloadSize;
+#ifdef INTEL_WLS_MEM
+ addWlsBlockToFree(dlMsgPayload, payloadSize, (lwrMacCb.phySlotIndCntr-1));
+#else
+ LWR_MAC_FREE(dlMsgPayload, payloadSize);
+#endif
return ROK;
}
-
#endif /* FAPI */
+
/*******************************************************************
*
* @brief Sends DL TTI Request to PHY
{
GET_CELL_IDX(currTimingInfo.cellId, cellIdx);
/* consider phy delay */
- ADD_DELTA_TO_TIME(currTimingInfo,dlTtiReqTimingInfo,PHY_DELTA);
+ ADD_DELTA_TO_TIME(currTimingInfo,dlTtiReqTimingInfo,PHY_DELTA_DL);
+ dlTtiReqTimingInfo.cellId = currTimingInfo.cellId;
macCellCfg = macCb.macCell[cellIdx]->macCellCfg;
currDlSlot = &macCb.macCell[cellIdx]->dlSlot[dlTtiReqTimingInfo.slot];
- nPdu = calcDlTtiReqPduCount(&currDlSlot->dlInfo);
LWR_MAC_ALLOC(dlTtiElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_dl_tti_req_t)));
if(dlTtiElem)
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for header in DL TTI req");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for header in DL TTI req");
LWR_MAC_FREE(dlTtiElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_dl_tti_req_t)));
return RFAILED;
}
dlTtiReq->nPdus = calcDlTtiReqPduCount(&currDlSlot->dlInfo); /* get total Pdus */
nPdu = dlTtiReq->nPdus;
dlTtiReq->nGroup = 0;
-
if(dlTtiReq->nPdus > 0)
{
if(currDlSlot->dlInfo.isBroadcastPres)
numPduEncoded++;
}
}
- printf("\033[1;31m");
- DU_LOG("\nLWR_MAC: MIB sent..");
- printf("\033[0m");
+ DU_LOG("\033[1;31m");
+ DU_LOG("\nDEBUG --> LWR_MAC: MIB sent..");
+ DU_LOG("\033[0m");
}
if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
{
pduIndex++;
numPduEncoded++;
}
- printf("\033[1;34m");
- DU_LOG("\nLWR_MAC: SIB1 sent...");
- printf("\033[0m");
+ DU_LOG("\033[1;34m");
+ DU_LOG("\nDEBUG --> LWR_MAC: SIB1 sent...");
+ DU_LOG("\033[0m");
}
}
if(currDlSlot->dlInfo.rarAlloc != NULLP)
numPduEncoded++;
pduIndex++;
- printf("\033[1;32m");
- DU_LOG("\nLWR_MAC: RAR sent...");
- printf("\033[0m");
+ DU_LOG("\033[1;32m");
+ DU_LOG("\nDEBUG --> LWR_MAC: RAR sent...");
+ DU_LOG("\033[0m");
}
if(currDlSlot->dlInfo.dlMsgAlloc != NULLP)
{
if(currDlSlot->dlInfo.dlMsgAlloc->dlMsgInfo.dlMsgPdu != NULLP)
{
/* Filling Msg4 param */
- printf("\033[1;32m");
+ DU_LOG("\033[1;32m");
if(currDlSlot->dlInfo.dlMsgAlloc->dlMsgInfo.isMsg4Pdu)
{
rntiType = TC_RNTI_TYPE;
fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
&currDlSlot->dlInfo, rntiType, CORESET_TYPE0);
- DU_LOG("\nLWR_MAC: MSG4 sent...");
+ DU_LOG("\nDEBUG --> LWR_MAC: MSG4 sent...");
}
else
{
rntiType = C_RNTI_TYPE;
fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], \
&currDlSlot->dlInfo, rntiType, CORESET_TYPE1);
- DU_LOG("\nLWR_MAC: DL MSG sent...");
+ DU_LOG("\nDEBUG --> LWR_MAC: DL MSG sent...");
}
- printf("\033[0m");
+ DU_LOG("\033[0m");
numPduEncoded++;
fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],
}
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nLWR_MAC: Sending DL TTI Request");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending DL TTI Request");
#endif
- LwrMacSendToL1(headerElem);
-
+ /* Intel L1 expects UL_TTI.request following DL_TTI.request */
+ msgHeader->num_msg++;
+ fillUlTtiReq(currTimingInfo, dlTtiElem);
/* send Tx-DATA req message */
- sendTxDataReq(currTimingInfo, &currDlSlot->dlInfo);
+ msgHeader->num_msg++;
+ sendTxDataReq(dlTtiReqTimingInfo, &currDlSlot->dlInfo, dlTtiElem->p_next);
+ LwrMacSendToL1(headerElem);
}
else
{
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nLWR_MAC: Sending DL TTI Request");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending DL TTI Request");
#endif
+
+ /* Intel L1 expects UL_TTI.request following DL_TTI.request */
+ msgHeader->num_msg++;
+ fillUlTtiReq(currTimingInfo, dlTtiElem);
LwrMacSendToL1(headerElem);
}
memset(currDlSlot, 0, sizeof(MacDlSlot));
}
else
{
- DU_LOG("\nLWR_MAC: Failed to allocate memory for DL TTI Request");
+ DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for DL TTI Request");
memset(currDlSlot, 0, sizeof(MacDlSlot));
return RFAILED;
}
* RFAILED - failure
*
* ****************************************************************/
-uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo)
+uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo, p_fapi_api_queue_elem_t prevElem)
{
#ifdef INTEL_FAPI
uint8_t nPdu = 0;
uint16_t cellIdx;
uint16_t pduIndex = 0;
fapi_tx_data_req_t *txDataReq =NULLP;
- fapi_msg_header_t *msgHeader =NULLP;
p_fapi_api_queue_elem_t txDataElem = 0;
- p_fapi_api_queue_elem_t headerElem =0;
GET_CELL_IDX(currTimingInfo.cellId, cellIdx);
LWR_MAC_ALLOC(txDataElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_tx_data_req_t)));
if(txDataElem == NULLP)
{
- DU_LOG("\nLWR_MAC: Failed to allocate memory for TX data Request");
+ DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for TX data Request");
return RFAILED;
}
txDataReq->slot = currTimingInfo.slot;
if(dlInfo->brdcstAlloc.sib1Trans)
{
- fillSib1TxDataReq(txDataReq->pdu_desc,
- &macCb.macCell[cellIdx]->macCellCfg, pduIndex);
+ fillSib1TxDataReq(txDataReq->pdu_desc, pduIndex, &macCb.macCell[cellIdx]->macCellCfg, \
+ dlInfo->brdcstAlloc.sib1Alloc.sib1PdschCfg);
pduIndex++;
txDataReq->num_pdus++;
}
if(dlInfo->rarAlloc != NULLP)
{
- fillRarTxDataReq(txDataReq->pdu_desc, &dlInfo->rarAlloc->rarInfo, pduIndex);
+ fillRarTxDataReq(txDataReq->pdu_desc, pduIndex, &dlInfo->rarAlloc->rarInfo,\
+ dlInfo->rarAlloc->rarPdschCfg);
pduIndex++;
txDataReq->num_pdus++;
}
if(dlInfo->dlMsgAlloc != NULLP)
{
- fillDlMsgTxDataReq(txDataReq->pdu_desc, \
- &dlInfo->dlMsgAlloc->dlMsgInfo, pduIndex);
+ fillDlMsgTxDataReq(txDataReq->pdu_desc, pduIndex, &dlInfo->dlMsgAlloc->dlMsgInfo,\
+ dlInfo->dlMsgAlloc->dlMsgPdschCfg);
pduIndex++;
txDataReq->num_pdus++;
}
/* Fill message header */
- LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
- if(!headerElem)
- {
- DU_LOG("\nLWR_MAC: Memory allocation failed for TxDataReq header");
- LWR_MAC_FREE(txDataElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_tx_data_req_t)));
- return RFAILED;
- }
- FILL_FAPI_LIST_ELEM(headerElem, txDataElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \
- sizeof(fapi_msg_header_t));
- msgHeader = (fapi_msg_header_t *)(headerElem + 1);
- msgHeader->num_msg = 1;
- msgHeader->handle = 0;
-
- DU_LOG("\nLWR_MAC: Sending TX DATA Request");
- LwrMacSendToL1(headerElem);
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending TX DATA Request");
+ prevElem->p_next = txDataElem;
}
#endif
return ROK;
* RFAILED - failure
*
******************************************************************/
-uint16_t fillUlTtiReq(SlotIndInfo currTimingInfo)
+uint16_t fillUlTtiReq(SlotIndInfo currTimingInfo, p_fapi_api_queue_elem_t prevElem)
{
#ifdef INTEL_FAPI
uint16_t cellIdx =0;
MacUlSlot *currUlSlot = NULLP;
MacCellCfg macCellCfg;
fapi_ul_tti_req_t *ulTtiReq = NULLP;
- fapi_msg_header_t *msgHeader = NULLP;
p_fapi_api_queue_elem_t ulTtiElem;
- p_fapi_api_queue_elem_t headerElem;
if(lwrMacCb.phyState == PHY_STATE_RUNNING)
{
macCellCfg = macCb.macCell[cellIdx]->macCellCfg;
/* add PHY delta */
- ADD_DELTA_TO_TIME(currTimingInfo,ulTtiReqTimingInfo,PHY_DELTA);
- currUlSlot = &macCb.macCell[cellIdx]->ulSlot[ulTtiReqTimingInfo.slot % MAX_SLOT_SUPPORTED];
+ ADD_DELTA_TO_TIME(currTimingInfo,ulTtiReqTimingInfo,PHY_DELTA_UL);
+ currUlSlot = &macCb.macCell[cellIdx]->ulSlot[ulTtiReqTimingInfo.slot % MAX_SLOTS];
LWR_MAC_ALLOC(ulTtiElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_ul_tti_req_t)));
if(ulTtiElem)
}
}
- /* Fill message header */
- LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
- if(!headerElem)
- {
- DU_LOG("\nLWR_MAC: Memory allocation failed for UL TTI req header");
- LWR_MAC_FREE(ulTtiElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_ul_tti_req_t)));
- return RFAILED;
- }
- FILL_FAPI_LIST_ELEM(headerElem, ulTtiElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \
- sizeof(fapi_msg_header_t));
- msgHeader = (fapi_msg_header_t *)(headerElem + 1);
- msgHeader->num_msg = 1;
- msgHeader->handle = 0;
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nLWR_MAC: Sending UL TTI Request");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending UL TTI Request");
#endif
- LwrMacSendToL1(headerElem);
+ prevElem->p_next = ulTtiElem;
memset(currUlSlot, 0, sizeof(MacUlSlot));
return ROK;
}
else
{
- DU_LOG("\nLWR_MAC: Failed to allocate memory for UL TTI Request");
+ DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for UL TTI Request");
memset(currUlSlot, 0, sizeof(MacUlSlot));
return RFAILED;
}
if(numBytes > FAPI_DCI_PAYLOAD_BYTE_LEN)
{
- DU_LOG("\nLWR_MAC : Total bytes for DCI is more than expected");
+ DU_LOG("\nERROR --> LWR_MAC : Total bytes for DCI is more than expected");
return;
}
{
GET_CELL_IDX(currTimingInfo.cellId, cellIdx);
memcpy(&ulDciReqTimingInfo, &currTimingInfo, sizeof(SlotIndInfo));
- currDlSlot = &macCb.macCell[cellIdx]->dlSlot[ulDciReqTimingInfo.slot % MAX_SLOT_SUPPORTED];
+ currDlSlot = &macCb.macCell[cellIdx]->dlSlot[ulDciReqTimingInfo.slot % MAX_SLOTS];
if(currDlSlot->dlInfo.ulGrant != NULLP)
{
LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Memory allocation failed for UL DCI req header");
+ DU_LOG("\nERROR --> LWR_MAC: Memory allocation failed for UL DCI req header");
LWR_MAC_FREE(ulDciElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_ul_dci_req_t)));
return RFAILED;
}
msgHeader->num_msg = 1;
msgHeader->handle = 0;
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\nLWR_MAC: Sending UL DCI Request");
+ DU_LOG("\nDEBUG --> LWR_MAC: Sending UL DCI Request");
#endif
LwrMacSendToL1(headerElem);
}
}
else
{
- DU_LOG("\nLWR_MAC: Failed to allocate memory for UL DCI Request");
+ DU_LOG("\nERROR --> LWR_MAC: Failed to allocate memory for UL DCI Request");
memset(currDlSlot, 0, sizeof(MacDlSlot));
return RFAILED;
}
Code Review / o-du / l2.git / blobdiff