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;               /* number of 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
  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         struct ice_mdd_vf_events mdd_rx_events;
 127         struct ice_mdd_vf_events mdd_tx_events;
 128         DECLARE_BITMAP(opcodes_allowlist, VIRTCHNL_OP_MAX);
 129
 130         struct ice_repr *repr;
 131         const struct ice_virtchnl_ops *virtchnl_ops;
 132         const struct ice_vf_ops *vf_ops;
 133
 134         /* devlink port data */
 135         struct devlink_port devlink_port;
 136 };
 137
 138 /* Flags for controlling behavior of ice_reset_vf */
 139 enum ice_vf_reset_flags {
 140         ICE_VF_RESET_VFLR = BIT(0), /* Indicate a VFLR reset */
 141         ICE_VF_RESET_NOTIFY = BIT(1), /* Notify VF prior to reset */
 142         ICE_VF_RESET_LOCK = BIT(2), /* Acquire the VF cfg_lock */
 143 };
 144
 145 static inline u16 ice_vf_get_port_vlan_id(struct ice_vf *vf)
 146 {
 147         return vf->port_vlan_info.vid;
 148 }
 149
 150 static inline u8 ice_vf_get_port_vlan_prio(struct ice_vf *vf)
 151 {
 152         return vf->port_vlan_info.prio;
 153 }
 154
 155 static inline bool ice_vf_is_port_vlan_ena(struct ice_vf *vf)
 156 {
 157         return (ice_vf_get_port_vlan_id(vf) || ice_vf_get_port_vlan_prio(vf));
 158 }
 159
 160 static inline u16 ice_vf_get_port_vlan_tpid(struct ice_vf *vf)
 161 {
 162         return vf->port_vlan_info.tpid;
 163 }
 164
 165 /* VF Hash Table access functions
 166  *
 167  * These functions provide abstraction for interacting with the VF hash table.
 168  * In general, direct access to the hash table should be avoided outside of
 169  * these functions where possible.
 170  *
 171  * The VF entries in the hash table are protected by reference counting to
 172  * track lifetime of accesses from the table. The ice_get_vf_by_id() function
 173  * obtains a reference to the VF structure which must be dropped by using
 174  * ice_put_vf().
 175  */
 176
 177 /**
 178  * ice_for_each_vf - Iterate over each VF entry
 179  * @pf: pointer to the PF private structure
 180  * @bkt: bucket index used for iteration
 181  * @vf: pointer to the VF entry currently being processed in the loop
 182  *
 183  * The bkt variable is an unsigned integer iterator used to traverse the VF
 184  * entries. It is *not* guaranteed to be the VF's vf_id. Do not assume it is.
 185  * Use vf->vf_id to get the id number if needed.
 186  *
 187  * The caller is expected to be under the table_lock mutex for the entire
 188  * loop. Use this iterator if your loop is long or if it might sleep.
 189  */
 190 #define ice_for_each_vf(pf, bkt, vf) \
 191         hash_for_each((pf)->vfs.table, (bkt), (vf), entry)
 192
 193 /**
 194  * ice_for_each_vf_rcu - Iterate over each VF entry protected by RCU
 195  * @pf: pointer to the PF private structure
 196  * @bkt: bucket index used for iteration
 197  * @vf: pointer to the VF entry currently being processed in the loop
 198  *
 199  * The bkt variable is an unsigned integer iterator used to traverse the VF
 200  * entries. It is *not* guaranteed to be the VF's vf_id. Do not assume it is.
 201  * Use vf->vf_id to get the id number if needed.
 202  *
 203  * The caller is expected to be under rcu_read_lock() for the entire loop.
 204  * Only use this iterator if your loop is short and you can guarantee it does
 205  * not sleep.
 206  */
 207 #define ice_for_each_vf_rcu(pf, bkt, vf) \
 208         hash_for_each_rcu((pf)->vfs.table, (bkt), (vf), entry)
 209
 210 #ifdef CONFIG_PCI_IOV
 211 struct ice_vf *ice_get_vf_by_id(struct ice_pf *pf, u16 vf_id);
 212 void ice_put_vf(struct ice_vf *vf);
 213 bool ice_has_vfs(struct ice_pf *pf);
 214 u16 ice_get_num_vfs(struct ice_pf *pf);
 215 struct ice_vsi *ice_get_vf_vsi(struct ice_vf *vf);
 216 bool ice_is_vf_disabled(struct ice_vf *vf);
 217 int ice_check_vf_ready_for_cfg(struct ice_vf *vf);
 218 int ice_check_vf_ready_for_reset(struct ice_vf *vf);
 219 void ice_set_vf_state_dis(struct ice_vf *vf);
 220 bool ice_is_any_vf_in_unicast_promisc(struct ice_pf *pf);
 221 void
 222 ice_vf_get_promisc_masks(struct ice_vf *vf, struct ice_vsi *vsi,
 223                          u8 *ucast_m, u8 *mcast_m);
 224 int
 225 ice_vf_set_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m);
 226 int
 227 ice_vf_clear_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m);
 228 int ice_reset_vf(struct ice_vf *vf, u32 flags);
 229 void ice_reset_all_vfs(struct ice_pf *pf);
 230 struct ice_vsi *ice_get_vf_ctrl_vsi(struct ice_pf *pf, struct ice_vsi *vsi);
 231 #else /* CONFIG_PCI_IOV */
 232 static inline struct ice_vf *ice_get_vf_by_id(struct ice_pf *pf, u16 vf_id)
 233 {
 234         return NULL;
 235 }
 236
 237 static inline void ice_put_vf(struct ice_vf *vf)
 238 {
 239 }
 240
 241 static inline bool ice_has_vfs(struct ice_pf *pf)
 242 {
 243         return false;
 244 }
 245
 246 static inline u16 ice_get_num_vfs(struct ice_pf *pf)
 247 {
 248         return 0;
 249 }
 250
 251 static inline struct ice_vsi *ice_get_vf_vsi(struct ice_vf *vf)
 252 {
 253         return NULL;
 254 }
 255
 256 static inline bool ice_is_vf_disabled(struct ice_vf *vf)
 257 {
 258         return true;
 259 }
 260
 261 static inline int ice_check_vf_ready_for_cfg(struct ice_vf *vf)
 262 {
 263         return -EOPNOTSUPP;
 264 }
 265
 266 static inline void ice_set_vf_state_dis(struct ice_vf *vf)
 267 {
 268 }
 269
 270 static inline bool ice_is_any_vf_in_unicast_promisc(struct ice_pf *pf)
 271 {
 272         return false;
 273 }
 274
 275 static inline int
 276 ice_vf_set_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m)
 277 {
 278         return -EOPNOTSUPP;
 279 }
 280
 281 static inline int
 282 ice_vf_clear_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m)
 283 {
 284         return -EOPNOTSUPP;
 285 }
 286
 287 static inline int ice_reset_vf(struct ice_vf *vf, u32 flags)
 288 {
 289         return 0;
 290 }
 291
 292 static inline void ice_reset_all_vfs(struct ice_pf *pf)
 293 {
 294 }
 295
 296 static inline struct ice_vsi *
 297 ice_get_vf_ctrl_vsi(struct ice_pf *pf, struct ice_vsi *vsi)
 298 {
 299         return NULL;
 300 }
 301 #endif /* !CONFIG_PCI_IOV */
 302
 303 #endif /* _ICE_VF_LIB_H_ */