X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=fhi_lib%2Flib%2Fapi%2Fxran_fh_o_du.h;h=bacf597693aabbb2baa8b5124e4e308d37634129;hb=HEAD;hp=62746628d34e3a1f4d1a7c052aa1900e0c33fc48;hpb=cef07f74965b1749dd909fc1322e211489fea2ea;p=o-du%2Fphy.git diff --git a/fhi_lib/lib/api/xran_fh_o_du.h b/fhi_lib/lib/api/xran_fh_o_du.h index 6274662..bacf597 100644 --- a/fhi_lib/lib/api/xran_fh_o_du.h +++ b/fhi_lib/lib/api/xran_fh_o_du.h @@ -1,6 +1,6 @@ /****************************************************************************** * -* Copyright (c) 2019 Intel. +* Copyright (c) 2020 Intel. * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -16,7 +16,6 @@ * *******************************************************************************/ - /** * @brief This file provides public interface to xRAN Front Haul layer implementation as defined in the * ORAN-WG4.CUS.0-v01.00 spec. Implementation specific to @@ -52,6 +51,7 @@ extern "C" { #include #include + #define XRAN_STATUS_SUCCESS (0) /**< * @ingroup xran @@ -100,23 +100,49 @@ extern "C" { /** Macro to calculate Symbol number for given slot from symbol index */ #define XranGetSymNum(symIdx, numSymPerTti) (((uint32_t)symIdx % (uint32_t)numSymPerTti)) /** Macro to calculate Frame number for given tti */ -#define XranGetFrameNum(tti,numSubFramePerSystemFrame, numSlotPerSubFrame) ((uint32_t)tti / ((uint32_t)numSubFramePerSystemFrame * (uint32_t)numSlotPerSubFrame)) +#define XranGetFrameNum(tti,SFNatSecStart,numSubFramePerSystemFrame, numSlotPerSubFrame) ((((uint32_t)tti / ((uint32_t)numSubFramePerSystemFrame * (uint32_t)numSlotPerSubFrame)) + SFNatSecStart) & 0x3FF) /** Macro to calculate Subframe number for given tti */ #define XranGetSubFrameNum(tti, numSlotPerSubFrame, numSubFramePerSystemFrame) (((uint32_t)tti/(uint32_t)numSlotPerSubFrame) % (uint32_t)numSubFramePerSystemFrame) /** Macro to calculate Slot number */ #define XranGetSlotNum(tti, numSlotPerSfn) ((uint32_t)tti % ((uint32_t)numSlotPerSfn)) -#define XRAN_PORTS_NUM (1) /**< number of XRAN ports (aka O-RU devices) supported */ -#define XRAN_N_FE_BUF_LEN (80) /**< Number of TTIs (slots) */ -#define XRAN_MAX_SECTOR_NR (12) /**< Max sectors per XRAN port */ -#define XRAN_MAX_ANTENNA_NR (4) /**< Max antenna per port */ +#define XRAN_PORTS_NUM (8) /**< number of XRAN ports (aka O-RU|O-DU devices) supported */ +#define XRAN_ETH_PF_LINKS_NUM (4) /**< number of Physical Ethernet links per one O-RU|O-DU */ +#define XRAN_MAX_PRACH_ANT_NUM (4) /**< number of XRAN Prach ports supported */ + +#if defined(XRAN_O_RU_BUILD) + #define XRAN_N_FE_BUF_LEN (20) /**< Number of TTIs (slots) */ +#else +#define XRAN_N_FE_BUF_LEN (20) /**< Number of TTIs (slots) */ +#endif + +#define XRAN_MAX_SECTOR_NR (16) /**< Max sectors per XRAN port */ +#define XRAN_MAX_ANTENNA_NR (16) /**< Max number of extended Antenna-Carriers: + a data flow for a single antenna (or spatial stream) for a single carrier in a single sector */ + +/* see 10.2 Hierarchy of Radiation Structure in O-RU (assume TX and RX panel are the same dimensions)*/ +#define XRAN_MAX_PANEL_NR (1) /**< Max number of Panels supported per O-RU */ +#define XRAN_MAX_TRX_ANTENNA_ARRAY (1) /**< Max number of TX and RX arrays per panel in O-RU */ +#define XRAN_MAX_ANT_ARRAY_ELM_NR (64) /**< Maximum number of Antenna Array Elemets in Antenna Array in the O-RU */ + #define XRAN_NUM_OF_SYMBOL_PER_SLOT (14) /**< Number of symbols per slot */ -#define XRAN_MAX_TDD_PERIODICITY (80) /**< Max TDD pattern period */ +#define XRAN_MAX_NUM_OF_SRS_SYMBOL_PER_SLOT XRAN_NUM_OF_SYMBOL_PER_SLOT /**< Max Number of SRS symbols per slot */ +#define XRAN_MAX_TDD_PERIODICITY (80) /**< Max TDD pattern period */ #define XRAN_MAX_CELLS_PER_PORT (XRAN_MAX_SECTOR_NR) /**< Max cells mapped to XRAN port */ #define XRAN_COMPONENT_CARRIERS_MAX (XRAN_MAX_SECTOR_NR) /**< number of CCs */ #define XRAN_NUM_OF_ANT_RADIO (XRAN_MAX_SECTOR_NR*XRAN_MAX_ANTENNA_NR) /**< Max Number of Antennas supported for all CC on single XRAN port */ #define XRAN_MAX_PRBS (275) /**< Max of PRBs per CC per antanna for 5G NR */ +#define XRAN_NUM_OF_SC_PER_RB (12) /**< Number of subcarriers per RB */ + +#define XRAN_MAX_DSS_PERIODICITY (15) /**< Max DSS pattern period */ +#define XRAN_MAX_SECTIONS_PER_SLOT (273) /**< Max number of different sections in single slot (section may be equal to RB allocation for UE) */ +#define XRAN_MIN_SECTIONS_PER_SLOT (6) /**< Min number of different sections in single slot (section may be equal to RB allocation for UE) */ +#define XRAN_MAX_SECTIONS_PER_SYM (XRAN_MAX_SECTIONS_PER_SLOT) /**< Max number of different sections in single slot (section may be equal to RB allocation for UE) */ +#define XRAN_MIN_SECTIONS_PER_SYM (XRAN_MIN_SECTIONS_PER_SLOT) /**< Min number of different sections in single slot (section may be equal to RB allocation for UE) */ + +#define XRAN_MAX_FRAGMENT (4) /**< Max number of fragmentations in single symbol */ +#define XRAN_MAX_SET_BFWS (64) /**< Assumed 64Ant, BFP 9bit with 9K jumbo frame */ #define XRAN_MAX_PKT_BURST (448+4) /**< 4x14x8 symbols per ms */ #define XRAN_N_MAX_BUFFER_SEGMENT XRAN_MAX_PKT_BURST /**< Max number of segments per ms */ @@ -141,6 +167,14 @@ extern "C" { //#define _XRAN_DEBUG /**< Enable debug log */ //#define _XRAN_VERBOSE /**< Enable verbose log */ +#define MX_NUM_SAMPLES (16)/**< MAX Number of Samples for One Way delay Measurement */ + +#define XRAN_VF_QUEUE_MAX (XRAN_MAX_ANTENNA_NR*2+XRAN_MAX_ANT_ARRAY_ELM_NR) /**< MAX number of HW queues for given VF */ + +#define XRAN_HALF_CB_SYM 0 /**< Half of the Slot (offset +7) */ +#define XRAN_THREE_FOURTHS_CB_SYM 3 /**< 2/4 of the Slot (offset +7) */ +#define XRAN_FULL_CB_SYM 7 /**< Full Slot (offset +7) */ +#define XRAN_ONE_FOURTHS_CB_SYM 12 /**< 1/4 of the Slot (offset +7) */ #ifdef _XRAN_DEBUG #define xran_log_dbg(fmt, ...) \ @@ -179,7 +213,8 @@ enum xran_if_state { XRAN_INIT = 0, XRAN_RUNNING, - XRAN_STOPPED + XRAN_STOPPED, + XRAN_OWDM }; /** @@ -203,7 +238,7 @@ enum xran_compression_method { * @ingroup xran * * @description - * Callback function type for symbol packet enum + * enum of callback function type ids for TTI *****************************************************************************/ enum callback_to_phy_id { @@ -213,46 +248,117 @@ enum callback_to_phy_id XRAN_CB_MAX /**< max number of callbacks */ }; +/** + ****************************************************************************** + * @ingroup xran + * + * @description + * enum of callback function type ids for sumbol + *****************************************************************************/ +enum cb_per_sym_type_id +{ + XRAN_CB_SYM_OTA_TIME = 0, /**< callback on exact SYM OTA time (+-SW jitter) */ + XRAN_CB_SYM_RX_WIN_BEGIN = 1, /**< callback on exact SYM RX window start time (+-SW jitter) */ + XRAN_CB_SYM_RX_WIN_END = 2, /**< callback on exact SYM RX window stop time (+-SW jitter) */ + XRAN_CB_SYM_TX_WIN_BEGIN = 3, /**< callback on exact SYM TX window start time (+-SW jitter) */ + XRAN_CB_SYM_TX_WIN_END = 4, /**< callback on exact SYM TX window stop time (+-SW jitter) */ + XRAN_CB_SYM_CP_DL_WIN_BEGIN = 5, /**< callback on exact SYM DL CP window start time (+-SW jitter) */ + XRAN_CB_SYM_CP_DL_WIN_END = 6, /**< callback on exact SYM DL CP window stop time (+-SW jitter) */ + XRAN_CB_SYM_CP_UL_WIN_BEGIN = 7, /**< callback on exact SYM UL CP window start time (+-SW jitter) */ + XRAN_CB_SYM_CP_UL_WIN_END = 8, /**< callback on exact SYM UL CP window stop time (+-SW jitter) */ + XRAN_CB_SYM_MAX /**< max number of types of callbacks */ +}; + +/** Beamforming type, enumerated as "frequency", "time" or "hybrid" + section 10.4.2 Weight-based dynamic beamforming */ +enum xran_weight_based_beamforming_type { + XRAN_BF_T_FREQUENCY = 0, + XRAN_BF_T_TIME = 1, + XRAN_BF_T_HYBRID = 2, + XRAN_BF_T_MAX +}; + +/** contains time related information according to type of event */ +struct xran_sense_of_time { + enum cb_per_sym_type_id type_of_event; /**< event type id */ + uint32_t tti_counter; /**< TTI counter with in GPS second */ + uint32_t nSymIdx; /**< Symbol Idx with in Slot [0-13] */ + uint32_t nFrameIdx; /**< ORAN Frame */ + uint32_t nSubframeIdx; /**< ORAN Subframe */ + uint32_t nSlotIdx; /**< Slot within subframe */ + uint64_t nSecond; /**< GPS second of this symbol */ +}; + typedef int32_t xran_status_t; /**< Xran status return value */ /** callback function type for Symbol packet */ -typedef void (*xran_callback_sym_fn)(void*); +typedef int32_t (*xran_callback_sym_fn)(void*, struct xran_sense_of_time* p_sense_of_time); /** Callback function type for TTI event */ -typedef int (*xran_fh_tti_callback_fn)(void*); +typedef int32_t (*xran_fh_tti_callback_fn)(void*); /** Callback function type packet arrival from transport layer (ETH or IP) */ -typedef void (*xran_transport_callback_fn)(void*, int32_t); +typedef void (*xran_transport_callback_fn)(void*, xran_status_t); /** Callback functions to poll BBdev encoder */ typedef int16_t (*phy_encoder_poll_fn)(void); -/** Callback functions to poll BBdev secoder */ +/** Callback functions to poll BBdev decoder */ typedef int16_t (*phy_decoder_poll_fn)(void); - /** XRAN port enum */ enum xran_vf_ports { XRAN_UP_VF = 0, /**< port type for U-plane */ XRAN_CP_VF, /**< port type for C-plane */ + XRAN_UP_VF1, /**< port type for U-plane */ + XRAN_CP_VF1, /**< port type for C-plane */ + XRAN_UP_VF2, /**< port type for U-plane */ + XRAN_CP_VF2, /**< port type for C-plane */ + XRAN_UP_VF3, /**< port type for U-plane */ + XRAN_CP_VF3, /**< port type for C-plane */ + XRAN_UP_VF4, /**< port type for U-plane */ + XRAN_CP_VF4, /**< port type for C-plane */ + XRAN_UP_VF5, /**< port type for U-plane */ + XRAN_CP_VF5, /**< port type for C-plane */ + XRAN_UP_VF6, /**< port type for U-plane */ + XRAN_CP_VF6, /**< port type for C-plane */ + XRAN_UP_VF7, /**< port type for U-plane */ + XRAN_CP_VF7, /**< port type for C-plane */ XRAN_VF_MAX }; +/** XRAN Radio Access technology enum */ +enum xran_ran_tech +{ + XRAN_RAN_5GNR = 0, /**< 5G NR */ + XRAN_RAN_LTE = 1, /**< LTE */ + XRAN_RAN_MAX +}; + +/** XRAN user data compression header handling types */ +enum xran_comp_hdr_type +{ + XRAN_COMP_HDR_TYPE_DYNAMIC = 0, /**< dynamic data format where U-plane udCompHdr controls compression parameters */ + XRAN_COMP_HDR_TYPE_STATIC = 1, /**< static data format where M-plane defines compression parameters */ + XRAN_COMP_HDR_TYPE_MAX +}; + /** XRAN category enum */ enum xran_category { - XRAN_CATRGORY_A = 0, - XRAN_CATRGORY_B = 1, - XRAN_CATRGORY_MAX + XRAN_CATEGORY_A = 0, /**< 5G NR Category A */ + XRAN_CATEGORY_B = 1, /**< 5G NR Category B */ + XRAN_CATEGORY_MAX }; /** type of beamforming */ enum xran_beamforming_type { XRAN_BEAM_ID_BASED = 0, /**< beam index based */ - XRAN_BEAM_WEIGHT, /**< beam forming weights */ - XRAN_BEAM_ATTRIBUTE, /**< beam index based */ + XRAN_BEAM_WEIGHT = 1, /**< beam forming weights */ + XRAN_BEAM_ATTRIBUTE = 2, /**< beam index based */ + XRAN_BEAM_TYPE_MAX }; /** state of bbdev with xran */ @@ -261,21 +367,75 @@ enum xran_bbdev_init XRAN_BBDEV_NOT_USED = -1, /**< BBDEV is disabled */ XRAN_BBDEV_MODE_HW_OFF = 0, /**< BBDEV is enabled for SW sim mode */ XRAN_BBDEV_MODE_HW_ON = 1, /**< BBDEV is enable for HW */ + XRAN_BBDEV_MODE_HW_SW = 2, /**< BBDEV for SW and HW is enabled */ XRAN_BBDEV_MODE_MAX }; +/** callback return information */ +struct xran_cb_tag { + uint16_t cellId; + uint16_t oXuId; + uint32_t symbol; + uint32_t slotiId; +}; + +/** Common Data for ecpri one-way delay measurements */ +struct xran_ecpri_del_meas_cmn { + uint16_t initiator_en; // Initiator 1, Recipient 0 + uint16_t numberOfSamples; // Total number of samples to be collected and averaged + uint32_t filterType; // Average for number of samples collected 0 + uint64_t responseTo; // Response Timeout in ns + uint16_t measVf; // Vf using the owd transmitter + uint16_t measState; // The state of the owd Transmitter: OWDMTX_DIS,OWDMTX_INIT,OWDMTX_IDLE,OWDMTX_ACTIVE,OWDTX_DONE + uint16_t measId; // Measurement Id to be used by the transmitter + uint16_t measMethod; // Measurement Method i.e. REQUEST, REM_REQ, REQ_WFUP or REM_REQ_WFUP + uint16_t owdm_enable; // 1: Enabled 0:Disabled + uint16_t owdm_PlLength; // Payload Length 44 <= PlLength <= 1400 +}; + +/** Port specific data for ecpri one-way delay measurements */ +struct xran_ecpri_del_meas_port { + uint64_t t1; // ecpri ts1 + uint64_t t2; // ecpri ts2 + uint64_t tr; // ecpri tr + int64_t delta; // stores differences based on the msState + uint8_t portid; // portid for this owdm + uint8_t runMeas; // run One Way Delay measurements for numberOfSamples + uint16_t currentMeasID; // Last Measurement ID received, for originator use as base for the Measurement ID being send out + uint16_t msState; // Measurement State for Initiator: Idle, Waiting_Response, Waiting_Request, Waiting_Request_with_fup, Waiting_fup, Done + // Measurement State for Recipient: Idle, Waiting_Response, Waiting_Follow_up, Done + uint16_t numMeas; // Number of Measurements completed (Running number up to common config numberOfSamples + uint16_t txDone; // For originator clear after each change of state and set once the transmission is done + uint64_t rspTimerIdx; // Timer Index for TimeOut Timer. On timeout abort current measurement and go back to idle state + uint64_t delaySamples[MX_NUM_SAMPLES]; // Storage for collected delay samples i.e. td + uint64_t delayAvg; // Contains the average based on the numberOfSamples for the delay, gets computed once we have + // completed the collection for all the numberOfSamples prescribed +}; + /** DPDK IO configuration for XRAN layer */ struct xran_io_cfg { uint8_t id; /**< should be (0) for O-DU or (1) O-RU (debug) */ + uint8_t num_vfs; /**< number of VFs for C-plane and U-plane (should be even) */ + uint16_t num_rxq; /**< number of RX queues per VF */ char *dpdk_dev[XRAN_VF_MAX]; /**< VFs devices */ - char *bbdev_dev[1]; /**< BBDev dev name */ - int32_t bbdev_mode; /**< DPDK for BBDev */ - int32_t core; /**< reservd */ - int32_t system_core; /**< reservd */ - int32_t pkt_proc_core; /**< reservd */ - int32_t pkt_aux_core; /**< reservd */ - int32_t timing_core; /**< core used by xRAN */ - int32_t port[XRAN_VF_MAX]; /**< VFs ports */ + char *bbdev_dev[1]; /**< BBDev dev name */ + int32_t bbdev_mode; /**< DPDK for BBDev */ + uint32_t dpdkIoVaMode; /**< IOVA Mode */ + uint32_t dpdkMemorySize; /**< DPDK max memory allocation */ + int32_t core; /**< reserved */ + int32_t system_core; /**< reserved */ + uint64_t pkt_proc_core; /**< worker mask 0-63 */ + uint64_t pkt_proc_core_64_127; /**< worker mask 64-127 */ + int32_t pkt_aux_core; /**< reserved */ + int32_t timing_core; /**< core used by xRAN */ + int32_t port[XRAN_VF_MAX]; /**< VFs ports */ + int32_t io_sleep; /**< enable sleep on PMD cores */ + uint32_t nEthLinePerPort; /**< 1, 2, 3 total number of links per O-RU (Fronthaul Ethernet link) */ + uint32_t nEthLineSpeed; /**< 10G,25G,40G,100G speed of Physical connection on O-RU */ + int32_t one_vf_cu_plane; /**< 1 - C-plane and U-plane use one VF */ + struct xran_ecpri_del_meas_cmn eowd_cmn[2];/**52600000 */ uint32_t nULAbsFrePointA; /**< Abs Freq Point A of the Carrier Center Frequency for in KHz Value: 450000->52600000 */ - uint32_t nDLCenterFreqARFCN; /**< center frerquency for DL in MHz */ - uint32_t nULCenterFreqARFCN; /**< center frerquency for UL in MHz */ + uint32_t nDLCenterFreqARFCN; /**< center frequency for DL in MHz */ + uint32_t nULCenterFreqARFCN; /**< center frequency for UL in MHz */ xran_fh_tti_callback_fn ttiCb; /**< call back for TTI event */ void *ttiCbParam; /**< parameters of call back function */ + uint16_t Tadv_cp_dl; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t T2a_min_cp_dl; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t T2a_max_cp_dl; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t T2a_min_cp_ul; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t T2a_max_cp_ul; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t T2a_min_up; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t T2a_max_up; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t Ta3_min; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t Ta3_max; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t T1a_min_cp_dl; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t T1a_max_cp_dl; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t T1a_min_cp_ul; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t T1a_max_cp_ul; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t T1a_min_up; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t T1a_max_up; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t Ta4_min; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + uint16_t Ta4_max; /**< Table 2 7 : xRAN Delay Management Model Parameters */ + + uint8_t enableCP; /**< enable C-plane */ + uint8_t prachEnable; /**< enable PRACH */ + uint8_t srsEnable; /**< enable SRS (Cat B specific) */ + uint8_t srsEnableCp; /**< enable SRS Cp(Cat B specific) */ + uint8_t SrsDelaySym; /**< enable SRS Cp(Cat B specific) */ + uint8_t puschMaskEnable;/**< enable pusch mask> */ + uint8_t puschMaskSlot; /**< specific which slot pusch channel masked> */ + uint8_t cp_vlan_tag; /**< C-plane vlan tag */ + uint8_t up_vlan_tag; /**< U-plane vlan tag */ + int32_t debugStop; /**< enable auto stop */ + int32_t debugStopCount; /**< enable auto stop after number of Tx packets */ + int32_t DynamicSectionEna; /**< enable dynamic C-Plane section allocation */ + int32_t GPS_Alpha; // refer to alpha as defined in section 9.7.2 of ORAN spec. this value should be alpha*(1/1.2288ns), range 0 - 1e7 (ns) + int32_t GPS_Beta; //beta value as defined in section 9.7.2 of ORAN spec. range -32767 ~ +32767 + struct xran_prach_config prach_conf; /**< PRACH specific configurations for FH */ + struct xran_srs_config srs_conf; /**< SRS specific configurations for FH */ struct xran_frame_config frame_conf; /**< frame config */ struct xran_ru_config ru_conf; /**< config of RU as per XRAN spec */ phy_encoder_poll_fn bbdev_enc; /**< call back to poll BBDev encoder */ phy_decoder_poll_fn bbdev_dec; /**< call back to poll BBDev decoder */ + uint16_t tx_cp_eAxC2Vf[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR*2 + XRAN_MAX_ANT_ARRAY_ELM_NR]; /**< mapping of C-Plane (ecpriRtcid) or U-Plane (ecpriPcid) to VF */ + uint16_t tx_up_eAxC2Vf[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR*2 + XRAN_MAX_ANT_ARRAY_ELM_NR]; /**< mapping of C-Plane (ecpriRtcid) or U-Plane (ecpriPcid) to VF */ + + uint16_t rx_cp_eAxC2Vf[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR*2 + XRAN_MAX_ANT_ARRAY_ELM_NR]; /**< mapping of C-Plane (ecpriRtcid) or U-Plane (ecpriPcid) to VF */ + uint16_t rx_up_eAxC2Vf[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR*2 + XRAN_MAX_ANT_ARRAY_ELM_NR]; /**< mapping of C-Plane (ecpriRtcid) or U-Plane (ecpriPcid) to VF */ + uint32_t log_level; /**< configuration of log level */ + + uint16_t max_sections_per_slot; /**< M-Plane settings for section */ + uint16_t max_sections_per_symbol; /**< M-Plane settings for section */ + int32_t RunSlotPrbMapBySymbolEnable; /**< enable prb mapping by symbol with multisection*/ + + uint8_t dssEnable; /**< enable DSS (extension-9) */ + uint8_t dssPeriod; /**< DSS pattern period for LTE/NR */ + uint8_t technology[XRAN_MAX_DSS_PERIODICITY]; /**< technology array represents slot is LTE(0)/NR(1) */ }; /** @@ -472,6 +729,22 @@ struct xran_common_counters{ uint64_t Rx_corrupt; /**< Corrupt/Incorrect header packet */ uint64_t Rx_pkt_dupl; /**< Duplicated packet */ uint64_t Total_msgs_rcvd; /**< Total messages received (on all links) */ + + /* debug statistis */ + uint64_t rx_counter; + uint64_t tx_counter; + uint64_t tx_bytes_counter; + uint64_t rx_bytes_counter; + uint64_t tx_bytes_per_sec; + uint64_t rx_bytes_per_sec; + + uint64_t rx_pusch_packets[XRAN_MAX_ANTENNA_NR]; + uint64_t rx_prach_packets[XRAN_MAX_ANTENNA_NR]; + uint64_t rx_srs_packets; + uint64_t rx_invalid_ext1_packets; /**< Counts the invalid extType-1 packets - valid for packets received from O-DU*/ + + uint64_t timer_missed_sym; + uint64_t timer_missed_slot; }; /** @@ -491,23 +764,16 @@ typedef void * xran_cc_handle_t; *****************************************************************************/ struct xran_flat_buffer { - uint32_t nElementLenInBytes; - /**< The Element length specified in bytes. + uint32_t nElementLenInBytes; /**< The Element length specified in bytes. * This parameter specifies the size of a single element in the buffer. * The total size of the buffer is described as * bufferSize = nElementLenInBytes * nNumberOfElements */ - uint32_t nNumberOfElements; - /**< The number of elements in the physical contiguous memory segment */ - uint32_t nOffsetInBytes; - /**< Offset in bytes to the start of the data in the physical contiguous + uint32_t nNumberOfElements; /**< The number of elements in the physical contiguous memory segment */ + uint32_t nOffsetInBytes; /**< Offset in bytes to the start of the data in the physical contiguous * memory segment */ - uint32_t nIsPhyAddr; - uint8_t *pData; - /**< The data pointer is a virtual address, however the actual data pointed - * to is required to be in contiguous physical memory unless the field - requiresPhysicallyContiguousMemory in CpaInstanceInfo is false. */ - void *pCtrl; - /**< pointer to control section coresponding to data buffer */ + uint8_t *pData; /**< The data pointer is a virtual address */ + void *pCtrl; /**< pointer to control section coresponding to data buffer */ + void *pRing; /**< pointer to ring with prepared mbufs */ }; /** @@ -520,30 +786,13 @@ struct xran_flat_buffer * structure will be used where more than one flat buffer can be provided * on a particular API. * - * IMPORTANT - The memory for the pPrivateMetaData member must be allocated - * by the client as contiguous memory. When allocating memory for - * pPrivateMetaData a call to cpaCyBufferListGetMetaSize MUST be made to - * determine the size of the Meta Data Buffer. The returned size - * (in bytes) may then be passed in a memory allocation routine to allocate - * the pPrivateMetaData memory. - * *****************************************************************************/ struct xran_buffer_list { - uint32_t nNumBuffers; - /**< Number of pointers */ + uint32_t nNumBuffers; /**< Number of pointers */ struct xran_flat_buffer *pBuffers; - /**< Pointer to an unbounded array containing the number of CpaFlatBuffers - * defined by nNumBuffers */ void *pUserData; - /**< This is an opaque field that is not read or modified internally. */ void *pPrivateMetaData; - /**< Private Meta representation of this buffer List - the memory for this - * buffer needs to be allocated by the client as contiguous data. - * The amount of memory required is returned with a call to - * cpaCyBufferListGetMetaSize. If cpaCyBufferListGetMetaSize returns a size - * of zero no memory needs to be allocated, and this parameter can be NULL. - */ }; /** @@ -580,7 +829,7 @@ int32_t xran_init(int argc, char *argv[], struct xran_fh_init *p_xran_fh_init, c * @return * 0 - on success */ -int32_t xran_sector_get_instances (void * pHandle, uint16_t nNumInstances, +int32_t xran_sector_get_instances (uint32_t xran_port, void * pDevHandle, uint16_t nNumInstances, xran_cc_handle_t * pSectorInstanceHandles); /** @@ -641,6 +890,31 @@ int32_t xran_bm_init (void * pHandle, uint32_t * pPoolIndex, uint32_t nNumberOfB */ int32_t xran_bm_allocate_buffer(void * pHandle, uint32_t nPoolIndex, void **ppData, void **ppCtrl); +/** + * @ingroup xran + * + * Function allocates buffer used between XRAN layer and PHY. In general case it's DPDK mbuf. + * + * @param pHandle + * Pointer to XRAN layer handle for given CC + * @param rng_name_prefix + * prefix of ring name + * @param cc_id + * Component Carrier ID + * @param buff_id + * Buffer id for given ring + * @param ant_id + * Antenna id for given ring + * @param symb_id + * Symbol id for given ring + * @param ppRing + * Pointer to pointer where to store address of internal DDPD ring + * + * @return + * 0 - on success + */ +int32_t xran_bm_allocate_ring(void * pHandle, const char *rng_name_prefix, uint16_t cc_id, uint16_t buff_id, uint16_t ant_id, uint16_t symb_id, void **ppRing); + /** * @ingroup xran * @@ -724,9 +998,54 @@ int32_t xran_mm_destroy (void * pHandle); */ int32_t xran_5g_prach_req (void * pHandle, struct xran_buffer_list *pDstBuffer[XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN], + struct xran_buffer_list *pDstBufferDecomp[XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN], + xran_transport_callback_fn pCallback, + void *pCallbackTag); + +/** + * @ingroup xran + * + * Function configures SRS output buffers and callback for XRAN layer with given handle + * + * @param pHandle + * Pointer to XRAN layer handle for given CC + * @param pDstBuffer + * list of memory buffers to use to deliver SRS IQs from xran layer to PHY + * @param xran_transport_callback_fn pCallback + * Callback function to call with arrival of SRS packets for given CC + * @param pCallbackTag + * Parameters of Callback function + * + * @return + * 0 - on success + * -1 - on error + */ +int32_t xran_5g_srs_req (void * pHandle, + struct xran_buffer_list *pDstBuffer[XRAN_MAX_ANT_ARRAY_ELM_NR][XRAN_N_FE_BUF_LEN], + struct xran_buffer_list *pDstCpBuffer[XRAN_MAX_ANT_ARRAY_ELM_NR][XRAN_N_FE_BUF_LEN], xran_transport_callback_fn pCallback, void *pCallbackTag); + +/** + * @ingroup xran + * + * Function returns XRAN core utilization stats + * + * @param total_time (out) + * Pointer to variable to store Total time thread has been running + * @param used_time (out) + * Pointer to variable to store Total time essential tasks have been running on the thread + * @param core_used (out) + * Pointer to variable to store Core on which the XRAN thread is running + * @param clear (in) + * If set to 1, then internal variables total_time and used_time are cleared + * + * @return + * 0 - on success + */ +uint32_t xran_get_time_stats(uint64_t *total_time, uint64_t *used_time, uint32_t *num_core_used, uint32_t *core_used, uint32_t clear); + /** * @ingroup xran * @@ -790,18 +1109,19 @@ int32_t xran_close(void *pHandle); * Pointer to XRAN layer handle for given CC * @param symCb * pointer to callback function - * @param symCb + * @param symCbParam * pointer to Callback Function parameters * @param symb * symbol to be register for - * @param ant - * Antenna number to trigger callback for packet arrival + * @param cb_per_sym_type_id + * call back time identification (see enum cb_per_sym_type_id) * * @return * 0 - in case of success * -1 - in case of failure */ -int32_t xran_reg_sym_cb(void *pHandle, xran_callback_sym_fn symCb, void * symCbParam, uint8_t symb, uint8_t ant); +int32_t xran_reg_sym_cb(void *pHandle, xran_callback_sym_fn symCb, void * symCbParam, struct xran_sense_of_time* symCbTime, uint8_t symb, enum cb_per_sym_type_id cb_sym_t_id); + /** * @ingroup xran @@ -826,6 +1146,31 @@ int32_t xran_reg_sym_cb(void *pHandle, xran_callback_sym_fn symCb, void * symCbP */ int32_t xran_reg_physide_cb(void *pHandle, xran_fh_tti_callback_fn Cb, void *cbParam, int skipTtiNum, enum callback_to_phy_id); +/** + * @ingroup xran + * + * Function registers callback to XRAN layer. Function support callbacks align to OTA time. TTI even, half of slot, + * full slot with respect to PTP time. + * + * @param pHandle + * Pointer to XRAN layer handle for given CC + * @param Cb + * pointer to callback function + * @param cbParam + * pointer to Callback Function parameters + * @param skipTtiNum + * number of calls to be skipped before first call + * @param callback_to_phy_id + * call back time identification (see enum callback_to_phy_id) + * @param xran_port_id + * XRAN device ID + * + * @return + * 0 - in case of success + * -1 - in case of failure + */ +int32_t xran_reg_physide_cb_by_dev_id(void *pHandle, xran_fh_tti_callback_fn Cb, void *cbParam, int skipTtiNum, enum callback_to_phy_id, uint8_t xran_port_id); + /** * @ingroup xran * @@ -846,7 +1191,26 @@ int32_t xran_reg_physide_cb(void *pHandle, xran_fh_tti_callback_fn Cb, void *cbP * @return * current TTI number [0-7999] */ -int32_t xran_get_slot_idx (uint32_t *nFrameIdx, uint32_t *nSubframeIdx, uint32_t *nSlotIdx, uint64_t *nSecond); +int32_t xran_get_slot_idx (uint32_t PortId, uint32_t *nFrameIdx, uint32_t *nSubframeIdx, uint32_t *nSlotIdx, uint64_t *nSecond); + +/** + * @ingroup xran + * + * Function returns whether it is a prach slot or not based on given port and slot number + * + * @param PortId + * xRAN Port Id + * + * @param subframe_id + * Subframe number [0-9] + * + * @param slot_id + * Pointer to Slot number [0-7] + * + * @return + * whether it is a prach slot or not + */ +int32_t xran_is_prach_slot(uint8_t PortId, uint32_t subframe_id, uint32_t slot_id); /** * @ingroup xran @@ -864,9 +1228,172 @@ int32_t xran_get_slot_idx (uint32_t *nFrameIdx, uint32_t *nSubframeIdx, uint32_ */ int32_t xran_get_common_counters(void *pXranLayerHandle, struct xran_common_counters *pStats); + +/** + * @ingroup xran + * + * Function returns status of operation of FH layer + * + * @return + * XRAN_INIT - init state + * XRAN_RUNNING - running + * XRAN_STOPPED - stopped + */ enum xran_if_state xran_get_if_state(void); +/** + * @ingroup xran + * + * Function allocates memory of given size from heap + * + * @param buf_len + * buffer size + * + * @return + * buf_len - size of memory allocation + */ +void* xran_malloc(size_t buf_len); + +/** + * @ingroup xran + * + * Function frees memory of given size from heap + * + * @param buf_len + * addr - pointer to buffer + * + * @return + * void + */ +void xran_free(void *addr); + +/** + * @ingroup xran + * + * Function calculates offset for ptr according to ORAN headers requared + * + * @param dst + * pointer to be addjusted + * @compMethod + * compression method according to enum xran_compression_method + * + * @return + * ptr - pointer to payload given header requared + */ +uint8_t* xran_add_hdr_offset(uint8_t *dst, int16_t compMethod); + +/** + * @ingroup xran + * + * Function calculates offset for ptr according to ORAN C-plane headers requared + * + * @param dst + * pointer to be addjusted + * + * @return + * ptr - pointer to payload given header requared + */ +uint8_t *xran_add_cp_hdr_offset(uint8_t *dst); + +/** + * @ingroup xran + * + * Debug function to trigger stop on 1pps (GPS second) boundary + * + * @param value + * 1 - enable stop + * 0 - disable stop + * @param count + * enable auto stop after number of Tx packets + * @return + * 0 - on success + */ +int32_t xran_set_debug_stop(int32_t value, int32_t count); + +/** + * @ingroup xran + * + * function initialize PRB map from config input + * + * @param p_PrbMapIn + * Input PRBmap from config + * @param p_PrbMapOut + * Output PRBmap + * @return + * 0 - on success + */ +int32_t xran_init_PrbMap_from_cfg(struct xran_prb_map* p_PrbMapIn, struct xran_prb_map* p_PrbMapOut, uint32_t mtu); + +/** + * @ingroup xran + * + * function initialize PRB map from config input + * + * @param p_PrbMapIn + * Input PRBmap from config for Rx + * @param p_PrbMapOut + * Output PRBmap + * @return + * 0 - on success + */ + +int32_t xran_init_PrbMap_from_cfg_for_rx(struct xran_prb_map* p_PrbMapIn, struct xran_prb_map* p_PrbMapOut, uint32_t mtu); + +int32_t xran_get_num_prb_elm(struct xran_prb_map* p_PrbMapIn, uint32_t mtu); + +/** + * @ingroup xran + * + * function initialize PRB map from config input by symbol + * + * @param p_PrbMapIn + * Input PRBmap from config + * @param p_PrbMapOut + * Output PRBmap + * @return + * 0 - on success + */ +int32_t xran_init_PrbMap_by_symbol_from_cfg(struct xran_prb_map* p_PrbMapIn, struct xran_prb_map* p_PrbMapOut, uint32_t mtu, uint32_t xran_max_prb); + +/** + * @ingroup xran + * + * Function prepares DL U-plane packets for symbol for O-RAN FH. Enques resulting packet to ring for TX at appropriate time + * + * @param pHandle + * pointer to O-RU port structure + * @return + * 0 - on success + */ +int32_t xran_prepare_up_dl_sym(uint16_t xran_port_id, uint32_t nSlotIdx, uint32_t nCcStart, uint32_t nCcNum, uint32_t nSymMask, uint32_t nAntStart, + uint32_t nAntNum, uint32_t nSymStart, uint32_t nSymNum); +/** + * @ingroup xran + * + * Function prepares DL C-plane packets for slot for O-RAN FH. Enques resulting packet to ring for TX at appropriate time + * + * @param pHandle + * pointer to O-RU port structure + * @return + * 0 - on success + */ +int32_t xran_prepare_cp_dl_slot(uint16_t xran_port_id, uint32_t nSlotIdx, uint32_t nCcStart, uint32_t nCcNum, uint32_t nSymMask, uint32_t nAntStart, + uint32_t nAntNum, uint32_t nSymStart, uint32_t nSymNum); + +/** + * @ingroup xran + * + * Function prepares UL C-plane packets for slot for O-RAN FH. Enques resulting packet to ring for TX at appropriate time + * + * @param pHandle + * pointer to O-RU port structure + * @return + * 0 - on success + */ +int32_t xran_prepare_cp_ul_slot(uint16_t xran_port_id, uint32_t nSlotIdx, uint32_t nCcStart, uint32_t nCcNum, uint32_t nSymMask, uint32_t nAntStart, + uint32_t nAntNum, uint32_t nSymStart, uint32_t nSymNum); + #ifdef __cplusplus } #endif