O-RAN E Maintenance Release contribution for ODULOW
[o-du/phy.git] / fhi_lib / test / common / xran_lib_wrap.hpp
index c92abc7..2829ebd 100644 (file)
@@ -1,6 +1,19 @@
 /*******************************************************************************
  *
- * <COPYRIGHT_TAG>
+ * 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.
+ * 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.
+ * 
  *
  *******************************************************************************/
 
 
 extern "C"
 {
-extern uint32_t xran_lib_ota_tti;
-extern uint32_t xran_lib_ota_sym;
-extern uint32_t xran_lib_ota_sym_idx;
+extern uint32_t xran_lib_ota_tti[];
+extern uint32_t xran_lib_ota_sym[];
+extern uint32_t xran_lib_ota_sym_idx[];
 
 void sym_ota_cb(struct rte_timer *tim, void *arg);
 void tti_ota_cb(struct rte_timer *tim, void *arg);
 }
 
+
 class xranLibWraper
 {
 public:
@@ -65,6 +79,55 @@ public:
         MAX_SW_XRAN_INTERFACE_NUM
     } SWXRANInterfaceTypeEnum;
 
+struct xran_io_buf_ctrl {
+    /* -1-this subframe is not used in current frame format
+         0-this subframe can be transmitted, i.e., data is ready
+          1-this subframe is waiting transmission, i.e., data is not ready
+         10 - DL transmission missing deadline. When FE needs this subframe data but bValid is still 1,
+        set bValid to 10.
+    */
+    int32_t bValid ; // when UL rx, it is subframe index.
+    int32_t nSegToBeGen;
+    int32_t nSegGenerated; // how many date segment are generated by DL LTE processing or received from FE
+                       // -1 means that DL packet to be transmitted is not ready in BS
+    int32_t nSegTransferred; // number of data segments has been transmitted or received
+    //struct rte_mbuf *pData[N_MAX_BUFFER_SEGMENT]; // point to DPDK allocated memory pool
+    struct xran_buffer_list sBufferList;
+};
+
+struct xran_io_shared_ctrl {
+    /* io struct */
+    struct xran_io_buf_ctrl sFrontHaulTxBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
+    struct xran_io_buf_ctrl sFrontHaulTxPrbMapBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
+    struct xran_io_buf_ctrl sFrontHaulRxBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
+    struct xran_io_buf_ctrl sFrontHaulRxPrbMapBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
+    struct xran_io_buf_ctrl sFHPrachRxBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
+    struct xran_io_buf_ctrl sFHPrachRxBbuIoBufCtrlDecomp[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
+
+    /* Cat B */
+    struct xran_io_buf_ctrl sFHSrsRxBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANT_ARRAY_ELM_NR];
+    struct xran_io_buf_ctrl sFHSrsRxPrbMapBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANT_ARRAY_ELM_NR];
+
+    /* buffers lists */
+    struct xran_flat_buffer sFrontHaulTxBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_NUM_OF_SYMBOL_PER_SLOT];
+    struct xran_flat_buffer sFrontHaulTxPrbMapBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
+    struct xran_flat_buffer sFrontHaulRxBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_NUM_OF_SYMBOL_PER_SLOT];
+    struct xran_flat_buffer sFrontHaulRxPrbMapBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
+    struct xran_flat_buffer sFHPrachRxBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_NUM_OF_SYMBOL_PER_SLOT];
+    struct xran_flat_buffer sFHPrachRxBuffersDecomp[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_NUM_OF_SYMBOL_PER_SLOT];
+    
+    /* Cat B SRS buffers */
+    struct xran_flat_buffer sFHSrsRxBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANT_ARRAY_ELM_NR][XRAN_MAX_NUM_OF_SRS_SYMBOL_PER_SLOT];
+    struct xran_flat_buffer sFHSrsRxPrbMapBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANT_ARRAY_ELM_NR];
+};
+
+struct bbu_xran_io_if {
+    void*    nInstanceHandle[XRAN_PORTS_NUM][XRAN_MAX_SECTOR_NR]; /* instance per ORAN port */
+    uint32_t nBufPoolIndex[XRAN_PORTS_NUM][XRAN_MAX_SECTOR_NR][MAX_SW_XRAN_INTERFACE_NUM];   /* every api owns unique buffer pool */
+    uint16_t nInstanceNum[XRAN_PORTS_NUM];
+    struct xran_io_shared_ctrl ioCtrl[XRAN_PORTS_NUM]; /**< for each O-RU port */
+};
+
     enum nChBw
     {
         PHY_BW_5MHZ   =   5, PHY_BW_10MHZ  =  10, PHY_BW_15MHZ  =  15,
@@ -91,7 +154,6 @@ public:
         {    32,     66,    132,    264 }   // Numerology 3 (120KHz)
     };
 
-
 protected:
     char argv[25] = "unittest";
 
@@ -111,28 +173,7 @@ protected:
         uint32_t    tti_to_process;
         } m_timer_ctx[MAX_NUM_OF_XRAN_CTX];
 
-    /* io struct */
-    BbuIoBufCtrlStruct m_sFrontHaulTxBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
-    BbuIoBufCtrlStruct m_sFrontHaulTxPrbMapBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
-    BbuIoBufCtrlStruct m_sFrontHaulRxBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
-    BbuIoBufCtrlStruct m_sFrontHaulRxPrbMapBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
-    BbuIoBufCtrlStruct m_sFHPrachRxBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
-
-    /* Cat B */
-    BbuIoBufCtrlStruct m_sFHSrsRxBbuIoBufCtrl[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANT_ARRAY_ELM_NR];
-
-    /* buffers lists */
-    struct xran_flat_buffer m_sFrontHaulTxBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_NUM_OF_SYMBOL_PER_SLOT];
-    struct xran_flat_buffer m_sFrontHaulTxPrbMapBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
-    struct xran_flat_buffer m_sFrontHaulRxBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_NUM_OF_SYMBOL_PER_SLOT];
-    struct xran_flat_buffer m_sFrontHaulRxPrbMapBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR];
-    struct xran_flat_buffer m_sFHPrachRxBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_NUM_OF_SYMBOL_PER_SLOT];
-
-    /* Cat B SRS buffers */
-    struct xran_flat_buffer m_sFHSrsRxBuffers[XRAN_N_FE_BUF_LEN][XRAN_MAX_SECTOR_NR][XRAN_MAX_ANT_ARRAY_ELM_NR][XRAN_MAX_NUM_OF_SRS_SYMBOL_PER_SLOT];
-
-    void    *m_nInstanceHandle[XRAN_PORTS_NUM][XRAN_MAX_SECTOR_NR]; // instance per sector
-    uint32_t m_nBufPoolIndex[XRAN_MAX_SECTOR_NR][MAX_SW_XRAN_INTERFACE_NUM];   // every api owns unique buffer pool
+    struct bbu_xran_io_if  m_gsXranIoIf;
 
     uint32_t m_nSW_ToFpga_FTH_TxBufferLen;
     uint32_t m_nFpgaToSW_FTH_RxBufferLen;
