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 void ice_set_vf_state_dis(struct ice_vf *vf); 219 bool ice_is_any_vf_in_unicast_promisc(struct ice_pf *pf); 220 void 221 ice_vf_get_promisc_masks(struct ice_vf *vf, struct ice_vsi *vsi, 222 u8 *ucast_m, u8 *mcast_m); 223 int 224 ice_vf_set_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m); 225 int 226 ice_vf_clear_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m); 227 int ice_reset_vf(struct ice_vf *vf, u32 flags); 228 void ice_reset_all_vfs(struct ice_pf *pf); 229 #else /* CONFIG_PCI_IOV */ 230 static inline struct ice_vf *ice_get_vf_by_id(struct ice_pf *pf, u16 vf_id) 231 { 232 return NULL; 233 } 234 235 static inline void ice_put_vf(struct ice_vf *vf) 236 { 237 } 238 239 static inline bool ice_has_vfs(struct ice_pf *pf) 240 { 241 return false; 242 } 243 244 static inline u16 ice_get_num_vfs(struct ice_pf *pf) 245 { 246 return 0; 247 } 248 249 static inline struct ice_vsi *ice_get_vf_vsi(struct ice_vf *vf) 250 { 251 return NULL; 252 } 253 254 static inline bool ice_is_vf_disabled(struct ice_vf *vf) 255 { 256 return true; 257 } 258 259 static inline int ice_check_vf_ready_for_cfg(struct ice_vf *vf) 260 { 261 return -EOPNOTSUPP; 262 } 263 264 static inline void ice_set_vf_state_dis(struct ice_vf *vf) 265 { 266 } 267 268 static inline bool ice_is_any_vf_in_unicast_promisc(struct ice_pf *pf) 269 { 270 return false; 271 } 272 273 static inline int 274 ice_vf_set_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m) 275 { 276 return -EOPNOTSUPP; 277 } 278 279 static inline int 280 ice_vf_clear_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m) 281 { 282 return -EOPNOTSUPP; 283 } 284 285 static inline int ice_reset_vf(struct ice_vf *vf, u32 flags) 286 { 287 return 0; 288 } 289 290 static inline void ice_reset_all_vfs(struct ice_pf *pf) 291 { 292 } 293 #endif /* !CONFIG_PCI_IOV */ 294 295 #endif /* _ICE_VF_LIB_H_ */ 296