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

Generated by: LCOV version 1.14