@@ -152,7 +193,6 @@ protected:
     int32_t tx_ul_bfw_buffer_size[MAX_ANT_CARRIER_SUPPORTED];
     int32_t tx_ul_bfw_buffer_position[MAX_ANT_CARRIER_SUPPORTED];
 
-
 private:
     json m_global_cfg;
 
@@ -185,10 +225,10 @@ private:
         return (result << shift);
     }
 
-    int init_memory()
+    int init_memory(uint32_t o_xu_id)
     {
         xran_status_t status;
-        int32_t i, j, k, z;
+        int32_t i, j, k, z, m;
         SWXRANInterfaceTypeEnum eInterfaceType;
         void *ptr;
         void *mb;
@@ -196,6 +236,9 @@ private:
         uint16_t *u16dptr;
         uint8_t  *u8dptr;
 
+        struct bbu_xran_io_if *psBbuIo = (struct bbu_xran_io_if*)&m_gsXranIoIf;
+        struct xran_io_shared_ctrl *psIoCtrl =  (struct xran_io_shared_ctrl *)&psBbuIo->ioCtrl[o_xu_id];
+
         uint32_t xran_max_antenna_nr = RTE_MAX(get_num_eaxc(), get_num_eaxc_ul());
         uint32_t xran_max_ant_array_elm_nr = RTE_MAX(get_num_antelmtrx(), xran_max_antenna_nr);
 
@@ -208,26 +251,27 @@ private:
             }
 
         /* initialize maximum instances to have flexibility for the tests */
-        int nInstanceNum = XRAN_MAX_SECTOR_NR;
+
         /* initialize maximum supported CC to have flexibility on the test */
         int32_t nSectorNum = 6;//XRAN_MAX_SECTOR_NR;
 
-        for(k = 0; k < XRAN_PORTS_NUM; k++) {
-            status = xran_sector_get_instances(m_xranhandle, nInstanceNum, &m_nInstanceHandle[k][0]);
+        k = o_xu_id;
+        psBbuIo->nInstanceNum[k] = nSectorNum;
+        status = xran_sector_get_instances(k, m_xranhandle, psBbuIo->nInstanceNum[k], &psBbuIo->nInstanceHandle[k][0]);
             if(status != XRAN_STATUS_SUCCESS) {
-                std::cout  << "get sector instance failed " << k << " for XRAN nInstanceNum " << nInstanceNum << std::endl;
+            std::cout  << "get sector instance failed " << k << " for XRAN nInstanceNum " << psBbuIo->nInstanceNum[k] << std::endl;
                 return (-1);
                 }
-            for (i = 0; i < nInstanceNum; i++)
-                std::cout << __func__ << " [" << k << "]: CC " << i << " handle " << m_nInstanceHandle[0][i] << std::endl;
-            }
+        for (i = 0; i < psBbuIo->nInstanceNum[k]; i++)
+            std::cout << __func__ << " [" << k << "]: CC " << i << " handle " << psBbuIo->nInstanceHandle[k][i] << std::endl;
+
         std::cout << "Sucess xran_mm_init" << std::endl;
 
         /* Init Memory */
         for(i = 0; i<nSectorNum; i++) {
             eInterfaceType = XRANFTHTX_OUT;
-            status = xran_bm_init(m_nInstanceHandle[0][i],
-                            &m_nBufPoolIndex[m_nSectorIndex[i]][eInterfaceType],
+            status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i],
+                            &psBbuIo->nBufPoolIndex[o_xu_id][m_nSectorIndex[i]][eInterfaceType],
                             XRAN_N_FE_BUF_LEN * xran_max_antenna_nr * XRAN_NUM_OF_SYMBOL_PER_SLOT,
                             m_nSW_ToFpga_FTH_TxBufferLen);
             if(status != XRAN_STATUS_SUCCESS) {
@@ -236,24 +280,24 @@ private:
                 }
             for(j = 0; j < XRAN_N_FE_BUF_LEN; j++) {
                 for(z = 0; z < xran_max_antenna_nr; z++){
-                    m_sFrontHaulTxBbuIoBufCtrl[j][i][z].bValid = 0;
-                    m_sFrontHaulTxBbuIoBufCtrl[j][i][z].nSegGenerated = -1;
-                    m_sFrontHaulTxBbuIoBufCtrl[j][i][z].nSegToBeGen = -1;
-                    m_sFrontHaulTxBbuIoBufCtrl[j][i][z].nSegTransferred = 0;
-                    m_sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers = XRAN_NUM_OF_SYMBOL_PER_SLOT;
-                    m_sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers = &m_sFrontHaulTxBuffers[j][i][z][0];
+                    psIoCtrl->sFrontHaulTxBbuIoBufCtrl[j][i][z].bValid = 0;
+                    psIoCtrl->sFrontHaulTxBbuIoBufCtrl[j][i][z].nSegGenerated = -1;
+                    psIoCtrl->sFrontHaulTxBbuIoBufCtrl[j][i][z].nSegToBeGen = -1;
+                    psIoCtrl->sFrontHaulTxBbuIoBufCtrl[j][i][z].nSegTransferred = 0;
+                    psIoCtrl->sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers = XRAN_NUM_OF_SYMBOL_PER_SLOT;
+                    psIoCtrl->sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers = &psIoCtrl->sFrontHaulTxBuffers[j][i][z][0];
 
                     for(k = 0; k < XRAN_NUM_OF_SYMBOL_PER_SLOT; k++) {
-                        m_sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nElementLenInBytes = m_nSW_ToFpga_FTH_TxBufferLen; // 14 symbols 3200bytes/symbol
-                        m_sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nNumberOfElements = 1;
-                        m_sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nOffsetInBytes = 0;
-                        status = xran_bm_allocate_buffer(m_nInstanceHandle[0][i], m_nBufPoolIndex[m_nSectorIndex[i]][eInterfaceType], &ptr, &mb);
+                        psIoCtrl->sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nElementLenInBytes = m_nSW_ToFpga_FTH_TxBufferLen; // 14 symbols 3200bytes/symbol
+                        psIoCtrl->sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nNumberOfElements = 1;
+                        psIoCtrl->sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nOffsetInBytes = 0;
+                        status = xran_bm_allocate_buffer(psBbuIo->nInstanceHandle[o_xu_id][i], psBbuIo->nBufPoolIndex[o_xu_id][m_nSectorIndex[i]][eInterfaceType], &ptr, &mb);
                         if(status != XRAN_STATUS_SUCCESS) {
                             std::cout << __LINE__ << " Failed at  xran_bm_allocate_buffer, status " << status << std::endl;
                             return (-1);
                             }
-                        m_sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].pData = (uint8_t *)ptr;
-                        m_sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].pCtrl = (void *)mb;
+                        psIoCtrl->sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].pData = (uint8_t *)ptr;
+                        psIoCtrl->sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].pCtrl = (void *)mb;
 
                         if(ptr) {
                             u32dptr = (uint32_t*)(ptr);
@@ -266,16 +310,16 @@ private:
 
             /* C-plane DL */
             eInterfaceType = XRANFTHTX_SEC_DESC_OUT;
-            status = xran_bm_init(m_nInstanceHandle[0][i],
-                            &m_nBufPoolIndex[m_nSectorIndex[i]][eInterfaceType],
-                            XRAN_N_FE_BUF_LEN * xran_max_antenna_nr * XRAN_NUM_OF_SYMBOL_PER_SLOT*XRAN_MAX_SECTIONS_PER_SYM, sizeof(struct xran_section_desc));
+            status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i],
+                            &psBbuIo->nBufPoolIndex[o_xu_id][m_nSectorIndex[i]][eInterfaceType],
+                            XRAN_N_FE_BUF_LEN * xran_max_antenna_nr * XRAN_NUM_OF_SYMBOL_PER_SLOT*XRAN_MAX_SECTIONS_PER_SLOT*XRAN_MAX_FRAGMENT, sizeof(struct xran_section_desc));
             if(XRAN_STATUS_SUCCESS != status) {
                 std::cout << __LINE__ << " Failed at xran_bm_init, status " << status << std::endl;
                 return (-1);
             }
             eInterfaceType = XRANFTHTX_PRB_MAP_OUT;
