#define SSB_PDU_TYPE 3
#define PRACH_PDU_TYPE 0
#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(CmLteTimingInfo *currTimingInfo, DlAlloc *dlInfo);
void lwrMacInit()
{
* ****************************************************************/
S16 lwr_mac_handleInvalidEvt(void *msg)
{
- printf("\nLOWER MAC: Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState);
+ printf("\nLWR_MAC: Error Indication Event[%d] received in state [%d]", clGlobalCp.event, clGlobalCp.phyState);
RETVALUE(ROK);
}
}
else
{
- DU_LOG("\nLOWER MAC: Value Extraction failed" );
+ DU_LOG("\nLWR_MAC: Value Extraction failed" );
return RFAILED;
}
}
{
#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;
}
/*******************************************************************
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++)
}
}
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
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);
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);
+
+ 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;
}
* 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
******************************************************************/
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)
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;
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
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;
}
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;
}
dlTtiReqPdu->u.pdcch_pdu.shiftIndex = pdcchInfo->coreset0Cfg.shiftIndex;
dlTtiReqPdu->u.pdcch_pdu.precoderGranularity = pdcchInfo->coreset0Cfg.precoderGranularity;
dlTtiReqPdu->u.pdcch_pdu.numDlDci = pdcchInfo->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
+ 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(pdcchInfo->dci.rnti == SI_RNTI)
{
fillSib1DlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo);
fillRarDlDciPdu(dlTtiReqPdu->u.pdcch_pdu.dlDci, pdcchInfo);
}
- dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdcch_pdu_t);
- SETLENGTH(*msgLen, sizeof(fapi_dl_pdcch_pdu_t));
+ /* 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;
******************************************************************/
void fillPdschPdu(fapi_dl_tti_req_pdu_t *dlTtiReqPdu, PdschCfg *pdschInfo,
-uint32_t *msgLen)
+uint32_t *msgLen, uint16_t pduIndex)
{
uint8_t idx;
dlTtiReqPdu->pduType = PDSCH_PDU_TYPE;
dlTtiReqPdu->u.pdsch_pdu.pduBitMap = pdschInfo->pduBitmap;
dlTtiReqPdu->u.pdsch_pdu.rnti = pdschInfo->rnti;
- dlTtiReqPdu->u.pdsch_pdu.pduIndex = pdschInfo->pduIndex;
+ dlTtiReqPdu->u.pdsch_pdu.pduIndex = pduIndex;
dlTtiReqPdu->u.pdsch_pdu.bwpSize = pdschInfo->pdschBwpCfg.BWPSize;
dlTtiReqPdu->u.pdsch_pdu.bwpStart = pdschInfo->pdschBwpCfg.BWPStart;
dlTtiReqPdu->u.pdsch_pdu.subCarrierSpacing = pdschInfo->pdschBwpCfg.subcarrierSpacing;
dlTtiReqPdu->u.pdsch_pdu.powerControlOffset = pdschInfo->txPdschPower.powerControlOffset;
dlTtiReqPdu->u.pdsch_pdu.powerControlOffsetSS = pdschInfo->txPdschPower.powerControlOffsetSS;
dlTtiReqPdu->pduSize = sizeof(fapi_dl_pdsch_pdu_t);
- SETLENGTH(*msgLen, sizeof(fapi_dl_pdsch_pdu_t));
+
+ SET_MSG_LEN(*msgLen, (sizeof(dlTtiReqPdu->pduType) + \
+ sizeof(dlTtiReqPdu->pduSize) + sizeof(fapi_dl_pdsch_pdu_t)));
}
*
* @details
*
- * Function : calculatePduCount
+ * Function : calcDlTtiReqPduCount
*
* Functionality:
* -calculates the total pdu count to be allocated for DL TTI Req
* @return count
*
* ********************************************************************/
-uint8_t calculatePduCount(DlAlloc *dlInfo)
+uint8_t calcDlTtiReqPduCount(DlAlloc *dlInfo)
{
uint8_t count = 0;
uint8_t idx = 0;
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(DlAlloc *dlInfo)
+{
+ uint8_t count = 0;
+ if(dlInfo->isBroadcastPres && dlInfo->brdcstAlloc.sib1Trans)
+ {
+ count++;
+ }
+ if(dlInfo->isRarPres)
+ {
+ count++;
+ }
+ return count;
+}
/***********************************************************************
*
* @brief fills the SIB1 TX-DATA request message
* - fills the SIB1 TX-DATA request message
*
* @params[in] fapi_tx_pdu_desc_t *pduDesc
- * @params[in] MacCellCfg *macCellCfg
- * @params[in] uint16_t pduIndex
+ * @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,
- uint16_t pduIndex, uint32_t *msgLen)
+ uint32_t *msgLen, uint16_t pduIndex)
{
uint32_t pduLen = 0;
uint32_t *sib1TxdataValue = NULLP;
- pduDesc->pduIndex = pduIndex;
- pduDesc->numTlvs = 1;
+ 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->tlvs[0].tl.tag = 1; /* pointer to be sent */
- pduDesc->tlvs[0].tl.length = macCellCfg->sib1Cfg.sib1PduLen;
- MAC_ALLOC(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen);
+ 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->tlvs[0].value = sib1TxdataValue;
+ 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->pduLength = pduLen;
+ 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 */
- MAC_FREE(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen);
+#ifndef INTEL_WLS
+ MAC_FREE(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen);
+#endif
+
return ROK;
}
*
* @params[in] fapi_tx_pdu_desc_t *pduDesc
* @params[in] RarInfo *rarInfo
- * @params[in] uint16_t pduIndex
* @params[in] uint32_t *msgLen
+ * @params[in] uint16_t pduIndex
* @return ROK
*
* ********************************************************************/
uint8_t fillRarTxDataReq(fapi_tx_pdu_desc_t *pduDesc, RarInfo *rarInfo,
- uint16_t pduIndex, uint32_t *msgLen)
+ uint32_t *msgLen, uint16_t pduIndex)
{
uint32_t pduLen = 0;
uint32_t *rarTxdataValue = NULLP;
- pduDesc->pduIndex = pduIndex;
- pduDesc->numTlvs = 1;
+ 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->tlvs[0].tl.tag = 1; /* pointer to be sent */
- pduDesc->tlvs[0].tl.length = rarInfo->rarPduLen;
- MAC_ALLOC(rarTxdataValue,rarInfo->rarPduLen);
+ 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->tlvs[0].value = (uint32_t)rarTxdataValue;
+ 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->pduLength = pduLen;
+ 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 */
- MAC_FREE(rarTxdataValue,rarInfo->rarPduLen);
+/* 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;
}
* 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
*
* ****************************************************************/
-uint16_t handleDlTtiReq(CmLteTimingInfo *dlTtiReqtimingInfo)
+uint16_t handleDlTtiReq(CmLteTimingInfo *currTimingInfo)
{
#ifdef FAPI
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;
- fapi_tx_data_req_t *txDataReq = NULLP;
RgCellCb *cellCbParams = NULLP;
MacDlSlot *currDlSlot = NULLP;
MacCellCfg macCellCfg;
cellCbParams = rgCb[inst].cell;
macCellCfg = cellCbParams->macCellCfg;
- if(dlTtiReqtimingInfo != NULLP)
+ if(currTimingInfo != NULLP)
{
-#ifdef INTEL_WLS
- WLS_MEM_ALLOC(dlTtiReq, sizeof(fapi_dl_tti_req_t));
-#else
- MAC_ALLOC(dlTtiReq, sizeof(fapi_dl_tti_req_t));
-#endif
+ currDlSlot = &macCb.macCell->dlSlot[currTimingInfo->slot % MAX_SLOT_SUPPORTED];
+ nPdu = calcDlTtiReqPduCount(&currDlSlot->dlInfo);
+ dlTtiReqMsgSize = sizeof(fapi_dl_tti_req_t) + (nPdu * \
+ sizeof(fapi_dl_tti_req_pdu_t));
+ if(nPdu > 0)
+ {
+ if(currDlSlot->dlInfo.isBroadcastPres)
+ {
+ if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
+ {
+ dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
+ }
+
+ }
+ if(currDlSlot->dlInfo.isRarPres)
+ {
+ dlTtiReqMsgSize += sizeof(fapi_dl_dci_t);
+ }
+ }
+ LWR_MAC_ALLOC(dlTtiReq, dlTtiReqMsgSize);
+
if(dlTtiReq != NULLP)
{
- dlTtiReq->sfn = dlTtiReqtimingInfo->sfn;
- dlTtiReq->slot = dlTtiReqtimingInfo->slot;
- currDlSlot = &macCb.macCell->dlSlot[dlTtiReq->slot % MAX_SLOT_SUPPORTED];
- dlTtiReq->nPdus = calculatePduCount(&currDlSlot->dlInfo); /* get total Pdus */
+ memset(dlTtiReq, 0, dlTtiReqMsgSize);
+
+ dlTtiReq->sfn = currTimingInfo->sfn;
+ dlTtiReq->slot = currTimingInfo->slot;
+ dlTtiReq->nPdus = calcDlTtiReqPduCount(&currDlSlot->dlInfo); /* get total Pdus */
nPdu = dlTtiReq->nPdus;
dlTtiReq->nGroup = 0;
if(dlTtiReq->nPdus > 0)
{
-#ifdef INTEL_WLS
- WLS_MEM_ALLOC(dlTtiReq->pdus, (nPdu * sizeof(fapi_dl_tti_req_pdu_t)));
-#else
- MAC_ALLOC(dlTtiReq->pdus, (nPdu * sizeof(fapi_dl_tti_req_pdu_t)));
-#endif
+ 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)
{
for(idx = 0; idx < currDlSlot->dlInfo.brdcstAlloc.ssbIdxSupported; idx++)
{
- if(idx > 0)
- dlTtiReq->pdus++;
- fillSsbPdu(&dlTtiReq->pdus[numPduEncoded], &macCellCfg, currDlSlot, &msgLen, idx);
+ fillSsbPdu(&dlTtiReq->pdus[numPduEncoded], &macCellCfg,\
+ currDlSlot, &msgLen, idx, dlTtiReq->sfn);
numPduEncoded++;
}
}
- DU_LOG("\nLOWER MAC: MIB sent..");
+ printf("\033[1;31m");
+ DU_LOG("\nLWR_MAC: MIB sent..");
+ printf("\033[0m");
}
if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
{
sib1Alloc.sib1PdcchCfg, &msgLen);
numPduEncoded++;
fillPdschPdu(&dlTtiReq->pdus[numPduEncoded],&currDlSlot->dlInfo.brdcstAlloc.\
- sib1Alloc.sib1PdschCfg, &msgLen);
+ sib1Alloc.sib1PdschCfg, &msgLen, pduIndex);
+ pduIndex++;
numPduEncoded++;
}
- DU_LOG("\nLOWER MAC: SIB1 sent...");
+ printf("\033[1;34m");
+ DU_LOG("\nLWR_MAC: SIB1 sent...");
+ printf("\033[0m");
}
}
if(currDlSlot->dlInfo.isRarPres)
{
/* Filling RAR param */
+ fillRarPdu(&currDlSlot->dlInfo.rarAlloc.rarInfo);
fillPdcchPdu(&dlTtiReq->pdus[numPduEncoded], &currDlSlot->dlInfo.rarAlloc.rarPdcchCfg, &msgLen);
numPduEncoded++;
- fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], &currDlSlot->dlInfo.rarAlloc.rarPdschCfg, &msgLen);
+ fillPdschPdu(&dlTtiReq->pdus[numPduEncoded], &currDlSlot->dlInfo.rarAlloc.rarPdschCfg,
+ &msgLen, pduIndex);
numPduEncoded++;
- DU_LOG("\nLOWER MAC: RAR sent...");
+ pduIndex++;
+
+ printf("\033[1;32m");
+ DU_LOG("\nLWR_MAC: RAR sent...");
+ printf("\033[0m");
}
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);
-
- /* FREE the allocated memories */
- if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
- {
- if(currDlSlot->dlInfo.brdcstAlloc.ssbTrans)
- {
- 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));
- }
- }
- if(currDlSlot->dlInfo.isRarPres)
- {
- if(currDlSlot->dlInfo.brdcstAlloc.ssbTrans)
- {
- 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));
- }
- }
+ LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, \
+ (void *)dlTtiReq);
- MAC_FREE(dlTtiReq->pdus, (nPdu * sizeof(fapi_dl_tti_req_pdu_t)));
-
- /* send TX_Data request message */
- if(currDlSlot->dlInfo.brdcstAlloc.sib1Trans)
- {
- msgLen = 0;
- MAC_ALLOC(txDataReq,sizeof(fapi_tx_data_req_t));
- txDataReq->sfn = dlTtiReqtimingInfo->sfn;
- txDataReq->slot = dlTtiReqtimingInfo->slot;
- txDataReq->numPdus = 1;
- fillSib1TxDataReq(
- &txDataReq->pduDesc,
- &rgCb[inst].cell->macCellCfg,
- currDlSlot->dlInfo.brdcstAlloc.sib1Alloc.sib1PdschCfg.pduIndex,
- &msgLen);
- 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, msgLen,(void *)txDataReq);
- MAC_FREE(txDataReq,sizeof(fapi_tx_data_req_t));
- }
- if(currDlSlot->dlInfo.isRarPres)
- {
- msgLen = 0;
- /* mux and form RAR pdu */
- fillRarPdu(&currDlSlot->dlInfo.rarAlloc.rarInfo);
-
- MAC_ALLOC(txDataReq,sizeof(fapi_tx_data_req_t));
- txDataReq->sfn = dlTtiReqtimingInfo->sfn;
- txDataReq->slot = dlTtiReqtimingInfo->slot;
- txDataReq->numPdus = 1;
- fillRarTxDataReq(
- &txDataReq->pduDesc,
- &currDlSlot->dlInfo.rarAlloc.rarInfo,
- currDlSlot->dlInfo.rarAlloc.rarPdschCfg.pduIndex,
- &msgLen);
- fillMsgHeader(&txDataReq->header, FAPI_TX_DATA_REQUEST, msgLen);
- LwrMacSendToPhy(txDataReq->header.message_type_id, msgLen,(void *)txDataReq);
- MAC_FREE(txDataReq,sizeof(fapi_tx_data_req_t));
- }
+ /* send Tx-DATA req message */
+ sendTxDataReq(currTimingInfo, &currDlSlot->dlInfo);
}
else
{
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);
+ LwrMacSendToPhy(dlTtiReq->header.message_type_id, dlTtiReqMsgSize, (void *)dlTtiReq);
}
- MAC_FREE(dlTtiReq, sizeof(fapi_dl_tti_req_t));
return ROK;
}
else
{
- DU_LOG("\nLOWER MAC: Failed to allocate memory for DL TTI Request");
+ DU_LOG("\nLWR_MAC: Failed to allocate memory for DL TTI Request");
return RFAILED;
}
}
else
{
- DU_LOG("\nLOWER MAC: Current TTI Info is NULL");
+ DU_LOG("\nLWR_MAC: Current TTI Info is NULL");
return RFAILED;
}
}
else
{
- lwr_mac_handleInvalidEvt(dlTtiReqtimingInfo);
+ 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(CmLteTimingInfo *currTimingInfo, DlAlloc *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)
+ {
+ txDataReqMsgSize += rgCb[inst].cell->macCellCfg.sib1Cfg.sib1PduLen;
+ }
+ if(dlInfo->isRarPres)
+ {
+ txDataReqMsgSize += dlInfo->rarAlloc.rarInfo.rarPduLen;
+ }
+
+ LWR_MAC_ALLOC(txDataReq, txDataReqMsgSize);
+ if(txDataReq == NULLP)
+ {
+ DU_LOG("\nLWR_MAC: Failed to allocate memory for TX data Request");
+ return RFAILED;
+ }
+
+ 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->isRarPres)
+ {
+ /* mux and form RAR pdu */
+ //fillRarPdu(&dlInfo->rarAlloc.rarInfo);
+ fillRarTxDataReq(txDataReq->pduDesc,
+ &dlInfo->rarAlloc.rarInfo, &msgLen, pduIndex);
+ pduIndex++;
+ txDataReq->numPdus++;
+ }
+
+ 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;
+}
+
/***********************************************************************
*
* @brief calculates the total size to be allocated for UL TTI Req
if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PRACH)
{
pduCount++;
- ulTtiReq->rachPresent = PDU_PRESENT;
+ if(ulTtiReq)
+ ulTtiReq->rachPresent = PDU_PRESENT;
}
if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_PUSCH_UCI)
{
pduCount++;
- ulTtiReq->nUlsch = PDU_PRESENT;
+ if(ulTtiReq)
+ ulTtiReq->nUlsch = PDU_PRESENT;
}
if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_UCI)
{
pduCount++;
- ulTtiReq->nUlcch = PDU_PRESENT;
+ if(ulTtiReq)
+ ulTtiReq->nUlcch = PDU_PRESENT;
}
if(currUlSlot->ulCellInfo.dataType & SCH_DATATYPE_SRS)
{
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)));
}
}
#endif
* RFAILED - failure
*
******************************************************************/
-S16 handleUlTtiReq(CmLteTimingInfo *currTimingInfo)
+uint16_t handleUlTtiReq(CmLteTimingInfo *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;
RgCellCb *cellCbParams = NULLP;
MacUlSlot *currUlSlot = NULLP;
MacCellCfg macCellCfg;
- memset(&macCellCfg, 0, sizeof(MacCellCfg));
Inst inst = 0;
if(clGlobalCp.phyState == PHY_STATE_RUNNING)
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
+ currUlSlot = &macCb.macCell->ulSlot[currTimingInfo->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)
{
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
+ 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(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)));
+ pduIdx++;
+ fillPrachPdu(&ulTtiReq->pdus[pduIdx], &macCellCfg, currUlSlot, &msgLen);
+
+ 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("\nLOWER MAC: Sending UL TTI Request");
- LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgLen, (void *)ulTtiReq);
+
+ DU_LOG("\nLWR_MAC: Sending UL TTI Request");
+ LwrMacSendToPhy(ulTtiReq->header.message_type_id, msgSize, (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");
+ DU_LOG("\nLWR_MAC: Failed to allocate memory for UL TTI Request");
return RFAILED;
}
}
else
{
- DU_LOG("\nLOWER MAC: Current TTI Info in UL is NULL");
+ DU_LOG("\nLWR_MAC: Current TTI Info in UL is NULL");
return RFAILED;
}
}
lwr_mac_handleConfigReqEvt,
lwr_mac_handleConfigRspEvt,
lwr_mac_handleInvalidEvt,
+ lwr_mac_handleInvalidEvt,
},
{
/* PHY_STATE_CONFIGURED */
lwr_mac_handleConfigReqEvt,
lwr_mac_handleConfigRspEvt,
lwr_mac_handleStartReqEvt,
+ lwr_mac_handleInvalidEvt,
},
{
/* PHY_STATE_RUNNING */
lwr_mac_handleConfigReqEvt,
lwr_mac_handleConfigRspEvt,
lwr_mac_handleInvalidEvt,
+ lwr_mac_handleStopReqEvt,
}
};
/*******************************************************************
*
- * @brief Sends message to Lower Mac Fsm Event Handler
+ * @brief Sends message to LWR_MAC Fsm Event Handler
*
* @details
*
Code Review / o-du / l2.git / blobdiff