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