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                 vf->efx->type->filter_table_remove(vf->efx);
 505
 506                 rc = efx_ef10_vadaptor_free(vf->efx, EVB_PORT_ID_ASSIGNED);
 507                 if (rc)
 508                         return rc;
 509         }
 510
 511         rc = efx_ef10_evb_port_assign(efx, EVB_PORT_ID_NULL, vf_i);
 512         if (rc)
 513                 return rc;
 514
 515         if (!is_zero_ether_addr(vf->mac)) {
 516                 rc = efx_ef10_vport_del_vf_mac(efx, vf->vport_id, vf->mac);
 517                 if (rc)
 518                         return rc;
 519         }
 520
 521         if (!is_zero_ether_addr(mac)) {
 522                 rc = efx_ef10_vport_add_mac(efx, vf->vport_id, mac);
 523                 if (rc)
 524                         goto fail;
 525
 526                 if (vf->efx)
 527                         eth_hw_addr_set(vf->efx->net_dev, mac);
 528         }
 529
 530         ether_addr_copy(vf->mac, mac);
 531
 532         rc = efx_ef10_evb_port_assign(efx, vf->vport_id, vf_i);
 533         if (rc)
 534                 goto fail;
 535
 536         if (vf->efx) {
 537                 /* VF cannot use the vport_id that the PF created */
 538                 rc = efx_ef10_vadaptor_alloc(vf->efx, EVB_PORT_ID_ASSIGNED);
 539                 if (rc)
 540                         return rc;
 541                 vf->efx->type->filter_table_probe(vf->efx);
 542                 efx_net_open(vf->efx->net_dev);
 543                 efx_device_attach_if_not_resetting(vf->efx);
 544         }
 545
 546         return 0;
 547
 548 fail:
 549         eth_zero_addr(vf->mac);
 550         return rc;
 551 }
 552
 553 int efx_ef10_sriov_set_vf_vlan(struct efx_nic *efx, int vf_i, u16 vlan,
 554                                u8 qos)
 555 {
 556         struct efx_ef10_nic_data *nic_data = efx->nic_data;
 557         struct ef10_vf *vf;
 558         u16 new_vlan;
 559         int rc = 0, rc2 = 0;
 560
 561         if (vf_i >= efx->vf_count)
 562                 return -EINVAL;
 563         if (qos != 0)
 564                 return -EINVAL;
 565
 566         vf = nic_data->vf + vf_i;
 567
 568         new_vlan = (vlan == 0) ? EFX_EF10_NO_VLAN : vlan;
 569         if (new_vlan == vf->vlan)
 570                 return 0;
 571
 572         if (vf->efx) {
 573                 efx_device_detach_sync(vf->efx);
 574                 efx_net_stop(vf->efx->net_dev);
 575
 576                 mutex_lock(&vf->efx->mac_lock);
 577                 vf->efx->type->filter_table_remove(vf->efx);
 578
 579                 rc = efx_ef10_vadaptor_free(vf->efx, EVB_PORT_ID_ASSIGNED);
 580                 if (rc)
 581                         goto restore_filters;
 582         }
 583
 584         if (vf->vport_assigned) {
 585                 rc = efx_ef10_evb_port_assign(efx, EVB_PORT_ID_NULL, vf_i);
 586                 if (rc) {
 587                         netif_warn(efx, drv, efx->net_dev,
 588                                    "Failed to change vlan on VF %d.\n", vf_i);
 589                         netif_warn(efx, drv, efx->net_dev,
 590                                    "This is likely because the VF is bound to a driver in a VM.\n");
 591                         netif_warn(efx, drv, efx->net_dev,
 592                                    "Please unload the driver in the VM.\n");
 593                         goto restore_vadaptor;
 594                 }
 595                 vf->vport_assigned = 0;
 596         }
 597
 598         if (!is_zero_ether_addr(vf->mac)) {
 599                 rc = efx_ef10_vport_del_mac(efx, vf->vport_id, vf->mac);
 600                 if (rc)
 601                         goto restore_evb_port;
 602         }
 603
 604         if (vf->vport_id) {
 605                 rc = efx_ef10_vport_free(efx, vf->vport_id);
 606                 if (rc)
 607                         goto restore_mac;
 608                 vf->vport_id = 0;
 609         }
 610
 611         /* Do the actual vlan change */
 612         vf->vlan = new_vlan;
 613
 614         /* Restore everything in reverse order */
 615         rc = efx_ef10_vport_alloc(efx, EVB_PORT_ID_ASSIGNED,
 616                                   MC_CMD_VPORT_ALLOC_IN_VPORT_TYPE_NORMAL,
 617                                   vf->vlan, &vf->vport_id);
 618         if (rc)
 619                 goto reset_nic_up_write;
 620
 621 restore_mac:
 622         if (!is_zero_ether_addr(vf->mac)) {
 623                 rc2 = efx_ef10_vport_add_mac(efx, vf->vport_id, vf->mac);
 624                 if (rc2) {
 625                         eth_zero_addr(vf->mac);
 626                         goto reset_nic_up_write;
 627                 }
 628         }
 629
 630 restore_evb_port:
 631         rc2 = efx_ef10_evb_port_assign(efx, vf->vport_id, vf_i);
 632         if (rc2)
 633                 goto reset_nic_up_write;
 634         else
 635                 vf->vport_assigned = 1;
 636
 637 restore_vadaptor:
 638         if (vf->efx) {
 639                 rc2 = efx_ef10_vadaptor_alloc(vf->efx, EVB_PORT_ID_ASSIGNED);
 640                 if (rc2)
 641                         goto reset_nic_up_write;
 642         }
 643
 644 restore_filters:
 645         if (vf->efx) {
 646                 rc2 = vf->efx->type->filter_table_probe(vf->efx);
 647                 if (rc2)
 648                         goto reset_nic_up_write;
 649
 650                 mutex_unlock(&vf->efx->mac_lock);
 651
 652                 rc2 = efx_net_open(vf->efx->net_dev);
 653                 if (rc2)
 654                         goto reset_nic;
 655
 656                 efx_device_attach_if_not_resetting(vf->efx);
 657         }
 658         return rc;
 659
 660 reset_nic_up_write:
 661         if (vf->efx)
 662                 mutex_unlock(&vf->efx->mac_lock);
 663 reset_nic:
 664         if (vf->efx) {
 665                 netif_err(efx, drv, efx->net_dev,
 666                           "Failed to restore VF - scheduling reset.\n");
 667                 efx_schedule_reset(vf->efx, RESET_TYPE_DATAPATH);
 668         } else {
 669                 netif_err(efx, drv, efx->net_dev,
 670                           "Failed to restore the VF and cannot reset the VF "
 671                           "- VF is not functional.\n");
 672                 netif_err(efx, drv, efx->net_dev,
 673                           "Please reload the driver attached to the VF.\n");
 674         }
 675
 676         return rc ? rc : rc2;
 677 }
 678
 679 static int efx_ef10_sriov_set_privilege_mask(struct efx_nic *efx, int vf_i,
 680                                              u32 mask, u32 value)
 681 {
 682         MCDI_DECLARE_BUF(pm_outbuf, MC_CMD_PRIVILEGE_MASK_OUT_LEN);
 683         MCDI_DECLARE_BUF(pm_inbuf, MC_CMD_PRIVILEGE_MASK_IN_LEN);
 684         struct efx_ef10_nic_data *nic_data = efx->nic_data;
 685         u32 old_mask, new_mask;
 686         size_t outlen;
 687         int rc;
 688
 689         EFX_WARN_ON_PARANOID((value & ~mask) != 0);
 690
 691         /* Get privilege mask */
 692         MCDI_POPULATE_DWORD_2(pm_inbuf, PRIVILEGE_MASK_IN_FUNCTION,
 693                               PRIVILEGE_MASK_IN_FUNCTION_PF, nic_data->pf_index,
 694                               PRIVILEGE_MASK_IN_FUNCTION_VF, vf_i);
 695
 696         rc = efx_mcdi_rpc(efx, MC_CMD_PRIVILEGE_MASK,
 697                           pm_inbuf, sizeof(pm_inbuf),
 698                           pm_outbuf, sizeof(pm_outbuf), &outlen);
 699
 700         if (rc != 0)
 701                 return rc;
 702         if (outlen != MC_CMD_PRIVILEGE_MASK_OUT_LEN)
 703                 return -EIO;
 704
 705         old_mask = MCDI_DWORD(pm_outbuf, PRIVILEGE_MASK_OUT_OLD_MASK);
 706
 707         new_mask = old_mask & ~mask;
 708         new_mask |= value;
 709
 710         if (new_mask == old_mask)
 711                 return 0;
 712
 713         new_mask |= MC_CMD_PRIVILEGE_MASK_IN_DO_CHANGE;
 714
 715         /* Set privilege mask */
 716         MCDI_SET_DWORD(pm_inbuf, PRIVILEGE_MASK_IN_NEW_MASK, new_mask);
 717
 718         rc = efx_mcdi_rpc(efx, MC_CMD_PRIVILEGE_MASK,
 719                           pm_inbuf, sizeof(pm_inbuf),
 720                           pm_outbuf, sizeof(pm_outbuf), &outlen);
 721
 722         if (rc != 0)
 723                 return rc;
 724         if (outlen != MC_CMD_PRIVILEGE_MASK_OUT_LEN)
 725                 return -EIO;
 726
 727         return 0;
 728 }
 729
 730 int efx_ef10_sriov_set_vf_spoofchk(struct efx_nic *efx, int vf_i, bool spoofchk)
 731 {
 732         struct efx_ef10_nic_data *nic_data = efx->nic_data;
 733
 734         /* Can't enable spoofchk if firmware doesn't support it. */
 735         if (!(nic_data->datapath_caps &
 736               BIT(MC_CMD_GET_CAPABILITIES_OUT_TX_MAC_SECURITY_FILTERING_LBN)) &&
 737             spoofchk)
 738                 return -EOPNOTSUPP;
 739
 740         return efx_ef10_sriov_set_privilege_mask(efx, vf_i,
 741                 MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING_TX,
 742                 spoofchk ? 0 : MC_CMD_PRIVILEGE_MASK_IN_GRP_MAC_SPOOFING_TX);
 743 }
 744
 745 int efx_ef10_sriov_set_vf_link_state(struct efx_nic *efx, int vf_i,
 746                                      int link_state)
 747 {
 748         MCDI_DECLARE_BUF(inbuf, MC_CMD_LINK_STATE_MODE_IN_LEN);
 749         struct efx_ef10_nic_data *nic_data = efx->nic_data;
 750
 751         BUILD_BUG_ON(IFLA_VF_LINK_STATE_AUTO !=
 752                      MC_CMD_LINK_STATE_MODE_IN_LINK_STATE_AUTO);
 753         BUILD_BUG_ON(IFLA_VF_LINK_STATE_ENABLE !=
 754                      MC_CMD_LINK_STATE_MODE_IN_LINK_STATE_UP);
 755         BUILD_BUG_ON(IFLA_VF_LINK_STATE_DISABLE !=
 756                      MC_CMD_LINK_STATE_MODE_IN_LINK_STATE_DOWN);
 757         MCDI_POPULATE_DWORD_2(inbuf, LINK_STATE_MODE_IN_FUNCTION,
 758                               LINK_STATE_MODE_IN_FUNCTION_PF,
 759                               nic_data->pf_index,
 760                               LINK_STATE_MODE_IN_FUNCTION_VF, vf_i);
 761         MCDI_SET_DWORD(inbuf, LINK_STATE_MODE_IN_NEW_MODE, link_state);
 762         return efx_mcdi_rpc(efx, MC_CMD_LINK_STATE_MODE, inbuf, sizeof(inbuf),
 763                             NULL, 0, NULL); /* don't care what old mode was */
 764 }
 765
 766 int efx_ef10_sriov_get_vf_config(struct efx_nic *efx, int vf_i,
 767                                  struct ifla_vf_info *ivf)
 768 {
 769         MCDI_DECLARE_BUF(inbuf, MC_CMD_LINK_STATE_MODE_IN_LEN);
 770         MCDI_DECLARE_BUF(outbuf, MC_CMD_LINK_STATE_MODE_OUT_LEN);
 771
 772         struct efx_ef10_nic_data *nic_data = efx->nic_data;
 773         struct ef10_vf *vf;
 774         size_t outlen;
 775         int rc;
 776
 777         if (vf_i >= efx->vf_count)
 778                 return -EINVAL;
 779
 780         if (!nic_data->vf)
 781                 return -EOPNOTSUPP;
 782
 783         vf = nic_data->vf + vf_i;
 784
 785         ivf->vf = vf_i;
 786         ivf->min_tx_rate = 0;
 787         ivf->max_tx_rate = 0;
 788         ether_addr_copy(ivf->mac, vf->mac);
 789         ivf->vlan = (vf->vlan == EFX_EF10_NO_VLAN) ? 0 : vf->vlan;
 790         ivf->qos = 0;
 791
 792         MCDI_POPULATE_DWORD_2(inbuf, LINK_STATE_MODE_IN_FUNCTION,
 793                               LINK_STATE_MODE_IN_FUNCTION_PF,
 794                               nic_data->pf_index,
 795                               LINK_STATE_MODE_IN_FUNCTION_VF, vf_i);
 796         MCDI_SET_DWORD(inbuf, LINK_STATE_MODE_IN_NEW_MODE,
 797                        MC_CMD_LINK_STATE_MODE_IN_DO_NOT_CHANGE);
 798         rc = efx_mcdi_rpc(efx, MC_CMD_LINK_STATE_MODE, inbuf, sizeof(inbuf),
 799                           outbuf, sizeof(outbuf), &outlen);
 800         if (rc)
 801                 return rc;
 802         if (outlen < MC_CMD_LINK_STATE_MODE_OUT_LEN)
 803                 return -EIO;
 804         ivf->linkstate = MCDI_DWORD(outbuf, LINK_STATE_MODE_OUT_OLD_MODE);
 805
 806         return 0;
 807 }