-            status = xran_bm_init(m_nInstanceHandle[0][i],
-                            &m_nBufPoolIndex[m_nSectorIndex[i]][eInterfaceType],
+            status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i],
+                            &psBbuIo->nBufPoolIndex[o_xu_id][m_nSectorIndex[i]][eInterfaceType],
                             XRAN_N_FE_BUF_LEN * xran_max_antenna_nr * XRAN_NUM_OF_SYMBOL_PER_SLOT,
                             sizeof(struct xran_prb_map));
             if(status != XRAN_STATUS_SUCCESS) {
@@ -284,37 +328,40 @@ private:
             }
             for(j = 0; j < XRAN_N_FE_BUF_LEN; j++) {
                 for(z = 0; z < xran_max_antenna_nr; z++) {
-                    m_sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].bValid = 0;
-                    m_sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].nSegGenerated = -1;
-                    m_sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].nSegToBeGen = -1;
-                    m_sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].nSegTransferred = 0;
-                    m_sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers = XRAN_NUM_OF_SYMBOL_PER_SLOT;
-                    m_sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers = &m_sFrontHaulTxPrbMapBuffers[j][i][z];
-
-                    m_sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nElementLenInBytes = sizeof(struct xran_prb_map);
-                    m_sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nNumberOfElements = 1;
-                    m_sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nOffsetInBytes = 0;
-                    status = xran_bm_allocate_buffer(m_nInstanceHandle[0][i], m_nBufPoolIndex[m_nSectorIndex[i]][eInterfaceType], &ptr, &mb);
+                    psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].bValid = 0;
+                    psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].nSegGenerated = -1;
+                    psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].nSegToBeGen = -1;
+                    psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].nSegTransferred = 0;
+                    psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers = XRAN_NUM_OF_SYMBOL_PER_SLOT;
+                    psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers = &psIoCtrl->sFrontHaulTxPrbMapBuffers[j][i][z];
+
+                    psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nElementLenInBytes = sizeof(struct xran_prb_map);
+                    psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nNumberOfElements = 1;
+                    psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nOffsetInBytes = 0;
+
+                    status = xran_bm_allocate_buffer(psBbuIo->nInstanceHandle[o_xu_id][i], psBbuIo->nBufPoolIndex[o_xu_id][m_nSectorIndex[i]][eInterfaceType], &ptr, &mb);
                     if(status != XRAN_STATUS_SUCCESS) {
                         std::cout << __LINE__ << " Failed at xran_bm_allocate_buffer, status " << status << std::endl;
                         return (-1);
                         }
-                    m_sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pData = (uint8_t *)ptr;
-                    m_sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pCtrl = (void *)mb;
+                    psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pData = (uint8_t *)ptr;
+                    psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pCtrl = (void *)mb;
                     void *sd_ptr;
                     void *sd_mb;
                     int  elm_id;
                     struct xran_prb_map * p_rb_map = (struct xran_prb_map *)ptr;
                     //memcpy(ptr, &startupConfiguration.PrbMap, sizeof(struct xran_prb_map));
-                    for (elm_id = 0; elm_id < XRAN_MAX_SECTIONS_PER_SYM; elm_id++){
+                    for (elm_id = 0; elm_id < XRAN_MAX_SECTIONS_PER_SLOT; elm_id++){
                         struct xran_prb_elm *pPrbElem = &p_rb_map->prbMap[elm_id];
                         for(k = 0; k < XRAN_NUM_OF_SYMBOL_PER_SLOT; k++){
-                            status = xran_bm_allocate_buffer(m_nInstanceHandle[0][i], m_nBufPoolIndex[m_nSectorIndex[i]][XRANFTHTX_SEC_DESC_OUT], &sd_ptr, &sd_mb);
+                            for(m = 0; m < XRAN_MAX_FRAGMENT; m++){
+                                status = xran_bm_allocate_buffer(psBbuIo->nInstanceHandle[o_xu_id][i], psBbuIo->nBufPoolIndex[o_xu_id][m_nSectorIndex[i]][XRANFTHTX_SEC_DESC_OUT], &sd_ptr, &sd_mb);
                             if(XRAN_STATUS_SUCCESS != status){
                                 std::cout << __LINE__ << "SD Failed at  xran_bm_allocate_buffer , status %d\n" << status << std::endl;
                                 return (-1);
                             }
-                            pPrbElem->p_sec_desc[k] = (struct xran_section_desc *)sd_ptr;
+                                pPrbElem->p_sec_desc[k][m] = (struct xran_section_desc *)sd_ptr;
+                            }
                         }
                     }
                  }
