I_OPTS+=-isystem $(BSPPATH)/usr/include/brcm
I_OPTS+=-I$(SRC_DIR)/security
I-OPTS+=-I$(ROOT_DIR)/src/wls_lib
+I_OPTS+=-I$(ROOT_DIR)/src/dpdk_lib
HDR_FILES+=$(wildcard $(CM_DIR)/env*.[hx])
HDR_FILES+=$(wildcard $(CM_DIR)/gen*.[hx])
# macro for output file name and makefile name
#
-PLTFRM_FLAGS= -UMSPD -DODU -DINTEL_FAPI #-DODU_SLOT_IND_DEBUG_LOG #-DINTEL_WLS -DEGTP_TEST
+PLTFRM_FLAGS= -UMSPD -DODU -DINTEL_FAPI #-DSS_USE_WLS_MEM -DINTEL_WLS_MEM -DDEBUG_MODE \
+ #-DODU_SLOT_IND_DEBUG_LOG -DEGTP_TEST
ifeq ($(MODE),TDD)
PLTFRM_FLAGS += -DMODE=TDD
#ifndef __LWR_MAC_H__
#define __LWR_MAC_H__
-#ifdef INTEL_WLS
+#ifdef INTEL_WLS_MEM
#define LWR_MAC_ALLOC(_datPtr, _size) WLS_MEM_ALLOC(_datPtr, _size);
#else
#define LWR_MAC_ALLOC(_datPtr, _size) MAC_ALLOC(_datPtr, _size);
uint32_t reverseBits(uint32_t num, uint8_t numBits);
void fillDlDciPayload(uint8_t *buf, uint8_t *bytePos, uint8_t *bitPos,\
uint32_t val, uint8_t valSize);
-void lwrMacInit();
+void lwrMacLayerInit();
#endif
--- /dev/null
+/*******************************************************************************\r
+################################################################################\r
+# Copyright (c) [2017-2019] [Radisys] #\r
+# #\r
+# Licensed under the Apache License, Version 2.0 (the "License"); #\r
+# you may not use this file except in compliance with the License. #\r
+# You may obtain a copy of the License at #\r
+# #\r
+# http://www.apache.org/licenses/LICENSE-2.0 #\r
+# #\r
+# Unless required by applicable law or agreed to in writing, software #\r
+# distributed under the License is distributed on an "AS IS" BASIS, #\r
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. #\r
+# See the License for the specific language governing permissions and #\r
+# limitations under the License. #\r
+################################################################################\r
+*******************************************************************************/\r
+\r
+/* This file is the entry point for Lower MAC */\r
+\r
+#include "common_def.h"\r
+#include "lwr_mac_phy.h"\r
+\r
+/**************************************************************************\r
+ * @brief Task Initiation callback function. \r
+ *\r
+ * @details\r
+ *\r
+ * Function : lwrMacActvInit \r
+ * \r
+ * Functionality:\r
+ * This function is supplied as one of parameters during Lower MAC's \r
+ * task registration. SSI will invoke this function once, after\r
+ * it creates and attaches this TAPA Task to a system task.\r
+ * \r
+ * @param[in] Ent entity, the entity ID of this task. \r
+ * @param[in] Inst inst, the instance ID of this task.\r
+ * @param[in] Region region, the region ID registered for memory \r
+ * usage of this task.\r
+ * @param[in] Reason reason.\r
+ * @return ROK - success\r
+ * RFAILED - failure\r
+ ***************************************************************************/\r
+uint8_t lwrMacActvInit(Ent entity, Inst inst, Region region, Reason reason)\r
+{\r
+ return ROK;\r
+}\r
+\r
+/**************************************************************************\r
+ * @brief Task Activation callback function. \r
+ *\r
+ * @details\r
+ *\r
+ * Function : lwrMacActvTsk \r
+ * \r
+ * Functionality:\r
+ * Primitives invoked by Lower MAC's users/providers through\r
+ * a loosely coupled interface arrive here by means of \r
+ * SSI's message handling. This API is registered with\r
+ * SSI during the Task Registration of DU APP.\r
+ * \r
+ * @param[in] Pst *pst, Post structure of the primitive. \r
+ * @param[in] Buffer *mBuf, Packed primitive parameters in the\r
+ * buffer.\r
+ * @return ROK - success\r
+ * RFAILED - failure\r
+ *\r
+ ***************************************************************************/\r
+uint8_t lwrMacActvTsk(Pst *pst, Buffer *mBuf)\r
+{\r
+ uint8_t ret = ROK;\r
+\r
+ switch(pst->srcEnt)\r
+ {\r
+ case ENTLWRMAC:\r
+ {\r
+ switch(pst->event)\r
+ {\r
+#ifdef INTEL_WLS_MEM\r
+ case EVT_START_WLS_RCVR:\r
+ {\r
+ SPutMsg(mBuf);\r
+ DU_LOG("\nLWR MAC: Starting WLS receiver thread");\r
+ LwrMacRecvPhyMsg();\r
+ break;\r
+ }\r
+#endif\r
+ default:\r
+ {\r
+ SPutMsg(mBuf);\r
+ DU_LOG("\nLWR MAC: Invalid event %d received", pst->event);\r
+ ret = RFAILED;\r
+ }\r
+ }\r
+ break;\r
+ }\r
+ default:\r
+ {\r
+ SPutMsg(mBuf);\r
+ DU_LOG("\nLWR MAC: Message from invalid source entity %d", pst->srcEnt);\r
+ ret = RFAILED;\r
+ }\r
+ }\r
+ return ret;\r
+}\r
+\r
+/**********************************************************************\r
+ End of file\r
+ **********************************************************************/\r
#include "lwr_mac.h"
#ifdef INTEL_FAPI
#include "fapi.h"
+#include "fapi_vendor_extension.h"
+#endif
+#ifdef INTEL_WLS_MEM
+#include "wls_lib.h"
#endif
#include "lwr_mac_fsm.h"
#include "mac_utils.h"
uint8_t slotIndIdx;
uint16_t sendTxDataReq(SlotIndInfo currTimingInfo, DlSchedInfo *dlInfo);
-void lwrMacInit()
+void lwrMacLayerInit()
{
-#ifdef INTEL_WLS
+#ifdef INTEL_WLS_MEM
uint8_t idx;
/* Initializing WLS free mem list */
*
* ****************************************************************/
void fillTlvs(fapi_uint32_tlv_t *tlv, uint16_t tag, uint16_t length,
- uint16_t value, uint32_t *msgLen)
+ uint32_t value, uint32_t *msgLen)
{
tlv->tl.tag = tag;
tlv->tl.length = length;
}
}
#endif /* FAPI */
+
+/*******************************************************************
+ *
+ * @brief Modifes the received mibPdu to uint32 bit
+ * and stores it in MacCellCfg
+ *
+ * @details
+ *
+ * Function : setMibPdu
+ *
+ * Functionality:
+ * -Sets the MibPdu
+ *
+ * @params[in] Pointer to mibPdu
+ * pointer to modified value
+ ******************************************************************/
+void setMibPdu(uint8_t *mibPdu, uint32_t *val, uint16_t sfn)
+{
+ *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);
+}
+
/*******************************************************************
*
* @brief Sends FAPI Param req to PHY
uint8_t lwr_mac_procConfigReqEvt(void *msg)
{
#ifdef INTEL_FAPI
- uint8_t idx = 0;
- uint8_t index = 0;
- uint16_t *cellId;
- uint16_t cellIdx;
- uint32_t msgLen = 0;
- MacCellCfg macCfgParams;
+ //uint8_t idx = 0;
+ uint8_t index = 0;
+ uint16_t *cellId;
+ uint16_t cellIdx;
+ uint32_t msgLen = 0;
+ uint32_t mib = 0;
+ MacCellCfg macCfgParams;
+ fapi_vendor_msg_t *vendorMsg;
fapi_config_req_t *configReq;
+ fapi_msg_header_t *msgHeader;
+ p_fapi_api_queue_elem_t headerElem;
+ 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, \
lwrMacCb.phyState);
lwrMacCb.cellCb[lwrMacCb.numCell].phyCellId = macCfgParams.phyCellId;
lwrMacCb.numCell++;
- /* Fill FAPI config req */
- LWR_MAC_ALLOC(configReq, sizeof(fapi_config_req_t));
- if(configReq != NULL)
+ /* Allocte And fill Vendor msg */
+ LWR_MAC_ALLOC(vendorMsgQElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
+ if(!vendorMsgQElem)
{
- memset(configReq, 0, sizeof(fapi_config_req_t));
- msgLen = sizeof(macCfgParams.numTlv);
- configReq->number_of_tlvs = macCfgParams.numTlv;
+ DU_LOG("\nLWR_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 = (fapi_vendor_msg_t *)(vendorMsgQElem + 1);
+ fillMsgHeader(&vendorMsg->header, FAPI_VENDOR_MESSAGE, sizeof(fapi_vendor_msg_t));
+ vendorMsg->config_req_vendor.hopping_id = 0;
+ vendorMsg->config_req_vendor.carrier_aggregation_level = 0;
+ vendorMsg->config_req_vendor.group_hop_flag = 0;
+ vendorMsg->config_req_vendor.sequence_hop_flag = 0;
- 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);
- }
- 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_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);
-
- /* fill SSB configuration */
- fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_POWER_TAG, \
- sizeof(uint32_t), macCfgParams.ssbCfg.ssbPbchPwr, &msgLen);
- fillTlvs(&configReq->tlvs[index++], FAPI_BCH_PAYLOAD_TAG, \
- sizeof(uint8_t), macCfgParams.ssbCfg.bchPayloadFlag, &msgLen);
- fillTlvs(&configReq->tlvs[index++], FAPI_SCS_COMMON_TAG, \
- sizeof(uint8_t), macCfgParams.ssbCfg.scsCmn, &msgLen);
-
- /* fill PRACH configuration */
- fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SEQUENCE_LENGTH_TAG, \
- sizeof(uint8_t), macCfgParams.prachCfg.prachSeqLen, &msgLen);
- fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SUBC_SPACING_TAG, \
- sizeof(uint8_t), 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);
- if(macCfgParams.prachCfg.fdm[0].numUnusedRootSeq)
+ /* 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");
+ return RFAILED;
+ }
+ FILL_FAPI_LIST_ELEM(cfgReqQElem, vendorMsgQElem, FAPI_CONFIG_REQUEST, 1, \
+ sizeof(fapi_config_req_t));
+
+ configReq = (fapi_config_req_t *)(cfgReqQElem + 1);
+ memset(configReq, 0, sizeof(fapi_config_req_t));
+ fillMsgHeader(&configReq->header, FAPI_CONFIG_REQUEST, sizeof(fapi_config_req_t));
+ configReq->number_of_tlvs = 25;
+ msgLen = sizeof(configReq->number_of_tlvs);
+
+ if(macCfgParams.dlCarrCfg.pres)
+ {
+ fillTlvs(&configReq->tlvs[index++], FAPI_DL_BANDWIDTH_TAG, \
+ sizeof(uint32_t), macCfgParams.dlCarrCfg.bw, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_DL_FREQUENCY_TAG, \
+ sizeof(uint32_t), macCfgParams.dlCarrCfg.freq, &msgLen);
+ /* Due to bug in Intel FT code, commenting TLVs that are are not
+ * needed to avoid error. Must be uncommented when FT bug is fixed */
+ //fillTlvs(&configReq->tlvs[index++], FAPI_DL_K0_TAG, \
+ sizeof(uint16_t), macCfgParams.dlCarrCfg.k0[0], &msgLen);
+ //fillTlvs(&configReq->tlvs[index++], FAPI_DL_GRIDSIZE_TAG, \
+ sizeof(uint16_t), macCfgParams.dlCarrCfg.gridSize[0], &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_NUM_TX_ANT_TAG, \
+ sizeof(uint16_t), macCfgParams.dlCarrCfg.numAnt, &msgLen);
+ }
+ if(macCfgParams.ulCarrCfg.pres)
+ {
+ fillTlvs(&configReq->tlvs[index++], FAPI_UPLINK_BANDWIDTH_TAG, \
+ sizeof(uint32_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);
+
+ /* 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);
+
+ /* fill SSB configuration */
+ fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_POWER_TAG, \
+ sizeof(uint32_t), macCfgParams.ssbCfg.ssbPbchPwr, &msgLen);
+ //fillTlvs(&configReq->tlvs[index++], FAPI_BCH_PAYLOAD_TAG, \
+ sizeof(uint8_t), macCfgParams.ssbCfg.bchPayloadFlag, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_SCS_COMMON_TAG, \
+ sizeof(uint8_t), macCfgParams.ssbCfg.scsCmn, &msgLen);
+
+ /* fill PRACH configuration */
+ //fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SEQUENCE_LENGTH_TAG, \
+ sizeof(uint8_t), macCfgParams.prachCfg.prachSeqLen, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_SUBC_SPACING_TAG, \
+ sizeof(uint8_t), macCfgParams.prachCfg.prachSubcSpacing, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_RESTRICTED_SET_CONFIG_TAG, \
+ sizeof(uint8_t), macCfgParams.prachCfg.prachRstSetCfg, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_NUM_PRACH_FD_OCCASIONS_TAG,
+ sizeof(uint8_t), macCfgParams.prachCfg.msg1Fdm, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_CONFIG_INDEX_TAG,
+ sizeof(uint8_t), macCfgParams.prachCfg.prachCfgIdx, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ROOT_SEQUENCE_INDEX_TAG, \
+ sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].rootSeqIdx, &msgLen);
+ //fillTlvs(&configReq->tlvs[index++], FAPI_NUM_ROOT_SEQUENCES_TAG, \
+ sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numRootSeq, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_K1_TAG, \
+ sizeof(uint16_t), macCfgParams.prachCfg.fdm[0].k1, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_ZERO_CORR_CONF_TAG , \
+ sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].zeroCorrZoneCfg, &msgLen);
+ //fillTlvs(&configReq->tlvs[index++], FAPI_NUM_UNUSED_ROOT_SEQUENCES_TAG, \
+ sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].numUnusedRootSeq, &msgLen);
+ /* if(macCfgParams.prachCfg.fdm[0].numUnusedRootSeq)
{
- for(idx = 0; idx < macCfgParams.prachCfg.fdm[0].numUnusedRootSeq; idx++)
- fillTlvs(&configReq->tlvs[index++], FAPI_UNUSED_ROOT_SEQUENCES_TAG, \
- sizeof(uint8_t), macCfgParams.prachCfg.fdm[0].unsuedRootSeq[idx], \
- &msgLen);
+ 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);
-
- /* 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);
-
- /* fill measurement config */
- fillTlvs(&configReq->tlvs[index++], FAPI_RSSI_MEASUREMENT_TAG, \
- sizeof(uint8_t), macCfgParams.rssiUnit, &msgLen);
-
- /* fill DMRS Type A Pos */
- fillTlvs(&configReq->tlvs[index++], FAPI_DMRS_TYPE_A_POS_TAG, \
- sizeof(uint8_t), macCfgParams.dmrsTypeAPos, &msgLen);
-
- fillMsgHeader(&configReq->header, FAPI_CONFIG_REQUEST, \
- (sizeof(fapi_config_req_t) - sizeof(fapi_msg_t)));
-
- DU_LOG("\nLWR_MAC: Sending Config Request to Phy");
- LwrMacSendToPhy(configReq->header.msg_id, sizeof(fapi_config_req_t), (void *)configReq);
- }
- else
- {
- DU_LOG("\nLWR_MAC: Failed to allocate memory for config Request");
+ macCfgParams.prachCfg.fdm[0].unsuedRootSeq = NULL;
+ }*/
+
+ fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PER_RACH_TAG, \
+ sizeof(uint8_t), macCfgParams.prachCfg.ssbPerRach, &msgLen);
+ //fillTlvs(&configReq->tlvs[index++], FAPI_PRACH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, \
+ sizeof(uint8_t), macCfgParams.prachCfg.prachMultCarrBand, &msgLen);
+
+ /* fill SSB table */
+ fillTlvs(&configReq->tlvs[index++], FAPI_SSB_OFFSET_POINT_A_TAG, \
+ sizeof(uint16_t), macCfgParams.ssbCfg.ssbOffsetPointA, &msgLen);
+ //fillTlvs(&configReq->tlvs[index++], FAPI_BETA_PSS_TAG, \
+ sizeof(uint8_t), macCfgParams.ssbCfg.betaPss, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_SSB_PERIOD_TAG, \
+ sizeof(uint8_t), macCfgParams.ssbCfg.ssbPeriod, &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_SSB_SUBCARRIER_OFFSET_TAG, \
+ sizeof(uint8_t), macCfgParams.ssbCfg.ssbScOffset, &msgLen);
+
+ setMibPdu(macCfgParams.ssbCfg.mibPdu, &mib, 0);
+ fillTlvs(&configReq->tlvs[index++], FAPI_MIB_TAG , \
+ sizeof(uint32_t), mib, &msgLen);
+
+ fillTlvs(&configReq->tlvs[index++], FAPI_SSB_MASK_TAG, \
+ sizeof(uint32_t), macCfgParams.ssbCfg.ssbMask[0], &msgLen);
+ fillTlvs(&configReq->tlvs[index++], FAPI_BEAM_ID_TAG, \
+ sizeof(uint8_t), macCfgParams.ssbCfg.beamId[0], &msgLen);
+ //fillTlvs(&configReq->tlvs[index++], FAPI_SS_PBCH_MULTIPLE_CARRIERS_IN_A_BAND_TAG, \
+ sizeof(uint8_t), macCfgParams.ssbCfg.multCarrBand, &msgLen);
+ //fillTlvs(&configReq->tlvs[index++], FAPI_MULTIPLE_CELLS_SS_PBCH_IN_A_CARRIER_TAG, \
+ sizeof(uint8_t), macCfgParams.ssbCfg.multCellCarr, &msgLen);
+
+ /* 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);
+
+ /* fill measurement config */
+ //fillTlvs(&configReq->tlvs[index++], FAPI_RSSI_MEASUREMENT_TAG, \
+ sizeof(uint8_t), macCfgParams.rssiUnit, &msgLen);
+
+ /* fill DMRS Type A Pos */
+ fillTlvs(&configReq->tlvs[index++], FAPI_DMRS_TYPE_A_POS_TAG, \
+ sizeof(uint8_t), macCfgParams.dmrsTypeAPos, &msgLen);
+
+ /* 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 vendor msg in config req");
return RFAILED;
}
+ FILL_FAPI_LIST_ELEM(headerElem, cfgReqQElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \
+ sizeof(fapi_msg_header_t));
+ msgHeader = (fapi_msg_header_t *)(headerElem + 1);
+ msgHeader->num_msg = 2; /* Config req msg and vendor specific msg */
+ msgHeader->handle = 0;
+
+ DU_LOG("\nLWR_MAC: Sending Config Request to Phy");
+ LwrMacSendToFapi(headerElem);
#endif
return ROK;
uint8_t lwr_mac_procStartReqEvt(void *msg)
{
#ifdef INTEL_FAPI
- uint32_t msgLen = 0;
+ fapi_msg_header_t *msgHeader;
fapi_start_req_t *startReq;
+ fapi_vendor_msg_t *vendorMsg;
+ p_fapi_api_queue_elem_t headerElem;
+ p_fapi_api_queue_elem_t startReqElem;
+ p_fapi_api_queue_elem_t vendorMsgElem;
- LWR_MAC_ALLOC(startReq, sizeof(fapi_start_req_t));
- if(startReq != NULL)
+ /* Allocte And fill Vendor msg */
+ LWR_MAC_ALLOC(vendorMsgElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_vendor_msg_t)));
+ if(!vendorMsgElem)
{
- memset(startReq, 0, sizeof(fapi_start_req_t));
- fillMsgHeader(&startReq->header, FAPI_START_REQUEST, msgLen);
+ DU_LOG("\nLWR_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));
+ vendorMsg = (fapi_vendor_msg_t *)(vendorMsgElem + 1);
+ 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 */
+#ifdef DEBUG_MODE
+ vendorMsg->start_req_vendor.count = 0;
+ vendorMsg->start_req_vendor.period = 1;
+#endif
- DU_LOG("\nLWR_MAC: Sending Start Request to PHY");
- LwrMacSendToPhy(startReq->header.msg_id, sizeof(fapi_start_req_t),\
- (void *)startReq);
+ /* Fill FAPI config req */
+ 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");
+ return RFAILED;
}
- else
+ FILL_FAPI_LIST_ELEM(startReqElem, vendorMsgElem, FAPI_START_REQUEST, 1, \
+ sizeof(fapi_start_req_t));
+
+ startReq = (fapi_start_req_t *)(startReqElem + 1);
+ memset(startReq, 0, sizeof(fapi_start_req_t));
+ fillMsgHeader(&startReq->header, FAPI_START_REQUEST, sizeof(fapi_start_req_t));
+
+ /* Fill message header */
+ LWR_MAC_ALLOC(headerElem, (sizeof(fapi_api_queue_elem_t) + sizeof(fapi_msg_header_t)));
+ if(!headerElem)
{
- DU_LOG("\nLWR_MAC: Failed to allocate memory for Start Request");
+ DU_LOG("\nLWR_MAC: Memory allocation failed for vendor msg in config req");
return RFAILED;
}
+ FILL_FAPI_LIST_ELEM(headerElem, startReqElem, FAPI_VENDOR_MSG_HEADER_IND, 1, \
+ sizeof(fapi_msg_header_t));
+ msgHeader = (fapi_msg_header_t *)(headerElem + 1);
+ msgHeader->num_msg = 2; /* Start req msg and vendor specific msg */
+ msgHeader->handle = 0;
+
+ /* Send to PHY */
+ DU_LOG("\nLWR_MAC: Sending Start Request to Phy");
+ LwrMacSendToFapi(headerElem);
#endif
return ROK;
} /* lwr_mac_procStartReqEvt */
return ROK;
}
-/*******************************************************************
- *
- * @brief Modifes the received mibPdu to uint32 bit
- * and stores it in MacCellCfg
- *
- * @details
- *
- * Function : setMibPdu
- *
- * Functionality:
- * -Sets the MibPdu
- *
- * @params[in] Pointer to mibPdu
- * pointer to modified value
- ******************************************************************/
-
-void setMibPdu(uint8_t *mibPdu, uint32_t *val, uint16_t sfn)
-{
- *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);
-}
-
#ifdef INTEL_FAPI
/*******************************************************************
*
dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = sib1PdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx;
dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = sib1PdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0];
dlDciPtr->beta_pdcch_1_0 = sib1PdcchInfo->dci.txPdcchPower.powerValue;
- dlDciPtr->powerControlOfssetSS = sib1PdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
+ dlDciPtr->powerControlOffsetSS = sib1PdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
/* Calculating freq domain resource allocation field value and size
* coreset0Size = Size of coreset 0
dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx;
dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = rarPdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0];
dlDciPtr->beta_pdcch_1_0 = rarPdcchInfo->dci.txPdcchPower.powerValue;
- dlDciPtr->powerControlOfssetSS = rarPdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
+ dlDciPtr->powerControlOffsetSS = rarPdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
/* Calculating freq domain resource allocation field value and size
* coreset0Size = Size of coreset 0
dlDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = pdcchInfo->dci.beamPdcchInfo.prg[0].pmIdx;
dlDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = pdcchInfo->dci.beamPdcchInfo.prg[0].beamIdx[0];
dlDciPtr->beta_pdcch_1_0 = pdcchInfo->dci.txPdcchPower.powerValue;
- dlDciPtr->powerControlOfssetSS = pdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
+ dlDciPtr->powerControlOffsetSS = pdcchInfo->dci.txPdcchPower.powerControlOffsetSS;
/* Calculating freq domain resource allocation field value and size
* coreset0Size = Size of coreset 0
dlTtiReqPdu->pdu.pdcch_pdu.cceRegMappingType = pdcchInfo->coresetCfg.cceRegMappingType;
dlTtiReqPdu->pdu.pdcch_pdu.regBundleSize = pdcchInfo->coresetCfg.regBundleSize;
dlTtiReqPdu->pdu.pdcch_pdu.interleaverSize = pdcchInfo->coresetCfg.interleaverSize;
- dlTtiReqPdu->pdu.pdcch_pdu.coreSetSize = pdcchInfo->coresetCfg.coreSetType;
dlTtiReqPdu->pdu.pdcch_pdu.shiftIndex = pdcchInfo->coresetCfg.shiftIndex;
dlTtiReqPdu->pdu.pdcch_pdu.precoderGranularity = pdcchInfo->coresetCfg.precoderGranularity;
dlTtiReqPdu->pdu.pdcch_pdu.numDlDci = pdcchInfo->numDlDci;
pduLen += sizeof(fapi_uint8_ptr_tlv_t); /* only 1 TLV is present */
pduDesc[pduIndex].pdu_length = pduLen;
-#ifndef INTEL_WLS
+#ifndef INTEL_WLS_MEM
MAC_FREE(sib1TxdataValue,macCellCfg->sib1Cfg.sib1PduLen);
#endif
/* 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
+#ifndef INTEL_WLS_MEM
MAC_FREE(rarTxdataValue,rarInfo->rarPduLen);
#endif
/* 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
+#ifndef INTEL_WLS_MEM
MAC_FREE(dedMsgTxDataValue, dlMsgInfo->dlMsgPduLen);
#endif
ulDciPtr->pc_and_bform.pmi_bfi[0].pmIdx = schDciInfo->dciInfo.beamPdcchInfo.prg[0].pmIdx;
ulDciPtr->pc_and_bform.pmi_bfi[0].beamIdx[0].beamidx = schDciInfo->dciInfo.beamPdcchInfo.prg[0].beamIdx[0];
ulDciPtr->beta_pdcch_1_0 = schDciInfo->dciInfo.txPdcchPower.powerValue;
- ulDciPtr->powerControlOfssetSS = schDciInfo->dciInfo.txPdcchPower.powerControlOffsetSS;
+ ulDciPtr->powerControlOffsetSS = schDciInfo->dciInfo.txPdcchPower.powerControlOffsetSS;
/* Calculating freq domain resource allocation field value and size
* coreset1Size = Size of coreset 1
ulDciReqPdu->pdcchPduConfig.cceRegMappingType = dlInfo->ulGrant->coresetCfg.cceRegMappingType;
ulDciReqPdu->pdcchPduConfig.regBundleSize = dlInfo->ulGrant->coresetCfg.regBundleSize;
ulDciReqPdu->pdcchPduConfig.interleaverSize = dlInfo->ulGrant->coresetCfg.interleaverSize;
- ulDciReqPdu->pdcchPduConfig.coreSetSize = dlInfo->ulGrant->coresetCfg.coreSetType;
ulDciReqPdu->pdcchPduConfig.shiftIndex = dlInfo->ulGrant->coresetCfg.shiftIndex;
ulDciReqPdu->pdcchPduConfig.precoderGranularity = dlInfo->ulGrant->coresetCfg.precoderGranularity;
ulDciReqPdu->pdcchPduConfig.numDlDci = 1;
#define CORESET_TYPE2 2
#define CORESET_TYPE3 3
+#define FILL_FAPI_LIST_ELEM(_currElem, _nextElem, _msgType, _numMsgInBlock, _alignOffset)\
+{\
+ _currElem->msg_type = (uint8_t) _msgType;\
+ _currElem->num_message_in_block = _numMsgInBlock;\
+ _currElem->align_offset = (uint16_t) _alignOffset;\
+ _currElem->msg_len = _numMsgInBlock * _alignOffset;\
+ _currElem->p_next = _nextElem;\
+ _currElem->p_tx_data_elm_list = NULL;\
+ _currElem->time_stamp = 0;\
+}
+
typedef enum{
SI_RNTI_TYPE,
RA_RNTI_TYPE,
#include "lrg.h"
#ifdef INTEL_FAPI
#include "fapi.h"
+#include "fapi_vendor_extension.h"
#endif
/* header/extern include files (.x) */
#ifdef INTEL_FAPI
/* Function pointer for slot indication from lower mac to mac */
-packSlotIndMsg packSlotIndOpts[] =
+SlotIndFunc sendSlotIndOpts[] =
{
- packLcSlotInd, /* packing for loosely coupled */
+ packSlotInd, /* packing for loosely coupled */
fapiMacSlotInd, /* packing for tightly coupled */
- packLwlcSlotInd /* packing for light weight loosly coupled */
+ packSlotInd /* packing for light weight loosly coupled */
};
/* Function pointer for rach indication from lower mac to mac */
-packRachIndMsg sendRachIndOpts[] =
+RachIndFunc sendRachIndOpts[] =
{
packRachInd,
fapiMacRachInd,
};
/* Function pointer for crc indication from lower mac to mac */
-packCrcIndMsg sendCrcIndOpts[] =
+CrcIndFunc sendCrcIndOpts[] =
{
packCrcInd,
fapiMacCrcInd,
};
/* Function pointer for Rx Data indication from lower mac to mac */
-packRxDataIndMsg sendRxDataIndOpts[] =
+RxDataIndFunc sendRxDataIndOpts[] =
{
packRxDataInd,
fapiMacRxDataInd,
};
/* Function pointer for stop indication from lower mac to mac */
-packStopIndMsg sendStopIndOpts[] =
+StopIndFunc sendStopIndOpts[] =
{
packStopInd,
fapiMacStopInd,
};
/* Function pointer for Uci indication from lower mac to mac */
-packMacUciIndMsg sendUciIndOpts[] =
+UciIndFunc sendUciIndOpts[] =
{
- packMacUciInd,
+ packUciInd,
FapiMacUciInd,
- packMacUciInd
+ packUciInd
};
/*******************************************************************
/* fill Pst structure to send to lwr_mac to MAC */
Pst pst;
uint16_t ret;
- SlotIndInfo slotInd;
+ SlotIndInfo *slotInd;
- FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_SLOT_IND_TO_MAC);
-
- slotInd.cellId = lwrMacCb.cellCb[0].cellId;
- slotInd.sfn = fapiSlotInd->sfn;
- slotInd.slot = fapiSlotInd->slot;
+ MAC_ALLOC_SHRABL_BUF(slotInd, sizeof(SlotIndInfo));
+ if(slotInd)
+ {
+ slotInd->cellId = lwrMacCb.cellCb[0].cellId;
+ slotInd->sfn = fapiSlotInd->sfn;
+ slotInd->slot = fapiSlotInd->slot;
- ret = (*packSlotIndOpts[pst.selector])(&pst, &slotInd);
+ FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_SLOT_IND_TO_MAC);
+ ret = (*sendSlotIndOpts[pst.selector])(&pst, slotInd);
+ }
+ else
+ {
+ printf("\nLWR_MAC: Memory allocation failed in procSlotInd");
+ ret = RFAILED;
+ }
-#ifdef INTEL_WLS
+#ifdef INTEL_WLS_MEM
slotIndIdx++;
if(slotIndIdx > WLS_MEM_FREE_PRD)
{
}
freeWlsBlockList(slotIndIdx - 1);
#endif
-
return ret;
}
* ****************************************************************/
uint8_t procStopInd()
{
- uint8_t ret;
Pst pst;
+ uint16_t *cellId = NULLP;
+
+ MAC_ALLOC_SHRABL_BUF(cellId, sizeof(uint16_t));
+ if(!cellId)
+ {
+ printf("\nLWR_MAC: Memory Allocation failed in procStopInd");
+ return RFAILED;
+ }
+ *cellId = lwrMacCb.cellCb[0].cellId;
lwrMacCb.phyState = PHY_STATE_CONFIGURED;
lwrMacCb.cellCb[0].state = PHY_STATE_CONFIGURED;
DU_LOG("\nLWR_MAC: PHY has moved to configured state");
FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_STOP_IND_TO_MAC);
-
- ret = (*sendStopIndOpts[pst.selector])(&pst, \
- lwrMacCb.cellCb[0].cellId);
- return ret;
+ return (*sendStopIndOpts[pst.selector])(&pst, cellId);
}
+
/*******************************************************************
*
* @brief Processes Rach Indication from PHY and sends to MAC
Pst pst;
uint8_t pduIdx;
uint8_t prmbleIdx;
- RachPduInfo *rachPdu;
- RachInd rachInd;
-
- rachInd.cellId = lwrMacCb.cellCb[0].cellId;
- rachInd.timingInfo.sfn = fapiRachInd->sfn;
- rachInd.timingInfo.slot = fapiRachInd->slot;
- rachInd.numPdu = fapiRachInd->numPdus;
- for(pduIdx=0; pduIdx < rachInd.numPdu; pduIdx++)
+ RachPduInfo *rachPdu = NULLP;
+ RachInd *rachInd = NULLP;
+
+ MAC_ALLOC_SHRABL_BUF(rachInd, sizeof(RachInd));
+ if(!rachInd)
+ {
+ printf("\nLWR_MAC: Memory Allocation failed in procRachInd");
+ return RFAILED;
+ }
+
+ rachInd->cellId = lwrMacCb.cellCb[0].cellId;
+ rachInd->timingInfo.sfn = fapiRachInd->sfn;
+ rachInd->timingInfo.slot = fapiRachInd->slot;
+ rachInd->numPdu = fapiRachInd->numPdus;
+ for(pduIdx=0; pduIdx < rachInd->numPdu; pduIdx++)
{
- rachPdu = &rachInd.rachPdu[pduIdx];
+ rachPdu = &rachInd->rachPdu[pduIdx];
rachPdu->pci = fapiRachInd->rachPdu[pduIdx].phyCellId;
rachPdu->symbolIdx = fapiRachInd->rachPdu[pduIdx].symbolIndex;
rachPdu->slotIdx = fapiRachInd->rachPdu[pduIdx].slotIndex;
fapiRachInd->rachPdu[pduIdx].preambleInfo[prmbleIdx].timingAdvance;
}
}
- FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_RACH_IND_TO_MAC);
- (*sendRachIndOpts[pst.selector])(&pst, &rachInd);
- return ROK;
+ /* Fill post and sent to MAC */
+ FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_RACH_IND_TO_MAC);
+ return (*sendRachIndOpts[pst.selector])(&pst, rachInd);
}/* handleRachInd */
Pst pst;
uint8_t crcInfoIdx;
uint8_t crcStatusIdx;
- CrcInfo *crcIndInfo;
- CrcInd crcInd;
+ CrcInfo *crcIndInfo = NULLP;
+ CrcInd *crcInd = NULLP;
+
+ MAC_ALLOC_SHRABL_BUF(crcInd, sizeof(CrcInd));
+ if(!crcInd)
+ {
+ printf("\nLWR_MAC: Memory Allocation failed in procCrcInd");
+ return RFAILED;
+ }
- crcInd.cellId = lwrMacCb.cellCb[0].cellId;
- crcInd.timingInfo.sfn = fapiCrcInd->sfn;
- crcInd.timingInfo.slot = fapiCrcInd->slot;
- crcInd.numCrc = fapiCrcInd->numCrcs;
+ crcInd->cellId = lwrMacCb.cellCb[0].cellId;
+ crcInd->timingInfo.sfn = fapiCrcInd->sfn;
+ crcInd->timingInfo.slot = fapiCrcInd->slot;
+ crcInd->numCrc = fapiCrcInd->numCrcs;
- for(crcInfoIdx = 0; crcInfoIdx < crcInd.numCrc; crcInfoIdx++)
+ for(crcInfoIdx = 0; crcInfoIdx < crcInd->numCrc; crcInfoIdx++)
{
- crcIndInfo = &crcInd.crcInfo[crcInfoIdx];
+ crcIndInfo = &crcInd->crcInfo[crcInfoIdx];
crcIndInfo->handle = fapiCrcInd->crc[crcInfoIdx].handle;
crcIndInfo->rnti = fapiCrcInd->crc[crcInfoIdx].rnti;
crcIndInfo->harqId = fapiCrcInd->crc[crcInfoIdx].harqId;
crcIndInfo->rssi = fapiCrcInd->crc[crcInfoIdx].rssi;
}
+ /* Fill post and sent to MAC */
FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_CRC_IND_TO_MAC);
-
- (*sendCrcIndOpts[pst.selector])(&pst, &crcInd);
- return ROK;
-
+ return (*sendCrcIndOpts[pst.selector])(&pst, crcInd);
} /* handleCrcInd */
/*******************************************************************
{
Pst pst;
uint8_t pduIdx;
- RxDataInd rxDataInd;
- RxDataIndPdu *pdu;
+ RxDataInd *rxDataInd = NULLP;
+ RxDataIndPdu *pdu = NULLP;
- rxDataInd.cellId = lwrMacCb.cellCb[0].cellId;
- rxDataInd.timingInfo.sfn = fapiRxDataInd->sfn;
- rxDataInd.timingInfo.slot = fapiRxDataInd->slot;
- rxDataInd.numPdus = fapiRxDataInd->numPdus;
+ MAC_ALLOC_SHRABL_BUF(rxDataInd, sizeof(RxDataInd));
+ if(!rxDataInd)
+ {
+ printf("\nLWR_MAC: Memory Allocation failed in procRxDataInd");
+ return RFAILED;
+ }
+
+ rxDataInd->cellId = lwrMacCb.cellCb[0].cellId;
+ rxDataInd->timingInfo.sfn = fapiRxDataInd->sfn;
+ rxDataInd->timingInfo.slot = fapiRxDataInd->slot;
+ rxDataInd->numPdus = fapiRxDataInd->numPdus;
- for(pduIdx = 0; pduIdx < rxDataInd.numPdus; pduIdx++)
+ for(pduIdx = 0; pduIdx < rxDataInd->numPdus; pduIdx++)
{
- pdu = &rxDataInd.pdus[pduIdx];
+ pdu = &rxDataInd->pdus[pduIdx];
pdu->handle = fapiRxDataInd->pdus[pduIdx].handle;
pdu->rnti = fapiRxDataInd->pdus[pduIdx].rnti;
pdu->harqId = fapiRxDataInd->pdus[pduIdx].harqId;
pdu->timingAdvance = fapiRxDataInd->pdus[pduIdx].timingAdvance;
pdu->rssi = fapiRxDataInd->pdus[pduIdx].rssi;
- MAC_ALLOC(pdu->pduData, pdu->pduLength);
+ MAC_ALLOC_SHRABL_BUF(pdu->pduData, pdu->pduLength);
memcpy(pdu->pduData, fapiRxDataInd->pdus[pduIdx].pduData, pdu->pduLength);
}
+ /* Fill post and sent to MAC */
FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_RX_DATA_IND_TO_MAC);
-
- (*sendRxDataIndOpts[pst.selector])(&pst, &rxDataInd);
- return ROK;
+ return (*sendRxDataIndOpts[pst.selector])(&pst, rxDataInd);
}
/*******************************************************************
pduInfo->crnti = fapiPduInfo->rnti;
pduInfo->timingAdvance = fapiPduInfo->timingAdvance;
pduInfo->rssi = fapiPduInfo->rssi;
- memcpy(pduInfo->uciBits, fapiPduInfo->uciBits, MAX_UCI_BIT_PER_TTI_IN_BYTES);
if(fapiPduInfo->srInfo.srIndication)
{
pduInfo->srInfo.srIndPres = fapiPduInfo->srInfo.srIndication;
pduInfo->srInfo.srConfdcLevel = fapiPduInfo->srInfo.srConfidenceLevel;
-
}
if(fapiPduInfo->harqInfo.numHarq)
{
uint8_t pduIdx;
uint8_t ret = ROK;
Pst pst;
- memset(&pst, 0, sizeof(Pst));
- UciInd macUciInd;
- memset(&macUciInd, 0, sizeof(UciInd));
+ UciInd *macUciInd = NULLP;
+
+ MAC_ALLOC_SHRABL_BUF(macUciInd, sizeof(UciInd));
+ if(!macUciInd)
+ {
+ printf("\nLWR_MAC: Memory Allocation failed in procUciInd");
+ return RFAILED;
+ }
- macUciInd.cellId = lwrMacCb.cellCb[0].cellId;
- macUciInd.slotInd.sfn = fapiUciInd->sfn;
- macUciInd.slotInd.slot = fapiUciInd->slot;
- macUciInd.numUcis = fapiUciInd->numUcis;
+ memset(macUciInd, 0, sizeof(UciInd));
+ macUciInd->cellId = lwrMacCb.cellCb[0].cellId;
+ macUciInd->slotInd.sfn = fapiUciInd->sfn;
+ macUciInd->slotInd.slot = fapiUciInd->slot;
+ macUciInd->numUcis = fapiUciInd->numUcis;
- for(pduIdx = 0; pduIdx < macUciInd.numUcis; pduIdx++)
+ for(pduIdx = 0; pduIdx < macUciInd->numUcis; pduIdx++)
{
- macUciInd.pdus[pduIdx].pduType = fapiUciInd->uciPdu[pduIdx].pduType;
- switch(macUciInd.pdus[pduIdx].pduType)
+ macUciInd->pdus[pduIdx].pduType = fapiUciInd->uciPdu[pduIdx].pduType;
+ switch(macUciInd->pdus[pduIdx].pduType)
{
case UCI_IND_PUSCH:
break;
case UCI_IND_PUCCH_F0F1:
{
UciPucchF0F1 *pduInfo = NULLP;
- macUciInd.pdus[pduIdx].pduSize = fapiUciInd->uciPdu[pduIdx].pduSize;
- pduInfo = &macUciInd.pdus[pduIdx].uci.uciPucchF0F1;
+ macUciInd->pdus[pduIdx].pduSize = fapiUciInd->uciPdu[pduIdx].pduSize;
+ pduInfo = &macUciInd->pdus[pduIdx].uci.uciPucchF0F1;
ret = fillUciIndPucchF0F1(pduInfo, &fapiUciInd->uciPdu[pduIdx].uci.uciPucchF0F1);
}
break;
case UCI_IND_PUCCH_F2F3F4:
break;
default:
- DU_LOG("\nLWR_MAC: Invalid Pdu Type %d at procmacUciInd()", macUciInd.pdus[pduIdx].pduType);
+ DU_LOG("\nLWR_MAC: Invalid Pdu Type %d at procmacUciInd()", macUciInd->pdus[pduIdx].pduType);
ret = RFAILED;
break;
}
if(!ret)
{
FILL_PST_LWR_MAC_TO_MAC(pst, EVENT_UCI_IND_TO_MAC);
- ret = (*sendUciIndOpts[pst.selector])(&pst, &macUciInd);
+ ret = (*sendUciIndOpts[pst.selector])(&pst, macUciInd);
}
else
{
}
#endif /* FAPI */
+/*******************************************************************
+ *
+ * @brief Processes message from PHY
+ *
+ * @details
+ *
+ * Function : procPhyMessages
+ *
+ * Functionality: Processes message from PHY
+ *
+ * @params[in]
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
void procPhyMessages(uint16_t msgType, uint32_t msgSize, void *msg)
{
#ifdef INTEL_FAPI
switch(header->msg_id)
{
case FAPI_PARAM_RESPONSE:
+ {
+ sendToLowerMac(PARAM_RESPONSE, msgSize, msg);
+ break;
+ }
case FAPI_CONFIG_RESPONSE:
{
- sendToLowerMac(msgType, msgSize, msg);
+ sendToLowerMac(CONFIG_RESPONSE, msgSize, msg);
break;
}
case FAPI_SLOT_INDICATION:
break;
}
}
-#ifdef INTEL_WLS
- WLS_MEM_FREE(msg, LWR_MAC_WLS_BUF_SIZE);
-#endif
#endif
}
#include "lwr_mac_phy.h"
#include "lwr_mac_fsm.h"
#include "mac_utils.h"
-
-#ifdef INTEL_WLS
+#include "lwr_mac_utils.h"
+#ifdef INTEL_FAPI
+#include "fapi.h"
+#include "fapi_vendor_extension.h"
+#endif
+#ifdef INTEL_WLS_MEM
#include "wls_lib.h"
#endif
uint8_t rgClHndlCfgReq ARGS((void *msg));
void l1ProcessFapiRequest ARGS((uint8_t msgType, uint32_t msgLen, void *msg));
-#ifdef INTEL_WLS
+#ifdef INTEL_WLS_MEM
+
+/*******************************************************************
+ *
+ * @brief Sends request to start wls receiver thread
+ *
+ * @details
+ *
+ * Function : LwrMacStartWlsRcvr
+ *
+ * Functionality:
+ * Sends request to start wls receiver thread
+ *
+ * @params[in]
+ * @return void
+ *
+ * ****************************************************************/
+void LwrMacStartWlsRcvr()
+{
+ Pst pst;
+ Buffer *mBuf;
+
+ DU_LOG("\nLWR MAC: Requesting to start WLS receiver thread");
+
+ /* Filling post */
+ memset(&pst, 0, sizeof(Pst));
+ FILL_PST_LWR_MAC_TO_LWR_MAC(pst, EVT_START_WLS_RCVR);
+
+ if (ODU_GET_MSG_BUF(pst.region, pst.pool, &mBuf) != ROK)
+ {
+ DU_LOG("\nLWR MAC : Memory allocation failed for LwrMacStartWlsRcvr");
+ return;
+ }
+
+ ODU_POST_TASK(&pst, mBuf);
+}
/*******************************************************************
*
void LwrMacEnqueueWlsBlock()
{
void *memPtr;
- void *wlsHdlr;
+ void *wlsHdlr = NULLP;
WLS_MEM_ALLOC(memPtr, LWR_MAC_WLS_BUF_SIZE);
if(memPtr)
{
- wlsHdlr = mtGetWlsHdl();
-
+ mtGetWlsHdl(&wlsHdlr);
/* allocate blocks for UL transmittion */
while(WLS_EnqueueBlock(wlsHdlr, WLS_VA2PA(wlsHdlr, memPtr)))
{
}
}/* LwrMacEnqueueWlsBlock */
-/*******************************************************************
- *
- * @brief Enqueue N number of blocks
- *
- * @details
- *
- * Function : enqueueNBlocks
- *
- * Functionality:
- * Enqueue N number of memory blocks
- *
- * @params[in] Number of blocks
- * @return ROK - success
- * RFAILED - failure
- *
- * ****************************************************************/
-uint16_t enqueueNBlocks(uint32_t numBlocks)
-{
- void *memPtr;
- void *wlsHdlr; /* WLS handler */
-
- wlsHdlr = mtGetWlsHdl();
- while(numBlocks)
- {
- numBlocks--;
-
- memPtr = (void *)NULL;
- WLS_MEM_ALLOC(memPtr, LWR_MAC_WLS_BUF_SIZE);
- if(memPtr)
- {
- WLS_EnqueueBlock(wlsHdlr, WLS_VA2PA(wlsHdlr, memPtr));
- }
- }
- return ROK;
-}/* enqueueNBlocks */
-
/*******************************************************************
*
* @brief Add memory block (to be freed later) to list
}
}/* addWlsBlockToFree */
+
+/*******************************************************************
+ *
+ * @brief Free DL Memory blocks stored in list
+ *
+ * @details
+ *
+ * Function : freeWlsBlockList
+ *
+ * Functionality: Free DL Memory blocks stored in list
+ *
+ * @params[in] Array index to be freed
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
void freeWlsBlockList(uint8_t idx)
{
CmLList *node;
* ****************************************************************/
void LwrMacRecvPhyMsg()
{
- uint32_t numL1Msg; /* Number of L1 messaes received */
- uint32_t numToGet; /* Number of Memory blocks to get */
+#ifdef INTEL_FAPI
+ uint32_t numMsgToGet; /* Number of Memory blocks to get */
void *wlsHdlr; /* WLS handler */
uint64_t l1Msg; /* Message received */
void *l1MsgPtr;
uint32_t msgSize;
uint16_t msgType;
- uint16_t flag;
+ uint16_t flag = 0;
+ p_fapi_api_queue_elem_t currElem = NULLP;
+ struct timeval time;
- wlsHdlr = mtGetWlsHdl();
- if(WLS_Ready(wlsHdlr))
+ mtGetWlsHdl(&wlsHdlr);
+ if(WLS_Ready(wlsHdlr) == 0)
{
- numToGet = WLS_Wait(wlsHdlr);
-
- numL1Msg = numToGet;
-
- while(numToGet)
+ while(true)
{
- l1Msg = (uint64_t) NULL;
- l1Msg = WLS_Get(wlsHdlr, &msgSize, &msgType, &flag);
- if(l1Msg)
+ numMsgToGet = WLS_Wait(wlsHdlr);
+ if(numMsgToGet == 0)
{
- l1MsgPtr = WLS_PA2VA(wlsHdlr, l1Msg);
- procPhyMessages(msgType, msgSize, l1MsgPtr);
+ continue;
}
- numToGet--;
- }
- if(numL1Msg)
- {
- enqueueNBlocks(numL1Msg);
+ printf("\nLWR_MAC: numMsgToGet %d", numMsgToGet);
+ while(numMsgToGet--)
+ {
+ currElem = NULLP;
+ l1Msg = (uint64_t)NULLP;
+ l1MsgPtr = NULLP;
+ l1Msg = WLS_Get(wlsHdlr, &msgSize, &msgType, &flag);
+ if(l1Msg)
+ {
+ l1MsgPtr = WLS_PA2VA(wlsHdlr, l1Msg);
+ currElem = (p_fapi_api_queue_elem_t) l1MsgPtr;
+ if(currElem->msg_type != FAPI_VENDOR_MSG_HEADER_IND)
+ {
+ procPhyMessages(currElem->msg_type, 0, (void *)(currElem + 1));
+ }
+ WLS_MEM_FREE(currElem, LWR_MAC_WLS_BUF_SIZE);
+ }
+ }
+ LwrMacEnqueueWlsBlock();
}
-
}
+#endif
} /* LwrMacRecvPhyMsg */
-#endif /* INTEL_WLS */
+#endif /* INTEL_WLS_MEM */
/*******************************************************************
*
- * @brief Sends message to PHY
+ * @brief Sends message to PHY Stub
*
* @details
*
* Function : LwrMacSendToPhy
* Functionality:
- * -Sends message to PHY
+ * -Sends message to PHY Stub
+ * -Once super header and vendor specific message is
+ * implemented for all FAPI messages, this function
+ * can be deleted. LwrMacSendToFapi() should be used.
*
* @params[in] Message Type
* Message Length
uint8_t LwrMacSendToPhy(uint8_t msgType, uint32_t msgLen, void *msg)
{
-#ifdef INTEL_WLS
- uint8_t ret;
- unsigned long long pMsg;
+ l1ProcessFapiRequest(msgType, msgLen, msg);
+ return ROK;
+} /* LwrMacSendToPhy */
- pMsg = WLS_VA2PA(mtGetWlsHdl(), msg);
- ret = WLS_Put(mtGetWlsHdl(), pMsg, msgLen, msgType, 0);
- if(ret != 0)
+/*******************************************************************
+ *
+ * @brief Send FAPI messages to Intel PHY/Phy stub
+ *
+ * @details
+ *
+ * Function : LwrMacSendToFapi
+ *
+ * Functionality: Send FAPI messages to Intel PHY/Phy stub
+ *
+ * @params[in] Message pointer
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t LwrMacSendToFapi(void *msg)
+{
+ uint8_t ret = ROK;
+#ifdef INTEL_FAPI
+ uint16_t msgLen;
+ p_fapi_api_queue_elem_t currMsg = NULLP;
+
+#ifdef INTEL_WLS_MEM
+ void * wlsHdlr = NULLP;
+
+ mtGetWlsHdl(&wlsHdlr);
+ if(msg)
{
- printf("\nFailure in sending message to PHY");
- WLS_MEM_FREE(msg, msgLen);
- return RFAILED;
+ currMsg = (p_fapi_api_queue_elem_t)msg;
+ msgLen = currMsg->msg_len + sizeof(fapi_api_queue_elem_t);
+ addWlsBlockToFree(currMsg, msgLen, (slotIndIdx-1));
+ if(currMsg->p_next == NULLP)
+ {
+ DU_LOG("\nThere cannot be only one block to send");
+ return RFAILED;
+ }
+
+ /* Sending first block */
+ ret = WLS_Put(wlsHdlr, WLS_VA2PA(wlsHdlr, currMsg), msgLen, currMsg->msg_type, WLS_SG_FIRST);
+ if(ret != 0)
+ {
+ DU_LOG("\nFailure in sending message to PHY");
+ return RFAILED;
+ }
+ currMsg = currMsg->p_next;
+
+ while(currMsg)
+ {
+ /* Sending the next msg */
+ msgLen = currMsg->msg_len + sizeof(fapi_api_queue_elem_t);
+ addWlsBlockToFree(currMsg, msgLen, (slotIndIdx-1));
+ if(currMsg->p_next != NULLP)
+ {
+ ret = WLS_Put(wlsHdlr, WLS_VA2PA(wlsHdlr, currMsg), msgLen, currMsg->msg_type, WLS_SG_NEXT);
+ if(ret != 0)
+ {
+ DU_LOG("\nFailure in sending message to PHY");
+ return RFAILED;
+ }
+ currMsg = currMsg->p_next;
+ }
+ else
+ {
+ /* Sending last msg */
+ ret = WLS_Put(wlsHdlr, WLS_VA2PA(wlsHdlr, currMsg), msgLen, currMsg->msg_type, WLS_SG_LAST);
+ if(ret != 0)
+ {
+ DU_LOG("\nFailure in sending message to PHY");
+ return RFAILED;
+ }
+ currMsg = NULLP;
+ }
+ }
}
- else
+#else
+ p_fapi_api_queue_elem_t nextMsg = NULLP;
+
+ /* FAPI header and vendor specific msgs are freed here. Only
+ * the main FAPI messages are sent to phy stub */
+ currMsg = (p_fapi_api_queue_elem_t)msg;
+ while(currMsg)
{
- addWlsBlockToFree(msg, msgLen, (slotIndIdx-1));
+ nextMsg = currMsg->p_next;
+ msgLen = currMsg->msg_len + sizeof(fapi_api_queue_elem_t);
+ if((currMsg->msg_type != FAPI_VENDOR_MSG_HEADER_IND) && \
+ (currMsg->msg_type != FAPI_VENDOR_MESSAGE))
+ {
+ l1ProcessFapiRequest(currMsg->msg_type, msgLen, currMsg);
+ }
+ else
+ {
+ MAC_FREE(currMsg, msgLen);
+ }
+ currMsg = nextMsg;
}
-#else
- l1ProcessFapiRequest(msgType, msgLen, msg);
#endif
- return ROK;
-} /* LwrMacSendToPhy */
+#endif
+ return ret;
+}
/**********************************************************************
End of file
MSG_TX_ERR
}ErrorCode;
-#ifdef INTEL_WLS
+#ifdef INTEL_WLS_MEM
#define WLS_MEM_FREE_PRD 10 /* Free memory after 10 slot ind */
-#define LWR_MAC_WLS_BUF_SIZE 8192 /* Size of WLS memory block */
+#define LWR_MAC_WLS_BUF_SIZE 32000 /* Size of WLS memory block */
+#define EVT_START_WLS_RCVR 1
/* allocate static buffer from WLS memory */
#define WLS_MEM_ALLOC(_datPtr, _size) \
void freeWlsBlockList(uint8_t idx);
void LwrMacEnqueueWlsBlock();
-#endif /* INTEL_WLS */
+void LwrMacRecvPhyMsg();
+void LwrMacStartWlsRcvr();
+#endif /* INTEL_WLS_MEM */
+uint8_t LwrMacSendToFapi(void *msg);
uint8_t LwrMacSendToPhy(uint8_t msgType, uint32_t msgLen, void *msg);
#endif
* ****************************************************************/
uint8_t packCrcInd(Pst *pst, CrcInd *crcInd)
{
- if((pst->selector == ODU_SELECTOR_LC) || (pst->selector == ODU_SELECTOR_LWLC))
+ if(pst->selector == ODU_SELECTOR_LWLC)
{
- return ROK;
+ Buffer *mBuf = NULLP;
+ if(ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
+ {
+ printf("\nLWR_MAC: Memory allocation failed in packCrcInd");
+ return RFAILED;
+ }
+ CMCHKPK(oduPackPointer,(PTR)crcInd, mBuf);
+ return ODU_POST_TASK(pst, mBuf);
}
return RFAILED;
}
+/**************************************************************************
+ * @brief Function unpack crcInd
+ *
+ * @details
+ *
+ * Function : unpackCrcInd
+ *
+ * Functionality:
+ * unpacks crc indication
+ *
+ * @param[in] function pointer
+ * @param[in] Pst *pst, Post structure of the primitive.
+ * @param[in] Buffer *mBuf
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ***************************************************************************/
+uint8_t unpackCrcInd(CrcIndFunc func, Pst *pst, Buffer *mBuf)
+{
+ if(pst->selector == ODU_SELECTOR_LWLC)
+ {
+ CrcInd *crcInd = NULLP;
+
+ /* unpack the address of the structure */
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&crcInd, mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
+ return (*func)(pst, crcInd);
+ }
+ return RFAILED;
+}
+
+
/*******************************************************************
*
* @brief Packs and Sends Rx Data Ind to MAC
* ****************************************************************/
uint8_t packRxDataInd(Pst *pst, RxDataInd *rxDataInd)
{
- if((pst->selector == ODU_SELECTOR_LC) || (pst->selector == ODU_SELECTOR_LWLC))
+ if(pst->selector == ODU_SELECTOR_LWLC)
{
- return ROK;
+ Buffer *mBuf = NULLP;
+ if(ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
+ {
+ printf("\nLWR_MAC: Memory allocation failed in packRxDataInd");
+ return RFAILED;
+ }
+ CMCHKPK(oduPackPointer,(PTR)rxDataInd, mBuf);
+ return ODU_POST_TASK(pst, mBuf);
+ }
+ return RFAILED;
+}
+
+/**************************************************************************
+ * @brief Function unpack RxDataInd
+ *
+ * @details
+ *
+ * Function : unpackRxDataInd
+ *
+ * Functionality:
+ * unpacks Rx Data indication
+ *
+ * @param[in] function pointer
+ * @param[in] Pst *pst, Post structure of the primitive.
+ * @param[in] Buffer *mBuf
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ***************************************************************************/
+uint8_t unpackRxDataInd(RxDataIndFunc func, Pst *pst, Buffer *mBuf)
+{
+ if(pst->selector == ODU_SELECTOR_LWLC)
+ {
+ RxDataInd *rxDataInd = NULLP;
+
+ /* unpack the address of the structure */
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&rxDataInd, mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
+ return (*func)(pst, rxDataInd);
}
return RFAILED;
}
* ****************************************************************/
uint8_t packRachInd(Pst *pst, RachInd *rachInd)
{
- if((pst->selector == ODU_SELECTOR_LC) || (pst->selector == ODU_SELECTOR_LWLC))
+ if(pst->selector == ODU_SELECTOR_LWLC)
{
- return ROK;
+ Buffer *mBuf = NULLP;
+ if(ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
+ {
+ printf("\nLWR_MAC: Memory allocation failed in packRachInd");
+ return RFAILED;
+ }
+ CMCHKPK(oduPackPointer,(PTR)rachInd, mBuf);
+ return ODU_POST_TASK(pst, mBuf);
+ }
+ return RFAILED;
+}
+
+/**************************************************************************
+ * @brief Function unpacks RachInd
+ *
+ * @details
+ *
+ * Function : unpackRachInd
+ *
+ * Functionality:
+ * unpacks Rach indication
+ *
+ * @param[in] function pointer
+ * @param[in] Pst *pst, Post structure of the primitive.
+ * @param[in] Buffer *mBuf
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ***************************************************************************/
+uint8_t unpackRachInd(RachIndFunc func, Pst *pst, Buffer *mBuf)
+{
+ if(pst->selector == ODU_SELECTOR_LWLC)
+ {
+ RachInd *rachInd = NULLP;
+
+ /* unpack the address of the structure */
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&rachInd, mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
+ return (*func)(pst, rachInd);
}
return RFAILED;
}
/*******************************************************************
*
- * @brief Loose coupled packing of slot indication
+ * @brief Pack and send slot indication to MAC
*
* @details
*
- * Function : packLcSlotInd
+ * Function : packSlotInd
*
* Functionality:
- * Loose coupled packing of slot indication
+ * Pack and send slot indication to MAC
*
* @params[in] Post structure
* Slot indication info
* RFAILED - failure
*
* ****************************************************************/
-uint8_t packLcSlotInd (Pst *pst, SlotIndInfo *slotInd)
+uint8_t packSlotInd (Pst *pst, SlotIndInfo *slotInd)
{
- Buffer *mBuf = NULLP;
- if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
+ if(pst->selector == ODU_SELECTOR_LWLC)
{
- return RFAILED;
+ Buffer *mBuf = NULLP;
+ if(ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
+ {
+ printf("\nLWR_MAC: Memory allocation failed in packSlotInd");
+ return RFAILED;
+ }
+ CMCHKPK(oduPackPointer,(PTR)slotInd, mBuf);
+ return ODU_POST_TASK(pst, mBuf);
}
-
- /* pack SFN and slot value */
- CMCHKPK(oduUnpackUInt16,slotInd->sfn, mBuf);
- CMCHKPK(oduUnpackUInt16,slotInd->slot, mBuf);
-
- return ODU_POST_TASK(pst,mBuf);
+ return RFAILED;
}
-/*******************************************************************
- *
- * @brief Light weight loose coupled packing of slot indication
+/**************************************************************************
+ * @brief Function unpacks slot indication
*
* @details
*
- * Function : packLwlcSlotInd
+ * Function : unpackSlotInd
*
- * Functionality:
- * Light weight loose coupled packing of slot indication
+ * Functionality:
+ * unpacks slot indication
*
- * @params[in] Post structure
- * Slot indication info
+ * @param[in] function pointer,
+ * @param[in] Pst *pst,
+ * @param[in] Buffer *mBuf
* @return ROK - success
* RFAILED - failure
*
- * ****************************************************************/
-uint8_t packLwlcSlotInd (Pst *pst, SlotIndInfo *slotInd)
+ ***************************************************************************/
+uint8_t unpackSlotInd(SlotIndFunc func, Pst *pst, Buffer *mBuf)
{
- return ROK;
+ if(pst->selector == ODU_SELECTOR_LWLC)
+ {
+ SlotIndInfo *slotInd = NULLP;
+
+ /* unpack the address of the structure */
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&slotInd, mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
+ return (*func)(pst, slotInd);
+ }
+ return RFAILED;
}
+
/*******************************************************************
*
* @brief Packs and Sends Stop Ind to MAC
* RFAILED - failure
*
* ****************************************************************/
-uint8_t packStopInd(Pst *pst, uint16_t cellId)
+uint8_t packStopInd(Pst *pst, uint16_t *cellId)
{
- if((pst->selector == ODU_SELECTOR_LC) || (pst->selector == ODU_SELECTOR_LWLC))
+ if(pst->selector == ODU_SELECTOR_LWLC)
{
- return ROK;
+ Buffer *mBuf = NULLP;
+ if(ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
+ {
+ printf("\nLWR_MAC: Memory allocation failed in packStopInd");
+ return RFAILED;
+ }
+ CMCHKPK(oduPackPointer,(PTR)cellId, mBuf);
+ return ODU_POST_TASK(pst, mBuf);
}
- else
+ return RFAILED;
+}
+
+/**************************************************************************
+ * @brief Function unpack stop indication
+ *
+ * @details
+ *
+ * Function : unpackStopInd
+ *
+ * Functionality:
+ * unpacks stop indication
+ *
+ * @param[in] function pointer
+ * @param[in] Pst *pst,
+ * @param[in] Buffer *mBuf
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ***************************************************************************/
+uint8_t unpackStopInd(StopIndFunc func, Pst *pst, Buffer *mBuf)
+{
+ if(pst->selector == ODU_SELECTOR_LWLC)
{
- return RFAILED;
+ uint16_t *cellId = NULLP;
+
+ /* unpack the address of the structure */
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&cellId, mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
+ return (*func)(pst, cellId);
}
+ return RFAILED;
}
/*******************************************************************
*
* @details
*
- * Function : packMacUciInd
+ * Function : packUciInd
*
* Functionality:
* Packs and Sends Uci Ind to MAC
* RFAILED - failure
*
* ****************************************************************/
-uint8_t packMacUciInd(Pst *pst, UciInd *uciInd)
+uint8_t packUciInd(Pst *pst, UciInd *uciInd)
{
- if((pst->selector == ODU_SELECTOR_LC) || (pst->selector == ODU_SELECTOR_LWLC))
+ if(pst->selector == ODU_SELECTOR_LWLC)
{
- return ROK;
+ Buffer *mBuf = NULLP;
+ if(ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
+ {
+ printf("\nLWR_MAC: Memory allocation failed in packUciInd");
+ return RFAILED;
+ }
+ CMCHKPK(oduPackPointer,(PTR)uciInd, mBuf);
+ return ODU_POST_TASK(pst, mBuf);
}
- else
+ return RFAILED;
+}
+
+/**************************************************************************
+ * @brief Function unpack UCI indication
+ *
+ * @details
+ *
+ * Function : unpackUciInd
+ *
+ * Functionality:
+ * unpacks UCI indication
+ *
+ * @param[in] function pointer
+ * @param[in] Pst *pst,
+ * @param[in] Buffer *mBuf
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ ***************************************************************************/
+uint8_t unpackUciInd(UciIndFunc func, Pst *pst, Buffer *mBuf)
+{
+ if(pst->selector == ODU_SELECTOR_LWLC)
{
- return RFAILED;
+ UciInd *uciInd = NULLP;
+
+ /* unpack the address of the structure */
+ CMCHKUNPK(oduUnpackPointer, (PTR *)&uciInd, mBuf);
+ ODU_PUT_MSG_BUF(mBuf);
+ return (*func)(pst, uciInd);
}
+ return RFAILED;
}
+
+
/**********************************************************************
End of file
**********************************************************************/
#define HARQ_FAIL 1
#define HARQ_NOT_PRESENT 3
-/* events */
-#define EVENT_RACH_IND_TO_MAC 0
-#define EVENT_CRC_IND_TO_MAC 1
-#define EVENT_RX_DATA_IND_TO_MAC 2
-#define EVENT_STOP_IND_TO_MAC 3
-#define EVENT_SLOT_IND_TO_MAC 4
-#define EVENT_UCI_IND_TO_MAC 5
+/* Events */
+#define EVENT_RACH_IND_TO_MAC 1
+#define EVENT_CRC_IND_TO_MAC 2
+#define EVENT_RX_DATA_IND_TO_MAC 3
+#define EVENT_STOP_IND_TO_MAC 4
+#define EVENT_SLOT_IND_TO_MAC 5
+#define EVENT_UCI_IND_TO_MAC 6
typedef struct rachPreamInfo
{
uint16_t crnti;
uint16_t timingAdvance;
uint16_t rssi;
- uint8_t uciBits[MAX_UCI_BIT_PER_TTI_IN_BYTES];
SrInfoF0F1 srInfo;
HarqInfoF0F1 harqInfo;
}UciPucchF0F1;
UciIndPduInfo pdus[MAX_UCI_PDUS_PER_TTI];
}UciInd;
-typedef uint8_t (*packSlotIndMsg)(Pst *pst, SlotIndInfo *slotInd);
-typedef uint8_t (*packRachIndMsg)(Pst *pst, RachInd *rachInd);
-typedef uint8_t (*packCrcIndMsg)(Pst *pst, CrcInd *crcInd);
-typedef uint8_t (*packRxDataIndMsg)(Pst *pst, RxDataInd *rxDataInd);
-typedef uint8_t (*packStopIndMsg)(Pst *pst, uint16_t cellId);
-typedef uint8_t (*packMacUciIndMsg)(Pst *pst, UciInd *uciInd);
+typedef uint8_t (*SlotIndFunc)(Pst *pst, SlotIndInfo *slotInd);
+typedef uint8_t (*RachIndFunc)(Pst *pst, RachInd *rachInd);
+typedef uint8_t (*CrcIndFunc)(Pst *pst, CrcInd *crcInd);
+typedef uint8_t (*RxDataIndFunc)(Pst *pst, RxDataInd *rxDataInd);
+typedef uint8_t (*StopIndFunc)(Pst *pst, uint16_t *cellId);
+typedef uint8_t (*UciIndFunc)(Pst *pst, UciInd *uciInd);
-uint8_t packLcSlotInd (Pst *pst, SlotIndInfo *slotInd);
-uint8_t packLwlcSlotInd (Pst *pst, SlotIndInfo *slotInd);
+uint8_t packSlotInd (Pst *pst, SlotIndInfo *slotInd);
+uint8_t unpackSlotInd(SlotIndFunc func, Pst *pst, Buffer *mBuf);
uint8_t fapiMacSlotInd(Pst *pst, SlotIndInfo *slotInd);
uint8_t packRachInd(Pst *pst, RachInd *rachInd);
+uint8_t unpackRachInd(RachIndFunc func, Pst *pst, Buffer *mBuf);
uint8_t fapiMacRachInd(Pst *pst, RachInd *rachInd);
uint8_t packCrcInd(Pst *pst, CrcInd *crcInd);
+uint8_t unpackCrcInd(CrcIndFunc func, Pst *pst, Buffer *mBuf);
uint8_t fapiMacCrcInd(Pst *pst, CrcInd *crcInd);
uint8_t packRxDataInd(Pst *pst, RxDataInd *rxDataInd);
+uint8_t unpackRxDataInd(RxDataIndFunc func, Pst *pst, Buffer *mBuf);
uint8_t fapiMacRxDataInd(Pst *pst, RxDataInd *rxDataInd);
-uint8_t packStopInd(Pst *pst, uint16_t cellId);
-uint8_t fapiMacStopInd(Pst *pst, uint16_t cellId);
-uint8_t packMacUciInd(Pst *pst, UciInd *uciInd);
+uint8_t packStopInd(Pst *pst, uint16_t *cellId);
+uint8_t unpackStopInd(StopIndFunc func, Pst *pst, Buffer *mBuf);
+uint8_t fapiMacStopInd(Pst *pst, uint16_t *cellId);
+uint8_t packUciInd(Pst *pst, UciInd *uciInd);
+uint8_t unpackUciInd(UciIndFunc func, Pst *pst, Buffer *mBuf);
uint8_t FapiMacUciInd(Pst *pst, UciInd *uciInd);
#endif
################################################################################
*******************************************************************************/
-/* Fill Pst structure for sending msg from MAC to SCH */
+/* Fill coupling type for sending msg from Lower MAC to MAC.
+ * Using TC for phy stub data and LWLC with Intel L1 */
+#ifdef INTEL_WLS_MEM
+#define FILL_LWR_MAC_TO_MAC_SEL(_pst) _pst.selector = ODU_SELECTOR_LWLC
+#else
+#define FILL_LWR_MAC_TO_MAC_SEL(_pst) _pst.selector = ODU_SELECTOR_TC
+#endif
+
+/* Fill Pst structure for sending msg from Lower MAC to MAC */
#define FILL_PST_LWR_MAC_TO_MAC(_pst, _event) \
{ \
- _pst.selector = ODU_SELECTOR_TC; \
+ FILL_LWR_MAC_TO_MAC_SEL(_pst); \
_pst.srcEnt = ENTLWRMAC; \
_pst.dstEnt = ENTMAC; \
_pst.dstInst = 0; \
_pst.srcInst = 0; \
- _pst.dstProcId = ODU_GET_PROCID(); \
- _pst.srcProcId = ODU_GET_PROCID(); \
+ _pst.dstProcId = ODU_GET_PROCID(); \
+ _pst.srcProcId = ODU_GET_PROCID(); \
+ _pst.region = MAC_MEM_REGION; \
+ _pst.pool = MAC_POOL; \
+ _pst.event = _event; \
+ _pst.route = 0; \
+ _pst.prior = 0; \
+ _pst.intfVer = 0; \
+}
+
+/* Fill Pst structure for sending msg from Lower MAC to itself */
+#define FILL_PST_LWR_MAC_TO_LWR_MAC(_pst, _event) \
+{ \
+ _pst.selector = ODU_SELECTOR_LWLC; \
+ _pst.srcEnt = ENTLWRMAC; \
+ _pst.dstEnt = ENTLWRMAC; \
+ _pst.dstInst = 0; \
+ _pst.srcInst = 0; \
+ _pst.dstProcId = ODU_GET_PROCID(); \
+ _pst.srcProcId = ODU_GET_PROCID(); \
_pst.region = MAC_MEM_REGION; \
_pst.pool = MAC_POOL; \
_pst.event = _event; \
#include "lwr_mac.h"
#include "lwr_mac_fsm.h"
#include "mac_utils.h"
+#include "lwr_mac_phy.h"
+
+uint8_t ssbPeriodicity[6] = {5, 10, 20, 40, 80, 160};
uint8_t MacSchCellCfgReq(Pst *pst, MacCellCfg *macCellCfg);
uint8_t ret = ROK;
MacCellCb *macCellCb;
- memset(&cfmPst, 0, sizeof(Pst));
+ memset((uint8_t *)&cfmPst, 0, sizeof(Pst));
MAC_ALLOC(macCellCb, sizeof(MacCellCb));
if(macCellCb == NULLP)
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg->sib1Cfg.sib1Pdu, macCellCfg->sib1Cfg.sib1PduLen);
MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macCellCfg ,sizeof(MacCellCfg));
}
-#ifdef INTEL_WLS
- LwrMacEnqueueWlsBlock();
-#endif
return ret;
} /* end of MacProcCellCfgReq */
schCellCfg.ssbSchCfg.ssbPbchPwr = macCellCfg->ssbCfg.ssbPbchPwr;
schCellCfg.ssbSchCfg.scsCommon = macCellCfg->ssbCfg.scsCmn;
schCellCfg.ssbSchCfg.ssbOffsetPointA = macCellCfg->ssbCfg.ssbOffsetPointA;
- schCellCfg.ssbSchCfg.ssbPeriod = macCellCfg->ssbCfg.ssbPeriod;
+ schCellCfg.ssbSchCfg.ssbPeriod = ssbPeriodicity[macCellCfg->ssbCfg.ssbPeriod];
schCellCfg.ssbSchCfg.ssbSubcOffset = macCellCfg->ssbCfg.ssbScOffset;
for(uint8_t idx=0; idx<SSB_MASK_SIZE; idx++)
{
crcIndInfo.numCrcInd = crcInd->crcInfo[0].numCb;
crcIndInfo.crcInd[0] = crcInd->crcInfo[0].cbCrcStatus[0];
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, crcInd, sizeof(CrcInd));
return(sendCrcIndMacToSch(&crcIndInfo));
}
for(pduIdx = 0; pduIdx < rxDataInd->numPdus; pduIdx++)
{
unpackRxData(rxDataInd->cellId, rxDataInd->timingInfo, &rxDataInd->pdus[pduIdx]);
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, rxDataInd->pdus[pduIdx].pduData,\
+ rxDataInd->pdus[pduIdx].pduLength);
}
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, rxDataInd, sizeof(RxDataInd));
return ROK;
}
DU_LOG("\nMAC: Received Uci Ind is NULL at FapiMacUciInd()");
ret = RFAILED;
}
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, macUciInd, sizeof(UciInd));
return ret;
}
rachIndInfo.symbolIdx = rachInd->rachPdu[pduIdx].symbolIdx;
rachIndInfo.freqIdx = rachInd->rachPdu[pduIdx].freqIdx;
rachIndInfo.preambleIdx = \
- rachInd->rachPdu[pduIdx].preamInfo[preambleIdx].preamIdx;
+ rachInd->rachPdu[pduIdx].preamInfo[preambleIdx].preamIdx;
rachIndInfo.timingAdv = \
- rachInd->rachPdu[pduIdx].preamInfo[preambleIdx].timingAdv;
+ rachInd->rachPdu[pduIdx].preamInfo[preambleIdx].timingAdv;
/* storing the value in macRaCb */
createMacRaCb(&rachIndInfo);
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, rachInd, sizeof(RachInd));
return(sendRachIndMacToSch(&rachIndInfo));
}
**/
uint8_t fapiMacSlotInd(Pst *pst, SlotIndInfo *slotInd)
{
- uint8_t ret;
+ uint8_t ret = ROK;
volatile uint32_t startTime=0;
#ifdef ODU_SLOT_IND_DEBUG_LOG
if(ret != ROK)
{
DU_LOG("\nMAC : Sending of slot ind msg from MAC to SCH failed");
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, slotInd, sizeof(SlotIndInfo));
return ret;
}
if(ret != ROK)
{
DU_LOG("\nMAC : macProcSlotInd failed");
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, slotInd, sizeof(SlotIndInfo));
return ret;
}
if(ret != ROK)
{
DU_LOG("\nMAC :Sending of slot ind msg from MAC to DU APP failed");
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, slotInd, sizeof(SlotIndInfo));
return ret;
}
/*stoping Task*/
ODU_STOP_TASK(startTime, PID_MAC_TTI_IND);
-
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, slotInd, sizeof(SlotIndInfo));
return ret;
} /* fapiMacSlotInd */
* -# ROK
* -# RFAILED
******************************************************************/
-uint8_t fapiMacStopInd(Pst *pst, uint16_t cellId)
+uint8_t fapiMacStopInd(Pst *pst, uint16_t *cellId)
{
uint8_t ret = ROK;
- ret = sendStopIndToDuApp(cellId);
+ ret = sendStopIndToDuApp(*cellId);
+ MAC_FREE_SHRABL_BUF(pst->region, pst->pool, cellId, sizeof(uint16_t));
return ret;
}
#include "du_app_mac_inf.h"
#include "rg.x" /* typedefs for MAC */
#include "rlc_mac_inf.h"
+#include "lwr_mac_upr_inf.h"
/**
* @brief Task Activation callback function Entity SM.
{
switch(pst->event)
{
-#if (defined(LCRGLITFU) || defined(LWLCRGLITFU))
- case EVTTFUBNDCFM:
- cmUnpkTfuBndCfm(RgLiTfuBndCfm, pst, mBuf);
+ case EVENT_SLOT_IND_TO_MAC:
+ unpackSlotInd(fapiMacSlotInd, pst, mBuf);
break;
- case EVTTFUDATIND:
- cmUnpkTfuDatInd(RgLiTfuDatInd, pst, mBuf);
- break;
-#if defined(TENB_T2K3K_SPECIFIC_CHANGES) && defined(LTE_TDD)
- case EVTTFUNONRTIND:
- cmUnpkTfuNonRtInd(RgLiTfuNonRtInd, pst, mBuf);
- break;
-#endif
-#endif
+ case EVENT_STOP_IND_TO_MAC:
+ unpackStopInd(fapiMacStopInd, pst, mBuf);
+ break;
+ case EVENT_RACH_IND_TO_MAC:
+ unpackRachInd(fapiMacRachInd, pst, mBuf);
+ break;
+ case EVENT_CRC_IND_TO_MAC:
+ unpackCrcInd(fapiMacCrcInd, pst, mBuf);
+ break;
+ case EVENT_RX_DATA_IND_TO_MAC:
+ unpackRxDataInd(fapiMacRxDataInd, pst, mBuf);
+ break;
+ case EVENT_UCI_IND_TO_MAC:
+ unpackUciInd(FapiMacUciInd, pst, mBuf);
+ break;
default:
RG_FREE_MSG(mBuf);
break;
schActvInit(ENTMAC, (DEFAULT_CELLS + SCH_INST_START), DFLT_REGION, PWR_UP);
/* Initialize lower mac */
- lwrMacInit();
+ lwrMacLayerInit();
return ROK;
switch(cfg->hdr.elmId.elmnt)
{
case STGEN:
+#ifdef INTEL_WLS_MEM
+ /* Start WLS message receiver thread */
+ LwrMacStartWlsRcvr();
+ /* Allocate memory for UL transmissions */
+ LwrMacEnqueueWlsBlock();
+#endif
reason = rgLMMGenCfg(inst,&cfg->t.cfg);
break;
case STRGUSAP:
cmUnpkRgrLoadInfReq(RgUiRgrLoadInfReq, pst, mBuf);
break;
/* LTE_ADV_FLAG_REMOVED_END */
-#endif
- default:
- RGSCH_FREE_MSG(mBuf);
- break;
- }
- break;
- case ENTLWRMAC:
- switch(pst->event)
- {
-/*#ifdef LCRGLITFU L2Split */
-#if (defined(LCRGLITFU) || defined(LWLCRGLITFU))
- case EVTTFUSCHBNDCFM:
- cmUnpkTfuBndCfm(RgLiTfuSchBndCfm, pst, mBuf);
- break;
- case EVTTFURAREQIND:
- cmUnpkTfuRaReqInd(RgLiTfuRaReqInd, pst, mBuf);
- break;
- case EVTTFUULCQIIND:
- cmUnpkTfuUlCqiInd(RgLiTfuUlCqiInd, pst, mBuf);
- break;
- case EVTTFUHQIND:
- cmUnpkTfuHqInd(RgLiTfuHqInd, pst, mBuf);
- break;
- case EVTTFUSRIND:
- cmUnpkTfuSrInd(RgLiTfuSrInd, pst, mBuf);
- break;
- case EVTTFUDLCQIIND:
- cmUnpkTfuDlCqiInd(RgLiTfuDlCqiInd, pst, mBuf);
- break;
- case EVTTFUCRCIND:
- /*cmUnpkTfuCrcIndInfo(RgLiTfuCrcInd, pst, mBuf); */
- cmUnpkTfuCrcInd(RgLiTfuCrcInd, pst, mBuf);
- break;
- case EVTTFUTIMINGADVIND:
- cmUnpkTfuTimingAdvInd(RgLiTfuTimingAdvInd, pst, mBuf);
- break;
- case EVTTFUPUCCHDELPWR:
- cmUnpkTfuPucchDeltaPwr(RgLiTfuPucchDeltaPwrInd, pst, mBuf);
- break;
- case EVTTFUDOAIND:
- cmUnpkTfuDoaInd(RgLiTfuDoaInd, pst, mBuf);
- break;
-#ifdef TFU_UPGRADE
- case EVTTFURAWCQIIND:
- cmUnpkTfuRawCqiInd(RgLiTfuRawCqiInd, pst, mBuf);
- break;
- case EVTTFUSRSIND:
- cmUnpkTfuSrsInd(RgLiTfuSrsInd, pst, mBuf);
- break;
-#endif
- /*LAA: Error Indication on SCell*/
- case EVTTFUERRIND:
- cmUnpkTfuErrInd(RgLiTfuErrInd, pst, mBuf);
- break;
#endif
default:
RGSCH_FREE_MSG(mBuf);
#define ODU_SEGMENT_MSG SSegMsg
#define ODU_CAT_MSG SCatMsg
#define ODU_GET_PROCID SFndProcId
+#define ODU_SET_THREAD_AFFINITY SSetAffinity
#define GET_UE_IDX( _crnti,_ueIdx) \
{ \
if (ODU_GET_MSG_BUF(pst->region, pst->pool, &mBuf) != ROK)
{
- DU_LOG("\nDU APP : Memory allocation failed for cell start req pack");
+ DU_LOG("\nDU APP : Memory allocation failed for packMacSlotInd");
return RFAILED;
}
typedef struct carrierCfg
{
bool pres;
- uint16_t bw; /* DL/UL bandwidth */
+ uint32_t bw; /* DL/UL bandwidth */
uint32_t freq; /* Absolute frequency of DL/UL point A in KHz */
uint16_t k0[NUM_NUMEROLOGY]; /* K0 for DL/UL */
uint16_t gridSize[NUM_NUMEROLOGY]; /* DL/UL Grid size for each numerologies */
typedef struct macCellCfg
{
uint16_t cellId; /* Cell Id */
- uint8_t numTlv; /* Number of configuration TLVs */
uint8_t carrierId; /* Carrired Index */
uint16_t phyCellId; /* Physical cell id */
DuplexMode dupType; /* Duplex type: TDD/FDD */
S16 cmUnpkCmAlarm ARGS((CmAlarm *alrm, Buffer *mBuf));
#endif /* CMFILE_REORG_1 */
-#if defined(XEON_SPECIFIC_CHANGES) || defined(INTEL_WLS)
-void * mtGetWlsHdl();
+#if defined(XEON_SPECIFIC_CHANGES) || defined(INTEL_WLS) || defined(SS_USE_WLS_MEM)
+void mtGetWlsHdl(void **hdlr);
#endif
#ifdef __cplusplus
#endif
#endif /* SS_HISTOGRAM_SUPPORT */
#endif /*SS_LIGHT_MEM_LEAK_STS */
+#ifdef INTEL_WLS_MEM
+S16 SPutSBufWls(Region region, Pool pool, Data *ptr, Size size);
+S16 SGetSBufWls(Region region, Pool pool, Data **ptr, Size size);
+#endif
#ifdef INTEL_WLS
#ifdef T2K_MEM_LEAK_DBG
#define SGetSBufWls(region,pool,bufPtr,size) SGetSBufWls1(region,pool,bufPtr,size,__FILE__,__LINE__)
TFU_FREE_MSG(mBuf);
return RFAILED;
}
- pst->event = (Event) EVTTFUBNDREQ;
+ //pst->event = (Event) EVTTFUBNDREQ;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MSG(mBuf);
return RFAILED;
}
- pst->event = (Event) EVTTFUBNDCFM;
+ //pst->event = (Event) EVTTFUBNDCFM;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MSG(mBuf);
return RFAILED;
}
- pst->event = (Event) EVTTFUUBNDREQ;
+ //pst->event = (Event) EVTTFUUBNDREQ;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MSG(mBuf);
return RFAILED;
}
- pst->event = (Event) EVTTFUSCHBNDREQ;
+ //pst->event = (Event) EVTTFUSCHBNDREQ;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MSG(mBuf);
return RFAILED;
}
- pst->event = (Event) EVTTFUSCHBNDCFM;
+ //pst->event = (Event) EVTTFUSCHBNDCFM;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MSG(mBuf);
return RFAILED;
}
- pst->event = (Event) EVTTFUSCHUBNDREQ;
+ //pst->event = (Event) EVTTFUSCHUBNDREQ;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MEM(raReqInd);
}
- pst->event = (Event) EVTTFURAREQIND;
+ //pst->event = (Event) EVTTFURAREQIND;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MEM(recpReq);
}
- pst->event = (Event) EVTTFURECPREQ;
+ //pst->event = (Event) EVTTFURECPREQ;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MEM(ulCqiInd);
}
- pst->event = (Event) EVTTFUULCQIIND;
+ //pst->event = (Event) EVTTFUULCQIIND;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MEM(hqInd);
}
- pst->event = (Event) EVTTFUHQIND;
+ //pst->event = (Event) EVTTFUHQIND;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MEM(srInd);
}
- pst->event = (Event) EVTTFUSRIND;
+ //pst->event = (Event) EVTTFUSRIND;
return (SPstTsk(pst,mBuf));
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(dlCqiInd);
}
- pst->event = (Event) EVTTFUDLCQIIND;
+ //pst->event = (Event) EVTTFUDLCQIIND;
return (SPstTsk(pst,mBuf));
}
return RFAILED;
}
TFU_FREE_MEM(rawCqiInd);
- pst->event = (Event) EVTTFURAWCQIIND;
+ //pst->event = (Event) EVTTFURAWCQIIND;
return (SPstTsk(pst,mBuf));
}
return RFAILED;
}
TFU_FREE_MEM(srsInd);
- pst->event = (Event) EVTTFUSRSIND;
+ //pst->event = (Event) EVTTFUSRSIND;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MEM(datInd);
}
- pst->event = (Event) EVTTFUDATIND;
+ //pst->event = (Event) EVTTFUDATIND;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MEM(crcIndInfo);
}
- pst->event = (Event) EVTTFUCRCIND;
+ //pst->event = (Event) EVTTFUCRCIND;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MEM(timingAdvInd);
}
- pst->event = (Event) EVTTFUTIMINGADVIND;
+ //pst->event = (Event) EVTTFUTIMINGADVIND;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MEM(datReq);
}
- pst->event = (Event) EVTTFUDATREQ;
+ //pst->event = (Event) EVTTFUDATREQ;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MEM(cntrlReq);
}
- pst->event = (Event) EVTTFUCNTRLREQ;
+ //pst->event = (Event) EVTTFUCNTRLREQ;
return (SPstTsk(pst,mBuf));
}
TFU_FREE_MSG(mBuf);
return RFAILED;
}
- pst->event = (Event) EVTTFUNONRTIND;
+ //pst->event = (Event) EVTTFUNONRTIND;
return (SPstTsk(pst,mBuf));
}
if (pst->selector != ODU_SELECTOR_LWLC) {
TFU_FREE_MEM(pucchDeltaPwr);
}
- pst->event = (Event) EVTTFUPUCCHDELPWR;
+ //pst->event = (Event) EVTTFUPUCCHDELPWR;
return (SPstTsk(pst,mBuf));
}
return RFAILED;
}
TFU_FREE_MEM(doaInd);
- pst->event = (Event) EVTTFUDOAIND;
+ //pst->event = (Event) EVTTFUDOAIND;
return (SPstTsk(pst,mBuf));
}
}
}
- pst->event = (Event) EVTTFUERRIND;
+ //pst->event = (Event) EVTTFUERRIND;
return (SPstTsk(pst,mBuf));
}
/* Event corresponding to each primitive at this interface */
+#if 0
#define EVTTFUBNDREQ 1 /*!< Bind Request */
#define EVTTFUBNDCFM 2 /*!< Bind Confirm */
#define EVTTFUUBNDREQ 3 /*!< Unbind Request */
#endif
#define EVTTFUERRIND 25 /*!< TFU Error Indication */
/** @} */
-
+#endif
/* selector(coupling) values */
#define TFU_MAX_ALLOC_BYTES 4
/* pack unpack error code */
duCfgParam.macCellCfg.dlCarrCfg.k0[2] = 1;
duCfgParam.macCellCfg.dlCarrCfg.k0[3] = 1;
duCfgParam.macCellCfg.dlCarrCfg.k0[4] = 1;
- duCfgParam.macCellCfg.dlCarrCfg.gridSize[0] = 1;
+ duCfgParam.macCellCfg.dlCarrCfg.gridSize[0] = 273;
duCfgParam.macCellCfg.dlCarrCfg.gridSize[1] = 1;
duCfgParam.macCellCfg.dlCarrCfg.gridSize[2] = 1;
duCfgParam.macCellCfg.dlCarrCfg.gridSize[3] = 1;
duCfgParam.macCellCfg.ssbCfg.scsCmn = SUBCARRIER_SPACING;
duCfgParam.macCellCfg.ssbCfg.ssbOffsetPointA = OFFSET_TO_POINT_A;
duCfgParam.macCellCfg.ssbCfg.betaPss = BETA_PSS;
- duCfgParam.macCellCfg.ssbCfg.ssbPeriod = SSB_PERIODICITY_20MS;
+ duCfgParam.macCellCfg.ssbCfg.ssbPeriod = SSB_PRDCTY_MS_20;
duCfgParam.macCellCfg.ssbCfg.ssbScOffset = SSB_SUBCARRIER_OFFSET;
duCfgParam.macCellCfg.ssbCfg.ssbMask[0] = 1; /* only one SSB is transmitted */
duCfgParam.macCellCfg.ssbCfg.ssbMask[1] = 0;
duCfgParam.macCellCfg.prachCfg.rootSeqLen = ROOT_SEQ_LEN;
duCfgParam.macCellCfg.prachCfg.fdm[0].rootSeqIdx = ROOT_SEQ_IDX;
duCfgParam.macCellCfg.prachCfg.fdm[0].numRootSeq = NUM_ROOT_SEQ;
- duCfgParam.macCellCfg.prachCfg.fdm[0].k1 = 1;
+ duCfgParam.macCellCfg.prachCfg.fdm[0].k1 = 0;
duCfgParam.macCellCfg.prachCfg.fdm[0].zeroCorrZoneCfg = ZERO_CORRELATION_ZONE_CFG;
duCfgParam.macCellCfg.prachCfg.fdm[0].numUnusedRootSeq = NUM_UNUSED_ROOT_SEQ;
if(duCfgParam.macCellCfg.prachCfg.fdm[0].numUnusedRootSeq != 0)
duCfgParam.macCellCfg.initialUlBwp.pucchCommon.pucchResourceCommon = PUCCH_RSRC_COMMON;
duCfgParam.macCellCfg.initialUlBwp.pucchCommon.pucchGroupHopping = PUCCH_GROUP_HOPPING;
- /* This should be calculated based on
- (number of mandatory parameters) + (number of otional parameters being filled) */
- duCfgParam.macCellCfg.numTlv = 40;
-
return ROK;
}
#define PLMN_MNC1 8
#define PLMN_MNC2 0
#define PLMN_SIZE 3
-#define NR_DL_ARFCN 385627
-#define NR_UL_ARFCN 386687
+#define NR_DL_ARFCN 2118460
+#define NR_UL_ARFCN 1718460
#define SUL_ARFCN 100
#define NR_FREQ_BAND 257
#define NR_FREQ_BAND_IND 78
#define NUM_TX_ANT 2
#define NUM_RX_ANT 2
#define FREQ_SHIFT_7P5KHZ FALSE
-#define SSB_PBCH_PWR -5
-#define BCH_PAYLOAD MAC_GEN_FULL_PBCH_PAYLD
+#define SSB_PBCH_PWR 0
+#define BCH_PAYLOAD PHY_GEN_TIMING_PBCH_BIT
#define TOTAL_PRB_BW 106
#define SUBCARRIER_SPACING 0
#define NORMAL_CYCLIC_PREFIX 0
#define PRACH_CONFIG_IDX 88
#define PRACH_FREQ_START 0
#define PRACH_SEQ_LEN SHORT_SEQUENCE
-#define PRACH_SUBCARRIER_SPACING 1
+#define PRACH_SUBCARRIER_SPACING 0
#define PRACH_RESTRICTED_SET_CFG 0
#define NUM_PRACH_FDM 1
-#define ROOT_SEQ_IDX 24
+#define ROOT_SEQ_IDX 0
#define NUM_ROOT_SEQ 1
-#define ZERO_CORRELATION_ZONE_CFG 6
+#define ZERO_CORRELATION_ZONE_CFG 4
#define NUM_UNUSED_ROOT_SEQ 0
#define UNUSED_ROOT_SEQ 1
#define SSB_PER_RACH 1
uint8_t rlcDlActvInit (Ent, Inst, Region, Reason);
uint8_t rgActvTsk (Pst *, Buffer *);
uint8_t rgActvInit (Ent, Inst, Region, Reason);
+uint8_t lwrMacActvTsk(Pst *, Buffer *);
+uint8_t lwrMacActvInit(Ent, Inst, Region, Reason);
/* Global variable */
DuCfgParams duCfgParam;
return ROK;
}
+/*******************************************************************
+ *
+ * @brief Initializes Lower MAC receiver task
+ *
+ * @details
+ *
+ * Function : lwrMacInit
+ *
+ * Functionality:
+ * - Registers and attaches TAPA tasks for Lower MAC receiver
+ *
+ * @params[in] system task ID
+ * @return ROK - success
+ * RFAILED - failure
+ *
+ * ****************************************************************/
+uint8_t lwrMacInit(SSTskId sysTskId)
+{
+ /* Register SCTP TAPA Task */
+ if(ODU_REG_TTSK((Ent)ENTLWRMAC, (Inst)0, (Ttype)TTNORM, (Prior)PRIOR0,
+ lwrMacActvInit, (ActvTsk)lwrMacActvTsk) != ROK)
+ {
+ return RFAILED;
+ }
+ /* Attach SCTP TAPA Task */
+ if (ODU_ATTACH_TTSK((Ent)ENTLWRMAC, (Inst)0, sysTskId)!= ROK)
+ {
+ return RFAILED;
+ }
+
+ DU_LOG("\nDU_APP : LWR MAC TAPA task created and registered to %d sys task",
+ sysTskId);
+ return ROK;
+}
+
/*******************************************************************
*
* @brief Initializes system and TAPA tasks
uint8_t commonInit()
{
/* Declare system task Ids */
- SSTskId du_app_stsk, sctp_stsk, rlc_ul_stsk, rlc_mac_cl_stsk;
+ SSTskId du_app_stsk, sctp_stsk, rlc_ul_stsk, rlc_mac_cl_stsk, lwr_mac_stsk;
pthread_attr_t attr;
DU_LOG("\nDU_APP : System Task creation for DU APP failed");
return RFAILED;
}
+ ODU_SET_THREAD_AFFINITY(&du_app_stsk, SS_AFFINITY_MODE_EXCL, 15, 0);
/* system task for RLC_DL and MAC */
if(SCreateSTsk(PRIOR0, &rlc_mac_cl_stsk) != ROK)
}
pthread_attr_init(&attr);
pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED);
+ ODU_SET_THREAD_AFFINITY(&rlc_mac_cl_stsk, SS_AFFINITY_MODE_EXCL, 16, 0);
/* system task for RLC UL */
if(SCreateSTsk(PRIOR1, &rlc_ul_stsk) != ROK)
DU_LOG("\nDU_APP : System Task creation for RLC UL failed");
return RFAILED;
}
+ ODU_SET_THREAD_AFFINITY(&rlc_ul_stsk, SS_AFFINITY_MODE_EXCL, 17, 0);
/* system task for SCTP receiver thread */
if(SCreateSTsk(PRIOR0, &sctp_stsk) != ROK)
DU_LOG("\nDU_APP : System Task creation for SCTP failed");
return RFAILED;
}
+ ODU_SET_THREAD_AFFINITY(&sctp_stsk, SS_AFFINITY_MODE_EXCL, 18, 0);
+
+ /* system task for lower-mac receiver thread */
+ if(SCreateSTsk(PRIOR0, &lwr_mac_stsk) != ROK)
+ {
+ DU_LOG("\nDU_APP : System Task creation for Lower MAC failed");
+ return RFAILED;
+ }
+ ODU_SET_THREAD_AFFINITY(&lwr_mac_stsk, SS_AFFINITY_MODE_EXCL, 19, 0);
/* Create TAPA tasks */
if(duAppInit(du_app_stsk) != ROK)
DU_LOG("\nDU_APP : RLC UL Tapa Task initialization failed");
return RFAILED;
}
+
+ if(lwrMacInit(lwr_mac_stsk) != ROK)
+ {
+ DU_LOG("\nDU_APP : Lower MAC Tapa Task initialization failed");
+ return RFAILED;
+ }
+
return ROK;
}
#endif
if((pst->selector == ODU_SELECTOR_LWLC) || (pst->selector == ODU_SELECTOR_TC))
- DU_FREE_SHRABL_BUF(MAC_MEM_REGION, pst->pool, slotInfo, sizeof(SlotIndInfo));
-
+ DU_FREE_SHRABL_BUF(pst->region, pst->pool, slotInfo, sizeof(SlotIndInfo));
return ROK;
}
if(!mibMsg)
{
DU_LOG("DU APP: MIB msg memory allocation failure");
- break;
+ return RFAILED;
}
BuildMibret = BuildMib(mibMsg);
if(BuildMibret != ROK)
#define FAPI_STOP_REQUEST 0x05
#define FAPI_STOP_INDICATION 0x06
#define FAPI_ERROR_INDICATION 0x07
-// Reserved 0x08 - 0x7f
-#define FAPI_VENDOR_EXT_SHUTDOWN_REQUEST 0x08
-#define FAPI_VENDOR_MESSAGE 0x09
-#ifdef DEBUG_MODE
-#define FAPI_VENDOR_EXT_DL_IQ_SAMPLES 0x0A
-#define FAPI_VENDOR_EXT_UL_IQ_SAMPLES 0x0B
-#endif
-// WLS operation
-#define FAPI_MSG_HEADER_IND 0x2A
-
-// WLS operation with PDSCH Payload
-#define FAPI_MSG_PHY_ZBC_BLOCK_REQ 0x2B
-
-// WLS operation with PUSCH Payload
-#define FAPI_MSG_PHY_ZBC_BLOCK_IND 0x2C
+// Reserved 0x08 - 0x0F and 0x02 - 0x7f
+// 0x01 - 0x1F is used in vendor extension
#define FAPI_DL_TTI_REQUEST 0x80
#define FAPI_UL_TTI_REQUEST 0x81
#define FAPI_SRS_INDICATION 0x88
#define FAPI_RACH_INDICATION 0x89
// Reserved 0x8a -0xff
-#ifdef DEBUG_MODE
-#define FAPI_VENDOR_EXT_START_RESPONSE 0x8A
-#endif
-#define FAPI_VENDOR_EXT_SHUTDOWN_RESPONSE 0x8B
// Tags per 5G FAPI
// Cell Parameters
#define FAPI_MSG_UL_DCI_ERR 0x7
#define FAPI_MSG_TX_ERR 0x8
-// TODO : Work out what the correct maximums should be// Needs Review for 5G
-#if 0
-// Number of UL/DL configurations, I, as defined by 36.212 section 5.3.3.1.4
-// todo : work out what the max is
-#define FAPI_MAX_UL_DL_CONFIGURATIONS 4
-#define FAPI_MAX_NUM_PHYSICAL_ANTENNAS 4
-#define FAPI_MAX_NUM_SCHEDULED_UES 8
-#define FAPI_MAX_NUM_SUBBANDS 8
-#define FAPI_MAX_ANTENNA_PORT_COUNT 2
-#endif
-
// 5G FAPI Definitions
#define FAPI_NUMEROLOGIES 5
#define FAPI_MAX_NUM_UNUSED_ROOT_SEQUENCES 63 // 38.331 page 383
#define FAPI_MAX_NUMBER_OF_GROUPS_PER_TTI 16 // FlexRAN API Table 33
#define FAPI_MAX_NUMBER_UL_PDUS_PER_TTI 328 // (MAX_NUM_PUSCH+MAX_NUM_PUCCH+MAX_NUM_SRS+MAX_NUM_PRACH_DET)
#define FAPI_MAX_NUMBER_DCI_PDUS_PER_TTI 32 // Based on MAX_NUM_PDCCH
-#define FAPI_MAX_NUMBER_OF_TLVS_PER_PDU 2 // one for each codeword
+#define FAPI_MAX_NUMBER_OF_TLVS_PER_PDU 1 // one for each codeword
#define FAPI_MAX_NUMBER_TX_PDUS_PER_TTI 129 // Same as FAPI_MAX_NUMBER_DL_PDUS_PER_TTI
// Based on 38.214 5.1.3.4, the TBS is 1376264 bits and divided by 8 and
// aligned to 64 bytes
#define FAPI_MAX_PDU_LENGTH 172096
+#define FAPI_TX_DATA_PAYLOAD 0x00
+#define FAPI_TX_DATA_PTR_TO_PAYLOAD_32 0x01
+#define FAPI_TX_DATA_OFFSET_TO_PAYLOAD 0x02
+#define FAPI_TX_DATA_PTR_TO_PAYLOAD_64 0x03
#define FAPI_MAX_NUMBER_OF_PDUS_PER_TTI 129 // Same as FAPI_MAX_NUMBER_DL_PDUS_PER_TTI
#define FAPI_MAX_NUMBER_OF_ULSCH_PDUS_PER_SLOT 64 // NUM_PUSCH_CHAN*FAPI_MAX_NUMBER_OF_CODEWORDS_PER_PDU
#define FAPI_MAX_NUM_TLVS_SHUTDOWN 1 // Based on Timer Mode requirement.
#define FAPI_MAX_UCI_BIT_BYTE_LEN 256
-#ifdef DEBUG_MODE
-#define FAPI_MAX_IQ_SAMPLE_FILE_SIZE 576
-#define FAPI_MAX_IQ_SAMPLE_DL_PORTS 8
-#define FAPI_MAX_IQ_SAMPLE_UL_PORTS 2
-#define FAPI_MAX_IQ_SAMPLE_UL_VIRTUAL_PORTS 4
-#define FAPI_MAX_IQ_SAMPLE_UL_ANTENNA 32
-#define FAPI_MAX_IQ_SAMPLE_BUFFER_SIZE 4096
-#endif
-
-#define FAPI_PRACH_PDU_TYPE 0
-#define FAPI_PUSCH_PDU_TYPE 1
-#define FAPI_PUCCH_PDU_TYPE 2
-#define FAPI_SRS_PDU_TYPE 3
-
-#define FAPI_PDCCH_PDU_TYPE 0
-#define FAPI_PDSCH_PDU_TYPE 1
-#define FAPI_PBCH_PDU_TYPE 2
-#define FAPI_CSIRS_PDU_TYPE 3
+ enum ul_tti_pdu_type_e {
+ FAPI_PRACH_PDU_TYPE = 0,
+ FAPI_PUSCH_PDU_TYPE,
+ FAPI_PUCCH_PDU_TYPE,
+ FAPI_SRS_PDU_TYPE,
+ FAPI_UL_TTI_PDU_TYPE_MAX
+ };
+
+ enum dl_tti_pdu_type_e {
+ FAPI_PDCCH_PDU_TYPE = 0,
+ FAPI_PDSCH_PDU_TYPE,
+ FAPI_CSIRS_PDU_TYPE,
+ FAPI_PBCH_PDU_TYPE,
+ FAPI_DL_TTI_PDU_TYPE_MAX
+ };
//------------------------------------------------------------------------------------------------------------
-// Linked list header prent at the top of all messages
- typedef struct _fapi_api_queue_elem {
- struct _fapi_api_queue_elem *p_next;
- // p_tx_data_elm_list used for TX_DATA.request processing
- struct _fapi_api_queue_elem *p_tx_data_elm_list;
- uint8_t msg_type;
- uint8_t num_message_in_block;
- uint32_t msg_len;
- uint32_t align_offset;
- uint64_t time_stamp;
- } fapi_api_queue_elem_t, *p_fapi_api_queue_elem_t;
-
// Updated per 5G FAPI
typedef struct {
uint8_t num_msg;
// Can be used for Phy Id or Carrier Id 5G FAPI Table 3-2
uint8_t handle;
uint8_t pad[2];
- } fapi_msg_header_t, *p_fapi_msg_header_t;
+ } fapi_msg_header_t,
+ *p_fapi_msg_header_t;
// Updated per 5G FAPI
typedef struct {
uint16_t rsv; // To be 32-bit aligned, if FAPI_NUMEROLOGIES changes to some other value than 5 please ensure 32 bit alignment
} fapi_config_num_tlv_t;
- typedef struct {
- uint16_t hopping_id;
- uint8_t carrier_aggregation_level;
- uint8_t group_hop_flag;
- uint8_t sequence_hop_flag;
- // uint8_t nDMRS_type_A_pos;
- uint8_t pad[3];
- } fapi_config_req_vendor_msg_t;
-
- typedef struct {
- uint16_t sfn;
- uint16_t slot;
- uint32_t mode;
-#ifdef DEBUG_MODE
- uint32_t count;
- uint32_t period;
-#endif
- } fapi_start_req_vendor_msg_t;
-
- typedef struct {
- uint16_t sfn;
- uint16_t slot;
- } fapi_stop_req_vendor_msg_t;
-
- typedef struct {
- fapi_msg_t header;
- fapi_config_req_vendor_msg_t config_req_vendor;
- fapi_start_req_vendor_msg_t start_req_vendor;
- fapi_stop_req_vendor_msg_t stop_req_vendor;
- } fapi_vendor_msg_t;
-
// Updated per 5G FAPI
typedef struct {
fapi_msg_t header; // For PARAM.req message length in fapi_msg_t is zero per 5G FAPI 3.3.1.1
uint8_t aggregationLevel;
fapi_precoding_bmform_t pc_and_bform;
uint8_t beta_pdcch_1_0;
- uint8_t powerControlOfssetSS;
+ uint8_t powerControlOffsetSS;
uint16_t payloadSizeBits;
uint8_t payload[FAPI_DCI_PAYLOAD_BYTE_LEN]; // 5G FAPI Table 3-37
} fapi_dl_dci_t;
uint8_t cceRegMappingType;
uint8_t regBundleSize;
uint8_t interleaverSize;
- uint8_t coreSetSize;
+ uint8_t coreSetType;
uint16_t shiftIndex;
uint8_t precoderGranularity;
- uint8_t coreSetType;
+ uint8_t pad;
uint16_t numDlDci; // 5G FAPI Table 3-36
fapi_dl_dci_t dlDci[FAPI_MAX_NUMBER_DL_DCI];
} fapi_dl_pdcch_pdu_t;
// Updated per 5G FAPI
typedef struct {
- uint16_t pdu_length;
+ uint32_t pdu_length;
uint16_t pdu_index;
- uint32_t num_tlvs;
+ uint16_t num_tlvs;
fapi_uint8_ptr_tlv_t tlvs[FAPI_MAX_NUMBER_OF_TLVS_PER_PDU]; // 5G FAPI Table 3-58 Subset
} fapi_tx_pdu_desc_t;
uint16_t timingAdvance;
uint16_t rssi; // 5G FAPI Table 3-65
uint8_t pad1[2];
- uint8_t uciBits[FAPI_MAX_UCI_BIT_BYTE_LEN];
fapi_sr_f0f1_info_t srInfo; // This is included if indicated by the pduBitmap
fapi_harq_f0f1_info_t harqInfo; // This is included if indicated by the pduBitmap
} fapi_uci_o_pucch_f0f1_t;
fapi_rach_pdu_t rachPdu[FAPI_MAX_NUMBER_RACH_PDUS_PER_SLOT]; // 5G FAPI Table 3-74
} fapi_rach_indication_t;
-//Vendor extension messages
- typedef struct {
- fapi_msg_t header;
- uint16_t sfn;
- uint16_t slot;
- uint32_t test_type;
- } fapi_vendor_ext_shutdown_req_t;
-
- typedef struct {
- fapi_msg_t header;
- uint16_t sfn;
- uint16_t slot;
- uint32_t nStatus;
- } fapi_vendor_ext_shutdown_res_t;
-
-#ifdef DEBUG_MODE
- typedef struct {
- uint32_t carrNum;
- uint32_t numSubframes;
- uint32_t testUeMode;
- uint32_t timerModeFreqDomain;
- uint32_t phaseCompensationEnable;
- uint32_t startFrameNum;
- uint32_t startSlotNum;
- char filename_in_ul_iq[FAPI_MAX_IQ_SAMPLE_UL_VIRTUAL_PORTS]
- [FAPI_MAX_IQ_SAMPLE_FILE_SIZE];
- char filename_in_ul_urllc[FAPI_MAX_IQ_SAMPLE_UL_VIRTUAL_PORTS]
- [FAPI_MAX_IQ_SAMPLE_FILE_SIZE];
- char filename_in_prach_iq[FAPI_MAX_IQ_SAMPLE_UL_VIRTUAL_PORTS]
- [FAPI_MAX_IQ_SAMPLE_FILE_SIZE];
- char filename_in_srs_iq[FAPI_MAX_IQ_SAMPLE_UL_ANTENNA]
- [FAPI_MAX_IQ_SAMPLE_FILE_SIZE];
- char filename_out_dl_iq[FAPI_MAX_IQ_SAMPLE_FILE_SIZE];
- char filename_out_dl_iq_urllc[FAPI_MAX_IQ_SAMPLE_FILE_SIZE];
- char filename_out_dl_beam[FAPI_MAX_IQ_SAMPLE_DL_PORTS]
- [FAPI_MAX_IQ_SAMPLE_FILE_SIZE];
- char filename_out_ul_beam[FAPI_MAX_IQ_SAMPLE_UL_VIRTUAL_PORTS]
- [FAPI_MAX_IQ_SAMPLE_FILE_SIZE];
- uint8_t buffer[FAPI_MAX_IQ_SAMPLE_BUFFER_SIZE];
- } fapi_vendor_ext_iq_samples_info_t;
-
- typedef struct {
- fapi_msg_t header;
- fapi_vendor_ext_iq_samples_info_t iq_samples_info;
- } fapi_vendor_ext_iq_samples_req_t;
-
- typedef struct {
- fapi_msg_t header;
- } fapi_vendor_ext_dl_iq_samples_res_t;
-
- typedef struct {
- fapi_msg_t header;
- } fapi_vendor_ext_ul_iq_samples_res_t;
-
- typedef struct {
- fapi_msg_t header;
- } fapi_vendor_ext_start_response_t;
-#endif
//------------------------------------------------------------------------------
#if defined(__cplusplus)
--- /dev/null
+/******************************************************************************
+*
+* Copyright (c) 2019 Intel.
+*
+* Licensed under the Apache License, Version 2.0 (the "License");
+* you may not use this file except in compliance with the License.
+* You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*
+*******************************************************************************/
+
+#ifndef _FAPI_VENDOR_EXTENSION_H_
+#define _FAPI_VENDOR_EXTENSION_H_
+
+#if defined(__cplusplus)
+extern "C" {
+#endif
+
+#define FAPI_VENDOR_MESSAGE 0x10
+#define FAPI_VENDOR_EXT_SHUTDOWN_REQUEST 0x11
+#define FAPI_VENDOR_EXT_SHUTDOWN_RESPONSE 0x12
+
+#ifdef DEBUG_MODE
+#define FAPI_VENDOR_EXT_DL_IQ_SAMPLES 0x13
+#define FAPI_VENDOR_EXT_UL_IQ_SAMPLES 0x14
+#define FAPI_VENDOR_EXT_START_RESPONSE 0x15
+#endif
+
+/* ----- WLS Operation --- */
+#define FAPI_VENDOR_MSG_HEADER_IND 0x1A
+
+// PDSCH Payload
+#define FAPI_VENDOR_MSG_PHY_ZBC_BLOCK_REQ 0x1B
+
+// Linked list header present at the top of all messages
+ typedef struct _fapi_api_queue_elem {
+ struct _fapi_api_queue_elem *p_next;
+ // p_tx_data_elm_list used for TX_DATA.request processing
+ struct _fapi_api_queue_elem *p_tx_data_elm_list;
+ uint8_t msg_type;
+ uint8_t num_message_in_block;
+ uint32_t msg_len;
+ uint32_t align_offset;
+ uint64_t time_stamp;
+ } fapi_api_queue_elem_t,
+ *p_fapi_api_queue_elem_t;
+/* ----------------------- */
+
+#ifdef DEBUG_MODE
+#define FAPI_MAX_IQ_SAMPLE_FILE_SIZE 576
+#define FAPI_MAX_IQ_SAMPLE_DL_PORTS 16
+#define FAPI_MAX_IQ_SAMPLE_UL_PORTS 2
+#define FAPI_MAX_IQ_SAMPLE_UL_VIRTUAL_PORTS 8
+#define FAPI_MAX_IQ_SAMPLE_UL_ANTENNA 64
+#define FAPI_MAX_IQ_SAMPLE_BUFFER_SIZE 4096
+#endif
+
+ typedef struct {
+ uint16_t hopping_id;
+ uint8_t carrier_aggregation_level;
+ uint8_t group_hop_flag;
+ uint8_t sequence_hop_flag;
+ // uint8_t nDMRS_type_A_pos;
+ uint8_t pad[3];
+ } fapi_config_req_vendor_msg_t;
+
+ typedef struct {
+ uint16_t sfn;
+ uint16_t slot;
+ uint32_t mode;
+#ifdef DEBUG_MODE
+ uint32_t count;
+ uint32_t period;
+#endif
+ } fapi_start_req_vendor_msg_t;
+
+ typedef struct {
+ uint16_t sfn;
+ uint16_t slot;
+ } fapi_stop_req_vendor_msg_t;
+
+ typedef struct {
+ fapi_msg_t header;
+ fapi_config_req_vendor_msg_t config_req_vendor;
+ fapi_start_req_vendor_msg_t start_req_vendor;
+ fapi_stop_req_vendor_msg_t stop_req_vendor;
+ } fapi_vendor_msg_t;
+
+ typedef struct {
+ fapi_msg_t header;
+ uint16_t sfn;
+ uint16_t slot;
+ uint32_t test_type;
+ } fapi_vendor_ext_shutdown_req_t;
+
+ typedef struct {
+ fapi_msg_t header;
+ uint16_t sfn;
+ uint16_t slot;
+ uint32_t nStatus;
+ } fapi_vendor_ext_shutdown_res_t;
+
+#ifdef DEBUG_MODE
+ typedef struct {
+ uint32_t carrNum;
+ uint32_t numSubframes;
+ uint32_t nIsRadioMode;
+ uint32_t timerModeFreqDomain;
+ uint32_t phaseCompensationEnable;
+ uint32_t startFrameNum;
+ uint32_t startSlotNum;
+ uint32_t startSymNum;
+ char filename_in_ul_iq[FAPI_MAX_IQ_SAMPLE_UL_VIRTUAL_PORTS]
+ [FAPI_MAX_IQ_SAMPLE_FILE_SIZE];
+ char filename_in_prach_iq[FAPI_MAX_IQ_SAMPLE_UL_VIRTUAL_PORTS]
+ [FAPI_MAX_IQ_SAMPLE_FILE_SIZE];
+ char filename_in_srs_iq[FAPI_MAX_IQ_SAMPLE_UL_ANTENNA]
+ [FAPI_MAX_IQ_SAMPLE_FILE_SIZE];
+ char filename_out_dl_iq[FAPI_MAX_IQ_SAMPLE_FILE_SIZE];
+ char filename_out_dl_beam[FAPI_MAX_IQ_SAMPLE_DL_PORTS]
+ [FAPI_MAX_IQ_SAMPLE_FILE_SIZE];
+ char filename_out_ul_beam[FAPI_MAX_IQ_SAMPLE_UL_VIRTUAL_PORTS]
+ [FAPI_MAX_IQ_SAMPLE_FILE_SIZE];
+ uint8_t buffer[FAPI_MAX_IQ_SAMPLE_BUFFER_SIZE];
+ } fapi_vendor_ext_iq_samples_info_t;
+
+ typedef struct {
+ fapi_msg_t header;
+ fapi_vendor_ext_iq_samples_info_t iq_samples_info;
+ } fapi_vendor_ext_iq_samples_req_t;
+
+ typedef struct {
+ fapi_msg_t header;
+ } fapi_vendor_ext_dl_iq_samples_res_t;
+
+ typedef struct {
+ fapi_msg_t header;
+ } fapi_vendor_ext_ul_iq_samples_res_t;
+
+ typedef struct {
+ fapi_msg_t header;
+ } fapi_vendor_ext_start_response_t;
+#endif
+
+#if defined(__cplusplus)
+}
+#endif
+#endif // FAPI_VENDOR_EXTENSION_H_
#include <arpa/inet.h>
#endif /* SS_WATCHDOG */
+#ifdef SS_USE_WLS_MEM
+#include <rte_common.h>
+#include <rte_debug.h>
+#include <rte_eal.h>
+#endif
+
/* header/extern include files (.x) */
#include "gen.x" /* general layer */
#include "sys/syscall.h"
#endif
-#if defined(RGL_SPECIFIC_CHANGES) || defined(INTEL_WLS)
+#if defined(RGL_SPECIFIC_CHANGES) || defined(INTEL_WLS) || defined(SS_USE_WLS_MEM)
#include <wls_lib.h>
#include <hugetlbfs.h>
#endif
-#ifdef INTEL_WLS
-void LwrMacRecvPhyMsg();
-#endif
-
#if defined(SPLIT_RLC_DL_TASK) && defined(RLC_MAC_STA_RSP_RBUF)
S16 rgBatchProc (Void);
#endif
{ SS_POOL_DYNAMIC, MT_POOL_1_DSIZE },
{ SS_POOL_DYNAMIC, MT_POOL_2_DSIZE },
{ SS_POOL_DYNAMIC, MT_POOL_3_DSIZE },
+ { SS_POOL_DYNAMIC, MT_POOL_4_DSIZE },
{ SS_POOL_STATIC, 0 }
}
}
{ SS_POOL_DYNAMIC, MT_POOL_1_DSIZE },
{ SS_POOL_DYNAMIC, MT_POOL_2_DSIZE },
{ SS_POOL_DYNAMIC, MT_POOL_3_DSIZE },
+ { SS_POOL_DYNAMIC, MT_POOL_4_DSIZE },
{ SS_POOL_STATIC, 0 }
}
},
{ SS_POOL_DYNAMIC, MT_POOL_1_DSIZE },
{ SS_POOL_DYNAMIC, MT_POOL_2_DSIZE },
{ SS_POOL_DYNAMIC, MT_POOL_3_DSIZE },
+ { SS_POOL_DYNAMIC, MT_POOL_4_DSIZE },
{ SS_POOL_STATIC, 0 }
}
},
{ SS_POOL_DYNAMIC, MT_POOL_1_DSIZE },
{ SS_POOL_DYNAMIC, MT_POOL_2_DSIZE },
{ SS_POOL_DYNAMIC, MT_POOL_3_DSIZE },
+ { SS_POOL_DYNAMIC, MT_POOL_4_DSIZE },
{ SS_POOL_STATIC, 0 }
}
},
{ SS_POOL_DYNAMIC, MT_POOL_1_DSIZE },
{ SS_POOL_DYNAMIC, MT_POOL_2_DSIZE },
{ SS_POOL_DYNAMIC, MT_POOL_3_DSIZE },
+ { SS_POOL_DYNAMIC, MT_POOL_4_DSIZE },
+ { SS_POOL_STATIC, 0 }
+ }
+ },
+ {
+ SS_DFLT_REGION + 5, SS_MAX_POOLS_PER_REG - 1,
+ {
+ { SS_POOL_DYNAMIC, MT_POOL_0_DSIZE },
+ { SS_POOL_DYNAMIC, MT_POOL_1_DSIZE },
+ { SS_POOL_DYNAMIC, MT_POOL_2_DSIZE },
+ { SS_POOL_DYNAMIC, MT_POOL_3_DSIZE },
+ { SS_POOL_DYNAMIC, MT_POOL_4_DSIZE },
{ SS_POOL_STATIC, 0 }
}
- }
+ }
#endif /* SS_LOCKLESS_MEMORY */
};
/* mt003.301 Modifications - File Based task registration made
{SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
{SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
{SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
- {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD}
+ {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
+ {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD}
}
},
{
{SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
{SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
{SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
- {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD}
+ {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
+ {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD}
}
},
{
{SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
{SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
{SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
- {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD}
+ {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
+ {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD}
}
},
{
{SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
{SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
{SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
- {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD}
+ {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
+ {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD}
}
},
{
{SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
{SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
{SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
- {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD}
+ {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
+ {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD}
+ }
+ },
+ {
+ SS_DFLT_REGION + 5, /* region id */
+ MT_MAX_BKTS, /* number of buckets */
+ {
+ /* block size, no. of blocks, Upper threshold, lower threshold */
+ {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
+ {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
+ {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
+ {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD},
+ {SS_BLK_RELEASE_THRESHOLD, SS_BLK_ACQUIRE_THRESHOLD}
}
}
#if ((defined (SPLIT_RLC_DL_TASK)) && (!defined (L2_L3_SPLIT)))
{MT_BKT_0_DSIZE, (MT_BKT_0_NUMBLKS + MT_BKT_0_NUMBLKS), SS_DFLT_MEM_BLK_SET_SIZE},
{MT_BKT_1_DSIZE, MT_BKT_1_NUMBLKS, SS_DFLT_MEM_BLK_SET_SIZE},
{MT_BKT_2_DSIZE, MT_BKT_2_NUMBLKS, SS_DFLT_MEM_BLK_SET_SIZE},
- {MT_BKT_3_DSIZE, MT_BKT_3_NUMBLKS, SS_DFLT_MEM_BLK_SET_SIZE}
+ {MT_BKT_3_DSIZE, MT_BKT_3_NUMBLKS, SS_DFLT_MEM_BLK_SET_SIZE},
+ {MT_BKT_4_DSIZE, MT_BKT_4_NUMBLKS, SS_DFLT_MEM_BLK_SET_SIZE}
#else
{1024, 12800 /* MT_BKT_0_NUMBLKS */, SS_DFLT_MEM_BLK_SET_SIZE},
{1664, 12800 /* MT_BKT_1_NUMBLKS */, SS_DFLT_MEM_BLK_SET_SIZE},
{MT_BKT_0_DSIZE, MT_BKT_0_STATIC_NUMBLKS}, /* block size, no. of blocks */
{MT_BKT_1_DSIZE, MT_BKT_1_STATIC_NUMBLKS}, /* block size, no. of blocks */
{MT_BKT_2_DSIZE, MT_BKT_2_STATIC_NUMBLKS}, /* block size, no. of blocks */
- {MT_BKT_3_DSIZE, MT_BKT_3_STATIC_NUMBLKS} /* block size, no. of blocks */
+ {MT_BKT_3_DSIZE, MT_BKT_3_STATIC_NUMBLKS}, /* block size, no. of blocks */
+ {MT_BKT_4_DSIZE, MT_BKT_4_STATIC_NUMBLKS}
#else
{256, 491520}, /* 60 pages of 2M*/
{512, 12288}, /* 3 pages of 2M */
{MT_BKT_0_DSIZE, MT_BKT_0_STATIC_NUMBLKS}, /* block size, no. of blocks */
{MT_BKT_1_DSIZE, MT_BKT_1_STATIC_NUMBLKS}, /* block size, no. of blocks */
{MT_BKT_2_DSIZE, MT_BKT_2_STATIC_NUMBLKS}, /* block size, no. of blocks */
- {MT_BKT_3_DSIZE, MT_BKT_3_STATIC_NUMBLKS} /* block size, no. of blocks */
+ {MT_BKT_3_DSIZE, MT_BKT_3_STATIC_NUMBLKS}, /* block size, no. of blocks */
+ {MT_BKT_4_DSIZE, MT_BKT_4_STATIC_NUMBLKS} /* block size, no. of blocks */
}
},
{
{MT_BKT_0_DSIZE, MT_BKT_0_STATIC_NUMBLKS}, /* block size, no. of blocks */
{MT_BKT_1_DSIZE, MT_BKT_1_STATIC_NUMBLKS}, /* block size, no. of blocks */
{MT_BKT_2_DSIZE, MT_BKT_2_STATIC_NUMBLKS}, /* block size, no. of blocks */
- {MT_BKT_3_DSIZE, MT_BKT_3_STATIC_NUMBLKS} /* block size, no. of blocks */
+ {MT_BKT_3_DSIZE, MT_BKT_3_STATIC_NUMBLKS}, /* block size, no. of blocks */
+ {MT_BKT_4_DSIZE, MT_BKT_4_STATIC_NUMBLKS} /* block size, no. of blocks */
}
},
{
{MT_BKT_0_DSIZE, MT_BKT_0_STATIC_NUMBLKS}, /* block size, no. of blocks */
{MT_BKT_1_DSIZE, MT_BKT_1_STATIC_NUMBLKS}, /* block size, no. of blocks */
{MT_BKT_2_DSIZE, MT_BKT_2_STATIC_NUMBLKS}, /* block size, no. of blocks */
- {MT_BKT_3_DSIZE, MT_BKT_3_STATIC_NUMBLKS} /* block size, no. of blocks */
+ {MT_BKT_3_DSIZE, MT_BKT_3_STATIC_NUMBLKS}, /* block size, no. of blocks */
+ {MT_BKT_4_DSIZE, MT_BKT_4_STATIC_NUMBLKS} /* block size, no. of blocks */
}
},
{
{MT_BKT_0_DSIZE, MT_BKT_0_STATIC_NUMBLKS}, /* block size, no. of blocks */
{MT_BKT_1_DSIZE, MT_BKT_1_STATIC_NUMBLKS}, /* block size, no. of blocks */
{MT_BKT_2_DSIZE, MT_BKT_2_STATIC_NUMBLKS}, /* block size, no. of blocks */
- {MT_BKT_3_DSIZE, MT_BKT_3_STATIC_NUMBLKS} /* block size, no. of blocks */
+ {MT_BKT_3_DSIZE, MT_BKT_3_STATIC_NUMBLKS}, /* block size, no. of blocks */
+ {MT_BKT_4_DSIZE, MT_BKT_4_STATIC_NUMBLKS} /* block size, no. of blocks */
+ }
+ },
+ {
+ SS_DFLT_REGION + 5, /* region id */
+ MT_MAX_BKTS, /* number of buckets */
+ MT_HEAP_SIZE, /* heap size */
+ {
+ {MT_BKT_0_DSIZE, MT_BKT_0_STATIC_NUMBLKS}, /* block size, no. of blocks */
+ {MT_BKT_1_DSIZE, MT_BKT_1_STATIC_NUMBLKS}, /* block size, no. of blocks */
+ {MT_BKT_2_DSIZE, MT_BKT_2_STATIC_NUMBLKS}, /* block size, no. of blocks */
+ {MT_BKT_3_DSIZE, MT_BKT_3_STATIC_NUMBLKS}, /* block size, no. of blocks */
+ {MT_BKT_4_DSIZE, MT_BKT_4_STATIC_NUMBLKS} /* block size, no. of blocks */
}
}
-
#endif /* SS_LOCKLESS_MEMORY */
STATIC_MEM_CFG
}
S8 *msOptArg; /* SGetOpt vars */
-#ifdef INTEL_WLS
+#if defined (INTEL_WLS) || defined (SS_USE_WLS_MEM)
typedef struct _MtRegMemSz
{
uint32_t reqdSz;
uint8_t *startAddr;
}MtRegMemSz;
+#ifdef SS_USE_WLS_MEM
+static MtRegMemSz mtDynMemSz[MT_MAX_BKTS];
+static S16 SPartitionWlsDynMem();
+static S16 SAllocateWlsDynMem();
+#endif
+#ifdef INTEL_WLS
static MtRegMemSz mtRegMemSz[MT_MAX_BKTS+1];
#endif
+#endif
\f
/* private variable declarations */
/*mt010.301 - removed veriable defined for FA*/
-#ifdef INTEL_WLS
+#if defined (INTEL_WLS) || defined (SS_USE_WLS_MEM)
#ifdef NTL_LIB
void mtSetNtlHdl(unsigned int hdl)
}
#endif /* NTL_LIB */
-
-void * mtGetWlsHdl()
+void mtGetWlsHdl(void **hdlr)
{
- return (osCp.wls.intf);
-}
+ *hdlr = osCp.wls.intf;
+}
#ifdef XEON_MULTIPLE_CELL_CHANGES
S8 gWrWlsDeviceName[MAX_WLS_DEVICE_NAME_LEN];
static int SOpenWlsIntf()
{
+ uint8_t i;
void *hdl;
- #define WLS_DEVICE_NAME "/dev/wls"
+ #define WLS_DEVICE_NAME "wls0"
+
+ char *my_argv[] = {"gnodeb", "-c3", "--proc-type=auto", "--file-prefix", WLS_DEVICE_NAME, "--iova-mode=pa"};
+ printf("Calling rte_eal_init: ");
+ for (i = 0; i < RTE_DIM(my_argv); i++)
+ {
+ printf("%s ", my_argv[i]);
+ }
+ printf("\n");
+
+ if (rte_eal_init(RTE_DIM(my_argv), my_argv) < 0)
+ rte_panic("Cannot init EAL\n");
+
#ifdef XEON_SPECIFIC_CHANGES
#ifdef XEON_MULTIPLE_CELL_CHANGES
hdl = WLS_Open(WLS_DEVICE_NAME, 1);
#endif
#else
- hdl = WLS_Open(WLS_DEVICE_NAME, WLS_MASTER_CLIENT, (512 *1024 * 1024));
+ hdl = WLS_Open(WLS_DEVICE_NAME, WLS_MASTER_CLIENT, WLS_MEM_SIZE);
#endif
osCp.wls.intf = hdl;
} /* end of if statement */
#endif
-#ifdef INTEL_WLS
+#if defined (INTEL_WLS) || defined (SS_USE_WLS_MEM)
if(!SOpenWlsIntf())
return (0);
#endif /* INTEL_WLS */
RegionMemLeakInfo regMemLeakInfo;
#endif /* T2K_MEM_LEAK_DBG */
+#ifdef SS_USE_WLS_MEM
+static S16 SPartitionWlsDynMem()
+{
+ uint32_t i;
+ uint8_t *bktMemStrtAddr = (uint8_t *)(((uint8_t*)osCp.wls.allocAddr) + (4 * 1024 * 1024));
+
+ for (i = 0 ; i < mtGlobMemoCfg.numBkts ; i++)
+ {
+ mtDynMemSz[i].startAddr = bktMemStrtAddr;
+ bktMemStrtAddr += mtDynMemSz[i].reqdSz;
+ }
+
+ printf("Global Memory Info: \n");
+ for (i = 0 ; i < mtGlobMemoCfg.numBkts ; i++)
+ {
+ printf("mtDynMemSz[%d]: [0x%016lx]\n", i, (unsigned long int)mtDynMemSz[i].startAddr);
+ }
+ return ROK;
+}
+
+static S16 SAllocateWlsDynMem()
+{
+ uint32_t reqdMemSz;
+ uint32_t i;
+ reqdMemSz = 0;
+ memset(&mtDynMemSz[0], 0, sizeof(mtDynMemSz));
+
+ for (i = 0 ; i < mtGlobMemoCfg.numBkts ; i++)
+ {
+ reqdMemSz += (mtGlobMemoCfg.bkt[i].blkSize * mtGlobMemoCfg.bkt[i].numBlks);
+ mtDynMemSz[i].reqdSz += (mtGlobMemoCfg.bkt[i].blkSize * mtGlobMemoCfg.bkt[i].numBlks);
+ }
+ osCp.wls.allocAddr = WLS_Alloc(osCp.wls.intf,
+#ifdef INTEL_L1_V19_10
+ WLS_MEMORY_SIZE);
+#else
+ (reqdMemSz + (4 * 1024 * 1024)));
+#endif
+ printf("\n *************** \n WLS memory: %lx, %d\n", (PTR)osCp.wls.allocAddr, reqdMemSz);
+ SPartitionWlsDynMem();
+ return ROK;
+}
+
+#endif
+
#ifdef INTEL_WLS
S16 SPartitionWlsMemory()
globReg = (CmMmGlobRegCb *)osCp.globRegCb;
+#ifdef SS_USE_WLS_MEM
+ SAllocateWlsDynMem();
+#endif
+
for(i = 0; i < mtGlobMemoCfg.numBkts; i++)
{
memSize = (mtGlobMemoCfg.bkt[i].blkSize * mtGlobMemoCfg.bkt[i].numBlks);
+#if !defined (INTEL_WLS) && defined (SS_USE_WLS_MEM)
+ globReg->bktTbl[i].startAddr = (Data *)mtDynMemSz[i].startAddr;
+ printf("Starting Address of Bkt Entry [%d]: [0x%016lx], memSize[%d]\n", i, (unsigned long int)globReg->bktTbl[i].startAddr, memSize);
+#else
#ifndef INTEL_WLS
globReg->bktTbl[i].startAddr = (Data *)calloc(memSize, sizeof(Data));
#else
globReg->bktTbl[i].startAddr = (Data *)mtRegMemSz[i].startAddr;
+#endif
#endif
if(globReg->bktTbl[i].startAddr == NULLP)
{
#endif
return RFAILED;
}
+ dynRegCb->bktTbl[k].poolId = k;
dynRegCb->bktTbl[k].size = mtGlobMemoCfg.bkt[k].blkSize;
dynRegCb->bktTbl[k].blkSetRelThreshold = mtDynMemoCfg.region[i].bkt[k].blkSetRelThreshold;
dynRegCb->bktTbl[k].blkSetAcquireThreshold = mtDynMemoCfg.region[i].bkt[k].blkSetAcquireThreshold;
#endif
while (1)
{
-#ifndef ODU_TEST_STUB
-#ifdef INTEL_WLS
- LwrMacRecvPhyMsg();
-#endif
-#endif
/* Wait for a message from the demand queue */
#ifdef SS_CDMNDQ_SUPPORT
ret = ssCDmndQWait(&sTsk->dQ);
#define SS_MAX_TTSKS 100
#ifndef SS_MULTICORE_SUPPORT
-#define SS_MAX_STSKS 7
+#define SS_MAX_STSKS 6
#else
/* mt001.301 : Additions */
#ifdef SPLIT_RLC_DL_TASK
#define SS_MAX_STSKS 5
#endif
#else
-#define SS_MAX_STSKS 5
+#define SS_MAX_STSKS 6
#endif
#endif /* SS_MULTICORE_SUPPORT */
#else /* SS_MULTIPLE_PROCS */
#define SS_MAX_TTSKS 1000
-#define SS_MAX_STSKS 7
+#define SS_MAX_STSKS 6
#endif /* SS_MULTIPLE_PROCS */
#ifdef SS_DRVR_SUPPORT
#ifdef SS_MULTICORE_SUPPORT
#define SS_MAX_REGS SS_MAX_STSKS
#else
-#define SS_MAX_REGS 5
+#define SS_MAX_REGS 6
#endif
#ifdef CMM_MAX_BKT_ENT
#ifdef XEON_SPECIFIC_CHANGES
#define MT_BKT_0_NUMBLKS 5248 /* 10500 Modified from 3500 to 10500 */
#else
+#ifdef SS_USE_WLS_MEM
+#define MT_BKT_0_NUMBLKS 200704 /* 10500 Modified from 3500 to 10500 */
+#else
#define MT_BKT_0_NUMBLKS 10000 /* 10500 Modified from 3500 to 10500 */
#endif
+#endif
#else
#define MT_BKT_0_NUMBLKS 10000
#endif
#else
#define MT_BKT_1_DSIZE 1280 /* Modified from 256 to 4096 */
#endif
+#ifdef SS_USE_WLS_MEM
+#define MT_BKT_1_NUMBLKS 310720 /* 1000*/
+#else
#define MT_BKT_1_NUMBLKS 10496 /* 1000*/
+#endif
#else
/*mt010.301*/
#define MT_BKT_1_DSIZE 256
#define MT_BKT_3_DSIZE 4224 /* Fill in this value as required */
#define MT_BKT_3_NUMBLKS 5248 /*10496 */ /* Fill in this value as required */
#else
-#define MT_BKT_3_DSIZE 12000 /* Fill in this value as required */
+#define MT_BKT_3_DSIZE 12200 /* Fill in this value as required */
#define MT_BKT_3_NUMBLKS 1000 /*10496 */ /* Fill in this value as required */
#endif
#endif
+#define MT_BKT_4_DSIZE 65000
+#define MT_BKT_4_NUMBLKS 1000
+
/* For Non-Sharable regions/static regions */
#ifdef XEON_SPECIFIC_CHANGES
#define MT_BKT_0_STATIC_NUMBLKS 500000 /* Fill in this value as required */
#define MT_BKT_1_STATIC_NUMBLKS 15000 /* Fill in this value as required */
#define MT_BKT_2_STATIC_NUMBLKS 500 /* Fill in this value as required */
#define MT_BKT_3_STATIC_NUMBLKS 1600 /* Fill in this value as required */
+#define MT_BKT_4_STATIC_NUMBLKS 1000 /* Fill in this value as required */
#endif
/*mt010.301*/
#ifdef RGL_SPECIFIC_CHANGES
#define MT_MAX_BKTS 5
#else
-#define MT_MAX_BKTS 4
+#define MT_MAX_BKTS 5
#endif
/* mt029.201 corrected typos */
/* memory pool data size definitions for pool-to-size mapping table */
+#define MT_POOL_4_DSIZE (MT_BKT_4_DSIZE-(sizeof(SsMblk)+sizeof(SsDblk)))
#define MT_POOL_3_DSIZE (MT_BKT_3_DSIZE-(sizeof(SsMblk)+sizeof(SsDblk)))
#define MT_POOL_2_DSIZE (MT_BKT_2_DSIZE-(sizeof(SsMblk)+sizeof(SsDblk)))
#define MT_POOL_1_DSIZE (MT_BKT_1_DSIZE-(sizeof(SsMblk)+sizeof(SsDblk)))
#endif
#endif
+#define WLS_MEM_SIZE 0x7ec00000 /* Total size of WLS memory configured */
#endif /* __MTSSH__ */
} SLoggerInfo;
#endif /* SS_LOGGER_SUPPORT */
-#ifdef INTEL_WLS
+#if defined (INTEL_WLS) || defined (SS_USE_WLS_MEM)
typedef struct _MtWls
{
Void *intf;
SLoggerInfo logger;
#endif /* SS_LOGGER_SUPPORT */
S8 *configFilePath;
-#ifdef INTEL_WLS
+#if defined (INTEL_WLS) || defined (SS_USE_WLS_MEM)
SsMtWls wls;
#endif
}
#endif /* SS_LOCKLESS_MEMORY */
-#ifdef INTEL_WLS
+#ifdef INTEL_WLS_MEM
#ifndef SS_LOCKLESS_MEMORY
#ifdef ANSI
S16 SGetStaticBuffer
void l1HdlConfigReq(uint32_t msgLen, void *msg)
{
#ifdef INTEL_FAPI
- fapi_config_req_t *configReq = (fapi_config_req_t *)msg;
+ fapi_config_req_t *configReq = (fapi_config_req_t *)(msg +1);
DU_LOG("\nPHY_STUB: Received Config Request in PHY");
/* Handling CONFIG RESPONSE */
- if(l1BldAndSndConfigRsp(msg)!= ROK)
+ if(l1BldAndSndConfigRsp(configReq)!= ROK)
{
printf("\nPHY_STUB: Failed Sending config Response");
}
- MAC_FREE(configReq, msgLen);
+ MAC_FREE(msg, msgLen);
#endif
}
S16 l1HdlStartReq(uint32_t msgLen, void *msg)
{
#ifdef INTEL_FAPI
- fapi_start_req_t *startReq = (fapi_start_req_t *)msg;
-
if(lwrMacCb.phyState == PHY_STATE_CONFIGURED)
{
l1HdlSlotIndicaion(FALSE);
- MAC_FREE(startReq, sizeof(fapi_start_req_t));
+ MAC_FREE(msg, msgLen);
}
else
{
DU_LOG("\nPHY_STUB: Received Start Req in PHY State %d", lwrMacCb.phyState);
+ MAC_FREE(msg, msgLen);
return RFAILED;
}
#endif
pduInfo->rnti = pucchPdu.rnti;
pduInfo->timingAdvance = 0;
pduInfo->rssi = 0;
- pduInfo->uciBits[idx] = 0; //TODO: FAPI spec ver. 222.10.01 has no info about UCI Bits
if(pduInfo->pduBitmap & SR_PDU_BITMASK)
{
pduInfo->srInfo.srIndication = SR_DETECTED;
Code Review / o-du / l2.git / commitdiff