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