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

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (C) 2019-2021, Intel Corporation. */
   3
   4 #include "ice.h"
   5 #include "ice_lib.h"
   6 #include "ice_eswitch.h"
   7 #include "ice_eswitch_br.h"
   8 #include "ice_fltr.h"
   9 #include "ice_repr.h"
  10 #include "ice_devlink.h"
  11 #include "ice_tc_lib.h"
  12
  13 /**
  14  * ice_eswitch_add_vf_sp_rule - add adv rule with VF's VSI index
  15  * @pf: pointer to PF struct
  16  * @vf: pointer to VF struct
  17  *
  18  * This function adds advanced rule that forwards packets with
  19  * VF's VSI index to the corresponding switchdev ctrl VSI queue.
  20  */
  21 static int
  22 ice_eswitch_add_vf_sp_rule(struct ice_pf *pf, struct ice_vf *vf)
  23 {
  24         struct ice_vsi *ctrl_vsi = pf->switchdev.control_vsi;
  25         struct ice_adv_rule_info rule_info = { 0 };
  26         struct ice_adv_lkup_elem *list;
  27         struct ice_hw *hw = &pf->hw;
  28         const u16 lkups_cnt = 1;
  29         int err;
  30
  31         list = kcalloc(lkups_cnt, sizeof(*list), GFP_ATOMIC);
  32         if (!list)
  33                 return -ENOMEM;
  34
  35         ice_rule_add_src_vsi_metadata(list);
  36
  37         rule_info.sw_act.flag = ICE_FLTR_TX;
  38         rule_info.sw_act.vsi_handle = ctrl_vsi->idx;
  39         rule_info.sw_act.fltr_act = ICE_FWD_TO_Q;
  40         rule_info.sw_act.fwd_id.q_id = hw->func_caps.common_cap.rxq_first_id +
  41                                        ctrl_vsi->rxq_map[vf->vf_id];
  42         rule_info.flags_info.act |= ICE_SINGLE_ACT_LB_ENABLE;
  43         rule_info.flags_info.act_valid = true;
  44         rule_info.tun_type = ICE_SW_TUN_AND_NON_TUN;
  45         rule_info.src_vsi = vf->lan_vsi_idx;
  46
  47         err = ice_add_adv_rule(hw, list, lkups_cnt, &rule_info,
  48                                &vf->repr->sp_rule);
  49         if (err)
  50                 dev_err(ice_pf_to_dev(pf), "Unable to add VF slow-path rule in switchdev mode for VF %d",
  51                         vf->vf_id);
  52
  53         kfree(list);
  54         return err;
  55 }
  56
  57 /**
  58  * ice_eswitch_del_vf_sp_rule - delete adv rule with VF's VSI index
  59  * @vf: pointer to the VF struct
  60  *
  61  * Delete the advanced rule that was used to forward packets with the VF's VSI
  62  * index to the corresponding switchdev ctrl VSI queue.
  63  */
  64 static void ice_eswitch_del_vf_sp_rule(struct ice_vf *vf)
  65 {
  66         if (!vf->repr)
  67                 return;
  68
  69         ice_rem_adv_rule_by_id(&vf->pf->hw, &vf->repr->sp_rule);
  70 }
  71
  72 /**
  73  * ice_eswitch_setup_env - configure switchdev HW filters
  74  * @pf: pointer to PF struct
  75  *
  76  * This function adds HW filters configuration specific for switchdev
  77  * mode.
  78  */
  79 static int ice_eswitch_setup_env(struct ice_pf *pf)
  80 {
  81         struct ice_vsi *uplink_vsi = pf->switchdev.uplink_vsi;
  82         struct net_device *uplink_netdev = uplink_vsi->netdev;
  83         struct ice_vsi *ctrl_vsi = pf->switchdev.control_vsi;
  84         struct ice_vsi_vlan_ops *vlan_ops;
  85         bool rule_added = false;
  86
  87         vlan_ops = ice_get_compat_vsi_vlan_ops(ctrl_vsi);
  88         if (vlan_ops->dis_stripping(ctrl_vsi))
  89                 return -ENODEV;
  90
  91         ice_remove_vsi_fltr(&pf->hw, uplink_vsi->idx);
  92
  93         netif_addr_lock_bh(uplink_netdev);
  94         __dev_uc_unsync(uplink_netdev, NULL);
  95         __dev_mc_unsync(uplink_netdev, NULL);
  96         netif_addr_unlock_bh(uplink_netdev);
  97
  98         if (ice_vsi_add_vlan_zero(uplink_vsi))
  99                 goto err_def_rx;
 100
 101         if (!ice_is_dflt_vsi_in_use(uplink_vsi->port_info)) {
 102                 if (ice_set_dflt_vsi(uplink_vsi))
 103                         goto err_def_rx;
 104                 rule_added = true;
 105         }
 106
 107         vlan_ops = ice_get_compat_vsi_vlan_ops(uplink_vsi);
 108         if (vlan_ops->dis_rx_filtering(uplink_vsi))
 109                 goto err_dis_rx;
 110
 111         if (ice_vsi_update_security(uplink_vsi, ice_vsi_ctx_set_allow_override))
 112                 goto err_override_uplink;
 113
 114         if (ice_vsi_update_security(ctrl_vsi, ice_vsi_ctx_set_allow_override))
 115                 goto err_override_control;
 116
 117         if (ice_vsi_update_local_lb(uplink_vsi, true))
 118                 goto err_override_local_lb;
 119
 120         return 0;
 121
 122 err_override_local_lb:
 123         ice_vsi_update_security(ctrl_vsi, ice_vsi_ctx_clear_allow_override);
 124 err_override_control:
 125         ice_vsi_update_security(uplink_vsi, ice_vsi_ctx_clear_allow_override);
 126 err_override_uplink:
 127         vlan_ops->ena_rx_filtering(uplink_vsi);
 128 err_dis_rx:
 129         if (rule_added)
 130                 ice_clear_dflt_vsi(uplink_vsi);
 131 err_def_rx:
 132         ice_fltr_add_mac_and_broadcast(uplink_vsi,
 133                                        uplink_vsi->port_info->mac.perm_addr,
 134                                        ICE_FWD_TO_VSI);
 135         return -ENODEV;
 136 }
 137
 138 /**
 139  * ice_eswitch_remap_rings_to_vectors - reconfigure rings of switchdev ctrl VSI
 140  * @pf: pointer to PF struct
 141  *
 142  * In switchdev number of allocated Tx/Rx rings is equal.
 143  *
 144  * This function fills q_vectors structures associated with representor and
 145  * move each ring pairs to port representor netdevs. Each port representor
 146  * will have dedicated 1 Tx/Rx ring pair, so number of rings pair is equal to
 147  * number of VFs.
 148  */
 149 static void ice_eswitch_remap_rings_to_vectors(struct ice_pf *pf)
 150 {
 151         struct ice_vsi *vsi = pf->switchdev.control_vsi;
 152         int q_id;
 153
 154         ice_for_each_txq(vsi, q_id) {
 155                 struct ice_q_vector *q_vector;
 156                 struct ice_tx_ring *tx_ring;
 157                 struct ice_rx_ring *rx_ring;
 158                 struct ice_repr *repr;
 159                 struct ice_vf *vf;
 160
 161                 vf = ice_get_vf_by_id(pf, q_id);
 162                 if (WARN_ON(!vf))
 163                         continue;
 164
 165                 repr = vf->repr;
 166                 q_vector = repr->q_vector;
 167                 tx_ring = vsi->tx_rings[q_id];
 168                 rx_ring = vsi->rx_rings[q_id];
 169
 170                 q_vector->vsi = vsi;
 171                 q_vector->reg_idx = vsi->q_vectors[0]->reg_idx;
 172
 173                 q_vector->num_ring_tx = 1;
 174                 q_vector->tx.tx_ring = tx_ring;
 175                 tx_ring->q_vector = q_vector;
 176                 tx_ring->next = NULL;
 177                 tx_ring->netdev = repr->netdev;
 178                 /* In switchdev mode, from OS stack perspective, there is only
 179                  * one queue for given netdev, so it needs to be indexed as 0.
 180                  */
 181                 tx_ring->q_index = 0;
 182
 183                 q_vector->num_ring_rx = 1;
 184                 q_vector->rx.rx_ring = rx_ring;
 185                 rx_ring->q_vector = q_vector;
 186                 rx_ring->next = NULL;
 187                 rx_ring->netdev = repr->netdev;
 188
 189                 ice_put_vf(vf);
 190         }
 191 }
 192
 193 /**
 194  * ice_eswitch_release_reprs - clear PR VSIs configuration
 195  * @pf: poiner to PF struct
 196  * @ctrl_vsi: pointer to switchdev control VSI
 197  */
 198 static void
 199 ice_eswitch_release_reprs(struct ice_pf *pf, struct ice_vsi *ctrl_vsi)
 200 {
 201         struct ice_vf *vf;
 202         unsigned int bkt;
 203
 204         lockdep_assert_held(&pf->vfs.table_lock);
 205
 206         ice_for_each_vf(pf, bkt, vf) {
 207                 struct ice_vsi *vsi = vf->repr->src_vsi;
 208
 209                 /* Skip VFs that aren't configured */
 210                 if (!vf->repr->dst)
 211                         continue;
 212
 213                 ice_vsi_update_security(vsi, ice_vsi_ctx_set_antispoof);
 214                 metadata_dst_free(vf->repr->dst);
 215                 vf->repr->dst = NULL;
 216                 ice_eswitch_del_vf_sp_rule(vf);
 217                 ice_fltr_add_mac_and_broadcast(vsi, vf->hw_lan_addr,
 218                                                ICE_FWD_TO_VSI);
 219
 220                 netif_napi_del(&vf->repr->q_vector->napi);
 221         }
 222 }
 223
 224 /**
 225  * ice_eswitch_setup_reprs - configure port reprs to run in switchdev mode
 226  * @pf: pointer to PF struct
 227  */
 228 static int ice_eswitch_setup_reprs(struct ice_pf *pf)
 229 {
 230         struct ice_vsi *ctrl_vsi = pf->switchdev.control_vsi;
 231         int max_vsi_num = 0;
 232         struct ice_vf *vf;
 233         unsigned int bkt;
 234
 235         lockdep_assert_held(&pf->vfs.table_lock);
 236
 237         ice_for_each_vf(pf, bkt, vf) {
 238                 struct ice_vsi *vsi = vf->repr->src_vsi;
 239
 240                 ice_remove_vsi_fltr(&pf->hw, vsi->idx);
 241                 vf->repr->dst = metadata_dst_alloc(0, METADATA_HW_PORT_MUX,
 242                                                    GFP_KERNEL);
 243                 if (!vf->repr->dst) {
 244                         ice_fltr_add_mac_and_broadcast(vsi, vf->hw_lan_addr,
 245                                                        ICE_FWD_TO_VSI);
 246                         goto err;
 247                 }
 248
 249                 if (ice_eswitch_add_vf_sp_rule(pf, vf)) {
 250                         ice_fltr_add_mac_and_broadcast(vsi, vf->hw_lan_addr,
 251                                                        ICE_FWD_TO_VSI);
 252                         goto err;
 253                 }
 254
 255                 if (ice_vsi_update_security(vsi, ice_vsi_ctx_clear_antispoof)) {
 256                         ice_fltr_add_mac_and_broadcast(vsi, vf->hw_lan_addr,
 257                                                        ICE_FWD_TO_VSI);
 258                         ice_eswitch_del_vf_sp_rule(vf);
 259                         metadata_dst_free(vf->repr->dst);
 260                         vf->repr->dst = NULL;
 261                         goto err;
 262                 }
 263
 264                 if (ice_vsi_add_vlan_zero(vsi)) {
 265                         ice_fltr_add_mac_and_broadcast(vsi, vf->hw_lan_addr,
 266                                                        ICE_FWD_TO_VSI);
 267                         ice_eswitch_del_vf_sp_rule(vf);
 268                         metadata_dst_free(vf->repr->dst);
 269                         vf->repr->dst = NULL;
 270                         ice_vsi_update_security(vsi, ice_vsi_ctx_set_antispoof);
 271                         goto err;
 272                 }
 273
 274                 if (max_vsi_num < vsi->vsi_num)
 275                         max_vsi_num = vsi->vsi_num;
 276
 277                 netif_napi_add(vf->repr->netdev, &vf->repr->q_vector->napi,
 278                                ice_napi_poll);
 279
 280                 netif_keep_dst(vf->repr->netdev);
 281         }
 282
 283         ice_for_each_vf(pf, bkt, vf) {
 284                 struct ice_repr *repr = vf->repr;
 285                 struct ice_vsi *vsi = repr->src_vsi;
 286                 struct metadata_dst *dst;
 287
 288                 dst = repr->dst;
 289                 dst->u.port_info.port_id = vsi->vsi_num;
 290                 dst->u.port_info.lower_dev = repr->netdev;
 291                 ice_repr_set_traffic_vsi(repr, ctrl_vsi);
 292         }
 293
 294         return 0;
 295
 296 err:
 297         ice_eswitch_release_reprs(pf, ctrl_vsi);
 298
 299         return -ENODEV;
 300 }
 301
 302 /**
 303  * ice_eswitch_update_repr - reconfigure VF port representor
 304  * @vsi: VF VSI for which port representor is configured
 305  */
 306 void ice_eswitch_update_repr(struct ice_vsi *vsi)
 307 {
 308         struct ice_pf *pf = vsi->back;
 309         struct ice_repr *repr;
 310         struct ice_vf *vf;
 311         int ret;
 312
 313         if (!ice_is_switchdev_running(pf))
 314                 return;
 315
 316         vf = vsi->vf;
 317         repr = vf->repr;
 318         repr->src_vsi = vsi;
 319         repr->dst->u.port_info.port_id = vsi->vsi_num;
 320
 321         if (repr->br_port)
 322                 repr->br_port->vsi = vsi;
 323
 324         ret = ice_vsi_update_security(vsi, ice_vsi_ctx_clear_antispoof);
 325         if (ret) {
 326                 ice_fltr_add_mac_and_broadcast(vsi, vf->hw_lan_addr, ICE_FWD_TO_VSI);
 327                 dev_err(ice_pf_to_dev(pf), "Failed to update VF %d port representor",
 328                         vsi->vf->vf_id);
 329         }
 330 }
 331
 332 /**
 333  * ice_eswitch_port_start_xmit - callback for packets transmit
 334  * @skb: send buffer
 335  * @netdev: network interface device structure
 336  *
 337  * Returns NETDEV_TX_OK if sent, else an error code
 338  */
 339 netdev_tx_t
 340 ice_eswitch_port_start_xmit(struct sk_buff *skb, struct net_device *netdev)
 341 {
 342         struct ice_netdev_priv *np;
 343         struct ice_repr *repr;
 344         struct ice_vsi *vsi;
 345
 346         np = netdev_priv(netdev);
 347         vsi = np->vsi;
 348
 349         if (!vsi || !ice_is_switchdev_running(vsi->back))
 350                 return NETDEV_TX_BUSY;
 351
 352         if (ice_is_reset_in_progress(vsi->back->state) ||
 353             test_bit(ICE_VF_DIS, vsi->back->state))
 354                 return NETDEV_TX_BUSY;
 355
 356         repr = ice_netdev_to_repr(netdev);
 357         skb_dst_drop(skb);
 358         dst_hold((struct dst_entry *)repr->dst);
 359         skb_dst_set(skb, (struct dst_entry *)repr->dst);
 360         skb->queue_mapping = repr->vf->vf_id;
 361
 362         return ice_start_xmit(skb, netdev);
 363 }
 364
 365 /**
 366  * ice_eswitch_set_target_vsi - set switchdev context in Tx context descriptor
 367  * @skb: pointer to send buffer
 368  * @off: pointer to offload struct
 369  */
 370 void
 371 ice_eswitch_set_target_vsi(struct sk_buff *skb,
 372                            struct ice_tx_offload_params *off)
 373 {
 374         struct metadata_dst *dst = skb_metadata_dst(skb);
 375         u64 cd_cmd, dst_vsi;
 376
 377         if (!dst) {
 378                 cd_cmd = ICE_TX_CTX_DESC_SWTCH_UPLINK << ICE_TXD_CTX_QW1_CMD_S;
 379                 off->cd_qw1 |= (cd_cmd | ICE_TX_DESC_DTYPE_CTX);
 380         } else {
 381                 cd_cmd = ICE_TX_CTX_DESC_SWTCH_VSI << ICE_TXD_CTX_QW1_CMD_S;
 382                 dst_vsi = ((u64)dst->u.port_info.port_id <<
 383                            ICE_TXD_CTX_QW1_VSI_S) & ICE_TXD_CTX_QW1_VSI_M;
 384                 off->cd_qw1 = cd_cmd | dst_vsi | ICE_TX_DESC_DTYPE_CTX;
 385         }
 386 }
 387
 388 /**
 389  * ice_eswitch_release_env - clear switchdev HW filters
 390  * @pf: pointer to PF struct
 391  *
 392  * This function removes HW filters configuration specific for switchdev
 393  * mode and restores default legacy mode settings.
 394  */
 395 static void ice_eswitch_release_env(struct ice_pf *pf)
 396 {
 397         struct ice_vsi *uplink_vsi = pf->switchdev.uplink_vsi;
 398         struct ice_vsi *ctrl_vsi = pf->switchdev.control_vsi;
 399         struct ice_vsi_vlan_ops *vlan_ops;
 400
 401         vlan_ops = ice_get_compat_vsi_vlan_ops(uplink_vsi);
 402
 403         ice_vsi_update_local_lb(uplink_vsi, false);
 404         ice_vsi_update_security(ctrl_vsi, ice_vsi_ctx_clear_allow_override);
 405         ice_vsi_update_security(uplink_vsi, ice_vsi_ctx_clear_allow_override);
 406         vlan_ops->ena_rx_filtering(uplink_vsi);
 407         ice_clear_dflt_vsi(uplink_vsi);
 408         ice_fltr_add_mac_and_broadcast(uplink_vsi,
 409                                        uplink_vsi->port_info->mac.perm_addr,
 410                                        ICE_FWD_TO_VSI);
 411 }
 412
 413 /**
 414  * ice_eswitch_vsi_setup - configure switchdev control VSI
 415  * @pf: pointer to PF structure
 416  * @pi: pointer to port_info structure
 417  */
 418 static struct ice_vsi *
 419 ice_eswitch_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi)
 420 {
 421         struct ice_vsi_cfg_params params = {};
 422
 423         params.type = ICE_VSI_SWITCHDEV_CTRL;
 424         params.pi = pi;
 425         params.flags = ICE_VSI_FLAG_INIT;
 426
 427         return ice_vsi_setup(pf, &params);
 428 }
 429
 430 /**
 431  * ice_eswitch_napi_del - remove NAPI handle for all port representors
 432  * @pf: pointer to PF structure
 433  */
 434 static void ice_eswitch_napi_del(struct ice_pf *pf)
 435 {
 436         struct ice_vf *vf;
 437         unsigned int bkt;
 438
 439         lockdep_assert_held(&pf->vfs.table_lock);
 440
 441         ice_for_each_vf(pf, bkt, vf)
 442                 netif_napi_del(&vf->repr->q_vector->napi);
 443 }
 444
 445 /**
 446  * ice_eswitch_napi_enable - enable NAPI for all port representors
 447  * @pf: pointer to PF structure
 448  */
 449 static void ice_eswitch_napi_enable(struct ice_pf *pf)
 450 {
 451         struct ice_vf *vf;
 452         unsigned int bkt;
 453
 454         lockdep_assert_held(&pf->vfs.table_lock);
 455
 456         ice_for_each_vf(pf, bkt, vf)
 457                 napi_enable(&vf->repr->q_vector->napi);
 458 }
 459
 460 /**
 461  * ice_eswitch_napi_disable - disable NAPI for all port representors
 462  * @pf: pointer to PF structure
 463  */
 464 static void ice_eswitch_napi_disable(struct ice_pf *pf)
 465 {
 466         struct ice_vf *vf;
 467         unsigned int bkt;
 468
 469         lockdep_assert_held(&pf->vfs.table_lock);
 470
 471         ice_for_each_vf(pf, bkt, vf)
 472                 napi_disable(&vf->repr->q_vector->napi);
 473 }
 474
 475 /**
 476  * ice_eswitch_enable_switchdev - configure eswitch in switchdev mode
 477  * @pf: pointer to PF structure
 478  */
 479 static int ice_eswitch_enable_switchdev(struct ice_pf *pf)
 480 {
 481         struct ice_vsi *ctrl_vsi, *uplink_vsi;
 482
 483         uplink_vsi = ice_get_main_vsi(pf);
 484         if (!uplink_vsi)
 485                 return -ENODEV;
 486
 487         if (netif_is_any_bridge_port(uplink_vsi->netdev)) {
 488                 dev_err(ice_pf_to_dev(pf),
 489                         "Uplink port cannot be a bridge port\n");
 490                 return -EINVAL;
 491         }
 492
 493         pf->switchdev.control_vsi = ice_eswitch_vsi_setup(pf, pf->hw.port_info);
 494         if (!pf->switchdev.control_vsi)
 495                 return -ENODEV;
 496
 497         ctrl_vsi = pf->switchdev.control_vsi;
 498         pf->switchdev.uplink_vsi = uplink_vsi;
 499
 500         if (ice_eswitch_setup_env(pf))
 501                 goto err_vsi;
 502
 503         if (ice_repr_add_for_all_vfs(pf))
 504                 goto err_repr_add;
 505
 506         if (ice_eswitch_setup_reprs(pf))
 507                 goto err_setup_reprs;
 508
 509         ice_eswitch_remap_rings_to_vectors(pf);
 510
 511         if (ice_vsi_open(ctrl_vsi))
 512                 goto err_setup_reprs;
 513
 514         if (ice_eswitch_br_offloads_init(pf))
 515                 goto err_br_offloads;
 516
 517         ice_eswitch_napi_enable(pf);
 518
 519         return 0;
 520
 521 err_br_offloads:
 522         ice_vsi_close(ctrl_vsi);
 523 err_setup_reprs:
 524         ice_repr_rem_from_all_vfs(pf);
 525 err_repr_add:
 526         ice_eswitch_release_env(pf);
 527 err_vsi:
 528         ice_vsi_release(ctrl_vsi);
 529         return -ENODEV;
 530 }
 531
 532 /**
 533  * ice_eswitch_disable_switchdev - disable switchdev resources
 534  * @pf: pointer to PF structure
 535  */
 536 static void ice_eswitch_disable_switchdev(struct ice_pf *pf)
 537 {
 538         struct ice_vsi *ctrl_vsi = pf->switchdev.control_vsi;
 539
 540         ice_eswitch_napi_disable(pf);
 541         ice_eswitch_br_offloads_deinit(pf);
 542         ice_eswitch_release_env(pf);
 543         ice_eswitch_release_reprs(pf, ctrl_vsi);
 544         ice_vsi_release(ctrl_vsi);
 545         ice_repr_rem_from_all_vfs(pf);
 546 }
 547
 548 /**
 549  * ice_eswitch_mode_set - set new eswitch mode
 550  * @devlink: pointer to devlink structure
 551  * @mode: eswitch mode to switch to
 552  * @extack: pointer to extack structure
 553  */
 554 int
 555 ice_eswitch_mode_set(struct devlink *devlink, u16 mode,
 556                      struct netlink_ext_ack *extack)
 557 {
 558         struct ice_pf *pf = devlink_priv(devlink);
 559
 560         if (pf->eswitch_mode == mode)
 561                 return 0;
 562
 563         if (ice_has_vfs(pf)) {
 564                 dev_info(ice_pf_to_dev(pf), "Changing eswitch mode is allowed only if there is no VFs created");
 565                 NL_SET_ERR_MSG_MOD(extack, "Changing eswitch mode is allowed only if there is no VFs created");
 566                 return -EOPNOTSUPP;
 567         }
 568
 569         switch (mode) {
 570         case DEVLINK_ESWITCH_MODE_LEGACY:
 571                 dev_info(ice_pf_to_dev(pf), "PF %d changed eswitch mode to legacy",
 572                          pf->hw.pf_id);
 573                 NL_SET_ERR_MSG_MOD(extack, "Changed eswitch mode to legacy");
 574                 break;
 575         case DEVLINK_ESWITCH_MODE_SWITCHDEV:
 576         {
 577                 if (ice_is_adq_active(pf)) {
 578                         dev_err(ice_pf_to_dev(pf), "Couldn't change eswitch mode to switchdev - ADQ is active. Delete ADQ configs and try again, e.g. tc qdisc del dev $PF root");
 579                         NL_SET_ERR_MSG_MOD(extack, "Couldn't change eswitch mode to switchdev - ADQ is active. Delete ADQ configs and try again, e.g. tc qdisc del dev $PF root");
 580                         return -EOPNOTSUPP;
 581                 }
 582
 583                 dev_info(ice_pf_to_dev(pf), "PF %d changed eswitch mode to switchdev",
 584                          pf->hw.pf_id);
 585                 NL_SET_ERR_MSG_MOD(extack, "Changed eswitch mode to switchdev");
 586                 break;
 587         }
 588         default:
 589                 NL_SET_ERR_MSG_MOD(extack, "Unknown eswitch mode");
 590                 return -EINVAL;
 591         }
 592
 593         pf->eswitch_mode = mode;
 594         return 0;
 595 }
 596
 597 /**
 598  * ice_eswitch_mode_get - get current eswitch mode
 599  * @devlink: pointer to devlink structure
 600  * @mode: output parameter for current eswitch mode
 601  */
 602 int ice_eswitch_mode_get(struct devlink *devlink, u16 *mode)
 603 {
 604         struct ice_pf *pf = devlink_priv(devlink);
 605
 606         *mode = pf->eswitch_mode;
 607         return 0;
 608 }
 609
 610 /**
 611  * ice_is_eswitch_mode_switchdev - check if eswitch mode is set to switchdev
 612  * @pf: pointer to PF structure
 613  *
 614  * Returns true if eswitch mode is set to DEVLINK_ESWITCH_MODE_SWITCHDEV,
 615  * false otherwise.
 616  */
 617 bool ice_is_eswitch_mode_switchdev(struct ice_pf *pf)
 618 {
 619         return pf->eswitch_mode == DEVLINK_ESWITCH_MODE_SWITCHDEV;
 620 }
 621
 622 /**
 623  * ice_eswitch_release - cleanup eswitch
 624  * @pf: pointer to PF structure
 625  */
 626 void ice_eswitch_release(struct ice_pf *pf)
 627 {
 628         if (pf->eswitch_mode == DEVLINK_ESWITCH_MODE_LEGACY)
 629                 return;
 630
 631         ice_eswitch_disable_switchdev(pf);
 632         pf->switchdev.is_running = false;
 633 }
 634
 635 /**
 636  * ice_eswitch_configure - configure eswitch
 637  * @pf: pointer to PF structure
 638  */
 639 int ice_eswitch_configure(struct ice_pf *pf)
 640 {
 641         int status;
 642
 643         if (pf->eswitch_mode == DEVLINK_ESWITCH_MODE_LEGACY || pf->switchdev.is_running)
 644                 return 0;
 645
 646         status = ice_eswitch_enable_switchdev(pf);
 647         if (status)
 648                 return status;
 649
 650         pf->switchdev.is_running = true;
 651         return 0;
 652 }
 653
 654 /**
 655  * ice_eswitch_start_all_tx_queues - start Tx queues of all port representors
 656  * @pf: pointer to PF structure
 657  */
 658 static void ice_eswitch_start_all_tx_queues(struct ice_pf *pf)
 659 {
 660         struct ice_vf *vf;
 661         unsigned int bkt;
 662
 663         lockdep_assert_held(&pf->vfs.table_lock);
 664
 665         if (test_bit(ICE_DOWN, pf->state))
 666                 return;
 667
 668         ice_for_each_vf(pf, bkt, vf) {
 669                 if (vf->repr)
 670                         ice_repr_start_tx_queues(vf->repr);
 671         }
 672 }
 673
 674 /**
 675  * ice_eswitch_stop_all_tx_queues - stop Tx queues of all port representors
 676  * @pf: pointer to PF structure
 677  */
 678 void ice_eswitch_stop_all_tx_queues(struct ice_pf *pf)
 679 {
 680         struct ice_vf *vf;
 681         unsigned int bkt;
 682
 683         lockdep_assert_held(&pf->vfs.table_lock);
 684
 685         if (test_bit(ICE_DOWN, pf->state))
 686                 return;
 687
 688         ice_for_each_vf(pf, bkt, vf) {
 689                 if (vf->repr)
 690                         ice_repr_stop_tx_queues(vf->repr);
 691         }
 692 }
 693
 694 /**
 695  * ice_eswitch_rebuild - rebuild eswitch
 696  * @pf: pointer to PF structure
 697  */
 698 int ice_eswitch_rebuild(struct ice_pf *pf)
 699 {
 700         struct ice_vsi *ctrl_vsi = pf->switchdev.control_vsi;
 701         int status;
 702
 703         ice_eswitch_napi_disable(pf);
 704         ice_eswitch_napi_del(pf);
 705
 706         status = ice_eswitch_setup_env(pf);
 707         if (status)
 708                 return status;
 709
 710         status = ice_eswitch_setup_reprs(pf);
 711         if (status)
 712                 return status;
 713
 714         ice_eswitch_remap_rings_to_vectors(pf);
 715
 716         ice_replay_tc_fltrs(pf);
 717
 718         status = ice_vsi_open(ctrl_vsi);
 719         if (status)
 720                 return status;
 721
 722         ice_eswitch_napi_enable(pf);
 723         ice_eswitch_start_all_tx_queues(pf);
 724
 725         return 0;
 726 }