drivers/net/ethernet/intel/ice/ice_lag.c

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