@@ -323,8 +370,8 @@ private:
 
         for(i = 0; i<nSectorNum; i++) {
             eInterfaceType = XRANFTHRX_IN;
-            status = xran_bm_init(m_nInstanceHandle[0][i],
-                            &m_nBufPoolIndex[m_nSectorIndex[i]][eInterfaceType],
+            status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i],
+                            &psBbuIo->nBufPoolIndex[o_xu_id][m_nSectorIndex[i]][eInterfaceType],
                             XRAN_N_FE_BUF_LEN * xran_max_antenna_nr * XRAN_NUM_OF_SYMBOL_PER_SLOT,
                             m_nSW_ToFpga_FTH_TxBufferLen);  /* ????, actual alloc size is m_nFpgaToSW_FTH_RxBUfferLen */
             if(status != XRAN_STATUS_SUCCESS) {
@@ -334,23 +381,23 @@ private:
 
             for(j = 0;j < XRAN_N_FE_BUF_LEN; j++) {
                 for(z = 0; z < xran_max_antenna_nr; z++) {
-                    m_sFrontHaulRxBbuIoBufCtrl[j][i][z].bValid                  = 0;
-                    m_sFrontHaulRxBbuIoBufCtrl[j][i][z].nSegGenerated           = -1;
-                    m_sFrontHaulRxBbuIoBufCtrl[j][i][z].nSegToBeGen             = -1;
-                    m_sFrontHaulRxBbuIoBufCtrl[j][i][z].nSegTransferred         = 0;
-                    m_sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers = XRAN_NUM_OF_SYMBOL_PER_SLOT;
-                    m_sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers    = &m_sFrontHaulRxBuffers[j][i][z][0];
+                    psIoCtrl->sFrontHaulRxBbuIoBufCtrl[j][i][z].bValid                  = 0;
+                    psIoCtrl->sFrontHaulRxBbuIoBufCtrl[j][i][z].nSegGenerated           = -1;
+                    psIoCtrl->sFrontHaulRxBbuIoBufCtrl[j][i][z].nSegToBeGen             = -1;
+                    psIoCtrl->sFrontHaulRxBbuIoBufCtrl[j][i][z].nSegTransferred         = 0;
+                    psIoCtrl->sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers = XRAN_NUM_OF_SYMBOL_PER_SLOT;
+                    psIoCtrl->sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers    = &psIoCtrl->sFrontHaulRxBuffers[j][i][z][0];
                     for(k = 0; k< XRAN_NUM_OF_SYMBOL_PER_SLOT; k++) {
-                        m_sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nElementLenInBytes  = m_nFpgaToSW_FTH_RxBufferLen;
-                        m_sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nNumberOfElements   = 1;
-                        m_sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nOffsetInBytes      = 0;
-                        status = xran_bm_allocate_buffer(m_nInstanceHandle[0][i], m_nBufPoolIndex[m_nSectorIndex[i]][eInterfaceType],&ptr, &mb);
+                        psIoCtrl->sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nElementLenInBytes  = m_nFpgaToSW_FTH_RxBufferLen;
+                        psIoCtrl->sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nNumberOfElements   = 1;
+                        psIoCtrl->sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nOffsetInBytes      = 0;
+                        status = xran_bm_allocate_buffer(psBbuIo->nInstanceHandle[o_xu_id][i], psBbuIo->nBufPoolIndex[o_xu_id][m_nSectorIndex[i]][eInterfaceType],&ptr, &mb);
                         if(status != XRAN_STATUS_SUCCESS) {
                             std::cout << __LINE__ << " Failed at  xran_bm_allocate_buffer, status " << status << std::endl;
                             return (-1);
                             }
-                        m_sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].pData   = (uint8_t *)ptr;
-                        m_sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].pCtrl   = (void *) mb;
+                        psIoCtrl->sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].pData   = (uint8_t *)ptr;
+                        psIoCtrl->sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].pCtrl   = (void *) mb;
                         if(ptr) {
                             u32dptr = (uint32_t*)(ptr);
                             uint8_t *ptr_temp = (uint8_t *)ptr;
@@ -361,16 +408,16 @@ private:
                 }
 
             eInterfaceType = XRANFTHTX_SEC_DESC_IN;
-            status = xran_bm_init(m_nInstanceHandle[0][i],
-                            &m_nBufPoolIndex[m_nSectorIndex[i]][eInterfaceType],
-                            XRAN_N_FE_BUF_LEN * xran_max_antenna_nr * XRAN_NUM_OF_SYMBOL_PER_SLOT*XRAN_MAX_SECTIONS_PER_SYM, sizeof(struct xran_section_desc));
+            status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i],
+                            &psBbuIo->nBufPoolIndex[o_xu_id][m_nSectorIndex[i]][eInterfaceType],
+                            XRAN_N_FE_BUF_LEN * xran_max_antenna_nr * XRAN_NUM_OF_SYMBOL_PER_SLOT*XRAN_MAX_SECTIONS_PER_SLOT*XRAN_MAX_FRAGMENT, sizeof(struct xran_section_desc));
             if(XRAN_STATUS_SUCCESS != status) {
                 std::cout << __LINE__ << " Failed at xran_bm_init, status " << status << std::endl;
                 return (-1);
             }
             eInterfaceType = XRANFTHRX_PRB_MAP_IN;
-            status = xran_bm_init(m_nInstanceHandle[0][i],
-                                &m_nBufPoolIndex[m_nSectorIndex[i]][eInterfaceType],
+            status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i],
+                                &psBbuIo->nBufPoolIndex[o_xu_id][m_nSectorIndex[i]][eInterfaceType],
                                 XRAN_N_FE_BUF_LEN * xran_max_antenna_nr * XRAN_NUM_OF_SYMBOL_PER_SLOT,
                                 sizeof(struct xran_prb_map));
             if(status != XRAN_STATUS_SUCCESS) {
@@ -380,37 +427,39 @@ private:
 
             for(j = 0;j < XRAN_N_FE_BUF_LEN; j++) {
                 for(z = 0; z < xran_max_antenna_nr; z++) {
-                    m_sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].bValid                    = 0;
-                    m_sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].nSegGenerated             = -1;
-                    m_sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].nSegToBeGen               = -1;
-                    m_sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].nSegTransferred           = 0;
-                    m_sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers   = XRAN_NUM_OF_SYMBOL_PER_SLOT;
-                    m_sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers      = &m_sFrontHaulRxPrbMapBuffers[j][i][z];
-
-                    m_sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nElementLenInBytes  = sizeof(struct xran_prb_map);
-                    m_sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nNumberOfElements   = 1;
-                    m_sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nOffsetInBytes      = 0;
-                    status = xran_bm_allocate_buffer(m_nInstanceHandle[0][i],m_nBufPoolIndex[m_nSectorIndex[i]][eInterfaceType], &ptr, &mb);
+                    psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].bValid                    = 0;
+                    psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].nSegGenerated             = -1;
+                    psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].nSegToBeGen               = -1;
+                    psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].nSegTransferred           = 0;
+                    psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers   = XRAN_NUM_OF_SYMBOL_PER_SLOT;
+                    psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers      = &psIoCtrl->sFrontHaulRxPrbMapBuffers[j][i][z];
+
+                    psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nElementLenInBytes  = sizeof(struct xran_prb_map);
+                    psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nNumberOfElements   = 1;
+                    psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->nOffsetInBytes      = 0;
+                    status = xran_bm_allocate_buffer(psBbuIo->nInstanceHandle[o_xu_id][i],psBbuIo->nBufPoolIndex[o_xu_id][m_nSectorIndex[i]][eInterfaceType], &ptr, &mb);
                     if(status != XRAN_STATUS_SUCCESS) {
                         std::cout << __LINE__ << " Failed at  xran_bm_allocate_buffer , status " << status << std::endl;
                         return (-1);
                         }
