drivers/net/ethernet/intel/ice/ice_vf_lib.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /* Copyright (C) 2018-2021, Intel Corporation. */
   3
   4 #ifndef _ICE_VF_LIB_H_
   5 #define _ICE_VF_LIB_H_
   6
   7 #include <linux/types.h>
   8 #include <linux/hashtable.h>
   9 #include <linux/bitmap.h>
  10 #include <linux/mutex.h>
  11 #include <linux/pci.h>
  12 #include <net/devlink.h>
  13 #include <linux/avf/virtchnl.h>
  14 #include "ice_type.h"
  15 #include "ice_virtchnl_fdir.h"
  16 #include "ice_vsi_vlan_ops.h"
  17
  18 #define ICE_MAX_SRIOV_VFS               256
  19
  20 /* VF resource constraints */
  21 #define ICE_MAX_RSS_QS_PER_VF   16
  22
  23 struct ice_pf;
  24 struct ice_vf;
  25 struct ice_virtchnl_ops;
  26
  27 /* VF capabilities */
  28 enum ice_virtchnl_cap {
  29         ICE_VIRTCHNL_VF_CAP_PRIVILEGE = 0,
  30 };
  31
  32 /* Specific VF states */
  33 enum ice_vf_states {
  34         ICE_VF_STATE_INIT = 0,          /* PF is initializing VF */
  35         ICE_VF_STATE_ACTIVE,            /* VF resources are allocated for use */
  36         ICE_VF_STATE_QS_ENA,            /* VF queue(s) enabled */
  37         ICE_VF_STATE_DIS,
  38         ICE_VF_STATE_MC_PROMISC,
  39         ICE_VF_STATE_UC_PROMISC,
  40         ICE_VF_STATES_NBITS
  41 };
  42
  43 struct ice_time_mac {
  44         unsigned long time_modified;
  45         u8 addr[ETH_ALEN];
  46 };
  47
  48 /* VF MDD events print structure */
  49 struct ice_mdd_vf_events {
  50         u16 count;                      /* total count of Rx|Tx events */
  51         /* count number of the last printed event */
  52         u16 last_printed;
  53 };
  54
  55 /* VF operations */
  56 struct ice_vf_ops {
  57         enum ice_disq_rst_src reset_type;
  58         void (*free)(struct ice_vf *vf);
  59         void (*clear_reset_state)(struct ice_vf *vf);
  60         void (*clear_mbx_register)(struct ice_vf *vf);
  61         void (*trigger_reset_register)(struct ice_vf *vf, bool is_vflr);
  62         bool (*poll_reset_status)(struct ice_vf *vf);
  63         void (*clear_reset_trigger)(struct ice_vf *vf);
  64         void (*irq_close)(struct ice_vf *vf);
  65         int (*create_vsi)(struct ice_vf *vf);
  66         void (*post_vsi_rebuild)(struct ice_vf *vf);
  67 };
  68
  69 /* Virtchnl/SR-IOV config info */
  70 struct ice_vfs {
  71         DECLARE_HASHTABLE(table, 8);    /* table of VF entries */
  72         struct mutex table_lock;        /* Lock for protecting the hash table */
  73         u16 num_supported;              /* max supported VFs on this PF */
  74         u16 num_qps_per;                /* number of queue pairs per VF */
  75         u16 num_msix_per;               /* default MSI-X vectors per VF */
  76         unsigned long last_printed_mdd_jiffies; /* MDD message rate limit */
  77 };
  78
  79 /* VF information structure */
  80 struct ice_vf {
  81         struct hlist_node entry;
  82         struct rcu_head rcu;
  83         struct kref refcnt;
  84         struct ice_pf *pf;
  85         struct pci_dev *vfdev;
  86         /* Used during virtchnl message handling and NDO ops against the VF
  87          * that will trigger a VFR
  88          */
  89         struct mutex cfg_lock;
  90
  91         u16 vf_id;                      /* VF ID in the PF space */
  92         u16 lan_vsi_idx;                /* index into PF struct */
  93         u16 ctrl_vsi_idx;
  94         struct ice_vf_fdir fdir;
  95         /* first vector index of this VF in the PF space */
  96         int first_vector_idx;
  97         struct ice_sw *vf_sw_id;        /* switch ID the VF VSIs connect to */
  98         struct virtchnl_version_info vf_ver;
  99         u32 driver_caps;                /* reported by VF driver */
 100         u8 dev_lan_addr[ETH_ALEN];
 101         u8 hw_lan_addr[ETH_ALEN];
 102         struct ice_time_mac legacy_last_added_umac;
 103         DECLARE_BITMAP(txq_ena, ICE_MAX_RSS_QS_PER_VF);
 104         DECLARE_BITMAP(rxq_ena, ICE_MAX_RSS_QS_PER_VF);
 105         struct ice_vlan port_vlan_info; /* Port VLAN ID, QoS, and TPID */
 106         struct virtchnl_vlan_caps vlan_v2_caps;
 107         struct ice_mbx_vf_info mbx_info;
 108         u8 pf_set_mac:1;                /* VF MAC address set by VMM admin */
 109         u8 trusted:1;
 110         u8 spoofchk:1;
 111         u8 link_forced:1;
 112         u8 link_up:1;                   /* only valid if VF link is forced */
 113         /* VSI indices - actual VSI pointers are maintained in the PF structure
 114          * When assigned, these will be non-zero, because VSI 0 is always
 115          * the main LAN VSI for the PF.
 116          */
 117         u16 lan_vsi_num;                /* ID as used by firmware */
 118         unsigned int min_tx_rate;       /* Minimum Tx bandwidth limit in Mbps */
 119         unsigned int max_tx_rate;       /* Maximum Tx bandwidth limit in Mbps */
 120         DECLARE_BITMAP(vf_states, ICE_VF_STATES_NBITS); /* VF runtime states */
 121
 122         unsigned long vf_caps;          /* VF's adv. capabilities */
 123         u8 num_req_qs;                  /* num of queue pairs requested by VF */
 124         u16 num_mac;
 125         u16 num_vf_qs;                  /* num of queue configured per VF */
 126         u8 vlan_strip_ena;              /* Outer and Inner VLAN strip enable */
 127 #define ICE_INNER_VLAN_STRIP_ENA        BIT(0)
 128 #define ICE_OUTER_VLAN_STRIP_ENA        BIT(1)
 129         struct ice_mdd_vf_events mdd_rx_events;
 130         struct ice_mdd_vf_events mdd_tx_events;
 131         DECLARE_BITMAP(opcodes_allowlist, VIRTCHNL_OP_MAX);
 132
 133         unsigned long repr_id;
 134         const struct ice_virtchnl_ops *virtchnl_ops;
 135         const struct ice_vf_ops *vf_ops;
 136
 137         /* devlink port data */
 138         struct devlink_port devlink_port;
 139
 140         u16 num_msix;                   /* num of MSI-X configured on this VF */
 141 };
 142
 143 /* Flags for controlling behavior of ice_reset_vf */
 144 enum ice_vf_reset_flags {
 145         ICE_VF_RESET_VFLR = BIT(0), /* Indicate a VFLR reset */
 146         ICE_VF_RESET_NOTIFY = BIT(1), /* Notify VF prior to reset */
 147         ICE_VF_RESET_LOCK = BIT(2), /* Acquire the VF cfg_lock */
 148 };
 149
 150 static inline u16 ice_vf_get_port_vlan_id(struct ice_vf *vf)
 151 {
 152         return vf->port_vlan_info.vid;
 153 }
 154
 155 static inline u8 ice_vf_get_port_vlan_prio(struct ice_vf *vf)
 156 {
 157         return vf->port_vlan_info.prio;
 158 }
 159
 160 static inline bool ice_vf_is_port_vlan_ena(struct ice_vf *vf)
 161 {
 162         return (ice_vf_get_port_vlan_id(vf) || ice_vf_get_port_vlan_prio(vf));
 163 }
 164
 165 static inline u16 ice_vf_get_port_vlan_tpid(struct ice_vf *vf)
 166 {
 167         return vf->port_vlan_info.tpid;
 168 }
 169
 170 /* VF Hash Table access functions
 171  *
 172  * These functions provide abstraction for interacting with the VF hash table.
 173  * In general, direct access to the hash table should be avoided outside of
 174  * these functions where possible.
 175  *
 176  * The VF entries in the hash table are protected by reference counting to
 177  * track lifetime of accesses from the table. The ice_get_vf_by_id() function
 178  * obtains a reference to the VF structure which must be dropped by using
 179  * ice_put_vf().
 180  */
 181
 182 /**
 183  * ice_for_each_vf - Iterate over each VF entry
 184  * @pf: pointer to the PF private structure
 185  * @bkt: bucket index used for iteration
 186  * @vf: pointer to the VF entry currently being processed in the loop
 187  *
 188  * The bkt variable is an unsigned integer iterator used to traverse the VF
 189  * entries. It is *not* guaranteed to be the VF's vf_id. Do not assume it is.
 190  * Use vf->vf_id to get the id number if needed.
 191  *
 192  * The caller is expected to be under the table_lock mutex for the entire
 193  * loop. Use this iterator if your loop is long or if it might sleep.
 194  */
 195 #define ice_for_each_vf(pf, bkt, vf) \
 196         hash_for_each((pf)->vfs.table, (bkt), (vf), entry)
 197
 198 /**
 199  * ice_for_each_vf_rcu - Iterate over each VF entry protected by RCU
 200  * @pf: pointer to the PF private structure
 201  * @bkt: bucket index used for iteration
 202  * @vf: pointer to the VF entry currently being processed in the loop
 203  *
 204  * The bkt variable is an unsigned integer iterator used to traverse the VF
 205  * entries. It is *not* guaranteed to be the VF's vf_id. Do not assume it is.
 206  * Use vf->vf_id to get the id number if needed.
 207  *
 208  * The caller is expected to be under rcu_read_lock() for the entire loop.
 209  * Only use this iterator if your loop is short and you can guarantee it does
 210  * not sleep.
 211  */
 212 #define ice_for_each_vf_rcu(pf, bkt, vf) \
 213         hash_for_each_rcu((pf)->vfs.table, (bkt), (vf), entry)
 214
 215 #ifdef CONFIG_PCI_IOV
 216 struct ice_vf *ice_get_vf_by_id(struct ice_pf *pf, u16 vf_id);
 217 void ice_put_vf(struct ice_vf *vf);
 218 bool ice_has_vfs(struct ice_pf *pf);
 219 u16 ice_get_num_vfs(struct ice_pf *pf);
 220 struct ice_vsi *ice_get_vf_vsi(struct ice_vf *vf);
 221 bool ice_is_vf_disabled(struct ice_vf *vf);
 222 int ice_check_vf_ready_for_cfg(struct ice_vf *vf);
 223 void ice_set_vf_state_dis(struct ice_vf *vf);
 224 bool ice_is_any_vf_in_unicast_promisc(struct ice_pf *pf);
 225 void
 226 ice_vf_get_promisc_masks(struct ice_vf *vf, struct ice_vsi *vsi,
 227                          u8 *ucast_m, u8 *mcast_m);
 228 int
 229 ice_vf_set_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m);
 230 int
 231 ice_vf_clear_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m);
 232 int ice_reset_vf(struct ice_vf *vf, u32 flags);
 233 void ice_reset_all_vfs(struct ice_pf *pf);
 234 struct ice_vsi *ice_get_vf_ctrl_vsi(struct ice_pf *pf, struct ice_vsi *vsi);
 235 #else /* CONFIG_PCI_IOV */
 236 static inline struct ice_vf *ice_get_vf_by_id(struct ice_pf *pf, u16 vf_id)
 237 {
 238         return NULL;
 239 }
 240
 241 static inline void ice_put_vf(struct ice_vf *vf)
 242 {
 243 }
 244
 245 static inline bool ice_has_vfs(struct ice_pf *pf)
 246 {
 247         return false;
 248 }
 249
 250 static inline u16 ice_get_num_vfs(struct ice_pf *pf)
 251 {
 252         return 0;
 253 }
 254
 255 static inline struct ice_vsi *ice_get_vf_vsi(struct ice_vf *vf)
 256 {
 257         return NULL;
 258 }
 259
 260 static inline bool ice_is_vf_disabled(struct ice_vf *vf)
 261 {
 262         return true;
 263 }
 264
 265 static inline int ice_check_vf_ready_for_cfg(struct ice_vf *vf)
 266 {
 267         return -EOPNOTSUPP;
 268 }
 269
 270 static inline void ice_set_vf_state_dis(struct ice_vf *vf)
 271 {
 272 }
 273
 274 static inline bool ice_is_any_vf_in_unicast_promisc(struct ice_pf *pf)
 275 {
 276         return false;
 277 }
 278
 279 static inline int
 280 ice_vf_set_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m)
 281 {
 282         return -EOPNOTSUPP;
 283 }
 284
 285 static inline int
 286 ice_vf_clear_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m)
 287 {
 288         return -EOPNOTSUPP;
 289 }
 290
 291 static inline int ice_reset_vf(struct ice_vf *vf, u32 flags)
 292 {
 293         return 0;
 294 }
 295
 296 static inline void ice_reset_all_vfs(struct ice_pf *pf)
 297 {
 298 }
 299
 300 static inline struct ice_vsi *
 301 ice_get_vf_ctrl_vsi(struct ice_pf *pf, struct ice_vsi *vsi)
 302 {
 303         return NULL;
 304 }
 305 #endif /* !CONFIG_PCI_IOV */
 306
 307 #endif /* _ICE_VF_LIB_H_ */