drivers/net/ethernet/intel/ice/ice_vf_lib.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (C) 2022, Intel Corporation. */
   3
   4 #include "ice_vf_lib_private.h"
   5 #include "ice.h"
   6 #include "ice_lib.h"
   7 #include "ice_fltr.h"
   8 #include "ice_virtchnl_allowlist.h"
   9
  10 /* Public functions which may be accessed by all driver files */
  11
  12 /**
  13  * ice_get_vf_by_id - Get pointer to VF by ID
  14  * @pf: the PF private structure
  15  * @vf_id: the VF ID to locate
  16  *
  17  * Locate and return a pointer to the VF structure associated with a given ID.
  18  * Returns NULL if the ID does not have a valid VF structure associated with
  19  * it.
  20  *
  21  * This function takes a reference to the VF, which must be released by
  22  * calling ice_put_vf() once the caller is finished accessing the VF structure
  23  * returned.
  24  */
  25 struct ice_vf *ice_get_vf_by_id(struct ice_pf *pf, u16 vf_id)
  26 {
  27         struct ice_vf *vf;
  28
  29         rcu_read_lock();
  30         hash_for_each_possible_rcu(pf->vfs.table, vf, entry, vf_id) {
  31                 if (vf->vf_id == vf_id) {
  32                         struct ice_vf *found;
  33
  34                         if (kref_get_unless_zero(&vf->refcnt))
  35                                 found = vf;
  36                         else
  37                                 found = NULL;
  38
  39                         rcu_read_unlock();
  40                         return found;
  41                 }
  42         }
  43         rcu_read_unlock();
  44
  45         return NULL;
  46 }
  47
  48 /**
  49  * ice_release_vf - Release VF associated with a refcount
  50  * @ref: the kref decremented to zero
  51  *
  52  * Callback function for kref_put to release a VF once its reference count has
  53  * hit zero.
  54  */
  55 static void ice_release_vf(struct kref *ref)
  56 {
  57         struct ice_vf *vf = container_of(ref, struct ice_vf, refcnt);
  58
  59         vf->vf_ops->free(vf);
  60 }
  61
  62 /**
  63  * ice_put_vf - Release a reference to a VF
  64  * @vf: the VF structure to decrease reference count on
  65  *
  66  * Decrease the reference count for a VF, and free the entry if it is no
  67  * longer in use.
  68  *
  69  * This must be called after ice_get_vf_by_id() once the reference to the VF
  70  * structure is no longer used. Otherwise, the VF structure will never be
  71  * freed.
  72  */
  73 void ice_put_vf(struct ice_vf *vf)
  74 {
  75         kref_put(&vf->refcnt, ice_release_vf);
  76 }
  77
  78 /**
  79  * ice_has_vfs - Return true if the PF has any associated VFs
  80  * @pf: the PF private structure
  81  *
  82  * Return whether or not the PF has any allocated VFs.
  83  *
  84  * Note that this function only guarantees that there are no VFs at the point
  85  * of calling it. It does not guarantee that no more VFs will be added.
  86  */
  87 bool ice_has_vfs(struct ice_pf *pf)
  88 {
  89         /* A simple check that the hash table is not empty does not require
  90          * the mutex or rcu_read_lock.
  91          */
  92         return !hash_empty(pf->vfs.table);
  93 }
  94
  95 /**
  96  * ice_get_num_vfs - Get number of allocated VFs
  97  * @pf: the PF private structure
  98  *
  99  * Return the total number of allocated VFs. NOTE: VF IDs are not guaranteed
 100  * to be contiguous. Do not assume that a VF ID is guaranteed to be less than
 101  * the output of this function.
 102  */
 103 u16 ice_get_num_vfs(struct ice_pf *pf)
 104 {
 105         struct ice_vf *vf;
 106         unsigned int bkt;
 107         u16 num_vfs = 0;
 108
 109         rcu_read_lock();
 110         ice_for_each_vf_rcu(pf, bkt, vf)
 111                 num_vfs++;
 112         rcu_read_unlock();
 113
 114         return num_vfs;
 115 }
 116
 117 /**
 118  * ice_get_vf_vsi - get VF's VSI based on the stored index
 119  * @vf: VF used to get VSI
 120  */
 121 struct ice_vsi *ice_get_vf_vsi(struct ice_vf *vf)
 122 {
 123         if (vf->lan_vsi_idx == ICE_NO_VSI)
 124                 return NULL;
 125
 126         return vf->pf->vsi[vf->lan_vsi_idx];
 127 }
 128
 129 /**
 130  * ice_is_vf_disabled
 131  * @vf: pointer to the VF info
 132  *
 133  * If the PF has been disabled, there is no need resetting VF until PF is
 134  * active again. Similarly, if the VF has been disabled, this means something
 135  * else is resetting the VF, so we shouldn't continue.
 136  *
 137  * Returns true if the caller should consider the VF as disabled whether
 138  * because that single VF is explicitly disabled or because the PF is
 139  * currently disabled.
 140  */
 141 bool ice_is_vf_disabled(struct ice_vf *vf)
 142 {
 143         struct ice_pf *pf = vf->pf;
 144
 145         return (test_bit(ICE_VF_DIS, pf->state) ||
 146                 test_bit(ICE_VF_STATE_DIS, vf->vf_states));
 147 }
 148
 149 /**
 150  * ice_wait_on_vf_reset - poll to make sure a given VF is ready after reset
 151  * @vf: The VF being resseting
 152  *
 153  * The max poll time is about ~800ms, which is about the maximum time it takes
 154  * for a VF to be reset and/or a VF driver to be removed.
 155  */
 156 static void ice_wait_on_vf_reset(struct ice_vf *vf)
 157 {
 158         int i;
 159
 160         for (i = 0; i < ICE_MAX_VF_RESET_TRIES; i++) {
 161                 if (test_bit(ICE_VF_STATE_INIT, vf->vf_states))
 162                         break;
 163                 msleep(ICE_MAX_VF_RESET_SLEEP_MS);
 164         }
 165 }
 166
 167 /**
 168  * ice_check_vf_ready_for_cfg - check if VF is ready to be configured/queried
 169  * @vf: VF to check if it's ready to be configured/queried
 170  *
 171  * The purpose of this function is to make sure the VF is not in reset, not
 172  * disabled, and initialized so it can be configured and/or queried by a host
 173  * administrator.
 174  */
 175 int ice_check_vf_ready_for_cfg(struct ice_vf *vf)
 176 {
 177         ice_wait_on_vf_reset(vf);
 178
 179         if (ice_is_vf_disabled(vf))
 180                 return -EINVAL;
 181
 182         if (ice_check_vf_init(vf))
 183                 return -EBUSY;
 184
 185         return 0;
 186 }
 187
 188 /**
 189  * ice_trigger_vf_reset - Reset a VF on HW
 190  * @vf: pointer to the VF structure
 191  * @is_vflr: true if VFLR was issued, false if not
 192  * @is_pfr: true if the reset was triggered due to a previous PFR
 193  *
 194  * Trigger hardware to start a reset for a particular VF. Expects the caller
 195  * to wait the proper amount of time to allow hardware to reset the VF before
 196  * it cleans up and restores VF functionality.
 197  */
 198 static void ice_trigger_vf_reset(struct ice_vf *vf, bool is_vflr, bool is_pfr)
 199 {
 200         /* Inform VF that it is no longer active, as a warning */
 201         clear_bit(ICE_VF_STATE_ACTIVE, vf->vf_states);
 202
 203         /* Disable VF's configuration API during reset. The flag is re-enabled
 204          * when it's safe again to access VF's VSI.
 205          */
 206         clear_bit(ICE_VF_STATE_INIT, vf->vf_states);
 207
 208         /* VF_MBX_ARQLEN and VF_MBX_ATQLEN are cleared by PFR, so the driver
 209          * needs to clear them in the case of VFR/VFLR. If this is done for
 210          * PFR, it can mess up VF resets because the VF driver may already
 211          * have started cleanup by the time we get here.
 212          */
 213         if (!is_pfr)
 214                 vf->vf_ops->clear_mbx_register(vf);
 215
 216         vf->vf_ops->trigger_reset_register(vf, is_vflr);
 217 }
 218
 219 static void ice_vf_clear_counters(struct ice_vf *vf)
 220 {
 221         struct ice_vsi *vsi = ice_get_vf_vsi(vf);
 222
 223         if (vsi)
 224                 vsi->num_vlan = 0;
 225
 226         vf->num_mac = 0;
 227         memset(&vf->mdd_tx_events, 0, sizeof(vf->mdd_tx_events));
 228         memset(&vf->mdd_rx_events, 0, sizeof(vf->mdd_rx_events));
 229 }
 230
 231 /**
 232  * ice_vf_pre_vsi_rebuild - tasks to be done prior to VSI rebuild
 233  * @vf: VF to perform pre VSI rebuild tasks
 234  *
 235  * These tasks are items that don't need to be amortized since they are most
 236  * likely called in a for loop with all VF(s) in the reset_all_vfs() case.
 237  */
 238 static void ice_vf_pre_vsi_rebuild(struct ice_vf *vf)
 239 {
 240         ice_vf_clear_counters(vf);
 241         vf->vf_ops->clear_reset_trigger(vf);
 242 }
 243
 244 /**
 245  * ice_vf_rebuild_vsi - rebuild the VF's VSI
 246  * @vf: VF to rebuild the VSI for
 247  *
 248  * This is only called when all VF(s) are being reset (i.e. PCIe Reset on the
 249  * host, PFR, CORER, etc.).
 250  */
 251 static int ice_vf_rebuild_vsi(struct ice_vf *vf)
 252 {
 253         struct ice_vsi *vsi = ice_get_vf_vsi(vf);
 254         struct ice_pf *pf = vf->pf;
 255
 256         if (WARN_ON(!vsi))
 257                 return -EINVAL;
 258
 259         if (ice_vsi_rebuild(vsi, true)) {
 260                 dev_err(ice_pf_to_dev(pf), "failed to rebuild VF %d VSI\n",
 261                         vf->vf_id);
 262                 return -EIO;
 263         }
 264         /* vsi->idx will remain the same in this case so don't update
 265          * vf->lan_vsi_idx
 266          */
 267         vsi->vsi_num = ice_get_hw_vsi_num(&pf->hw, vsi->idx);
 268         vf->lan_vsi_num = vsi->vsi_num;
 269
 270         return 0;
 271 }
 272
 273 /**
 274  * ice_is_any_vf_in_promisc - check if any VF(s) are in promiscuous mode
 275  * @pf: PF structure for accessing VF(s)
 276  *
 277  * Return false if no VF(s) are in unicast and/or multicast promiscuous mode,
 278  * else return true
 279  */
 280 bool ice_is_any_vf_in_promisc(struct ice_pf *pf)
 281 {
 282         bool is_vf_promisc = false;
 283         struct ice_vf *vf;
 284         unsigned int bkt;
 285
 286         rcu_read_lock();
 287         ice_for_each_vf_rcu(pf, bkt, vf) {
 288                 /* found a VF that has promiscuous mode configured */
 289                 if (test_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states) ||
 290                     test_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states)) {
 291                         is_vf_promisc = true;
 292                         break;
 293                 }
 294         }
 295         rcu_read_unlock();
 296
 297         return is_vf_promisc;
 298 }
 299
 300 /**
 301  * ice_vf_set_vsi_promisc - Enable promiscuous mode for a VF VSI
 302  * @vf: the VF to configure
 303  * @vsi: the VF's VSI
 304  * @promisc_m: the promiscuous mode to enable
 305  */
 306 int
 307 ice_vf_set_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m)
 308 {
 309         struct ice_hw *hw = &vsi->back->hw;
 310         int status;
 311
 312         if (ice_vf_is_port_vlan_ena(vf))
 313                 status = ice_fltr_set_vsi_promisc(hw, vsi->idx, promisc_m,
 314                                                   ice_vf_get_port_vlan_id(vf));
 315         else if (ice_vsi_has_non_zero_vlans(vsi))
 316                 status = ice_fltr_set_vlan_vsi_promisc(hw, vsi, promisc_m);
 317         else
 318                 status = ice_fltr_set_vsi_promisc(hw, vsi->idx, promisc_m, 0);
 319
 320         if (status && status != -EEXIST) {
 321                 dev_err(ice_pf_to_dev(vsi->back), "enable Tx/Rx filter promiscuous mode on VF-%u failed, error: %d\n",
 322                         vf->vf_id, status);
 323                 return status;
 324         }
 325
 326         return 0;
 327 }
 328
 329 /**
 330  * ice_vf_clear_vsi_promisc - Disable promiscuous mode for a VF VSI
 331  * @vf: the VF to configure
 332  * @vsi: the VF's VSI
 333  * @promisc_m: the promiscuous mode to disable
 334  */
 335 int
 336 ice_vf_clear_vsi_promisc(struct ice_vf *vf, struct ice_vsi *vsi, u8 promisc_m)
 337 {
 338         struct ice_hw *hw = &vsi->back->hw;
 339         int status;
 340
 341         if (ice_vf_is_port_vlan_ena(vf))
 342                 status = ice_fltr_clear_vsi_promisc(hw, vsi->idx, promisc_m,
 343                                                     ice_vf_get_port_vlan_id(vf));
 344         else if (ice_vsi_has_non_zero_vlans(vsi))
 345                 status = ice_fltr_clear_vlan_vsi_promisc(hw, vsi, promisc_m);
 346         else
 347                 status = ice_fltr_clear_vsi_promisc(hw, vsi->idx, promisc_m, 0);
 348
 349         if (status && status != -ENOENT) {
 350                 dev_err(ice_pf_to_dev(vsi->back), "disable Tx/Rx filter promiscuous mode on VF-%u failed, error: %d\n",
 351                         vf->vf_id, status);
 352                 return status;
 353         }
 354
 355         return 0;
 356 }
 357
 358 /**
 359  * ice_reset_all_vfs - reset all allocated VFs in one go
 360  * @pf: pointer to the PF structure
 361  *
 362  * Reset all VFs at once, in response to a PF or other device reset.
 363  *
 364  * First, tell the hardware to reset each VF, then do all the waiting in one
 365  * chunk, and finally finish restoring each VF after the wait. This is useful
 366  * during PF routines which need to reset all VFs, as otherwise it must perform
 367  * these resets in a serialized fashion.
 368  */
 369 void ice_reset_all_vfs(struct ice_pf *pf)
 370 {
 371         struct device *dev = ice_pf_to_dev(pf);
 372         struct ice_hw *hw = &pf->hw;
 373         struct ice_vf *vf;
 374         unsigned int bkt;
 375
 376         /* If we don't have any VFs, then there is nothing to reset */
 377         if (!ice_has_vfs(pf))
 378                 return;
 379
 380         mutex_lock(&pf->vfs.table_lock);
 381
 382         /* clear all malicious info if the VFs are getting reset */
 383         ice_for_each_vf(pf, bkt, vf)
 384                 if (ice_mbx_clear_malvf(&hw->mbx_snapshot, pf->vfs.malvfs,
 385                                         ICE_MAX_SRIOV_VFS, vf->vf_id))
 386                         dev_dbg(dev, "failed to clear malicious VF state for VF %u\n",
 387                                 vf->vf_id);
 388
 389         /* If VFs have been disabled, there is no need to reset */
 390         if (test_and_set_bit(ICE_VF_DIS, pf->state)) {
 391                 mutex_unlock(&pf->vfs.table_lock);
 392                 return;
 393         }
 394
 395         /* Begin reset on all VFs at once */
 396         ice_for_each_vf(pf, bkt, vf)
 397                 ice_trigger_vf_reset(vf, true, true);
 398
 399         /* HW requires some time to make sure it can flush the FIFO for a VF
 400          * when it resets it. Now that we've triggered all of the VFs, iterate
 401          * the table again and wait for each VF to complete.
 402          */
 403         ice_for_each_vf(pf, bkt, vf) {
 404                 if (!vf->vf_ops->poll_reset_status(vf)) {
 405                         /* Display a warning if at least one VF didn't manage
 406                          * to reset in time, but continue on with the
 407                          * operation.
 408                          */
 409                         dev_warn(dev, "VF %u reset check timeout\n", vf->vf_id);
 410                         break;
 411                 }
 412         }
 413
 414         /* free VF resources to begin resetting the VSI state */
 415         ice_for_each_vf(pf, bkt, vf) {
 416                 mutex_lock(&vf->cfg_lock);
 417
 418                 vf->driver_caps = 0;
 419                 ice_vc_set_default_allowlist(vf);
 420
 421                 ice_vf_fdir_exit(vf);
 422                 ice_vf_fdir_init(vf);
 423                 /* clean VF control VSI when resetting VFs since it should be
 424                  * setup only when VF creates its first FDIR rule.
 425                  */
 426                 if (vf->ctrl_vsi_idx != ICE_NO_VSI)
 427                         ice_vf_ctrl_invalidate_vsi(vf);
 428
 429                 ice_vf_pre_vsi_rebuild(vf);
 430                 ice_vf_rebuild_vsi(vf);
 431                 vf->vf_ops->post_vsi_rebuild(vf);
 432
 433                 mutex_unlock(&vf->cfg_lock);
 434         }
 435
 436         if (ice_is_eswitch_mode_switchdev(pf))
 437                 if (ice_eswitch_rebuild(pf))
 438                         dev_warn(dev, "eswitch rebuild failed\n");
 439
 440         ice_flush(hw);
 441         clear_bit(ICE_VF_DIS, pf->state);
 442
 443         mutex_unlock(&pf->vfs.table_lock);
 444 }
 445
 446 /**
 447  * ice_notify_vf_reset - Notify VF of a reset event
 448  * @vf: pointer to the VF structure
 449  */
 450 static void ice_notify_vf_reset(struct ice_vf *vf)
 451 {
 452         struct ice_hw *hw = &vf->pf->hw;
 453         struct virtchnl_pf_event pfe;
 454
 455         /* Bail out if VF is in disabled state, neither initialized, nor active
 456          * state - otherwise proceed with notifications
 457          */
 458         if ((!test_bit(ICE_VF_STATE_INIT, vf->vf_states) &&
 459              !test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) ||
 460             test_bit(ICE_VF_STATE_DIS, vf->vf_states))
 461                 return;
 462
 463         pfe.event = VIRTCHNL_EVENT_RESET_IMPENDING;
 464         pfe.severity = PF_EVENT_SEVERITY_CERTAIN_DOOM;
 465         ice_aq_send_msg_to_vf(hw, vf->vf_id, VIRTCHNL_OP_EVENT,
 466                               VIRTCHNL_STATUS_SUCCESS, (u8 *)&pfe, sizeof(pfe),
 467                               NULL);
 468 }
 469
 470 /**
 471  * ice_reset_vf - Reset a particular VF
 472  * @vf: pointer to the VF structure
 473  * @flags: flags controlling behavior of the reset
 474  *
 475  * Flags:
 476  *   ICE_VF_RESET_VFLR - Indicates a reset is due to VFLR event
 477  *   ICE_VF_RESET_NOTIFY - Send VF a notification prior to reset
 478  *   ICE_VF_RESET_LOCK - Acquire VF cfg_lock before resetting
 479  *
 480  * Returns 0 if the VF is currently in reset, if resets are disabled, or if
 481  * the VF resets successfully. Returns an error code if the VF fails to
 482  * rebuild.
 483  */
 484 int ice_reset_vf(struct ice_vf *vf, u32 flags)
 485 {
 486         struct ice_pf *pf = vf->pf;
 487         struct ice_vsi *vsi;
 488         struct device *dev;
 489         struct ice_hw *hw;
 490         u8 promisc_m;
 491         int err = 0;
 492         bool rsd;
 493
 494         dev = ice_pf_to_dev(pf);
 495         hw = &pf->hw;
 496
 497         if (flags & ICE_VF_RESET_NOTIFY)
 498                 ice_notify_vf_reset(vf);
 499
 500         if (test_bit(ICE_VF_RESETS_DISABLED, pf->state)) {
 501                 dev_dbg(dev, "Trying to reset VF %d, but all VF resets are disabled\n",
 502                         vf->vf_id);
 503                 return 0;
 504         }
 505
 506         if (ice_is_vf_disabled(vf)) {
 507                 dev_dbg(dev, "VF is already disabled, there is no need for resetting it, telling VM, all is fine %d\n",
 508                         vf->vf_id);
 509                 return 0;
 510         }
 511
 512         if (flags & ICE_VF_RESET_LOCK)
 513                 mutex_lock(&vf->cfg_lock);
 514         else
 515                 lockdep_assert_held(&vf->cfg_lock);
 516
 517         /* Set VF disable bit state here, before triggering reset */
 518         set_bit(ICE_VF_STATE_DIS, vf->vf_states);
 519         ice_trigger_vf_reset(vf, flags & ICE_VF_RESET_VFLR, false);
 520
 521         vsi = ice_get_vf_vsi(vf);
 522         if (WARN_ON(!vsi)) {
 523                 err = -EIO;
 524                 goto out_unlock;
 525         }
 526
 527         ice_dis_vf_qs(vf);
 528
 529         /* Call Disable LAN Tx queue AQ whether or not queues are
 530          * enabled. This is needed for successful completion of VFR.
 531          */
 532         ice_dis_vsi_txq(vsi->port_info, vsi->idx, 0, 0, NULL, NULL,
 533                         NULL, vf->vf_ops->reset_type, vf->vf_id, NULL);
 534
 535         /* poll VPGEN_VFRSTAT reg to make sure
 536          * that reset is complete
 537          */
 538         rsd = vf->vf_ops->poll_reset_status(vf);
 539
 540         /* Display a warning if VF didn't manage to reset in time, but need to
 541          * continue on with the operation.
 542          */
 543         if (!rsd)
 544                 dev_warn(dev, "VF reset check timeout on VF %d\n", vf->vf_id);
 545
 546         vf->driver_caps = 0;
 547         ice_vc_set_default_allowlist(vf);
 548
 549         /* disable promiscuous modes in case they were enabled
 550          * ignore any error if disabling process failed
 551          */
 552         if (test_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states) ||
 553             test_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states)) {
 554                 if (ice_vf_is_port_vlan_ena(vf) || vsi->num_vlan)
 555                         promisc_m = ICE_UCAST_VLAN_PROMISC_BITS;
 556                 else
 557                         promisc_m = ICE_UCAST_PROMISC_BITS;
 558
 559                 if (ice_vf_clear_vsi_promisc(vf, vsi, promisc_m))
 560                         dev_err(dev, "disabling promiscuous mode failed\n");
 561         }
 562
 563         ice_eswitch_del_vf_mac_rule(vf);
 564
 565         ice_vf_fdir_exit(vf);
 566         ice_vf_fdir_init(vf);
 567         /* clean VF control VSI when resetting VF since it should be setup
 568          * only when VF creates its first FDIR rule.
 569          */
 570         if (vf->ctrl_vsi_idx != ICE_NO_VSI)
 571                 ice_vf_ctrl_vsi_release(vf);
 572
 573         ice_vf_pre_vsi_rebuild(vf);
 574
 575         if (vf->vf_ops->vsi_rebuild(vf)) {
 576                 dev_err(dev, "Failed to release and setup the VF%u's VSI\n",
 577                         vf->vf_id);
 578                 err = -EFAULT;
 579                 goto out_unlock;
 580         }
 581
 582         vf->vf_ops->post_vsi_rebuild(vf);
 583         vsi = ice_get_vf_vsi(vf);
 584         if (WARN_ON(!vsi)) {
 585                 err = -EINVAL;
 586                 goto out_unlock;
 587         }
 588
 589         ice_eswitch_update_repr(vsi);
 590         ice_eswitch_replay_vf_mac_rule(vf);
 591
 592         /* if the VF has been reset allow it to come up again */
 593         if (ice_mbx_clear_malvf(&hw->mbx_snapshot, pf->vfs.malvfs,
 594                                 ICE_MAX_SRIOV_VFS, vf->vf_id))
 595                 dev_dbg(dev, "failed to clear malicious VF state for VF %u\n",
 596                         vf->vf_id);
 597
 598 out_unlock:
 599         if (flags & ICE_VF_RESET_LOCK)
 600                 mutex_unlock(&vf->cfg_lock);
 601
 602         return err;
 603 }
 604
 605 /**
 606  * ice_set_vf_state_qs_dis - Set VF queues state to disabled
 607  * @vf: pointer to the VF structure
 608  */
 609 void ice_set_vf_state_qs_dis(struct ice_vf *vf)
 610 {
 611         /* Clear Rx/Tx enabled queues flag */
 612         bitmap_zero(vf->txq_ena, ICE_MAX_RSS_QS_PER_VF);
 613         bitmap_zero(vf->rxq_ena, ICE_MAX_RSS_QS_PER_VF);
 614         clear_bit(ICE_VF_STATE_QS_ENA, vf->vf_states);
 615 }
 616
 617 /* Private functions only accessed from other virtualization files */
 618
 619 /**
 620  * ice_dis_vf_qs - Disable the VF queues
 621  * @vf: pointer to the VF structure
 622  */
 623 void ice_dis_vf_qs(struct ice_vf *vf)
 624 {
 625         struct ice_vsi *vsi = ice_get_vf_vsi(vf);
 626
 627         if (WARN_ON(!vsi))
 628                 return;
 629
 630         ice_vsi_stop_lan_tx_rings(vsi, ICE_NO_RESET, vf->vf_id);
 631         ice_vsi_stop_all_rx_rings(vsi);
 632         ice_set_vf_state_qs_dis(vf);
 633 }
 634
 635 /**
 636  * ice_check_vf_init - helper to check if VF init complete
 637  * @vf: the pointer to the VF to check
 638  */
 639 int ice_check_vf_init(struct ice_vf *vf)
 640 {
 641         struct ice_pf *pf = vf->pf;
 642
 643         if (!test_bit(ICE_VF_STATE_INIT, vf->vf_states)) {
 644                 dev_err(ice_pf_to_dev(pf), "VF ID: %u in reset. Try again.\n",
 645                         vf->vf_id);
 646                 return -EBUSY;
 647         }
 648         return 0;
 649 }
 650
 651 /**
 652  * ice_vf_get_port_info - Get the VF's port info structure
 653  * @vf: VF used to get the port info structure for
 654  */
 655 struct ice_port_info *ice_vf_get_port_info(struct ice_vf *vf)
 656 {
 657         return vf->pf->hw.port_info;
 658 }
 659
 660 /**
 661  * ice_cfg_mac_antispoof - Configure MAC antispoof checking behavior
 662  * @vsi: the VSI to configure
 663  * @enable: whether to enable or disable the spoof checking
 664  *
 665  * Configure a VSI to enable (or disable) spoof checking behavior.
 666  */
 667 static int ice_cfg_mac_antispoof(struct ice_vsi *vsi, bool enable)
 668 {
 669         struct ice_vsi_ctx *ctx;
 670         int err;
 671
 672         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 673         if (!ctx)
 674                 return -ENOMEM;
 675
 676         ctx->info.sec_flags = vsi->info.sec_flags;
 677         ctx->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SECURITY_VALID);
 678
 679         if (enable)
 680                 ctx->info.sec_flags |= ICE_AQ_VSI_SEC_FLAG_ENA_MAC_ANTI_SPOOF;
 681         else
 682                 ctx->info.sec_flags &= ~ICE_AQ_VSI_SEC_FLAG_ENA_MAC_ANTI_SPOOF;
 683
 684         err = ice_update_vsi(&vsi->back->hw, vsi->idx, ctx, NULL);
 685         if (err)
 686                 dev_err(ice_pf_to_dev(vsi->back), "Failed to configure Tx MAC anti-spoof %s for VSI %d, error %d\n",
 687                         enable ? "ON" : "OFF", vsi->vsi_num, err);
 688         else
 689                 vsi->info.sec_flags = ctx->info.sec_flags;
 690
 691         kfree(ctx);
 692
 693         return err;
 694 }
 695
 696 /**
 697  * ice_vsi_ena_spoofchk - enable Tx spoof checking for this VSI
 698  * @vsi: VSI to enable Tx spoof checking for
 699  */
 700 static int ice_vsi_ena_spoofchk(struct ice_vsi *vsi)
 701 {
 702         struct ice_vsi_vlan_ops *vlan_ops;
 703         int err;
 704
 705         vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);
 706
 707         err = vlan_ops->ena_tx_filtering(vsi);
 708         if (err)
 709                 return err;
 710
 711         return ice_cfg_mac_antispoof(vsi, true);
 712 }
 713
 714 /**
 715  * ice_vsi_dis_spoofchk - disable Tx spoof checking for this VSI
 716  * @vsi: VSI to disable Tx spoof checking for
 717  */
 718 static int ice_vsi_dis_spoofchk(struct ice_vsi *vsi)
 719 {
 720         struct ice_vsi_vlan_ops *vlan_ops;
 721         int err;
 722
 723         vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);
 724
 725         err = vlan_ops->dis_tx_filtering(vsi);
 726         if (err)
 727                 return err;
 728
 729         return ice_cfg_mac_antispoof(vsi, false);
 730 }
 731
 732 /**
 733  * ice_vsi_apply_spoofchk - Apply Tx spoof checking setting to a VSI
 734  * @vsi: VSI associated to the VF
 735  * @enable: whether to enable or disable the spoof checking
 736  */
 737 int ice_vsi_apply_spoofchk(struct ice_vsi *vsi, bool enable)
 738 {
 739         int err;
 740
 741         if (enable)
 742                 err = ice_vsi_ena_spoofchk(vsi);
 743         else
 744                 err = ice_vsi_dis_spoofchk(vsi);
 745
 746         return err;
 747 }
 748
 749 /**
 750  * ice_is_vf_trusted
 751  * @vf: pointer to the VF info
 752  */
 753 bool ice_is_vf_trusted(struct ice_vf *vf)
 754 {
 755         return test_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
 756 }
 757
 758 /**
 759  * ice_vf_has_no_qs_ena - check if the VF has any Rx or Tx queues enabled
 760  * @vf: the VF to check
 761  *
 762  * Returns true if the VF has no Rx and no Tx queues enabled and returns false
 763  * otherwise
 764  */
 765 bool ice_vf_has_no_qs_ena(struct ice_vf *vf)
 766 {
 767         return (!bitmap_weight(vf->rxq_ena, ICE_MAX_RSS_QS_PER_VF) &&
 768                 !bitmap_weight(vf->txq_ena, ICE_MAX_RSS_QS_PER_VF));
 769 }
 770
 771 /**
 772  * ice_is_vf_link_up - check if the VF's link is up
 773  * @vf: VF to check if link is up
 774  */
 775 bool ice_is_vf_link_up(struct ice_vf *vf)
 776 {
 777         struct ice_port_info *pi = ice_vf_get_port_info(vf);
 778
 779         if (ice_check_vf_init(vf))
 780                 return false;
 781
 782         if (ice_vf_has_no_qs_ena(vf))
 783                 return false;
 784         else if (vf->link_forced)
 785                 return vf->link_up;
 786         else
 787                 return pi->phy.link_info.link_info &
 788                         ICE_AQ_LINK_UP;
 789 }
 790
 791 /**
 792  * ice_vf_set_host_trust_cfg - set trust setting based on pre-reset value
 793  * @vf: VF to configure trust setting for
 794  */
 795 static void ice_vf_set_host_trust_cfg(struct ice_vf *vf)
 796 {
 797         if (vf->trusted)
 798                 set_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
 799         else
 800                 clear_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
 801 }
 802
 803 /**
 804  * ice_vf_rebuild_host_mac_cfg - add broadcast and the VF's perm_addr/LAA
 805  * @vf: VF to add MAC filters for
 806  *
 807  * Called after a VF VSI has been re-added/rebuilt during reset. The PF driver
 808  * always re-adds a broadcast filter and the VF's perm_addr/LAA after reset.
 809  */
 810 static int ice_vf_rebuild_host_mac_cfg(struct ice_vf *vf)
 811 {
 812         struct device *dev = ice_pf_to_dev(vf->pf);
 813         struct ice_vsi *vsi = ice_get_vf_vsi(vf);
 814         u8 broadcast[ETH_ALEN];
 815         int status;
 816
 817         if (WARN_ON(!vsi))
 818                 return -EINVAL;
 819
 820         if (ice_is_eswitch_mode_switchdev(vf->pf))
 821                 return 0;
 822
 823         eth_broadcast_addr(broadcast);
 824         status = ice_fltr_add_mac(vsi, broadcast, ICE_FWD_TO_VSI);
 825         if (status) {
 826                 dev_err(dev, "failed to add broadcast MAC filter for VF %u, error %d\n",
 827                         vf->vf_id, status);
 828                 return status;
 829         }
 830
 831         vf->num_mac++;
 832
 833         if (is_valid_ether_addr(vf->hw_lan_addr.addr)) {
 834                 status = ice_fltr_add_mac(vsi, vf->hw_lan_addr.addr,
 835                                           ICE_FWD_TO_VSI);
 836                 if (status) {
 837                         dev_err(dev, "failed to add default unicast MAC filter %pM for VF %u, error %d\n",
 838                                 &vf->hw_lan_addr.addr[0], vf->vf_id,
 839                                 status);
 840                         return status;
 841                 }
 842                 vf->num_mac++;
 843
 844                 ether_addr_copy(vf->dev_lan_addr.addr, vf->hw_lan_addr.addr);
 845         }
 846
 847         return 0;
 848 }
 849
 850 /**
 851  * ice_vf_rebuild_host_vlan_cfg - add VLAN 0 filter or rebuild the Port VLAN
 852  * @vf: VF to add MAC filters for
 853  * @vsi: Pointer to VSI
 854  *
 855  * Called after a VF VSI has been re-added/rebuilt during reset. The PF driver
 856  * always re-adds either a VLAN 0 or port VLAN based filter after reset.
 857  */
 858 static int ice_vf_rebuild_host_vlan_cfg(struct ice_vf *vf, struct ice_vsi *vsi)
 859 {
 860         struct ice_vsi_vlan_ops *vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);
 861         struct device *dev = ice_pf_to_dev(vf->pf);
 862         int err;
 863
 864         if (ice_vf_is_port_vlan_ena(vf)) {
 865                 err = vlan_ops->set_port_vlan(vsi, &vf->port_vlan_info);
 866                 if (err) {
 867                         dev_err(dev, "failed to configure port VLAN via VSI parameters for VF %u, error %d\n",
 868                                 vf->vf_id, err);
 869                         return err;
 870                 }
 871
 872                 err = vlan_ops->add_vlan(vsi, &vf->port_vlan_info);
 873         } else {
 874                 err = ice_vsi_add_vlan_zero(vsi);
 875         }
 876
 877         if (err) {
 878                 dev_err(dev, "failed to add VLAN %u filter for VF %u during VF rebuild, error %d\n",
 879                         ice_vf_is_port_vlan_ena(vf) ?
 880                         ice_vf_get_port_vlan_id(vf) : 0, vf->vf_id, err);
 881                 return err;
 882         }
 883
 884         err = vlan_ops->ena_rx_filtering(vsi);
 885         if (err)
 886                 dev_warn(dev, "failed to enable Rx VLAN filtering for VF %d VSI %d during VF rebuild, error %d\n",
 887                          vf->vf_id, vsi->idx, err);
 888
 889         return 0;
 890 }
 891
 892 /**
 893  * ice_vf_rebuild_host_tx_rate_cfg - re-apply the Tx rate limiting configuration
 894  * @vf: VF to re-apply the configuration for
 895  *
 896  * Called after a VF VSI has been re-added/rebuild during reset. The PF driver
 897  * needs to re-apply the host configured Tx rate limiting configuration.
 898  */
 899 static int ice_vf_rebuild_host_tx_rate_cfg(struct ice_vf *vf)
 900 {
 901         struct device *dev = ice_pf_to_dev(vf->pf);
 902         struct ice_vsi *vsi = ice_get_vf_vsi(vf);
 903         int err;
 904
 905         if (WARN_ON(!vsi))
 906                 return -EINVAL;
 907
 908         if (vf->min_tx_rate) {
 909                 err = ice_set_min_bw_limit(vsi, (u64)vf->min_tx_rate * 1000);
 910                 if (err) {
 911                         dev_err(dev, "failed to set min Tx rate to %d Mbps for VF %u, error %d\n",
 912                                 vf->min_tx_rate, vf->vf_id, err);
 913                         return err;
 914                 }
 915         }
 916
 917         if (vf->max_tx_rate) {
 918                 err = ice_set_max_bw_limit(vsi, (u64)vf->max_tx_rate * 1000);
 919                 if (err) {
 920                         dev_err(dev, "failed to set max Tx rate to %d Mbps for VF %u, error %d\n",
 921                                 vf->max_tx_rate, vf->vf_id, err);
 922                         return err;
 923                 }
 924         }
 925
 926         return 0;
 927 }
 928
 929 /**
 930  * ice_vf_rebuild_aggregator_node_cfg - rebuild aggregator node config
 931  * @vsi: Pointer to VSI
 932  *
 933  * This function moves VSI into corresponding scheduler aggregator node
 934  * based on cached value of "aggregator node info" per VSI
 935  */
 936 static void ice_vf_rebuild_aggregator_node_cfg(struct ice_vsi *vsi)
 937 {
 938         struct ice_pf *pf = vsi->back;
 939         struct device *dev;
 940         int status;
 941
 942         if (!vsi->agg_node)
 943                 return;
 944
 945         dev = ice_pf_to_dev(pf);
 946         if (vsi->agg_node->num_vsis == ICE_MAX_VSIS_IN_AGG_NODE) {
 947                 dev_dbg(dev,
 948                         "agg_id %u already has reached max_num_vsis %u\n",
 949                         vsi->agg_node->agg_id, vsi->agg_node->num_vsis);
 950                 return;
 951         }
 952
 953         status = ice_move_vsi_to_agg(pf->hw.port_info, vsi->agg_node->agg_id,
 954                                      vsi->idx, vsi->tc_cfg.ena_tc);
 955         if (status)
 956                 dev_dbg(dev, "unable to move VSI idx %u into aggregator %u node",
 957                         vsi->idx, vsi->agg_node->agg_id);
 958         else
 959                 vsi->agg_node->num_vsis++;
 960 }
 961
 962 /**
 963  * ice_vf_rebuild_host_cfg - host admin configuration is persistent across reset
 964  * @vf: VF to rebuild host configuration on
 965  */
 966 void ice_vf_rebuild_host_cfg(struct ice_vf *vf)
 967 {
 968         struct device *dev = ice_pf_to_dev(vf->pf);
 969         struct ice_vsi *vsi = ice_get_vf_vsi(vf);
 970
 971         if (WARN_ON(!vsi))
 972                 return;
 973
 974         ice_vf_set_host_trust_cfg(vf);
 975
 976         if (ice_vf_rebuild_host_mac_cfg(vf))
 977                 dev_err(dev, "failed to rebuild default MAC configuration for VF %d\n",
 978                         vf->vf_id);
 979
 980         if (ice_vf_rebuild_host_vlan_cfg(vf, vsi))
 981                 dev_err(dev, "failed to rebuild VLAN configuration for VF %u\n",
 982                         vf->vf_id);
 983
 984         if (ice_vf_rebuild_host_tx_rate_cfg(vf))
 985                 dev_err(dev, "failed to rebuild Tx rate limiting configuration for VF %u\n",
 986                         vf->vf_id);
 987
 988         if (ice_vsi_apply_spoofchk(vsi, vf->spoofchk))
 989                 dev_err(dev, "failed to rebuild spoofchk configuration for VF %d\n",
 990                         vf->vf_id);
 991
 992         /* rebuild aggregator node config for main VF VSI */
 993         ice_vf_rebuild_aggregator_node_cfg(vsi);
 994 }
 995
 996 /**
 997  * ice_vf_ctrl_invalidate_vsi - invalidate ctrl_vsi_idx to remove VSI access
 998  * @vf: VF that control VSI is being invalidated on
 999  */
