LCOV - code coverage report
Current view: top level - drivers/net/zxdh - zxdh_msg.c (source / functions) Hit Total Coverage
Test: Code coverage Lines: 0 980 0.0 %
Date: 2025-07-01 21:32:37 Functions: 0 63 0.0 %
Legend: Lines: hit not hit | Branches: + taken - not taken # not executed Branches: 0 390 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: BSD-3-Clause
       2                 :            :  * Copyright(c) 2024 ZTE Corporation
       3                 :            :  */
       4                 :            : 
       5                 :            : #include <stdbool.h>
       6                 :            : 
       7                 :            : #include <rte_common.h>
       8                 :            : #include <rte_memcpy.h>
       9                 :            : #include <rte_spinlock.h>
      10                 :            : #include <rte_cycles.h>
      11                 :            : #include <inttypes.h>
      12                 :            : #include <rte_malloc.h>
      13                 :            : #include "rte_mtr_driver.h"
      14                 :            : 
      15                 :            : #include "zxdh_ethdev.h"
      16                 :            : #include "zxdh_logs.h"
      17                 :            : #include "zxdh_msg.h"
      18                 :            : #include "zxdh_pci.h"
      19                 :            : #include "zxdh_tables.h"
      20                 :            : #include "zxdh_np.h"
      21                 :            : #include "zxdh_common.h"
      22                 :            : 
      23                 :            : #define ZXDH_REPS_INFO_FLAG_USABLE  0x00
      24                 :            : #define ZXDH_BAR_SEQID_NUM_MAX      256
      25                 :            : #define ZXDH_REPS_INFO_FLAG_USED    0xa0
      26                 :            : 
      27                 :            : #define ZXDH_PCIEID_IS_PF_MASK      (0x0800)
      28                 :            : #define ZXDH_PCIEID_PF_IDX_MASK     (0x0700)
      29                 :            : #define ZXDH_PCIEID_VF_IDX_MASK     (0x00ff)
      30                 :            : #define ZXDH_PCIEID_EP_IDX_MASK     (0x7000)
      31                 :            : /* PCIEID bit field offset */
      32                 :            : #define ZXDH_PCIEID_PF_IDX_OFFSET   (8)
      33                 :            : #define ZXDH_PCIEID_EP_IDX_OFFSET   (12)
      34                 :            : 
      35                 :            : #define ZXDH_MULTIPLY_BY_8(x)       ((x) << 3)
      36                 :            : #define ZXDH_MULTIPLY_BY_32(x)      ((x) << 5)
      37                 :            : #define ZXDH_MULTIPLY_BY_256(x)     ((x) << 8)
      38                 :            : 
      39                 :            : #define ZXDH_MAX_EP_NUM              (4)
      40                 :            : #define ZXDH_MAX_HARD_SPINLOCK_NUM   (511)
      41                 :            : 
      42                 :            : #define ZXDH_LOCK_PRIMARY_ID_MASK       (0x8000)
      43                 :            : /* bar offset */
      44                 :            : #define ZXDH_BAR0_CHAN_RISC_OFFSET      (0x2000)
      45                 :            : #define ZXDH_BAR0_CHAN_PFVF_OFFSET      (0x3000)
      46                 :            : #define ZXDH_BAR0_SPINLOCK_OFFSET       (0x4000)
      47                 :            : #define ZXDH_FW_SHRD_OFFSET             (0x5000)
      48                 :            : #define ZXDH_FW_SHRD_INNER_HW_LABEL_PAT (0x800)
      49                 :            : #define ZXDH_HW_LABEL_OFFSET   \
      50                 :            :         (ZXDH_FW_SHRD_OFFSET + ZXDH_FW_SHRD_INNER_HW_LABEL_PAT)
      51                 :            : 
      52                 :            : #define ZXDH_CHAN_RISC_SPINLOCK_OFFSET \
      53                 :            :         (ZXDH_BAR0_SPINLOCK_OFFSET - ZXDH_BAR0_CHAN_RISC_OFFSET)
      54                 :            : #define ZXDH_CHAN_PFVF_SPINLOCK_OFFSET \
      55                 :            :         (ZXDH_BAR0_SPINLOCK_OFFSET - ZXDH_BAR0_CHAN_PFVF_OFFSET)
      56                 :            : #define ZXDH_CHAN_RISC_LABEL_OFFSET    \
      57                 :            :         (ZXDH_HW_LABEL_OFFSET - ZXDH_BAR0_CHAN_RISC_OFFSET)
      58                 :            : #define ZXDH_CHAN_PFVF_LABEL_OFFSET    \
      59                 :            :         (ZXDH_HW_LABEL_OFFSET - ZXDH_BAR0_CHAN_PFVF_OFFSET)
      60                 :            : 
      61                 :            : #define ZXDH_REPS_HEADER_LEN_OFFSET      1
      62                 :            : #define ZXDH_REPS_HEADER_PAYLOAD_OFFSET  4
      63                 :            : #define ZXDH_REPS_HEADER_REPLYED         0xff
      64                 :            : 
      65                 :            : #define ZXDH_BAR_MSG_CHAN_USABLE  0
      66                 :            : #define ZXDH_BAR_MSG_CHAN_USED    1
      67                 :            : 
      68                 :            : #define ZXDH_BAR_MSG_POL_MASK     (0x10)
      69                 :            : #define ZXDH_BAR_MSG_POL_OFFSET   (4)
      70                 :            : 
      71                 :            : #define ZXDH_BAR_ALIGN_WORD_MASK   0xfffffffc
      72                 :            : #define ZXDH_BAR_MSG_VALID_MASK    1
      73                 :            : #define ZXDH_BAR_MSG_VALID_OFFSET  0
      74                 :            : 
      75                 :            : #define ZXDH_BAR_PF_NUM             7
      76                 :            : #define ZXDH_BAR_VF_NUM             256
      77                 :            : #define ZXDH_BAR_INDEX_PF_TO_VF     0
      78                 :            : #define ZXDH_BAR_INDEX_MPF_TO_MPF   0xff
      79                 :            : #define ZXDH_BAR_INDEX_MPF_TO_PFVF  0
      80                 :            : #define ZXDH_BAR_INDEX_PFVF_TO_MPF  0
      81                 :            : 
      82                 :            : #define ZXDH_MAX_HARD_SPINLOCK_ASK_TIMES  (1000)
      83                 :            : #define ZXDH_SPINLOCK_POLLING_SPAN_US     (100)
      84                 :            : 
      85                 :            : #define ZXDH_BAR_MSG_SRC_NUM   3
      86                 :            : #define ZXDH_BAR_MSG_SRC_MPF   0
      87                 :            : #define ZXDH_BAR_MSG_SRC_PF    1
      88                 :            : #define ZXDH_BAR_MSG_SRC_VF    2
      89                 :            : #define ZXDH_BAR_MSG_SRC_ERR   0xff
      90                 :            : #define ZXDH_BAR_MSG_DST_NUM   3
      91                 :            : #define ZXDH_BAR_MSG_DST_RISC  0
      92                 :            : #define ZXDH_BAR_MSG_DST_MPF   2
      93                 :            : #define ZXDH_BAR_MSG_DST_PFVF  1
      94                 :            : #define ZXDH_BAR_MSG_DST_ERR   0xff
      95                 :            : #define ZXDH_BAR_INDEX_TO_RISC  0
      96                 :            : 
      97                 :            : #define ZXDH_BAR_CHAN_INDEX_SEND  0
      98                 :            : #define ZXDH_BAR_CHAN_INDEX_RECV  1
      99                 :            : 
     100                 :            : #define ZXDH_BAR_CHAN_MSG_SYNC     0
     101                 :            : #define ZXDH_BAR_CHAN_MSG_NO_EMEC  0
     102                 :            : #define ZXDH_BAR_CHAN_MSG_EMEC     1
     103                 :            : #define ZXDH_BAR_CHAN_MSG_NO_ACK   0
     104                 :            : #define ZXDH_BAR_CHAN_MSG_ACK      1
     105                 :            : #define ZXDH_MSG_REPS_OK           0xff
     106                 :            : 
     107                 :            : static uint8_t subchan_id_tbl[ZXDH_BAR_MSG_SRC_NUM][ZXDH_BAR_MSG_DST_NUM] = {
     108                 :            :         {ZXDH_BAR_CHAN_INDEX_SEND, ZXDH_BAR_CHAN_INDEX_SEND, ZXDH_BAR_CHAN_INDEX_SEND},
     109                 :            :         {ZXDH_BAR_CHAN_INDEX_SEND, ZXDH_BAR_CHAN_INDEX_SEND, ZXDH_BAR_CHAN_INDEX_RECV},
     110                 :            :         {ZXDH_BAR_CHAN_INDEX_SEND, ZXDH_BAR_CHAN_INDEX_RECV, ZXDH_BAR_CHAN_INDEX_RECV}
     111                 :            : };
     112                 :            : 
     113                 :            : static uint8_t chan_id_tbl[ZXDH_BAR_MSG_SRC_NUM][ZXDH_BAR_MSG_DST_NUM] = {
     114                 :            :         {ZXDH_BAR_INDEX_TO_RISC, ZXDH_BAR_INDEX_MPF_TO_PFVF, ZXDH_BAR_INDEX_MPF_TO_MPF},
     115                 :            :         {ZXDH_BAR_INDEX_TO_RISC, ZXDH_BAR_INDEX_PF_TO_VF,   ZXDH_BAR_INDEX_PFVF_TO_MPF},
     116                 :            :         {ZXDH_BAR_INDEX_TO_RISC, ZXDH_BAR_INDEX_PF_TO_VF,   ZXDH_BAR_INDEX_PFVF_TO_MPF}
     117                 :            : };
     118                 :            : 
     119                 :            : struct zxdh_dev_stat {
     120                 :            :         bool is_mpf_scanned;
     121                 :            :         bool is_res_init;
     122                 :            :         int16_t dev_cnt; /* probe cnt */
     123                 :            : };
     124                 :            : 
     125                 :            : struct zxdh_seqid_item {
     126                 :            :         void *reps_addr;
     127                 :            :         uint16_t id;
     128                 :            :         uint16_t buffer_len;
     129                 :            :         uint16_t flag;
     130                 :            : };
     131                 :            : 
     132                 :            : struct zxdh_seqid_ring {
     133                 :            :         uint16_t cur_id;
     134                 :            :         rte_spinlock_t lock;
     135                 :            :         struct zxdh_seqid_item reps_info_tbl[ZXDH_BAR_SEQID_NUM_MAX];
     136                 :            : };
     137                 :            : 
     138                 :            : static struct zxdh_dev_stat g_dev_stat;
     139                 :            : static struct zxdh_seqid_ring g_seqid_ring;
     140                 :            : static uint8_t tmp_msg_header[ZXDH_BAR_MSG_ADDR_CHAN_INTERVAL];
     141                 :            : static rte_spinlock_t chan_lock;
     142                 :            : 
     143                 :            : zxdh_bar_chan_msg_recv_callback zxdh_msg_recv_func_tbl[ZXDH_BAR_MSG_MODULE_NUM];
     144                 :            : 
     145                 :            : static inline const char
     146                 :          0 : *zxdh_module_id_name(int val)
     147                 :            : {
     148   [ #  #  #  #  :          0 :         switch (val) {
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
     149                 :            :         case ZXDH_BAR_MODULE_DBG:        return "ZXDH_BAR_MODULE_DBG";
     150                 :          0 :         case ZXDH_BAR_MODULE_TBL:        return "ZXDH_BAR_MODULE_TBL";
     151                 :          0 :         case ZXDH_BAR_MODULE_MISX:       return "ZXDH_BAR_MODULE_MISX";
     152                 :          0 :         case ZXDH_BAR_MODULE_SDA:        return "ZXDH_BAR_MODULE_SDA";
     153                 :          0 :         case ZXDH_BAR_MODULE_RDMA:       return "ZXDH_BAR_MODULE_RDMA";
     154                 :          0 :         case ZXDH_BAR_MODULE_DEMO:       return "ZXDH_BAR_MODULE_DEMO";
     155                 :          0 :         case ZXDH_BAR_MODULE_SMMU:       return "ZXDH_BAR_MODULE_SMMU";
     156                 :          0 :         case ZXDH_BAR_MODULE_MAC:        return "ZXDH_BAR_MODULE_MAC";
     157                 :          0 :         case ZXDH_BAR_MODULE_VDPA:       return "ZXDH_BAR_MODULE_VDPA";
     158                 :          0 :         case ZXDH_BAR_MODULE_VQM:        return "ZXDH_BAR_MODULE_VQM";
     159                 :          0 :         case ZXDH_BAR_MODULE_NP:         return "ZXDH_BAR_MODULE_NP";
     160                 :          0 :         case ZXDH_BAR_MODULE_VPORT:      return "ZXDH_BAR_MODULE_VPORT";
     161                 :          0 :         case ZXDH_BAR_MODULE_BDF:        return "ZXDH_BAR_MODULE_BDF";
     162                 :          0 :         case ZXDH_BAR_MODULE_RISC_READY: return "ZXDH_BAR_MODULE_RISC_READY";
     163                 :          0 :         case ZXDH_BAR_MODULE_REVERSE:    return "ZXDH_BAR_MODULE_REVERSE";
     164                 :          0 :         case ZXDH_BAR_MDOULE_NVME:       return "ZXDH_BAR_MDOULE_NVME";
     165                 :          0 :         case ZXDH_BAR_MDOULE_NPSDK:      return "ZXDH_BAR_MDOULE_NPSDK";
     166                 :          0 :         case ZXDH_BAR_MODULE_NP_TODO:    return "ZXDH_BAR_MODULE_NP_TODO";
     167                 :          0 :         case ZXDH_MODULE_BAR_MSG_TO_PF:  return "ZXDH_MODULE_BAR_MSG_TO_PF";
     168                 :          0 :         case ZXDH_MODULE_BAR_MSG_TO_VF:  return "ZXDH_MODULE_BAR_MSG_TO_VF";
     169                 :          0 :         case ZXDH_MODULE_FLASH:          return "ZXDH_MODULE_FLASH";
     170                 :          0 :         case ZXDH_BAR_MODULE_OFFSET_GET: return "ZXDH_BAR_MODULE_OFFSET_GET";
     171                 :          0 :         case ZXDH_BAR_EVENT_OVS_WITH_VCB: return "ZXDH_BAR_EVENT_OVS_WITH_VCB";
     172                 :          0 :         default: return "NA";
     173                 :            :         }
     174                 :            : }
     175                 :            : 
     176                 :            : static uint16_t
     177                 :            : zxdh_pcie_id_to_hard_lock(uint16_t src_pcieid, uint8_t dst)
     178                 :            : {
     179                 :            :         uint16_t lock_id = 0;
     180                 :          0 :         uint16_t pf_idx = (src_pcieid & ZXDH_PCIEID_PF_IDX_MASK) >> ZXDH_PCIEID_PF_IDX_OFFSET;
     181                 :          0 :         uint16_t ep_idx = (src_pcieid & ZXDH_PCIEID_EP_IDX_MASK) >> ZXDH_PCIEID_EP_IDX_OFFSET;
     182                 :            : 
     183                 :          0 :         switch (dst) {
     184                 :            :         /* msg to risc */
     185                 :          0 :         case ZXDH_MSG_CHAN_END_RISC:
     186                 :          0 :                 lock_id = ZXDH_MULTIPLY_BY_8(ep_idx) + pf_idx;
     187                 :          0 :                 break;
     188                 :            :         /* msg to pf/vf */
     189                 :          0 :         case ZXDH_MSG_CHAN_END_VF:
     190                 :            :         case ZXDH_MSG_CHAN_END_PF:
     191                 :          0 :                 lock_id = ZXDH_MULTIPLY_BY_8(ep_idx) + pf_idx +
     192                 :            :                                 ZXDH_MULTIPLY_BY_8(1 + ZXDH_MAX_EP_NUM);
     193                 :          0 :                 break;
     194                 :            :         default:
     195                 :            :                 lock_id = 0;
     196                 :            :                 break;
     197                 :            :         }
     198                 :            :         if (lock_id >= ZXDH_MAX_HARD_SPINLOCK_NUM)
     199                 :            :                 lock_id = 0;
     200                 :            : 
     201                 :            :         return lock_id;
     202                 :            : }
     203                 :            : 
     204                 :            : static void
     205                 :            : label_write(uint64_t label_lock_addr, uint32_t lock_id, uint16_t value)
     206                 :            : {
     207                 :          0 :         *(volatile uint16_t *)(label_lock_addr + lock_id * 2) = value;
     208                 :          0 : }
     209                 :            : 
     210                 :            : static void
     211                 :            : spinlock_write(uint64_t virt_lock_addr, uint32_t lock_id, uint8_t data)
     212                 :            : {
     213                 :          0 :         *(volatile uint8_t *)((uint64_t)virt_lock_addr + (uint64_t)lock_id) = data;
     214                 :            : }
     215                 :            : 
     216                 :            : static uint8_t
     217                 :            : spinlock_read(uint64_t virt_lock_addr, uint32_t lock_id)
     218                 :            : {
     219                 :          0 :         return *(volatile uint8_t *)((uint64_t)virt_lock_addr + (uint64_t)lock_id);
     220                 :            : }
     221                 :            : 
     222                 :            : static int32_t
     223                 :          0 : zxdh_spinlock_lock(uint32_t virt_lock_id, uint64_t virt_addr,
     224                 :            :                 uint64_t label_addr, uint16_t primary_id)
     225                 :            : {
     226                 :            :         uint32_t lock_rd_cnt = 0;
     227                 :            : 
     228                 :            :         do {
     229                 :            :                 /* read to lock */
     230                 :            :                 uint8_t spl_val = spinlock_read(virt_addr, virt_lock_id);
     231                 :            : 
     232         [ #  # ]:          0 :                 if (spl_val == 0) {
     233                 :            :                         label_write((uint64_t)label_addr, virt_lock_id, primary_id);
     234                 :            :                         break;
     235                 :            :                 }
     236                 :          0 :                 rte_delay_us_block(ZXDH_SPINLOCK_POLLING_SPAN_US);
     237                 :          0 :                 lock_rd_cnt++;
     238         [ #  # ]:          0 :         } while (lock_rd_cnt < ZXDH_MAX_HARD_SPINLOCK_ASK_TIMES);
     239         [ #  # ]:          0 :         if (lock_rd_cnt >= ZXDH_MAX_HARD_SPINLOCK_ASK_TIMES)
     240                 :          0 :                 return -1;
     241                 :            : 
     242                 :            :         return 0;
     243                 :            : }
     244                 :            : 
     245                 :            : static int32_t
     246                 :            : zxdh_spinlock_unlock(uint32_t virt_lock_id, uint64_t virt_addr, uint64_t label_addr)
     247                 :            : {
     248                 :            :         label_write((uint64_t)label_addr, virt_lock_id, 0);
     249                 :            :         spinlock_write(virt_addr, virt_lock_id, 0);
     250                 :          0 :         return 0;
     251                 :            : }
     252                 :            : 
     253                 :            : /**
     254                 :            :  * Fun: PF init hard_spinlock addr
     255                 :            :  */
     256                 :            : static int
     257                 :          0 : bar_chan_pf_init_spinlock(uint16_t pcie_id, uint64_t bar_base_addr)
     258                 :            : {
     259                 :          0 :         int lock_id = zxdh_pcie_id_to_hard_lock(pcie_id, ZXDH_MSG_CHAN_END_RISC);
     260                 :            : 
     261                 :          0 :         zxdh_spinlock_unlock(lock_id, bar_base_addr + ZXDH_BAR0_SPINLOCK_OFFSET,
     262                 :            :                         bar_base_addr + ZXDH_HW_LABEL_OFFSET);
     263                 :            :         lock_id = zxdh_pcie_id_to_hard_lock(pcie_id, ZXDH_MSG_CHAN_END_VF);
     264                 :          0 :         zxdh_spinlock_unlock(lock_id, bar_base_addr + ZXDH_BAR0_SPINLOCK_OFFSET,
     265                 :            :                         bar_base_addr + ZXDH_HW_LABEL_OFFSET);
     266                 :          0 :         return 0;
     267                 :            : }
     268                 :            : 
     269                 :            : int
     270                 :          0 : zxdh_msg_chan_hwlock_init(struct rte_eth_dev *dev)
     271                 :            : {
     272                 :          0 :         struct zxdh_hw *hw = dev->data->dev_private;
     273                 :            : 
     274         [ #  # ]:          0 :         if (!hw->is_pf)
     275                 :            :                 return 0;
     276                 :          0 :         return bar_chan_pf_init_spinlock(hw->pcie_id, (uint64_t)(hw->bar_addr[ZXDH_BAR0_INDEX]));
     277                 :            : }
     278                 :            : 
     279                 :            : int
     280                 :          0 : zxdh_msg_chan_init(void)
     281                 :            : {
     282                 :            :         uint16_t seq_id = 0;
     283                 :            : 
     284                 :          0 :         g_dev_stat.dev_cnt++;
     285         [ #  # ]:          0 :         if (g_dev_stat.is_res_init)
     286                 :            :                 return ZXDH_BAR_MSG_OK;
     287                 :            : 
     288                 :            :         rte_spinlock_init(&chan_lock);
     289                 :          0 :         g_seqid_ring.cur_id = 0;
     290                 :            :         rte_spinlock_init(&g_seqid_ring.lock);
     291                 :            : 
     292         [ #  # ]:          0 :         for (seq_id = 0; seq_id < ZXDH_BAR_SEQID_NUM_MAX; seq_id++) {
     293                 :          0 :                 struct zxdh_seqid_item *reps_info = &g_seqid_ring.reps_info_tbl[seq_id];
     294                 :            : 
     295                 :          0 :                 reps_info->id = seq_id;
     296                 :          0 :                 reps_info->flag = ZXDH_REPS_INFO_FLAG_USABLE;
     297                 :            :         }
     298                 :          0 :         g_dev_stat.is_res_init = true;
     299                 :          0 :         return ZXDH_BAR_MSG_OK;
     300                 :            : }
     301                 :            : 
     302                 :            : int
     303                 :          0 : zxdh_bar_msg_chan_exit(void)
     304                 :            : {
     305   [ #  #  #  # ]:          0 :         if (!g_dev_stat.is_res_init || (--g_dev_stat.dev_cnt > 0))
     306                 :          0 :                 return ZXDH_BAR_MSG_OK;
     307                 :            : 
     308                 :          0 :         g_dev_stat.is_res_init = false;
     309                 :          0 :         return ZXDH_BAR_MSG_OK;
     310                 :            : }
     311                 :            : 
     312                 :            : static int
     313                 :          0 : zxdh_bar_chan_msgid_allocate(uint16_t *msgid)
     314                 :            : {
     315                 :            :         struct zxdh_seqid_item *seqid_reps_info = NULL;
     316                 :            : 
     317                 :            :         rte_spinlock_lock(&g_seqid_ring.lock);
     318                 :          0 :         uint16_t g_id = g_seqid_ring.cur_id;
     319                 :            :         uint16_t count = 0;
     320                 :            :         int rc = 0;
     321                 :            : 
     322                 :            :         do {
     323                 :          0 :                 count++;
     324                 :          0 :                 ++g_id;
     325                 :          0 :                 g_id %= ZXDH_BAR_SEQID_NUM_MAX;
     326                 :          0 :                 seqid_reps_info = &g_seqid_ring.reps_info_tbl[g_id];
     327   [ #  #  #  # ]:          0 :         } while ((seqid_reps_info->flag != ZXDH_REPS_INFO_FLAG_USABLE) &&
     328                 :            :                 (count < ZXDH_BAR_SEQID_NUM_MAX));
     329                 :            : 
     330         [ #  # ]:          0 :         if (count >= ZXDH_BAR_SEQID_NUM_MAX) {
     331                 :            :                 rc = -1;
     332                 :          0 :                 goto out;
     333                 :            :         }
     334                 :          0 :         seqid_reps_info->flag = ZXDH_REPS_INFO_FLAG_USED;
     335                 :          0 :         g_seqid_ring.cur_id = g_id;
     336                 :          0 :         *msgid = g_id;
     337                 :            :         rc = ZXDH_BAR_MSG_OK;
     338                 :            : 
     339                 :          0 : out:
     340                 :            :         rte_spinlock_unlock(&g_seqid_ring.lock);
     341                 :          0 :         return rc;
     342                 :            : }
     343                 :            : 
     344                 :            : static uint16_t
     345                 :          0 : zxdh_bar_chan_save_recv_info(struct zxdh_msg_recviver_mem *result, uint16_t *msg_id)
     346                 :            : {
     347                 :          0 :         int ret = zxdh_bar_chan_msgid_allocate(msg_id);
     348                 :            : 
     349         [ #  # ]:          0 :         if (ret != ZXDH_BAR_MSG_OK)
     350                 :            :                 return ZXDH_BAR_MSG_ERR_MSGID;
     351                 :            : 
     352                 :          0 :         PMD_MSG_LOG(DEBUG, "allocate msg_id: %u", *msg_id);
     353                 :          0 :         struct zxdh_seqid_item *reps_info = &g_seqid_ring.reps_info_tbl[*msg_id];
     354                 :            : 
     355                 :          0 :         reps_info->reps_addr = result->recv_buffer;
     356                 :          0 :         reps_info->buffer_len = result->buffer_len;
     357                 :          0 :         return ZXDH_BAR_MSG_OK;
     358                 :            : }
     359                 :            : 
     360                 :            : static uint8_t
     361                 :            : zxdh_bar_msg_src_index_trans(uint8_t src)
     362                 :            : {
     363                 :            :         uint8_t src_index = 0;
     364                 :            : 
     365                 :            :         switch (src) {
     366                 :            :         case ZXDH_MSG_CHAN_END_MPF:
     367                 :            :                 src_index = ZXDH_BAR_MSG_SRC_MPF;
     368                 :            :                 break;
     369                 :            :         case ZXDH_MSG_CHAN_END_PF:
     370                 :            :                 src_index = ZXDH_BAR_MSG_SRC_PF;
     371                 :            :                 break;
     372                 :            :         case ZXDH_MSG_CHAN_END_VF:
     373                 :            :                 src_index = ZXDH_BAR_MSG_SRC_VF;
     374                 :            :                 break;
     375                 :            :         default:
     376                 :            :                 src_index = ZXDH_BAR_MSG_SRC_ERR;
     377                 :            :                 break;
     378                 :            :         }
     379                 :            :         return src_index;
     380                 :            : }
     381                 :            : 
     382                 :            : static uint8_t
     383                 :            : zxdh_bar_msg_dst_index_trans(uint8_t dst)
     384                 :            : {
     385                 :            :         uint8_t dst_index = 0;
     386                 :            : 
     387                 :            :         switch (dst) {
     388                 :            :         case ZXDH_MSG_CHAN_END_MPF:
     389                 :            :                 dst_index = ZXDH_BAR_MSG_DST_MPF;
     390                 :            :                 break;
     391                 :            :         case ZXDH_MSG_CHAN_END_PF:
     392                 :            :                 dst_index = ZXDH_BAR_MSG_DST_PFVF;
     393                 :            :                 break;
     394                 :            :         case ZXDH_MSG_CHAN_END_VF:
     395                 :            :                 dst_index = ZXDH_BAR_MSG_DST_PFVF;
     396                 :            :                 break;
     397                 :            :         case ZXDH_MSG_CHAN_END_RISC:
     398                 :            :                 dst_index = ZXDH_BAR_MSG_DST_RISC;
     399                 :            :                 break;
     400                 :            :         default:
     401                 :            :                 dst_index = ZXDH_BAR_MSG_SRC_ERR;
     402                 :            :                 break;
     403                 :            :         }
     404                 :            :         return dst_index;
     405                 :            : }
     406                 :            : 
     407                 :            : static int
     408                 :          0 : zxdh_bar_chan_send_para_check(struct zxdh_pci_bar_msg *in,
     409                 :            :                 struct zxdh_msg_recviver_mem *result)
     410                 :            : {
     411                 :            :         uint8_t src_index = 0;
     412                 :            :         uint8_t dst_index = 0;
     413                 :            : 
     414         [ #  # ]:          0 :         if (in == NULL || result == NULL) {
     415                 :          0 :                 PMD_MSG_LOG(ERR, "send para ERR: null para");
     416                 :          0 :                 return ZXDH_BAR_MSG_ERR_NULL_PARA;
     417                 :            :         }
     418         [ #  # ]:          0 :         src_index = zxdh_bar_msg_src_index_trans(in->src);
     419         [ #  # ]:          0 :         dst_index = zxdh_bar_msg_dst_index_trans(in->dst);
     420                 :            : 
     421         [ #  # ]:          0 :         if (src_index == ZXDH_BAR_MSG_SRC_ERR || dst_index == ZXDH_BAR_MSG_DST_ERR) {
     422                 :          0 :                 PMD_MSG_LOG(ERR, "send para ERR: chan doesn't exist");
     423                 :          0 :                 return ZXDH_BAR_MSG_ERR_TYPE;
     424                 :            :         }
     425         [ #  # ]:          0 :         if (in->module_id >= ZXDH_BAR_MSG_MODULE_NUM) {
     426                 :          0 :                 PMD_MSG_LOG(ERR, "send para ERR: invalid module_id: %d", in->module_id);
     427                 :          0 :                 return ZXDH_BAR_MSG_ERR_MODULE;
     428                 :            :         }
     429         [ #  # ]:          0 :         if (in->payload_addr == NULL) {
     430                 :          0 :                 PMD_MSG_LOG(ERR, "send para ERR: null message");
     431                 :          0 :                 return ZXDH_BAR_MSG_ERR_BODY_NULL;
     432                 :            :         }
     433         [ #  # ]:          0 :         if (in->payload_len > ZXDH_BAR_MSG_PAYLOAD_MAX_LEN) {
     434                 :          0 :                 PMD_MSG_LOG(ERR, "send para ERR: len %d is too long", in->payload_len);
     435                 :          0 :                 return ZXDH_BAR_MSG_ERR_LEN;
     436                 :            :         }
     437   [ #  #  #  # ]:          0 :         if (in->virt_addr == 0 || result->recv_buffer == NULL) {
     438                 :          0 :                 PMD_MSG_LOG(ERR, "send para ERR: virt_addr or recv_buffer is NULL");
     439                 :          0 :                 return ZXDH_BAR_MSG_ERR_VIRTADDR_NULL;
     440                 :            :         }
     441         [ #  # ]:          0 :         if (result->buffer_len < ZXDH_REPS_HEADER_PAYLOAD_OFFSET)
     442                 :          0 :                 PMD_MSG_LOG(ERR, "recv buffer len is short than minimal 4 bytes");
     443                 :            : 
     444                 :            :         return ZXDH_BAR_MSG_OK;
     445                 :            : }
     446                 :            : 
     447                 :            : static uint64_t
     448                 :            : zxdh_subchan_addr_cal(uint64_t virt_addr, uint8_t chan_id, uint8_t subchan_id)
     449                 :            : {
     450                 :          0 :         return virt_addr + (2 * chan_id + subchan_id) * ZXDH_BAR_MSG_ADDR_CHAN_INTERVAL;
     451                 :            : }
     452                 :            : 
     453                 :            : static uint16_t
     454                 :          0 : zxdh_bar_chan_subchan_addr_get(struct zxdh_pci_bar_msg *in, uint64_t *subchan_addr)
     455                 :            : {
     456         [ #  # ]:          0 :         uint8_t src_index = zxdh_bar_msg_src_index_trans(in->src);
     457         [ #  # ]:          0 :         uint8_t dst_index = zxdh_bar_msg_dst_index_trans(in->dst);
     458                 :          0 :         uint16_t chan_id = chan_id_tbl[src_index][dst_index];
     459                 :          0 :         uint16_t subchan_id = subchan_id_tbl[src_index][dst_index];
     460                 :            : 
     461                 :          0 :         *subchan_addr = zxdh_subchan_addr_cal(in->virt_addr, chan_id, subchan_id);
     462                 :          0 :         return ZXDH_BAR_MSG_OK;
     463                 :            : }
     464                 :            : 
     465                 :            : static int
     466                 :          0 : zxdh_bar_hard_lock(uint16_t src_pcieid, uint8_t dst, uint64_t virt_addr)
     467                 :            : {
     468                 :            :         int ret = 0;
     469      [ #  #  # ]:          0 :         uint16_t lockid = zxdh_pcie_id_to_hard_lock(src_pcieid, dst);
     470                 :            : 
     471                 :          0 :         PMD_MSG_LOG(DEBUG, "dev pcieid: 0x%x lock, get hardlockid: %u", src_pcieid, lockid);
     472         [ #  # ]:          0 :         if (dst == ZXDH_MSG_CHAN_END_RISC)
     473                 :          0 :                 ret = zxdh_spinlock_lock(lockid, virt_addr + ZXDH_CHAN_RISC_SPINLOCK_OFFSET,
     474                 :            :                                         virt_addr + ZXDH_CHAN_RISC_LABEL_OFFSET,
     475                 :            :                                         src_pcieid | ZXDH_LOCK_PRIMARY_ID_MASK);
     476                 :            :         else
     477                 :          0 :                 ret = zxdh_spinlock_lock(lockid, virt_addr + ZXDH_CHAN_PFVF_SPINLOCK_OFFSET,
     478                 :            :                                         virt_addr + ZXDH_CHAN_PFVF_LABEL_OFFSET,
     479                 :            :                                         src_pcieid | ZXDH_LOCK_PRIMARY_ID_MASK);
     480                 :            : 
     481                 :          0 :         return ret;
     482                 :            : }
     483                 :            : 
     484                 :            : static void
     485                 :          0 : zxdh_bar_hard_unlock(uint16_t src_pcieid, uint8_t dst, uint64_t virt_addr)
     486                 :            : {
     487      [ #  #  # ]:          0 :         uint16_t lockid = zxdh_pcie_id_to_hard_lock(src_pcieid, dst);
     488                 :            : 
     489                 :          0 :         PMD_MSG_LOG(DEBUG, "dev pcieid: 0x%x unlock, get hardlockid: %u", src_pcieid, lockid);
     490         [ #  # ]:          0 :         if (dst == ZXDH_MSG_CHAN_END_RISC)
     491                 :          0 :                 zxdh_spinlock_unlock(lockid, virt_addr + ZXDH_CHAN_RISC_SPINLOCK_OFFSET,
     492                 :            :                                 virt_addr + ZXDH_CHAN_RISC_LABEL_OFFSET);
     493                 :            :         else
     494                 :          0 :                 zxdh_spinlock_unlock(lockid, virt_addr + ZXDH_CHAN_PFVF_SPINLOCK_OFFSET,
     495                 :            :                                 virt_addr + ZXDH_CHAN_PFVF_LABEL_OFFSET);
     496                 :          0 : }
     497                 :            : 
     498                 :            : static int
     499         [ #  # ]:          0 : zxdh_bar_chan_lock(uint8_t src, uint8_t dst, uint16_t src_pcieid, uint64_t virt_addr)
     500                 :            : {
     501                 :            :         int ret = 0;
     502                 :            :         uint8_t src_index = zxdh_bar_msg_src_index_trans(src);
     503         [ #  # ]:          0 :         uint8_t dst_index = zxdh_bar_msg_dst_index_trans(dst);
     504                 :            : 
     505         [ #  # ]:          0 :         if (src_index == ZXDH_BAR_MSG_SRC_ERR || dst_index == ZXDH_BAR_MSG_DST_ERR) {
     506                 :          0 :                 PMD_MSG_LOG(ERR, "lock ERR: chan doesn't exist");
     507                 :          0 :                 return ZXDH_BAR_MSG_ERR_TYPE;
     508                 :            :         }
     509                 :            : 
     510                 :          0 :         ret = zxdh_bar_hard_lock(src_pcieid, dst, virt_addr);
     511         [ #  # ]:          0 :         if (ret != 0)
     512                 :          0 :                 PMD_MSG_LOG(ERR, "dev: 0x%x failed to lock", src_pcieid);
     513                 :            : 
     514                 :            :         return ret;
     515                 :            : }
     516                 :            : 
     517                 :            : static int
     518         [ #  # ]:          0 : zxdh_bar_chan_unlock(uint8_t src, uint8_t dst, uint16_t src_pcieid, uint64_t virt_addr)
     519                 :            : {
     520                 :            :         uint8_t src_index = zxdh_bar_msg_src_index_trans(src);
     521         [ #  # ]:          0 :         uint8_t dst_index = zxdh_bar_msg_dst_index_trans(dst);
     522                 :            : 
     523         [ #  # ]:          0 :         if (src_index == ZXDH_BAR_MSG_SRC_ERR || dst_index == ZXDH_BAR_MSG_DST_ERR) {
     524                 :          0 :                 PMD_MSG_LOG(ERR, "unlock ERR: chan doesn't exist");
     525                 :          0 :                 return ZXDH_BAR_MSG_ERR_TYPE;
     526                 :            :         }
     527                 :            : 
     528                 :          0 :         zxdh_bar_hard_unlock(src_pcieid, dst, virt_addr);
     529                 :            : 
     530                 :          0 :         return ZXDH_BAR_MSG_OK;
     531                 :            : }
     532                 :            : 
     533                 :            : static void
     534                 :          0 : zxdh_bar_chan_msgid_free(uint16_t msg_id)
     535                 :            : {
     536                 :          0 :         struct zxdh_seqid_item *seqid_reps_info = &g_seqid_ring.reps_info_tbl[msg_id];
     537                 :            : 
     538                 :            :         rte_spinlock_lock(&g_seqid_ring.lock);
     539                 :          0 :         seqid_reps_info->flag = ZXDH_REPS_INFO_FLAG_USABLE;
     540                 :          0 :         PMD_MSG_LOG(DEBUG, "free msg_id: %u", msg_id);
     541                 :            :         rte_spinlock_unlock(&g_seqid_ring.lock);
     542                 :          0 : }
     543                 :            : 
     544                 :            : static int
     545                 :          0 : zxdh_bar_chan_reg_write(uint64_t subchan_addr, uint32_t offset, uint32_t data)
     546                 :            : {
     547                 :          0 :         uint32_t algin_offset = (offset & ZXDH_BAR_ALIGN_WORD_MASK);
     548                 :            : 
     549         [ #  # ]:          0 :         if (unlikely(algin_offset >= ZXDH_BAR_MSG_ADDR_CHAN_INTERVAL)) {
     550                 :          0 :                 PMD_MSG_LOG(ERR, "algin_offset exceeds channel size!");
     551                 :          0 :                 return -1;
     552                 :            :         }
     553                 :          0 :         *(uint32_t *)(subchan_addr + algin_offset) = data;
     554                 :          0 :         return 0;
     555                 :            : }
     556                 :            : 
     557                 :            : static int
     558                 :          0 : zxdh_bar_chan_reg_read(uint64_t subchan_addr, uint32_t offset, uint32_t *pdata)
     559                 :            : {
     560                 :          0 :         uint32_t algin_offset = (offset & ZXDH_BAR_ALIGN_WORD_MASK);
     561                 :            : 
     562         [ #  # ]:          0 :         if (unlikely(algin_offset >= ZXDH_BAR_MSG_ADDR_CHAN_INTERVAL)) {
     563                 :          0 :                 PMD_MSG_LOG(ERR, "algin_offset exceeds channel size!");
     564                 :          0 :                 return -1;
     565                 :            :         }
     566                 :          0 :         *pdata = *(uint32_t *)(subchan_addr + algin_offset);
     567                 :          0 :         return 0;
     568                 :            : }
     569                 :            : 
     570                 :            : static uint16_t
     571                 :          0 : zxdh_bar_chan_msg_header_set(uint64_t subchan_addr,
     572                 :            :                 struct zxdh_bar_msg_header *msg_header)
     573                 :            : {
     574                 :            :         uint32_t *data = (uint32_t *)msg_header;
     575                 :            :         uint16_t i;
     576                 :            : 
     577   [ #  #  #  # ]:          0 :         for (i = 0; i < (ZXDH_BAR_MSG_PLAYLOAD_OFFSET >> 2); i++)
     578                 :          0 :                 zxdh_bar_chan_reg_write(subchan_addr, i * 4, *(data + i));
     579                 :            : 
     580                 :          0 :         return ZXDH_BAR_MSG_OK;
     581                 :            : }
     582                 :            : 
     583                 :            : static uint16_t
     584                 :            : zxdh_bar_chan_msg_header_get(uint64_t subchan_addr,
     585                 :            :                 struct zxdh_bar_msg_header *msg_header)
     586                 :            : {
     587                 :            :         uint32_t *data = (uint32_t *)msg_header;
     588                 :            :         uint16_t i;
     589                 :            : 
     590   [ #  #  #  #  :          0 :         for (i = 0; i < (ZXDH_BAR_MSG_PLAYLOAD_OFFSET >> 2); i++)
                   #  # ]
     591                 :          0 :                 zxdh_bar_chan_reg_read(subchan_addr, i * 4, data + i);
     592                 :            : 
     593                 :            :         return ZXDH_BAR_MSG_OK;
     594                 :            : }
     595                 :            : 
     596                 :            : static uint16_t
     597                 :          0 : zxdh_bar_chan_msg_payload_set(uint64_t subchan_addr, uint8_t *msg, uint16_t len)
     598                 :            : {
     599                 :            :         uint32_t *data = (uint32_t *)msg;
     600                 :          0 :         uint32_t count = (len >> 2);
     601                 :          0 :         uint32_t remain = (len & 0x3);
     602                 :            :         uint32_t remain_data = 0;
     603                 :            :         uint32_t i;
     604                 :            : 
     605         [ #  # ]:          0 :         for (i = 0; i < count; i++)
     606                 :          0 :                 zxdh_bar_chan_reg_write(subchan_addr, 4 * i +
     607                 :          0 :                                 ZXDH_BAR_MSG_PLAYLOAD_OFFSET, *(data + i));
     608         [ #  # ]:          0 :         if (remain) {
     609         [ #  # ]:          0 :                 for (i = 0; i < remain; i++)
     610                 :          0 :                         remain_data |= *((uint8_t *)(msg + len - remain + i)) << (8 * i);
     611                 :            : 
     612                 :          0 :                 zxdh_bar_chan_reg_write(subchan_addr, 4 * count +
     613                 :            :                                 ZXDH_BAR_MSG_PLAYLOAD_OFFSET, remain_data);
     614                 :            :         }
     615                 :          0 :         return ZXDH_BAR_MSG_OK;
     616                 :            : }
     617                 :            : 
     618                 :            : static uint16_t
     619                 :          0 : zxdh_bar_chan_msg_payload_get(uint64_t subchan_addr, uint8_t *msg, uint16_t len)
     620                 :            : {
     621                 :            :         uint32_t *data = (uint32_t *)msg;
     622                 :          0 :         uint32_t count = (len >> 2);
     623                 :          0 :         uint32_t remain_data = 0;
     624                 :          0 :         uint32_t remain = (len & 0x3);
     625                 :            :         uint32_t i;
     626                 :            : 
     627         [ #  # ]:          0 :         for (i = 0; i < count; i++)
     628                 :          0 :                 zxdh_bar_chan_reg_read(subchan_addr, 4 * i +
     629                 :          0 :                         ZXDH_BAR_MSG_PLAYLOAD_OFFSET, (data + i));
     630         [ #  # ]:          0 :         if (remain) {
     631                 :          0 :                 zxdh_bar_chan_reg_read(subchan_addr, 4 * count +
     632                 :            :                                 ZXDH_BAR_MSG_PLAYLOAD_OFFSET, &remain_data);
     633         [ #  # ]:          0 :                 for (i = 0; i < remain; i++)
     634                 :          0 :                         *((uint8_t *)(msg + (len - remain + i))) = remain_data >> (8 * i);
     635                 :            :         }
     636                 :          0 :         return ZXDH_BAR_MSG_OK;
     637                 :            : }
     638                 :            : 
     639                 :            : static uint16_t
     640                 :            : zxdh_bar_chan_msg_valid_set(uint64_t subchan_addr, uint8_t valid_label)
     641                 :            : {
     642                 :            :         uint32_t data;
     643                 :            : 
     644                 :            :         zxdh_bar_chan_reg_read(subchan_addr, ZXDH_BAR_MSG_VALID_OFFSET, &data);
     645                 :          0 :         data &= (~ZXDH_BAR_MSG_VALID_MASK);
     646                 :          0 :         data |= (uint32_t)valid_label;
     647                 :            :         zxdh_bar_chan_reg_write(subchan_addr, ZXDH_BAR_MSG_VALID_OFFSET, data);
     648                 :            :         return ZXDH_BAR_MSG_OK;
     649                 :            : }
     650                 :            : 
     651                 :            : static uint16_t
     652                 :          0 : zxdh_bar_chan_msg_send(uint64_t subchan_addr, void *payload_addr,
     653                 :            :                 uint16_t payload_len, struct zxdh_bar_msg_header *msg_header)
     654                 :            : {
     655                 :            :         uint16_t ret = 0;
     656                 :            :         ret = zxdh_bar_chan_msg_header_set(subchan_addr, msg_header);
     657                 :            : 
     658                 :            :         ret = zxdh_bar_chan_msg_header_get(subchan_addr,
     659                 :            :                                 (struct zxdh_bar_msg_header *)tmp_msg_header);
     660                 :            : 
     661                 :          0 :         ret = zxdh_bar_chan_msg_payload_set(subchan_addr,
     662                 :            :                                 (uint8_t *)(payload_addr), payload_len);
     663                 :            : 
     664                 :          0 :         ret = zxdh_bar_chan_msg_payload_get(subchan_addr,
     665                 :            :                                 tmp_msg_header, payload_len);
     666                 :            : 
     667                 :            :         ret = zxdh_bar_chan_msg_valid_set(subchan_addr, ZXDH_BAR_MSG_CHAN_USED);
     668                 :          0 :         return ret;
     669                 :            : }
     670                 :            : 
     671                 :            : static uint16_t
     672                 :            : zxdh_bar_msg_valid_stat_get(uint64_t subchan_addr)
     673                 :            : {
     674                 :            :         uint32_t data;
     675                 :            : 
     676                 :            :         zxdh_bar_chan_reg_read(subchan_addr, ZXDH_BAR_MSG_VALID_OFFSET, &data);
     677         [ #  # ]:          0 :         if (ZXDH_BAR_MSG_CHAN_USABLE == (data & ZXDH_BAR_MSG_VALID_MASK))
     678                 :          0 :                 return ZXDH_BAR_MSG_CHAN_USABLE;
     679                 :            : 
     680                 :            :         return ZXDH_BAR_MSG_CHAN_USED;
     681                 :            : }
     682                 :            : 
     683                 :            : static uint16_t
     684                 :            : zxdh_bar_chan_msg_poltag_set(uint64_t subchan_addr, uint8_t label)
     685                 :            : {
     686                 :            :         uint32_t data;
     687                 :            : 
     688                 :            :         zxdh_bar_chan_reg_read(subchan_addr, ZXDH_BAR_MSG_VALID_OFFSET, &data);
     689                 :          0 :         data &= (~(uint32_t)ZXDH_BAR_MSG_POL_MASK);
     690                 :            :         data |= ((uint32_t)label << ZXDH_BAR_MSG_POL_OFFSET);
     691                 :            :         zxdh_bar_chan_reg_write(subchan_addr, ZXDH_BAR_MSG_VALID_OFFSET, data);
     692                 :            :         return ZXDH_BAR_MSG_OK;
     693                 :            : }
     694                 :            : 
     695                 :            : static uint16_t
     696                 :          0 : zxdh_bar_chan_sync_msg_reps_get(uint64_t subchan_addr,
     697                 :            :                 uint64_t recv_buffer, uint16_t buffer_len)
     698                 :            : {
     699                 :            :         struct zxdh_bar_msg_header msg_header;
     700                 :            :         uint16_t msg_id = 0;
     701                 :            :         uint16_t msg_len = 0;
     702                 :            : 
     703                 :            :         zxdh_bar_chan_msg_header_get(subchan_addr, &msg_header);
     704                 :          0 :         msg_id = msg_header.msg_id;
     705                 :          0 :         struct zxdh_seqid_item *reps_info = &g_seqid_ring.reps_info_tbl[msg_id];
     706                 :            : 
     707         [ #  # ]:          0 :         if (reps_info->flag != ZXDH_REPS_INFO_FLAG_USED) {
     708                 :          0 :                 PMD_MSG_LOG(ERR, "msg_id %u unused", msg_id);
     709                 :          0 :                 return ZXDH_BAR_MSG_ERR_REPLY;
     710                 :            :         }
     711                 :          0 :         msg_len = msg_header.len;
     712                 :            : 
     713         [ #  # ]:          0 :         if (msg_len > buffer_len - 4) {
     714                 :          0 :                 PMD_MSG_LOG(ERR, "recv buffer len is: %u, but reply msg len is: %u",
     715                 :            :                                 buffer_len, msg_len + 4);
     716                 :          0 :                 return ZXDH_BAR_MSG_ERR_REPSBUFF_LEN;
     717                 :            :         }
     718                 :          0 :         uint8_t *recv_msg = (uint8_t *)recv_buffer;
     719                 :            : 
     720                 :          0 :         zxdh_bar_chan_msg_payload_get(subchan_addr,
     721                 :            :                         recv_msg + ZXDH_REPS_HEADER_PAYLOAD_OFFSET, msg_len);
     722                 :          0 :         *(uint16_t *)(recv_msg + ZXDH_REPS_HEADER_LEN_OFFSET) = msg_len;
     723                 :          0 :         *recv_msg = ZXDH_REPS_HEADER_REPLYED; /* set reps's valid */
     724                 :          0 :         return ZXDH_BAR_MSG_OK;
     725                 :            : }
     726                 :            : 
     727                 :            : int
     728                 :          0 : zxdh_bar_chan_sync_msg_send(struct zxdh_pci_bar_msg *in, struct zxdh_msg_recviver_mem *result)
     729                 :            : {
     730                 :          0 :         struct zxdh_bar_msg_header msg_header = {0};
     731                 :          0 :         uint16_t seq_id = 0;
     732                 :          0 :         uint64_t subchan_addr = 0;
     733                 :            :         uint32_t time_out_cnt = 0;
     734                 :            :         uint16_t valid = 0;
     735                 :            :         int ret = 0;
     736                 :            : 
     737                 :          0 :         ret = zxdh_bar_chan_send_para_check(in, result);
     738         [ #  # ]:          0 :         if (ret != ZXDH_BAR_MSG_OK)
     739                 :          0 :                 goto exit;
     740                 :            : 
     741                 :          0 :         ret = zxdh_bar_chan_save_recv_info(result, &seq_id);
     742         [ #  # ]:          0 :         if (ret != ZXDH_BAR_MSG_OK)
     743                 :          0 :                 goto exit;
     744                 :            : 
     745                 :          0 :         zxdh_bar_chan_subchan_addr_get(in, &subchan_addr);
     746                 :            : 
     747                 :            :         msg_header.sync = ZXDH_BAR_CHAN_MSG_SYNC;
     748                 :          0 :         msg_header.emec = in->emec;
     749                 :            :         msg_header.usr  = 0;
     750                 :            :         msg_header.rsv  = 0;
     751                 :          0 :         msg_header.module_id  = in->module_id;
     752                 :          0 :         msg_header.len        = in->payload_len;
     753                 :          0 :         msg_header.msg_id     = seq_id;
     754                 :          0 :         msg_header.src_pcieid = in->src_pcieid;
     755                 :          0 :         msg_header.dst_pcieid = in->dst_pcieid;
     756                 :            : 
     757                 :          0 :         ret = zxdh_bar_chan_lock(in->src, in->dst, in->src_pcieid, in->virt_addr);
     758         [ #  # ]:          0 :         if (ret != ZXDH_BAR_MSG_OK) {
     759                 :          0 :                 zxdh_bar_chan_msgid_free(seq_id);
     760                 :          0 :                 goto exit;
     761                 :            :         }
     762                 :          0 :         zxdh_bar_chan_msg_send(subchan_addr, in->payload_addr, in->payload_len, &msg_header);
     763                 :            : 
     764                 :            :         do {
     765                 :          0 :                 rte_delay_us_block(ZXDH_BAR_MSG_POLLING_SPAN);
     766                 :            :                 valid = zxdh_bar_msg_valid_stat_get(subchan_addr);
     767                 :          0 :                 ++time_out_cnt;
     768         [ #  # ]:          0 :         } while ((time_out_cnt < ZXDH_BAR_MSG_TIMEOUT_TH) && (valid == ZXDH_BAR_MSG_CHAN_USED));
     769                 :            : 
     770         [ #  # ]:          0 :         if (time_out_cnt == ZXDH_BAR_MSG_TIMEOUT_TH && valid != ZXDH_BAR_MSG_CHAN_USABLE) {
     771                 :            :                 zxdh_bar_chan_msg_valid_set(subchan_addr, ZXDH_BAR_MSG_CHAN_USABLE);
     772                 :            :                 zxdh_bar_chan_msg_poltag_set(subchan_addr, 0);
     773                 :          0 :                 PMD_MSG_LOG(ERR, "BAR MSG ERR: chan type time out");
     774                 :            :                 ret = ZXDH_BAR_MSG_ERR_TIME_OUT;
     775                 :            :         } else {
     776                 :          0 :                 ret = zxdh_bar_chan_sync_msg_reps_get(subchan_addr,
     777                 :          0 :                                         (uint64_t)result->recv_buffer, result->buffer_len);
     778                 :            :         }
     779                 :          0 :         zxdh_bar_chan_msgid_free(seq_id);
     780                 :          0 :         zxdh_bar_chan_unlock(in->src, in->dst, in->src_pcieid, in->virt_addr);
     781                 :            : 
     782                 :          0 : exit:
     783                 :          0 :         return ret;
     784                 :            : }
     785                 :            : 
     786                 :            : static int
     787                 :            : zxdh_bar_get_sum(uint8_t *ptr, uint8_t len)
     788                 :            : {
     789                 :            :         uint64_t sum = 0;
     790                 :            :         int idx;
     791                 :            : 
     792   [ #  #  #  # ]:          0 :         for (idx = 0; idx < len; idx++)
     793                 :          0 :                 sum += *(ptr + idx);
     794                 :            : 
     795                 :          0 :         return (uint16_t)sum;
     796                 :            : }
     797                 :            : 
     798                 :            : static int
     799                 :          0 : zxdh_bar_chan_enable(struct zxdh_msix_para *para, uint16_t *vport)
     800                 :            : {
     801                 :          0 :         struct zxdh_bar_recv_msg recv_msg = {0};
     802                 :            :         int ret = 0;
     803                 :            :         int check_token = 0;
     804                 :            :         int sum_res = 0;
     805                 :            : 
     806         [ #  # ]:          0 :         if (!para)
     807                 :            :                 return ZXDH_BAR_MSG_ERR_NULL;
     808                 :            : 
     809                 :          0 :         struct zxdh_msix_msg msix_msg = {
     810                 :          0 :                 .pcie_id = para->pcie_id,
     811                 :          0 :                 .vector_risc = para->vector_risc,
     812                 :          0 :                 .vector_pfvf = para->vector_pfvf,
     813                 :          0 :                 .vector_mpf = para->vector_mpf,
     814                 :            :         };
     815                 :          0 :         struct zxdh_pci_bar_msg in = {
     816                 :          0 :                 .virt_addr = para->virt_addr,
     817                 :            :                 .payload_addr = &msix_msg,
     818                 :            :                 .payload_len = sizeof(msix_msg),
     819                 :            :                 .emec = 0,
     820                 :          0 :                 .src = para->driver_type,
     821                 :            :                 .dst = ZXDH_MSG_CHAN_END_RISC,
     822                 :            :                 .module_id = ZXDH_BAR_MODULE_MISX,
     823                 :            :                 .src_pcieid = para->pcie_id,
     824                 :            :                 .dst_pcieid = 0,
     825                 :            :                 .usr = 0,
     826                 :            :         };
     827                 :            : 
     828                 :          0 :         struct zxdh_msg_recviver_mem result = {
     829                 :            :                 .recv_buffer = &recv_msg,
     830                 :            :                 .buffer_len = sizeof(recv_msg),
     831                 :            :         };
     832                 :            : 
     833                 :          0 :         ret = zxdh_bar_chan_sync_msg_send(&in, &result);
     834         [ #  # ]:          0 :         if (ret != ZXDH_BAR_MSG_OK)
     835                 :          0 :                 return -ret;
     836                 :            : 
     837                 :          0 :         check_token = recv_msg.msix_reps.check;
     838                 :            :         sum_res = zxdh_bar_get_sum((uint8_t *)&msix_msg, sizeof(msix_msg));
     839                 :            : 
     840         [ #  # ]:          0 :         if (check_token != sum_res) {
     841                 :          0 :                 PMD_MSG_LOG(ERR, "expect token: 0x%x, get token: 0x%x", sum_res, check_token);
     842                 :          0 :                 return ZXDH_BAR_MSG_ERR_REPLY;
     843                 :            :         }
     844                 :          0 :         *vport = recv_msg.msix_reps.vport;
     845                 :          0 :         PMD_MSG_LOG(DEBUG, "vport of pcieid: 0x%x get success", para->pcie_id);
     846                 :          0 :         return ZXDH_BAR_MSG_OK;
     847                 :            : }
     848                 :            : 
     849                 :            : int
     850                 :          0 : zxdh_msg_chan_enable(struct rte_eth_dev *dev)
     851                 :            : {
     852                 :          0 :         struct zxdh_hw *hw = dev->data->dev_private;
     853                 :          0 :         struct zxdh_msix_para misx_info = {
     854                 :            :                 .vector_risc = ZXDH_MSIX_FROM_RISCV,
     855                 :            :                 .vector_pfvf = ZXDH_MSIX_FROM_PFVF,
     856                 :            :                 .vector_mpf  = ZXDH_MSIX_FROM_MPF,
     857                 :          0 :                 .pcie_id     = hw->pcie_id,
     858                 :          0 :                 .driver_type = hw->is_pf ? ZXDH_MSG_CHAN_END_PF : ZXDH_MSG_CHAN_END_VF,
     859         [ #  # ]:          0 :                 .virt_addr   = (uint64_t)(hw->bar_addr[ZXDH_BAR0_INDEX] + ZXDH_CTRLCH_OFFSET),
     860                 :            :         };
     861                 :            : 
     862                 :          0 :         return zxdh_bar_chan_enable(&misx_info, &hw->vport.vport);
     863                 :            : }
     864                 :            : 
     865                 :            : static uint64_t
     866         [ #  # ]:          0 : zxdh_recv_addr_get(uint8_t src_type, uint8_t dst_type, uint64_t virt_addr)
     867                 :            : {
     868                 :            :         uint8_t chan_id = 0;
     869                 :            :         uint8_t subchan_id = 0;
     870                 :            :         uint8_t src = 0;
     871                 :            :         uint8_t dst = 0;
     872                 :            : 
     873                 :            :         src = zxdh_bar_msg_dst_index_trans(src_type);
     874                 :            :         dst = zxdh_bar_msg_src_index_trans(dst_type);
     875         [ #  # ]:          0 :         if (src == ZXDH_BAR_MSG_SRC_ERR || dst == ZXDH_BAR_MSG_DST_ERR)
     876                 :            :                 return 0;
     877                 :            : 
     878                 :          0 :         chan_id = chan_id_tbl[dst][src];
     879                 :          0 :         subchan_id = 1 - subchan_id_tbl[dst][src];
     880                 :            : 
     881                 :          0 :         return zxdh_subchan_addr_cal(virt_addr, chan_id, subchan_id);
     882                 :            : }
     883                 :            : 
     884                 :            : static void
     885                 :          0 : zxdh_bar_msg_ack_async_msg_proc(struct zxdh_bar_msg_header *msg_header,
     886                 :            :                 uint8_t *receiver_buff)
     887                 :            : {
     888                 :          0 :         struct zxdh_seqid_item *reps_info = &g_seqid_ring.reps_info_tbl[msg_header->msg_id];
     889                 :            : 
     890         [ #  # ]:          0 :         if (reps_info->flag != ZXDH_REPS_INFO_FLAG_USED) {
     891                 :          0 :                 PMD_MSG_LOG(ERR, "msg_id: %u is released", msg_header->msg_id);
     892                 :          0 :                 return;
     893                 :            :         }
     894         [ #  # ]:          0 :         if (msg_header->len > reps_info->buffer_len - 4) {
     895                 :          0 :                 PMD_MSG_LOG(ERR, "reps_buf_len is %u, but reps_msg_len is %u",
     896                 :            :                                 reps_info->buffer_len, msg_header->len + 4);
     897                 :          0 :                 goto free_id;
     898                 :            :         }
     899                 :          0 :         uint8_t *reps_buffer = (uint8_t *)reps_info->reps_addr;
     900                 :            : 
     901         [ #  # ]:          0 :         rte_memcpy(reps_buffer + 4, receiver_buff, msg_header->len);
     902                 :          0 :         *(uint16_t *)(reps_buffer + 1) = msg_header->len;
     903                 :          0 :         *(uint8_t *)(reps_info->reps_addr) = ZXDH_REPS_HEADER_REPLYED;
     904                 :            : 
     905                 :          0 : free_id:
     906                 :          0 :         zxdh_bar_chan_msgid_free(msg_header->msg_id);
     907                 :            : }
     908                 :            : 
     909                 :            : static void
     910                 :          0 : zxdh_bar_msg_sync_msg_proc(uint64_t reply_addr,
     911                 :            :                 struct zxdh_bar_msg_header *msg_header,
     912                 :            :                 uint8_t *receiver_buff, void *dev)
     913                 :            : {
     914                 :          0 :         uint16_t reps_len = 0;
     915                 :            :         uint8_t *reps_buffer = NULL;
     916                 :            : 
     917                 :          0 :         reps_buffer = rte_malloc(NULL, ZXDH_BAR_MSG_PAYLOAD_MAX_LEN, 0);
     918         [ #  # ]:          0 :         if (reps_buffer == NULL)
     919                 :          0 :                 return;
     920                 :            : 
     921                 :          0 :         zxdh_bar_chan_msg_recv_callback recv_func = zxdh_msg_recv_func_tbl[msg_header->module_id];
     922                 :            : 
     923                 :          0 :         recv_func(receiver_buff, msg_header->len, reps_buffer, &reps_len, dev);
     924                 :          0 :         msg_header->ack = ZXDH_BAR_CHAN_MSG_ACK;
     925                 :          0 :         msg_header->len = reps_len;
     926                 :          0 :         zxdh_bar_chan_msg_header_set(reply_addr, msg_header);
     927                 :          0 :         zxdh_bar_chan_msg_payload_set(reply_addr, reps_buffer, reps_len);
     928                 :            :         zxdh_bar_chan_msg_valid_set(reply_addr, ZXDH_BAR_MSG_CHAN_USABLE);
     929                 :          0 :         rte_free(reps_buffer);
     930                 :            : }
     931                 :            : 
     932                 :            : static uint64_t
     933         [ #  # ]:          0 : zxdh_reply_addr_get(uint8_t sync, uint8_t src_type,
     934                 :            :                 uint8_t dst_type, uint64_t virt_addr)
     935                 :            : {
     936                 :            :         uint64_t recv_rep_addr = 0;
     937                 :            :         uint8_t chan_id = 0;
     938                 :            :         uint8_t subchan_id = 0;
     939                 :            :         uint8_t src = 0;
     940                 :            :         uint8_t dst = 0;
     941                 :            : 
     942                 :            :         src = zxdh_bar_msg_dst_index_trans(src_type);
     943                 :            :         dst = zxdh_bar_msg_src_index_trans(dst_type);
     944         [ #  # ]:          0 :         if (src == ZXDH_BAR_MSG_SRC_ERR || dst == ZXDH_BAR_MSG_DST_ERR)
     945                 :            :                 return 0;
     946                 :            : 
     947                 :          0 :         chan_id = chan_id_tbl[dst][src];
     948                 :          0 :         subchan_id = 1 - subchan_id_tbl[dst][src];
     949                 :            : 
     950         [ #  # ]:          0 :         if (sync == ZXDH_BAR_CHAN_MSG_SYNC)
     951                 :          0 :                 recv_rep_addr = zxdh_subchan_addr_cal(virt_addr, chan_id, subchan_id);
     952                 :            :         else
     953                 :          0 :                 recv_rep_addr = zxdh_subchan_addr_cal(virt_addr, chan_id, 1 - subchan_id);
     954                 :            : 
     955                 :            :         return recv_rep_addr;
     956                 :            : }
     957                 :            : 
     958                 :            : static uint16_t
     959                 :          0 : zxdh_bar_chan_msg_header_check(struct zxdh_bar_msg_header *msg_header)
     960                 :            : {
     961                 :            :         uint16_t len = 0;
     962                 :            :         uint8_t module_id = 0;
     963                 :            : 
     964         [ #  # ]:          0 :         if (msg_header->valid != ZXDH_BAR_MSG_CHAN_USED) {
     965                 :          0 :                 PMD_MSG_LOG(ERR, "recv header ERR: valid label is not used");
     966                 :          0 :                 return ZXDH_BAR_MSG_ERR_MODULE;
     967                 :            :         }
     968                 :          0 :         module_id = msg_header->module_id;
     969                 :            : 
     970         [ #  # ]:          0 :         if (module_id >= (uint8_t)ZXDH_BAR_MSG_MODULE_NUM) {
     971                 :          0 :                 PMD_MSG_LOG(ERR, "recv header ERR: invalid module_id: %u", module_id);
     972                 :          0 :                 return ZXDH_BAR_MSG_ERR_MODULE;
     973                 :            :         }
     974                 :          0 :         len = msg_header->len;
     975                 :            : 
     976         [ #  # ]:          0 :         if (len > ZXDH_BAR_MSG_PAYLOAD_MAX_LEN) {
     977                 :          0 :                 PMD_MSG_LOG(ERR, "recv header ERR: invalid mesg len: %u", len);
     978                 :          0 :                 return ZXDH_BAR_MSG_ERR_LEN;
     979                 :            :         }
     980         [ #  # ]:          0 :         if (zxdh_msg_recv_func_tbl[msg_header->module_id] == NULL) {
     981                 :          0 :                 PMD_MSG_LOG(ERR, "recv header ERR: module:%s(%u) doesn't register",
     982                 :            :                                 zxdh_module_id_name(module_id), module_id);
     983                 :          0 :                 return ZXDH_BAR_MSG_ERR_MODULE_NOEXIST;
     984                 :            :         }
     985                 :            :         return ZXDH_BAR_MSG_OK;
     986                 :            : }
     987                 :            : 
     988                 :            : int
     989                 :          0 : zxdh_bar_irq_recv(uint8_t src, uint8_t dst, uint64_t virt_addr, void *dev)
     990                 :            : {
     991                 :            :         struct zxdh_bar_msg_header msg_header;
     992                 :            :         uint64_t recv_addr = 0;
     993                 :            :         uint64_t reps_addr = 0;
     994                 :            :         uint16_t ret = 0;
     995                 :            :         uint8_t *recved_msg = NULL;
     996                 :            : 
     997                 :          0 :         recv_addr = zxdh_recv_addr_get(src, dst, virt_addr);
     998         [ #  # ]:          0 :         if (recv_addr == 0) {
     999                 :          0 :                 PMD_MSG_LOG(ERR, "invalid driver type(src:%u, dst:%u)", src, dst);
    1000                 :          0 :                 return -1;
    1001                 :            :         }
    1002                 :            : 
    1003                 :            :         zxdh_bar_chan_msg_header_get(recv_addr, &msg_header);
    1004                 :          0 :         ret = zxdh_bar_chan_msg_header_check(&msg_header);
    1005                 :            : 
    1006         [ #  # ]:          0 :         if (ret != ZXDH_BAR_MSG_OK) {
    1007                 :          0 :                 PMD_MSG_LOG(ERR, "recv msg_head err, ret: %u", ret);
    1008                 :          0 :                 return -1;
    1009                 :            :         }
    1010                 :            : 
    1011                 :          0 :         recved_msg = rte_malloc(NULL, msg_header.len, 0);
    1012         [ #  # ]:          0 :         if (recved_msg == NULL) {
    1013                 :          0 :                 PMD_MSG_LOG(ERR, "malloc temp buff failed");
    1014                 :          0 :                 return -1;
    1015                 :            :         }
    1016                 :          0 :         zxdh_bar_chan_msg_payload_get(recv_addr, recved_msg, msg_header.len);
    1017                 :            : 
    1018                 :          0 :         reps_addr = zxdh_reply_addr_get(msg_header.sync, src, dst, virt_addr);
    1019                 :            : 
    1020         [ #  # ]:          0 :         if (msg_header.sync == ZXDH_BAR_CHAN_MSG_SYNC) {
    1021                 :          0 :                 zxdh_bar_msg_sync_msg_proc(reps_addr, &msg_header, recved_msg, dev);
    1022                 :          0 :                 goto exit;
    1023                 :            :         }
    1024                 :            :         zxdh_bar_chan_msg_valid_set(recv_addr, ZXDH_BAR_MSG_CHAN_USABLE);
    1025         [ #  # ]:          0 :         if (msg_header.ack == ZXDH_BAR_CHAN_MSG_ACK) {
    1026                 :          0 :                 zxdh_bar_msg_ack_async_msg_proc(&msg_header, recved_msg);
    1027                 :          0 :                 goto exit;
    1028                 :            :         }
    1029                 :            :         return 0;
    1030                 :            : 
    1031                 :          0 : exit:
    1032                 :          0 :         rte_free(recved_msg);
    1033                 :          0 :         return ZXDH_BAR_MSG_OK;
    1034                 :            : }
    1035                 :            : 
    1036                 :            : int
    1037                 :          0 : zxdh_get_bar_offset(struct zxdh_bar_offset_params *paras,
    1038                 :            :                 struct zxdh_bar_offset_res *res)
    1039                 :            : {
    1040                 :            :         uint16_t check_token;
    1041                 :            :         uint16_t sum_res;
    1042                 :            :         int ret;
    1043                 :            : 
    1044         [ #  # ]:          0 :         if (!paras)
    1045                 :            :                 return ZXDH_BAR_MSG_ERR_NULL;
    1046                 :            : 
    1047                 :          0 :         struct zxdh_offset_get_msg send_msg = {
    1048                 :          0 :                 .pcie_id = paras->pcie_id,
    1049                 :          0 :                 .type = paras->type,
    1050                 :            :         };
    1051                 :          0 :         struct zxdh_pci_bar_msg in = {
    1052                 :            :                 .payload_addr = &send_msg,
    1053                 :            :                 .payload_len = sizeof(send_msg),
    1054                 :          0 :                 .virt_addr = paras->virt_addr,
    1055                 :            :                 .src = ZXDH_MSG_CHAN_END_PF,
    1056                 :            :                 .dst = ZXDH_MSG_CHAN_END_RISC,
    1057                 :            :                 .module_id = ZXDH_BAR_MODULE_OFFSET_GET,
    1058                 :            :                 .src_pcieid = paras->pcie_id,
    1059                 :            :         };
    1060                 :          0 :         struct zxdh_bar_recv_msg recv_msg = {0};
    1061                 :          0 :         struct zxdh_msg_recviver_mem result = {
    1062                 :            :                 .recv_buffer = &recv_msg,
    1063                 :            :                 .buffer_len = sizeof(recv_msg),
    1064                 :            :         };
    1065                 :          0 :         ret = zxdh_bar_chan_sync_msg_send(&in, &result);
    1066         [ #  # ]:          0 :         if (ret != ZXDH_BAR_MSG_OK)
    1067                 :          0 :                 return -ret;
    1068                 :            : 
    1069                 :          0 :         check_token = recv_msg.offset_reps.check;
    1070                 :            :         sum_res = zxdh_bar_get_sum((uint8_t *)&send_msg, sizeof(send_msg));
    1071                 :            : 
    1072         [ #  # ]:          0 :         if (check_token != sum_res) {
    1073                 :          0 :                 PMD_MSG_LOG(ERR, "expect token: 0x%x, get token: 0x%x", sum_res, check_token);
    1074                 :          0 :                 return ZXDH_BAR_MSG_ERR_REPLY;
    1075                 :            :         }
    1076                 :          0 :         res->bar_offset = recv_msg.offset_reps.offset;
    1077                 :          0 :         res->bar_length = recv_msg.offset_reps.length;
    1078                 :          0 :         return ZXDH_BAR_MSG_OK;
    1079                 :            : }
    1080                 :            : 
    1081                 :            : int
    1082                 :          0 : zxdh_vf_send_msg_to_pf(struct rte_eth_dev *dev,  void *msg_req,
    1083                 :            :                         uint16_t msg_req_len, void *reply, uint16_t reply_len)
    1084                 :            : {
    1085                 :          0 :         struct zxdh_hw *hw  = dev->data->dev_private;
    1086                 :          0 :         struct zxdh_msg_recviver_mem result = {0};
    1087                 :          0 :         uint8_t zxdh_msg_reply_info[ZXDH_ST_SZ_BYTES(msg_reply_info)] = {0};
    1088                 :            :         int ret = 0;
    1089                 :            : 
    1090         [ #  # ]:          0 :         if (reply) {
    1091                 :            :                 RTE_ASSERT(reply_len < ZXDH_ST_SZ_BYTES(msg_reply_info));
    1092                 :          0 :                 result.recv_buffer  = reply;
    1093                 :          0 :                 result.buffer_len = reply_len;
    1094                 :            :         } else {
    1095                 :          0 :                 result.recv_buffer = zxdh_msg_reply_info;
    1096                 :          0 :                 result.buffer_len = ZXDH_ST_SZ_BYTES(msg_reply_info);
    1097                 :            :         }
    1098                 :            : 
    1099                 :          0 :         void *reply_head_addr = ZXDH_ADDR_OF(msg_reply_info, result.recv_buffer, reply_head);
    1100                 :          0 :         void *reply_body_addr = ZXDH_ADDR_OF(msg_reply_info, result.recv_buffer, reply_body);
    1101                 :            : 
    1102                 :          0 :         struct zxdh_pci_bar_msg in = {
    1103                 :          0 :                 .virt_addr = (uint64_t)(hw->bar_addr[ZXDH_BAR0_INDEX] +
    1104                 :            :                                 ZXDH_MSG_CHAN_PFVFSHARE_OFFSET),
    1105                 :            :                 .payload_addr = msg_req,
    1106                 :            :                 .payload_len = msg_req_len,
    1107                 :            :                 .src = ZXDH_MSG_CHAN_END_VF,
    1108                 :            :                 .dst = ZXDH_MSG_CHAN_END_PF,
    1109                 :            :                 .module_id = ZXDH_MODULE_BAR_MSG_TO_PF,
    1110                 :          0 :                 .src_pcieid = hw->pcie_id,
    1111                 :          0 :                 .dst_pcieid = ZXDH_PF_PCIE_ID(hw->pcie_id),
    1112                 :            :         };
    1113                 :            : 
    1114                 :          0 :         ret = zxdh_bar_chan_sync_msg_send(&in, &result);
    1115         [ #  # ]:          0 :         if (ret != ZXDH_BAR_MSG_OK) {
    1116                 :          0 :                 PMD_MSG_LOG(ERR,
    1117                 :            :                         "vf[%d] send bar msg to pf failed.ret %d", hw->vport.vfid, ret);
    1118                 :          0 :                 return -1;
    1119                 :            :         }
    1120                 :            : 
    1121                 :          0 :         uint8_t flag = ZXDH_GET(msg_reply_head, reply_head_addr, flag);
    1122                 :          0 :         uint16_t reps_len = ZXDH_GET(msg_reply_head, reply_head_addr, reps_len);
    1123         [ #  # ]:          0 :         if (flag != ZXDH_MSG_REPS_OK) {
    1124                 :          0 :                 PMD_MSG_LOG(ERR, "vf[%d] get pf reply failed: reply_head flag : 0x%x(0xff is OK).replylen %d",
    1125                 :            :                                 hw->vport.vfid, flag, reps_len);
    1126                 :          0 :                 return -1;
    1127                 :            :         }
    1128                 :          0 :         uint8_t reply_body_flag = ZXDH_GET(msg_reply_body, reply_body_addr, flag);
    1129         [ #  # ]:          0 :         if (reply_body_flag != ZXDH_REPS_SUCC) {
    1130                 :          0 :                 PMD_MSG_LOG(ERR, "vf[%d] msg processing failed", hw->vfid);
    1131                 :          0 :                 return -1;
    1132                 :            :         }
    1133                 :            :         return 0;
    1134                 :            : }
    1135                 :            : 
    1136                 :            : int32_t
    1137                 :          0 : zxdh_send_msg_to_riscv(struct rte_eth_dev *dev, void *msg_req,
    1138                 :            :                         uint16_t msg_req_len, void *reply, uint16_t reply_len,
    1139                 :            :                         enum ZXDH_BAR_MODULE_ID module_id)
    1140                 :            : {
    1141                 :          0 :         struct zxdh_hw *hw = dev->data->dev_private;
    1142                 :          0 :         struct zxdh_msg_recviver_mem result = {0};
    1143                 :          0 :         uint8_t zxdh_msg_reply_info[ZXDH_ST_SZ_BYTES(msg_reply_info)] = {0};
    1144                 :            : 
    1145         [ #  # ]:          0 :         if (reply) {
    1146                 :            :                 RTE_ASSERT(reply_len < ZXDH_ST_SZ_BYTES(msg_reply_info));
    1147                 :          0 :                 result.recv_buffer  = reply;
    1148                 :          0 :                 result.buffer_len = reply_len;
    1149                 :            :         } else {
    1150                 :          0 :                 result.recv_buffer = zxdh_msg_reply_info;
    1151                 :          0 :                 result.buffer_len = ZXDH_ST_SZ_BYTES(msg_reply_info);
    1152                 :            :         }
    1153                 :            : 
    1154                 :          0 :         struct zxdh_pci_bar_msg in = {
    1155                 :            :                 .payload_addr = msg_req,
    1156                 :            :                 .payload_len = msg_req_len,
    1157                 :          0 :                 .virt_addr = (uint64_t)(hw->bar_addr[ZXDH_BAR0_INDEX] + ZXDH_CTRLCH_OFFSET),
    1158         [ #  # ]:          0 :                 .src = hw->is_pf ? ZXDH_MSG_CHAN_END_PF : ZXDH_MSG_CHAN_END_VF,
    1159                 :            :                 .dst = ZXDH_MSG_CHAN_END_RISC,
    1160                 :            :                 .module_id = module_id,
    1161                 :          0 :                 .src_pcieid = hw->pcie_id,
    1162                 :            :         };
    1163                 :            : 
    1164         [ #  # ]:          0 :         if (zxdh_bar_chan_sync_msg_send(&in, &result) != ZXDH_BAR_MSG_OK) {
    1165                 :          0 :                 PMD_MSG_LOG(ERR, "Failed to send sync messages or receive response");
    1166                 :          0 :                 return -1;
    1167                 :            :         }
    1168                 :            : 
    1169                 :            :         return 0;
    1170                 :            : }
    1171                 :            : 
    1172                 :            : void
    1173                 :          0 : zxdh_msg_head_build(struct zxdh_hw *hw, enum zxdh_msg_type type,
    1174                 :            :                 struct zxdh_msg_info *msg_info)
    1175                 :            : {
    1176                 :            :         struct zxdh_msg_head *msghead = &msg_info->msg_head;
    1177                 :            : 
    1178                 :          0 :         msghead->msg_type = type;
    1179                 :          0 :         msghead->vport    = hw->vport.vport;
    1180                 :          0 :         msghead->vf_id    = hw->vport.vfid;
    1181                 :          0 :         msghead->pcieid   = hw->pcie_id;
    1182                 :          0 : }
    1183                 :            : 
    1184                 :            : void
    1185                 :          0 : zxdh_agent_msg_build(struct zxdh_hw *hw, enum zxdh_agent_msg_type type,
    1186                 :            :                 struct zxdh_msg_info *msg_info)
    1187                 :            : {
    1188                 :            :         struct zxdh_agent_msg_head *agent_head = &msg_info->agent_msg_head;
    1189                 :            : 
    1190                 :          0 :         agent_head->msg_type = type;
    1191                 :          0 :         agent_head->panel_id = hw->panel_id;
    1192                 :          0 :         agent_head->phyport = hw->phyport;
    1193                 :          0 :         agent_head->vf_id = hw->vfid;
    1194                 :          0 :         agent_head->pcie_id = hw->pcie_id;
    1195                 :          0 : }
    1196                 :            : 
    1197                 :            : static int
    1198                 :          0 : zxdh_bar_chan_msg_recv_register(uint8_t module_id, zxdh_bar_chan_msg_recv_callback callback)
    1199                 :            : {
    1200         [ #  # ]:          0 :         if (module_id >= (uint16_t)ZXDH_BAR_MSG_MODULE_NUM) {
    1201                 :          0 :                 PMD_MSG_LOG(ERR, "register ERR: invalid module_id: %u.", module_id);
    1202                 :          0 :                 return ZXDH_BAR_MSG_ERR_MODULE;
    1203                 :            :         }
    1204         [ #  # ]:          0 :         if (callback == NULL) {
    1205                 :          0 :                 PMD_MSG_LOG(ERR, "register %s(%u) error: null callback.",
    1206                 :            :                                         zxdh_module_id_name(module_id), module_id);
    1207                 :          0 :                 return ZXDH_BAR_MEG_ERR_NULL_FUNC;
    1208                 :            :         }
    1209         [ #  # ]:          0 :         if (zxdh_msg_recv_func_tbl[module_id] != NULL) {
    1210                 :          0 :                 PMD_MSG_LOG(DEBUG, "register warning, event:%s(%u) already be registered.",
    1211                 :            :                                         zxdh_module_id_name(module_id), module_id);
    1212                 :          0 :                 return ZXDH_BAR_MSG_ERR_REPEAT_REGISTER;
    1213                 :            :         }
    1214                 :          0 :         zxdh_msg_recv_func_tbl[module_id] = callback;
    1215                 :          0 :         return ZXDH_BAR_MSG_OK;
    1216                 :            : }
    1217                 :            : 
    1218                 :            : static int
    1219                 :            : zxdh_vf_promisc_init(struct zxdh_hw *hw, union zxdh_virport_num vport)
    1220                 :            : {
    1221                 :            :         int16_t ret;
    1222                 :            : 
    1223                 :          0 :         ret = zxdh_dev_broadcast_set(hw, vport.vport, true);
    1224                 :          0 :         return ret;
    1225                 :            : }
    1226                 :            : 
    1227                 :            : static int
    1228                 :            : zxdh_vf_promisc_uninit(struct zxdh_hw *hw, union zxdh_virport_num vport)
    1229                 :            : {
    1230                 :            :         int16_t ret;
    1231                 :            : 
    1232                 :          0 :         ret = zxdh_dev_broadcast_set(hw, vport.vport, false);
    1233                 :          0 :         return ret;
    1234                 :            : }
    1235                 :            : 
    1236                 :            : static int
    1237                 :          0 : zxdh_vf_port_init(struct zxdh_hw *pf_hw, uint16_t vport, void *cfg_data,
    1238                 :            :                 void *res_info, uint16_t *res_len)
    1239                 :            : {
    1240                 :          0 :         struct zxdh_port_attr_table port_attr = {0};
    1241                 :            :         union zxdh_virport_num port = {.vport = vport};
    1242                 :            :         struct zxdh_vf_init_msg *vf_init_msg = (struct zxdh_vf_init_msg *)cfg_data;
    1243                 :            :         int ret = 0;
    1244                 :            : 
    1245                 :            :         RTE_ASSERT(!cfg_data || !pf_hw || !res_info || !res_len);
    1246                 :          0 :         *res_len = ZXDH_MSG_REPLYBODY_HEAD;
    1247                 :          0 :         port_attr.hit_flag = 1;
    1248                 :          0 :         port_attr.is_vf = 1;
    1249                 :          0 :         port_attr.phy_port = pf_hw->phyport;
    1250                 :          0 :         port_attr.is_up = 1;
    1251                 :            :         port_attr.rss_enable = 0;
    1252                 :          0 :         port_attr.pf_vfid = pf_hw->vfid;
    1253                 :          0 :         port_attr.hash_search_index = pf_hw->hash_search_index;
    1254                 :          0 :         port_attr.port_base_qid = vf_init_msg->base_qid;
    1255                 :          0 :         uint16_t vfid = zxdh_vport_to_vfid(port);
    1256                 :            : 
    1257                 :          0 :         ret = zxdh_set_port_attr(pf_hw, vfid, &port_attr);
    1258         [ #  # ]:          0 :         if (ret) {
    1259                 :          0 :                 PMD_DRV_LOG(ERR, "set vport attr failed, code:%d", ret);
    1260                 :          0 :                 goto proc_end;
    1261                 :            :         }
    1262                 :            : 
    1263                 :            :         ret = zxdh_vf_promisc_init(pf_hw, port);
    1264         [ #  # ]:          0 :         if (ret) {
    1265                 :          0 :                 PMD_DRV_LOG(ERR, "vf_promisc_table_init failed, code:%d", ret);
    1266                 :          0 :                 goto proc_end;
    1267                 :            :         }
    1268                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
    1269                 :          0 :         *res_len = sizeof(uint8_t);
    1270                 :            : 
    1271                 :          0 :         return ret;
    1272                 :          0 : proc_end:
    1273                 :          0 :         *res_len = sizeof(uint8_t);
    1274                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
    1275                 :          0 :         return ret;
    1276                 :            : }
    1277                 :            : 
    1278                 :            : static int
    1279                 :          0 : zxdh_mac_clear(struct zxdh_hw *hw, union zxdh_virport_num vport)
    1280                 :            : {
    1281                 :          0 :         uint16_t vf_id = vport.vfid;
    1282                 :            :         int i;
    1283                 :            :         int ret = 0;
    1284                 :            : 
    1285         [ #  # ]:          0 :         for (i = 0; (i != ZXDH_MAX_MAC_ADDRS); ++i) {
    1286         [ #  # ]:          0 :                 if (!rte_is_zero_ether_addr(&hw->vfinfo[vf_id].vf_mac[i])) {
    1287                 :          0 :                         ret = zxdh_del_mac_table(hw, vport.vport,
    1288                 :            :                                         &hw->vfinfo[vf_id].vf_mac[i],
    1289                 :          0 :                                         hw->hash_search_index, 0, 0);
    1290         [ #  # ]:          0 :                         if (ret) {
    1291                 :          0 :                                 PMD_DRV_LOG(ERR, "vf_del_mac_failed. code:%d", ret);
    1292                 :          0 :                                 return ret;
    1293                 :            :                         }
    1294                 :          0 :                         memset(&hw->vfinfo[vf_id].vf_mac[i], 0, sizeof(struct rte_ether_addr));
    1295                 :            :                 }
    1296                 :            :         }
    1297                 :            :         return ret;
    1298                 :            : }
    1299                 :            : 
    1300                 :            : static int
    1301                 :          0 : zxdh_vf_port_uninit(struct zxdh_hw *pf_hw,
    1302                 :            :                 uint16_t vport, void *cfg_data __rte_unused,
    1303                 :            :                 void *res_info, uint16_t *res_len)
    1304                 :            : {
    1305                 :          0 :         char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "uninit";
    1306                 :          0 :         struct zxdh_port_attr_table port_attr = {0};
    1307                 :            :         union zxdh_virport_num vport_num = {.vport = vport};
    1308                 :          0 :         void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, res_info, reply_data);
    1309                 :            :         int ret = 0;
    1310                 :            : 
    1311                 :          0 :         *res_len =  ZXDH_MSG_REPLYBODY_HEAD;
    1312                 :            :         RTE_ASSERT(!cfg_data || !pf_hw || !res_info || !res_len);
    1313                 :            : 
    1314                 :          0 :         ret = zxdh_delete_port_attr(pf_hw, vport, &port_attr);
    1315         [ #  # ]:          0 :         if (ret) {
    1316                 :          0 :                 PMD_DRV_LOG(ERR, "write port_attr_eram failed, code:%d", ret);
    1317                 :          0 :                 goto proc_end;
    1318                 :            :         }
    1319                 :            : 
    1320                 :          0 :         ret = zxdh_mac_clear(pf_hw, vport_num);
    1321         [ #  # ]:          0 :         if (ret) {
    1322                 :          0 :                 PMD_DRV_LOG(ERR, "zxdh_mac_clear failed, code:%d", ret);
    1323                 :          0 :                 goto proc_end;
    1324                 :            :         }
    1325                 :            : 
    1326                 :            :         ret = zxdh_vf_promisc_uninit(pf_hw, vport_num);
    1327         [ #  # ]:          0 :         if (ret) {
    1328                 :          0 :                 PMD_DRV_LOG(ERR, "vf_promisc_table_uninit failed, code:%d", ret);
    1329                 :          0 :                 goto proc_end;
    1330                 :            :         }
    1331                 :            : 
    1332                 :          0 :         *res_len += strlen(str);
    1333         [ #  # ]:          0 :         rte_memcpy(reply_data_addr, str, strlen(str) + 1);
    1334                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
    1335                 :          0 :         return ret;
    1336                 :            : 
    1337                 :          0 : proc_end:
    1338                 :          0 :         *res_len += strlen(str);
    1339         [ #  # ]:          0 :         rte_memcpy(reply_data_addr, str, strlen(str) + 1);
    1340                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
    1341                 :          0 :         return ret;
    1342                 :            : }
    1343                 :            : 
    1344                 :            : static int
    1345                 :          0 : zxdh_add_vf_mac_table(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
    1346                 :            :                 void *reply_body, uint16_t *reply_len)
    1347                 :            : {
    1348                 :          0 :         char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "add mac";
    1349                 :            :         union zxdh_virport_num port = {0};
    1350                 :            :         struct zxdh_mac_filter *mac_filter = (struct zxdh_mac_filter *)cfg_data;
    1351                 :          0 :         struct rte_ether_addr *addr = &mac_filter->mac;
    1352                 :            :         int i = 0, ret = 0;
    1353                 :            :         uint16_t vf_id = port.vfid;
    1354                 :            :         port.vport = vport;
    1355                 :          0 :         void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply_body, reply_data);
    1356                 :            :         void *mac_reply_msg_addr = ZXDH_ADDR_OF(msg_reply_body, reply_body, mac_reply_msg);
    1357                 :            : 
    1358         [ #  # ]:          0 :         for (i = 0; i < ZXDH_MAX_MAC_ADDRS; i++)
    1359         [ #  # ]:          0 :                 if (rte_is_same_ether_addr(&hw->vfinfo[vf_id].vf_mac[i], addr))
    1360                 :          0 :                         goto success;
    1361                 :            : 
    1362                 :          0 :         ret = zxdh_add_mac_table(hw, vport, addr, hw->hash_search_index, 0, 0);
    1363         [ #  # ]:          0 :         if (ret == -EADDRINUSE) {
    1364                 :          0 :                 ZXDH_SET(mac_reply_msg, mac_reply_msg_addr, mac_flag, ZXDH_EEXIST_MAC_FLAG);
    1365                 :          0 :                 PMD_DRV_LOG(ERR, "vf vport 0x%x set mac ret 0x%x failed. mac is in used.",
    1366                 :            :                                 port.vport, ret);
    1367                 :          0 :                 goto failure;
    1368                 :            :         }
    1369         [ #  # ]:          0 :         if (ret) {
    1370                 :            :                 sprintf(str, "[PF GET MSG FROM VF]--VF add mac failed. code:%d\n", ret);
    1371                 :          0 :                 PMD_DRV_LOG(ERR, " %s", str);
    1372                 :          0 :                 goto failure;
    1373                 :            :         }
    1374         [ #  # ]:          0 :         for (i = 0; i < ZXDH_MAX_MAC_ADDRS; i++) {
    1375         [ #  # ]:          0 :                 if (rte_is_zero_ether_addr(&hw->vfinfo[vf_id].vf_mac[i])) {
    1376                 :            :                         memcpy(&hw->vfinfo[vf_id].vf_mac[i], addr, 6);
    1377                 :            :                         break;
    1378                 :            :                 }
    1379                 :            :         }
    1380                 :            : 
    1381                 :          0 : success:
    1382         [ #  # ]:          0 :         sprintf(str, " vport 0x%x set mac ret 0x%x\n", port.vport, ret);
    1383                 :          0 :         *reply_len =  strlen(str) + ZXDH_MSG_REPLYBODY_HEAD;
    1384         [ #  # ]:          0 :         rte_memcpy(reply_data_addr, str, strlen(str) + 1);
    1385                 :          0 :         ZXDH_SET(msg_reply_body, reply_body, flag, ZXDH_REPS_SUCC);
    1386                 :          0 :         PMD_DRV_LOG(DEBUG, " reply len %d", *reply_len);
    1387                 :          0 :         return ret;
    1388                 :            : 
    1389                 :          0 : failure:
    1390                 :          0 :         *reply_len = strlen(str) + ZXDH_MSG_REPLYBODY_HEAD;
    1391                 :          0 :         ZXDH_SET(msg_reply_body, reply_body, flag, ZXDH_REPS_FAIL);
    1392                 :          0 :         return ret;
    1393                 :            : }
    1394                 :            : 
    1395                 :            : static int
    1396                 :          0 : zxdh_del_vf_mac_table(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
    1397                 :            :         void *res_info, uint16_t *res_len)
    1398                 :            : {
    1399                 :            :         int ret, i = 0;
    1400                 :            :         struct zxdh_mac_filter *mac_filter = (struct zxdh_mac_filter *)cfg_data;
    1401                 :            :         union zxdh_virport_num  port = (union zxdh_virport_num)vport;
    1402                 :          0 :         char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "del mac";
    1403                 :            :         uint16_t  vf_id = port.vfid;
    1404                 :          0 :         void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, res_info, reply_data);
    1405                 :            : 
    1406                 :          0 :         PMD_DRV_LOG(DEBUG, "[PF GET MSG FROM VF]--vf mac to del.");
    1407                 :          0 :         ret = zxdh_del_mac_table(hw, vport, &mac_filter->mac, hw->hash_search_index, 0, 0);
    1408         [ #  # ]:          0 :         if (ret == -EADDRINUSE)
    1409                 :            :                 ret = 0;
    1410                 :            : 
    1411         [ #  # ]:          0 :         if (ret) {
    1412                 :            :                 sprintf(str, "[PF GET MSG FROM VF]--VF del mac failed. code:%d\n", ret);
    1413                 :          0 :                 PMD_DRV_LOG(ERR, "%s", str);
    1414                 :          0 :                 goto proc_end;
    1415                 :            :         }
    1416                 :            : 
    1417         [ #  # ]:          0 :         for (i = 0; i < ZXDH_MAX_MAC_ADDRS; i++) {
    1418         [ #  # ]:          0 :                 if (rte_is_same_ether_addr(&hw->vfinfo[vf_id].vf_mac[i], &mac_filter->mac))
    1419                 :            :                         memset(&hw->vfinfo[vf_id].vf_mac[i], 0, sizeof(struct rte_ether_addr));
    1420                 :            :         }
    1421                 :            : 
    1422                 :            :         sprintf(str, "vport 0x%x del mac ret 0x%x\n", port.vport, ret);
    1423                 :          0 :         *res_len =  strlen(str) + ZXDH_MSG_REPLYBODY_HEAD;
    1424         [ #  # ]:          0 :         rte_memcpy(reply_data_addr, str, strlen(str) + 1);
    1425                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
    1426                 :          0 :         return ret;
    1427                 :            : 
    1428                 :            : proc_end:
    1429                 :          0 :         *res_len = strlen(str) + ZXDH_MSG_REPLYBODY_HEAD;
    1430                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
    1431                 :          0 :         return ret;
    1432                 :            : }
    1433                 :            : 
    1434                 :            : static int
    1435                 :          0 : zxdh_vf_promisc_set(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
    1436                 :            :                 void *reply, uint16_t *res_len)
    1437                 :            : {
    1438                 :            :         struct zxdh_port_promisc_msg *promisc_msg = (struct zxdh_port_promisc_msg *)cfg_data;
    1439                 :            :         int ret = 0;
    1440                 :            : 
    1441                 :            :         RTE_ASSERT(!cfg_data || !hw || !reply || !res_len);
    1442                 :            : 
    1443         [ #  # ]:          0 :         if (promisc_msg->mode == ZXDH_PROMISC_MODE) {
    1444                 :          0 :                 zxdh_dev_unicast_table_set(hw, vport, promisc_msg->value);
    1445         [ #  # ]:          0 :                 if (promisc_msg->mc_follow == 1)
    1446                 :          0 :                         ret = zxdh_dev_multicast_table_set(hw, vport, promisc_msg->value);
    1447         [ #  # ]:          0 :         } else if (promisc_msg->mode == ZXDH_ALLMULTI_MODE) {
    1448                 :          0 :                 ret = zxdh_dev_multicast_table_set(hw, vport, promisc_msg->value);
    1449                 :            :         } else {
    1450                 :          0 :                 PMD_DRV_LOG(ERR, "promisc_set_msg mode[%u] error", promisc_msg->mode);
    1451                 :          0 :                 goto proc_end;
    1452                 :            :         }
    1453                 :            : 
    1454                 :          0 :         *res_len = sizeof(struct zxdh_port_attr_set_msg) + sizeof(uint8_t);
    1455                 :          0 :         ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
    1456                 :            : 
    1457                 :          0 :         return ret;
    1458                 :            : 
    1459                 :            : proc_end:
    1460                 :          0 :         *res_len = sizeof(struct zxdh_port_attr_set_msg) + sizeof(uint8_t);
    1461                 :          0 :         ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
    1462                 :          0 :         return ret;
    1463                 :            : }
    1464                 :            : 
    1465                 :            : static int
    1466                 :          0 : zxdh_vf_vlan_filter_table_process(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
    1467                 :            :                 void *res_info, uint16_t *res_len, uint8_t enable)
    1468                 :            : {
    1469                 :            :         struct zxdh_vlan_filter *vlan_filter = cfg_data;
    1470                 :          0 :         uint16_t vlan_id =  vlan_filter->vlan_id;
    1471                 :          0 :         char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "vlan filter table";
    1472                 :          0 :         void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, res_info, reply_data);
    1473                 :            :         int ret = 0;
    1474                 :            : 
    1475                 :          0 :         ret = zxdh_vlan_filter_table_set(hw, vport, vlan_id, enable);
    1476         [ #  # ]:          0 :         if (ret)
    1477                 :            :                 sprintf(str, "vlan filter op-code[%d] vlan id:%d failed, code:%d\n",
    1478                 :            :                         enable, vlan_id, ret);
    1479                 :            : 
    1480                 :          0 :         *res_len = strlen(str) + sizeof(uint8_t);
    1481                 :            : 
    1482         [ #  # ]:          0 :         memcpy(reply_data_addr, str, strlen(str) + 1);
    1483         [ #  # ]:          0 :         if (ret == 0)
    1484                 :          0 :                 ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
    1485                 :            :         else
    1486                 :          0 :                 ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
    1487                 :          0 :         return ret;
    1488                 :            : }
    1489                 :            : 
    1490                 :            : static int
    1491                 :          0 : zxdh_vf_vlan_filter_table_add(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
    1492                 :            :                 void *res_info, uint16_t *res_len)
    1493                 :            : {
    1494                 :          0 :         return zxdh_vf_vlan_filter_table_process(hw, vport, cfg_data, res_info, res_len, 1);
    1495                 :            : }
    1496                 :            : 
    1497                 :            : static int
    1498                 :          0 : zxdh_vf_vlan_filter_table_del(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
    1499                 :            :                 void *res_info, uint16_t *res_len)
    1500                 :            : {
    1501                 :          0 :         return zxdh_vf_vlan_filter_table_process(hw, vport, cfg_data, res_info, res_len, 0);
    1502                 :            : }
    1503                 :            : 
    1504                 :            : static int
    1505                 :          0 : zxdh_vf_set_vlan_filter(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
    1506                 :            :                 void *reply, uint16_t *res_len)
    1507                 :            : {
    1508                 :            :         struct zxdh_vlan_filter_set *vlan_filter = cfg_data;
    1509                 :            :         union zxdh_virport_num port = (union zxdh_virport_num)vport;
    1510                 :          0 :         char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "vlan filter";
    1511                 :          0 :         void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply, reply_data);
    1512                 :            :         int ret = 0;
    1513                 :            :         uint16_t vfid = port.vfid;
    1514                 :            : 
    1515                 :          0 :         ret = zxdh_set_vlan_filter(hw, vport, vlan_filter->enable);
    1516         [ #  # ]:          0 :         if (ret)
    1517                 :          0 :                 sprintf(str, "[vfid:%d] vlan filter. set failed, ret:%d\n", vfid, ret);
    1518                 :            : 
    1519                 :          0 :         *res_len = strlen(str) + sizeof(uint8_t);
    1520         [ #  # ]:          0 :         if (ret == 0)
    1521                 :          0 :                 ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
    1522                 :            :         else
    1523                 :          0 :                 ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
    1524                 :          0 :         memcpy(reply_data_addr, str, strlen(str) + 1);
    1525                 :          0 :         return ret;
    1526                 :            : }
    1527                 :            : 
    1528                 :            : static int
    1529                 :          0 : zxdh_vf_set_vlan_offload(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
    1530                 :            :                 void *reply, uint16_t *res_len)
    1531                 :            : {
    1532                 :            :         struct zxdh_vlan_offload *vlan_offload = cfg_data;
    1533                 :            :         union zxdh_virport_num port = (union zxdh_virport_num)vport;
    1534                 :          0 :         char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "vlan offload";
    1535                 :          0 :         void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply, reply_data);
    1536                 :            :         int ret = 0;
    1537                 :            :         uint16_t vfid = port.vfid;
    1538                 :            : 
    1539         [ #  # ]:          0 :         PMD_DRV_LOG(DEBUG, "vfid:%d, type:%s, enable:%d",
    1540                 :            :                 vfid, vlan_offload->type == ZXDH_VLAN_STRIP_TYPE ? "vlan-strip" : "qinq-strip",
    1541                 :            :                         vlan_offload->enable);
    1542                 :          0 :         ret = zxdh_set_vlan_offload(hw, vport, vlan_offload->type, vlan_offload->enable);
    1543         [ #  # ]:          0 :         if (ret)
    1544                 :            :                 sprintf(str, "[vfid:%d] vlan offload set failed, ret:%d\n", vfid, ret);
    1545                 :            : 
    1546                 :          0 :         *res_len = strlen(str) + sizeof(uint8_t);
    1547         [ #  # ]:          0 :         if (ret == 0)
    1548                 :          0 :                 ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
    1549                 :            :         else
    1550                 :          0 :                 ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
    1551                 :          0 :         memcpy(reply_data_addr, str, strlen(str) + 1);
    1552                 :          0 :         return ret;
    1553                 :            : }
    1554                 :            : 
    1555                 :            : static int
    1556                 :          0 : zxdh_vf_rss_hf_get(struct zxdh_hw *hw, uint16_t vport, void *cfg_data __rte_unused,
    1557                 :            :                         void *reply, uint16_t *res_len)
    1558                 :            : {
    1559                 :          0 :         char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "rss_hf";
    1560                 :          0 :         struct zxdh_port_attr_table vport_att = {0};
    1561                 :          0 :         void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply, reply_data);
    1562                 :            :         void *rss_hf_msg_addr = ZXDH_ADDR_OF(msg_reply_body, reply, rss_hf_msg);
    1563                 :            :         int ret = 0;
    1564                 :            : 
    1565                 :          0 :         ret = zxdh_get_port_attr(hw, vport, &vport_att);
    1566         [ #  # ]:          0 :         if (ret) {
    1567                 :            :                 sprintf(str, "get rss hash factor failed, ret:%d\n", ret);
    1568                 :          0 :                 PMD_DRV_LOG(ERR, "get rss hash factor failed.");
    1569                 :          0 :                 goto proc_end;
    1570                 :            :         }
    1571                 :            : 
    1572                 :          0 :         ZXDH_SET(rss_hf, rss_hf_msg_addr, rss_hf, vport_att.rss_hash_factor);
    1573                 :            : 
    1574                 :          0 : proc_end:
    1575                 :          0 :         *res_len = strlen(str) + sizeof(uint8_t);
    1576         [ #  # ]:          0 :         if (ret == 0)
    1577                 :          0 :                 ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
    1578                 :            :         else
    1579                 :          0 :                 ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
    1580                 :          0 :         memcpy(reply_data_addr, str, strlen(str) + 1);
    1581                 :          0 :         return ret;
    1582                 :            : }
    1583                 :            : 
    1584                 :            : static int
    1585                 :          0 : zxdh_vf_rss_hf_set(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
    1586                 :            :                         void *reply, uint16_t *res_len)
    1587                 :            : {
    1588                 :          0 :         char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "rss_hf";
    1589                 :            :         struct zxdh_rss_hf *rss_hf = cfg_data;
    1590                 :          0 :         struct zxdh_port_attr_table vport_att = {0};
    1591                 :          0 :         void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply, reply_data);
    1592                 :            :         int ret = 0;
    1593                 :            : 
    1594                 :          0 :         ret = zxdh_get_port_attr(hw, vport, &vport_att);
    1595         [ #  # ]:          0 :         if (ret) {
    1596                 :          0 :                 sprintf(str, "set rss hash factor (set vport tbl failed, hf is %d). ret:%d\n",
    1597                 :            :                                 rss_hf->rss_hf, ret);
    1598                 :          0 :                 PMD_DRV_LOG(ERR, "rss enable hash factor set failed");
    1599                 :          0 :                 goto proc_end;
    1600                 :            :         }
    1601                 :            : 
    1602                 :          0 :         vport_att.rss_hash_factor = rss_hf->rss_hf;
    1603                 :          0 :         ret = zxdh_set_port_attr(hw, vport, &vport_att);
    1604         [ #  # ]:          0 :         if (ret) {
    1605                 :          0 :                 sprintf(str, "set rss hash factor (set vport tbl failed, hf is %d). ret:%d\n",
    1606                 :            :                                 rss_hf->rss_hf, ret);
    1607                 :          0 :                 PMD_DRV_LOG(ERR, "rss config hf failed");
    1608                 :            :         }
    1609                 :            : 
    1610                 :          0 : proc_end:
    1611                 :          0 :         *res_len = strlen(str) + sizeof(uint8_t);
    1612         [ #  # ]:          0 :         if (ret == 0)
    1613                 :          0 :                 ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
    1614                 :            :         else
    1615                 :          0 :                 ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
    1616                 :          0 :         memcpy(reply_data_addr, str, strlen(str) + 1);
    1617                 :          0 :         return ret;
    1618                 :            : }
    1619                 :            : 
    1620                 :            : static int
    1621                 :          0 : zxdh_vf_rss_enable(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
    1622                 :            :                         void *reply, uint16_t *res_len)
    1623                 :            : {
    1624                 :          0 :         char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "rss_enable";
    1625                 :            :         struct zxdh_rss_enable *rss_enable = cfg_data;
    1626                 :          0 :         struct zxdh_port_attr_table vport_att = {0};
    1627                 :          0 :         void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply, reply_data);
    1628                 :            :         int ret = 0;
    1629                 :            : 
    1630                 :          0 :         ret = zxdh_get_port_attr(hw, vport, &vport_att);
    1631         [ #  # ]:          0 :         if (ret) {
    1632                 :          0 :                 sprintf(str, "set rss enable (get vport tbl failed, rss_enable is %d). ret:%d\n",
    1633                 :          0 :                                 rss_enable->enable, ret);
    1634                 :          0 :                 PMD_DRV_LOG(ERR, "rss enable set failed");
    1635                 :          0 :                 goto proc_end;
    1636                 :            :         }
    1637                 :            : 
    1638                 :          0 :         vport_att.rss_enable = rss_enable->enable;
    1639                 :          0 :         ret = zxdh_set_port_attr(hw, vport, &vport_att);
    1640         [ #  # ]:          0 :         if (ret) {
    1641                 :          0 :                 sprintf(str, "set rss enable (set vport tbl failed, rss_enable is %d). ret:%d\n",
    1642                 :          0 :                                 rss_enable->enable, ret);
    1643                 :          0 :                 PMD_DRV_LOG(ERR, "rss enable set failed");
    1644                 :            :         }
    1645                 :            : 
    1646                 :          0 : proc_end:
    1647                 :          0 :         *res_len = strlen(str) + sizeof(uint8_t);
    1648         [ #  # ]:          0 :         if (ret == 0)
    1649                 :          0 :                 ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
    1650                 :            :         else
    1651                 :          0 :                 ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
    1652                 :          0 :         memcpy(reply_data_addr, str, strlen(str) + 1);
    1653                 :          0 :         return ret;
    1654                 :            : }
    1655                 :            : 
    1656                 :            : static int
    1657                 :          0 : zxdh_vf_rss_table_set(struct zxdh_hw *hw, uint16_t vport, void *cfg_data,
    1658                 :            :                 void *reply, uint16_t *res_len)
    1659                 :            : {
    1660                 :          0 :         char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "rss_table";
    1661                 :            :         struct zxdh_rss_reta *rss_reta = cfg_data;
    1662                 :          0 :         void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply, reply_data);
    1663                 :            :         int32_t ret = 0;
    1664                 :            : 
    1665                 :          0 :         ret = zxdh_rss_table_set(hw, vport, rss_reta);
    1666         [ #  # ]:          0 :         if (ret)
    1667                 :            :                 sprintf(str, "set rss reta tbl failed, code:%d", ret);
    1668                 :            : 
    1669                 :          0 :         *res_len = strlen(str) + sizeof(uint8_t);
    1670         [ #  # ]:          0 :         if (ret == 0)
    1671                 :          0 :                 ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
    1672                 :            :         else
    1673                 :          0 :                 ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
    1674                 :          0 :         memcpy(reply_data_addr, str, strlen(str) + 1);
    1675                 :          0 :         return ret;
    1676                 :            : }
    1677                 :            : 
    1678                 :            : static int
    1679                 :          0 : zxdh_vf_rss_table_get(struct zxdh_hw *hw, uint16_t vport, void *cfg_data __rte_unused,
    1680                 :            :                 void *reply, uint16_t *res_len)
    1681                 :            : {
    1682                 :          0 :         char str[ZXDH_MSG_REPLY_BODY_MAX_LEN] = "rss_table";
    1683                 :          0 :         void *rss_reta_msg_addr = ZXDH_ADDR_OF(msg_reply_body, reply, rss_reta_msg);
    1684                 :            :         struct zxdh_rss_reta *rss_reta = (struct zxdh_rss_reta *)rss_reta_msg_addr;
    1685                 :            :         void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reply, reply_data);
    1686                 :            :         int ret = 0;
    1687                 :            : 
    1688                 :          0 :         ret = zxdh_rss_table_get(hw, vport, rss_reta);
    1689         [ #  # ]:          0 :         if (ret)
    1690                 :            :                 sprintf(str, "set rss reta tbl failed, code:%d", ret);
    1691                 :            : 
    1692                 :          0 :         *res_len = strlen(str) + sizeof(uint8_t);
    1693         [ #  # ]:          0 :         if (ret == 0)
    1694                 :          0 :                 ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_SUCC);
    1695                 :            :         else
    1696                 :          0 :                 ZXDH_SET(msg_reply_body, reply, flag, ZXDH_REPS_FAIL);
    1697                 :          0 :         memcpy(reply_data_addr, str, strlen(str) + 1);
    1698                 :          0 :         return ret;
    1699                 :            : }
    1700                 :            : 
    1701                 :            : static int
    1702                 :          0 : zxdh_vf_port_attr_set(struct zxdh_hw *pf_hw, uint16_t vport, void *cfg_data,
    1703                 :            :         void *res_info, uint16_t *res_len)
    1704                 :            : {
    1705                 :            :         RTE_ASSERT(!cfg_data || !pf_hw);
    1706         [ #  # ]:          0 :         if (res_info)
    1707                 :          0 :                 *res_len = 0;
    1708                 :            :         struct zxdh_port_attr_set_msg *attr_msg = (struct zxdh_port_attr_set_msg *)cfg_data;
    1709                 :            :         union zxdh_virport_num port = {.vport = vport};
    1710                 :          0 :         struct zxdh_port_attr_table port_attr = {0};
    1711                 :            : 
    1712                 :          0 :         int ret = zxdh_get_port_attr(pf_hw, vport, &port_attr);
    1713         [ #  # ]:          0 :         if (ret) {
    1714                 :          0 :                 PMD_DRV_LOG(ERR, "get vport 0x%x(%d) attr failed", vport, port.vfid);
    1715                 :          0 :                 return ret;
    1716                 :            :         }
    1717   [ #  #  #  #  :          0 :         switch (attr_msg->mode) {
          #  #  #  #  #  
                #  #  # ]
    1718                 :          0 :         case ZXDH_PORT_BASE_QID_FLAG:
    1719                 :          0 :                 port_attr.port_base_qid = attr_msg->value;
    1720                 :          0 :                 break;
    1721                 :          0 :         case ZXDH_PORT_MTU_OFFLOAD_EN_OFF_FLAG:
    1722                 :          0 :                 port_attr.mtu_enable = attr_msg->value;
    1723                 :          0 :                 break;
    1724                 :          0 :         case ZXDH_PORT_MTU_FLAG:
    1725                 :          0 :                 port_attr.mtu = attr_msg->value;
    1726                 :          0 :                 break;
    1727                 :          0 :         case ZXDH_PORT_VPORT_IS_UP_FLAG:
    1728                 :          0 :                 port_attr.is_up = attr_msg->value;
    1729                 :          0 :                 break;
    1730                 :          0 :         case ZXDH_PORT_OUTER_IP_CHECKSUM_OFFLOAD_FLAG:
    1731                 :          0 :                 port_attr.outer_ip_checksum_offload = attr_msg->value;
    1732                 :          0 :                 break;
    1733                 :          0 :         case ZXDH_PORT_IP_CHKSUM_FLAG:
    1734                 :          0 :                 port_attr.ip_checksum_offload = attr_msg->value;
    1735                 :          0 :                 break;
    1736                 :          0 :         case ZXDH_PORT_TCP_UDP_CHKSUM_FLAG:
    1737                 :          0 :                 port_attr.tcp_udp_checksum_offload = attr_msg->value;
    1738                 :          0 :                 break;
    1739                 :          0 :         case ZXDH_PORT_ACCELERATOR_OFFLOAD_FLAG_FLAG:
    1740                 :          0 :                 port_attr.accelerator_offload_flag = attr_msg->value;
    1741                 :          0 :                 break;
    1742                 :          0 :         case ZXDH_PORT_LRO_OFFLOAD_FLAG:
    1743                 :          0 :                 port_attr.lro_offload = attr_msg->value;
    1744                 :          0 :                 break;
    1745                 :          0 :         case ZXDH_PORT_EGRESS_METER_EN_OFF_FLAG:
    1746                 :          0 :                 port_attr.egress_meter_enable = attr_msg->value;
    1747                 :          0 :                 break;
    1748                 :          0 :         case ZXDH_PORT_INGRESS_METER_EN_OFF_FLAG:
    1749                 :          0 :                 port_attr.ingress_meter_mode = attr_msg->value;
    1750                 :          0 :                 break;
    1751                 :          0 :         default:
    1752                 :          0 :                 PMD_DRV_LOG(ERR, "unsupported attr 0x%x set", attr_msg->mode);
    1753                 :          0 :                 return -1;
    1754                 :            :         }
    1755                 :          0 :         ret = zxdh_set_port_attr(pf_hw, vport, &port_attr);
    1756         [ #  # ]:          0 :         if (ret) {
    1757                 :          0 :                 PMD_DRV_LOG(ERR, "set port attr failed. code:%d", ret);
    1758                 :          0 :                 return ret;
    1759                 :            :         }
    1760                 :            :         return ret;
    1761                 :            : }
    1762                 :            : 
    1763                 :            : static int
    1764                 :          0 : zxdh_vf_np_stats_update(struct zxdh_hw *pf_hw, uint16_t vport,
    1765                 :            :                 void *cfg_data, void *res_info,
    1766                 :            :                 uint16_t *res_len)
    1767                 :            : {
    1768                 :            :         struct zxdh_np_stats_updata_msg *np_stats_query =
    1769                 :            :                          (struct zxdh_np_stats_updata_msg  *)cfg_data;
    1770                 :          0 :         union zxdh_virport_num vport_num = {.vport = vport};
    1771                 :            :         struct zxdh_hw_stats_data stats_data;
    1772                 :          0 :         uint32_t is_clr = np_stats_query->clear_mode;
    1773                 :            :         uint32_t idx = 0;
    1774                 :            :         int ret = 0;
    1775                 :            : 
    1776                 :          0 :         void *hw_stats_addr = ZXDH_ADDR_OF(msg_reply_body, res_info, hw_stats);
    1777                 :          0 :         void *tx_unicast_pkts_addr =
    1778                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_unicast_pkts);
    1779                 :            :         void *rx_unicast_pkts_addr =
    1780                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_unicast_pkts);
    1781                 :          0 :         void *tx_unicast_bytes_addr =
    1782                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_unicast_bytes);
    1783                 :          0 :         void *rx_unicast_bytes_addr =
    1784                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_unicast_bytes);
    1785                 :          0 :         void *tx_multicast_pkts_addr =
    1786                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_multicast_pkts);
    1787                 :          0 :         void *rx_multicast_pkts_addr =
    1788                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_multicast_pkts);
    1789                 :          0 :         void *tx_multicast_bytes_addr =
    1790                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_multicast_bytes);
    1791                 :          0 :         void *rx_multicast_bytes_addr =
    1792                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_multicast_bytes);
    1793                 :          0 :         void *tx_broadcast_pkts_addr =
    1794                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_broadcast_pkts);
    1795                 :          0 :         void *tx_broadcast_bytes_addr =
    1796                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_broadcast_bytes);
    1797                 :          0 :         void *rx_broadcast_pkts_addr =
    1798                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_broadcast_pkts);
    1799                 :          0 :         void *rx_broadcast_bytes_addr =
    1800                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_broadcast_bytes);
    1801                 :          0 :         void *tx_mtu_drop_pkts_addr =
    1802                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_mtu_drop_pkts);
    1803                 :          0 :         void *tx_mtu_drop_bytes_addr =
    1804                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_mtu_drop_bytes);
    1805                 :          0 :         void *rx_mtu_drop_pkts_addr =
    1806                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_mtu_drop_pkts);
    1807                 :          0 :         void *rx_mtu_drop_bytes_addr =
    1808                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_mtu_drop_bytes);
    1809                 :          0 :         void *tx_mtr_drop_pkts_addr =
    1810                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_mtr_drop_pkts);
    1811                 :          0 :         void *tx_mtr_drop_bytes_addr =
    1812                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, tx_mtr_drop_bytes);
    1813                 :          0 :         void *rx_mtr_drop_pkts_addr =
    1814                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_mtr_drop_pkts);
    1815                 :          0 :         void *rx_mtr_drop_bytes_addr =
    1816                 :            :                 ZXDH_ADDR_OF(hw_np_stats, hw_stats_addr, rx_mtr_drop_bytes);
    1817         [ #  # ]:          0 :         if (!res_len || !res_info) {
    1818                 :          0 :                 PMD_DRV_LOG(ERR, "get stat invalid inparams");
    1819                 :          0 :                 return -1;
    1820                 :            :         }
    1821         [ #  # ]:          0 :         if (is_clr == 1) {
    1822                 :          0 :                 ret = zxdh_hw_np_stats_pf_reset(pf_hw->eth_dev, zxdh_vport_to_vfid(vport_num));
    1823                 :          0 :                 return ret;
    1824                 :            :         }
    1825                 :          0 :         idx = zxdh_vport_to_vfid(vport_num) + ZXDH_UNICAST_STATS_EGRESS_BASE;
    1826                 :          0 :         ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
    1827                 :            :                         0, idx, (uint32_t *)&stats_data);
    1828         [ #  # ]:          0 :         if (ret) {
    1829                 :          0 :                 PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
    1830                 :          0 :                 return ret;
    1831                 :            :         }
    1832                 :          0 :         zxdh_data_hi_to_lo(tx_unicast_pkts_addr);
    1833                 :          0 :         zxdh_data_hi_to_lo(tx_unicast_bytes_addr);
    1834                 :            : 
    1835                 :          0 :         idx = zxdh_vport_to_vfid(vport_num) + ZXDH_UNICAST_STATS_INGRESS_BASE;
    1836                 :            :         memset(&stats_data, 0, sizeof(stats_data));
    1837                 :          0 :         ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
    1838                 :            :                         0, idx, (uint32_t *)&stats_data);
    1839         [ #  # ]:          0 :         if (ret) {
    1840                 :          0 :                 PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
    1841                 :          0 :                 return ret;
    1842                 :            :         }
    1843                 :          0 :         zxdh_data_hi_to_lo(rx_unicast_pkts_addr);
    1844                 :          0 :         zxdh_data_hi_to_lo(rx_unicast_bytes_addr);
    1845                 :            : 
    1846                 :          0 :         idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MULTICAST_STATS_EGRESS_BASE;
    1847                 :          0 :         ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
    1848                 :            :                         0, idx, (uint32_t *)&stats_data);
    1849         [ #  # ]:          0 :         if (ret) {
    1850                 :          0 :                 PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
    1851                 :          0 :                 return ret;
    1852                 :            :         }
    1853                 :          0 :         zxdh_data_hi_to_lo(tx_multicast_pkts_addr);
    1854                 :          0 :         zxdh_data_hi_to_lo(tx_multicast_bytes_addr);
    1855                 :            : 
    1856                 :          0 :         idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MULTICAST_STATS_INGRESS_BASE;
    1857                 :            :         memset(&stats_data, 0, sizeof(stats_data));
    1858                 :          0 :         ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
    1859                 :            :                         0, idx, (uint32_t *)&stats_data);
    1860         [ #  # ]:          0 :         if (ret) {
    1861                 :          0 :                 PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
    1862                 :          0 :                 return ret;
    1863                 :            :         }
    1864                 :          0 :         zxdh_data_hi_to_lo(rx_multicast_pkts_addr);
    1865                 :          0 :         zxdh_data_hi_to_lo(rx_multicast_bytes_addr);
    1866                 :            : 
    1867                 :          0 :         idx = zxdh_vport_to_vfid(vport_num) + ZXDH_BROAD_STATS_EGRESS_BASE;
    1868                 :          0 :         ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
    1869                 :            :                         0, idx, (uint32_t *)&stats_data);
    1870         [ #  # ]:          0 :         if (ret) {
    1871                 :          0 :                 PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
    1872                 :          0 :                 return ret;
    1873                 :            :         }
    1874                 :          0 :         zxdh_data_hi_to_lo(tx_broadcast_pkts_addr);
    1875                 :          0 :         zxdh_data_hi_to_lo(tx_broadcast_bytes_addr);
    1876                 :            : 
    1877                 :          0 :         idx = zxdh_vport_to_vfid(vport_num) + ZXDH_BROAD_STATS_INGRESS_BASE;
    1878                 :            :         memset(&stats_data, 0, sizeof(stats_data));
    1879                 :          0 :         ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
    1880                 :            :                         0, idx, (uint32_t *)&stats_data);
    1881         [ #  # ]:          0 :         if (ret) {
    1882                 :          0 :                 PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
    1883                 :          0 :                 return ret;
    1884                 :            :         }
    1885                 :          0 :         zxdh_data_hi_to_lo(rx_broadcast_pkts_addr);
    1886                 :          0 :         zxdh_data_hi_to_lo(rx_broadcast_bytes_addr);
    1887                 :            : 
    1888                 :          0 :         idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MTU_STATS_EGRESS_BASE;
    1889                 :            :         memset(&stats_data, 0, sizeof(stats_data));
    1890                 :          0 :         ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
    1891                 :            :                         1, idx, (uint32_t *)&stats_data);
    1892         [ #  # ]:          0 :         if (ret) {
    1893                 :          0 :                 PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
    1894                 :          0 :                 return ret;
    1895                 :            :         }
    1896                 :          0 :         ZXDH_SET(hw_np_stats, hw_stats_addr, tx_mtu_drop_pkts, stats_data.n_pkts_dropped);
    1897                 :          0 :         ZXDH_SET(hw_np_stats, hw_stats_addr, tx_mtu_drop_bytes, stats_data.n_bytes_dropped);
    1898                 :          0 :         zxdh_data_hi_to_lo(tx_mtu_drop_pkts_addr);
    1899                 :          0 :         zxdh_data_hi_to_lo(tx_mtu_drop_bytes_addr);
    1900                 :            : 
    1901                 :          0 :         idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MTU_STATS_INGRESS_BASE;
    1902                 :            :         memset(&stats_data, 0, sizeof(stats_data));
    1903                 :          0 :         ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
    1904                 :            :                         1, idx, (uint32_t *)&stats_data);
    1905         [ #  # ]:          0 :         if (ret) {
    1906                 :          0 :                 PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
    1907                 :          0 :                 return ret;
    1908                 :            :         }
    1909                 :          0 :         ZXDH_SET(hw_np_stats, hw_stats_addr, rx_mtu_drop_pkts, stats_data.n_pkts_dropped);
    1910                 :          0 :         ZXDH_SET(hw_np_stats, hw_stats_addr, rx_mtu_drop_bytes, stats_data.n_bytes_dropped);
    1911                 :          0 :         zxdh_data_hi_to_lo(rx_mtu_drop_pkts_addr);
    1912                 :          0 :         zxdh_data_hi_to_lo(rx_mtu_drop_bytes_addr);
    1913                 :            : 
    1914                 :          0 :         idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MTR_STATS_EGRESS_BASE;
    1915                 :            :         memset(&stats_data, 0, sizeof(stats_data));
    1916                 :          0 :         ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
    1917                 :            :                         1, idx, (uint32_t *)&stats_data);
    1918         [ #  # ]:          0 :         if (ret) {
    1919                 :          0 :                 PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
    1920                 :          0 :                 return ret;
    1921                 :            :         }
    1922                 :          0 :         ZXDH_SET(hw_np_stats, hw_stats_addr, tx_mtr_drop_pkts, stats_data.n_pkts_dropped);
    1923                 :          0 :         ZXDH_SET(hw_np_stats, hw_stats_addr, tx_mtr_drop_bytes, stats_data.n_bytes_dropped);
    1924                 :            : 
    1925                 :          0 :         zxdh_data_hi_to_lo(tx_mtr_drop_pkts_addr);
    1926                 :          0 :         zxdh_data_hi_to_lo(tx_mtr_drop_bytes_addr);
    1927                 :            : 
    1928                 :          0 :         idx = zxdh_vport_to_vfid(vport_num) + ZXDH_MTR_STATS_INGRESS_BASE;
    1929                 :            :         memset(&stats_data, 0, sizeof(stats_data));
    1930                 :          0 :         ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
    1931                 :            :                         1, idx, (uint32_t *)&stats_data);
    1932         [ #  # ]:          0 :         if (ret) {
    1933                 :          0 :                 PMD_DRV_LOG(ERR, "get stats failed. code:%d", ret);
    1934                 :          0 :                 return ret;
    1935                 :            :         }
    1936                 :          0 :         ZXDH_SET(hw_np_stats, hw_stats_addr, rx_mtr_drop_pkts, stats_data.n_pkts_dropped);
    1937                 :          0 :         ZXDH_SET(hw_np_stats, hw_stats_addr, rx_mtr_drop_bytes, stats_data.n_bytes_dropped);
    1938                 :            : 
    1939                 :          0 :         zxdh_data_hi_to_lo(rx_mtr_drop_pkts_addr);
    1940                 :          0 :         zxdh_data_hi_to_lo(rx_mtr_drop_bytes_addr);
    1941                 :          0 :         *res_len = sizeof(struct zxdh_hw_np_stats);
    1942                 :            : 
    1943                 :          0 :         return 0;
    1944                 :            : }
    1945                 :            : 
    1946                 :            : static int
    1947                 :          0 : zxdh_vf_mtr_hw_stats_get(struct zxdh_hw *pf_hw,
    1948                 :            :         uint16_t vport, void *cfg_data,
    1949                 :            :         void *res_info,
    1950                 :            :         uint16_t *res_len)
    1951                 :            : {
    1952                 :            :         struct zxdh_mtr_stats_query  *zxdh_mtr_stats_query =
    1953                 :            :                         (struct zxdh_mtr_stats_query  *)cfg_data;
    1954                 :          0 :         union zxdh_virport_num v_port = {.vport = vport};
    1955                 :          0 :         uint8_t *hw_mtr_stats_addr = ZXDH_ADDR_OF(msg_reply_body, res_info, hw_mtr_stats);
    1956                 :            :         int ret = 0;
    1957                 :            : 
    1958                 :          0 :         uint32_t stat_baseaddr = zxdh_mtr_stats_query->direction ==
    1959                 :            :                                 ZXDH_EGRESS ?
    1960         [ #  # ]:          0 :                                 ZXDH_MTR_STATS_EGRESS_BASE : ZXDH_MTR_STATS_INGRESS_BASE;
    1961                 :          0 :         uint32_t idx = zxdh_vport_to_vfid(v_port) + stat_baseaddr;
    1962                 :            : 
    1963         [ #  # ]:          0 :         if (!res_len || !res_info) {
    1964                 :          0 :                 PMD_DRV_LOG(ERR, "get stat invalid in params");
    1965                 :          0 :                 return -1;
    1966                 :            :         }
    1967                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
    1968                 :          0 :         ret = zxdh_np_dtb_stats_get(pf_hw->dev_id, pf_hw->dev_sd->dtb_sd.queueid,
    1969                 :            :                                 1, idx, (uint32_t *)hw_mtr_stats_addr);
    1970         [ #  # ]:          0 :         if (ret) {
    1971                 :          0 :                 PMD_DRV_LOG(ERR, "get dir %d stats  failed", zxdh_mtr_stats_query->direction);
    1972                 :          0 :                 return ret;
    1973                 :            :         }
    1974                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
    1975                 :          0 :         *res_len = sizeof(struct zxdh_hw_mtr_stats);
    1976                 :          0 :         return 0;
    1977                 :            : }
    1978                 :            : 
    1979                 :            : static int
    1980                 :          0 : zxdh_vf_mtr_hw_profile_add(struct zxdh_hw *pf_hw,
    1981                 :            :         uint16_t vport,
    1982                 :            :         void *cfg_data,
    1983                 :            :         void *res_info,
    1984                 :            :         uint16_t *res_len)
    1985                 :            : {
    1986   [ #  #  #  # ]:          0 :         if (!cfg_data || !res_len || !res_info) {
    1987                 :          0 :                 PMD_DRV_LOG(ERR, " get profileid invalid inparams");
    1988                 :          0 :                 return -1;
    1989                 :            :         }
    1990                 :          0 :         struct rte_mtr_error error = {0};
    1991                 :            :         int ret = 0;
    1992                 :          0 :         uint64_t hw_profile_id = HW_PROFILE_MAX;
    1993                 :          0 :         void *mtr_profile_info_addr = ZXDH_ADDR_OF(msg_reply_body, res_info, mtr_profile_info);
    1994                 :            : 
    1995                 :            :         struct zxdh_plcr_profile_add  *zxdh_plcr_profile_add =
    1996                 :            :                 (struct zxdh_plcr_profile_add *)cfg_data;
    1997                 :            : 
    1998                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
    1999                 :            : 
    2000                 :          0 :         *res_len = sizeof(struct zxdh_mtr_profile_info);
    2001                 :          0 :         ret = zxdh_hw_profile_alloc_direct(pf_hw->eth_dev,
    2002                 :          0 :                 zxdh_plcr_profile_add->car_type,
    2003                 :            :                 &hw_profile_id, &error);
    2004                 :            : 
    2005         [ #  # ]:          0 :         if (ret) {
    2006                 :          0 :                 PMD_DRV_LOG(ERR, "pf 0x%x for vf 0x%x alloc hw profile failed",
    2007                 :            :                         pf_hw->vport.vport,
    2008                 :            :                         vport
    2009                 :            :                 );
    2010                 :          0 :                 return -1;
    2011                 :            :         }
    2012                 :          0 :         zxdh_hw_profile_ref(hw_profile_id);
    2013                 :          0 :         ZXDH_SET(mtr_profile_info, mtr_profile_info_addr, profile_id, hw_profile_id);
    2014                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
    2015                 :            : 
    2016                 :          0 :         return 0;
    2017                 :            : }
    2018                 :            : 
    2019                 :            : static int
    2020                 :          0 : zxdh_vf_mtr_hw_profile_del(struct zxdh_hw *pf_hw,
    2021                 :            :         uint16_t vport,
    2022                 :            :         void *cfg_data,
    2023                 :            :         void *res_info,
    2024                 :            :         uint16_t *res_len)
    2025                 :            : {
    2026   [ #  #  #  # ]:          0 :         if (!cfg_data || !res_len || !res_info) {
    2027                 :          0 :                 PMD_DRV_LOG(ERR, " del profileid  invalid inparams");
    2028                 :          0 :                 return -1;
    2029                 :            :         }
    2030                 :            : 
    2031                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
    2032                 :          0 :         *res_len = 0;
    2033                 :            :         struct zxdh_plcr_profile_free *mtr_profile_free = (struct zxdh_plcr_profile_free *)cfg_data;
    2034                 :          0 :         uint64_t profile_id = mtr_profile_free->profile_id;
    2035                 :          0 :         struct rte_mtr_error error = {0};
    2036                 :            :         int ret;
    2037                 :            : 
    2038         [ #  # ]:          0 :         if (profile_id >= HW_PROFILE_MAX) {
    2039                 :          0 :                 PMD_DRV_LOG(ERR, " del profileid  invalid inparams");
    2040                 :          0 :                 return -rte_mtr_error_set(&error, ENOTSUP,
    2041                 :            :                                 RTE_MTR_ERROR_TYPE_METER_PROFILE_ID, NULL,
    2042                 :            :                                 "Meter offload del profile failed  profilie id invalid ");
    2043                 :            :         }
    2044                 :            : 
    2045                 :          0 :         ret = zxdh_hw_profile_unref(pf_hw->eth_dev, mtr_profile_free->car_type, profile_id, &error);
    2046         [ #  # ]:          0 :         if (ret) {
    2047                 :          0 :                 PMD_DRV_LOG(ERR,
    2048                 :            :                         " del  hw vport %d profile %d failed. code:%d",
    2049                 :            :                         vport,
    2050                 :            :                         mtr_profile_free->profile_id,
    2051                 :            :                         ret
    2052                 :            :                 );
    2053                 :          0 :                 return -rte_mtr_error_set(&error, ENOTSUP,
    2054                 :            :                                 RTE_MTR_ERROR_TYPE_METER_PROFILE_ID, NULL,
    2055                 :            :                                 "Meter offload del profile failed ");
    2056                 :            :         }
    2057                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
    2058                 :          0 :         return 0;
    2059                 :            : }
    2060                 :            : 
    2061                 :            : static int
    2062                 :          0 : zxdh_vf_mtr_hw_plcrflow_cfg(struct zxdh_hw *pf_hw,
    2063                 :            :         uint16_t vport,
    2064                 :            :         void *cfg_data,
    2065                 :            :         void *res_info,
    2066                 :            :         uint16_t *res_len)
    2067                 :            : {
    2068                 :            :         int ret = 0;
    2069                 :            : 
    2070   [ #  #  #  # ]:          0 :         if (!cfg_data || !res_info || !res_len) {
    2071                 :          0 :                 PMD_DRV_LOG(ERR, " (vport %d) flow bind failed invalid inparams", vport);
    2072                 :          0 :                 return -1;
    2073                 :            :         }
    2074                 :            :         struct rte_mtr_error error = {0};
    2075                 :            :         struct zxdh_plcr_flow_cfg *zxdh_plcr_flow_cfg = (struct zxdh_plcr_flow_cfg *)cfg_data;
    2076                 :            : 
    2077                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
    2078                 :          0 :         *res_len = 0;
    2079                 :          0 :         ret = zxdh_np_stat_car_queue_cfg_set(pf_hw->dev_id,
    2080                 :          0 :                 zxdh_plcr_flow_cfg->car_type,
    2081                 :          0 :                 zxdh_plcr_flow_cfg->flow_id,
    2082                 :          0 :                 zxdh_plcr_flow_cfg->drop_flag,
    2083                 :          0 :                 zxdh_plcr_flow_cfg->plcr_en,
    2084                 :          0 :                 (uint64_t)zxdh_plcr_flow_cfg->profile_id);
    2085         [ #  # ]:          0 :         if (ret) {
    2086                 :          0 :                 PMD_DRV_LOG(ERR,
    2087                 :            :                         " dpp_stat_car_queue_cfg_set failed flowid %d      profile id %d. code:%d",
    2088                 :            :                         zxdh_plcr_flow_cfg->flow_id,
    2089                 :            :                         zxdh_plcr_flow_cfg->profile_id,
    2090                 :            :                         ret
    2091                 :            :                 );
    2092                 :          0 :                 return -rte_mtr_error_set(&error, ENOTSUP,
    2093                 :            :                                 RTE_MTR_ERROR_TYPE_MTR_PARAMS,
    2094                 :            :                                 NULL, "Failed to bind plcr flow.");
    2095                 :            :         }
    2096                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
    2097                 :          0 :         return 0;
    2098                 :            : }
    2099                 :            : 
    2100                 :            : static int
    2101                 :          0 : zxdh_vf_mtr_hw_profile_cfg(struct zxdh_hw *pf_hw __rte_unused,
    2102                 :            :         uint16_t vport,
    2103                 :            :         void *cfg_data,
    2104                 :            :         void *res_info,
    2105                 :            :         uint16_t *res_len)
    2106                 :            : {
    2107                 :            :         int ret = 0;
    2108                 :            : 
    2109   [ #  #  #  # ]:          0 :         if (!cfg_data || !res_info || !res_len) {
    2110                 :          0 :                 PMD_DRV_LOG(ERR, " cfg profile invalid inparams");
    2111                 :          0 :                 return -1;
    2112                 :            :         }
    2113                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_FAIL);
    2114                 :          0 :         *res_len = 0;
    2115                 :            :         struct rte_mtr_error error = {0};
    2116                 :            :         struct zxdh_plcr_profile_cfg *zxdh_plcr_profile_cfg =
    2117                 :            :                 (struct zxdh_plcr_profile_cfg *)cfg_data;
    2118                 :          0 :         union zxdh_offload_profile_cfg *plcr_param = &zxdh_plcr_profile_cfg->plcr_param;
    2119                 :            : 
    2120                 :          0 :         ret = zxdh_np_car_profile_cfg_set(pf_hw->dev_id,
    2121                 :            :                 vport,
    2122                 :          0 :                 zxdh_plcr_profile_cfg->car_type,
    2123                 :          0 :                 zxdh_plcr_profile_cfg->packet_mode,
    2124                 :          0 :                 zxdh_plcr_profile_cfg->hw_profile_id,
    2125                 :            :                 plcr_param);
    2126         [ #  # ]:          0 :         if (ret) {
    2127                 :          0 :                 PMD_DRV_LOG(ERR, "(vport %d)config hw profilefailed", vport);
    2128                 :          0 :                 return -rte_mtr_error_set(&error, ENOTSUP, RTE_MTR_ERROR_TYPE_METER_PROFILE, NULL, "Meter offload cfg profile failed");
    2129                 :            :         }
    2130                 :          0 :         ZXDH_SET(msg_reply_body, res_info, flag, ZXDH_REPS_SUCC);
    2131                 :          0 :         return 0;
    2132                 :            : }
    2133                 :            : 
    2134                 :            : static const zxdh_msg_process_callback zxdh_proc_cb[] = {
    2135                 :            :         [ZXDH_NULL] = NULL,
    2136                 :            :         [ZXDH_VF_PORT_INIT] = zxdh_vf_port_init,
    2137                 :            :         [ZXDH_VF_PORT_UNINIT] = zxdh_vf_port_uninit,
    2138                 :            :         [ZXDH_MAC_ADD] = zxdh_add_vf_mac_table,
    2139                 :            :         [ZXDH_MAC_DEL] = zxdh_del_vf_mac_table,
    2140                 :            :         [ZXDH_PORT_PROMISC_SET] = zxdh_vf_promisc_set,
    2141                 :            :         [ZXDH_VLAN_FILTER_SET] = zxdh_vf_set_vlan_filter,
    2142                 :            :         [ZXDH_VLAN_FILTER_ADD] = zxdh_vf_vlan_filter_table_add,
    2143                 :            :         [ZXDH_VLAN_FILTER_DEL] = zxdh_vf_vlan_filter_table_del,
    2144                 :            :         [ZXDH_VLAN_OFFLOAD] = zxdh_vf_set_vlan_offload,
    2145                 :            :         [ZXDH_RSS_ENABLE] = zxdh_vf_rss_enable,
    2146                 :            :         [ZXDH_RSS_RETA_GET] = zxdh_vf_rss_table_get,
    2147                 :            :         [ZXDH_RSS_RETA_SET] = zxdh_vf_rss_table_set,
    2148                 :            :         [ZXDH_RSS_HF_SET] = zxdh_vf_rss_hf_set,
    2149                 :            :         [ZXDH_RSS_HF_GET] = zxdh_vf_rss_hf_get,
    2150                 :            :         [ZXDH_PORT_ATTRS_SET] = zxdh_vf_port_attr_set,
    2151                 :            :         [ZXDH_GET_NP_STATS] = zxdh_vf_np_stats_update,
    2152                 :            :         [ZXDH_PORT_METER_STAT_GET] = zxdh_vf_mtr_hw_stats_get,
    2153                 :            :         [ZXDH_PLCR_CAR_PROFILE_ID_ADD] = zxdh_vf_mtr_hw_profile_add,
    2154                 :            :         [ZXDH_PLCR_CAR_PROFILE_ID_DELETE] =  zxdh_vf_mtr_hw_profile_del,
    2155                 :            :         [ZXDH_PLCR_CAR_QUEUE_CFG_SET] = zxdh_vf_mtr_hw_plcrflow_cfg,
    2156                 :            :         [ZXDH_PLCR_CAR_PROFILE_CFG_SET] = zxdh_vf_mtr_hw_profile_cfg,
    2157                 :            : };
    2158                 :            : 
    2159                 :            : static inline int
    2160                 :          0 : zxdh_config_process_callback(struct zxdh_hw *hw, struct zxdh_msg_info *msg_info,
    2161                 :            :         void *res, uint16_t *res_len)
    2162                 :            : {
    2163                 :            :         struct zxdh_msg_head *msghead = &msg_info->msg_head;
    2164                 :            :         int ret = -1;
    2165                 :            : 
    2166         [ #  # ]:          0 :         if (!res || !res_len) {
    2167                 :          0 :                 PMD_DRV_LOG(ERR, " invalid param");
    2168                 :          0 :                 return -1;
    2169                 :            :         }
    2170         [ #  # ]:          0 :         if (zxdh_proc_cb[msghead->msg_type]) {
    2171                 :          0 :                 ret = zxdh_proc_cb[msghead->msg_type](hw, msghead->vport,
    2172                 :          0 :                                         (void *)&msg_info->data, res, res_len);
    2173         [ #  # ]:          0 :                 if (!ret)
    2174                 :          0 :                         ZXDH_SET(msg_reply_body, res, flag, ZXDH_REPS_SUCC);
    2175                 :            :                 else
    2176                 :          0 :                         ZXDH_SET(msg_reply_body, res, flag, ZXDH_REPS_FAIL);
    2177                 :            :         } else {
    2178                 :          0 :                 ZXDH_SET(msg_reply_body, res, flag, ZXDH_REPS_INVALID);
    2179                 :            :         }
    2180                 :          0 :         *res_len += sizeof(uint8_t);
    2181                 :          0 :         return ret;
    2182                 :            : }
    2183                 :            : 
    2184                 :            : static int
    2185                 :          0 : pf_recv_bar_msg(void *pay_load, uint16_t len, void *reps_buffer,
    2186                 :            :         uint16_t *reps_len, void *eth_dev)
    2187                 :            : {
    2188                 :            :         struct zxdh_msg_info *msg_info = (struct zxdh_msg_info *)pay_load;
    2189                 :          0 :         void *reply_data_addr = ZXDH_ADDR_OF(msg_reply_body, reps_buffer, reply_data);
    2190                 :            :         struct rte_eth_dev *dev = (struct rte_eth_dev *)eth_dev;
    2191                 :          0 :         int32_t ret = 0;
    2192                 :            :         struct zxdh_hw *hw;
    2193                 :          0 :         uint16_t reply_len = 0;
    2194                 :            : 
    2195         [ #  # ]:          0 :         if (eth_dev == NULL) {
    2196                 :          0 :                 PMD_DRV_LOG(ERR, "param invalid, dev is null.");
    2197                 :          0 :                 ret = -2;
    2198                 :          0 :                 goto msg_proc_end;
    2199                 :            :         }
    2200                 :          0 :         hw = dev->data->dev_private;
    2201                 :            : 
    2202         [ #  # ]:          0 :         if (msg_info->msg_head.msg_type >= ZXDH_MSG_TYPE_END) {
    2203                 :          0 :                 PMD_DRV_LOG(ERR, "len %u msg_type %d unsupported",
    2204                 :            :                         len, msg_info->msg_head.msg_type);
    2205                 :          0 :                 ret = -2;
    2206                 :          0 :                 goto msg_proc_end;
    2207                 :            :         }
    2208                 :            : 
    2209                 :          0 :         ret = zxdh_config_process_callback(hw, msg_info, reps_buffer, &reply_len);
    2210                 :          0 :         *reps_len = reply_len + ZXDH_ST_SZ_BYTES(msg_reply_head);
    2211                 :          0 :         return ret;
    2212                 :            : 
    2213                 :          0 : msg_proc_end:
    2214                 :            :         memcpy(reply_data_addr, &ret, sizeof(ret));
    2215                 :            :         reply_len = sizeof(ret);
    2216                 :          0 :         *reps_len = ZXDH_ST_SZ_BYTES(msg_reply_head) + reply_len;
    2217                 :          0 :         return ret;
    2218                 :            : }
    2219                 :            : 
    2220                 :            : void
    2221                 :          0 : zxdh_msg_cb_reg(struct zxdh_hw *hw)
    2222                 :            : {
    2223         [ #  # ]:          0 :         if (hw->is_pf)
    2224                 :          0 :                 zxdh_bar_chan_msg_recv_register(ZXDH_MODULE_BAR_MSG_TO_PF, pf_recv_bar_msg);
    2225                 :          0 : }

Generated by: LCOV version 1.14