#include "du_app_mac_inf.h"
#include "mac_sch_interface.h"
#include "lwr_mac.h"
+#include "lwr_mac_fsm.h"
#include "lwr_mac_phy.h"
#ifdef INTEL_FAPI
#include "fapi.h"
#include "fapi_vendor_extension.h"
#endif
-#include "lphy_stub.h"
#include "lwr_mac_upr_inf.h"
#include "mac_utils.h"
#include "phy_stub.h"
+#include "phy_stub_utils.h"
+#include "lwr_mac_phy_stub_inf.h"
/*******************************************************************
*
MAC_ALLOC(fapiParamRsp, sizeof(fapi_param_resp_t));
if(!fapiParamRsp)
{
- DU_LOG("PHY STUB: Memory allocation failed");
+ DU_LOG("\nERROR --> PHY STUB: Memory allocation failed");
return RFAILED;
}
fillMsgHeader(&fapiParamRsp->header, FAPI_PARAM_RESPONSE, msgLen);
fapiParamRsp->error_code = MSG_OK;
- DU_LOG("\nPHY_STUB: Sending Param Request to Lower Mac");
+ DU_LOG("\nINFO --> PHY_STUB: Sending Param Request to Lower Mac");
procPhyMessages(fapiParamRsp->header.msg_id, sizeof(fapi_param_resp_t), (void *)fapiParamRsp);
MAC_FREE(fapiParamRsp, sizeof(fapi_param_resp_t));
#endif
MAC_ALLOC(fapiConfigRsp, sizeof(fapi_config_resp_t));
if(!fapiConfigRsp)
{
- DU_LOG("PHY STUB: Memory allocation failed");
+ DU_LOG("\nERROR --> PHY STUB: Memory allocation failed");
return RFAILED;
}
memset(fapiConfigRsp, 0, sizeof(fapi_config_resp_t));
msgLen = sizeof(fapi_config_resp_t) - sizeof(fapi_msg_t);
fillMsgHeader(&fapiConfigRsp->header, FAPI_CONFIG_RESPONSE, msgLen);
- DU_LOG("\nPHY_STUB: Sending Config Response to Lower Mac");
+ DU_LOG("\nINFO --> PHY_STUB: Sending Config Response to Lower Mac");
procPhyMessages(fapiConfigRsp->header.msg_id, \
sizeof(fapi_config_resp_t), (void *)fapiConfigRsp);
void l1HdlParamReq(uint32_t msgLen, void *msg)
{
#ifdef INTEL_FAPI
- DU_LOG("\nPHY_STUB: Received Param Request in PHY");
+ DU_LOG("\nINFO --> PHY_STUB: Received Param Request in PHY");
/* Build and send PARAM RESPONSE */
if(l1BldAndSndParamRsp(msg)!= ROK)
{
- DU_LOG("\nPHY_STUB: Failed Sending Param Response");
+ DU_LOG("\nERROR --> PHY_STUB: Failed Sending Param Response");
}
MAC_FREE(msg, sizeof(fapi_param_req_t));
#endif
void l1HdlConfigReq(uint32_t msgLen, void *msg)
{
+ memset(&ueDb, 0, sizeof(UeDb));
+
#ifdef INTEL_FAPI
p_fapi_api_queue_elem_t configReqElem = (p_fapi_api_queue_elem_t)msg;
fapi_config_req_t *configReq = (fapi_config_req_t *)(configReqElem +1);
- DU_LOG("\nPHY_STUB: Received Config Request in PHY");
+ DU_LOG("\nINFO --> PHY_STUB: Received Config Request in PHY");
/* Handling CONFIG RESPONSE */
if(l1BldAndSndConfigRsp(configReq)!= ROK)
{
- printf("\nPHY_STUB: Failed Sending config Response");
+ DU_LOG("\nERROR --> PHY_STUB: Failed Sending config Response");
}
MAC_FREE(msg, msgLen);
MAC_ALLOC(crcInd, sizeof(fapi_crc_ind_t));
if(!crcInd)
{
- printf("\nPHY_STUB: Memory allocation failed for CRC Indication Message");
+ DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for CRC Indication Message");
return RFAILED;
}
memset(crcInd, 0, sizeof(fapi_crc_ind_t));
sizeof(fapi_crc_ind_t) - sizeof(fapi_msg_t));
/* Sending RACH indication to MAC */
- DU_LOG("\nPHY STUB: Sending CRC Indication to MAC");
+ DU_LOG("\nINFO --> PHY STUB: Sending CRC Indication to MAC");
procPhyMessages(crcInd->header.msg_id, sizeof(fapi_crc_ind_t), (void *)crcInd);
MAC_FREE(crcInd, sizeof(fapi_crc_ind_t));
#endif
* ****************************************************************/
uint16_t l1BuildAndSendRxDataInd(uint16_t slot, uint16_t sfn, fapi_ul_pusch_pdu_t puschPdu)
{
- uint8_t idx = 0;
+ uint8_t idx = 0, ueId = 0;
fapi_rx_data_indication_t *rxDataInd =NULLP;
fapi_pdu_ind_info_t *pduInfo =NULLP;
uint8_t *pdu = NULLP;
uint32_t msgLen = 0;
MsgType type = 0;
- if(!msg3Sent)
+ GET_UE_ID(puschPdu.rnti, ueId);
+ if(!ueDb.ueCb[ueId-1].msg3Sent)
{
- msg3Sent = true;
+ ueDb.ueCb[ueId-1].ueId = ueId;
+ ueDb.ueCb[ueId-1].crnti = puschPdu.rnti;
+ ueDb.ueCb[ueId-1].msg3Sent = true;
type = MSG_TYPE_MSG3;
sleep(2);
}
- else if(!msg5ShortBsrSent)
+ else if(!ueDb.ueCb[ueId-1].msg5ShortBsrSent)
{
- msg5ShortBsrSent = true;
+ ueDb.ueCb[ueId-1].msg5ShortBsrSent = true;
type = MSG_TYPE_SHORT_BSR;
}
- else if(!msg5Sent)
+ else if(!ueDb.ueCb[ueId-1].msg5Sent)
{
- msg5Sent = true;
+ ueDb.ueCb[ueId-1].msg5Sent = true;
type = MSG_TYPE_MSG5;
}
- else if(!msgRegistrationComp)
+ else if(!ueDb.ueCb[ueId-1].msgRegistrationComp)
{
- msgRegistrationComp = true;
+ ueDb.ueCb[ueId-1].msgRegistrationComp = true;
type = MSG_TYPE_REGISTRATION_COMPLETE;
}
- else if(!msgSecurityModeComp)
+ else if(!ueDb.ueCb[ueId-1].msgSecurityModeComp)
{
- msgSecurityModeComp = true;
+ ueDb.ueCb[ueId-1].msgSecurityModeComp = true;
type = MSG_TYPE_SECURITY_MODE_COMPLETE;
}
- else if(!msgRrcReconfiguration)
+ else if(!ueDb.ueCb[ueId-1].msgRrcReconfiguration)
{
- msgRrcReconfiguration = true;
+ ueDb.ueCb[ueId-1].msgRrcReconfiguration = true;
type = MSG_TYPE_RRC_RECONFIG_COMPLETE;
}
else
MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t));
if(!rxDataInd)
{
- printf("\nPHY_STUB: Memory allocation failed for Rx Data Indication");
+ DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
return RFAILED;
}
memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t));
MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length);
if(!pduInfo->pduData)
{
- printf("\nPHY_STUB: Memory allocation failed for Rx Data Pdu");
+ DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
return RFAILED;
}
memset(pduInfo->pduData, 0, pduInfo->pdu_length);
{
case MSG_TYPE_MSG3:
{
- DU_LOG("\nPHY_STUB: Forming MSG3 PDU ");
+ DU_LOG("\nDEBUG --> PHY_STUB: Forming MSG3 PDU ");
/* For Initial RRC setup Request,
MAC subheader format is R/R/LCId (1byte)
LCId is CCCH(0)
}
case MSG_TYPE_SHORT_BSR:
{
- DU_LOG("\nPHY_STUB: Forming SHORT BSR PDU ");
+ DU_LOG("\nDEBUG --> PHY_STUB: Forming SHORT BSR PDU ");
uint8_t lcgId = 0;
uint8_t bufferSizeIdx = 6;
case MSG_TYPE_MSG5:
{
- DU_LOG("\nPHY_STUB: Forming MSG5 PDU");
+ DU_LOG("\nDEBUG --> PHY_STUB: Forming MSG5 PDU");
uint8_t msg5PduLen = 33;
/* For RRC setup complete
MAC subheader format is R/F/LCId/L (2/3 bytes)
case MSG_TYPE_SECURITY_MODE_COMPLETE:
{
- DU_LOG("\nPHY_STUB: Forming SECURITY MODE COMPLETE PDU");
+ DU_LOG("\nDEBUG --> PHY_STUB: Forming SECURITY MODE COMPLETE PDU");
uint8_t pduLen = 12;
/* For security mode complete where RRC Container is dummy
MAC subheader format is R/F/LCId/L (2/3 bytes)
case MSG_TYPE_REGISTRATION_COMPLETE:
{
- DU_LOG("\nPHY_STUB: Forming RRC REGISTRATION COMPLETE PDU");
+ DU_LOG("\nDEBUG --> PHY_STUB: Forming RRC REGISTRATION COMPLETE PDU");
uint8_t pduLen = 12;
/* For rrc reconfig complete where RRC Container is dummy
MAC subheader format is R/F/LCId/L (2/3 bytes)
}
case MSG_TYPE_RRC_RECONFIG_COMPLETE:
{
- DU_LOG("\nPHY_STUB: Forming RRC RECONFIGURATION COMPLETE PDU");
+ DU_LOG("\nDEBUG --> PHY_STUB: Forming RRC RECONFIGURATION COMPLETE PDU");
uint8_t pduLen = 14;
/* For rrc reconfig complete where RRC Container is dummy
MAC subheader format is R/F/LCId/L (2/3 bytes)
fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen);
/* Sending Rx data indication to MAC */
- DU_LOG("\nPHY STUB: Sending Rx data Indication to MAC");
+ DU_LOG("\nINFO --> PHY STUB: Sending Rx data Indication to MAC");
procPhyMessages(rxDataInd->header.msg_id, sizeof(fapi_rx_data_indication_t), (void *)rxDataInd);
if(pduInfo->pdu_length)
MAC_ALLOC(rachInd, sizeof(fapi_rach_indication_t));
if(!rachInd)
{
- printf("\nPHY_STUB: Memory allocation failed for Rach Indication Message");
+ DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rach Indication Message");
return RFAILED;
}
memset(rachInd, 0, sizeof(fapi_rach_indication_t));
sizeof(fapi_rach_indication_t) - sizeof(fapi_msg_t));
/* Sending RACH indication to MAC */
- DU_LOG("\nPHY STUB: Sending RACH Indication to MAC");
+ DU_LOG("\nINFO --> PHY STUB: Sending RACH Indication to MAC");
procPhyMessages(rachInd->header.msg_id, sizeof(fapi_rach_indication_t), (void *)rachInd);
MAC_FREE(rachInd, sizeof(fapi_rach_indication_t));
#endif
* ****************************************************************/
uint16_t l1BuildAndSendSlotIndication()
{
+ Pst pst;
+ Buffer *mBuf;
+
#ifdef INTEL_FAPI
fapi_slot_ind_t *slotIndMsg;
- MAC_ALLOC(slotIndMsg, sizeof(fapi_slot_ind_t));
+ MAC_ALLOC_SHRABL_BUF(slotIndMsg, sizeof(fapi_slot_ind_t));
if(!slotIndMsg)
{
- DU_LOG("\nPHY_STUB: Memory allocation failed for slot Indication Message");
+ DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for slot Indication Message");
return RFAILED;
}
else
slotIndMsg->slot = slotValue;
#ifdef ODU_SLOT_IND_DEBUG_LOG
- DU_LOG("\n\nPHY_STUB: SLOT indication [%d:%d]",sfnValue,slotValue);
+ DU_LOG("\n\nDEBUG --> PHY_STUB: Sending Slot Indication [%d : %d] to MAC", sfnValue, slotValue);
#endif
+
/* increment for the next TTI */
slotValue++;
if(sfnValue >= MAX_SFN_VALUE && slotValue > MAX_SLOT_VALUE)
{
- sfnValue = 0;
- slotValue = 0;
+ sfnValue = 0;
+ slotValue = 0;
}
else if(slotValue > MAX_SLOT_VALUE)
{
- sfnValue++;
- slotValue = 0;
+ sfnValue++;
+ slotValue = 0;
}
fillMsgHeader(&slotIndMsg->header, FAPI_SLOT_INDICATION, \
- sizeof(fapi_slot_ind_t) - sizeof(fapi_msg_t));
- procPhyMessages(slotIndMsg->header.msg_id, sizeof(fapi_slot_ind_t), (void*)slotIndMsg);
- MAC_FREE(slotIndMsg, sizeof(fapi_slot_ind_t));
+ sizeof(fapi_slot_ind_t) - sizeof(fapi_msg_t));
+
+ memset(&pst, 0, sizeof(Pst));
+ FILL_PST_PHY_STUB_TO_LWR_MAC(pst, EVT_PHY_STUB_SLOT_IND);
+
+ ODU_GET_MSG_BUF(pst.region, pst.pool, &mBuf);
+ if(!mBuf)
+ {
+ DU_LOG("\nERROR --> PHY_STUB: Failed to allocate memory for slot indication buffer");
+ MAC_FREE_SHRABL_BUF(pst.region, pst.pool, slotIndMsg, sizeof(fapi_slot_ind_t));
+ return RFAILED;
+ }
+ CMCHKPK(oduPackPointer, (PTR)slotIndMsg, mBuf);
+ ODU_POST_TASK(&pst, mBuf);
}
#endif
return ROK;
}
else
{
- DU_LOG("\nPHY_STUB: Received Start Req in PHY State %d", lwrMacCb.phyState);
+ DU_LOG("\nINFO --> PHY_STUB: Received Start Req in PHY State %d", lwrMacCb.phyState);
MAC_FREE(msg, msgLen);
return RFAILED;
}
#ifdef ODU_SLOT_IND_DEBUG_LOG
if(dlTtiReq->nPdus == 0)
{
- DU_LOG("\nPHY_STUB: No PDU in DL TTI Request");
+ DU_LOG("\nDEBUG --> PHY_STUB: No PDU in DL TTI Request");
}
else
{
- DU_LOG("\nPHY STUB: DL TTI Request at sfn=%d slot=%d",dlTtiReq->sfn,dlTtiReq->slot);
+ DU_LOG("\nDEBUG --> PHY STUB: DL TTI Request at sfn=%d slot=%d",dlTtiReq->sfn,dlTtiReq->slot);
}
#endif
{
if(dlTtiReq->pdus[pduCount].pduType == 3) //SSB_PDU_TYPE
{
- DU_LOG("\nPHY_STUB: SSB PDU");
+ DU_LOG("\nINFO --> PHY_STUB: SSB PDU");
}
else if(dlTtiReq->pdus[pduCount].pduType == 0)
{
- DU_LOG("\nPHY_STUB: PDCCH PDU");
- if(dlTtiReq->pdus[pduCount].pdu.pdcch_pdu.\
- coreSetType == 1)
- {
- dlDedMsg = true;
- }
+ DU_LOG("\nINFO --> PHY_STUB: PDCCH PDU");
}
else if(dlTtiReq->pdus[pduCount].pduType == 1)
{
- DU_LOG("\nPHY_STUB: PDSCH PDU");
+ DU_LOG("\nINFO --> PHY_STUB: PDSCH PDU");
}
}
p_fapi_api_queue_elem_t txDataElem = (p_fapi_api_queue_elem_t)msg;
fapi_tx_data_req_t *txDataReq = (fapi_tx_data_req_t *)(txDataElem +1);
- DU_LOG("\nPHY STUB: TX DATA Request at sfn=%d slot=%d",txDataReq->sfn,txDataReq->slot);
+ DU_LOG("\nINFO --> PHY STUB: TX DATA Request at sfn=%d slot=%d",txDataReq->sfn,txDataReq->slot);
+/*
if(dlDedMsg)
{
- DU_LOG("\nPHY_STUB: TxDataPdu for DED MSG sent");
+ DU_LOG("\nINFO --> PHY_STUB: TxDataPdu for DED MSG sent");
dlDedMsg = false;
}
+*/
MAC_FREE(msg, msgLen);
#endif
return ROK;
case UCI_IND_PUCCH_F2F3F4:
break;
default:
- DU_LOG("\nPHY_STUB: Invalid Pdu Type %d", uciPdu->pduType);
+ DU_LOG("\nERROR --> PHY_STUB: Invalid Pdu Type %d", uciPdu->pduType);
break;
}
return ret;
MAC_ALLOC(uciInd, sizeof(fapi_uci_indication_t));
if(!uciInd)
{
- printf("\nPHY_STUB: Memory allocation failed for UCI Indication");
+ DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for UCI Indication");
return RFAILED;
}
memset(uciInd, 0, sizeof(fapi_uci_indication_t));
fillMsgHeader(&uciInd->header, FAPI_UCI_INDICATION, msgLen);
/* Sending UCI indication to MAC */
- DU_LOG("\nPHY STUB: Sending UCI Indication to MAC");
+ DU_LOG("\nINFO --> PHY STUB: Sending UCI Indication to MAC");
procPhyMessages(uciInd->header.msg_id, sizeof(fapi_uci_indication_t), (void *)uciInd);
}
MAC_FREE(uciInd, sizeof(fapi_uci_indication_t));
#ifdef ODU_SLOT_IND_DEBUG_LOG
if(numPdus == 0)
{
- DU_LOG("\nPHY STUB: No PDU received in UL TTI Req");
+ DU_LOG("\nINFO --> PHY STUB: No PDU received in UL TTI Req");
}
else
{
- DU_LOG("\nPHY STUB: Received UL TTI Request");
+ DU_LOG("\nINFO --> PHY STUB: Received UL TTI Request");
}
#endif
{
if(ulTtiReq->pdus[numPdus-1].pduType == 0)
{
- DU_LOG("\nPHY STUB: PRACH PDU");
+ DU_LOG("\nINFO --> PHY STUB: PRACH PDU");
}
if(ulTtiReq->pdus[numPdus-1].pduType == 1)
{
- DU_LOG("\nPHY STUB: PUSCH PDU");
+ DU_LOG("\nINFO --> PHY STUB: PUSCH PDU");
l1BuildAndSendRxDataInd(ulTtiReq->slot, ulTtiReq->sfn, \
ulTtiReq->pdus[numPdus-1].pdu.pusch_pdu);
}
if(ulTtiReq->pdus[numPdus-1].pduType == 2)
{
- DU_LOG("\nPHY STUB: PUCCH PDU");
+ DU_LOG("\nINFO --> PHY STUB: PUCCH PDU");
fapi_ul_tti_req_t ulTtiSlotInd;
memset(&ulTtiSlotInd, 0, sizeof(fapi_ul_tti_req_t));
ulTtiSlotInd.slot = ulTtiReq->slot;
numPdus--;
}
- if(rachIndSent == false && ulTtiReq->sfn == 2 && ulTtiReq->slot == 6)
+ /* TODO: [SFN:SLOT] at which RACH Indication is sent should be calculated
+ * based on PRACH cfg index */
+ /* Send RACH Ind to L2 for first UE */
+ if(ueDb.ueCb[UE_IDX_0].rachIndSent == false && ulTtiReq->sfn == 16 && ulTtiReq->slot == 6)
{
- rachIndSent = true;
+ ueDb.ueCb[UE_IDX_0].rachIndSent = true;
l1BuildAndSendRachInd(ulTtiReq->slot, ulTtiReq->sfn);
+ ueDb.numActvUe++;
+ }
+#if 0
+ /* Send RACH Ind to L2 for second UE */
+ if(ueDb.ueCb[UE_IDX_1].rachIndSent == false && ulTtiReq->sfn == 304 && ulTtiReq->slot == 0)
+ {
+ ueDb.ueCb[UE_IDX_1].rachIndSent = true;
+ l1BuildAndSendRachInd(ulTtiReq->slot, ulTtiReq->sfn);
+ ueDb.numActvUe++;
}
+ /* Send RACH Ind to L2 for third UE */
+ if(ueDb.ueCb[UE_IDX_2].rachIndSent == false && ulTtiReq->sfn == 526 && ulTtiReq->slot == 0)
+ {
+ ueDb.ueCb[UE_IDX_2].rachIndSent = true;
+ l1BuildAndSendRachInd(ulTtiReq->slot, ulTtiReq->sfn);
+ ueDb.numActvUe++;
+ }
+#endif
MAC_FREE(msg, msgLen);
#endif
return ROK;
uint16_t l1BuildAndSendStopInd()
{
#ifdef INTEL_FAPI
+ Pst pst;
+ Buffer *mBuf = NULLP;
fapi_stop_ind_t *stopIndMsg = NULLP;
uint32_t msgLen = 0;
- MAC_ALLOC(stopIndMsg, sizeof(fapi_stop_ind_t));
+ MAC_ALLOC_SHRABL_BUF(stopIndMsg, sizeof(fapi_stop_ind_t));
if(!stopIndMsg)
{
- DU_LOG("\nPHY_STUB: Memory allocation failed for stop Indication Message");
+ DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for stop Indication Message");
return RFAILED;
}
else
{
fillMsgHeader(&stopIndMsg->header, FAPI_STOP_INDICATION, msgLen);
- DU_LOG("\n\nPHY_STUB: Processing Stop indication to MAC");
- procPhyMessages(stopIndMsg->header.msg_id,\
- sizeof(fapi_stop_ind_t), (void*)stopIndMsg);
- MAC_FREE(stopIndMsg, sizeof(fapi_stop_ind_t));
+ DU_LOG("\n\nINFO --> PHY_STUB: Processing Stop indication to MAC");
+
+ memset(&pst, 0, sizeof(Pst));
+ FILL_PST_PHY_STUB_TO_LWR_MAC(pst, EVT_PHY_STUB_STOP_IND);
+ ODU_GET_MSG_BUF(pst.region, pst.pool, &mBuf);
+ if(!mBuf)
+ {
+ DU_LOG("\nERROR --> PHY_STUB: Failed to allocate memory for slot indication buffer");
+ MAC_FREE_SHRABL_BUF(pst.region, pst.pool, stopIndMsg, sizeof(fapi_stop_ind_t));
+ return RFAILED;
+ }
+ CMCHKPK(oduPackPointer, (PTR)stopIndMsg, mBuf);
+ ODU_POST_TASK(&pst, mBuf);
}
#endif
return ROK;
if(lwrMacCb.phyState == PHY_STATE_RUNNING)
{
l1HdlSlotIndicaion(TRUE);
- DU_LOG("\nPHY_STUB: Slot Indication is stopped successfully");
- l1BuildAndSendStopInd();
+
+ /* Initialize all global variables */
+ sfnValue = 0;
+ slotValue = 0;
+ memset(&ueDb, 0, sizeof(UeDb));
+
+ DU_LOG("\nINFO --> PHY_STUB: Slot Indication is stopped successfully");
MAC_FREE(msg, msgLen);
}
else
{
- DU_LOG("\nPHY_STUB: Received Stop Req in PHY State %d", lwrMacCb.phyState);
+ DU_LOG("\nINFO --> PHY_STUB: Received Stop Req in PHY State %d", lwrMacCb.phyState);
MAC_FREE(msg, msgLen);
return RFAILED;
}
return ROK;
}
+#if 0
/*******************************************************************
*
* @brief Build And Send Rx Data Ind for Msg5
MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t));
if(!rxDataInd)
{
- printf("\nPHY_STUB: Memory allocation failed for Rx Data Indication for msg5");
+ DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication for msg5");
return RFAILED;
}
memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t));
MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length);
if(!pduInfo->pduData)
{
- printf("\nPHY_STUB: Memory allocation failed for Rx Data Pdu");
+ DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
return RFAILED;
}
fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen);
/* Sending Rx data indication to MAC */
- DU_LOG("\nPHY STUB: Sending Rx data Indication to MAC");
+ DU_LOG("\nINFO --> PHY STUB: Sending Rx data Indication to MAC");
procPhyMessages(rxDataInd->header.msg_id, sizeof(fapi_rx_data_indication_t), (void *)rxDataInd);
if(pduInfo->pdu_length)
#endif
return ROK;
}
+#endif
/*******************************************************************
*
{
if(ulDciReq->pdus[numPdus-1].pduType == 0)
{
- DU_LOG("\nPHY STUB: Received UL DCI Request for PDCCH PDU");
+ DU_LOG("\nINFO --> PHY STUB: Received UL DCI Request for PDCCH PDU");
//l1BuildAndSendMsg5(ulDciReq->sfn, ulDciReq->slot);
//msg5Sent = true;
}
* RFAILED - failure
*
* ****************************************************************/
-uint8_t l1SendUlUserData()
+uint8_t l1SendUlUserData(uint8_t drbId, uint8_t ueIdx)
{
uint8_t cnt = 0;
fapi_rx_data_indication_t *rxDataInd;
uint16_t byteIdx = 0;
uint32_t msgLen = 0;
uint8_t idx = 0;
+ uint8_t lcId = 0;
MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t));
if(!rxDataInd)
{
- printf("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
+ DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
return RFAILED;
}
memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t));
/* TODO : Fill pduInfo using PUSCH PDU. Currently hardcoding */
pduInfo = &rxDataInd->pdus[idx];
- pduInfo->handle = 100;
- pduInfo->rnti = 100;
+ pduInfo->handle = ueIdx + ODU_START_CRNTI;
+ pduInfo->rnti = ueIdx + ODU_START_CRNTI;
pduInfo->harqId = 1;
/* Since user data size = 50bytes and 2 bytes of MAC header and 3 byte of RLC header,
* setting tbsize = 56 from Table 5.1.3.2-1 spec 38.214 */
MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length);
if(!pduInfo->pduData)
{
- printf("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
+ DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
return RFAILED;
}
/* Filling PDU */
pdu = (uint8_t *)pduInfo->pduData;
- msgLen = 51;
+ msgLen = 52;
/* For UL User data
MAC subheader format is R/F/LCId/L (2/3 bytes)
LCId is 4 for DRB1
L is length of PDU i.e 50 bytes
From 38.321 section 6.1.1
+ From 38.322 section 6.2.2.4, 6.2.2.3 for AM, UM Header
*/
- uint8_t ulMsg[] = {4, msgLen, 0, 69, 0, 0, 50, 0, 0, 0, 0, 0, 1, 0, 0, 192, 168, 130, 81, 192, 168, 130, 82, 84, 104,
- 105, 115, 32, 105, 115, 32, 69, 71, 84, 80, 32, 100, 97, 116, 97, 32, 102, 114, 111, 109, 32, 68, 85, 0, 0, 0, 0, 0};
- msgLen += 2; /* 2bytes of header */
- memcpy(pdu, &ulMsg, msgLen);
- byteIdx += msgLen; /* 2 bytes of header */
+ /* Below ulMsg supports 12bit SN for UM mode */
+ /* SI SN */
+ lcId = MIN_DRB_LCID + drbId;
+ uint8_t ulMsg[] = {lcId, msgLen, 0, 0, 0, 0, 0, 50, 0, 0, 0, 0, 0, 1, 0, 0, 192, 168, 130, 81, 192, 168, 130, 82, 84, 104,
+ 105, 115, 32, 105, 115, 32, 69, 71, 84, 80, 32, 100, 97, 116, 97, 32, 102, 114, 111, 109, 32, 68, 85, 0, 0, 0, 0, 0};
+ msgLen += 2; /* 2bytes of header */
+ memcpy(pdu, &ulMsg, msgLen);
+ byteIdx += msgLen; /* 2 bytes of header */
/* Filling MAC SDU for Padding bytes*/
if(byteIdx < pduInfo->pdu_length)
fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen);
/* Send Message to peer */
- while(cnt < 200)
+ while(cnt < NUM_UL_PACKETS)
{
- DU_LOG("\nDEBUG --> PHY STUB : Sending UL User Data[%d] at sfn %d slot %d", cnt+1, sfnValue, slotValue);
+ DU_LOG("\nDEBUG --> PHY STUB : Sending UL User Data[%d][LCID:%d] at sfn %d slot %d", cnt+1, lcId, sfnValue, slotValue);
/* Sending Rx data indication to MAC */
rxDataInd->sfn = sfnValue;
rxDataInd->slot = slotValue;
return ROK;
}
+/*******************************************************************
+ *
+ * @brief Sends RLC Status PDU to DU
+ *
+ * @details
+ *
+ * Function : l1SendStatusPdu
+ *
+ * Functionality: Send RLC Status PDU to DU
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t l1SendStatusPdu()
+{
+ fapi_rx_data_indication_t *rxDataInd;
+ fapi_pdu_ind_info_t *pduInfo;
+ uint8_t *pdu = NULLP;
+ uint16_t byteIdx = 0;
+ uint32_t msgLen = 0;
+ uint8_t idx = 0;
+
+ MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t));
+ if(!rxDataInd)
+ {
+ printf("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
+ return RFAILED;
+ }
+ memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t));
+
+ msgLen = sizeof(fapi_rx_data_indication_t) - sizeof(fapi_msg_t);
+ rxDataInd->sfn = 0;
+ rxDataInd->slot = 0;
+ rxDataInd->numPdus = 1;
+
+ /* TODO : Fill pduInfo using PUSCH PDU. Currently hardcoding */
+ pduInfo = &rxDataInd->pdus[idx];
+ pduInfo->handle = 100;
+ pduInfo->rnti = 100;
+ pduInfo->harqId = 1;
+ /* Since status pdu size = 3bytes and 2 bytes of MAC header,
+ * setting tbsize = 24 from Table 5.1.3.2-1 spec 38.214 */
+ pduInfo->pdu_length = 24;
+ pduInfo->ul_cqi = 0;
+ pduInfo->timingAdvance = 0;
+ pduInfo->rssi = 0;
+
+ /* Filling pdu with random values for testing */
+ pduInfo->pduData = NULL;
+ MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length);
+ if(!pduInfo->pduData)
+ {
+ printf("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
+ return RFAILED;
+ }
+
+ /* Filling PDU */
+ pdu = (uint8_t *)pduInfo->pduData;
+ msgLen = 3;
+
+ /* For RLC Status PDU
+ MAC subheader format is R/F/LCId/L (2/3 bytes)
+ LCId is 4 for DRB1
+ L is length of Status PDU i.e 3 bytes
+ From 38.321 section 6.1.1
+ */
+ uint8_t statusPdu[] = {4, msgLen, 0, 0, 0};
+ msgLen += 2; /* 2bytes of header */
+ memcpy(pdu, &statusPdu, msgLen);
+ byteIdx += msgLen; /* 2 bytes of header */
+
+
+ /* Filling MAC SDU for Padding bytes*/
+ if(byteIdx < pduInfo->pdu_length)
+ {
+ /* For Padding
+ MAC subheader format is R/R/LCId (1byte)
+ LCId is 63 for padding
+ From 38.321 section 6.1.1
+ */
+ pdu[byteIdx++] = 63;
+
+ for(; byteIdx < pduInfo->pdu_length; byteIdx++)
+ pdu[byteIdx] = 0;
+ }
+ msgLen += pduInfo->pdu_length;
+
+ fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen);
+
+ /* Send Message to peer */
+ DU_LOG("\nDEBUG --> PHY STUB : Sending RLC status pdu at sfn %d slot %d", sfnValue, slotValue);
+ /* Sending Rx data indication to MAC */
+ rxDataInd->sfn = sfnValue;
+ rxDataInd->slot = slotValue;
+ procPhyMessages(rxDataInd->header.msg_id, sizeof(fapi_rx_data_indication_t), (void *)rxDataInd);
+
+ if(pduInfo->pdu_length)
+ MAC_FREE(pduInfo->pduData, pduInfo->pdu_length);
+ MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t));
+ return ROK;
+}
+
/*******************************************************************
*
* @brief Receives message from MAC
{
#ifdef INTEL_FAPI
case FAPI_PARAM_REQUEST:
- l1HdlParamReq(msgLen, msg);
- break;
+ l1HdlParamReq(msgLen, msg);
+ break;
case FAPI_CONFIG_REQUEST:
- l1HdlConfigReq(msgLen, msg);
- break;
+ l1HdlConfigReq(msgLen, msg);
+ break;
case FAPI_START_REQUEST:
- l1HdlStartReq(msgLen, msg);
- break;
+ l1HdlStartReq(msgLen, msg);
+ break;
case FAPI_DL_TTI_REQUEST:
- l1HdlDlTtiReq(msgLen, msg);
- break;
+ l1HdlDlTtiReq(msgLen, msg);
+ break;
case FAPI_TX_DATA_REQUEST:
- l1HdlTxDataReq(msgLen, msg);
- break;
+ l1HdlTxDataReq(msgLen, msg);
+ break;
case FAPI_UL_TTI_REQUEST:
- l1HdlUlTtiReq(msgLen, msg);
- break;
+ l1HdlUlTtiReq(msgLen, msg);
+ break;
case FAPI_STOP_REQUEST:
- l1HdlStopReq(msgLen, msg);
- break;
+ l1HdlStopReq(msgLen, msg);
+ break;
case FAPI_UL_DCI_REQUEST:
- l1HdlUlDciReq(msgLen, msg);
- break;
+ l1HdlUlDciReq(msgLen, msg);
+ break;
default:
- DU_LOG("\nPHY_STUB: Invalid message type[%x] received at PHY", msgType);
- break;
+ DU_LOG("\nERROR --> PHY_STUB: Invalid message type[%x] received at PHY", msgType);
+ break;
#endif
}
}
+
+#ifdef INTEL_FAPI
+/*******************************************************************
+ *
+ * @brief Builds and Send the BSR message to MAC
+ *
+ * @details
+ *
+ * Function : l1BuildAndSendBSR
+ *
+ * Functionality:
+ * -Send the BSR Message to MAC
+ *
+ * @params[in] BSR type
+ * array of LCGID and BSIdx
+ * @return void
+ *
+ *****************************************************************/
+uint16_t l1BuildAndSendBSR(uint8_t ueIdx, BsrType bsrType,\
+ LcgBufferSize lcgBsIdx[MAX_NUM_LOGICAL_CHANNEL_GROUPS])
+{
+ fapi_rx_data_indication_t *rxDataInd;
+ fapi_pdu_ind_info_t *pduInfo;
+ uint8_t *pdu = NULLP;
+ uint16_t byteIdx = 0;
+ uint32_t msgLen = 0;
+ uint8_t pduIdx = 0, lcgIdx = 0, lcgIdxPos = 0;
+
+ MAC_ALLOC(rxDataInd, sizeof(fapi_rx_data_indication_t));
+ if(!rxDataInd)
+ {
+ DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Indication");
+ return RFAILED;
+ }
+ memset(rxDataInd, 0, sizeof(fapi_rx_data_indication_t));
+
+ msgLen = sizeof(fapi_rx_data_indication_t) - sizeof(fapi_msg_t);
+ rxDataInd->sfn = 0;
+ rxDataInd->slot = 0;
+ rxDataInd->numPdus = 1;
+
+ pduInfo = &rxDataInd->pdus[pduIdx];
+ pduInfo->handle = (ODU_START_CRNTI + ueIdx);
+ pduInfo->rnti = (ODU_START_CRNTI + ueIdx);
+ pduInfo->harqId = 1;
+
+ /* Since status pdu size = 3bytes and 2 bytes of MAC header,
+ * setting tbsize = 24 from Table 5.1.3.2-1 spec 38.214 */
+ pduInfo->pdu_length = 24;
+ pduInfo->ul_cqi = 0;
+ pduInfo->timingAdvance = 0;
+ pduInfo->rssi = 0;
+
+ /* Filling pdu with random values for testing */
+ pduInfo->pduData = NULL;
+ MAC_ALLOC(pduInfo->pduData, pduInfo->pdu_length);
+ if(!pduInfo->pduData)
+ {
+ DU_LOG("\nERROR --> PHY_STUB: Memory allocation failed for Rx Data Pdu");
+ MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t));
+ return RFAILED;
+ }
+
+ /* Filling PDU */
+ pdu = (uint8_t *)pduInfo->pduData;
+
+ switch(bsrType)
+ {
+ case SHORT_BSR:
+ {
+ DU_LOG("\nDEBUG --> PHY_STUB: Forming SHORT BSR PDU ");
+
+ /* For Short BSR
+ * MAC subheader format is R/R/LcId (1Byte)
+ * LCId is 61
+ * From 38.321 section 6.1.1
+ */
+ pdu[byteIdx++] = 61; // LCID
+ pdu[byteIdx++] = (lcgBsIdx[0].lcgId << 5) | lcgBsIdx[0].bsIdx;
+ break;
+ }
+
+ case LONG_BSR:
+ {
+ DU_LOG("\nDEBUG --> PHY_STUB: Forming LONG BSR PDU ");
+
+ /* For Long BSR
+ * MAC subheader format is R/R/LcId (1Byte)
+ * LCId is 62
+ * From 38.321 section 6.1.1
+ */
+ pdu[byteIdx++] = 62; // LCID
+
+ /*Octet where lcgId bitmap will be present*/
+ lcgIdxPos = byteIdx;
+ byteIdx++;
+ for(lcgIdx = 0; lcgIdx < MAX_NUM_LOGICAL_CHANNEL_GROUPS; lcgIdx++)
+ {
+ if(lcgBsIdx[lcgIdx].bsIdx > 0)
+ {
+ pdu[lcgIdxPos] |= 1 << lcgBsIdx[lcgIdx].lcgId;
+ pdu[byteIdx++] = lcgBsIdx[lcgIdx].bsIdx;
+ }
+ }
+
+ break;
+ }
+
+ default:
+ {
+ DU_LOG("\nERROR --> PHY_STUB: Incorrect BSR type:%d!", bsrType);
+ if(pduInfo->pdu_length)
+ MAC_FREE(pduInfo->pduData, pduInfo->pdu_length);
+ MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t));
+ return RFAILED;
+ }
+ }
+ /* Filling MAC SDU for Padding bytes*/
+ if(byteIdx < pduInfo->pdu_length)
+ {
+ /* For Padding
+ * MAC subheader format is R/R/LCId (1byte)
+ * LCId is 63 for padding
+ * From 38.321 section 6.1.1
+ */
+ pdu[byteIdx++] = 63;
+
+ for(; byteIdx < pduInfo->pdu_length; byteIdx++)
+ pdu[byteIdx] = 0;
+ }
+ msgLen += pduInfo->pdu_length;
+ fillMsgHeader(&rxDataInd->header, FAPI_RX_DATA_INDICATION, msgLen);
+
+ /* Sending Rx data indication to MAC */
+ DU_LOG("\nINFO --> PHY STUB: Sending Rx data Indication to MAC");
+ procPhyMessages(rxDataInd->header.msg_id, sizeof(fapi_rx_data_indication_t), (void *)rxDataInd);
+
+ if(pduInfo->pdu_length)
+ MAC_FREE(pduInfo->pduData, pduInfo->pdu_length);
+ MAC_FREE(rxDataInd, sizeof(fapi_rx_data_indication_t));
+ return ROK;
+}
+#endif
+
/**********************************************************************
End of file
**********************************************************************/
Code Review / o-du / l2.git / blobdiff