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