1000 void ice_vf_ctrl_invalidate_vsi(struct ice_vf *vf)
1001 {
1002         vf->ctrl_vsi_idx = ICE_NO_VSI;
1003 }
1004
1005 /**
1006  * ice_vf_ctrl_vsi_release - invalidate the VF's control VSI after freeing it
1007  * @vf: VF that control VSI is being released on
1008  */
1009 void ice_vf_ctrl_vsi_release(struct ice_vf *vf)
1010 {
1011         ice_vsi_release(vf->pf->vsi[vf->ctrl_vsi_idx]);
1012         ice_vf_ctrl_invalidate_vsi(vf);
1013 }
1014
1015 /**
1016  * ice_vf_ctrl_vsi_setup - Set up a VF control VSI
1017  * @vf: VF to setup control VSI for
1018  *
1019  * Returns pointer to the successfully allocated VSI struct on success,
1020  * otherwise returns NULL on failure.
1021  */
1022 struct ice_vsi *ice_vf_ctrl_vsi_setup(struct ice_vf *vf)
1023 {
1024         struct ice_port_info *pi = ice_vf_get_port_info(vf);
1025         struct ice_pf *pf = vf->pf;
1026         struct ice_vsi *vsi;
1027
1028         vsi = ice_vsi_setup(pf, pi, ICE_VSI_CTRL, vf, NULL);
1029         if (!vsi) {
1030                 dev_err(ice_pf_to_dev(pf), "Failed to create VF control VSI\n");
1031                 ice_vf_ctrl_invalidate_vsi(vf);
1032         }
1033
1034         return vsi;
1035 }
1036
1037 /**
1038  * ice_vf_invalidate_vsi - invalidate vsi_idx/vsi_num to remove VSI access
1039  * @vf: VF to remove access to VSI for
1040  */
1041 void ice_vf_invalidate_vsi(struct ice_vf *vf)
1042 {
1043         vf->lan_vsi_idx = ICE_NO_VSI;
1044         vf->lan_vsi_num = ICE_NO_VSI;
1045 }
1046
1047 /**
1048  * ice_vf_set_initialized - VF is ready for VIRTCHNL communication
1049  * @vf: VF to set in initialized state
1050  *
1051  * After this function the VF will be ready to receive/handle the
1052  * VIRTCHNL_OP_GET_VF_RESOURCES message
1053  */
1054 void ice_vf_set_initialized(struct ice_vf *vf)
1055 {
1056         ice_set_vf_state_qs_dis(vf);
1057         clear_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states);
1058         clear_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states);
1059         clear_bit(ICE_VF_STATE_DIS, vf->vf_states);
1060         set_bit(ICE_VF_STATE_INIT, vf->vf_states);
1061         memset(&vf->vlan_v2_caps, 0, sizeof(vf->vlan_v2_caps));
1062 }