1// SPDX-License-Identifier: GPL-2.0 2/* Copyright (C) 2018-2021, Intel Corporation. */ 3 4/* Link Aggregation code */ 5 6#include "ice.h" 7#include "ice_lib.h" 8#include "ice_lag.h" 9 10#define ICE_LAG_RES_SHARED BIT(14) 11#define ICE_LAG_RES_VALID BIT(15) 12 13#define LACP_TRAIN_PKT_LEN 16 14static const u8 lacp_train_pkt[LACP_TRAIN_PKT_LEN] = { 0, 0, 0, 0, 0, 0, 15 0, 0, 0, 0, 0, 0, 16 0x88, 0x09, 0, 0 }; 17 18#define ICE_RECIPE_LEN 64 19static const u8 ice_dflt_vsi_rcp[ICE_RECIPE_LEN] = { 20 0x05, 0, 0, 0, 0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 21 0x85, 0, 0x01, 0, 0, 0, 0xff, 0xff, 0x08, 0, 0, 0, 0, 0, 0, 0, 22 0, 0, 0, 0, 0, 0, 0x30 }; 23static const u8 ice_lport_rcp[ICE_RECIPE_LEN] = { 24 0x05, 0, 0, 0, 0x20, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 25 0x85, 0, 0x16, 0, 0, 0, 0xff, 0xff, 0x07, 0, 0, 0, 0, 0, 0, 0, 26 0, 0, 0, 0, 0, 0, 0x30 }; 27 28/** 29 * ice_lag_set_primary - set PF LAG state as Primary 30 * @lag: LAG info struct 31 */ 32static void ice_lag_set_primary(struct ice_lag *lag) 33{ 34 struct ice_pf *pf = lag->pf; 35 36 if (!pf) 37 return; 38 39 if (lag->role != ICE_LAG_UNSET && lag->role != ICE_LAG_BACKUP) { 40 dev_warn(ice_pf_to_dev(pf), "%s: Attempt to be Primary, but incompatible state.\n", 41 netdev_name(lag->netdev)); 42 return; 43 } 44 45 lag->role = ICE_LAG_PRIMARY; 46} 47 48/** 49 * ice_lag_set_backup - set PF LAG state to Backup 50 * @lag: LAG info struct 51 */ 52static void ice_lag_set_backup(struct ice_lag *lag) 53{ 54 struct ice_pf *pf = lag->pf; 55 56 if (!pf) 57 return; 58 59 if (lag->role != ICE_LAG_UNSET && lag->role != ICE_LAG_PRIMARY) { 60 dev_dbg(ice_pf_to_dev(pf), "%s: Attempt to be Backup, but incompatible state\n", 61 netdev_name(lag->netdev)); 62 return; 63 } 64 65 lag->role = ICE_LAG_BACKUP; 66} 67 68/** 69 * netif_is_same_ice - determine if netdev is on the same ice NIC as local PF 70 * @pf: local PF struct 71 * @netdev: netdev we are evaluating 72 */ 73static bool netif_is_same_ice(struct ice_pf *pf, struct net_device *netdev) 74{ 75 struct ice_netdev_priv *np; 76 struct ice_pf *test_pf; 77 struct ice_vsi *vsi; 78 79 if (!netif_is_ice(netdev)) 80 return false; 81 82 np = netdev_priv(netdev); 83 if (!np) 84 return false; 85 86 vsi = np->vsi; 87 if (!vsi) 88 return false; 89 90 test_pf = vsi->back; 91 if (!test_pf) 92 return false; 93 94 if (pf->pdev->bus != test_pf->pdev->bus || 95 pf->pdev->slot != test_pf->pdev->slot) 96 return false; 97 98 return true; 99} 100 101/** 102 * ice_netdev_to_lag - return pointer to associated lag struct from netdev 103 * @netdev: pointer to net_device struct to query 104 */ 105static struct ice_lag *ice_netdev_to_lag(struct net_device *netdev) 106{ 107 struct ice_netdev_priv *np; 108 struct ice_vsi *vsi; 109 110 if (!netif_is_ice(netdev)) 111 return NULL; 112 113 np = netdev_priv(netdev); 114 if (!np) 115 return NULL; 116 117 vsi = np->vsi; 118 if (!vsi) 119 return NULL; 120 121 return vsi->back->lag; 122} 123 124/** 125 * ice_lag_find_hw_by_lport - return an hw struct from bond members lport 126 * @lag: lag struct 127 * @lport: lport value to search for 128 */ 129static struct ice_hw * 130ice_lag_find_hw_by_lport(struct ice_lag *lag, u8 lport) 131{ 132 struct ice_lag_netdev_list *entry; 133 struct net_device *tmp_netdev; 134 struct ice_netdev_priv *np; 135 struct ice_hw *hw; 136 137 list_for_each_entry(entry, lag->netdev_head, node) { 138 tmp_netdev = entry->netdev; 139 if (!tmp_netdev || !netif_is_ice(tmp_netdev)) 140 continue; 141 142 np = netdev_priv(tmp_netdev); 143 if (!np || !np->vsi) 144 continue; 145 146 hw = &np->vsi->back->hw; 147 if (hw->port_info->lport == lport) 148 return hw; 149 } 150 151 return NULL; 152} 153 154/** 155 * ice_pkg_has_lport_extract - check if lport extraction supported 156 * @hw: HW struct 157 */ 158static bool ice_pkg_has_lport_extract(struct ice_hw *hw) 159{ 160 int i; 161 162 for (i = 0; i < hw->blk[ICE_BLK_SW].es.count; i++) { 163 u16 offset; 164 u8 fv_prot; 165 166 ice_find_prot_off(hw, ICE_BLK_SW, ICE_SW_DEFAULT_PROFILE, i, 167 &fv_prot, &offset); 168 if (fv_prot == ICE_FV_PROT_MDID && 169 offset == ICE_LP_EXT_BUF_OFFSET) 170 return true; 171 } 172 return false; 173} 174 175/** 176 * ice_lag_find_primary - returns pointer to primary interfaces lag struct 177 * @lag: local interfaces lag struct 178 */ 179static struct ice_lag *ice_lag_find_primary(struct ice_lag *lag) 180{ 181 struct ice_lag *primary_lag = NULL; 182 struct list_head *tmp; 183 184 list_for_each(tmp, lag->netdev_head) { 185 struct ice_lag_netdev_list *entry; 186 struct ice_lag *tmp_lag; 187 188 entry = list_entry(tmp, struct ice_lag_netdev_list, node); 189 tmp_lag = ice_netdev_to_lag(entry->netdev); 190 if (tmp_lag && tmp_lag->primary) { 191 primary_lag = tmp_lag; 192 break; 193 } 194 } 195 196 return primary_lag; 197} 198 199/** 200 * ice_lag_cfg_fltr - Add/Remove rule for LAG 201 * @lag: lag struct for local interface 202 * @act: rule action 203 * @recipe_id: recipe id for the new rule 204 * @rule_idx: pointer to rule index 205 * @add: boolean on whether we are adding filters 206 */ 207static int 208ice_lag_cfg_fltr(struct ice_lag *lag, u32 act, u16 recipe_id, u16 *rule_idx, 209 bool add) 210{ 211 struct ice_sw_rule_lkup_rx_tx *s_rule; 212 u16 s_rule_sz, vsi_num; 213 struct ice_hw *hw; 214 u8 *eth_hdr; 215 u32 opc; 216 int err; 217 218 hw = &lag->pf->hw; 219 vsi_num = ice_get_hw_vsi_num(hw, 0); 220 221 s_rule_sz = ICE_SW_RULE_RX_TX_ETH_HDR_SIZE(s_rule); 222 s_rule = kzalloc(s_rule_sz, GFP_KERNEL); 223 if (!s_rule) { 224 dev_err(ice_pf_to_dev(lag->pf), "error allocating rule for LAG\n"); 225 return -ENOMEM; 226 } 227 228 if (add) { 229 eth_hdr = s_rule->hdr_data; 230 ice_fill_eth_hdr(eth_hdr); 231 232 act |= FIELD_PREP(ICE_SINGLE_ACT_VSI_ID_M, vsi_num); 233 234 s_rule->hdr.type = cpu_to_le16(ICE_AQC_SW_RULES_T_LKUP_RX); 235 s_rule->recipe_id = cpu_to_le16(recipe_id); 236 s_rule->src = cpu_to_le16(hw->port_info->lport); 237 s_rule->act = cpu_to_le32(act); 238 s_rule->hdr_len = cpu_to_le16(DUMMY_ETH_HDR_LEN); 239 opc = ice_aqc_opc_add_sw_rules; 240 } else { 241 s_rule->index = cpu_to_le16(*rule_idx); 242 opc = ice_aqc_opc_remove_sw_rules; 243 } 244 245 err = ice_aq_sw_rules(&lag->pf->hw, s_rule, s_rule_sz, 1, opc, NULL); 246 if (err) 247 goto dflt_fltr_free; 248 249 if (add) 250 *rule_idx = le16_to_cpu(s_rule->index); 251 else 252 *rule_idx = 0; 253 254dflt_fltr_free: 255 kfree(s_rule); 256 return err; 257} 258 259/** 260 * ice_lag_cfg_dflt_fltr - Add/Remove default VSI rule for LAG 261 * @lag: lag struct for local interface 262 * @add: boolean on whether to add filter 263 */ 264static int 265ice_lag_cfg_dflt_fltr(struct ice_lag *lag, bool add) 266{ 267 u32 act = ICE_SINGLE_ACT_VSI_FORWARDING | 268 ICE_SINGLE_ACT_VALID_BIT | ICE_SINGLE_ACT_LAN_ENABLE; 269 270 return ice_lag_cfg_fltr(lag, act, lag->pf_recipe, 271 &lag->pf_rule_id, add); 272} 273 274/** 275 * ice_lag_cfg_drop_fltr - Add/Remove lport drop rule 276 * @lag: lag struct for local interface 277 * @add: boolean on whether to add filter 278 */ 279static int 280ice_lag_cfg_drop_fltr(struct ice_lag *lag, bool add) 281{ 282 u32 act = ICE_SINGLE_ACT_VSI_FORWARDING | 283 ICE_SINGLE_ACT_VALID_BIT | 284 ICE_SINGLE_ACT_DROP; 285 286 return ice_lag_cfg_fltr(lag, act, lag->lport_recipe, 287 &lag->lport_rule_idx, add); 288} 289 290/** 291 * ice_lag_cfg_pf_fltrs - set filters up for new active port 292 * @lag: local interfaces lag struct 293 * @ptr: opaque data containing notifier event 294 */ 295static void 296ice_lag_cfg_pf_fltrs(struct ice_lag *lag, void *ptr) 297{ 298 struct netdev_notifier_bonding_info *info; 299 struct netdev_bonding_info *bonding_info; 300 struct net_device *event_netdev; 301 struct device *dev; 302 303 event_netdev = netdev_notifier_info_to_dev(ptr); 304 /* not for this netdev */ 305 if (event_netdev != lag->netdev) 306 return; 307 308 info = (struct netdev_notifier_bonding_info *)ptr; 309 bonding_info = &info->bonding_info; 310 dev = ice_pf_to_dev(lag->pf); 311 312 /* interface not active - remove old default VSI rule */ 313 if (bonding_info->slave.state && lag->pf_rule_id) { 314 if (ice_lag_cfg_dflt_fltr(lag, false)) 315 dev_err(dev, "Error removing old default VSI filter\n"); 316 if (ice_lag_cfg_drop_fltr(lag, true)) 317 dev_err(dev, "Error adding new drop filter\n"); 318 return; 319 } 320 321 /* interface becoming active - add new default VSI rule */ 322 if (!bonding_info->slave.state && !lag->pf_rule_id) { 323 if (ice_lag_cfg_dflt_fltr(lag, true)) 324 dev_err(dev, "Error adding new default VSI filter\n"); 325 if (lag->lport_rule_idx && ice_lag_cfg_drop_fltr(lag, false)) 326 dev_err(dev, "Error removing old drop filter\n"); 327 } 328} 329 330/** 331 * ice_display_lag_info - print LAG info 332 * @lag: LAG info struct 333 */ 334static void ice_display_lag_info(struct ice_lag *lag) 335{ 336 const char *name, *upper, *role, *bonded, *primary; 337 struct device *dev = &lag->pf->pdev->dev; 338 339 name = lag->netdev ? netdev_name(lag->netdev) : "unset"; 340 upper = lag->upper_netdev ? netdev_name(lag->upper_netdev) : "unset"; 341 primary = lag->primary ? "TRUE" : "FALSE"; 342 bonded = lag->bonded ? "BONDED" : "UNBONDED"; 343 344 switch (lag->role) { 345 case ICE_LAG_NONE: 346 role = "NONE"; 347 break; 348 case ICE_LAG_PRIMARY: 349 role = "PRIMARY"; 350 break; 351 case ICE_LAG_BACKUP: 352 role = "BACKUP"; 353 break; 354 case ICE_LAG_UNSET: 355 role = "UNSET"; 356 break; 357 default: 358 role = "ERROR"; 359 } 360 361 dev_dbg(dev, "%s %s, upper:%s, role:%s, primary:%s\n", name, bonded, 362 upper, role, primary); 363} 364 365/** 366 * ice_lag_qbuf_recfg - generate a buffer of queues for a reconfigure command 367 * @hw: HW struct that contains the queue contexts 368 * @qbuf: pointer to buffer to populate 369 * @vsi_num: index of the VSI in PF space 370 * @numq: number of queues to search for 371 * @tc: traffic class that contains the queues 372 * 373 * function returns the number of valid queues in buffer 374 */ 375static u16 376ice_lag_qbuf_recfg(struct ice_hw *hw, struct ice_aqc_cfg_txqs_buf *qbuf, 377 u16 vsi_num, u16 numq, u8 tc) 378{ 379 struct ice_q_ctx *q_ctx; 380 u16 qid, count = 0; 381 struct ice_pf *pf; 382 int i; 383 384 pf = hw->back; 385 for (i = 0; i < numq; i++) { 386 q_ctx = ice_get_lan_q_ctx(hw, vsi_num, tc, i); 387 if (!q_ctx) { 388 dev_dbg(ice_hw_to_dev(hw), "%s queue %d NO Q CONTEXT\n", 389 __func__, i); 390 continue; 391 } 392 if (q_ctx->q_teid == ICE_INVAL_TEID) { 393 dev_dbg(ice_hw_to_dev(hw), "%s queue %d INVAL TEID\n", 394 __func__, i); 395 continue; 396 } 397 if (q_ctx->q_handle == ICE_INVAL_Q_HANDLE) { 398 dev_dbg(ice_hw_to_dev(hw), "%s queue %d INVAL Q HANDLE\n", 399 __func__, i); 400 continue; 401 } 402 403 qid = pf->vsi[vsi_num]->txq_map[q_ctx->q_handle]; 404 qbuf->queue_info[count].q_handle = cpu_to_le16(qid); 405 qbuf->queue_info[count].tc = tc; 406 qbuf->queue_info[count].q_teid = cpu_to_le32(q_ctx->q_teid); 407 count++; 408 } 409 410 return count; 411} 412 413/** 414 * ice_lag_get_sched_parent - locate or create a sched node parent 415 * @hw: HW struct for getting parent in 416 * @tc: traffic class on parent/node 417 */ 418static struct ice_sched_node * 419ice_lag_get_sched_parent(struct ice_hw *hw, u8 tc) 420{ 421 struct ice_sched_node *tc_node, *aggnode, *parent = NULL; 422 u16 num_nodes[ICE_AQC_TOPO_MAX_LEVEL_NUM] = { 0 }; 423 struct ice_port_info *pi = hw->port_info; 424 struct device *dev; 425 u8 aggl, vsil; 426 int n; 427 428 dev = ice_hw_to_dev(hw); 429 430 tc_node = ice_sched_get_tc_node(pi, tc); 431 if (!tc_node) { 432 dev_warn(dev, "Failure to find TC node for LAG move\n"); 433 return parent; 434 } 435 436 aggnode = ice_sched_get_agg_node(pi, tc_node, ICE_DFLT_AGG_ID); 437 if (!aggnode) { 438 dev_warn(dev, "Failure to find aggregate node for LAG move\n"); 439 return parent; 440 } 441 442 aggl = ice_sched_get_agg_layer(hw); 443 vsil = ice_sched_get_vsi_layer(hw); 444 445 for (n = aggl + 1; n < vsil; n++) 446 num_nodes[n] = 1; 447 448 for (n = 0; n < aggnode->num_children; n++) { 449 parent = ice_sched_get_free_vsi_parent(hw, aggnode->children[n], 450 num_nodes); 451 if (parent) 452 return parent; 453 } 454 455 /* if free parent not found - add one */ 456 parent = aggnode; 457 for (n = aggl + 1; n < vsil; n++) { 458 u16 num_nodes_added; 459 u32 first_teid; 460 int err; 461 462 err = ice_sched_add_nodes_to_layer(pi, tc_node, parent, n, 463 num_nodes[n], &first_teid, 464 &num_nodes_added); 465 if (err || num_nodes[n] != num_nodes_added) 466 return NULL; 467 468 if (num_nodes_added) 469 parent = ice_sched_find_node_by_teid(tc_node, 470 first_teid); 471 else 472 parent = parent->children[0]; 473 if (!parent) { 474 dev_warn(dev, "Failure to add new parent for LAG move\n"); 475 return parent; 476 } 477 } 478 479 return parent; 480} 481 482/** 483 * ice_lag_move_vf_node_tc - move scheduling nodes for one VF on one TC 484 * @lag: lag info struct 485 * @oldport: lport of previous nodes location 486 * @newport: lport of destination nodes location 487 * @vsi_num: array index of VSI in PF space 488 * @tc: traffic class to move 489 */ 490static void 491ice_lag_move_vf_node_tc(struct ice_lag *lag, u8 oldport, u8 newport, 492 u16 vsi_num, u8 tc) 493{ 494 DEFINE_RAW_FLEX(struct ice_aqc_move_elem, buf, teid, 1); 495 struct device *dev = ice_pf_to_dev(lag->pf); 496 u16 numq, valq, num_moved, qbuf_size; 497 u16 buf_size = __struct_size(buf); 498 struct ice_aqc_cfg_txqs_buf *qbuf; 499 struct ice_sched_node *n_prt; 500 struct ice_hw *new_hw = NULL; 501 __le32 teid, parent_teid; 502 struct ice_vsi_ctx *ctx; 503 u32 tmp_teid; 504 505 ctx = ice_get_vsi_ctx(&lag->pf->hw, vsi_num); 506 if (!ctx) { 507 dev_warn(dev, "Unable to locate VSI context for LAG failover\n"); 508 return; 509 } 510 511 /* check to see if this VF is enabled on this TC */ 512 if (!ctx->sched.vsi_node[tc]) 513 return; 514 515 /* locate HW struct for destination port */ 516 new_hw = ice_lag_find_hw_by_lport(lag, newport); 517 if (!new_hw) { 518 dev_warn(dev, "Unable to locate HW struct for LAG node destination\n"); 519 return; 520 } 521 522 numq = ctx->num_lan_q_entries[tc]; 523 teid = ctx->sched.vsi_node[tc]->info.node_teid; 524 tmp_teid = le32_to_cpu(teid); 525 parent_teid = ctx->sched.vsi_node[tc]->info.parent_teid; 526 /* if no teid assigned or numq == 0, then this TC is not active */ 527 if (!tmp_teid || !numq) 528 return; 529 530 /* suspend VSI subtree for Traffic Class "tc" on 531 * this VF's VSI 532 */ 533 if (ice_sched_suspend_resume_elems(&lag->pf->hw, 1, &tmp_teid, true)) 534 dev_dbg(dev, "Problem suspending traffic for LAG node move\n"); 535 536 /* reconfigure all VF's queues on this Traffic Class 537 * to new port 538 */ 539 qbuf_size = struct_size(qbuf, queue_info, numq); 540 qbuf = kzalloc(qbuf_size, GFP_KERNEL); 541 if (!qbuf) { 542 dev_warn(dev, "Failure allocating memory for VF queue recfg buffer\n"); 543 goto resume_traffic; 544 } 545 546 /* add the per queue info for the reconfigure command buffer */ 547 valq = ice_lag_qbuf_recfg(&lag->pf->hw, qbuf, vsi_num, numq, tc); 548 if (!valq) { 549 dev_dbg(dev, "No valid queues found for LAG failover\n"); 550 goto qbuf_none; 551 } 552 553 if (ice_aq_cfg_lan_txq(&lag->pf->hw, qbuf, qbuf_size, valq, oldport, 554 newport, NULL)) { 555 dev_warn(dev, "Failure to configure queues for LAG failover\n"); 556 goto qbuf_err; 557 } 558 559qbuf_none: 560 kfree(qbuf); 561 562 /* find new parent in destination port's tree for VF VSI node on this 563 * Traffic Class 564 */ 565 n_prt = ice_lag_get_sched_parent(new_hw, tc); 566 if (!n_prt) 567 goto resume_traffic; 568 569 /* Move Vf's VSI node for this TC to newport's scheduler tree */ 570 buf->hdr.src_parent_teid = parent_teid; 571 buf->hdr.dest_parent_teid = n_prt->info.node_teid; 572 buf->hdr.num_elems = cpu_to_le16(1); 573 buf->hdr.mode = ICE_AQC_MOVE_ELEM_MODE_KEEP_OWN; 574 buf->teid[0] = teid; 575 576 if (ice_aq_move_sched_elems(&lag->pf->hw, buf, buf_size, &num_moved)) 577 dev_warn(dev, "Failure to move VF nodes for failover\n"); 578 else 579 ice_sched_update_parent(n_prt, ctx->sched.vsi_node[tc]); 580 581 goto resume_traffic; 582 583qbuf_err: 584 kfree(qbuf); 585 586resume_traffic: 587 /* restart traffic for VSI node */ 588 if (ice_sched_suspend_resume_elems(&lag->pf->hw, 1, &tmp_teid, false)) 589 dev_dbg(dev, "Problem restarting traffic for LAG node move\n"); 590} 591 592/** 593 * ice_lag_build_netdev_list - populate the lag struct's netdev list 594 * @lag: local lag struct 595 * @ndlist: pointer to netdev list to populate 596 */ 597static void ice_lag_build_netdev_list(struct ice_lag *lag, 598 struct ice_lag_netdev_list *ndlist) 599{ 600 struct ice_lag_netdev_list *nl; 601 struct net_device *tmp_nd; 602 603 INIT_LIST_HEAD(&ndlist->node); 604 rcu_read_lock(); 605 for_each_netdev_in_bond_rcu(lag->upper_netdev, tmp_nd) { 606 nl = kzalloc(sizeof(*nl), GFP_ATOMIC); 607 if (!nl) 608 break; 609 610 nl->netdev = tmp_nd; 611 list_add(&nl->node, &ndlist->node); 612 } 613 rcu_read_unlock(); 614 lag->netdev_head = &ndlist->node; 615} 616 617/** 618 * ice_lag_destroy_netdev_list - free lag struct's netdev list 619 * @lag: pointer to local lag struct 620 * @ndlist: pointer to lag struct netdev list 621 */ 622static void ice_lag_destroy_netdev_list(struct ice_lag *lag, 623 struct ice_lag_netdev_list *ndlist) 624{ 625 struct ice_lag_netdev_list *entry, *n; 626 627 rcu_read_lock(); 628 list_for_each_entry_safe(entry, n, &ndlist->node, node) { 629 list_del(&entry->node); 630 kfree(entry); 631 } 632 rcu_read_unlock(); 633 lag->netdev_head = NULL; 634} 635 636/** 637 * ice_lag_move_single_vf_nodes - Move Tx scheduling nodes for single VF 638 * @lag: primary interface LAG struct 639 * @oldport: lport of previous interface 640 * @newport: lport of destination interface 641 * @vsi_num: SW index of VF's VSI 642 */ 643static void 644ice_lag_move_single_vf_nodes(struct ice_lag *lag, u8 oldport, u8 newport, 645 u16 vsi_num) 646{ 647 u8 tc; 648 649 ice_for_each_traffic_class(tc) 650 ice_lag_move_vf_node_tc(lag, oldport, newport, vsi_num, tc); 651} 652 653/** 654 * ice_lag_move_new_vf_nodes - Move Tx scheduling nodes for a VF if required 655 * @vf: the VF to move Tx nodes for 656 * 657 * Called just after configuring new VF queues. Check whether the VF Tx 658 * scheduling nodes need to be updated to fail over to the active port. If so, 659 * move them now. 660 */ 661void ice_lag_move_new_vf_nodes(struct ice_vf *vf) 662{ 663 struct ice_lag_netdev_list ndlist; 664 u8 pri_port, act_port; 665 struct ice_lag *lag; 666 struct ice_vsi *vsi; 667 struct ice_pf *pf; 668 669 vsi = ice_get_vf_vsi(vf); 670 671 if (WARN_ON(!vsi)) 672 return; 673 674 if (WARN_ON(vsi->type != ICE_VSI_VF)) 675 return; 676 677 pf = vf->pf; 678 lag = pf->lag; 679 680 mutex_lock(&pf->lag_mutex); 681 if (!lag->bonded) 682 goto new_vf_unlock; 683 684 pri_port = pf->hw.port_info->lport; 685 act_port = lag->active_port; 686 687 if (lag->upper_netdev) 688 ice_lag_build_netdev_list(lag, &ndlist); 689 690 if (ice_is_feature_supported(pf, ICE_F_SRIOV_LAG) && 691 lag->bonded && lag->primary && pri_port != act_port && 692 !list_empty(lag->netdev_head)) 693 ice_lag_move_single_vf_nodes(lag, pri_port, act_port, vsi->idx); 694 695 ice_lag_destroy_netdev_list(lag, &ndlist); 696 697new_vf_unlock: 698 mutex_unlock(&pf->lag_mutex); 699} 700 701/** 702 * ice_lag_move_vf_nodes - move Tx scheduling nodes for all VFs to new port 703 * @lag: lag info struct 704 * @oldport: lport of previous interface 705 * @newport: lport of destination interface 706 */ 707static void ice_lag_move_vf_nodes(struct ice_lag *lag, u8 oldport, u8 newport) 708{ 709 struct ice_pf *pf; 710 int i; 711 712 if (!lag->primary) 713 return; 714 715 pf = lag->pf; 716 ice_for_each_vsi(pf, i) 717 if (pf->vsi[i] && (pf->vsi[i]->type == ICE_VSI_VF || 718 pf->vsi[i]->type == ICE_VSI_SWITCHDEV_CTRL)) 719 ice_lag_move_single_vf_nodes(lag, oldport, newport, i); 720} 721 722/** 723 * ice_lag_move_vf_nodes_cfg - move vf nodes outside LAG netdev event context 724 * @lag: local lag struct 725 * @src_prt: lport value for source port 726 * @dst_prt: lport value for destination port 727 * 728 * This function is used to move nodes during an out-of-netdev-event situation, 729 * primarily when the driver needs to reconfigure or recreate resources. 730 * 731 * Must be called while holding the lag_mutex to avoid lag events from 732 * processing while out-of-sync moves are happening. Also, paired moves, 733 * such as used in a reset flow, should both be called under the same mutex 734 * lock to avoid changes between start of reset and end of reset. 735 */ 736void ice_lag_move_vf_nodes_cfg(struct ice_lag *lag, u8 src_prt, u8 dst_prt) 737{ 738 struct ice_lag_netdev_list ndlist; 739 740 ice_lag_build_netdev_list(lag, &ndlist); 741 ice_lag_move_vf_nodes(lag, src_prt, dst_prt); 742 ice_lag_destroy_netdev_list(lag, &ndlist); 743} 744 745#define ICE_LAG_SRIOV_CP_RECIPE 10 746#define ICE_LAG_SRIOV_TRAIN_PKT_LEN 16 747 748/** 749 * ice_lag_cfg_cp_fltr - configure filter for control packets 750 * @lag: local interface's lag struct 751 * @add: add or remove rule 752 */ 753static void 754ice_lag_cfg_cp_fltr(struct ice_lag *lag, bool add) 755{ 756 struct ice_sw_rule_lkup_rx_tx *s_rule = NULL; 757 struct ice_vsi *vsi; 758 u16 buf_len, opc; 759 760 vsi = lag->pf->vsi[0]; 761 762 buf_len = ICE_SW_RULE_RX_TX_HDR_SIZE(s_rule, 763 ICE_LAG_SRIOV_TRAIN_PKT_LEN); 764 s_rule = kzalloc(buf_len, GFP_KERNEL); 765 if (!s_rule) { 766 netdev_warn(lag->netdev, "-ENOMEM error configuring CP filter\n"); 767 return; 768 } 769 770 if (add) { 771 s_rule->hdr.type = cpu_to_le16(ICE_AQC_SW_RULES_T_LKUP_RX); 772 s_rule->recipe_id = cpu_to_le16(ICE_LAG_SRIOV_CP_RECIPE); 773 s_rule->src = cpu_to_le16(vsi->port_info->lport); 774 s_rule->act = cpu_to_le32(ICE_FWD_TO_VSI | 775 ICE_SINGLE_ACT_LAN_ENABLE | 776 ICE_SINGLE_ACT_VALID_BIT | 777 FIELD_PREP(ICE_SINGLE_ACT_VSI_ID_M, vsi->vsi_num)); 778 s_rule->hdr_len = cpu_to_le16(ICE_LAG_SRIOV_TRAIN_PKT_LEN); 779 memcpy(s_rule->hdr_data, lacp_train_pkt, LACP_TRAIN_PKT_LEN); 780 opc = ice_aqc_opc_add_sw_rules; 781 } else { 782 opc = ice_aqc_opc_remove_sw_rules; 783 s_rule->index = cpu_to_le16(lag->cp_rule_idx); 784 } 785 if (ice_aq_sw_rules(&lag->pf->hw, s_rule, buf_len, 1, opc, NULL)) { 786 netdev_warn(lag->netdev, "Error %s CP rule for fail-over\n", 787 add ? "ADDING" : "REMOVING"); 788 goto cp_free; 789 } 790 791 if (add) 792 lag->cp_rule_idx = le16_to_cpu(s_rule->index); 793 else 794 lag->cp_rule_idx = 0; 795 796cp_free: 797 kfree(s_rule); 798} 799 800/** 801 * ice_lag_info_event - handle NETDEV_BONDING_INFO event 802 * @lag: LAG info struct 803 * @ptr: opaque data pointer 804 * 805 * ptr is to be cast to (netdev_notifier_bonding_info *) 806 */ 807static void ice_lag_info_event(struct ice_lag *lag, void *ptr) 808{ 809 struct netdev_notifier_bonding_info *info; 810 struct netdev_bonding_info *bonding_info; 811 struct net_device *event_netdev; 812 const char *lag_netdev_name; 813 814 event_netdev = netdev_notifier_info_to_dev(ptr); 815 info = ptr; 816 lag_netdev_name = netdev_name(lag->netdev); 817 bonding_info = &info->bonding_info; 818 819 if (event_netdev != lag->netdev || !lag->bonded || !lag->upper_netdev) 820 return; 821 822 if (bonding_info->master.bond_mode != BOND_MODE_ACTIVEBACKUP) { 823 netdev_dbg(lag->netdev, "Bonding event recv, but mode not active/backup\n"); 824 goto lag_out; 825 } 826 827 if (strcmp(bonding_info->slave.slave_name, lag_netdev_name)) { 828 netdev_dbg(lag->netdev, "Bonding event recv, but secondary info not for us\n"); 829 goto lag_out; 830 } 831 832 if (bonding_info->slave.state) 833 ice_lag_set_backup(lag); 834 else 835 ice_lag_set_primary(lag); 836 837lag_out: 838 ice_display_lag_info(lag); 839} 840 841/** 842 * ice_lag_reclaim_vf_tc - move scheduling nodes back to primary interface 843 * @lag: primary interface lag struct 844 * @src_hw: HW struct current node location 845 * @vsi_num: VSI index in PF space 846 * @tc: traffic class to move 847 */ 848static void 849ice_lag_reclaim_vf_tc(struct ice_lag *lag, struct ice_hw *src_hw, u16 vsi_num, 850 u8 tc) 851{ 852 DEFINE_RAW_FLEX(struct ice_aqc_move_elem, buf, teid, 1); 853 struct device *dev = ice_pf_to_dev(lag->pf); 854 u16 numq, valq, num_moved, qbuf_size; 855 u16 buf_size = __struct_size(buf); 856 struct ice_aqc_cfg_txqs_buf *qbuf; 857 struct ice_sched_node *n_prt; 858 __le32 teid, parent_teid; 859 struct ice_vsi_ctx *ctx; 860 struct ice_hw *hw; 861 u32 tmp_teid; 862 863 hw = &lag->pf->hw; 864 ctx = ice_get_vsi_ctx(hw, vsi_num); 865 if (!ctx) { 866 dev_warn(dev, "Unable to locate VSI context for LAG reclaim\n"); 867 return; 868 } 869 870 /* check to see if this VF is enabled on this TC */ 871 if (!ctx->sched.vsi_node[tc]) 872 return; 873 874 numq = ctx->num_lan_q_entries[tc]; 875 teid = ctx->sched.vsi_node[tc]->info.node_teid; 876 tmp_teid = le32_to_cpu(teid); 877 parent_teid = ctx->sched.vsi_node[tc]->info.parent_teid; 878 879 /* if !teid or !numq, then this TC is not active */ 880 if (!tmp_teid || !numq) 881 return; 882 883 /* suspend traffic */ 884 if (ice_sched_suspend_resume_elems(hw, 1, &tmp_teid, true)) 885 dev_dbg(dev, "Problem suspending traffic for LAG node move\n"); 886 887 /* reconfig queues for new port */ 888 qbuf_size = struct_size(qbuf, queue_info, numq); 889 qbuf = kzalloc(qbuf_size, GFP_KERNEL); 890 if (!qbuf) { 891 dev_warn(dev, "Failure allocating memory for VF queue recfg buffer\n"); 892 goto resume_reclaim; 893 } 894 895 /* add the per queue info for the reconfigure command buffer */ 896 valq = ice_lag_qbuf_recfg(hw, qbuf, vsi_num, numq, tc); 897 if (!valq) { 898 dev_dbg(dev, "No valid queues found for LAG reclaim\n"); 899 goto reclaim_none; 900 } 901 902 if (ice_aq_cfg_lan_txq(hw, qbuf, qbuf_size, numq, 903 src_hw->port_info->lport, hw->port_info->lport, 904 NULL)) { 905 dev_warn(dev, "Failure to configure queues for LAG failover\n"); 906 goto reclaim_qerr; 907 } 908 909reclaim_none: 910 kfree(qbuf); 911 912 /* find parent in primary tree */ 913 n_prt = ice_lag_get_sched_parent(hw, tc); 914 if (!n_prt) 915 goto resume_reclaim; 916 917 /* Move node to new parent */ 918 buf->hdr.src_parent_teid = parent_teid; 919 buf->hdr.dest_parent_teid = n_prt->info.node_teid; 920 buf->hdr.num_elems = cpu_to_le16(1); 921 buf->hdr.mode = ICE_AQC_MOVE_ELEM_MODE_KEEP_OWN; 922 buf->teid[0] = teid; 923 924 if (ice_aq_move_sched_elems(&lag->pf->hw, buf, buf_size, &num_moved)) 925 dev_warn(dev, "Failure to move VF nodes for LAG reclaim\n"); 926 else 927 ice_sched_update_parent(n_prt, ctx->sched.vsi_node[tc]); 928 929 goto resume_reclaim; 930 931reclaim_qerr: 932 kfree(qbuf); 933 934resume_reclaim: 935 /* restart traffic */ 936 if (ice_sched_suspend_resume_elems(hw, 1, &tmp_teid, false)) 937 dev_warn(dev, "Problem restarting traffic for LAG node reclaim\n"); 938} 939 940/** 941 * ice_lag_reclaim_vf_nodes - When interface leaving bond primary reclaims nodes 942 * @lag: primary interface lag struct 943 * @src_hw: HW struct for current node location 944 */ 945static void 946ice_lag_reclaim_vf_nodes(struct ice_lag *lag, struct ice_hw *src_hw) 947{ 948 struct ice_pf *pf; 949 int i, tc; 950 951 if (!lag->primary || !src_hw) 952 return; 953 954 pf = lag->pf; 955 ice_for_each_vsi(pf, i) 956 if (pf->vsi[i] && (pf->vsi[i]->type == ICE_VSI_VF || 957 pf->vsi[i]->type == ICE_VSI_SWITCHDEV_CTRL)) 958 ice_for_each_traffic_class(tc) 959 ice_lag_reclaim_vf_tc(lag, src_hw, i, tc); 960} 961 962/** 963 * ice_lag_link - handle LAG link event 964 * @lag: LAG info struct 965 */ 966static void ice_lag_link(struct ice_lag *lag) 967{ 968 struct ice_pf *pf = lag->pf; 969 970 if (lag->bonded) 971 dev_warn(ice_pf_to_dev(pf), "%s Already part of a bond\n", 972 netdev_name(lag->netdev)); 973 974 lag->bonded = true; 975 lag->role = ICE_LAG_UNSET; 976 netdev_info(lag->netdev, "Shared SR-IOV resources in bond are active\n"); 977} 978 979/** 980 * ice_lag_unlink - handle unlink event 981 * @lag: LAG info struct 982 */ 983static void ice_lag_unlink(struct ice_lag *lag) 984{ 985 u8 pri_port, act_port, loc_port; 986 struct ice_pf *pf = lag->pf; 987 988 if (!lag->bonded) { 989 netdev_dbg(lag->netdev, "bonding unlink event on non-LAG netdev\n"); 990 return; 991 } 992 993 if (lag->primary) { 994 act_port = lag->active_port; 995 pri_port = lag->pf->hw.port_info->lport; 996 if (act_port != pri_port && act_port != ICE_LAG_INVALID_PORT) 997 ice_lag_move_vf_nodes(lag, act_port, pri_port); 998 lag->primary = false; 999 lag->active_port = ICE_LAG_INVALID_PORT; 1000 } else { 1001 struct ice_lag *primary_lag; 1002 1003 primary_lag = ice_lag_find_primary(lag); 1004 if (primary_lag) { 1005 act_port = primary_lag->active_port; 1006 pri_port = primary_lag->pf->hw.port_info->lport; 1007 loc_port = pf->hw.port_info->lport; 1008 if (act_port == loc_port && 1009 act_port != ICE_LAG_INVALID_PORT) { 1010 ice_lag_reclaim_vf_nodes(primary_lag, 1011 &lag->pf->hw); 1012 primary_lag->active_port = ICE_LAG_INVALID_PORT; 1013 } 1014 } 1015 } 1016 1017 lag->bonded = false; 1018 lag->role = ICE_LAG_NONE; 1019 lag->upper_netdev = NULL; 1020} 1021 1022/** 1023 * ice_lag_link_unlink - helper function to call lag_link/unlink 1024 * @lag: lag info struct 1025 * @ptr: opaque pointer data 1026 */ 1027static void ice_lag_link_unlink(struct ice_lag *lag, void *ptr) 1028{ 1029 struct net_device *netdev = netdev_notifier_info_to_dev(ptr); 1030 struct netdev_notifier_changeupper_info *info = ptr; 1031 1032 if (netdev != lag->netdev) 1033 return; 1034 1035 if (info->linking) 1036 ice_lag_link(lag); 1037 else 1038 ice_lag_unlink(lag); 1039} 1040 1041/** 1042 * ice_lag_set_swid - set the SWID on secondary interface 1043 * @primary_swid: primary interface's SWID 1044 * @local_lag: local interfaces LAG struct 1045 * @link: Is this a linking activity 1046 * 1047 * If link is false, then primary_swid should be expected to not be valid 1048 * This function should never be called in interrupt context. 1049 */ 1050static void 1051ice_lag_set_swid(u16 primary_swid, struct ice_lag *local_lag, 1052 bool link) 1053{ 1054 struct ice_aqc_alloc_free_res_elem *buf; 1055 struct ice_aqc_set_port_params *cmd; 1056 struct ice_aq_desc desc; 1057 u16 buf_len, swid; 1058 int status, i; 1059 1060 buf_len = struct_size(buf, elem, 1); 1061 buf = kzalloc(buf_len, GFP_KERNEL); 1062 if (!buf) { 1063 dev_err(ice_pf_to_dev(local_lag->pf), "-ENOMEM error setting SWID\n"); 1064 return; 1065 } 1066 1067 buf->num_elems = cpu_to_le16(1); 1068 buf->res_type = cpu_to_le16(ICE_AQC_RES_TYPE_SWID); 1069 /* if unlinnking need to free the shared resource */ 1070 if (!link && local_lag->bond_swid) { 1071 buf->elem[0].e.sw_resp = cpu_to_le16(local_lag->bond_swid); 1072 status = ice_aq_alloc_free_res(&local_lag->pf->hw, buf, 1073 buf_len, ice_aqc_opc_free_res); 1074 if (status) 1075 dev_err(ice_pf_to_dev(local_lag->pf), "Error freeing SWID during LAG unlink\n"); 1076 local_lag->bond_swid = 0; 1077 } 1078 1079 if (link) { 1080 buf->res_type |= cpu_to_le16(ICE_LAG_RES_SHARED | 1081 ICE_LAG_RES_VALID); 1082 /* store the primary's SWID in case it leaves bond first */ 1083 local_lag->bond_swid = primary_swid; 1084 buf->elem[0].e.sw_resp = cpu_to_le16(local_lag->bond_swid); 1085 } else { 1086 buf->elem[0].e.sw_resp = 1087 cpu_to_le16(local_lag->pf->hw.port_info->sw_id); 1088 } 1089 1090 status = ice_aq_alloc_free_res(&local_lag->pf->hw, buf, buf_len, 1091 ice_aqc_opc_alloc_res); 1092 if (status) 1093 dev_err(ice_pf_to_dev(local_lag->pf), "Error subscribing to SWID 0x%04X\n", 1094 local_lag->bond_swid); 1095 1096 kfree(buf); 1097 1098 /* Configure port param SWID to correct value */ 1099 if (link) 1100 swid = primary_swid; 1101 else 1102 swid = local_lag->pf->hw.port_info->sw_id; 1103 1104 cmd = &desc.params.set_port_params; 1105 ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_set_port_params); 1106 1107 cmd->swid = cpu_to_le16(ICE_AQC_PORT_SWID_VALID | swid); 1108 /* If this is happening in reset context, it is possible that the 1109 * primary interface has not finished setting its SWID to SHARED 1110 * yet. Allow retries to account for this timing issue between 1111 * interfaces. 1112 */ 1113 for (i = 0; i < ICE_LAG_RESET_RETRIES; i++) { 1114 status = ice_aq_send_cmd(&local_lag->pf->hw, &desc, NULL, 0, 1115 NULL); 1116 if (!status) 1117 break; 1118 1119 usleep_range(1000, 2000); 1120 } 1121 1122 if (status) 1123 dev_err(ice_pf_to_dev(local_lag->pf), "Error setting SWID in port params %d\n", 1124 status); 1125} 1126 1127/** 1128 * ice_lag_primary_swid - set/clear the SHARED attrib of primary's SWID 1129 * @lag: primary interface's lag struct 1130 * @link: is this a linking activity 1131 * 1132 * Implement setting primary SWID as shared using 0x020B 1133 */ 1134static void ice_lag_primary_swid(struct ice_lag *lag, bool link) 1135{ 1136 struct ice_hw *hw; 1137 u16 swid; 1138 1139 hw = &lag->pf->hw; 1140 swid = hw->port_info->sw_id; 1141 1142 if (ice_share_res(hw, ICE_AQC_RES_TYPE_SWID, link, swid)) 1143 dev_warn(ice_pf_to_dev(lag->pf), "Failure to set primary interface shared status\n"); 1144} 1145 1146/** 1147 * ice_lag_add_prune_list - Adds event_pf's VSI to primary's prune list 1148 * @lag: lag info struct 1149 * @event_pf: PF struct for VSI we are adding to primary's prune list 1150 */ 1151static void ice_lag_add_prune_list(struct ice_lag *lag, struct ice_pf *event_pf) 1152{ 1153 u16 num_vsi, rule_buf_sz, vsi_list_id, event_vsi_num, prim_vsi_idx; 1154 struct ice_sw_rule_vsi_list *s_rule = NULL; 1155 struct device *dev; 1156 1157 num_vsi = 1; 1158 1159 dev = ice_pf_to_dev(lag->pf); 1160 event_vsi_num = event_pf->vsi[0]->vsi_num; 1161 prim_vsi_idx = lag->pf->vsi[0]->idx; 1162 1163 if (!ice_find_vsi_list_entry(&lag->pf->hw, ICE_SW_LKUP_VLAN, 1164 prim_vsi_idx, &vsi_list_id)) { 1165 dev_warn(dev, "Could not locate prune list when setting up SRIOV LAG\n"); 1166 return; 1167 } 1168 1169 rule_buf_sz = (u16)ICE_SW_RULE_VSI_LIST_SIZE(s_rule, num_vsi); 1170 s_rule = kzalloc(rule_buf_sz, GFP_KERNEL); 1171 if (!s_rule) { 1172 dev_warn(dev, "Error allocating space for prune list when configuring SRIOV LAG\n"); 1173 return; 1174 } 1175 1176 s_rule->hdr.type = cpu_to_le16(ICE_AQC_SW_RULES_T_PRUNE_LIST_SET); 1177 s_rule->index = cpu_to_le16(vsi_list_id); 1178 s_rule->number_vsi = cpu_to_le16(num_vsi); 1179 s_rule->vsi[0] = cpu_to_le16(event_vsi_num); 1180 1181 if (ice_aq_sw_rules(&event_pf->hw, s_rule, rule_buf_sz, 1, 1182 ice_aqc_opc_update_sw_rules, NULL)) 1183 dev_warn(dev, "Error adding VSI prune list\n"); 1184 kfree(s_rule); 1185} 1186 1187/** 1188 * ice_lag_del_prune_list - Remove secondary's vsi from primary's prune list 1189 * @lag: primary interface's ice_lag struct 1190 * @event_pf: PF struct for unlinking interface 1191 */ 1192static void ice_lag_del_prune_list(struct ice_lag *lag, struct ice_pf *event_pf) 1193{ 1194 u16 num_vsi, vsi_num, vsi_idx, rule_buf_sz, vsi_list_id; 1195 struct ice_sw_rule_vsi_list *s_rule = NULL; 1196 struct device *dev; 1197 1198 num_vsi = 1; 1199 1200 dev = ice_pf_to_dev(lag->pf); 1201 vsi_num = event_pf->vsi[0]->vsi_num; 1202 vsi_idx = lag->pf->vsi[0]->idx; 1203 1204 if (!ice_find_vsi_list_entry(&lag->pf->hw, ICE_SW_LKUP_VLAN, 1205 vsi_idx, &vsi_list_id)) { 1206 dev_warn(dev, "Could not locate prune list when unwinding SRIOV LAG\n"); 1207 return; 1208 } 1209 1210 rule_buf_sz = (u16)ICE_SW_RULE_VSI_LIST_SIZE(s_rule, num_vsi); 1211 s_rule = kzalloc(rule_buf_sz, GFP_KERNEL); 1212 if (!s_rule) { 1213 dev_warn(dev, "Error allocating prune list when unwinding SRIOV LAG\n"); 1214 return; 1215 } 1216 1217 s_rule->hdr.type = cpu_to_le16(ICE_AQC_SW_RULES_T_PRUNE_LIST_CLEAR); 1218 s_rule->index = cpu_to_le16(vsi_list_id); 1219 s_rule->number_vsi = cpu_to_le16(num_vsi); 1220 s_rule->vsi[0] = cpu_to_le16(vsi_num); 1221 1222 if (ice_aq_sw_rules(&event_pf->hw, (struct ice_aqc_sw_rules *)s_rule, 1223 rule_buf_sz, 1, ice_aqc_opc_update_sw_rules, NULL)) 1224 dev_warn(dev, "Error clearing VSI prune list\n"); 1225 1226 kfree(s_rule); 1227} 1228 1229/** 1230 * ice_lag_init_feature_support_flag - Check for package and NVM support for LAG 1231 * @pf: PF struct 1232 */ 1233static void ice_lag_init_feature_support_flag(struct ice_pf *pf) 1234{ 1235 struct ice_hw_common_caps *caps; 1236 1237 caps = &pf->hw.dev_caps.common_cap; 1238 if (caps->roce_lag) 1239 ice_set_feature_support(pf, ICE_F_ROCE_LAG); 1240 else 1241 ice_clear_feature_support(pf, ICE_F_ROCE_LAG); 1242 1243 if (caps->sriov_lag && ice_pkg_has_lport_extract(&pf->hw)) 1244 ice_set_feature_support(pf, ICE_F_SRIOV_LAG); 1245 else 1246 ice_clear_feature_support(pf, ICE_F_SRIOV_LAG); 1247} 1248 1249/** 1250 * ice_lag_changeupper_event - handle LAG changeupper event 1251 * @lag: LAG info struct 1252 * @ptr: opaque pointer data 1253 */ 1254static void ice_lag_changeupper_event(struct ice_lag *lag, void *ptr) 1255{ 1256 struct netdev_notifier_changeupper_info *info; 1257 struct ice_lag *primary_lag; 1258 struct net_device *netdev; 1259 1260 info = ptr; 1261 netdev = netdev_notifier_info_to_dev(ptr); 1262 1263 /* not for this netdev */ 1264 if (netdev != lag->netdev) 1265 return; 1266 1267 primary_lag = ice_lag_find_primary(lag); 1268 if (info->linking) { 1269 lag->upper_netdev = info->upper_dev; 1270 /* If there is not already a primary interface in the LAG, 1271 * then mark this one as primary. 1272 */ 1273 if (!primary_lag) { 1274 lag->primary = true; 1275 /* Configure primary's SWID to be shared */ 1276 ice_lag_primary_swid(lag, true); 1277 primary_lag = lag; 1278 } else { 1279 u16 swid; 1280 1281 swid = primary_lag->pf->hw.port_info->sw_id; 1282 ice_lag_set_swid(swid, lag, true); 1283 ice_lag_add_prune_list(primary_lag, lag->pf); 1284 ice_lag_cfg_drop_fltr(lag, true); 1285 } 1286 /* add filter for primary control packets */ 1287 ice_lag_cfg_cp_fltr(lag, true); 1288 } else { 1289 if (!primary_lag && lag->primary) 1290 primary_lag = lag; 1291 1292 if (!lag->primary) { 1293 ice_lag_set_swid(0, lag, false); 1294 } else { 1295 if (primary_lag && lag->primary) { 1296 ice_lag_primary_swid(lag, false); 1297 ice_lag_del_prune_list(primary_lag, lag->pf); 1298 } 1299 } 1300 /* remove filter for control packets */ 1301 ice_lag_cfg_cp_fltr(lag, false); 1302 } 1303} 1304 1305/** 1306 * ice_lag_monitor_link - monitor interfaces entering/leaving the aggregate 1307 * @lag: lag info struct 1308 * @ptr: opaque data containing notifier event 1309 * 1310 * This function only operates after a primary has been set. 1311 */ 1312static void ice_lag_monitor_link(struct ice_lag *lag, void *ptr) 1313{ 1314 struct netdev_notifier_changeupper_info *info; 1315 struct ice_hw *prim_hw, *active_hw; 1316 struct net_device *event_netdev; 1317 struct ice_pf *pf; 1318 u8 prim_port; 1319 1320 if (!lag->primary) 1321 return; 1322 1323 event_netdev = netdev_notifier_info_to_dev(ptr); 1324 if (!netif_is_same_ice(lag->pf, event_netdev)) 1325 return; 1326 1327 pf = lag->pf; 1328 prim_hw = &pf->hw; 1329 prim_port = prim_hw->port_info->lport; 1330 1331 info = (struct netdev_notifier_changeupper_info *)ptr; 1332 if (info->upper_dev != lag->upper_netdev) 1333 return; 1334 1335 if (!info->linking) { 1336 /* Since there are only two interfaces allowed in SRIOV+LAG, if 1337 * one port is leaving, then nodes need to be on primary 1338 * interface. 1339 */ 1340 if (prim_port != lag->active_port && 1341 lag->active_port != ICE_LAG_INVALID_PORT) { 1342 active_hw = ice_lag_find_hw_by_lport(lag, 1343 lag->active_port); 1344 ice_lag_reclaim_vf_nodes(lag, active_hw); 1345 lag->active_port = ICE_LAG_INVALID_PORT; 1346 } 1347 } 1348} 1349 1350/** 1351 * ice_lag_monitor_active - main PF keep track of which port is active 1352 * @lag: lag info struct 1353 * @ptr: opaque data containing notifier event 1354 * 1355 * This function is for the primary PF to monitor changes in which port is 1356 * active and handle changes for SRIOV VF functionality 1357 */ 1358static void ice_lag_monitor_active(struct ice_lag *lag, void *ptr) 1359{ 1360 struct net_device *event_netdev, *event_upper; 1361 struct netdev_notifier_bonding_info *info; 1362 struct netdev_bonding_info *bonding_info; 1363 struct ice_netdev_priv *event_np; 1364 struct ice_pf *pf, *event_pf; 1365 u8 prim_port, event_port; 1366 1367 if (!lag->primary) 1368 return; 1369 1370 pf = lag->pf; 1371 if (!pf) 1372 return; 1373 1374 event_netdev = netdev_notifier_info_to_dev(ptr); 1375 rcu_read_lock(); 1376 event_upper = netdev_master_upper_dev_get_rcu(event_netdev); 1377 rcu_read_unlock(); 1378 if (!netif_is_ice(event_netdev) || event_upper != lag->upper_netdev) 1379 return; 1380 1381 event_np = netdev_priv(event_netdev); 1382 event_pf = event_np->vsi->back; 1383 event_port = event_pf->hw.port_info->lport; 1384 prim_port = pf->hw.port_info->lport; 1385 1386 info = (struct netdev_notifier_bonding_info *)ptr; 1387 bonding_info = &info->bonding_info; 1388 1389 if (!bonding_info->slave.state) { 1390 /* if no port is currently active, then nodes and filters exist 1391 * on primary port, check if we need to move them 1392 */ 1393 if (lag->active_port == ICE_LAG_INVALID_PORT) { 1394 if (event_port != prim_port) 1395 ice_lag_move_vf_nodes(lag, prim_port, 1396 event_port); 1397 lag->active_port = event_port; 1398 return; 1399 } 1400 1401 /* active port is already set and is current event port */ 1402 if (lag->active_port == event_port) 1403 return; 1404 /* new active port */ 1405 ice_lag_move_vf_nodes(lag, lag->active_port, event_port); 1406 lag->active_port = event_port; 1407 } else { 1408 /* port not set as currently active (e.g. new active port 1409 * has already claimed the nodes and filters 1410 */ 1411 if (lag->active_port != event_port) 1412 return; 1413 /* This is the case when neither port is active (both link down) 1414 * Link down on the bond - set active port to invalid and move 1415 * nodes and filters back to primary if not already there 1416 */ 1417 if (event_port != prim_port) 1418 ice_lag_move_vf_nodes(lag, event_port, prim_port); 1419 lag->active_port = ICE_LAG_INVALID_PORT; 1420 } 1421} 1422 1423/** 1424 * ice_lag_chk_comp - evaluate bonded interface for feature support 1425 * @lag: lag info struct 1426 * @ptr: opaque data for netdev event info 1427 */ 1428static bool 1429ice_lag_chk_comp(struct ice_lag *lag, void *ptr) 1430{ 1431 struct net_device *event_netdev, *event_upper; 1432 struct netdev_notifier_bonding_info *info; 1433 struct netdev_bonding_info *bonding_info; 1434 struct list_head *tmp; 1435 struct device *dev; 1436 int count = 0; 1437 1438 if (!lag->primary) 1439 return true; 1440 1441 event_netdev = netdev_notifier_info_to_dev(ptr); 1442 rcu_read_lock(); 1443 event_upper = netdev_master_upper_dev_get_rcu(event_netdev); 1444 rcu_read_unlock(); 1445 if (event_upper != lag->upper_netdev) 1446 return true; 1447 1448 dev = ice_pf_to_dev(lag->pf); 1449 1450 /* only supporting switchdev mode for SRIOV VF LAG. 1451 * primary interface has to be in switchdev mode 1452 */ 1453 if (!ice_is_switchdev_running(lag->pf)) { 1454 dev_info(dev, "Primary interface not in switchdev mode - VF LAG disabled\n"); 1455 return false; 1456 } 1457 1458 info = (struct netdev_notifier_bonding_info *)ptr; 1459 bonding_info = &info->bonding_info; 1460 lag->bond_mode = bonding_info->master.bond_mode; 1461 if (lag->bond_mode != BOND_MODE_ACTIVEBACKUP) { 1462 dev_info(dev, "Bond Mode not ACTIVE-BACKUP - VF LAG disabled\n"); 1463 return false; 1464 } 1465 1466 list_for_each(tmp, lag->netdev_head) { 1467 struct ice_dcbx_cfg *dcb_cfg, *peer_dcb_cfg; 1468 struct ice_lag_netdev_list *entry; 1469 struct ice_netdev_priv *peer_np; 1470 struct net_device *peer_netdev; 1471 struct ice_vsi *vsi, *peer_vsi; 1472 struct ice_pf *peer_pf; 1473 1474 entry = list_entry(tmp, struct ice_lag_netdev_list, node); 1475 peer_netdev = entry->netdev; 1476 if (!netif_is_ice(peer_netdev)) { 1477 dev_info(dev, "Found %s non-ice netdev in LAG - VF LAG disabled\n", 1478 netdev_name(peer_netdev)); 1479 return false; 1480 } 1481 1482 count++; 1483 if (count > 2) { 1484 dev_info(dev, "Found more than two netdevs in LAG - VF LAG disabled\n"); 1485 return false; 1486 } 1487 1488 peer_np = netdev_priv(peer_netdev); 1489 vsi = ice_get_main_vsi(lag->pf); 1490 peer_vsi = peer_np->vsi; 1491 if (lag->pf->pdev->bus != peer_vsi->back->pdev->bus || 1492 lag->pf->pdev->slot != peer_vsi->back->pdev->slot) { 1493 dev_info(dev, "Found %s on different device in LAG - VF LAG disabled\n", 1494 netdev_name(peer_netdev)); 1495 return false; 1496 } 1497 1498 dcb_cfg = &vsi->port_info->qos_cfg.local_dcbx_cfg; 1499 peer_dcb_cfg = &peer_vsi->port_info->qos_cfg.local_dcbx_cfg; 1500 if (memcmp(dcb_cfg, peer_dcb_cfg, 1501 sizeof(struct ice_dcbx_cfg))) { 1502 dev_info(dev, "Found %s with different DCB in LAG - VF LAG disabled\n", 1503 netdev_name(peer_netdev)); 1504 return false; 1505 } 1506 1507 peer_pf = peer_vsi->back; 1508 if (test_bit(ICE_FLAG_FW_LLDP_AGENT, peer_pf->flags)) { 1509 dev_warn(dev, "Found %s with FW LLDP agent active - VF LAG disabled\n", 1510 netdev_name(peer_netdev)); 1511 return false; 1512 } 1513 } 1514 1515 return true; 1516} 1517 1518/** 1519 * ice_lag_unregister - handle netdev unregister events 1520 * @lag: LAG info struct 1521 * @event_netdev: netdev struct for target of notifier event 1522 */ 1523static void 1524ice_lag_unregister(struct ice_lag *lag, struct net_device *event_netdev) 1525{ 1526 struct ice_netdev_priv *np; 1527 struct ice_pf *event_pf; 1528 struct ice_lag *p_lag; 1529 1530 p_lag = ice_lag_find_primary(lag); 1531 np = netdev_priv(event_netdev); 1532 event_pf = np->vsi->back; 1533 1534 if (p_lag) { 1535 if (p_lag->active_port != p_lag->pf->hw.port_info->lport && 1536 p_lag->active_port != ICE_LAG_INVALID_PORT) { 1537 struct ice_hw *active_hw; 1538 1539 active_hw = ice_lag_find_hw_by_lport(lag, 1540 p_lag->active_port); 1541 if (active_hw) 1542 ice_lag_reclaim_vf_nodes(p_lag, active_hw); 1543 lag->active_port = ICE_LAG_INVALID_PORT; 1544 } 1545 } 1546 1547 /* primary processing for primary */ 1548 if (lag->primary && lag->netdev == event_netdev) 1549 ice_lag_primary_swid(lag, false); 1550 1551 /* primary processing for secondary */ 1552 if (lag->primary && lag->netdev != event_netdev) 1553 ice_lag_del_prune_list(lag, event_pf); 1554 1555 /* secondary processing for secondary */ 1556 if (!lag->primary && lag->netdev == event_netdev) 1557 ice_lag_set_swid(0, lag, false); 1558} 1559 1560/** 1561 * ice_lag_monitor_rdma - set and clear rdma functionality 1562 * @lag: pointer to lag struct 1563 * @ptr: opaque data for netdev event info 1564 */ 1565static void 1566ice_lag_monitor_rdma(struct ice_lag *lag, void *ptr) 1567{ 1568 struct netdev_notifier_changeupper_info *info; 1569 struct net_device *netdev; 1570 1571 info = ptr; 1572 netdev = netdev_notifier_info_to_dev(ptr); 1573 1574 if (netdev != lag->netdev) 1575 return; 1576 1577 if (info->linking) 1578 ice_clear_rdma_cap(lag->pf); 1579 else 1580 ice_set_rdma_cap(lag->pf); 1581} 1582 1583/** 1584 * ice_lag_chk_disabled_bond - monitor interfaces entering/leaving disabled bond 1585 * @lag: lag info struct 1586 * @ptr: opaque data containing event 1587 * 1588 * as interfaces enter a bond - determine if the bond is currently 1589 * SRIOV LAG compliant and flag if not. As interfaces leave the 1590 * bond, reset their compliant status. 1591 */ 1592static void ice_lag_chk_disabled_bond(struct ice_lag *lag, void *ptr) 1593{ 1594 struct net_device *netdev = netdev_notifier_info_to_dev(ptr); 1595 struct netdev_notifier_changeupper_info *info = ptr; 1596 struct ice_lag *prim_lag; 1597 1598 if (netdev != lag->netdev) 1599 return; 1600 1601 if (info->linking) { 1602 prim_lag = ice_lag_find_primary(lag); 1603 if (prim_lag && 1604 !ice_is_feature_supported(prim_lag->pf, ICE_F_SRIOV_LAG)) { 1605 ice_clear_feature_support(lag->pf, ICE_F_SRIOV_LAG); 1606 netdev_info(netdev, "Interface added to non-compliant SRIOV LAG aggregate\n"); 1607 } 1608 } else { 1609 ice_lag_init_feature_support_flag(lag->pf); 1610 } 1611} 1612 1613/** 1614 * ice_lag_disable_sriov_bond - set members of bond as not supporting SRIOV LAG 1615 * @lag: primary interfaces lag struct 1616 */ 1617static void ice_lag_disable_sriov_bond(struct ice_lag *lag) 1618{ 1619 struct ice_netdev_priv *np; 1620 struct ice_pf *pf; 1621 1622 np = netdev_priv(lag->netdev); 1623 pf = np->vsi->back; 1624 ice_clear_feature_support(pf, ICE_F_SRIOV_LAG); 1625} 1626 1627/** 1628 * ice_lag_process_event - process a task assigned to the lag_wq 1629 * @work: pointer to work_struct 1630 */ 1631static void ice_lag_process_event(struct work_struct *work) 1632{ 1633 struct netdev_notifier_changeupper_info *info; 1634 struct ice_lag_work *lag_work; 1635 struct net_device *netdev; 1636 struct list_head *tmp, *n; 1637 struct ice_pf *pf; 1638 1639 lag_work = container_of(work, struct ice_lag_work, lag_task); 1640 pf = lag_work->lag->pf; 1641 1642 mutex_lock(&pf->lag_mutex); 1643 lag_work->lag->netdev_head = &lag_work->netdev_list.node; 1644 1645 switch (lag_work->event) { 1646 case NETDEV_CHANGEUPPER: 1647 info = &lag_work->info.changeupper_info; 1648 ice_lag_chk_disabled_bond(lag_work->lag, info); 1649 if (ice_is_feature_supported(pf, ICE_F_SRIOV_LAG)) { 1650 ice_lag_monitor_link(lag_work->lag, info); 1651 ice_lag_changeupper_event(lag_work->lag, info); 1652 ice_lag_link_unlink(lag_work->lag, info); 1653 } 1654 ice_lag_monitor_rdma(lag_work->lag, info); 1655 break; 1656 case NETDEV_BONDING_INFO: 1657 if (ice_is_feature_supported(pf, ICE_F_SRIOV_LAG)) { 1658 if (!ice_lag_chk_comp(lag_work->lag, 1659 &lag_work->info.bonding_info)) { 1660 netdev = lag_work->info.bonding_info.info.dev; 1661 ice_lag_disable_sriov_bond(lag_work->lag); 1662 ice_lag_unregister(lag_work->lag, netdev); 1663 goto lag_cleanup; 1664 } 1665 ice_lag_monitor_active(lag_work->lag, 1666 &lag_work->info.bonding_info); 1667 ice_lag_cfg_pf_fltrs(lag_work->lag, 1668 &lag_work->info.bonding_info); 1669 } 1670 ice_lag_info_event(lag_work->lag, &lag_work->info.bonding_info); 1671 break; 1672 case NETDEV_UNREGISTER: 1673 if (ice_is_feature_supported(pf, ICE_F_SRIOV_LAG)) { 1674 netdev = lag_work->info.bonding_info.info.dev; 1675 if ((netdev == lag_work->lag->netdev || 1676 lag_work->lag->primary) && lag_work->lag->bonded) 1677 ice_lag_unregister(lag_work->lag, netdev); 1678 } 1679 break; 1680 default: 1681 break; 1682 } 1683 1684lag_cleanup: 1685 /* cleanup resources allocated for this work item */ 1686 list_for_each_safe(tmp, n, &lag_work->netdev_list.node) { 1687 struct ice_lag_netdev_list *entry; 1688 1689 entry = list_entry(tmp, struct ice_lag_netdev_list, node); 1690 list_del(&entry->node); 1691 kfree(entry); 1692 } 1693 lag_work->lag->netdev_head = NULL; 1694 1695 mutex_unlock(&pf->lag_mutex); 1696 1697 kfree(lag_work); 1698} 1699 1700/** 1701 * ice_lag_event_handler - handle LAG events from netdev 1702 * @notif_blk: notifier block registered by this netdev 1703 * @event: event type 1704 * @ptr: opaque data containing notifier event 1705 */ 1706static int 1707ice_lag_event_handler(struct notifier_block *notif_blk, unsigned long event, 1708 void *ptr) 1709{ 1710 struct net_device *netdev = netdev_notifier_info_to_dev(ptr); 1711 struct net_device *upper_netdev; 1712 struct ice_lag_work *lag_work; 1713 struct ice_lag *lag; 1714 1715 if (!netif_is_ice(netdev)) 1716 return NOTIFY_DONE; 1717 1718 if (event != NETDEV_CHANGEUPPER && event != NETDEV_BONDING_INFO && 1719 event != NETDEV_UNREGISTER) 1720 return NOTIFY_DONE; 1721 1722 if (!(netdev->priv_flags & IFF_BONDING)) 1723 return NOTIFY_DONE; 1724 1725 lag = container_of(notif_blk, struct ice_lag, notif_block); 1726 if (!lag->netdev) 1727 return NOTIFY_DONE; 1728 1729 if (!net_eq(dev_net(netdev), &init_net)) 1730 return NOTIFY_DONE; 1731 1732 /* This memory will be freed at the end of ice_lag_process_event */ 1733 lag_work = kzalloc(sizeof(*lag_work), GFP_KERNEL); 1734 if (!lag_work) 1735 return -ENOMEM; 1736 1737 lag_work->event_netdev = netdev; 1738 lag_work->lag = lag; 1739 lag_work->event = event; 1740 if (event == NETDEV_CHANGEUPPER) { 1741 struct netdev_notifier_changeupper_info *info; 1742 1743 info = ptr; 1744 upper_netdev = info->upper_dev; 1745 } else { 1746 upper_netdev = netdev_master_upper_dev_get(netdev); 1747 } 1748 1749 INIT_LIST_HEAD(&lag_work->netdev_list.node); 1750 if (upper_netdev) { 1751 struct ice_lag_netdev_list *nd_list; 1752 struct net_device *tmp_nd; 1753 1754 rcu_read_lock(); 1755 for_each_netdev_in_bond_rcu(upper_netdev, tmp_nd) { 1756 nd_list = kzalloc(sizeof(*nd_list), GFP_ATOMIC); 1757 if (!nd_list) 1758 break; 1759 1760 nd_list->netdev = tmp_nd; 1761 list_add(&nd_list->node, &lag_work->netdev_list.node); 1762 } 1763 rcu_read_unlock(); 1764 } 1765 1766 switch (event) { 1767 case NETDEV_CHANGEUPPER: 1768 lag_work->info.changeupper_info = 1769 *((struct netdev_notifier_changeupper_info *)ptr); 1770 break; 1771 case NETDEV_BONDING_INFO: 1772 lag_work->info.bonding_info = 1773 *((struct netdev_notifier_bonding_info *)ptr); 1774 break; 1775 default: 1776 lag_work->info.notifier_info = 1777 *((struct netdev_notifier_info *)ptr); 1778 break; 1779 } 1780 1781 INIT_WORK(&lag_work->lag_task, ice_lag_process_event); 1782 queue_work(ice_lag_wq, &lag_work->lag_task); 1783 1784 return NOTIFY_DONE; 1785} 1786 1787/** 1788 * ice_register_lag_handler - register LAG handler on netdev 1789 * @lag: LAG struct 1790 */ 1791static int ice_register_lag_handler(struct ice_lag *lag) 1792{ 1793 struct device *dev = ice_pf_to_dev(lag->pf); 1794 struct notifier_block *notif_blk; 1795 1796 notif_blk = &lag->notif_block; 1797 1798 if (!notif_blk->notifier_call) { 1799 notif_blk->notifier_call = ice_lag_event_handler; 1800 if (register_netdevice_notifier(notif_blk)) { 1801 notif_blk->notifier_call = NULL; 1802 dev_err(dev, "FAIL register LAG event handler!\n"); 1803 return -EINVAL; 1804 } 1805 dev_dbg(dev, "LAG event handler registered\n"); 1806 } 1807 return 0; 1808} 1809 1810/** 1811 * ice_unregister_lag_handler - unregister LAG handler on netdev 1812 * @lag: LAG struct 1813 */ 1814static void ice_unregister_lag_handler(struct ice_lag *lag) 1815{ 1816 struct device *dev = ice_pf_to_dev(lag->pf); 1817 struct notifier_block *notif_blk; 1818 1819 notif_blk = &lag->notif_block; 1820 if (notif_blk->notifier_call) { 1821 unregister_netdevice_notifier(notif_blk); 1822 dev_dbg(dev, "LAG event handler unregistered\n"); 1823 } 1824} 1825 1826/** 1827 * ice_create_lag_recipe 1828 * @hw: pointer to HW struct 1829 * @rid: pointer to u16 to pass back recipe index 1830 * @base_recipe: recipe to base the new recipe on 1831 * @prio: priority for new recipe 1832 * 1833 * function returns 0 on error 1834 */ 1835static int ice_create_lag_recipe(struct ice_hw *hw, u16 *rid, 1836 const u8 *base_recipe, u8 prio) 1837{ 1838 struct ice_aqc_recipe_data_elem *new_rcp; 1839 int err; 1840 1841 err = ice_alloc_recipe(hw, rid); 1842 if (err) 1843 return err; 1844 1845 new_rcp = kzalloc(ICE_RECIPE_LEN * ICE_MAX_NUM_RECIPES, GFP_KERNEL); 1846 if (!new_rcp) 1847 return -ENOMEM; 1848 1849 memcpy(new_rcp, base_recipe, ICE_RECIPE_LEN); 1850 new_rcp->content.act_ctrl_fwd_priority = prio; 1851 new_rcp->content.rid = *rid | ICE_AQ_RECIPE_ID_IS_ROOT; 1852 new_rcp->recipe_indx = *rid; 1853 bitmap_zero((unsigned long *)new_rcp->recipe_bitmap, 1854 ICE_MAX_NUM_RECIPES); 1855 set_bit(*rid, (unsigned long *)new_rcp->recipe_bitmap); 1856 1857 err = ice_aq_add_recipe(hw, new_rcp, 1, NULL); 1858 if (err) 1859 *rid = 0; 1860 1861 kfree(new_rcp); 1862 return err; 1863} 1864 1865/** 1866 * ice_lag_move_vf_nodes_tc_sync - move a VF's nodes for a tc during reset 1867 * @lag: primary interfaces lag struct 1868 * @dest_hw: HW struct for destination's interface 1869 * @vsi_num: VSI index in PF space 1870 * @tc: traffic class to move 1871 */ 1872static void 1873ice_lag_move_vf_nodes_tc_sync(struct ice_lag *lag, struct ice_hw *dest_hw, 1874 u16 vsi_num, u8 tc) 1875{ 1876 DEFINE_RAW_FLEX(struct ice_aqc_move_elem, buf, teid, 1); 1877 struct device *dev = ice_pf_to_dev(lag->pf); 1878 u16 numq, valq, num_moved, qbuf_size; 1879 u16 buf_size = __struct_size(buf); 1880 struct ice_aqc_cfg_txqs_buf *qbuf; 1881 struct ice_sched_node *n_prt; 1882 __le32 teid, parent_teid; 1883 struct ice_vsi_ctx *ctx; 1884 struct ice_hw *hw; 1885 u32 tmp_teid; 1886 1887 hw = &lag->pf->hw; 1888 ctx = ice_get_vsi_ctx(hw, vsi_num); 1889 if (!ctx) { 1890 dev_warn(dev, "LAG rebuild failed after reset due to VSI Context failure\n"); 1891 return; 1892 } 1893 1894 if (!ctx->sched.vsi_node[tc]) 1895 return; 1896 1897 numq = ctx->num_lan_q_entries[tc]; 1898 teid = ctx->sched.vsi_node[tc]->info.node_teid; 1899 tmp_teid = le32_to_cpu(teid); 1900 parent_teid = ctx->sched.vsi_node[tc]->info.parent_teid; 1901 1902 if (!tmp_teid || !numq) 1903 return; 1904 1905 if (ice_sched_suspend_resume_elems(hw, 1, &tmp_teid, true)) 1906 dev_dbg(dev, "Problem suspending traffic during reset rebuild\n"); 1907 1908 /* reconfig queues for new port */ 1909 qbuf_size = struct_size(qbuf, queue_info, numq); 1910 qbuf = kzalloc(qbuf_size, GFP_KERNEL); 1911 if (!qbuf) { 1912 dev_warn(dev, "Failure allocating VF queue recfg buffer for reset rebuild\n"); 1913 goto resume_sync; 1914 } 1915 1916 /* add the per queue info for the reconfigure command buffer */ 1917 valq = ice_lag_qbuf_recfg(hw, qbuf, vsi_num, numq, tc); 1918 if (!valq) { 1919 dev_warn(dev, "Failure to reconfig queues for LAG reset rebuild\n"); 1920 goto sync_none; 1921 } 1922 1923 if (ice_aq_cfg_lan_txq(hw, qbuf, qbuf_size, numq, hw->port_info->lport, 1924 dest_hw->port_info->lport, NULL)) { 1925 dev_warn(dev, "Failure to configure queues for LAG reset rebuild\n"); 1926 goto sync_qerr; 1927 } 1928 1929sync_none: 1930 kfree(qbuf); 1931 1932 /* find parent in destination tree */ 1933 n_prt = ice_lag_get_sched_parent(dest_hw, tc); 1934 if (!n_prt) 1935 goto resume_sync; 1936 1937 /* Move node to new parent */ 1938 buf->hdr.src_parent_teid = parent_teid; 1939 buf->hdr.dest_parent_teid = n_prt->info.node_teid; 1940 buf->hdr.num_elems = cpu_to_le16(1); 1941 buf->hdr.mode = ICE_AQC_MOVE_ELEM_MODE_KEEP_OWN; 1942 buf->teid[0] = teid; 1943 1944 if (ice_aq_move_sched_elems(&lag->pf->hw, buf, buf_size, &num_moved)) 1945 dev_warn(dev, "Failure to move VF nodes for LAG reset rebuild\n"); 1946 else 1947 ice_sched_update_parent(n_prt, ctx->sched.vsi_node[tc]); 1948 1949 goto resume_sync; 1950 1951sync_qerr: 1952 kfree(qbuf); 1953 1954resume_sync: 1955 if (ice_sched_suspend_resume_elems(hw, 1, &tmp_teid, false)) 1956 dev_warn(dev, "Problem restarting traffic for LAG node reset rebuild\n"); 1957} 1958 1959/** 1960 * ice_lag_move_vf_nodes_sync - move vf nodes to active interface 1961 * @lag: primary interfaces lag struct 1962 * @dest_hw: lport value for currently active port 1963 * 1964 * This function is used in a reset context, outside of event handling, 1965 * to move the VF nodes to the secondary interface when that interface 1966 * is the active interface during a reset rebuild 1967 */ 1968static void 1969ice_lag_move_vf_nodes_sync(struct ice_lag *lag, struct ice_hw *dest_hw) 1970{ 1971 struct ice_pf *pf; 1972 int i, tc; 1973 1974 if (!lag->primary || !dest_hw) 1975 return; 1976 1977 pf = lag->pf; 1978 ice_for_each_vsi(pf, i) 1979 if (pf->vsi[i] && (pf->vsi[i]->type == ICE_VSI_VF || 1980 pf->vsi[i]->type == ICE_VSI_SWITCHDEV_CTRL)) 1981 ice_for_each_traffic_class(tc) 1982 ice_lag_move_vf_nodes_tc_sync(lag, dest_hw, i, 1983 tc); 1984} 1985 1986/** 1987 * ice_init_lag - initialize support for LAG 1988 * @pf: PF struct 1989 * 1990 * Alloc memory for LAG structs and initialize the elements. 1991 * Memory will be freed in ice_deinit_lag 1992 */ 1993int ice_init_lag(struct ice_pf *pf) 1994{ 1995 struct device *dev = ice_pf_to_dev(pf); 1996 struct ice_lag *lag; 1997 struct ice_vsi *vsi; 1998 u64 recipe_bits = 0; 1999 int n, err; 2000 2001 ice_lag_init_feature_support_flag(pf); 2002 if (!ice_is_feature_supported(pf, ICE_F_SRIOV_LAG)) 2003 return 0; 2004 2005 pf->lag = kzalloc(sizeof(*lag), GFP_KERNEL); 2006 if (!pf->lag) 2007 return -ENOMEM; 2008 lag = pf->lag; 2009 2010 vsi = ice_get_main_vsi(pf); 2011 if (!vsi) { 2012 dev_err(dev, "couldn't get main vsi, link aggregation init fail\n"); 2013 err = -EIO; 2014 goto lag_error; 2015 } 2016 2017 lag->pf = pf; 2018 lag->netdev = vsi->netdev; 2019 lag->role = ICE_LAG_NONE; 2020 lag->active_port = ICE_LAG_INVALID_PORT; 2021 lag->bonded = false; 2022 lag->upper_netdev = NULL; 2023 lag->notif_block.notifier_call = NULL; 2024 2025 err = ice_register_lag_handler(lag); 2026 if (err) { 2027 dev_warn(dev, "INIT LAG: Failed to register event handler\n"); 2028 goto lag_error; 2029 } 2030 2031 err = ice_create_lag_recipe(&pf->hw, &lag->pf_recipe, 2032 ice_dflt_vsi_rcp, 1); 2033 if (err) 2034 goto lag_error; 2035 2036 err = ice_create_lag_recipe(&pf->hw, &lag->lport_recipe, 2037 ice_lport_rcp, 3); 2038 if (err) 2039 goto free_rcp_res; 2040 2041 /* associate recipes to profiles */ 2042 for (n = 0; n < ICE_PROFID_IPV6_GTPU_IPV6_TCP_INNER; n++) { 2043 err = ice_aq_get_recipe_to_profile(&pf->hw, n, 2044 &recipe_bits, NULL); 2045 if (err) 2046 continue; 2047 2048 if (recipe_bits & BIT(ICE_SW_LKUP_DFLT)) { 2049 recipe_bits |= BIT(lag->pf_recipe) | 2050 BIT(lag->lport_recipe); 2051 ice_aq_map_recipe_to_profile(&pf->hw, n, 2052 recipe_bits, NULL); 2053 } 2054 } 2055 2056 ice_display_lag_info(lag); 2057 2058 dev_dbg(dev, "INIT LAG complete\n"); 2059 return 0; 2060 2061free_rcp_res: 2062 ice_free_hw_res(&pf->hw, ICE_AQC_RES_TYPE_RECIPE, 1, 2063 &pf->lag->pf_recipe); 2064lag_error: 2065 kfree(lag); 2066 pf->lag = NULL; 2067 return err; 2068} 2069 2070/** 2071 * ice_deinit_lag - Clean up LAG 2072 * @pf: PF struct 2073 * 2074 * Clean up kernel LAG info and free memory 2075 * This function is meant to only be called on driver remove/shutdown 2076 */ 2077void ice_deinit_lag(struct ice_pf *pf) 2078{ 2079 struct ice_lag *lag; 2080 2081 lag = pf->lag; 2082 2083 if (!lag) 2084 return; 2085 2086 if (lag->pf) 2087 ice_unregister_lag_handler(lag); 2088 2089 flush_workqueue(ice_lag_wq); 2090 2091 ice_free_hw_res(&pf->hw, ICE_AQC_RES_TYPE_RECIPE, 1, 2092 &pf->lag->pf_recipe); 2093 ice_free_hw_res(&pf->hw, ICE_AQC_RES_TYPE_RECIPE, 1, 2094 &pf->lag->lport_recipe); 2095 2096 kfree(lag); 2097 2098 pf->lag = NULL; 2099} 2100 2101/** 2102 * ice_lag_rebuild - rebuild lag resources after reset 2103 * @pf: pointer to local pf struct 2104 * 2105 * PF resets are promoted to CORER resets when interface in an aggregate. This 2106 * means that we need to rebuild the PF resources for the interface. Since 2107 * this will happen outside the normal event processing, need to acquire the lag 2108 * lock. 2109 * 2110 * This function will also evaluate the VF resources if this is the primary 2111 * interface. 2112 */ 2113void ice_lag_rebuild(struct ice_pf *pf) 2114{ 2115 struct ice_lag_netdev_list ndlist; 2116 struct ice_lag *lag, *prim_lag; 2117 u8 act_port, loc_port; 2118 2119 if (!pf->lag || !pf->lag->bonded) 2120 return; 2121 2122 mutex_lock(&pf->lag_mutex); 2123 2124 lag = pf->lag; 2125 if (lag->primary) { 2126 prim_lag = lag; 2127 } else { 2128 ice_lag_build_netdev_list(lag, &ndlist); 2129 prim_lag = ice_lag_find_primary(lag); 2130 } 2131 2132 if (!prim_lag) { 2133 dev_dbg(ice_pf_to_dev(pf), "No primary interface in aggregate, can't rebuild\n"); 2134 goto lag_rebuild_out; 2135 } 2136 2137 act_port = prim_lag->active_port; 2138 loc_port = lag->pf->hw.port_info->lport; 2139 2140 /* configure SWID for this port */ 2141 if (lag->primary) { 2142 ice_lag_primary_swid(lag, true); 2143 } else { 2144 ice_lag_set_swid(prim_lag->pf->hw.port_info->sw_id, lag, true); 2145 ice_lag_add_prune_list(prim_lag, pf); 2146 if (act_port == loc_port) 2147 ice_lag_move_vf_nodes_sync(prim_lag, &pf->hw); 2148 } 2149 2150 ice_lag_cfg_cp_fltr(lag, true); 2151 2152 if (lag->pf_rule_id) 2153 if (ice_lag_cfg_dflt_fltr(lag, true)) 2154 dev_err(ice_pf_to_dev(pf), "Error adding default VSI rule in rebuild\n"); 2155 2156 ice_clear_rdma_cap(pf); 2157lag_rebuild_out: 2158 ice_lag_destroy_netdev_list(lag, &ndlist); 2159 mutex_unlock(&pf->lag_mutex); 2160} 2161 2162/** 2163 * ice_lag_is_switchdev_running 2164 * @pf: pointer to PF structure 2165 * 2166 * Check if switchdev is running on any of the interfaces connected to lag. 2167 */ 2168bool ice_lag_is_switchdev_running(struct ice_pf *pf) 2169{ 2170 struct ice_lag *lag = pf->lag; 2171 struct net_device *tmp_nd; 2172 2173 if (!ice_is_feature_supported(pf, ICE_F_SRIOV_LAG) || !lag) 2174 return false; 2175 2176 rcu_read_lock(); 2177 for_each_netdev_in_bond_rcu(lag->upper_netdev, tmp_nd) { 2178 struct ice_netdev_priv *priv = netdev_priv(tmp_nd); 2179 2180 if (!netif_is_ice(tmp_nd) || !priv || !priv->vsi || 2181 !priv->vsi->back) 2182 continue; 2183 2184 if (ice_is_switchdev_running(priv->vsi->back)) { 2185 rcu_read_unlock(); 2186 return true; 2187 } 2188 } 2189 rcu_read_unlock(); 2190 2191 return false; 2192} 2193