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                 vsi = ice_get_vf_vsi(vf);
 508                 if (WARN_ON(!vsi))
 509                         return -EINVAL;
 510                 ice_vsi_stop_lan_tx_rings(vsi, ICE_NO_RESET, vf->vf_id);
 511                 ice_vsi_stop_all_rx_rings(vsi);
 512                 dev_dbg(dev, "VF is already disabled, there is no need for resetting it, telling VM, all is fine %d\n",
 513                         vf->vf_id);
 514                 return 0;
 515         }
 516
 517         if (flags & ICE_VF_RESET_LOCK)
 518                 mutex_lock(&vf->cfg_lock);
 519         else
 520                 lockdep_assert_held(&vf->cfg_lock);
 521
 522         /* Set VF disable bit state here, before triggering reset */
 523         set_bit(ICE_VF_STATE_DIS, vf->vf_states);
 524         ice_trigger_vf_reset(vf, flags & ICE_VF_RESET_VFLR, false);
 525
 526         vsi = ice_get_vf_vsi(vf);
 527         if (WARN_ON(!vsi)) {
 528                 err = -EIO;
 529                 goto out_unlock;
 530         }
 531
 532         ice_dis_vf_qs(vf);
 533
 534         /* Call Disable LAN Tx queue AQ whether or not queues are
 535          * enabled. This is needed for successful completion of VFR.
 536          */
 537         ice_dis_vsi_txq(vsi->port_info, vsi->idx, 0, 0, NULL, NULL,
 538                         NULL, vf->vf_ops->reset_type, vf->vf_id, NULL);
 539
 540         /* poll VPGEN_VFRSTAT reg to make sure
 541          * that reset is complete
 542          */
 543         rsd = vf->vf_ops->poll_reset_status(vf);
 544
 545         /* Display a warning if VF didn't manage to reset in time, but need to
 546          * continue on with the operation.
 547          */
 548         if (!rsd)
 549                 dev_warn(dev, "VF reset check timeout on VF %d\n", vf->vf_id);
 550
 551         vf->driver_caps = 0;
 552         ice_vc_set_default_allowlist(vf);
 553
 554         /* disable promiscuous modes in case they were enabled
 555          * ignore any error if disabling process failed
 556          */
 557         if (test_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states) ||
 558             test_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states)) {
 559                 if (ice_vf_is_port_vlan_ena(vf) || vsi->num_vlan)
 560                         promisc_m = ICE_UCAST_VLAN_PROMISC_BITS;
 561                 else
 562                         promisc_m = ICE_UCAST_PROMISC_BITS;
 563
 564                 if (ice_vf_clear_vsi_promisc(vf, vsi, promisc_m))
 565                         dev_err(dev, "disabling promiscuous mode failed\n");
 566         }
 567
 568         ice_eswitch_del_vf_mac_rule(vf);
 569
 570         ice_vf_fdir_exit(vf);
 571         ice_vf_fdir_init(vf);
 572         /* clean VF control VSI when resetting VF since it should be setup
 573          * only when VF creates its first FDIR rule.
 574          */
 575         if (vf->ctrl_vsi_idx != ICE_NO_VSI)
 576                 ice_vf_ctrl_vsi_release(vf);
 577
 578         ice_vf_pre_vsi_rebuild(vf);
 579
 580         if (vf->vf_ops->vsi_rebuild(vf)) {
 581                 dev_err(dev, "Failed to release and setup the VF%u's VSI\n",
 582                         vf->vf_id);
 583                 err = -EFAULT;
 584                 goto out_unlock;
 585         }
 586
 587         vf->vf_ops->post_vsi_rebuild(vf);
 588         vsi = ice_get_vf_vsi(vf);
 589         if (WARN_ON(!vsi)) {
 590                 err = -EINVAL;
 591                 goto out_unlock;
 592         }
 593
 594         ice_eswitch_update_repr(vsi);
 595         ice_eswitch_replay_vf_mac_rule(vf);
 596
 597         /* if the VF has been reset allow it to come up again */
 598         if (ice_mbx_clear_malvf(&hw->mbx_snapshot, pf->vfs.malvfs,
 599                                 ICE_MAX_SRIOV_VFS, vf->vf_id))
 600                 dev_dbg(dev, "failed to clear malicious VF state for VF %u\n",
 601                         vf->vf_id);
 602
 603 out_unlock:
 604         if (flags & ICE_VF_RESET_LOCK)
 605                 mutex_unlock(&vf->cfg_lock);
 606
 607         return err;
 608 }
 609
 610 /**
 611  * ice_set_vf_state_qs_dis - Set VF queues state to disabled
 612  * @vf: pointer to the VF structure
 613  */
 614 void ice_set_vf_state_qs_dis(struct ice_vf *vf)
 615 {
 616         /* Clear Rx/Tx enabled queues flag */
 617         bitmap_zero(vf->txq_ena, ICE_MAX_RSS_QS_PER_VF);
 618         bitmap_zero(vf->rxq_ena, ICE_MAX_RSS_QS_PER_VF);
 619         clear_bit(ICE_VF_STATE_QS_ENA, vf->vf_states);
 620 }
 621
 622 /* Private functions only accessed from other virtualization files */
 623
 624 /**
 625  * ice_dis_vf_qs - Disable the VF queues
 626  * @vf: pointer to the VF structure
 627  */
 628 void ice_dis_vf_qs(struct ice_vf *vf)
 629 {
 630         struct ice_vsi *vsi = ice_get_vf_vsi(vf);
 631
 632         if (WARN_ON(!vsi))
 633                 return;
 634
 635         ice_vsi_stop_lan_tx_rings(vsi, ICE_NO_RESET, vf->vf_id);
 636         ice_vsi_stop_all_rx_rings(vsi);
 637         ice_set_vf_state_qs_dis(vf);
 638 }
 639
 640 /**
 641  * ice_check_vf_init - helper to check if VF init complete
 642  * @vf: the pointer to the VF to check
 643  */
 644 int ice_check_vf_init(struct ice_vf *vf)
 645 {
 646         struct ice_pf *pf = vf->pf;
 647
 648         if (!test_bit(ICE_VF_STATE_INIT, vf->vf_states)) {
 649                 dev_err(ice_pf_to_dev(pf), "VF ID: %u in reset. Try again.\n",
 650                         vf->vf_id);
 651                 return -EBUSY;
 652         }
 653         return 0;
 654 }
 655
 656 /**
 657  * ice_vf_get_port_info - Get the VF's port info structure
 658  * @vf: VF used to get the port info structure for
 659  */
 660 struct ice_port_info *ice_vf_get_port_info(struct ice_vf *vf)
 661 {
 662         return vf->pf->hw.port_info;
 663 }
 664
 665 /**
 666  * ice_cfg_mac_antispoof - Configure MAC antispoof checking behavior
 667  * @vsi: the VSI to configure
 668  * @enable: whether to enable or disable the spoof checking
 669  *
 670  * Configure a VSI to enable (or disable) spoof checking behavior.
 671  */
 672 static int ice_cfg_mac_antispoof(struct ice_vsi *vsi, bool enable)
 673 {
 674         struct ice_vsi_ctx *ctx;
 675         int err;
 676
 677         ctx = kzalloc(sizeof(*ctx), GFP_KERNEL);
 678         if (!ctx)
 679                 return -ENOMEM;
 680
 681         ctx->info.sec_flags = vsi->info.sec_flags;
 682         ctx->info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SECURITY_VALID);
 683
 684         if (enable)
 685                 ctx->info.sec_flags |= ICE_AQ_VSI_SEC_FLAG_ENA_MAC_ANTI_SPOOF;
 686         else
 687                 ctx->info.sec_flags &= ~ICE_AQ_VSI_SEC_FLAG_ENA_MAC_ANTI_SPOOF;
 688
 689         err = ice_update_vsi(&vsi->back->hw, vsi->idx, ctx, NULL);
 690         if (err)
 691                 dev_err(ice_pf_to_dev(vsi->back), "Failed to configure Tx MAC anti-spoof %s for VSI %d, error %d\n",
 692                         enable ? "ON" : "OFF", vsi->vsi_num, err);
 693         else
 694                 vsi->info.sec_flags = ctx->info.sec_flags;
 695
 696         kfree(ctx);
 697
 698         return err;
 699 }
 700
 701 /**
 702  * ice_vsi_ena_spoofchk - enable Tx spoof checking for this VSI
 703  * @vsi: VSI to enable Tx spoof checking for
 704  */
 705 static int ice_vsi_ena_spoofchk(struct ice_vsi *vsi)
 706 {
 707         struct ice_vsi_vlan_ops *vlan_ops;
 708         int err;
 709
 710         vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);
 711
 712         err = vlan_ops->ena_tx_filtering(vsi);
 713         if (err)
 714                 return err;
 715
 716         return ice_cfg_mac_antispoof(vsi, true);
 717 }
 718
 719 /**
 720  * ice_vsi_dis_spoofchk - disable Tx spoof checking for this VSI
 721  * @vsi: VSI to disable Tx spoof checking for
 722  */
 723 static int ice_vsi_dis_spoofchk(struct ice_vsi *vsi)
 724 {
 725         struct ice_vsi_vlan_ops *vlan_ops;
 726         int err;
 727
 728         vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);
 729
 730         err = vlan_ops->dis_tx_filtering(vsi);
 731         if (err)
 732                 return err;
 733
 734         return ice_cfg_mac_antispoof(vsi, false);
 735 }
 736
 737 /**
 738  * ice_vsi_apply_spoofchk - Apply Tx spoof checking setting to a VSI
 739  * @vsi: VSI associated to the VF
 740  * @enable: whether to enable or disable the spoof checking
 741  */
 742 int ice_vsi_apply_spoofchk(struct ice_vsi *vsi, bool enable)
 743 {
 744         int err;
 745
 746         if (enable)
 747                 err = ice_vsi_ena_spoofchk(vsi);
 748         else
 749                 err = ice_vsi_dis_spoofchk(vsi);
 750
 751         return err;
 752 }
 753
 754 /**
 755  * ice_is_vf_trusted
 756  * @vf: pointer to the VF info
 757  */
 758 bool ice_is_vf_trusted(struct ice_vf *vf)
 759 {
 760         return test_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
 761 }
 762
 763 /**
 764  * ice_vf_has_no_qs_ena - check if the VF has any Rx or Tx queues enabled
 765  * @vf: the VF to check
 766  *
 767  * Returns true if the VF has no Rx and no Tx queues enabled and returns false
 768  * otherwise
 769  */
 770 bool ice_vf_has_no_qs_ena(struct ice_vf *vf)
 771 {
 772         return (!bitmap_weight(vf->rxq_ena, ICE_MAX_RSS_QS_PER_VF) &&
 773                 !bitmap_weight(vf->txq_ena, ICE_MAX_RSS_QS_PER_VF));
 774 }
 775
 776 /**
 777  * ice_is_vf_link_up - check if the VF's link is up
 778  * @vf: VF to check if link is up
 779  */
 780 bool ice_is_vf_link_up(struct ice_vf *vf)
 781 {
 782         struct ice_port_info *pi = ice_vf_get_port_info(vf);
 783
 784         if (ice_check_vf_init(vf))
 785                 return false;
 786
 787         if (ice_vf_has_no_qs_ena(vf))
 788                 return false;
 789         else if (vf->link_forced)
 790                 return vf->link_up;
 791         else
 792                 return pi->phy.link_info.link_info &
 793                         ICE_AQ_LINK_UP;
 794 }
 795
 796 /**
 797  * ice_vf_set_host_trust_cfg - set trust setting based on pre-reset value
 798  * @vf: VF to configure trust setting for
 799  */
 800 static void ice_vf_set_host_trust_cfg(struct ice_vf *vf)
 801 {
 802         if (vf->trusted)
 803                 set_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
 804         else
 805                 clear_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
 806 }
 807
 808 /**
 809  * ice_vf_rebuild_host_mac_cfg - add broadcast and the VF's perm_addr/LAA
 810  * @vf: VF to add MAC filters for
 811  *
 812  * Called after a VF VSI has been re-added/rebuilt during reset. The PF driver
 813  * always re-adds a broadcast filter and the VF's perm_addr/LAA after reset.
 814  */
 815 static int ice_vf_rebuild_host_mac_cfg(struct ice_vf *vf)
 816 {
 817         struct device *dev = ice_pf_to_dev(vf->pf);
 818         struct ice_vsi *vsi = ice_get_vf_vsi(vf);
 819         u8 broadcast[ETH_ALEN];
 820         int status;
 821
 822         if (WARN_ON(!vsi))
 823                 return -EINVAL;
 824
 825         if (ice_is_eswitch_mode_switchdev(vf->pf))
 826                 return 0;
 827
 828         eth_broadcast_addr(broadcast);
 829         status = ice_fltr_add_mac(vsi, broadcast, ICE_FWD_TO_VSI);
 830         if (status) {
 831                 dev_err(dev, "failed to add broadcast MAC filter for VF %u, error %d\n",
 832                         vf->vf_id, status);
 833                 return status;
 834         }
 835
 836         vf->num_mac++;
 837
 838         if (is_valid_ether_addr(vf->hw_lan_addr.addr)) {
 839                 status = ice_fltr_add_mac(vsi, vf->hw_lan_addr.addr,
 840                                           ICE_FWD_TO_VSI);
 841                 if (status) {
 842                         dev_err(dev, "failed to add default unicast MAC filter %pM for VF %u, error %d\n",
 843                                 &vf->hw_lan_addr.addr[0], vf->vf_id,
 844                                 status);
 845                         return status;
 846                 }
 847                 vf->num_mac++;
 848
 849                 ether_addr_copy(vf->dev_lan_addr.addr, vf->hw_lan_addr.addr);
 850         }
 851
 852         return 0;
 853 }
 854
 855 /**
 856  * ice_vf_rebuild_host_vlan_cfg - add VLAN 0 filter or rebuild the Port VLAN
 857  * @vf: VF to add MAC filters for
 858  * @vsi: Pointer to VSI
 859  *
 860  * Called after a VF VSI has been re-added/rebuilt during reset. The PF driver
 861  * always re-adds either a VLAN 0 or port VLAN based filter after reset.
 862  */
 863 static int ice_vf_rebuild_host_vlan_cfg(struct ice_vf *vf, struct ice_vsi *vsi)
 864 {
 865         struct ice_vsi_vlan_ops *vlan_ops = ice_get_compat_vsi_vlan_ops(vsi);
 866         struct device *dev = ice_pf_to_dev(vf->pf);
 867         int err;
 868
 869         if (ice_vf_is_port_vlan_ena(vf)) {
 870                 err = vlan_ops->set_port_vlan(vsi, &vf->port_vlan_info);
 871                 if (err) {
 872                         dev_err(dev, "failed to configure port VLAN via VSI parameters for VF %u, error %d\n",
 873                                 vf->vf_id, err);
 874                         return err;
 875                 }
 876
 877                 err = vlan_ops->add_vlan(vsi, &vf->port_vlan_info);
 878         } else {
 879                 err = ice_vsi_add_vlan_zero(vsi);
 880         }
 881
 882         if (err) {
 883                 dev_err(dev, "failed to add VLAN %u filter for VF %u during VF rebuild, error %d\n",
 884                         ice_vf_is_port_vlan_ena(vf) ?
 885                         ice_vf_get_port_vlan_id(vf) : 0, vf->vf_id, err);
 886                 return err;
 887         }
 888
 889         err = vlan_ops->ena_rx_filtering(vsi);
 890         if (err)
 891                 dev_warn(dev, "failed to enable Rx VLAN filtering for VF %d VSI %d during VF rebuild, error %d\n",
 892                          vf->vf_id, vsi->idx, err);
 893
 894         return 0;
 895 }
 896
 897 /**
 898  * ice_vf_rebuild_host_tx_rate_cfg - re-apply the Tx rate limiting configuration
 899  * @vf: VF to re-apply the configuration for
 900  *
 901  * Called after a VF VSI has been re-added/rebuild during reset. The PF driver
 902  * needs to re-apply the host configured Tx rate limiting configuration.
 903  */
 904 static int ice_vf_rebuild_host_tx_rate_cfg(struct ice_vf *vf)
 905 {
 906         struct device *dev = ice_pf_to_dev(vf->pf);
 907         struct ice_vsi *vsi = ice_get_vf_vsi(vf);
 908         int err;
 909
 910         if (WARN_ON(!vsi))
 911                 return -EINVAL;
 912
 913         if (vf->min_tx_rate) {
 914                 err = ice_set_min_bw_limit(vsi, (u64)vf->min_tx_rate * 1000);
 915                 if (err) {
 916                         dev_err(dev, "failed to set min Tx rate to %d Mbps for VF %u, error %d\n",
 917                                 vf->min_tx_rate, vf->vf_id, err);
 918                         return err;
 919                 }
 920         }
 921
 922         if (vf->max_tx_rate) {
 923                 err = ice_set_max_bw_limit(vsi, (u64)vf->max_tx_rate * 1000);
 924                 if (err) {
 925                         dev_err(dev, "failed to set max Tx rate to %d Mbps for VF %u, error %d\n",
 926                                 vf->max_tx_rate, vf->vf_id, err);
 927                         return err;
 928                 }
 929         }
 930
 931         return 0;
 932 }
 933
 934 /**
 935  * ice_vf_rebuild_aggregator_node_cfg - rebuild aggregator node config
 936  * @vsi: Pointer to VSI
 937  *
 938  * This function moves VSI into corresponding scheduler aggregator node
 939  * based on cached value of "aggregator node info" per VSI
 940  */
 941 static void ice_vf_rebuild_aggregator_node_cfg(struct ice_vsi *vsi)
 942 {
 943         struct ice_pf *pf = vsi->back;
 944         struct device *dev;
 945         int status;
 946
 947         if (!vsi->agg_node)
 948                 return;
 949
 950         dev = ice_pf_to_dev(pf);
 951         if (vsi->agg_node->num_vsis == ICE_MAX_VSIS_IN_AGG_NODE) {
 952                 dev_dbg(dev,
 953                         "agg_id %u already has reached max_num_vsis %u\n",
 954                         vsi->agg_node->agg_id, vsi->agg_node->num_vsis);
 955                 return;
 956         }
 957
 958         status = ice_move_vsi_to_agg(pf->hw.port_info, vsi->agg_node->agg_id,
 959                                      vsi->idx, vsi->tc_cfg.ena_tc);
 960         if (status)
 961                 dev_dbg(dev, "unable to move VSI idx %u into aggregator %u node",
 962                         vsi->idx, vsi->agg_node->agg_id);
 963         else
 964                 vsi->agg_node->num_vsis++;
 965 }
 966
 967 /**
 968  * ice_vf_rebuild_host_cfg - host admin configuration is persistent across reset
 969  * @vf: VF to rebuild host configuration on
 970  */
 971 void ice_vf_rebuild_host_cfg(struct ice_vf *vf)
 972 {
 973         struct device *dev = ice_pf_to_dev(vf->pf);
 974         struct ice_vsi *vsi = ice_get_vf_vsi(vf);
 975
 976         if (WARN_ON(!vsi))
 977                 return;
 978
 979         ice_vf_set_host_trust_cfg(vf);
 980
 981         if (ice_vf_rebuild_host_mac_cfg(vf))
 982                 dev_err(dev, "failed to rebuild default MAC configuration for VF %d\n",
 983                         vf->vf_id);
 984
 985         if (ice_vf_rebuild_host_vlan_cfg(vf, vsi))
 986                 dev_err(dev, "failed to rebuild VLAN configuration for VF %u\n",
 987                         vf->vf_id);
 988
 989         if (ice_vf_rebuild_host_tx_rate_cfg(vf))
 990                 dev_err(dev, "failed to rebuild Tx rate limiting configuration for VF %u\n",
 991                         vf->vf_id);
 992
 993         if (ice_vsi_apply_spoofchk(vsi, vf->spoofchk))
 994                 dev_err(dev, "failed to rebuild spoofchk configuration for VF %d\n",
 995                         vf->vf_id);
 996
 997         /* rebuild aggregator node config for main VF VSI */
 998         ice_vf_rebuild_aggregator_node_cfg(vsi);
 999 }
