1 // SPDX-License-Identifier: GPL-2.0-only
2 /****************************************************************************
3  * Driver for Solarflare network controllers and boards
4  * Copyright 2015 Solarflare Communications Inc.
5  */
6 #include <linux/etherdevice.h>
7 #include <linux/pci.h>
8 #include <linux/module.h>
9 #include "net_driver.h"
10 #include "ef10_sriov.h"
11 #include "efx.h"
12 #include "nic.h"
13 #include "mcdi_pcol.h"
14 
15 static int efx_ef10_evb_port_assign(struct efx_nic *efx, unsigned int port_id,
16 				    unsigned int vf_fn)
17 {
18 	MCDI_DECLARE_BUF(inbuf, MC_CMD_EVB_PORT_ASSIGN_IN_LEN);
19 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
20 
21 	MCDI_SET_DWORD(inbuf, EVB_PORT_ASSIGN_IN_PORT_ID, port_id);
22 	MCDI_POPULATE_DWORD_2(inbuf, EVB_PORT_ASSIGN_IN_FUNCTION,
23 			      EVB_PORT_ASSIGN_IN_PF, nic_data->pf_index,
24 			      EVB_PORT_ASSIGN_IN_VF, vf_fn);
25 
26 	return efx_mcdi_rpc(efx, MC_CMD_EVB_PORT_ASSIGN, inbuf, sizeof(inbuf),
27 			    NULL, 0, NULL);
28 }
29 
30 static int efx_ef10_vswitch_alloc(struct efx_nic *efx, unsigned int port_id,
31 				  unsigned int vswitch_type)
32 {
33 	MCDI_DECLARE_BUF(inbuf, MC_CMD_VSWITCH_ALLOC_IN_LEN);
34 	int rc;
35 
36 	MCDI_SET_DWORD(inbuf, VSWITCH_ALLOC_IN_UPSTREAM_PORT_ID, port_id);
37 	MCDI_SET_DWORD(inbuf, VSWITCH_ALLOC_IN_TYPE, vswitch_type);
38 	MCDI_SET_DWORD(inbuf, VSWITCH_ALLOC_IN_NUM_VLAN_TAGS, 2);
39 	MCDI_POPULATE_DWORD_1(inbuf, VSWITCH_ALLOC_IN_FLAGS,
40 			      VSWITCH_ALLOC_IN_FLAG_AUTO_PORT, 0);
41 
42 	/* Quietly try to allocate 2 VLAN tags */
43 	rc = efx_mcdi_rpc_quiet(efx, MC_CMD_VSWITCH_ALLOC, inbuf, sizeof(inbuf),
44 				NULL, 0, NULL);
45 
46 	/* If 2 VLAN tags is too many, revert to trying with 1 VLAN tags */
47 	if (rc == -EPROTO) {
48 		MCDI_SET_DWORD(inbuf, VSWITCH_ALLOC_IN_NUM_VLAN_TAGS, 1);
49 		rc = efx_mcdi_rpc(efx, MC_CMD_VSWITCH_ALLOC, inbuf,
50 				  sizeof(inbuf), NULL, 0, NULL);
51 	} else if (rc) {
52 		efx_mcdi_display_error(efx, MC_CMD_VSWITCH_ALLOC,
53 				       MC_CMD_VSWITCH_ALLOC_IN_LEN,
54 				       NULL, 0, rc);
55 	}
56 	return rc;
57 }
58 
59 static int efx_ef10_vswitch_free(struct efx_nic *efx, unsigned int port_id)
60 {
61 	MCDI_DECLARE_BUF(inbuf, MC_CMD_VSWITCH_FREE_IN_LEN);
62 
63 	MCDI_SET_DWORD(inbuf, VSWITCH_FREE_IN_UPSTREAM_PORT_ID, port_id);
64 
65 	return efx_mcdi_rpc(efx, MC_CMD_VSWITCH_FREE, inbuf, sizeof(inbuf),
66 			    NULL, 0, NULL);
67 }
68 
69 static int efx_ef10_vport_alloc(struct efx_nic *efx,
70 				unsigned int port_id_in,
71 				unsigned int vport_type,
72 				u16 vlan,
73 				unsigned int *port_id_out)
74 {
75 	MCDI_DECLARE_BUF(inbuf, MC_CMD_VPORT_ALLOC_IN_LEN);
76 	MCDI_DECLARE_BUF(outbuf, MC_CMD_VPORT_ALLOC_OUT_LEN);
77 	size_t outlen;
78 	int rc;
79 
80 	EFX_WARN_ON_PARANOID(!port_id_out);
81 
82 	MCDI_SET_DWORD(inbuf, VPORT_ALLOC_IN_UPSTREAM_PORT_ID, port_id_in);
83 	MCDI_SET_DWORD(inbuf, VPORT_ALLOC_IN_TYPE, vport_type);
84 	MCDI_SET_DWORD(inbuf, VPORT_ALLOC_IN_NUM_VLAN_TAGS,
85 		       (vlan != EFX_EF10_NO_VLAN));
86 	MCDI_POPULATE_DWORD_1(inbuf, VPORT_ALLOC_IN_FLAGS,
87 			      VPORT_ALLOC_IN_FLAG_AUTO_PORT, 0);
88 	if (vlan != EFX_EF10_NO_VLAN)
89 		MCDI_POPULATE_DWORD_1(inbuf, VPORT_ALLOC_IN_VLAN_TAGS,
90 				      VPORT_ALLOC_IN_VLAN_TAG_0, vlan);
91 
92 	rc = efx_mcdi_rpc(efx, MC_CMD_VPORT_ALLOC, inbuf, sizeof(inbuf),
93 			  outbuf, sizeof(outbuf), &outlen);
94 	if (rc)
95 		return rc;
96 	if (outlen < MC_CMD_VPORT_ALLOC_OUT_LEN)
97 		return -EIO;
98 
99 	*port_id_out = MCDI_DWORD(outbuf, VPORT_ALLOC_OUT_VPORT_ID);
100 	return 0;
101 }
102 
103 static int efx_ef10_vport_free(struct efx_nic *efx, unsigned int port_id)
104 {
105 	MCDI_DECLARE_BUF(inbuf, MC_CMD_VPORT_FREE_IN_LEN);
106 
107 	MCDI_SET_DWORD(inbuf, VPORT_FREE_IN_VPORT_ID, port_id);
108 
109 	return efx_mcdi_rpc(efx, MC_CMD_VPORT_FREE, inbuf, sizeof(inbuf),
110 			    NULL, 0, NULL);
111 }
112 
113 static void efx_ef10_sriov_free_vf_vports(struct efx_nic *efx)
114 {
115 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
116 	int i;
117 
118 	if (!nic_data->vf)
119 		return;
120 
121 	for (i = 0; i < efx->vf_count; i++) {
122 		struct ef10_vf *vf = nic_data->vf + i;
123 
124 		/* If VF is assigned, do not free the vport  */
125 		if (vf->pci_dev && pci_is_dev_assigned(vf->pci_dev))
126 			continue;
127 
128 		if (vf->vport_assigned) {
129 			efx_ef10_evb_port_assign(efx, EVB_PORT_ID_NULL, i);
130 			vf->vport_assigned = 0;
131 		}
132 
133 		if (!is_zero_ether_addr(vf->mac)) {
134 			efx_ef10_vport_del_mac(efx, vf->vport_id, vf->mac);
135 			eth_zero_addr(vf->mac);
136 		}
137 
138 		if (vf->vport_id) {
139 			efx_ef10_vport_free(efx, vf->vport_id);
140 			vf->vport_id = 0;
141 		}
142 
143 		vf->efx = NULL;
144 	}
145 }
146 
147 static void efx_ef10_sriov_free_vf_vswitching(struct efx_nic *efx)
148 {
149 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
150 
151 	efx_ef10_sriov_free_vf_vports(efx);
152 	kfree(nic_data->vf);
153 	nic_data->vf = NULL;
154 }
155 
156 static int efx_ef10_sriov_assign_vf_vport(struct efx_nic *efx,
157 					  unsigned int vf_i)
158 {
159 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
160 	struct ef10_vf *vf = nic_data->vf + vf_i;
161 	int rc;
162 
163 	if (WARN_ON_ONCE(!nic_data->vf))
164 		return -EOPNOTSUPP;
165 
166 	rc = efx_ef10_vport_alloc(efx, EVB_PORT_ID_ASSIGNED,
167 				  MC_CMD_VPORT_ALLOC_IN_VPORT_TYPE_NORMAL,
168 				  vf->vlan, &vf->vport_id);
169 	if (rc)
170 		return rc;
171 
172 	rc = efx_ef10_vport_add_mac(efx, vf->vport_id, vf->mac);
173 	if (rc) {
174 		eth_zero_addr(vf->mac);
175 		return rc;
176 	}
177 
178 	rc =  efx_ef10_evb_port_assign(efx, vf->vport_id, vf_i);
179 	if (rc)
180 		return rc;
181 
182 	vf->vport_assigned = 1;
183 	return 0;
184 }
185 
186 static int efx_ef10_sriov_alloc_vf_vswitching(struct efx_nic *efx)
187 {
188 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
189 	unsigned int i;
190 	int rc;
191 
192 	nic_data->vf = kcalloc(efx->vf_count, sizeof(struct ef10_vf),
193 			       GFP_KERNEL);
194 	if (!nic_data->vf)
195 		return -ENOMEM;
196 
197 	for (i = 0; i < efx->vf_count; i++) {
198 		eth_random_addr(nic_data->vf[i].mac);
199 		nic_data->vf[i].efx = NULL;
200 		nic_data->vf[i].vlan = EFX_EF10_NO_VLAN;
201 
202 		rc = efx_ef10_sriov_assign_vf_vport(efx, i);
203 		if (rc)
204 			goto fail;
205 	}
206 
207 	return 0;
208 fail:
209 	efx_ef10_sriov_free_vf_vswitching(efx);
210 	return rc;
211 }
212 
213 static int efx_ef10_sriov_restore_vf_vswitching(struct efx_nic *efx)
214 {
215 	unsigned int i;
216 	int rc;
217 
218 	for (i = 0; i < efx->vf_count; i++) {
219 		rc = efx_ef10_sriov_assign_vf_vport(efx, i);
220 		if (rc)
221 			goto fail;
222 	}
223 
224 	return 0;
225 fail:
226 	efx_ef10_sriov_free_vf_vswitching(efx);
227 	return rc;
228 }
229 
230 static int efx_ef10_vadaptor_alloc_set_features(struct efx_nic *efx)
231 {
232 	u32 port_flags;
233 	int rc;
234 
235 	rc = efx_ef10_vadaptor_alloc(efx, efx->vport_id);
236 	if (rc)
237 		goto fail_vadaptor_alloc;
238 
239 	rc = efx_ef10_vadaptor_query(efx, efx->vport_id,
240 				     &port_flags, NULL, NULL);
241 	if (rc)
242 		goto fail_vadaptor_query;
243 
244 	if (port_flags &
245 	    (1 << MC_CMD_VPORT_ALLOC_IN_FLAG_VLAN_RESTRICT_LBN))
246 		efx->fixed_features |= NETIF_F_HW_VLAN_CTAG_FILTER;
247 	else
248 		efx->fixed_features &= ~NETIF_F_HW_VLAN_CTAG_FILTER;
249 
250 	return 0;
251 
252 fail_vadaptor_query:
253 	efx_ef10_vadaptor_free(efx, EVB_PORT_ID_ASSIGNED);
254 fail_vadaptor_alloc:
255 	return rc;
256 }
257 
258 /* On top of the default firmware vswitch setup, create a VEB vswitch and
259  * expansion vport for use by this function.
260  */
261 int efx_ef10_vswitching_probe_pf(struct efx_nic *efx)
262 {
263 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
264 	struct net_device *net_dev = efx->net_dev;
265 	int rc;
266 
267 	if (pci_sriov_get_totalvfs(efx->pci_dev) <= 0) {
268 		/* vswitch not needed as we have no VFs */
269 		efx_ef10_vadaptor_alloc_set_features(efx);
270 		return 0;
271 	}
272 
273 	rc = efx_ef10_vswitch_alloc(efx, EVB_PORT_ID_ASSIGNED,
274 				    MC_CMD_VSWITCH_ALLOC_IN_VSWITCH_TYPE_VEB);
275 	if (rc)
276 		goto fail1;
277 
278 	rc = efx_ef10_vport_alloc(efx, EVB_PORT_ID_ASSIGNED,
279 				  MC_CMD_VPORT_ALLOC_IN_VPORT_TYPE_NORMAL,
280 				  EFX_EF10_NO_VLAN, &efx->vport_id);
281 	if (rc)
282 		goto fail2;
283 
284 	rc = efx_ef10_vport_add_mac(efx, efx->vport_id, net_dev->dev_addr);
285 	if (rc)
286 		goto fail3;
287 	ether_addr_copy(nic_data->vport_mac, net_dev->dev_addr);
288 
289 	rc = efx_ef10_vadaptor_alloc_set_features(efx);
290 	if (rc)
291 		goto fail4;
292 
293 	return 0;
294 fail4:
295 	efx_ef10_vport_del_mac(efx, efx->vport_id, nic_data->vport_mac);
296 	eth_zero_addr(nic_data->vport_mac);
297 fail3:
298 	efx_ef10_vport_free(efx, efx->vport_id);
299 	efx->vport_id = EVB_PORT_ID_ASSIGNED;
300 fail2:
301 	efx_ef10_vswitch_free(efx, EVB_PORT_ID_ASSIGNED);
302 fail1:
303 	return rc;
304 }
305 
306 int efx_ef10_vswitching_probe_vf(struct efx_nic *efx)
307 {
308 	return efx_ef10_vadaptor_alloc_set_features(efx);
309 }
310 
311 int efx_ef10_vswitching_restore_pf(struct efx_nic *efx)
312 {
313 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
314 	int rc;
315 
316 	if (!nic_data->must_probe_vswitching)
317 		return 0;
318 
319 	rc = efx_ef10_vswitching_probe_pf(efx);
320 	if (rc)
321 		goto fail;
322 
323 	rc = efx_ef10_sriov_restore_vf_vswitching(efx);
324 	if (rc)
325 		goto fail;
326 
327 	nic_data->must_probe_vswitching = false;
328 fail:
329 	return rc;
330 }
331 
332 int efx_ef10_vswitching_restore_vf(struct efx_nic *efx)
333 {
334 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
335 	int rc;
336 
337 	if (!nic_data->must_probe_vswitching)
338 		return 0;
339 
340 	rc = efx_ef10_vadaptor_free(efx, EVB_PORT_ID_ASSIGNED);
341 	if (rc)
342 		return rc;
343 
344 	nic_data->must_probe_vswitching = false;
345 	return 0;
346 }
347 
348 void efx_ef10_vswitching_remove_pf(struct efx_nic *efx)
349 {
350 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
351 
352 	efx_ef10_sriov_free_vf_vswitching(efx);
353 
354 	efx_ef10_vadaptor_free(efx, efx->vport_id);
355 
356 	if (efx->vport_id == EVB_PORT_ID_ASSIGNED)
357 		return; /* No vswitch was ever created */
358 
359 	if (!is_zero_ether_addr(nic_data->vport_mac)) {
360 		efx_ef10_vport_del_mac(efx, efx->vport_id,
361 				       efx->net_dev->dev_addr);
362 		eth_zero_addr(nic_data->vport_mac);
363 	}
364 	efx_ef10_vport_free(efx, efx->vport_id);
365 	efx->vport_id = EVB_PORT_ID_ASSIGNED;
366 
367 	/* Only free the vswitch if no VFs are assigned */
368 	if (!pci_vfs_assigned(efx->pci_dev))
369 		efx_ef10_vswitch_free(efx, efx->vport_id);
370 }
371 
372 void efx_ef10_vswitching_remove_vf(struct efx_nic *efx)
373 {
374 	efx_ef10_vadaptor_free(efx, EVB_PORT_ID_ASSIGNED);
375 }
376 
377 static int efx_ef10_pci_sriov_enable(struct efx_nic *efx, int num_vfs)
378 {
379 	int rc = 0;
380 	struct pci_dev *dev = efx->pci_dev;
381 
382 	efx->vf_count = num_vfs;
383 
384 	rc = efx_ef10_sriov_alloc_vf_vswitching(efx);
385 	if (rc)
386 		goto fail1;
387 
388 	rc = pci_enable_sriov(dev, num_vfs);
389 	if (rc)
390 		goto fail2;
391 
392 	return 0;
393 fail2:
394 	efx_ef10_sriov_free_vf_vswitching(efx);
395 fail1:
396 	efx->vf_count = 0;
397 	netif_err(efx, probe, efx->net_dev,
398 		  "Failed to enable SRIOV VFs\n");
399 	return rc;
400 }
401 
402 /* Disable SRIOV and remove VFs
403  * If some VFs are attached to a guest (using Xen, only) nothing is
404  * done if force=false, and vports are freed if force=true (for the non
405  * attachedc ones, only) but SRIOV is not disabled and VFs are not
406  * removed in either case.
407  */
408 static int efx_ef10_pci_sriov_disable(struct efx_nic *efx, bool force)
409 {
410 	struct pci_dev *dev = efx->pci_dev;
411 	unsigned int vfs_assigned = pci_vfs_assigned(dev);
412 	int rc = 0;
413 
414 	if (vfs_assigned && !force) {
415 		netif_info(efx, drv, efx->net_dev, "VFs are assigned to guests; "
416 			   "please detach them before disabling SR-IOV\n");
417 		return -EBUSY;
418 	}
419 
420 	if (!vfs_assigned)
421 		pci_disable_sriov(dev);
422 	else
423 		rc = -EBUSY;
424 
425 	efx_ef10_sriov_free_vf_vswitching(efx);
426 	efx->vf_count = 0;
427 	return rc;
428 }
429 
430 int efx_ef10_sriov_configure(struct efx_nic *efx, int num_vfs)
431 {
432 	if (num_vfs == 0)
433 		return efx_ef10_pci_sriov_disable(efx, false);
434 	else
435 		return efx_ef10_pci_sriov_enable(efx, num_vfs);
436 }
437 
438 int efx_ef10_sriov_init(struct efx_nic *efx)
439 {
440 	return 0;
441 }
442 
443 void efx_ef10_sriov_fini(struct efx_nic *efx)
444 {
445 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
446 	int rc;
447 
448 	if (!nic_data->vf) {
449 		/* Remove any un-assigned orphaned VFs. This can happen if the PF driver
450 		 * was unloaded while any VF was assigned to a guest (using Xen, only).
451 		 */
452 		if (pci_num_vf(efx->pci_dev) && !pci_vfs_assigned(efx->pci_dev))
453 			pci_disable_sriov(efx->pci_dev);
454 		return;
455 	}
456 
457 	/* Disable SRIOV and remove any VFs in the host */
458 	rc = efx_ef10_pci_sriov_disable(efx, true);
459 	if (rc)
460 		netif_dbg(efx, drv, efx->net_dev,
461 			  "Disabling SRIOV was not successful rc=%d\n", rc);
462 	else
463 		netif_dbg(efx, drv, efx->net_dev, "SRIOV disabled\n");
464 }
465 
466 static int efx_ef10_vport_del_vf_mac(struct efx_nic *efx, unsigned int port_id,
467 				     u8 *mac)
468 {
469 	MCDI_DECLARE_BUF(inbuf, MC_CMD_VPORT_DEL_MAC_ADDRESS_IN_LEN);
470 	MCDI_DECLARE_BUF_ERR(outbuf);
471 	size_t outlen;
472 	int rc;
473 
474 	MCDI_SET_DWORD(inbuf, VPORT_DEL_MAC_ADDRESS_IN_VPORT_ID, port_id);
475 	ether_addr_copy(MCDI_PTR(inbuf, VPORT_DEL_MAC_ADDRESS_IN_MACADDR), mac);
476 
477 	rc = efx_mcdi_rpc(efx, MC_CMD_VPORT_DEL_MAC_ADDRESS, inbuf,
478 			  sizeof(inbuf), outbuf, sizeof(outbuf), &outlen);
479 
480 	return rc;
481 }
482 
483 int efx_ef10_sriov_set_vf_mac(struct efx_nic *efx, int vf_i, const u8 *mac)
484 {
485 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
486 	struct ef10_vf *vf;
487 	int rc;
488 
489 	if (!nic_data->vf)
490 		return -EOPNOTSUPP;
491 
492 	if (vf_i >= efx->vf_count)
493 		return -EINVAL;
494 	vf = nic_data->vf + vf_i;
495 
496 	if (vf->efx) {
497 		efx_device_detach_sync(vf->efx);
498 		efx_net_stop(vf->efx->net_dev);
499 
500 		down_write(&vf->efx->filter_sem);
501 		vf->efx->type->filter_table_remove(vf->efx);
502 
503 		rc = efx_ef10_vadaptor_free(vf->efx, EVB_PORT_ID_ASSIGNED);
504 		if (rc) {
505 			up_write(&vf->efx->filter_sem);
506 			return rc;
507 		}
508 	}
509 
510 	rc = efx_ef10_evb_port_assign(efx, EVB_PORT_ID_NULL, vf_i);
511 	if (rc)
512 		return rc;
513 
514 	if (!is_zero_ether_addr(vf->mac)) {
515 		rc = efx_ef10_vport_del_vf_mac(efx, vf->vport_id, vf->mac);
516 		if (rc)
517 			return rc;
518 	}
519 
520 	if (!is_zero_ether_addr(mac)) {
521 		rc = efx_ef10_vport_add_mac(efx, vf->vport_id, mac);
522 		if (rc)
523 			goto fail;
524 
525 		if (vf->efx)
526 			eth_hw_addr_set(vf->efx->net_dev, mac);
527 	}
528 
529 	ether_addr_copy(vf->mac, mac);
530 
531 	rc = efx_ef10_evb_port_assign(efx, vf->vport_id, vf_i);
532 	if (rc)
533 		goto fail;
534 
535 	if (vf->efx) {
536 		/* VF cannot use the vport_id that the PF created */
537 		rc = efx_ef10_vadaptor_alloc(vf->efx, EVB_PORT_ID_ASSIGNED);
538 		if (rc) {
539 			up_write(&vf->efx->filter_sem);
540 			return rc;
541 		}
542 		vf->efx->type->filter_table_probe(vf->efx);
543 		up_write(&vf->efx->filter_sem);
544 		efx_net_open(vf->efx->net_dev);
545 		efx_device_attach_if_not_resetting(vf->efx);
546 	}
547 
548 	return 0;
549 
550 fail:
551 	eth_zero_addr(vf->mac);
552 	return rc;
553 }
554 
555 int efx_ef10_sriov_set_vf_vlan(struct efx_nic *efx, int vf_i, u16 vlan,
556 			       u8 qos)
557 {
558 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
559 	struct ef10_vf *vf;
560 	u16 new_vlan;
561 	int rc = 0, rc2 = 0;
562 
563 	if (vf_i >= efx->vf_count)
564 		return -EINVAL;
565 	if (qos != 0)
566 		return -EINVAL;
567 
568 	vf = nic_data->vf + vf_i;
569 
570 	new_vlan = (vlan == 0) ? EFX_EF10_NO_VLAN : vlan;
571 	if (new_vlan == vf->vlan)
572 		return 0;
573 
574 	if (vf->efx) {
575 		efx_device_detach_sync(vf->efx);
576 		efx_net_stop(vf->efx->net_dev);
577 
578 		mutex_lock(&vf->efx->mac_lock);
579 		down_write(&vf->efx->filter_sem);
580 		vf->efx->type->filter_table_remove(vf->efx);
581 
582 		rc = efx_ef10_vadaptor_free(vf->efx, EVB_PORT_ID_ASSIGNED);
583 		if (rc)
584 			goto restore_filters;
585 	}
586 
587 	if (vf->vport_assigned) {
588 		rc = efx_ef10_evb_port_assign(efx, EVB_PORT_ID_NULL, vf_i);
589 		if (rc) {
590 			netif_warn(efx, drv, efx->net_dev,
591 				   "Failed to change vlan on VF %d.\n", vf_i);
592 			netif_warn(efx, drv, efx->net_dev,
593 				   "This is likely because the VF is bound to a driver in a VM.\n");
594 			netif_warn(efx, drv, efx->net_dev,
595 				   "Please unload the driver in the VM.\n");
596 			goto restore_vadaptor;
597 		}
598 		vf->vport_assigned = 0;
599 	}
600 
601 	if (!is_zero_ether_addr(vf->mac)) {
602 		rc = efx_ef10_vport_del_mac(efx, vf->vport_id, vf->mac);
603 		if (rc)
604 			goto restore_evb_port;
605 	}
606 
607 	if (vf->vport_id) {
608 		rc = efx_ef10_vport_free(efx, vf->vport_id);
609 		if (rc)
610 			goto restore_mac;
611 		vf->vport_id = 0;
612 	}
613 
614 	/* Do the actual vlan change */
615 	vf->vlan = new_vlan;
616 
617 	/* Restore everything in reverse order */
618 	rc = efx_ef10_vport_alloc(efx, EVB_PORT_ID_ASSIGNED,
619 				  MC_CMD_VPORT_ALLOC_IN_VPORT_TYPE_NORMAL,
620 				  vf->vlan, &vf->vport_id);
621 	if (rc)
622 		goto reset_nic_up_write;
623 
624 restore_mac:
625 	if (!is_zero_ether_addr(vf->mac)) {
626 		rc2 = efx_ef10_vport_add_mac(efx, vf->vport_id, vf->mac);
627 		if (rc2) {
628 			eth_zero_addr(vf->mac);
629 			goto reset_nic_up_write;
630 		}
631 	}
632 
633 restore_evb_port:
634 	rc2 = efx_ef10_evb_port_assign(efx, vf->vport_id, vf_i);
635 	if (rc2)
636 		goto reset_nic_up_write;
637 	else
638 		vf->vport_assigned = 1;
639 
640 restore_vadaptor:
641 	if (vf->efx) {
642 		rc2 = efx_ef10_vadaptor_alloc(vf->efx, EVB_PORT_ID_ASSIGNED);
643 		if (rc2)
644 			goto reset_nic_up_write;
645 	}
646 
647 restore_filters:
648 	if (vf->efx) {
649 		rc2 = vf->efx->type->filter_table_probe(vf->efx);
650 		if (rc2)
651 			goto reset_nic_up_write;
652 
653 		up_write(&vf->efx->filter_sem);
654 		mutex_unlock(&vf->efx->mac_lock);
655 
656 		rc2 = efx_net_open(vf->efx->net_dev);
657 		if (rc2)
658 			goto reset_nic;
659 
660 		efx_device_attach_if_not_resetting(vf->efx);
661 	}
662 	return rc;
663 
664 reset_nic_up_write:
665 	if (vf->efx) {
666 		up_write(&vf->efx->filter_sem);
667 		mutex_unlock(&vf->efx->mac_lock);
668 	}
669 reset_nic:
670 	if (vf->efx) {
671 		netif_err(efx, drv, efx->net_dev,
672 			  "Failed to restore VF - scheduling reset.\n");
673 		efx_schedule_reset(vf->efx, RESET_TYPE_DATAPATH);
674 	} else {
675 		netif_err(efx, drv, efx->net_dev,
676 			  "Failed to restore the VF and cannot reset the VF "
677 			  "- VF is not functional.\n");
678 		netif_err(efx, drv, efx->net_dev,
679 			  "Please reload the driver attached to the VF.\n");
680 	}
681 
682 	return rc ? rc : rc2;
683 }
684 
685 static int efx_ef10_sriov_set_privilege_mask(struct efx_nic *efx, int vf_i,
686 					     u32 mask, u32 value)
687 {
688 	MCDI_DECLARE_BUF(pm_outbuf, MC_CMD_PRIVILEGE_MASK_OUT_LEN);
689 	MCDI_DECLARE_BUF(pm_inbuf, MC_CMD_PRIVILEGE_MASK_IN_LEN);
690 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
691 	u32 old_mask, new_mask;
692 	size_t outlen;
693 	int rc;
694 
695 	EFX_WARN_ON_PARANOID((value & ~mask) != 0);
696 
697 	/* Get privilege mask */
698 	MCDI_POPULATE_DWORD_2(pm_inbuf, PRIVILEGE_MASK_IN_FUNCTION,
699 			      PRIVILEGE_MASK_IN_FUNCTION_PF, nic_data->pf_index,
700 			      PRIVILEGE_MASK_IN_FUNCTION_VF, vf_i);
701 
702 	rc = efx_mcdi_rpc(efx, MC_CMD_PRIVILEGE_MASK,
703 			  pm_inbuf, sizeof(pm_inbuf),
704 			  pm_outbuf, sizeof(pm_outbuf), &outlen);
705 
706 	if (rc != 0)
707 		return rc;
708 	if (outlen != MC_CMD_PRIVILEGE_MASK_OUT_LEN)
709 		return -EIO;
710 
711 	old_mask = MCDI_DWORD(pm_outbuf, PRIVILEGE_MASK_OUT_OLD_MASK);
712 
713 	new_mask = old_mask & ~mask;
714 	new_mask |= value;
715 
716 	if (new_mask == old_mask)
717 		return 0;
718 
719 	new_mask |= MC_CMD_PRIVILEGE_MASK_IN_DO_CHANGE;
720 
721 	/* Set privilege mask */
722 	MCDI_SET_DWORD(pm_inbuf, PRIVILEGE_MASK_IN_NEW_MASK, new_mask);
723 
724 	rc = efx_mcdi_rpc(efx, MC_CMD_PRIVILEGE_MASK,
725 			  pm_inbuf, sizeof(pm_inbuf),
726 			  pm_outbuf, sizeof(pm_outbuf), &outlen);
727 
728 	if (rc != 0)
729 		return rc;
730 	if (outlen != MC_CMD_PRIVILEGE_MASK_OUT_LEN)
731 		return -EIO;
732 
733 	return 0;
734 }
735 
736 int efx_ef10_sriov_set_vf_spoofchk(struct efx_nic *efx, int vf_i, bool spoofchk)
737 {
738 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
739 
740 	/* Can't enable spoofchk if firmware doesn't support it. */
741 	if (!(nic_data->datapath_caps &
742 	      BIT(MC_CMD_GET_CAPABILITIES_OUT_TX_MAC_SECURITY_FILTERING_LBN)) &&
743 	    spoofchk)
744 		return -EOPNOTSUPP;
745 
746 	return efx_ef10_sriov_set_privilege_mask(efx, vf_i,
747 		MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING_TX,
748 		spoofchk ? 0 : MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING_TX);
749 }
750 
751 int efx_ef10_sriov_set_vf_link_state(struct efx_nic *efx, int vf_i,
752 				     int link_state)
753 {
754 	MCDI_DECLARE_BUF(inbuf, MC_CMD_LINK_STATE_MODE_IN_LEN);
755 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
756 
757 	BUILD_BUG_ON(IFLA_VF_LINK_STATE_AUTO !=
758 		     MC_CMD_LINK_STATE_MODE_IN_LINK_STATE_AUTO);
759 	BUILD_BUG_ON(IFLA_VF_LINK_STATE_ENABLE !=
760 		     MC_CMD_LINK_STATE_MODE_IN_LINK_STATE_UP);
761 	BUILD_BUG_ON(IFLA_VF_LINK_STATE_DISABLE !=
762 		     MC_CMD_LINK_STATE_MODE_IN_LINK_STATE_DOWN);
763 	MCDI_POPULATE_DWORD_2(inbuf, LINK_STATE_MODE_IN_FUNCTION,
764 			      LINK_STATE_MODE_IN_FUNCTION_PF,
765 			      nic_data->pf_index,
766 			      LINK_STATE_MODE_IN_FUNCTION_VF, vf_i);
767 	MCDI_SET_DWORD(inbuf, LINK_STATE_MODE_IN_NEW_MODE, link_state);
768 	return efx_mcdi_rpc(efx, MC_CMD_LINK_STATE_MODE, inbuf, sizeof(inbuf),
769 			    NULL, 0, NULL); /* don't care what old mode was */
770 }
771 
772 int efx_ef10_sriov_get_vf_config(struct efx_nic *efx, int vf_i,
773 				 struct ifla_vf_info *ivf)
774 {
775 	MCDI_DECLARE_BUF(inbuf, MC_CMD_LINK_STATE_MODE_IN_LEN);
776 	MCDI_DECLARE_BUF(outbuf, MC_CMD_LINK_STATE_MODE_OUT_LEN);
777 
778 	struct efx_ef10_nic_data *nic_data = efx->nic_data;
779 	struct ef10_vf *vf;
780 	size_t outlen;
781 	int rc;
782 
783 	if (vf_i >= efx->vf_count)
784 		return -EINVAL;
785 
786 	if (!nic_data->vf)
787 		return -EOPNOTSUPP;
788 
789 	vf = nic_data->vf + vf_i;
790 
791 	ivf->vf = vf_i;
792 	ivf->min_tx_rate = 0;
793 	ivf->max_tx_rate = 0;
794 	ether_addr_copy(ivf->mac, vf->mac);
795 	ivf->vlan = (vf->vlan == EFX_EF10_NO_VLAN) ? 0 : vf->vlan;
796 	ivf->qos = 0;
797 
798 	MCDI_POPULATE_DWORD_2(inbuf, LINK_STATE_MODE_IN_FUNCTION,
799 			      LINK_STATE_MODE_IN_FUNCTION_PF,
800 			      nic_data->pf_index,
801 			      LINK_STATE_MODE_IN_FUNCTION_VF, vf_i);
802 	MCDI_SET_DWORD(inbuf, LINK_STATE_MODE_IN_NEW_MODE,
803 		       MC_CMD_LINK_STATE_MODE_IN_DO_NOT_CHANGE);
804 	rc = efx_mcdi_rpc(efx, MC_CMD_LINK_STATE_MODE, inbuf, sizeof(inbuf),
805 			  outbuf, sizeof(outbuf), &outlen);
806 	if (rc)
807 		return rc;
808 	if (outlen < MC_CMD_LINK_STATE_MODE_OUT_LEN)
809 		return -EIO;
810 	ivf->linkstate = MCDI_DWORD(outbuf, LINK_STATE_MODE_OUT_OLD_MODE);
811 
812 	return 0;
813 }
814