-                    m_sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pData   = (uint8_t *)ptr;
-                    m_sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pCtrl   = (void *)mb;
+                    psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pData   = (uint8_t *)ptr;
+                    psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList.pBuffers->pCtrl   = (void *)mb;
                     void *sd_ptr;
                     void *sd_mb;
                     int  elm_id;
                     struct xran_prb_map * p_rb_map = (struct xran_prb_map *)ptr;
                     //memcpy(ptr, &startupConfiguration.PrbMap, sizeof(struct xran_prb_map));
-                    for (elm_id = 0; elm_id < XRAN_MAX_SECTIONS_PER_SYM; elm_id++){
+                    for (elm_id = 0; elm_id < XRAN_MAX_SECTIONS_PER_SLOT; elm_id++){
                         struct xran_prb_elm *pPrbElem = &p_rb_map->prbMap[elm_id];
                         for(k = 0; k < XRAN_NUM_OF_SYMBOL_PER_SLOT; k++){
-                            status = xran_bm_allocate_buffer(m_nInstanceHandle[0][i], m_nBufPoolIndex[m_nSectorIndex[i]][XRANFTHTX_SEC_DESC_IN], &sd_ptr, &sd_mb);
+                            for(m = 0; m < XRAN_MAX_FRAGMENT; m++){
+                                status = xran_bm_allocate_buffer(psBbuIo->nInstanceHandle[o_xu_id][i], psBbuIo->nBufPoolIndex[o_xu_id][m_nSectorIndex[i]][XRANFTHTX_SEC_DESC_IN], &sd_ptr, &sd_mb);
                             if(XRAN_STATUS_SUCCESS != status){
                                 std::cout << __LINE__ << "SD Failed at  xran_bm_allocate_buffer , status %d\n" << status << std::endl;
                                 return (-1);
                             }
-                            pPrbElem->p_sec_desc[k] = (struct xran_section_desc *)sd_ptr;
+                                pPrbElem->p_sec_desc[k][m] = (struct xran_section_desc *)sd_ptr;
+                            }
                         }
                     }
                 }
@@ -419,36 +468,37 @@ private:
 
         for(i = 0; i<nSectorNum; i++) {
             eInterfaceType = XRANFTHRACH_IN;
-            status = xran_bm_init(m_nInstanceHandle[0][i],
-                                &m_nBufPoolIndex[m_nSectorIndex[i]][eInterfaceType],
+
+            status = xran_bm_init(psBbuIo->nInstanceHandle[o_xu_id][i],
+                                &psBbuIo->nBufPoolIndex[o_xu_id][m_nSectorIndex[i]][eInterfaceType],
                                 XRAN_N_FE_BUF_LEN * xran_max_antenna_nr * XRAN_NUM_OF_SYMBOL_PER_SLOT,
-                                FPGA_TO_SW_PRACH_RX_BUFFER_LEN);
+                                PRACH_PLAYBACK_BUFFER_BYTES);
             if(status != XRAN_STATUS_SUCCESS) {
                 std::cout << __LINE__ << " Failed at xran_bm_init, status " << status << std::endl;
                 return (-1);
                 }
             for(j = 0; j < XRAN_N_FE_BUF_LEN; j++) {
                 for(z = 0; z < xran_max_antenna_nr; z++) {
-                    m_sFHPrachRxBbuIoBufCtrl[j][i][z].bValid                    = 0;
-                    m_sFHPrachRxBbuIoBufCtrl[j][i][z].nSegGenerated             = -1;
-                    m_sFHPrachRxBbuIoBufCtrl[j][i][z].nSegToBeGen               = -1;
-                    m_sFHPrachRxBbuIoBufCtrl[j][i][z].nSegTransferred           = 0;
-                    m_sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers   = xran_max_antenna_nr;
-                    m_sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers      = &m_sFHPrachRxBuffers[j][i][z][0];
+                    psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].bValid                    = 0;
+                    psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].nSegGenerated             = -1;
+                    psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].nSegToBeGen               = -1;
+                    psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].nSegTransferred           = 0;
+                    psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.nNumBuffers   = xran_max_antenna_nr;
+                    psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers      = &psIoCtrl->sFHPrachRxBuffers[j][i][z][0];
                     for(k = 0; k< XRAN_NUM_OF_SYMBOL_PER_SLOT; k++) {
-                        m_sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nElementLenInBytes    = FPGA_TO_SW_PRACH_RX_BUFFER_LEN;
-                        m_sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nNumberOfElements     = 1;
-                        m_sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nOffsetInBytes        = 0;
-                        status = xran_bm_allocate_buffer(m_nInstanceHandle[0][i], m_nBufPoolIndex[m_nSectorIndex[i]][eInterfaceType], &ptr, &mb);
+                        psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nElementLenInBytes    = PRACH_PLAYBACK_BUFFER_BYTES;
+                        psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nNumberOfElements     = 1;
+                        psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].nOffsetInBytes        = 0;
+                        status = xran_bm_allocate_buffer(psBbuIo->nInstanceHandle[o_xu_id][i], psBbuIo->nBufPoolIndex[o_xu_id][m_nSectorIndex[i]][eInterfaceType], &ptr, &mb);
                         if(status != XRAN_STATUS_SUCCESS) {
                             std::cout << __LINE__ << " Failed at  xran_bm_allocate_buffer, status " << status << std::endl;
                             return (-1);
                             }
-                        m_sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].pData = (uint8_t *)ptr;
-                        m_sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].pCtrl = (void *)mb;
+                        psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].pData = (uint8_t *)ptr;
+                        psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList.pBuffers[k].pCtrl = (void *)mb;
                         if(ptr) {
                             u32dptr = (uint32_t*)(ptr);
-                            memset(u32dptr, 0x0, FPGA_TO_SW_PRACH_RX_BUFFER_LEN);
+                            memset(u32dptr, 0x0, PRACH_PLAYBACK_BUFFER_BYTES);
                             }
                         }
                     }
@@ -484,6 +534,9 @@ public:
         m_xranInit.io_cfg.pkt_proc_core     = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_IO, "pkt_proc_core");
         m_xranInit.io_cfg.pkt_aux_core      = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_IO, "pkt_aux_core");
         m_xranInit.io_cfg.timing_core       = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_IO, "timing_core");
+        m_xranInit.io_cfg.dpdkMemorySize    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_IO, "dpdkMemorySize");
+
+        m_xranInit.xran_ports = 1;
 
         std::string bbdev_mode = get_globalcfg<std::string>(XRAN_UT_KEY_GLOBALCFG_IO, "bbdev_mode");
         if(bbdev_mode == "sw")
@@ -499,6 +552,7 @@ public:
 
         m_xranInit.dpdkBasebandFecMode      = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_IO, "dpdkBasebandFecMode");
 
+
         m_dpdk_bbdev = get_globalcfg<std::string>(XRAN_UT_KEY_GLOBALCFG_IO, "dpdkBasebandDevice");
         m_xranInit.dpdkBasebandDevice       = (m_dpdk_bbdev == "") ? NULL : (char *)&m_dpdk_bbdev;
 
