xran_fh_o_du.h

Go to the documentation of this file.

/******************************************************************************
*
*   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 _XRAN_FH_O_DU_H_
#define _XRAN_FH_O_DU_H_

#ifdef __cplusplus
extern "C" {
#endif

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
#include <inttypes.h>
#include <sys/types.h>
#include <sys/queue.h>
#include <netinet/in.h>
#include <setjmp.h>
#include <stdarg.h>
#include <ctype.h>
#include <errno.h>
#include <getopt.h>
#include <unistd.h>

#define XRAN_STATUS_SUCCESS (0)

#define XRAN_STATUS_FAIL (-1)

#define XRAN_STATUS_RETRY (-2)

#define XRAN_STATUS_RESOURCE (-3)

#define XRAN_STATUS_INVALID_PARAM (-4)

#define XRAN_STATUS_FATAL (-5)

#define XRAN_STATUS_UNSUPPORTED (-6)

#define XRAN_STATUS_INVALID_PACKET (-7)

#define XranGetTtiNum(symIdx, numSymPerTti) (((uint32_t)symIdx / (uint32_t)numSymPerTti))

#define XranGetSymNum(symIdx, numSymPerTti) (((uint32_t)symIdx % (uint32_t)numSymPerTti))

#define XranGetFrameNum(tti,SFNatSecStart,numSubFramePerSystemFrame, numSlotPerSubFrame)  ((((uint32_t)tti / ((uint32_t)numSubFramePerSystemFrame * (uint32_t)numSlotPerSubFrame)) + SFNatSecStart) & 0x3FF)

#define XranGetSubFrameNum(tti, numSlotPerSubFrame, numSubFramePerSystemFrame) (((uint32_t)tti/(uint32_t)numSlotPerSubFrame) % (uint32_t)numSubFramePerSystemFrame)

#define XranGetSlotNum(tti, numSlotPerSfn) ((uint32_t)tti % ((uint32_t)numSlotPerSfn))

#define XRAN_PORTS_NUM               (1)    
#define XRAN_N_FE_BUF_LEN            (40)   
#define XRAN_MAX_SECTOR_NR           (12)   
#define XRAN_MAX_ANTENNA_NR          (16)    
/* see 10.2 Hierarchy of Radiation Structure in O-RU (assume TX and RX pannel are the same dimensions)*/
#define XRAN_MAX_PANEL_NR            (1)   
#define XRAN_MAX_TRX_ANTENNA_ARRAY   (1)   
#define XRAN_MAX_ANT_ARRAY_ELM_NR    (64)  
#define XRAN_NUM_OF_SYMBOL_PER_SLOT  (14) 
#define XRAN_MAX_NUM_OF_SRS_SYMBOL_PER_SLOT  XRAN_NUM_OF_SYMBOL_PER_SLOT 
#define XRAN_MAX_TDD_PERIODICITY     (80) 
#define XRAN_MAX_CELLS_PER_PORT      (XRAN_MAX_SECTOR_NR) 
#define XRAN_COMPONENT_CARRIERS_MAX  (XRAN_MAX_SECTOR_NR) 
#define XRAN_NUM_OF_ANT_RADIO        (XRAN_MAX_SECTOR_NR*XRAN_MAX_ANTENNA_NR) 
#define XRAN_MAX_PRBS                (275) 
#define XRAN_MAX_SECTIONS_PER_SYM    (16)  
#define XRAN_MAX_PKT_BURST (448+4) 
#define XRAN_N_MAX_BUFFER_SEGMENT XRAN_MAX_PKT_BURST 
#define XRAN_STRICT_PARM_CHECK               (1) 
/* Slot type definition */
#define XRAN_SLOT_TYPE_INVALID               (0) 
#define XRAN_SLOT_TYPE_DL                    (1) 
#define XRAN_SLOT_TYPE_UL                    (2) 
#define XRAN_SLOT_TYPE_SP                    (3) 
#define XRAN_SLOT_TYPE_FDD                   (4) 
#define XRAN_SLOT_TYPE_LAST                  (5) 
/* symbol type definition */
#define XRAN_SYMBOL_TYPE_DL                  (0) 
#define XRAN_SYMBOL_TYPE_UL                  (1) 
#define XRAN_SYMBOL_TYPE_GUARD               (2) 
#define XRAN_SYMBOL_TYPE_FDD                 (3) 
#define XRAN_NUM_OF_SLOT_IN_TDD_LOOP         (80)
//#define _XRAN_DEBUG   
//#define _XRAN_VERBOSE 
#ifdef _XRAN_DEBUG
    #define xran_log_dbg(fmt, ...)          \
        fprintf(stderr,                     \
            "DEBUG: %s(%d): " fmt "\n",     \
            __FILE__,                       \
            __LINE__, ##__VA_ARGS__)
#else
    #define xran_log_dbg(fmt, ...)
#endif

#if defined(_XRAN_DEBUG) || defined(_XRAN_VERBOSE)
    #define xran_log_wrn(fmt, ...)          \
        fprintf(                            \
            stderr,                         \
            "WARNING: %s(%d): " fmt "\n",   \
            __FILE__,                       \
            __LINE__, ##__VA_ARGS__)
#else
    #define xran_log_dbg(fmt, ...)
    #define xran_log_wrn(fmt, ...)
#endif

#define xran_log_err(fmt, ...)          \
    fprintf(stderr,                     \
        "ERROR: %s(%d): " fmt "\n",     \
        __FILE__,                       \
        __LINE__, ##__VA_ARGS__)

enum XranFrameDuplexType
{
    XRAN_FDD = 0, XRAN_TDD
};

enum xran_if_state
{
    XRAN_INIT = 0,
    XRAN_RUNNING,
    XRAN_STOPPED
};

enum xran_compression_method {
    XRAN_COMPMETHOD_NONE        = 0,
    XRAN_COMPMETHOD_BLKFLOAT    = 1,
    XRAN_COMPMETHOD_BLKSCALE    = 2,
    XRAN_COMPMETHOD_ULAW        = 3,
    XRAN_COMPMETHOD_MODULATION  = 4,
    XRAN_COMPMETHOD_MAX
};

enum callback_to_phy_id
{
    XRAN_CB_TTI = 0, 
    XRAN_CB_HALF_SLOT_RX =1, 
    XRAN_CB_FULL_SLOT_RX =2, 
    XRAN_CB_MAX 
};

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
};

typedef int32_t xran_status_t; 
typedef void (*xran_callback_sym_fn)(void*);

typedef int (*xran_fh_tti_callback_fn)(void*);

typedef void (*xran_transport_callback_fn)(void*, xran_status_t);

typedef int16_t (*phy_encoder_poll_fn)(void);

typedef int16_t (*phy_decoder_poll_fn)(void);

enum xran_vf_ports
{
    XRAN_UP_VF = 0, 
    XRAN_CP_VF,     
    XRAN_VF_MAX
};

enum xran_category
{
    XRAN_CATEGORY_A = 0,
    XRAN_CATEGORY_B = 1,
    XRAN_CATEGORY_MAX
};

enum xran_beamforming_type
{
    XRAN_BEAM_ID_BASED = 0, 
    XRAN_BEAM_WEIGHT,       
    XRAN_BEAM_ATTRIBUTE,    
};

enum xran_bbdev_init
{
    XRAN_BBDEV_NOT_USED    = -1, 
    XRAN_BBDEV_MODE_HW_OFF = 0,  
    XRAN_BBDEV_MODE_HW_ON  = 1,  
    XRAN_BBDEV_MODE_MAX
};

struct xran_cb_tag {
    uint16_t cellId;
    uint32_t symbol;
    uint32_t slotiId;
};

struct xran_io_cfg {
    uint8_t id; 
    char *dpdk_dev[XRAN_VF_MAX]; 
    char *bbdev_dev[1];     
    int32_t bbdev_mode;     
    int32_t core;           
    int32_t system_core;    
    int32_t pkt_proc_core;  
    int32_t pkt_aux_core;   
    int32_t timing_core;    
    int32_t port[XRAN_VF_MAX];  
};

struct xran_eaxcid_config {
    uint16_t mask_cuPortId;     
    uint16_t mask_bandSectorId; 
    uint16_t mask_ccId;         
    uint16_t mask_ruPortId;     
    uint8_t bit_cuPortId;       
    uint8_t bit_bandSectorId;   
    uint8_t bit_ccId;           
    uint8_t bit_ruPortId;       
};

struct xran_fh_init {
    struct xran_io_cfg io_cfg;
    struct xran_eaxcid_config eAxCId_conf; 
    uint32_t dpdkBasebandFecMode; 
    char *dpdkBasebandDevice;     
    char *filePrefix;             
    uint32_t mtu; 
    int8_t *p_o_du_addr;  
    int8_t *p_o_ru_addr;  
    uint16_t totalBfWeights;
    uint16_t Tadv_cp_dl;    
    uint16_t T2a_min_cp_dl; 
    uint16_t T2a_max_cp_dl; 
    uint16_t T2a_min_cp_ul; 
    uint16_t T2a_max_cp_ul; 
    uint16_t T2a_min_up;    
    uint16_t T2a_max_up;    
    uint16_t Ta3_min;       
    uint16_t Ta3_max;       
    uint16_t T1a_min_cp_dl; 
    uint16_t T1a_max_cp_dl; 
    uint16_t T1a_min_cp_ul; 
    uint16_t T1a_max_cp_ul; 
    uint16_t T1a_min_up;    
    uint16_t T1a_max_up;    
    uint16_t Ta4_min;       
    uint16_t Ta4_max;       
    uint8_t enableCP;       
    uint8_t prachEnable;    
    uint8_t srsEnable;      
    uint8_t cp_vlan_tag;    
    uint8_t up_vlan_tag;    
    int32_t debugStop;      
    int32_t debugStopCount;      
    int32_t DynamicSectionEna; 
    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_cp_bf_weight{
    int16_t nAntElmTRx;        
    int8_t*  p_ext_section;    
    int16_t  ext_section_sz;   
};
struct xran_cp_bf_attribute{
    int16_t weight[4];
};
struct xran_cp_bf_precoding{
    int16_t weight[4];
};

struct xran_section_desc {
    uint16_t section_id; 
    int16_t iq_buffer_offset;    
    int16_t iq_buffer_len;       
    uint8_t *pData;      
    void    *pCtrl;      
};

struct xran_prb_elm {
    int16_t nRBStart;    
    int16_t nRBSize;     
    int16_t nStartSymb;  
    int16_t numSymb;     
    int16_t nBeamIndex;  
    int16_t bf_weight_update; 
    int16_t compMethod;  
    int16_t iqWidth;     
    int16_t BeamFormingType; 
    struct xran_section_desc * p_sec_desc[XRAN_NUM_OF_SYMBOL_PER_SLOT]; 
    struct xran_cp_bf_weight   bf_weight; 
    union {
        struct xran_cp_bf_attribute bf_attribute;
        struct xran_cp_bf_precoding bf_precoding;
    };
};

struct xran_prb_map {
    uint8_t   dir;        
    uint8_t   xran_port;  
    uint16_t  band_id;    
    uint16_t  cc_id;      
    uint16_t  ru_port_id; 
    uint16_t  tti_id;     
    uint8_t   start_sym_id;     
    uint32_t  nPrbElm;    
    struct xran_prb_elm prbMap[XRAN_MAX_PRBS];


};

/* PRACH config required for XRAN based FH */
struct xran_prach_config
{
    /* PRACH config*/
    uint8_t      nPrachConfIdx;  
    uint8_t      nPrachSubcSpacing;
    uint8_t      nPrachZeroCorrConf; 
    uint8_t      nPrachRestrictSet;  
    uint16_t     nPrachRootSeqIdx; 
    uint16_t     nPrachFreqStart;  
    int32_t      nPrachFreqOffset; 
    uint8_t      nPrachFilterIdx;  
};

struct xran_srs_config {
    uint16_t   symbMask;    
    uint8_t    eAxC_offset; 
};

struct xran_slot_config {
    uint8_t nSymbolType[XRAN_NUM_OF_SYMBOL_PER_SLOT]; 
    uint8_t reserved[2];
};

struct xran_frame_config {
    uint8_t      nFrameDuplexType; 
    uint8_t      nNumerology; 
    uint8_t      nTddPeriod;  
    struct xran_slot_config sSlotConfig[XRAN_MAX_TDD_PERIODICITY];
    /* The number of slots need to be equal to nTddPeriod */
};

enum xran_input_byte_order {
    XRAN_NE_BE_BYTE_ORDER = 0, 
    XRAN_CPU_LE_BYTE_ORDER     
};

enum xran_input_i_q_order {
    XRAN_I_Q_ORDER = 0,  
    XRAN_Q_I_ORDER       
};

struct xran_ru_config {
    enum xran_category xranCat;   
    uint8_t iqWidth;        
    uint8_t compMeth;       
    uint8_t fftSize;        
    enum xran_input_byte_order byteOrder; 
    enum xran_input_i_q_order  iqOrder;   
    uint16_t xran_max_frame; 
};

struct xran_fh_config {
    uint32_t            dpdk_port; 
    uint32_t            sector_id; 
    uint32_t            nCC;       
    uint32_t            neAxc;     
    uint32_t            neAxcUl;     
    uint32_t            nAntElmTRx;  
    uint16_t            nDLFftSize;  
    uint16_t            nULFftSize;  
    uint16_t            nDLRBs;      
    uint16_t            nULRBs;      
    uint32_t            nDLAbsFrePointA; 
    uint32_t            nULAbsFrePointA; 
    uint32_t            nDLCenterFreqARFCN;   
    uint32_t            nULCenterFreqARFCN;   
    xran_fh_tti_callback_fn     ttiCb;        
    void                *ttiCbParam;  
    struct xran_prach_config     prach_conf;   
    struct xran_srs_config       srs_conf;     
    struct xran_frame_config     frame_conf;   
    struct xran_ru_config        ru_conf;      
    phy_encoder_poll_fn bbdev_enc; 
    phy_decoder_poll_fn bbdev_dec; 
    uint32_t log_level; 
};

struct xran_common_counters{
    uint64_t Rx_on_time;      
    uint64_t Rx_early;        
    uint64_t Rx_late;         
    uint64_t Rx_corrupt;      
    uint64_t Rx_pkt_dupl;     
    uint64_t Total_msgs_rcvd; 
};

typedef void * xran_cc_handle_t;

struct xran_flat_buffer
{
    uint32_t nElementLenInBytes;
    uint32_t nNumberOfElements;
    uint32_t nOffsetInBytes;
    uint32_t nIsPhyAddr;
    uint8_t *pData;
    void *pCtrl;
};

struct xran_buffer_list
{
    uint32_t nNumBuffers;
    struct xran_flat_buffer *pBuffers;
    void *pUserData;
    void *pPrivateMetaData;
};

int32_t xran_init(int argc, char *argv[], struct xran_fh_init *p_xran_fh_init, char *appName, void ** pHandle);

int32_t xran_sector_get_instances (void * pHandle, uint16_t nNumInstances,
               xran_cc_handle_t * pSectorInstanceHandles);

int32_t xran_mm_init (void * pHandle, uint64_t nMemorySize, uint32_t nMemorySegmentSize);

int32_t xran_bm_init (void * pHandle, uint32_t * pPoolIndex, uint32_t nNumberOfBuffers, uint32_t nBufferSize);

int32_t xran_bm_allocate_buffer(void * pHandle, uint32_t nPoolIndex, void **ppData,  void **ppCtrl);

int32_t xran_bm_free_buffer(void * pHandle, void *pData, void *pCtrl);

int32_t xran_mm_destroy (void * pHandle);

 int32_t xran_5g_fronthault_config (void * pHandle,
                    struct xran_buffer_list *pSrcBuffer[XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN],
                    struct xran_buffer_list *pSrcCpBuffer[XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN],
                    struct xran_buffer_list *pDstBuffer[XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN],
                    struct xran_buffer_list *pDstCpBuffer[XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN],
                    xran_transport_callback_fn pCallback,
                    void *pCallbackTag);

int32_t xran_5g_prach_req (void *  pHandle,
                struct xran_buffer_list *pDstBuffer[XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN],
                xran_transport_callback_fn pCallback,
                void *pCallbackTag);

int32_t xran_5g_srs_req (void *  pHandle,
                struct xran_buffer_list *pDstBuffer[XRAN_MAX_ANT_ARRAY_ELM_NR][XRAN_N_FE_BUF_LEN],
                xran_transport_callback_fn pCallback,
                void *pCallbackTag);


uint32_t xran_get_time_stats(uint64_t *total_time, uint64_t *used_time, uint32_t *core_used, uint32_t clear);

int32_t xran_open(void *pHandle, struct xran_fh_config* pConf);

int32_t xran_start(void *pHandle);

int32_t xran_stop(void *pHandle);

int32_t xran_close(void *pHandle);

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_physide_cb(void *pHandle, xran_fh_tti_callback_fn Cb, void *cbParam, int skipTtiNum, enum callback_to_phy_id);

int32_t xran_get_slot_idx (uint32_t *nFrameIdx, uint32_t *nSubframeIdx,  uint32_t *nSlotIdx, uint64_t *nSecond);

int32_t xran_get_common_counters(void *pXranLayerHandle, struct xran_common_counters *pStats);


enum xran_if_state xran_get_if_state(void);


void*    xran_malloc(size_t buf_len);


uint8_t* xran_add_hdr_offset(uint8_t  *dst, int16_t compMethod);

#ifdef __cplusplus
}
#endif

#endif /* _XRAN_FH_O_DU_H_*/