1000
1001 /**
1002  * ice_vf_ctrl_invalidate_vsi - invalidate ctrl_vsi_idx to remove VSI access
1003  * @vf: VF that control VSI is being invalidated on
1004  */
1005 void ice_vf_ctrl_invalidate_vsi(struct ice_vf *vf)
1006 {
1007         vf->ctrl_vsi_idx = ICE_NO_VSI;
1008 }
1009
1010 /**
1011  * ice_vf_ctrl_vsi_release - invalidate the VF's control VSI after freeing it
1012  * @vf: VF that control VSI is being released on
1013  */
1014 void ice_vf_ctrl_vsi_release(struct ice_vf *vf)
1015 {
1016         ice_vsi_release(vf->pf->vsi[vf->ctrl_vsi_idx]);
1017         ice_vf_ctrl_invalidate_vsi(vf);
1018 }
1019
1020 /**
1021  * ice_vf_ctrl_vsi_setup - Set up a VF control VSI
1022  * @vf: VF to setup control VSI for
1023  *
1024  * Returns pointer to the successfully allocated VSI struct on success,
1025  * otherwise returns NULL on failure.
1026  */
1027 struct ice_vsi *ice_vf_ctrl_vsi_setup(struct ice_vf *vf)
1028 {
1029         struct ice_port_info *pi = ice_vf_get_port_info(vf);
1030         struct ice_pf *pf = vf->pf;
1031         struct ice_vsi *vsi;
1032
1033         vsi = ice_vsi_setup(pf, pi, ICE_VSI_CTRL, vf, NULL);
1034         if (!vsi) {
1035                 dev_err(ice_pf_to_dev(pf), "Failed to create VF control VSI\n");
1036                 ice_vf_ctrl_invalidate_vsi(vf);
1037         }
1038
1039         return vsi;
1040 }
1041
1042 /**
1043  * ice_vf_invalidate_vsi - invalidate vsi_idx/vsi_num to remove VSI access
1044  * @vf: VF to remove access to VSI for
1045  */
1046 void ice_vf_invalidate_vsi(struct ice_vf *vf)
1047 {
1048         vf->lan_vsi_idx = ICE_NO_VSI;
1049         vf->lan_vsi_num = ICE_NO_VSI;
1050 }
1051
1052 /**
1053  * ice_vf_set_initialized - VF is ready for VIRTCHNL communication
1054  * @vf: VF to set in initialized state
1055  *
1056  * After this function the VF will be ready to receive/handle the
1057  * VIRTCHNL_OP_GET_VF_RESOURCES message
1058  */
1059 void ice_vf_set_initialized(struct ice_vf *vf)
1060 {
1061         ice_set_vf_state_qs_dis(vf);
1062         clear_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states);
1063         clear_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states);
1064         clear_bit(ICE_VF_STATE_DIS, vf->vf_states);
1065         set_bit(ICE_VF_STATE_INIT, vf->vf_states);
1066         memset(&vf->vlan_v2_caps, 0, sizeof(vf->vlan_v2_caps));
1067 }