@@ -520,8 +574,8 @@ public:
             m_ru_mac[i] = (uint8_t)tmp_mac[i];
         m_xranInit.p_o_du_addr  = (int8_t *)m_du_mac;
         m_xranInit.p_o_ru_addr  = (int8_t *)m_ru_mac;
-        m_xranInit.cp_vlan_tag  = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_IO, "cp_vlan_tag");
-        m_xranInit.up_vlan_tag  = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_IO, "up_vlan_tag");
+        m_xranConf.cp_vlan_tag  = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_IO, "cp_vlan_tag");
+        m_xranConf.up_vlan_tag  = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_IO, "up_vlan_tag");
 
         /* eAxCID configurations */
         int bitnum_cuport   = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_EAXCID, "bit_cuPortId");
@@ -539,36 +593,36 @@ public:
         m_xranInit.eAxCId_conf.mask_ruPortId      = get_eaxcid_mask(bitnum_ruport, m_xranInit.eAxCId_conf.bit_ruPortId);
 
         m_xranInit.totalBfWeights   = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "totalBfWeights");
-
-        m_xranInit.Tadv_cp_dl       = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "Tadv_cp_dl");
-        m_xranInit.T2a_min_cp_dl    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T2a_min_cp_dl");
-        m_xranInit.T2a_max_cp_dl    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T2a_max_cp_dl");
-        m_xranInit.T2a_min_cp_ul    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T2a_min_cp_ul");
-        m_xranInit.T2a_max_cp_ul    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T2a_max_cp_ul");
-        m_xranInit.T2a_min_up       = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T2a_min_up");
-        m_xranInit.T2a_max_up       = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T2a_max_up");
-        m_xranInit.Ta3_min          = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "Ta3_min");
-        m_xranInit.Ta3_max          = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "Ta3_max");
-        m_xranInit.T1a_min_cp_dl    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T1a_min_cp_dl");
-        m_xranInit.T1a_max_cp_dl    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T1a_max_cp_dl");
-        m_xranInit.T1a_min_cp_ul    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T1a_min_cp_ul");
-        m_xranInit.T1a_max_cp_ul    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T1a_max_cp_ul");
-        m_xranInit.T1a_min_up       = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T1a_min_up");
-        m_xranInit.T1a_max_up       = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T1a_max_up");
-        m_xranInit.Ta4_min          = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "Ta4_min");
-        m_xranInit.Ta4_max          = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "Ta4_max");
-
-        m_xranInit.enableCP         = 1;
-        m_xranInit.prachEnable      = 1;
-        m_xranInit.debugStop        = 0;
-        m_xranInit.debugStopCount   = 0;
-        m_xranInit.DynamicSectionEna= 0;
-
         m_xranInit.filePrefix   = "wls";
 
         m_bSub6     = get_globalcfg<bool>(XRAN_UT_KEY_GLOBALCFG_RU, "sub6");
 
         memset(&m_xranConf, 0, sizeof(struct xran_fh_config));
+
+        m_xranConf.Tadv_cp_dl       = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "Tadv_cp_dl");
+        m_xranConf.T2a_min_cp_dl    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T2a_min_cp_dl");
+        m_xranConf.T2a_max_cp_dl    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T2a_max_cp_dl");
+        m_xranConf.T2a_min_cp_ul    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T2a_min_cp_ul");
+        m_xranConf.T2a_max_cp_ul    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T2a_max_cp_ul");
+        m_xranConf.T2a_min_up       = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T2a_min_up");
+        m_xranConf.T2a_max_up       = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T2a_max_up");
+        m_xranConf.Ta3_min          = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "Ta3_min");
+        m_xranConf.Ta3_max          = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "Ta3_max");
+        m_xranConf.T1a_min_cp_dl    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T1a_min_cp_dl");
+        m_xranConf.T1a_max_cp_dl    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T1a_max_cp_dl");
+        m_xranConf.T1a_min_cp_ul    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T1a_min_cp_ul");
+        m_xranConf.T1a_max_cp_ul    = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T1a_max_cp_ul");
+        m_xranConf.T1a_min_up       = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T1a_min_up");
+        m_xranConf.T1a_max_up       = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "T1a_max_up");
+        m_xranConf.Ta4_min          = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "Ta4_min");
+        m_xranConf.Ta4_max          = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "Ta4_max");
+
+        m_xranConf.enableCP         = 1;
+        m_xranConf.prachEnable      = 1;
+        m_xranConf.debugStop        = 0;
+        m_xranConf.debugStopCount   = 0;
+        m_xranConf.DynamicSectionEna= 0;
+
         tmpstr = get_globalcfg<std::string>(XRAN_UT_KEY_GLOBALCFG_RU, "duplex");
         if(tmpstr == "FDD") {
             m_xranConf.frame_conf.nFrameDuplexType  = 0;
@@ -623,6 +677,7 @@ public:
         m_xranConf.nDLRBs = get_num_rbs(get_numerology(), temp, m_bSub6);
         temp = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "chbw_ul");
         m_xranConf.nULRBs = get_num_rbs(get_numerology(), temp, m_bSub6);
+        m_xranConf.dpdk_port    = 0;
 
         m_xranConf.nAntElmTRx = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "ant_elm_trx");
         m_xranConf.nDLFftSize = get_globalcfg<int>(XRAN_UT_KEY_GLOBALCFG_RU, "fft_size");
@@ -706,6 +761,8 @@ public:
 
         xran_init(0, NULL, &m_xranInit, &argv[0], &m_xranhandle);
 
+
+
         for(i = 0; i < XRAN_MAX_SECTOR_NR; i++)
             m_nSectorIndex[i] = i;
 
@@ -713,7 +770,7 @@ public:
         m_nFpgaToSW_FTH_RxBufferLen     = 13168; /* 273*12*4 + 64*/
         m_nSW_ToFpga_FTH_TxBufferLen    = 13168; /* 273*12*4 + 64*/
 
