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
23struct ice_pf;
24struct ice_vf;
25struct ice_virtchnl_ops;
26
27/* VF capabilities */
28enum ice_virtchnl_cap {
29 ICE_VIRTCHNL_VF_CAP_PRIVILEGE = 0,
30};
31
32/* Specific VF states */
33enum 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
43struct ice_time_mac {
44 unsigned long time_modified;
45 u8 addr[ETH_ALEN];
46};
47
48/* VF MDD events print structure */
49struct 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 */
56struct 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 */
70struct 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 */
80struct 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 struct ice_repr *repr;
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 */
144enum 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
150static inline u16 ice_vf_get_port_vlan_id(struct ice_vf *vf)
151{
152 return vf->port_vlan_info.vid;
153}
154
155static inline u8 ice_vf_get_port_vlan_prio(struct ice_vf *vf)
156{
157 return vf->port_vlan_info.prio;
158}
159
160static 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
165static 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
216struct ice_vf *ice_get_vf_by_id(struct ice_pf *pf, u16 vf_id);
217void ice_put_vf(struct ice_vf *vf);
218bool ice_has_vfs(struct ice_pf *pf);
219u16 ice_get_num_vfs(struct ice_pf *pf);
220struct ice_vsi *ice_get_vf_vsi(struct ice_vf *vf);
221bool ice_is_vf_disabled(struct ice_vf *vf);
222int ice_check_vf_ready_for_cfg(struct ice_vf *vf);
223void ice_set_vf_state_dis(struct ice_vf *vf);
224bool ice_is_any_vf_in_unicast_promisc(struct ice_pf *pf);
225void
226ice_vf_get_promisc_masks(struct ice_vf *vf, struct ice_vsi *vsi,
227 u8 *ucast_m, u8 *mcast_m);
228int
229ice_vf_set_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m);
230int
231ice_vf_clear_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m);
232int ice_reset_vf(struct ice_vf *vf, u32 flags);
233void ice_reset_all_vfs(struct ice_pf *pf);
234struct ice_vsi *ice_get_vf_ctrl_vsi(struct ice_pf *pf, struct ice_vsi *vsi);
235#else /* CONFIG_PCI_IOV */
236static inline struct ice_vf *ice_get_vf_by_id(struct ice_pf *pf, u16 vf_id)
237{
238 return NULL;
239}
240
241static inline void ice_put_vf(struct ice_vf *vf)
242{
243}
244
245static inline bool ice_has_vfs(struct ice_pf *pf)
246{
247 return false;
248}
249
250static inline u16 ice_get_num_vfs(struct ice_pf *pf)
251{
252 return 0;
253}
254
255static inline struct ice_vsi *ice_get_vf_vsi(struct ice_vf *vf)
256{
257 return NULL;
258}
259
260static inline bool ice_is_vf_disabled(struct ice_vf *vf)
261{
262 return true;
263}
264
265static inline int ice_check_vf_ready_for_cfg(struct ice_vf *vf)
266{
267 return -EOPNOTSUPP;
268}
269
270static inline void ice_set_vf_state_dis(struct ice_vf *vf)
271{
272}
273
274static inline bool ice_is_any_vf_in_unicast_promisc(struct ice_pf *pf)
275{
276 return false;
277}
278
279static inline int
280ice_vf_set_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m)
281{
282 return -EOPNOTSUPP;
283}
284
285static inline int
286ice_vf_clear_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m)
287{
288 return -EOPNOTSUPP;
289}
290
291static inline int ice_reset_vf(struct ice_vf *vf, u32 flags)
292{
293 return 0;
294}
295
296static inline void ice_reset_all_vfs(struct ice_pf *pf)
297{
298}
299
300static inline struct ice_vsi *
301ice_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_ */
308

source code of linux/drivers/net/ethernet/intel/ice/ice_vf_lib.h