drivers/net/ethernet/sfc/ef10_sriov.c

   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         struct efx_ef10_nic_data *nic_data = efx->nic_data;
 412         unsigned int vfs_assigned = pci_vfs_assigned(dev);
 413         int i, rc = 0;
 414
 415         if (vfs_assigned && !force) {
 416                 netif_info(efx, drv, efx->net_dev, "VFs are assigned to guests; "
 417                            "please detach them before disabling SR-IOV\n");
 418                 return -EBUSY;
 419         }
 420
 421         if (!vfs_assigned) {
 422                 for (i = 0; i < efx->vf_count; i++)
 423                         nic_data->vf[i].pci_dev = NULL;
 424                 pci_disable_sriov(dev);
 425         } else {
 426                 rc = -EBUSY;
 427         }
 428
 429         efx_ef10_sriov_free_vf_vswitching(efx);
 430         efx->vf_count = 0;
 431         return rc;
 432 }
 433
 434 int efx_ef10_sriov_configure(struct efx_nic *efx, int num_vfs)
 435 {
 436         if (num_vfs == 0)
 437                 return efx_ef10_pci_sriov_disable(efx, false);
 438         else
 439                 return efx_ef10_pci_sriov_enable(efx, num_vfs);
 440 }
 441
 442 int efx_ef10_sriov_init(struct efx_nic *efx)
 443 {
 444         return 0;
 445 }
 446
 447 void efx_ef10_sriov_fini(struct efx_nic *efx)
 448 {
 449         struct efx_ef10_nic_data *nic_data = efx->nic_data;
 450         int rc;
 451
 452         if (!nic_data->vf) {
 453                 /* Remove any un-assigned orphaned VFs. This can happen if the PF driver
 454                  * was unloaded while any VF was assigned to a guest (using Xen, only).
 455                  */
 456                 if (pci_num_vf(efx->pci_dev) && !pci_vfs_assigned(efx->pci_dev))
 457                         pci_disable_sriov(efx->pci_dev);
 458                 return;
 459         }
 460
 461         /* Disable SRIOV and remove any VFs in the host */
 462         rc = efx_ef10_pci_sriov_disable(efx, true);
 463         if (rc)
 464                 netif_dbg(efx, drv, efx->net_dev,
 465                           "Disabling SRIOV was not successful rc=%d\n", rc);
 466         else
 467                 netif_dbg(efx, drv, efx->net_dev, "SRIOV disabled\n");
 468 }
 469
 470 static int efx_ef10_vport_del_vf_mac(struct efx_nic *efx, unsigned int port_id,
 471                                      u8 *mac)
 472 {
 473         MCDI_DECLARE_BUF(inbuf, MC_CMD_VPORT_DEL_MAC_ADDRESS_IN_LEN);
 474         MCDI_DECLARE_BUF_ERR(outbuf);
 475         size_t outlen;
 476         int rc;
 477
 478         MCDI_SET_DWORD(inbuf, VPORT_DEL_MAC_ADDRESS_IN_VPORT_ID, port_id);
 479         ether_addr_copy(MCDI_PTR(inbuf, VPORT_DEL_MAC_ADDRESS_IN_MACADDR), mac);
 480
 481         rc = efx_mcdi_rpc(efx, MC_CMD_VPORT_DEL_MAC_ADDRESS, inbuf,
 482                           sizeof(inbuf), outbuf, sizeof(outbuf), &outlen);
 483
 484         return rc;
 485 }
 486
 487 int efx_ef10_sriov_set_vf_mac(struct efx_nic *efx, int vf_i, const u8 *mac)
 488 {
 489         struct efx_ef10_nic_data *nic_data = efx->nic_data;
 490         struct ef10_vf *vf;
 491         int rc;
 492
 493         if (!nic_data->vf)
 494                 return -EOPNOTSUPP;
 495
 496         if (vf_i >= efx->vf_count)
 497                 return -EINVAL;
 498         vf = nic_data->vf + vf_i;
 499
 500         if (vf->efx) {
 501                 efx_device_detach_sync(vf->efx);
 502                 efx_net_stop(vf->efx->net_dev);
 503
 504                 down_write(&vf->efx->filter_sem);
 505                 vf->efx->type->filter_table_remove(vf->efx);
 506
 507                 rc = efx_ef10_vadaptor_free(vf->efx, EVB_PORT_ID_ASSIGNED);
 508                 if (rc) {
 509                         up_write(&vf->efx->filter_sem);
 510                         return rc;
 511                 }
 512         }
 513
 514         rc = efx_ef10_evb_port_assign(efx, EVB_PORT_ID_NULL, vf_i);
 515         if (rc)
 516                 return rc;
 517
 518         if (!is_zero_ether_addr(vf->mac)) {
 519                 rc = efx_ef10_vport_del_vf_mac(efx, vf->vport_id, vf->mac);
 520                 if (rc)
 521                         return rc;
 522         }
 523
 524         if (!is_zero_ether_addr(mac)) {
 525                 rc = efx_ef10_vport_add_mac(efx, vf->vport_id, mac);
 526                 if (rc)
 527                         goto fail;
 528
 529                 if (vf->efx)
 530                         eth_hw_addr_set(vf->efx->net_dev, mac);
 531         }
 532
 533         ether_addr_copy(vf->mac, mac);
 534
 535         rc = efx_ef10_evb_port_assign(efx, vf->vport_id, vf_i);
 536         if (rc)
 537                 goto fail;
 538
 539         if (vf->efx) {
 540                 /* VF cannot use the vport_id that the PF created */
 541                 rc = efx_ef10_vadaptor_alloc(vf->efx, EVB_PORT_ID_ASSIGNED);
 542                 if (rc) {
 543                         up_write(&vf->efx->filter_sem);
 544                         return rc;
 545                 }
 546                 vf->efx->type->filter_table_probe(vf->efx);
 547                 up_write(&vf->efx->filter_sem);
 548                 efx_net_open(vf->efx->net_dev);
 549                 efx_device_attach_if_not_resetting(vf->efx);
 550         }
 551
 552         return 0;
 553
 554 fail:
 555         eth_zero_addr(vf->mac);
 556         return rc;
 557 }
 558
 559 int efx_ef10_sriov_set_vf_vlan(struct efx_nic *efx, int vf_i, u16 vlan,
 560                                u8 qos)
 561 {
 562         struct efx_ef10_nic_data *nic_data = efx->nic_data;
 563         struct ef10_vf *vf;
 564         u16 new_vlan;
 565         int rc = 0, rc2 = 0;
 566
 567         if (vf_i >= efx->vf_count)
 568                 return -EINVAL;
 569         if (qos != 0)
 570                 return -EINVAL;
 571
 572         vf = nic_data->vf + vf_i;
 573
 574         new_vlan = (vlan == 0) ? EFX_EF10_NO_VLAN : vlan;
 575         if (new_vlan == vf->vlan)
 576                 return 0;
 577
 578         if (vf->efx) {
 579                 efx_device_detach_sync(vf->efx);
 580                 efx_net_stop(vf->efx->net_dev);
 581
 582                 mutex_lock(&vf->efx->mac_lock);
 583                 down_write(&vf->efx->filter_sem);
 584                 vf->efx->type->filter_table_remove(vf->efx);
 585
 586                 rc = efx_ef10_vadaptor_free(vf->efx, EVB_PORT_ID_ASSIGNED);
 587                 if (rc)
 588                         goto restore_filters;
 589         }
 590
 591         if (vf->vport_assigned) {
 592                 rc = efx_ef10_evb_port_assign(efx, EVB_PORT_ID_NULL, vf_i);
 593                 if (rc) {
 594                         netif_warn(efx, drv, efx->net_dev,
 595                                    "Failed to change vlan on VF %d.\n", vf_i);
 596                         netif_warn(efx, drv, efx->net_dev,
 597                                    "This is likely because the VF is bound to a driver in a VM.\n");
 598                         netif_warn(efx, drv, efx->net_dev,
 599                                    "Please unload the driver in the VM.\n");
 600                         goto restore_vadaptor;
 601                 }
 602                 vf->vport_assigned = 0;
 603         }
 604
 605         if (!is_zero_ether_addr(vf->mac)) {
 606                 rc = efx_ef10_vport_del_mac(efx, vf->vport_id, vf->mac);
 607                 if (rc)
 608                         goto restore_evb_port;
 609         }
 610
 611         if (vf->vport_id) {
 612                 rc = efx_ef10_vport_free(efx, vf->vport_id);
 613                 if (rc)
 614                         goto restore_mac;
 615                 vf->vport_id = 0;
 616         }
 617
 618         /* Do the actual vlan change */
 619         vf->vlan = new_vlan;
 620
 621         /* Restore everything in reverse order */
 622         rc = efx_ef10_vport_alloc(efx, EVB_PORT_ID_ASSIGNED,
 623                                   MC_CMD_VPORT_ALLOC_IN_VPORT_TYPE_NORMAL,
 624                                   vf->vlan, &vf->vport_id);
 625         if (rc)
 626                 goto reset_nic_up_write;
 627
 628 restore_mac:
 629         if (!is_zero_ether_addr(vf->mac)) {
 630                 rc2 = efx_ef10_vport_add_mac(efx, vf->vport_id, vf->mac);
 631                 if (rc2) {
 632                         eth_zero_addr(vf->mac);
 633                         goto reset_nic_up_write;
 634                 }
 635         }
 636
 637 restore_evb_port:
 638         rc2 = efx_ef10_evb_port_assign(efx, vf->vport_id, vf_i);
 639         if (rc2)
 640                 goto reset_nic_up_write;
 641         else
 642                 vf->vport_assigned = 1;
 643
 644 restore_vadaptor:
 645         if (vf->efx) {
 646                 rc2 = efx_ef10_vadaptor_alloc(vf->efx, EVB_PORT_ID_ASSIGNED);
 647                 if (rc2)
 648                         goto reset_nic_up_write;
 649         }
 650
 651 restore_filters:
 652         if (vf->efx) {
 653                 rc2 = vf->efx->type->filter_table_probe(vf->efx);
 654                 if (rc2)
 655                         goto reset_nic_up_write;
 656
 657                 up_write(&vf->efx->filter_sem);
 658                 mutex_unlock(&vf->efx->mac_lock);
 659
 660                 rc2 = efx_net_open(vf->efx->net_dev);
 661                 if (rc2)
 662                         goto reset_nic;
 663
 664                 efx_device_attach_if_not_resetting(vf->efx);
 665         }
 666         return rc;
 667
 668 reset_nic_up_write:
 669         if (vf->efx) {
 670                 up_write(&vf->efx->filter_sem);
 671                 mutex_unlock(&vf->efx->mac_lock);
 672         }
 673 reset_nic:
 674         if (vf->efx) {
 675                 netif_err(efx, drv, efx->net_dev,
 676                           "Failed to restore VF - scheduling reset.\n");
 677                 efx_schedule_reset(vf->efx, RESET_TYPE_DATAPATH);
 678         } else {
 679                 netif_err(efx, drv, efx->net_dev,
 680                           "Failed to restore the VF and cannot reset the VF "
 681                           "- VF is not functional.\n");
 682                 netif_err(efx, drv, efx->net_dev,
 683                           "Please reload the driver attached to the VF.\n");
 684         }
 685
 686         return rc ? rc : rc2;
 687 }
 688
 689 static int efx_ef10_sriov_set_privilege_mask(struct efx_nic *efx, int vf_i,
 690                                              u32 mask, u32 value)
 691 {
 692         MCDI_DECLARE_BUF(pm_outbuf, MC_CMD_PRIVILEGE_MASK_OUT_LEN);
 693         MCDI_DECLARE_BUF(pm_inbuf, MC_CMD_PRIVILEGE_MASK_IN_LEN);
 694         struct efx_ef10_nic_data *nic_data = efx->nic_data;
 695         u32 old_mask, new_mask;
 696         size_t outlen;
 697         int rc;
 698
 699         EFX_WARN_ON_PARANOID((value & ~mask) != 0);
 700
 701         /* Get privilege mask */
 702         MCDI_POPULATE_DWORD_2(pm_inbuf, PRIVILEGE_MASK_IN_FUNCTION,
 703                               PRIVILEGE_MASK_IN_FUNCTION_PF, nic_data->pf_index,
 704                               PRIVILEGE_MASK_IN_FUNCTION_VF, vf_i);
 705
 706         rc = efx_mcdi_rpc(efx, MC_CMD_PRIVILEGE_MASK,
 707                           pm_inbuf, sizeof(pm_inbuf),
 708                           pm_outbuf, sizeof(pm_outbuf), &outlen);
 709
 710         if (rc != 0)
 711                 return rc;
 712         if (outlen != MC_CMD_PRIVILEGE_MASK_OUT_LEN)
 713                 return -EIO;
 714
 715         old_mask = MCDI_DWORD(pm_outbuf, PRIVILEGE_MASK_OUT_OLD_MASK);
 716
 717         new_mask = old_mask & ~mask;
 718         new_mask |= value;
 719
 720         if (new_mask == old_mask)
 721                 return 0;
 722
 723         new_mask |= MC_CMD_PRIVILEGE_MASK_IN_DO_CHANGE;
 724
 725         /* Set privilege mask */
 726         MCDI_SET_DWORD(pm_inbuf, PRIVILEGE_MASK_IN_NEW_MASK, new_mask);
 727
 728         rc = efx_mcdi_rpc(efx, MC_CMD_PRIVILEGE_MASK,
 729                           pm_inbuf, sizeof(pm_inbuf),
 730                           pm_outbuf, sizeof(pm_outbuf), &outlen);
 731
 732         if (rc != 0)
 733                 return rc;
 734         if (outlen != MC_CMD_PRIVILEGE_MASK_OUT_LEN)
 735                 return -EIO;
 736
 737         return 0;
 738 }
 739
 740 int efx_ef10_sriov_set_vf_spoofchk(struct efx_nic *efx, int vf_i, bool spoofchk)
 741 {
 742         struct efx_ef10_nic_data *nic_data = efx->nic_data;
 743
 744         /* Can't enable spoofchk if firmware doesn't support it. */
 745         if (!(nic_data->datapath_caps &
 746               BIT(MC_CMD_GET_CAPABILITIES_OUT_TX_MAC_SECURITY_FILTERING_LBN)) &&
 747             spoofchk)
 748                 return -EOPNOTSUPP;
 749
 750         return efx_ef10_sriov_set_privilege_mask(efx, vf_i,
 751                 MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING_TX,
 752                 spoofchk ? 0 : MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING_TX);
 753 }
 754
 755 int efx_ef10_sriov_set_vf_link_state(struct efx_nic *efx, int vf_i,
 756                                      int link_state)
 757 {
 758         MCDI_DECLARE_BUF(inbuf, MC_CMD_LINK_STATE_MODE_IN_LEN);
 759         struct efx_ef10_nic_data *nic_data = efx->nic_data;
 760
 761         BUILD_BUG_ON(IFLA_VF_LINK_STATE_AUTO !=
 762                      MC_CMD_LINK_STATE_MODE_IN_LINK_STATE_AUTO);
 763         BUILD_BUG_ON(IFLA_VF_LINK_STATE_ENABLE !=
 764                      MC_CMD_LINK_STATE_MODE_IN_LINK_STATE_UP);
 765         BUILD_BUG_ON(IFLA_VF_LINK_STATE_DISABLE !=
 766                      MC_CMD_LINK_STATE_MODE_IN_LINK_STATE_DOWN);
 767         MCDI_POPULATE_DWORD_2(inbuf, LINK_STATE_MODE_IN_FUNCTION,
 768                               LINK_STATE_MODE_IN_FUNCTION_PF,
 769                               nic_data->pf_index,
 770                               LINK_STATE_MODE_IN_FUNCTION_VF, vf_i);
 771         MCDI_SET_DWORD(inbuf, LINK_STATE_MODE_IN_NEW_MODE, link_state);
 772         return efx_mcdi_rpc(efx, MC_CMD_LINK_STATE_MODE, inbuf, sizeof(inbuf),
 773                             NULL, 0, NULL); /* don't care what old mode was */
 774 }
 775
 776 int efx_ef10_sriov_get_vf_config(struct efx_nic *efx, int vf_i,
 777                                  struct ifla_vf_info *ivf)
 778 {
 779         MCDI_DECLARE_BUF(inbuf, MC_CMD_LINK_STATE_MODE_IN_LEN);
 780         MCDI_DECLARE_BUF(outbuf, MC_CMD_LINK_STATE_MODE_OUT_LEN);
 781
 782         struct efx_ef10_nic_data *nic_data = efx->nic_data;
 783         struct ef10_vf *vf;
 784         size_t outlen;
 785         int rc;
 786
 787         if (vf_i >= efx->vf_count)
 788                 return -EINVAL;
 789
 790         if (!nic_data->vf)
 791                 return -EOPNOTSUPP;
 792
 793         vf = nic_data->vf + vf_i;
 794
 795         ivf->vf = vf_i;
 796         ivf->min_tx_rate = 0;
 797         ivf->max_tx_rate = 0;
 798         ether_addr_copy(ivf->mac, vf->mac);
 799         ivf->vlan = (vf->vlan == EFX_EF10_NO_VLAN) ? 0 : vf->vlan;
 800         ivf->qos = 0;
 801
 802         MCDI_POPULATE_DWORD_2(inbuf, LINK_STATE_MODE_IN_FUNCTION,
 803                               LINK_STATE_MODE_IN_FUNCTION_PF,
 804                               nic_data->pf_index,
 805                               LINK_STATE_MODE_IN_FUNCTION_VF, vf_i);
 806         MCDI_SET_DWORD(inbuf, LINK_STATE_MODE_IN_NEW_MODE,
 807                        MC_CMD_LINK_STATE_MODE_IN_DO_NOT_CHANGE);
 808         rc = efx_mcdi_rpc(efx, MC_CMD_LINK_STATE_MODE, inbuf, sizeof(inbuf),
 809                           outbuf, sizeof(outbuf), &outlen);
 810         if (rc)
 811                 return rc;
 812         if (outlen < MC_CMD_LINK_STATE_MODE_OUT_LEN)
 813                 return -EIO;
 814         ivf->linkstate = MCDI_DWORD(outbuf, LINK_STATE_MODE_OUT_OLD_MODE);
 815
 816         return 0;
 817 }