-        if(init_memory() < 0) {
+        if(init_memory(0) < 0) {
             std::cout << "Fatal Error on Initialization !!!" << std::endl;
             std::cout << "INIT FAILED" << std::endl;
             return (-1);
@@ -734,7 +791,7 @@ public:
             std::cout << "ALREADY CLOSED" << std::endl;
     }
 
-    int Init(struct xran_fh_config *pCfg = nullptr)
+    int Init(uint32_t o_xu_id, struct xran_fh_config *pCfg = nullptr)
     {
         xran_status_t status;
         int32_t nSectorNum;
@@ -750,6 +807,8 @@ public:
         char    *pos        = NULL;
         struct xran_prb_map *pRbMap = NULL;
 
+        struct bbu_xran_io_if *psBbuIo = (struct bbu_xran_io_if*)&m_gsXranIoIf;
+        struct xran_io_shared_ctrl *psIoCtrl =  (struct xran_io_shared_ctrl *)&psBbuIo->ioCtrl[o_xu_id];
 
         uint32_t xran_max_antenna_nr = RTE_MAX(get_num_eaxc(), get_num_eaxc_ul());
         uint32_t xran_max_ant_array_elm_nr = RTE_MAX(get_num_antelmtrx(), xran_max_antenna_nr);
@@ -760,9 +819,12 @@ public:
             memcpy(&m_xranConf, pCfg, sizeof(struct xran_fh_config));
 
         /* Init timer context */
-        xran_lib_ota_tti        = 0;
-        xran_lib_ota_sym        = 0;
-        xran_lib_ota_sym_idx    = 0;
+        for (i=0; i<XRAN_PORTS_NUM; i++)
+        {
+            xran_lib_ota_sym[i] = 0;
+            xran_lib_ota_sym_idx[i] = 0;
+            xran_lib_ota_tti[i]        = 0;
+        }
         for(i=0; i < MAX_NUM_OF_XRAN_CTX; i++)
             m_timer_ctx[i].tti_to_process = i;
 
@@ -800,7 +862,7 @@ public:
                     flowId = xran_max_antenna_nr*cc_id + ant_id;
 
                     /* C-plane DL */
-                    pRbMap = (struct xran_prb_map *)m_sFrontHaulTxPrbMapBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers->pData;
+                    pRbMap = (struct xran_prb_map *)psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers->pData;
                     if(pRbMap) {
                         pRbMap->dir                     = XRAN_DIR_DL;
                         pRbMap->xran_port               = 0;
@@ -842,7 +904,7 @@ public:
                                 p_prbMap = &pRbMap->prbMap[idxElm];
                                 for (iPrb = p_prbMap->nRBStart; iPrb < (p_prbMap->nRBStart + p_prbMap->nRBSize); iPrb++) {
                                     /* copy BF W IQs for 1 PRB of */
-                                    rte_memcpy(&pRbMap->bf_weight.weight[iPrb][0], (dl_bfw_pos + (iPrb * num_antelm)*4), num_antelm*4);
+                                    memcpy(&pRbMap->bf_weight.weight[iPrb][0], (dl_bfw_pos + (iPrb * num_antelm)*4), num_antelm*4);
                                     }
                                 }
 #endif
@@ -853,7 +915,7 @@ public:
                         }
 
                     /* C-plane UL */
-                    pRbMap = (struct xran_prb_map *)m_sFrontHaulRxPrbMapBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers->pData;
+                    pRbMap = (struct xran_prb_map *)psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[tti][cc_id][ant_id].sBufferList.pBuffers->pData;
                     if(pRbMap) {
                         pRbMap->dir                     = XRAN_DIR_UL;
                         pRbMap->xran_port               = 0;
@@ -895,7 +957,7 @@ public:
                                 p_prbMap = &pRbMap->prbMap[idxElm];
                                 for (iPrb = p_prbMap->nRBStart; iPrb < (p_prbMap->nRBStart + p_prbMap->nRBSize); iPrb++){
                                     /* copy BF W IQs for 1 PRB of */
-                                    rte_memcpy(&pRbMap->bf_weight.weight[iPrb][0], (ul_bfw_pos + (iPrb*num_antelm)*4), num_antelm*4);
+                                    memcpy(&pRbMap->bf_weight.weight[iPrb][0], (ul_bfw_pos + (iPrb*num_antelm)*4), num_antelm*4);
                                     }
                                 }
 #endif
@@ -934,13 +996,16 @@ public:
     }
 
 
