src/plugins/dev_iavf/virtchnl_funcs.h

   1 /* SPDX-License-Identifier: Apache-2.0
   2  * Copyright (c) 2023 Cisco Systems, Inc.
   3  */
   4
   5 #ifndef _IIAVF_VIRTCHNL_FUNCS_H_
   6 #define _IIAVF_VIRTCHNL_FUNCS_H_
   7
   8 #include <vppinfra/clib.h>
   9 #include <vnet/dev/dev.h>
  10 #include <dev_iavf/iavf.h>
  11
  12 #define VIRTCHNL_MSG_SZ(s, e, n) STRUCT_OFFSET_OF (s, e[(n) + 1])
  13
  14 typedef struct
  15 {
  16   virtchnl_op_t op;
  17   u8 no_reply : 1;
  18   u16 req_sz;
  19   u16 resp_sz;
  20   virtchnl_status_t status;
  21   const void *req;
  22   void *resp;
  23 } iavf_virtchnl_req_t;
  24
  25 vnet_dev_rv_t iavf_virtchnl_req (vlib_main_t *, vnet_dev_t *,
  26                                  iavf_virtchnl_req_t *);
  27
  28 static_always_inline vnet_dev_rv_t
  29 iavf_vc_op_version (vlib_main_t *vm, vnet_dev_t *dev,
  30                     const virtchnl_version_info_t *req,
  31                     virtchnl_version_info_t *resp)
  32 {
  33   iavf_virtchnl_req_t vr = {
  34     .op = VIRTCHNL_OP_VERSION,
  35     .req = req,
  36     .req_sz = sizeof (*req),
  37     .resp = resp,
  38     .resp_sz = sizeof (*resp),
  39   };
  40
  41   return iavf_virtchnl_req (vm, dev, &vr);
  42 }
  43
  44 static_always_inline vnet_dev_rv_t
  45 iavf_vc_op_reset_vf (vlib_main_t *vm, vnet_dev_t *dev)
  46 {
  47   iavf_virtchnl_req_t vr = {
  48     .op = VIRTCHNL_OP_RESET_VF,
  49     .no_reply = 1,
  50   };
  51
  52   return iavf_virtchnl_req (vm, dev, &vr);
  53 }
  54
  55 static_always_inline vnet_dev_rv_t
  56 iavf_vc_op_get_vf_resources (vlib_main_t *vm, vnet_dev_t *dev, const u32 *req,
  57                              virtchnl_vf_resource_t *resp)
  58 {
  59   iavf_virtchnl_req_t vr = {
  60     .op = VIRTCHNL_OP_GET_VF_RESOURCES,
  61     .req = req,
  62     .req_sz = sizeof (*req),
  63     .resp = resp,
  64     .resp_sz = sizeof (*resp),
  65   };
  66
  67   return iavf_virtchnl_req (vm, dev, &vr);
  68 }
  69
  70 static_always_inline vnet_dev_rv_t
  71 iavf_vc_op_enable_queues (vlib_main_t *vm, vnet_dev_t *dev,
  72                           const virtchnl_queue_select_t *req)
  73 {
  74   iavf_virtchnl_req_t vr = {
  75     .op = VIRTCHNL_OP_ENABLE_QUEUES,
  76     .req = req,
  77     .req_sz = sizeof (*req),
  78   };
  79   return iavf_virtchnl_req (vm, dev, &vr);
  80 }
  81
  82 static_always_inline vnet_dev_rv_t
  83 iavf_vc_op_disable_queues (vlib_main_t *vm, vnet_dev_t *dev,
  84                            const virtchnl_queue_select_t *req)
  85 {
  86   iavf_virtchnl_req_t vr = {
  87     .op = VIRTCHNL_OP_DISABLE_QUEUES,
  88     .req = req,
  89     .req_sz = sizeof (*req),
  90   };
  91   return iavf_virtchnl_req (vm, dev, &vr);
  92 }
  93
  94 static_always_inline vnet_dev_rv_t
  95 iavf_vc_op_config_vsi_queues (vlib_main_t *vm, vnet_dev_t *dev,
  96                               const virtchnl_vsi_queue_config_info_t *req)
  97 {
  98   iavf_virtchnl_req_t vr = {
  99     .op = VIRTCHNL_OP_CONFIG_VSI_QUEUES,
 100     .req = req,
 101     .req_sz = VIRTCHNL_MSG_SZ (virtchnl_vsi_queue_config_info_t, qpair,
 102                                req->num_queue_pairs),
 103   };
 104
 105   return iavf_virtchnl_req (vm, dev, &vr);
 106 }
 107
 108 static_always_inline vnet_dev_rv_t
 109 iavf_vc_op_config_irq_map (vlib_main_t *vm, vnet_dev_t *dev,
 110                            const virtchnl_irq_map_info_t *req)
 111 {
 112   iavf_virtchnl_req_t vr = {
 113     .op = VIRTCHNL_OP_CONFIG_IRQ_MAP,
 114     .req = req,
 115     .req_sz =
 116       VIRTCHNL_MSG_SZ (virtchnl_irq_map_info_t, vecmap, req->num_vectors),
 117   };
 118
 119   return iavf_virtchnl_req (vm, dev, &vr);
 120 }
 121
 122 static_always_inline vnet_dev_rv_t
 123 iavf_vc_op_config_rss_lut (vlib_main_t *vm, vnet_dev_t *dev,
 124                            const virtchnl_rss_lut_t *req)
 125 {
 126   iavf_virtchnl_req_t vr = {
 127     .op = VIRTCHNL_OP_CONFIG_RSS_LUT,
 128     .req = req,
 129     .req_sz = VIRTCHNL_MSG_SZ (virtchnl_rss_lut_t, lut, req->lut_entries),
 130   };
 131
 132   return iavf_virtchnl_req (vm, dev, &vr);
 133 }
 134
 135 static_always_inline vnet_dev_rv_t
 136 iavf_vc_op_config_rss_key (vlib_main_t *vm, vnet_dev_t *dev,
 137                            const virtchnl_rss_key_t *req)
 138 {
 139   iavf_virtchnl_req_t vr = {
 140     .op = VIRTCHNL_OP_CONFIG_RSS_KEY,
 141     .req = req,
 142     .req_sz = VIRTCHNL_MSG_SZ (virtchnl_rss_key_t, key, req->key_len),
 143   };
 144
 145   return iavf_virtchnl_req (vm, dev, &vr);
 146 }
 147
 148 static_always_inline vnet_dev_rv_t
 149 iavf_vc_op_config_promisc_mode (vlib_main_t *vm, vnet_dev_t *dev,
 150                                 const virtchnl_promisc_info_t *req)
 151 {
 152   iavf_virtchnl_req_t vr = {
 153     .op = VIRTCHNL_OP_CONFIG_PROMISCUOUS_MODE,
 154     .req = req,
 155     .req_sz = sizeof (*req),
 156   };
 157
 158   return iavf_virtchnl_req (vm, dev, &vr);
 159 }
 160
 161 static_always_inline vnet_dev_rv_t
 162 iavf_vc_op_disable_vlan_stripping (vlib_main_t *vm, vnet_dev_t *dev)
 163 {
 164   iavf_virtchnl_req_t vr = {
 165     .op = VIRTCHNL_OP_DISABLE_VLAN_STRIPPING,
 166   };
 167
 168   return iavf_virtchnl_req (vm, dev, &vr);
 169 }
 170
 171 static_always_inline vnet_dev_rv_t
 172 iavf_vc_op_add_eth_addr (vlib_main_t *vm, vnet_dev_t *dev,
 173                          const virtchnl_ether_addr_list_t *req)
 174 {
 175   iavf_virtchnl_req_t vr = {
 176     .op = VIRTCHNL_OP_ADD_ETH_ADDR,
 177     .req = req,
 178     .req_sz =
 179       VIRTCHNL_MSG_SZ (virtchnl_ether_addr_list_t, list, req->num_elements),
 180   };
 181
 182   return iavf_virtchnl_req (vm, dev, &vr);
 183 }
 184
 185 static_always_inline vnet_dev_rv_t
 186 iavf_vc_op_del_eth_addr (vlib_main_t *vm, vnet_dev_t *dev,
 187                          const virtchnl_ether_addr_list_t *req)
 188 {
 189   iavf_virtchnl_req_t vr = {
 190     .op = VIRTCHNL_OP_DEL_ETH_ADDR,
 191     .req = req,
 192     .req_sz =
 193       VIRTCHNL_MSG_SZ (virtchnl_ether_addr_list_t, list, req->num_elements),
 194   };
 195
 196   return iavf_virtchnl_req (vm, dev, &vr);
 197 }
 198
 199 static_always_inline vnet_dev_rv_t
 200 iavf_vc_op_get_offload_vlan_v2_caps (vlib_main_t *vm, vnet_dev_t *dev,
 201                                      virtchnl_vlan_caps_t *resp)
 202 {
 203   iavf_virtchnl_req_t vr = {
 204     .op = VIRTCHNL_OP_GET_OFFLOAD_VLAN_V2_CAPS,
 205     .resp = resp,
 206     .resp_sz = sizeof (*resp),
 207   };
 208
 209   return iavf_virtchnl_req (vm, dev, &vr);
 210 }
 211
 212 static_always_inline vnet_dev_rv_t
 213 iavf_vc_op_get_stats (vlib_main_t *vm, vnet_dev_t *dev,
 214                       const virtchnl_queue_select_t *req,
 215                       virtchnl_eth_stats_t *resp)
 216 {
 217   iavf_virtchnl_req_t vr = {
 218     .op = VIRTCHNL_OP_GET_STATS,
 219     .req = req,
 220     .req_sz = sizeof (*req),
 221     .resp = resp,
 222     .resp_sz = sizeof (*resp),
 223   };
 224
 225   return iavf_virtchnl_req (vm, dev, &vr);
 226 }
 227
 228 static_always_inline vnet_dev_rv_t
 229 iavf_vc_op_disable_vlan_stripping_v2 (vlib_main_t *vm, vnet_dev_t *dev,
 230                                       const virtchnl_vlan_setting_t *req)
 231 {
 232   iavf_virtchnl_req_t vr = {
 233     .op = VIRTCHNL_OP_DISABLE_VLAN_STRIPPING_V2,
 234     .req = req,
 235     .req_sz = sizeof (*req),
 236   };
 237
 238   return iavf_virtchnl_req (vm, dev, &vr);
 239 }
 240
 241 #endif /* _IIAVF_VIRTCHNL_FUNCS_H_ */