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