-    void Open(xran_ethdi_mbuf_send_fn send_cp, xran_ethdi_mbuf_send_fn send_up,
+    void Open(uint32_t o_xu_id, xran_ethdi_mbuf_send_fn send_cp, xran_ethdi_mbuf_send_fn send_up,
             void *fh_rx_callback, void *fh_rx_prach_callback, void *fh_srs_callback)
     {
         struct xran_fh_config *pXranConf;
         int32_t nSectorNum;
         int i, j, k, z;
 
+        struct bbu_xran_io_if *psBbuIo = (struct bbu_xran_io_if*)&m_gsXranIoIf;
+        struct xran_io_shared_ctrl *psIoCtrl =  (struct xran_io_shared_ctrl *)&psBbuIo->ioCtrl[o_xu_id];
+
         uint32_t xran_max_antenna_nr = RTE_MAX(get_num_eaxc(), get_num_eaxc_ul());
         uint32_t xran_max_ant_array_elm_nr = RTE_MAX(get_num_antelmtrx(), xran_max_antenna_nr);
 
@@ -949,7 +1014,9 @@ public:
         struct xran_buffer_list *pFthRxBuffer[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN];
         struct xran_buffer_list *pFthRxPrbMapBuffer[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN];
         struct xran_buffer_list *pFthRxRachBuffer[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN];
+        struct xran_buffer_list *pFthRxRachBufferDecomp[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANTENNA_NR][XRAN_N_FE_BUF_LEN];
         struct xran_buffer_list *pFthRxSrsBuffer[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANT_ARRAY_ELM_NR][XRAN_N_FE_BUF_LEN];
+        struct xran_buffer_list *pFthRxSrsPrbMapBuffer[XRAN_MAX_SECTOR_NR][XRAN_MAX_ANT_ARRAY_ELM_NR][XRAN_N_FE_BUF_LEN];
 
 #if 0
         xran_reg_physide_cb(xranHandle, physide_dl_tti_call_back, NULL, 10, XRAN_CB_TTI);
@@ -958,61 +1025,59 @@ public:
 #endif
         nSectorNum = get_num_cc();
 
-        for(i=0; i<nSectorNum; i++)
-        {
-            for(j=0; j<XRAN_N_FE_BUF_LEN; j++)
-            {
-                for(z = 0; z < xran_max_antenna_nr; z++){
+        for(i=0; i<nSectorNum; i++) {
+            for(j=0; j<XRAN_N_FE_BUF_LEN; j++) {
+                for(z = 0; z < /*xran_max_antenna_nr*/XRAN_MAX_ANTENNA_NR; z++) {
                     pFthTxBuffer[i][z][j]       = NULL;
                     pFthTxPrbMapBuffer[i][z][j] = NULL;
                     pFthRxBuffer[i][z][j]       = NULL;
                     pFthRxPrbMapBuffer[i][z][j] = NULL;
                     pFthRxRachBuffer[i][z][j]   = NULL;
+                    pFthRxRachBufferDecomp[i][z][j]   = NULL;
                 }
-                for(z = 0; z < xran_max_ant_array_elm_nr; z++){
+                for(z = 0; z < /*xran_max_ant_array_elm_nr*/XRAN_MAX_ANT_ARRAY_ELM_NR; z++) {
                     pFthRxSrsBuffer[i][z][j] = NULL;
+                    pFthRxSrsPrbMapBuffer[i][z][j] = NULL;
                 }
             }
         }
 
         for(i=0; i<nSectorNum; i++) {
             for(j=0; j<XRAN_N_FE_BUF_LEN; j++) {
-                for(z = 0; z < xran_max_antenna_nr; z++) {
-                    pFthTxBuffer[i][z][j]       = &(m_sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList);
-                    pFthTxPrbMapBuffer[i][z][j] = &(m_sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList);
-                    pFthRxBuffer[i][z][j]       = &(m_sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList);
-                    pFthRxPrbMapBuffer[i][z][j] = &(m_sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList);
-                    pFthRxRachBuffer[i][z][j]   = &(m_sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList);
+                for(z = 0; z < /*xran_max_antenna_nr*/XRAN_MAX_ANTENNA_NR; z++) {
+                    pFthTxBuffer[i][z][j]       = &(psIoCtrl->sFrontHaulTxBbuIoBufCtrl[j][i][z].sBufferList);
+                    pFthTxPrbMapBuffer[i][z][j] = &(psIoCtrl->sFrontHaulTxPrbMapBbuIoBufCtrl[j][i][z].sBufferList);
+                    pFthRxBuffer[i][z][j]       = &(psIoCtrl->sFrontHaulRxBbuIoBufCtrl[j][i][z].sBufferList);
+                    pFthRxPrbMapBuffer[i][z][j] = &(psIoCtrl->sFrontHaulRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList);
+                    pFthRxRachBuffer[i][z][j]   = &(psIoCtrl->sFHPrachRxBbuIoBufCtrl[j][i][z].sBufferList);
+                    pFthRxRachBufferDecomp[i][z][j]   = &(psIoCtrl->sFHPrachRxBbuIoBufCtrlDecomp[j][i][z].sBufferList);                    
                     }
-                    for(z = 0; z < xran_max_ant_array_elm_nr && xran_max_ant_array_elm_nr; z++){
-                        pFthRxSrsBuffer[i][z][j] = &(m_sFHSrsRxBbuIoBufCtrl[j][i][z].sBufferList);
+                for(z = 0; z < XRAN_MAX_ANT_ARRAY_ELM_NR /*xran_max_ant_array_elm_nr && xran_max_ant_array_elm_nr*/; z++) {
+                    pFthRxSrsBuffer[i][z][j] = &(psIoCtrl->sFHSrsRxBbuIoBufCtrl[j][i][z].sBufferList);
+                    pFthRxSrsPrbMapBuffer[i][z][j] = &(psIoCtrl->sFHSrsRxPrbMapBbuIoBufCtrl[j][i][z].sBufferList);
             }
                 }
             }
 
-        if(m_nInstanceHandle[0] != NULL) {
+        if(psBbuIo->nInstanceHandle[o_xu_id] != NULL) {
             for(i = 0; i<nSectorNum; i++) {
-                xran_5g_fronthault_config(m_nInstanceHandle[0][i],
+                xran_5g_fronthault_config(psBbuIo->nInstanceHandle[o_xu_id][i],
                         pFthTxBuffer[i], pFthTxPrbMapBuffer[i],
                         pFthRxBuffer[i], pFthRxPrbMapBuffer[i],
                         (void (*)(void *, xran_status_t))fh_rx_callback, &pFthRxBuffer[i][0]);
-
-                xran_5g_prach_req(m_nInstanceHandle[0][i], pFthRxRachBuffer[i],
-                        (void (*)(void *, xran_status_t))fh_rx_prach_callback, &pFthRxRachBuffer[i][0]);
+                xran_5g_prach_req(psBbuIo->nInstanceHandle[o_xu_id][i], pFthRxRachBuffer[i],pFthRxRachBufferDecomp[i],
+                        (void (*)(void *, xran_status_t))fh_rx_prach_callback, &pFthRxRachBuffer[i]);
                 }
 
             /* add SRS callback here */
             for (i = 0; i<nSectorNum && xran_max_ant_array_elm_nr; i++) {
-                xran_5g_srs_req(m_nInstanceHandle[0][i], pFthRxSrsBuffer[i],
-                    (void (*)(void *, xran_status_t))fh_srs_callback,&pFthRxSrsBuffer[i][0]);
+                xran_5g_srs_req(psBbuIo->nInstanceHandle[o_xu_id][i], pFthRxSrsBuffer[i], pFthRxSrsPrbMapBuffer[i],
+                    (void (*)(void *, xran_status_t))fh_srs_callback, pFthRxSrsBuffer[i]);
                 }
 
             }
 
-
-
         xran_register_cb_mbuf2ring(send_cp, send_up);
-
         xran_open(m_xranhandle, &m_xranConf);
     }
 
@@ -1046,14 +1111,19 @@ public:
 
     void update_symbol_index()
     {
-        xran_lib_ota_sym_idx++;
-        if((xran_lib_ota_sym_idx % N_SYM_PER_SLOT) == 0) {
+        int i;
+        for (i=0; i<XRAN_PORTS_NUM; i++)
+            xran_lib_ota_sym_idx[i]++;
+        if((xran_lib_ota_sym_idx[0] % N_SYM_PER_SLOT) == 0) {
             update_tti();
             }
+        for (i=0; i<XRAN_PORTS_NUM; i++)
+        {
+            xran_lib_ota_sym[i]++;
+            if(xran_lib_ota_sym[i] >= N_SYM_PER_SLOT)
+                xran_lib_ota_sym[i] = 0;
+        }
 
-        xran_lib_ota_sym++;
-        if(xran_lib_ota_sym >= N_SYM_PER_SLOT)
-            xran_lib_ota_sym = 0;
     }
 
     int apply_cpenable(bool flag)
@@ -1067,11 +1137,11 @@ public:
             return (-1);
 
         if(flag == true) {
-            m_xranInit.enableCP = 1;
+            m_xranConf.enableCP = 1;
             pCtx->enableCP = 1;
             }
         else {
-            m_xranInit.enableCP = 0;
+            m_xranConf.enableCP = 0;
             pCtx->enableCP = 0;
             }
 
@@ -1142,9 +1212,9 @@ public:
     }
 
     void *get_xranhandle()  { return(m_xranhandle); }
-    void *get_timer_ctx()   { return((void *)&m_timer_ctx[0]); }
+    void *get_timer_ctx()   { return((void *)xran_dev_get_ctx()); }
 
-    int get_symbol_index()  { return (xran_lib_ota_sym); }
+    int get_symbol_index()  { return (xran_lib_ota_sym[0]); }
 
     bool is_running()       { return((xran_get_if_state() == XRAN_RUNNING)?true:false); }
 
@@ -1159,9 +1229,9 @@ public:
     int get_num_ulrbs()     { return(m_xranConf.nULRBs); }
     int get_num_antelmtrx() { return(m_xranConf.nAntElmTRx); }
 
-    bool is_cpenable()      { return(m_xranInit.enableCP); };
-    bool is_prachenable()   { return(m_xranInit.prachEnable); };
-    bool is_dynamicsection() { return(m_xranInit.DynamicSectionEna?true:false); }
+    bool is_cpenable()      { return(m_xranConf.enableCP); };
+    bool is_prachenable()   { return(m_xranConf.prachEnable); };
+    bool is_dynamicsection() { return(m_xranConf.DynamicSectionEna?true:false); }
 
     void get_cfg_prach(struct xran_prach_config *pCfg)
     {