1 // SPDX-License-Identifier: (GPL-2.0-only OR BSD-2-Clause)
2 /* Copyright (C) 2017-2019 Netronome Systems, Inc. */
3 
4 #include <linux/bitfield.h>
5 #include <linux/errno.h>
6 #include <linux/etherdevice.h>
7 #include <linux/if_link.h>
8 #include <linux/if_ether.h>
9 
10 #include "nfpcore/nfp_cpp.h"
11 #include "nfp_app.h"
12 #include "nfp_main.h"
13 #include "nfp_net_ctrl.h"
14 #include "nfp_net.h"
15 #include "nfp_net_sriov.h"
16 
17 static int
18 nfp_net_sriov_check(struct nfp_app *app, int vf, u16 cap, const char *msg, bool warn)
19 {
20 	u16 cap_vf;
21 
22 	if (!app || !app->pf->vfcfg_tbl2)
23 		return -EOPNOTSUPP;
24 
25 	cap_vf = readw(app->pf->vfcfg_tbl2 + NFP_NET_VF_CFG_MB_CAP);
26 	if ((cap_vf & cap) != cap) {
27 		if (warn)
28 			nfp_warn(app->pf->cpp, "ndo_set_vf_%s not supported\n", msg);
29 		return -EOPNOTSUPP;
30 	}
31 
32 	if (vf < 0 || vf >= app->pf->num_vfs) {
33 		if (warn)
34 			nfp_warn(app->pf->cpp, "invalid VF id %d\n", vf);
35 		return -EINVAL;
36 	}
37 
38 	return 0;
39 }
40 
41 static int
42 nfp_net_sriov_update(struct nfp_app *app, int vf, u16 update, const char *msg)
43 {
44 	struct nfp_net *nn;
45 	int ret;
46 
47 	/* Write update info to mailbox in VF config symbol */
48 	writeb(vf, app->pf->vfcfg_tbl2 + NFP_NET_VF_CFG_MB_VF_NUM);
49 	writew(update, app->pf->vfcfg_tbl2 + NFP_NET_VF_CFG_MB_UPD);
50 
51 	nn = list_first_entry(&app->pf->vnics, struct nfp_net, vnic_list);
52 	/* Signal VF reconfiguration */
53 	ret = nfp_net_reconfig(nn, NFP_NET_CFG_UPDATE_VF);
54 	if (ret)
55 		return ret;
56 
57 	ret = readw(app->pf->vfcfg_tbl2 + NFP_NET_VF_CFG_MB_RET);
58 	if (ret)
59 		nfp_warn(app->pf->cpp,
60 			 "FW refused VF %s update with errno: %d\n", msg, ret);
61 	return -ret;
62 }
63 
64 int nfp_app_set_vf_mac(struct net_device *netdev, int vf, u8 *mac)
65 {
66 	struct nfp_app *app = nfp_app_from_netdev(netdev);
67 	unsigned int vf_offset;
68 	int err;
69 
70 	err = nfp_net_sriov_check(app, vf, NFP_NET_VF_CFG_MB_CAP_MAC, "mac", true);
71 	if (err)
72 		return err;
73 
74 	if (is_multicast_ether_addr(mac)) {
75 		nfp_warn(app->pf->cpp,
76 			 "invalid Ethernet address %pM for VF id %d\n",
77 			 mac, vf);
78 		return -EINVAL;
79 	}
80 
81 	/* Write MAC to VF entry in VF config symbol */
82 	vf_offset = NFP_NET_VF_CFG_MB_SZ + vf * NFP_NET_VF_CFG_SZ;
83 	writel(get_unaligned_be32(mac), app->pf->vfcfg_tbl2 + vf_offset);
84 	writew(get_unaligned_be16(mac + 4),
85 	       app->pf->vfcfg_tbl2 + vf_offset + NFP_NET_VF_CFG_MAC_LO);
86 
87 	err = nfp_net_sriov_update(app, vf, NFP_NET_VF_CFG_MB_UPD_MAC, "MAC");
88 	if (!err)
89 		nfp_info(app->pf->cpp,
90 			 "MAC %pM set on VF %d, reload the VF driver to make this change effective.\n",
91 			 mac, vf);
92 
93 	return err;
94 }
95 
96 int nfp_app_set_vf_vlan(struct net_device *netdev, int vf, u16 vlan, u8 qos,
97 			__be16 vlan_proto)
98 {
99 	struct nfp_app *app = nfp_app_from_netdev(netdev);
100 	u16 update = NFP_NET_VF_CFG_MB_UPD_VLAN;
101 	bool is_proto_sup = true;
102 	unsigned int vf_offset;
103 	u32 vlan_tag;
104 	int err;
105 
106 	err = nfp_net_sriov_check(app, vf, NFP_NET_VF_CFG_MB_CAP_VLAN, "vlan", true);
107 	if (err)
108 		return err;
109 
110 	if (!eth_type_vlan(vlan_proto))
111 		return -EOPNOTSUPP;
112 
113 	if (vlan > 4095 || qos > 7) {
114 		nfp_warn(app->pf->cpp,
115 			 "invalid vlan id or qos for VF id %d\n", vf);
116 		return -EINVAL;
117 	}
118 
119 	/* Check if fw supports or not */
120 	err = nfp_net_sriov_check(app, vf, NFP_NET_VF_CFG_MB_CAP_VLAN_PROTO, "vlan_proto", true);
121 	if (err)
122 		is_proto_sup = false;
123 
124 	if (vlan_proto != htons(ETH_P_8021Q)) {
125 		if (!is_proto_sup)
126 			return -EOPNOTSUPP;
127 		update |= NFP_NET_VF_CFG_MB_UPD_VLAN_PROTO;
128 	}
129 
130 	/* Write VLAN tag to VF entry in VF config symbol */
131 	vlan_tag = FIELD_PREP(NFP_NET_VF_CFG_VLAN_VID, vlan) |
132 		FIELD_PREP(NFP_NET_VF_CFG_VLAN_QOS, qos);
133 
134 	/* vlan_tag of 0 means that the configuration should be cleared and in
135 	 * such circumstances setting the TPID has no meaning when
136 	 * configuring firmware.
137 	 */
138 	if (vlan_tag && is_proto_sup)
139 		vlan_tag |= FIELD_PREP(NFP_NET_VF_CFG_VLAN_PROT, ntohs(vlan_proto));
140 
141 	vf_offset = NFP_NET_VF_CFG_MB_SZ + vf * NFP_NET_VF_CFG_SZ;
142 	writel(vlan_tag, app->pf->vfcfg_tbl2 + vf_offset + NFP_NET_VF_CFG_VLAN);
143 
144 	return nfp_net_sriov_update(app, vf, update, "vlan");
145 }
146 
147 int nfp_app_set_vf_rate(struct net_device *netdev, int vf,
148 			int min_tx_rate, int max_tx_rate)
149 {
150 	struct nfp_app *app = nfp_app_from_netdev(netdev);
151 	u32 vf_offset, ratevalue;
152 	int err;
153 
154 	err = nfp_net_sriov_check(app, vf, NFP_NET_VF_CFG_MB_CAP_RATE, "rate", true);
155 	if (err)
156 		return err;
157 
158 	if (max_tx_rate >= NFP_NET_VF_RATE_MAX ||
159 	    min_tx_rate >= NFP_NET_VF_RATE_MAX) {
160 		nfp_warn(app->cpp, "tx-rate exceeds %d.\n",
161 			 NFP_NET_VF_RATE_MAX);
162 		return -EINVAL;
163 	}
164 
165 	vf_offset = NFP_NET_VF_CFG_MB_SZ + vf * NFP_NET_VF_CFG_SZ;
166 	ratevalue = FIELD_PREP(NFP_NET_VF_CFG_MAX_RATE,
167 			       max_tx_rate ? max_tx_rate :
168 			       NFP_NET_VF_RATE_MAX) |
169 		    FIELD_PREP(NFP_NET_VF_CFG_MIN_RATE, min_tx_rate);
170 
171 	writel(ratevalue,
172 	       app->pf->vfcfg_tbl2 + vf_offset + NFP_NET_VF_CFG_RATE);
173 
174 	return nfp_net_sriov_update(app, vf, NFP_NET_VF_CFG_MB_UPD_RATE,
175 				    "rate");
176 }
177 
178 int nfp_app_set_vf_spoofchk(struct net_device *netdev, int vf, bool enable)
179 {
180 	struct nfp_app *app = nfp_app_from_netdev(netdev);
181 	unsigned int vf_offset;
182 	u8 vf_ctrl;
183 	int err;
184 
185 	err = nfp_net_sriov_check(app, vf, NFP_NET_VF_CFG_MB_CAP_SPOOF,
186 				  "spoofchk", true);
187 	if (err)
188 		return err;
189 
190 	/* Write spoof check control bit to VF entry in VF config symbol */
191 	vf_offset = NFP_NET_VF_CFG_MB_SZ + vf * NFP_NET_VF_CFG_SZ +
192 		NFP_NET_VF_CFG_CTRL;
193 	vf_ctrl = readb(app->pf->vfcfg_tbl2 + vf_offset);
194 	vf_ctrl &= ~NFP_NET_VF_CFG_CTRL_SPOOF;
195 	vf_ctrl |= FIELD_PREP(NFP_NET_VF_CFG_CTRL_SPOOF, enable);
196 	writeb(vf_ctrl, app->pf->vfcfg_tbl2 + vf_offset);
197 
198 	return nfp_net_sriov_update(app, vf, NFP_NET_VF_CFG_MB_UPD_SPOOF,
199 				    "spoofchk");
200 }
201 
202 int nfp_app_set_vf_trust(struct net_device *netdev, int vf, bool enable)
203 {
204 	struct nfp_app *app = nfp_app_from_netdev(netdev);
205 	unsigned int vf_offset;
206 	u8 vf_ctrl;
207 	int err;
208 
209 	err = nfp_net_sriov_check(app, vf, NFP_NET_VF_CFG_MB_CAP_TRUST,
210 				  "trust", true);
211 	if (err)
212 		return err;
213 
214 	/* Write trust control bit to VF entry in VF config symbol */
215 	vf_offset = NFP_NET_VF_CFG_MB_SZ + vf * NFP_NET_VF_CFG_SZ +
216 		NFP_NET_VF_CFG_CTRL;
217 	vf_ctrl = readb(app->pf->vfcfg_tbl2 + vf_offset);
218 	vf_ctrl &= ~NFP_NET_VF_CFG_CTRL_TRUST;
219 	vf_ctrl |= FIELD_PREP(NFP_NET_VF_CFG_CTRL_TRUST, enable);
220 	writeb(vf_ctrl, app->pf->vfcfg_tbl2 + vf_offset);
221 
222 	return nfp_net_sriov_update(app, vf, NFP_NET_VF_CFG_MB_UPD_TRUST,
223 				    "trust");
224 }
225 
226 int nfp_app_set_vf_link_state(struct net_device *netdev, int vf,
227 			      int link_state)
228 {
229 	struct nfp_app *app = nfp_app_from_netdev(netdev);
230 	unsigned int vf_offset;
231 	u8 vf_ctrl;
232 	int err;
233 
234 	err = nfp_net_sriov_check(app, vf, NFP_NET_VF_CFG_MB_CAP_LINK_STATE,
235 				  "link_state", true);
236 	if (err)
237 		return err;
238 
239 	switch (link_state) {
240 	case IFLA_VF_LINK_STATE_AUTO:
241 	case IFLA_VF_LINK_STATE_ENABLE:
242 	case IFLA_VF_LINK_STATE_DISABLE:
243 		break;
244 	default:
245 		return -EINVAL;
246 	}
247 
248 	/* Write link state to VF entry in VF config symbol */
249 	vf_offset = NFP_NET_VF_CFG_MB_SZ + vf * NFP_NET_VF_CFG_SZ +
250 		NFP_NET_VF_CFG_CTRL;
251 	vf_ctrl = readb(app->pf->vfcfg_tbl2 + vf_offset);
252 	vf_ctrl &= ~NFP_NET_VF_CFG_CTRL_LINK_STATE;
253 	vf_ctrl |= FIELD_PREP(NFP_NET_VF_CFG_CTRL_LINK_STATE, link_state);
254 	writeb(vf_ctrl, app->pf->vfcfg_tbl2 + vf_offset);
255 
256 	return nfp_net_sriov_update(app, vf, NFP_NET_VF_CFG_MB_UPD_LINK_STATE,
257 				    "link state");
258 }
259 
260 int nfp_app_get_vf_config(struct net_device *netdev, int vf,
261 			  struct ifla_vf_info *ivi)
262 {
263 	struct nfp_app *app = nfp_app_from_netdev(netdev);
264 	u32 vf_offset, mac_hi, rate;
265 	u32 vlan_tag;
266 	u16 mac_lo;
267 	u8 flags;
268 	int err;
269 
270 	err = nfp_net_sriov_check(app, vf, 0, "", true);
271 	if (err)
272 		return err;
273 
274 	vf_offset = NFP_NET_VF_CFG_MB_SZ + vf * NFP_NET_VF_CFG_SZ;
275 
276 	mac_hi = readl(app->pf->vfcfg_tbl2 + vf_offset);
277 	mac_lo = readw(app->pf->vfcfg_tbl2 + vf_offset + NFP_NET_VF_CFG_MAC_LO);
278 
279 	flags = readb(app->pf->vfcfg_tbl2 + vf_offset + NFP_NET_VF_CFG_CTRL);
280 	vlan_tag = readl(app->pf->vfcfg_tbl2 + vf_offset + NFP_NET_VF_CFG_VLAN);
281 
282 	memset(ivi, 0, sizeof(*ivi));
283 	ivi->vf = vf;
284 
285 	put_unaligned_be32(mac_hi, &ivi->mac[0]);
286 	put_unaligned_be16(mac_lo, &ivi->mac[4]);
287 
288 	ivi->vlan = FIELD_GET(NFP_NET_VF_CFG_VLAN_VID, vlan_tag);
289 	ivi->qos = FIELD_GET(NFP_NET_VF_CFG_VLAN_QOS, vlan_tag);
290 	if (!nfp_net_sriov_check(app, vf, NFP_NET_VF_CFG_MB_CAP_VLAN_PROTO, "vlan_proto", false))
291 		ivi->vlan_proto = htons(FIELD_GET(NFP_NET_VF_CFG_VLAN_PROT, vlan_tag));
292 	ivi->spoofchk = FIELD_GET(NFP_NET_VF_CFG_CTRL_SPOOF, flags);
293 	ivi->trusted = FIELD_GET(NFP_NET_VF_CFG_CTRL_TRUST, flags);
294 	ivi->linkstate = FIELD_GET(NFP_NET_VF_CFG_CTRL_LINK_STATE, flags);
295 
296 	err = nfp_net_sriov_check(app, vf, NFP_NET_VF_CFG_MB_CAP_RATE, "rate", false);
297 	if (!err) {
298 		rate = readl(app->pf->vfcfg_tbl2 + vf_offset +
299 			     NFP_NET_VF_CFG_RATE);
300 
301 		ivi->max_tx_rate = FIELD_GET(NFP_NET_VF_CFG_MAX_RATE, rate);
302 		ivi->min_tx_rate = FIELD_GET(NFP_NET_VF_CFG_MIN_RATE, rate);
303 
304 		if (ivi->max_tx_rate == NFP_NET_VF_RATE_MAX)
305 			ivi->max_tx_rate = 0;
306 		if (ivi->min_tx_rate == NFP_NET_VF_RATE_MAX)
307 			ivi->min_tx_rate = 0;
308 	}
309 
310 	return 0;
311 }
312