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