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

   1 // SPDX-License-Identifier: GPL-2.0
   2 /* Copyright (c) 2019, Intel Corporation. */
   3
   4 #include "ice_dcb_lib.h"
   5 #include "ice_dcb_nl.h"
   6
   7 /**
   8  * ice_vsi_cfg_netdev_tc - Setup the netdev TC configuration
   9  * @vsi: the VSI being configured
  10  * @ena_tc: TC map to be enabled
  11  */
  12 void ice_vsi_cfg_netdev_tc(struct ice_vsi *vsi, u8 ena_tc)
  13 {
  14         struct net_device *netdev = vsi->netdev;
  15         struct ice_pf *pf = vsi->back;
  16         struct ice_dcbx_cfg *dcbcfg;
  17         u8 netdev_tc;
  18         int i;
  19
  20         if (!netdev)
  21                 return;
  22
  23         if (!ena_tc) {
  24                 netdev_reset_tc(netdev);
  25                 return;
  26         }
  27
  28         if (netdev_set_num_tc(netdev, vsi->tc_cfg.numtc))
  29                 return;
  30
  31         dcbcfg = &pf->hw.port_info->local_dcbx_cfg;
  32
  33         ice_for_each_traffic_class(i)
  34                 if (vsi->tc_cfg.ena_tc & BIT(i))
  35                         netdev_set_tc_queue(netdev,
  36                                             vsi->tc_cfg.tc_info[i].netdev_tc,
  37                                             vsi->tc_cfg.tc_info[i].qcount_tx,
  38                                             vsi->tc_cfg.tc_info[i].qoffset);
  39
  40         for (i = 0; i < ICE_MAX_USER_PRIORITY; i++) {
  41                 u8 ets_tc = dcbcfg->etscfg.prio_table[i];
  42
  43                 /* Get the mapped netdev TC# for the UP */
  44                 netdev_tc = vsi->tc_cfg.tc_info[ets_tc].netdev_tc;
  45                 netdev_set_prio_tc_map(netdev, i, netdev_tc);
  46         }
  47 }
  48
  49 /**
  50  * ice_dcb_get_ena_tc - return bitmap of enabled TCs
  51  * @dcbcfg: DCB config to evaluate for enabled TCs
  52  */
  53 u8 ice_dcb_get_ena_tc(struct ice_dcbx_cfg *dcbcfg)
  54 {
  55         u8 i, num_tc, ena_tc = 1;
  56
  57         num_tc = ice_dcb_get_num_tc(dcbcfg);
  58
  59         for (i = 0; i < num_tc; i++)
  60                 ena_tc |= BIT(i);
  61
  62         return ena_tc;
  63 }
  64
  65 /**
  66  * ice_dcb_get_num_tc - Get the number of TCs from DCBX config
  67  * @dcbcfg: config to retrieve number of TCs from
  68  */
  69 u8 ice_dcb_get_num_tc(struct ice_dcbx_cfg *dcbcfg)
  70 {
  71         bool tc_unused = false;
  72         u8 num_tc = 0;
  73         u8 ret = 0;
  74         int i;
  75
  76         /* Scan the ETS Config Priority Table to find traffic classes
  77          * enabled and create a bitmask of enabled TCs
  78          */
  79         for (i = 0; i < CEE_DCBX_MAX_PRIO; i++)
  80                 num_tc |= BIT(dcbcfg->etscfg.prio_table[i]);
  81
  82         /* Scan bitmask for contiguous TCs starting with TC0 */
  83         for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
  84                 if (num_tc & BIT(i)) {
  85                         if (!tc_unused) {
  86                                 ret++;
  87                         } else {
  88                                 pr_err("Non-contiguous TCs - Disabling DCB\n");
  89                                 return 1;
  90                         }
  91                 } else {
  92                         tc_unused = true;
  93                 }
  94         }
  95
  96         /* There is always at least 1 TC */
  97         if (!ret)
  98                 ret = 1;
  99
 100         return ret;
 101 }
 102
 103 /**
 104  * ice_dcb_get_tc - Get the TC associated with the queue
 105  * @vsi: ptr to the VSI
 106  * @queue_index: queue number associated with VSI
 107  */
 108 u8 ice_dcb_get_tc(struct ice_vsi *vsi, int queue_index)
 109 {
 110         return vsi->tx_rings[queue_index]->dcb_tc;
 111 }
 112
 113 /**
 114  * ice_vsi_cfg_dcb_rings - Update rings to reflect DCB TC
 115  * @vsi: VSI owner of rings being updated
 116  */
 117 void ice_vsi_cfg_dcb_rings(struct ice_vsi *vsi)
 118 {
 119         struct ice_ring *tx_ring, *rx_ring;
 120         u16 qoffset, qcount;
 121         int i, n;
 122
 123         if (!test_bit(ICE_FLAG_DCB_ENA, vsi->back->flags)) {
 124                 /* Reset the TC information */
 125                 for (i = 0; i < vsi->num_txq; i++) {
 126                         tx_ring = vsi->tx_rings[i];
 127                         tx_ring->dcb_tc = 0;
 128                 }
 129                 for (i = 0; i < vsi->num_rxq; i++) {
 130                         rx_ring = vsi->rx_rings[i];
 131                         rx_ring->dcb_tc = 0;
 132                 }
 133                 return;
 134         }
 135
 136         ice_for_each_traffic_class(n) {
 137                 if (!(vsi->tc_cfg.ena_tc & BIT(n)))
 138                         break;
 139
 140                 qoffset = vsi->tc_cfg.tc_info[n].qoffset;
 141                 qcount = vsi->tc_cfg.tc_info[n].qcount_tx;
 142                 for (i = qoffset; i < (qoffset + qcount); i++) {
 143                         tx_ring = vsi->tx_rings[i];
 144                         rx_ring = vsi->rx_rings[i];
 145                         tx_ring->dcb_tc = n;
 146                         rx_ring->dcb_tc = n;
 147                 }
 148         }
 149 }
 150
 151 /**
 152  * ice_pf_dcb_cfg - Apply new DCB configuration
 153  * @pf: pointer to the PF struct
 154  * @new_cfg: DCBX config to apply
 155  * @locked: is the RTNL held
 156  */
 157 int ice_pf_dcb_cfg(struct ice_pf *pf, struct ice_dcbx_cfg *new_cfg, bool locked)
 158 {
 159         struct ice_aqc_port_ets_elem buf = { 0 };
 160         struct ice_dcbx_cfg *old_cfg, *curr_cfg;
 161         struct device *dev = ice_pf_to_dev(pf);
 162         int ret = ICE_DCB_NO_HW_CHG;
 163         struct ice_vsi *pf_vsi;
 164
 165         curr_cfg = &pf->hw.port_info->local_dcbx_cfg;
 166
 167         /* FW does not care if change happened */
 168         if (!pf->hw.port_info->is_sw_lldp)
 169                 ret = ICE_DCB_HW_CHG_RST;
 170
 171         /* Enable DCB tagging only when more than one TC */
 172         if (ice_dcb_get_num_tc(new_cfg) > 1) {
 173                 dev_dbg(dev, "DCB tagging enabled (num TC > 1)\n");
 174                 set_bit(ICE_FLAG_DCB_ENA, pf->flags);
 175         } else {
 176                 dev_dbg(dev, "DCB tagging disabled (num TC = 1)\n");
 177                 clear_bit(ICE_FLAG_DCB_ENA, pf->flags);
 178         }
 179
 180         if (!memcmp(new_cfg, curr_cfg, sizeof(*new_cfg))) {
 181                 dev_dbg(dev, "No change in DCB config required\n");
 182                 return ret;
 183         }
 184
 185         /* Store old config in case FW config fails */
 186         old_cfg = kmemdup(curr_cfg, sizeof(*old_cfg), GFP_KERNEL);
 187         if (!old_cfg)
 188                 return -ENOMEM;
 189
 190         dev_info(dev, "Commit DCB Configuration to the hardware\n");
 191         pf_vsi = ice_get_main_vsi(pf);
 192         if (!pf_vsi) {
 193                 dev_dbg(dev, "PF VSI doesn't exist\n");
 194                 ret = -EINVAL;
 195                 goto free_cfg;
 196         }
 197
 198         /* avoid race conditions by holding the lock while disabling and
 199          * re-enabling the VSI
 200          */
 201         if (!locked)
 202                 rtnl_lock();
 203         ice_dis_vsi(pf_vsi, true);
 204
 205         memcpy(curr_cfg, new_cfg, sizeof(*curr_cfg));
 206         memcpy(&curr_cfg->etsrec, &curr_cfg->etscfg, sizeof(curr_cfg->etsrec));
 207         memcpy(&new_cfg->etsrec, &curr_cfg->etscfg, sizeof(curr_cfg->etsrec));
 208
 209         /* Only send new config to HW if we are in SW LLDP mode. Otherwise,
 210          * the new config came from the HW in the first place.
 211          */
 212         if (pf->hw.port_info->is_sw_lldp) {
 213                 ret = ice_set_dcb_cfg(pf->hw.port_info);
 214                 if (ret) {
 215                         dev_err(dev, "Set DCB Config failed\n");
 216                         /* Restore previous settings to local config */
 217                         memcpy(curr_cfg, old_cfg, sizeof(*curr_cfg));
 218                         goto out;
 219                 }
 220         }
 221
 222         ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
 223         if (ret) {
 224                 dev_err(dev, "Query Port ETS failed\n");
 225                 goto out;
 226         }
 227
 228         ice_pf_dcb_recfg(pf);
 229
 230 out:
 231         ice_ena_vsi(pf_vsi, true);
 232         if (!locked)
 233                 rtnl_unlock();
 234 free_cfg:
 235         kfree(old_cfg);
 236         return ret;
 237 }
 238
 239 /**
 240  * ice_cfg_etsrec_defaults - Set default ETS recommended DCB config
 241  * @pi: port information structure
 242  */
 243 static void ice_cfg_etsrec_defaults(struct ice_port_info *pi)
 244 {
 245         struct ice_dcbx_cfg *dcbcfg = &pi->local_dcbx_cfg;
 246         u8 i;
 247
 248         /* Ensure ETS recommended DCB configuration is not already set */
 249         if (dcbcfg->etsrec.maxtcs)
 250                 return;
 251
 252         /* In CEE mode, set the default to 1 TC */
 253         dcbcfg->etsrec.maxtcs = 1;
 254         for (i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) {
 255                 dcbcfg->etsrec.tcbwtable[i] = i ? 0 : 100;
 256                 dcbcfg->etsrec.tsatable[i] = i ? ICE_IEEE_TSA_STRICT :
 257                                                  ICE_IEEE_TSA_ETS;
 258         }
 259 }
 260
 261 /**
 262  * ice_dcb_need_recfg - Check if DCB needs reconfig
 263  * @pf: board private structure
 264  * @old_cfg: current DCB config
 265  * @new_cfg: new DCB config
 266  */
 267 static bool
 268 ice_dcb_need_recfg(struct ice_pf *pf, struct ice_dcbx_cfg *old_cfg,
 269                    struct ice_dcbx_cfg *new_cfg)
 270 {
 271         struct device *dev = ice_pf_to_dev(pf);
 272         bool need_reconfig = false;
 273
 274         /* Check if ETS configuration has changed */
 275         if (memcmp(&new_cfg->etscfg, &old_cfg->etscfg,
 276                    sizeof(new_cfg->etscfg))) {
 277                 /* If Priority Table has changed reconfig is needed */
 278                 if (memcmp(&new_cfg->etscfg.prio_table,
 279                            &old_cfg->etscfg.prio_table,
 280                            sizeof(new_cfg->etscfg.prio_table))) {
 281                         need_reconfig = true;
 282                         dev_dbg(dev, "ETS UP2TC changed.\n");
 283                 }
 284
 285                 if (memcmp(&new_cfg->etscfg.tcbwtable,
 286                            &old_cfg->etscfg.tcbwtable,
 287                            sizeof(new_cfg->etscfg.tcbwtable)))
 288                         dev_dbg(dev, "ETS TC BW Table changed.\n");
 289
 290                 if (memcmp(&new_cfg->etscfg.tsatable,
 291                            &old_cfg->etscfg.tsatable,
 292                            sizeof(new_cfg->etscfg.tsatable)))
 293                         dev_dbg(dev, "ETS TSA Table changed.\n");
 294         }
 295
 296         /* Check if PFC configuration has changed */
 297         if (memcmp(&new_cfg->pfc, &old_cfg->pfc, sizeof(new_cfg->pfc))) {
 298                 need_reconfig = true;
 299                 dev_dbg(dev, "PFC config change detected.\n");
 300         }
 301
 302         /* Check if APP Table has changed */
 303         if (memcmp(&new_cfg->app, &old_cfg->app, sizeof(new_cfg->app))) {
 304                 need_reconfig = true;
 305                 dev_dbg(dev, "APP Table change detected.\n");
 306         }
 307
 308         dev_dbg(dev, "dcb need_reconfig=%d\n", need_reconfig);
 309         return need_reconfig;
 310 }
 311
 312 /**
 313  * ice_dcb_rebuild - rebuild DCB post reset
 314  * @pf: physical function instance
 315  */
 316 void ice_dcb_rebuild(struct ice_pf *pf)
 317 {
 318         struct ice_dcbx_cfg *local_dcbx_cfg, *desired_dcbx_cfg, *prev_cfg;
 319         struct ice_aqc_port_ets_elem buf = { 0 };
 320         struct device *dev = ice_pf_to_dev(pf);
 321         enum ice_status ret;
 322
 323         ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
 324         if (ret) {
 325                 dev_err(dev, "Query Port ETS failed\n");
 326                 goto dcb_error;
 327         }
 328
 329         /* If DCB was not enabled previously, we are done */
 330         if (!test_bit(ICE_FLAG_DCB_ENA, pf->flags))
 331                 return;
 332
 333         local_dcbx_cfg = &pf->hw.port_info->local_dcbx_cfg;
 334         desired_dcbx_cfg = &pf->hw.port_info->desired_dcbx_cfg;
 335
 336         /* Save current willing state and force FW to unwilling */
 337         local_dcbx_cfg->etscfg.willing = 0x0;
 338         local_dcbx_cfg->pfc.willing = 0x0;
 339         local_dcbx_cfg->app_mode = ICE_DCBX_APPS_NON_WILLING;
 340
 341         ice_cfg_etsrec_defaults(pf->hw.port_info);
 342         ret = ice_set_dcb_cfg(pf->hw.port_info);
 343         if (ret) {
 344                 dev_err(dev, "Failed to set DCB to unwilling\n");
 345                 goto dcb_error;
 346         }
 347
 348         /* Retrieve DCB config and ensure same as current in SW */
 349         prev_cfg = kmemdup(local_dcbx_cfg, sizeof(*prev_cfg), GFP_KERNEL);
 350         if (!prev_cfg)
 351                 goto dcb_error;
 352
 353         ice_init_dcb(&pf->hw, true);
 354         if (pf->hw.port_info->dcbx_status == ICE_DCBX_STATUS_DIS)
 355                 pf->hw.port_info->is_sw_lldp = true;
 356         else
 357                 pf->hw.port_info->is_sw_lldp = false;
 358
 359         if (ice_dcb_need_recfg(pf, prev_cfg, local_dcbx_cfg)) {
 360                 /* difference in cfg detected - disable DCB till next MIB */
 361                 dev_err(dev, "Set local MIB not accurate\n");
 362                 kfree(prev_cfg);
 363                 goto dcb_error;
 364         }
 365
 366         /* fetched config congruent to previous configuration */
 367         kfree(prev_cfg);
 368
 369         /* Set the local desired config */
 370         if (local_dcbx_cfg->dcbx_mode == ICE_DCBX_MODE_CEE)
 371                 memcpy(local_dcbx_cfg, desired_dcbx_cfg,
 372                        sizeof(*local_dcbx_cfg));
 373
 374         ice_cfg_etsrec_defaults(pf->hw.port_info);
 375         ret = ice_set_dcb_cfg(pf->hw.port_info);
 376         if (ret) {
 377                 dev_err(dev, "Failed to set desired config\n");
 378                 goto dcb_error;
 379         }
 380         dev_info(dev, "DCB restored after reset\n");
 381         ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
 382         if (ret) {
 383                 dev_err(dev, "Query Port ETS failed\n");
 384                 goto dcb_error;
 385         }
 386
 387         return;
 388
 389 dcb_error:
 390         dev_err(dev, "Disabling DCB until new settings occur\n");
 391         prev_cfg = kzalloc(sizeof(*prev_cfg), GFP_KERNEL);
 392         if (!prev_cfg)
 393                 return;
 394
 395         prev_cfg->etscfg.willing = true;
 396         prev_cfg->etscfg.tcbwtable[0] = ICE_TC_MAX_BW;
 397         prev_cfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS;
 398         memcpy(&prev_cfg->etsrec, &prev_cfg->etscfg, sizeof(prev_cfg->etsrec));
 399         /* Coverity warns the return code of ice_pf_dcb_cfg() is not checked
 400          * here as is done for other calls to that function. That check is
 401          * not necessary since this is in this function's error cleanup path.
 402          * Suppress the Coverity warning with the following comment...
 403          */
 404         /* coverity[check_return] */
 405         ice_pf_dcb_cfg(pf, prev_cfg, false);
 406         kfree(prev_cfg);
 407 }
 408
 409 /**
 410  * ice_dcb_init_cfg - set the initial DCB config in SW
 411  * @pf: PF to apply config to
 412  * @locked: Is the RTNL held
 413  */
 414 static int ice_dcb_init_cfg(struct ice_pf *pf, bool locked)
 415 {
 416         struct ice_dcbx_cfg *newcfg;
 417         struct ice_port_info *pi;
 418         int ret = 0;
 419
 420         pi = pf->hw.port_info;
 421         newcfg = kmemdup(&pi->local_dcbx_cfg, sizeof(*newcfg), GFP_KERNEL);
 422         if (!newcfg)
 423                 return -ENOMEM;
 424
 425         memset(&pi->local_dcbx_cfg, 0, sizeof(*newcfg));
 426
 427         dev_info(ice_pf_to_dev(pf), "Configuring initial DCB values\n");
 428         if (ice_pf_dcb_cfg(pf, newcfg, locked))
 429                 ret = -EINVAL;
 430
 431         kfree(newcfg);
 432
 433         return ret;
 434 }
 435
 436 /**
 437  * ice_dcb_sw_default_config - Apply a default DCB config
 438  * @pf: PF to apply config to
 439  * @ets_willing: configure ets willing
 440  * @locked: was this function called with RTNL held
 441  */
 442 static int ice_dcb_sw_dflt_cfg(struct ice_pf *pf, bool ets_willing, bool locked)
 443 {
 444         struct ice_aqc_port_ets_elem buf = { 0 };
 445         struct ice_dcbx_cfg *dcbcfg;
 446         struct ice_port_info *pi;
 447         struct ice_hw *hw;
 448         int ret;
 449
 450         hw = &pf->hw;
 451         pi = hw->port_info;
 452         dcbcfg = kzalloc(sizeof(*dcbcfg), GFP_KERNEL);
 453         if (!dcbcfg)
 454                 return -ENOMEM;
 455
 456         memset(&pi->local_dcbx_cfg, 0, sizeof(*dcbcfg));
 457
 458         dcbcfg->etscfg.willing = ets_willing ? 1 : 0;
 459         dcbcfg->etscfg.maxtcs = hw->func_caps.common_cap.maxtc;
 460         dcbcfg->etscfg.tcbwtable[0] = 100;
 461         dcbcfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS;
 462
 463         memcpy(&dcbcfg->etsrec, &dcbcfg->etscfg,
 464                sizeof(dcbcfg->etsrec));
 465         dcbcfg->etsrec.willing = 0;
 466
 467         dcbcfg->pfc.willing = 1;
 468         dcbcfg->pfc.pfccap = hw->func_caps.common_cap.maxtc;
 469
 470         dcbcfg->numapps = 1;
 471         dcbcfg->app[0].selector = ICE_APP_SEL_ETHTYPE;
 472         dcbcfg->app[0].priority = 3;
 473         dcbcfg->app[0].prot_id = ICE_APP_PROT_ID_FCOE;
 474
 475         ret = ice_pf_dcb_cfg(pf, dcbcfg, locked);
 476         kfree(dcbcfg);
 477         if (ret)
 478                 return ret;
 479
 480         return ice_query_port_ets(pi, &buf, sizeof(buf), NULL);
 481 }
 482
 483 /**
 484  * ice_dcb_tc_contig - Check that TCs are contiguous
 485  * @prio_table: pointer to priority table
 486  *
 487  * Check if TCs begin with TC0 and are contiguous
 488  */
 489 static bool ice_dcb_tc_contig(u8 *prio_table)
 490 {
 491         u8 max_tc = 0;
 492         int i;
 493
 494         for (i = 0; i < CEE_DCBX_MAX_PRIO; i++) {
 495                 u8 cur_tc = prio_table[i];
 496
 497                 if (cur_tc > max_tc)
 498                         return false;
 499                 else if (cur_tc == max_tc)
 500                         max_tc++;
 501         }
 502
 503         return true;
 504 }
 505
 506 /**
 507  * ice_dcb_noncontig_cfg - Configure DCB for non-contiguous TCs
 508  * @pf: pointer to the PF struct
 509  *
 510  * If non-contiguous TCs, then configure SW DCB with TC0 and ETS non-willing
 511  */
 512 static int ice_dcb_noncontig_cfg(struct ice_pf *pf)
 513 {
 514         struct ice_dcbx_cfg *dcbcfg = &pf->hw.port_info->local_dcbx_cfg;
 515         struct device *dev = ice_pf_to_dev(pf);
 516         int ret;
 517
 518         /* Configure SW DCB default with ETS non-willing */
 519         ret = ice_dcb_sw_dflt_cfg(pf, false, true);
 520         if (ret) {
 521                 dev_err(dev, "Failed to set local DCB config %d\n", ret);
 522                 return ret;
 523         }
 524
 525         /* Reconfigure with ETS willing so that FW will send LLDP MIB event */
 526         dcbcfg->etscfg.willing = 1;
 527         ret = ice_set_dcb_cfg(pf->hw.port_info);
 528         if (ret)
 529                 dev_err(dev, "Failed to set DCB to unwilling\n");
 530
 531         return ret;
 532 }
 533
 534 /**
 535  * ice_pf_dcb_recfg - Reconfigure all VEBs and VSIs
 536  * @pf: pointer to the PF struct
 537  *
 538  * Assumed caller has already disabled all VSIs before
 539  * calling this function. Reconfiguring DCB based on
 540  * local_dcbx_cfg.
 541  */
 542 void ice_pf_dcb_recfg(struct ice_pf *pf)
 543 {
 544         struct ice_dcbx_cfg *dcbcfg = &pf->hw.port_info->local_dcbx_cfg;
 545         u8 tc_map = 0;
 546         int v, ret;
 547
 548         /* Update each VSI */
 549         ice_for_each_vsi(pf, v) {
 550                 struct ice_vsi *vsi = pf->vsi[v];
 551
 552                 if (!vsi)
 553                         continue;
 554
 555                 if (vsi->type == ICE_VSI_PF) {
 556                         tc_map = ice_dcb_get_ena_tc(dcbcfg);
 557
 558                         /* If DCBX request non-contiguous TC, then configure
 559                          * default TC
 560                          */
 561                         if (!ice_dcb_tc_contig(dcbcfg->etscfg.prio_table)) {
 562                                 tc_map = ICE_DFLT_TRAFFIC_CLASS;
 563                                 ice_dcb_noncontig_cfg(pf);
 564                         }
 565                 } else {
 566                         tc_map = ICE_DFLT_TRAFFIC_CLASS;
 567                 }
 568
 569                 ret = ice_vsi_cfg_tc(vsi, tc_map);
 570                 if (ret) {
 571                         dev_err(ice_pf_to_dev(pf), "Failed to config TC for VSI index: %d\n",
 572                                 vsi->idx);
 573                         continue;
 574                 }
 575
 576                 ice_vsi_map_rings_to_vectors(vsi);
 577                 if (vsi->type == ICE_VSI_PF)
 578                         ice_dcbnl_set_all(vsi);
 579         }
 580 }
 581
 582 /**
 583  * ice_init_pf_dcb - initialize DCB for a PF
 584  * @pf: PF to initialize DCB for
 585  * @locked: Was function called with RTNL held
 586  */
 587 int ice_init_pf_dcb(struct ice_pf *pf, bool locked)
 588 {
 589         struct device *dev = ice_pf_to_dev(pf);
 590         struct ice_port_info *port_info;
 591         struct ice_hw *hw = &pf->hw;
 592         int err;
 593
 594         port_info = hw->port_info;
 595
 596         err = ice_init_dcb(hw, false);
 597         if (err && !port_info->is_sw_lldp) {
 598                 dev_err(dev, "Error initializing DCB %d\n", err);
 599                 goto dcb_init_err;
 600         }
 601
 602         dev_info(dev,
 603                  "DCB is enabled in the hardware, max number of TCs supported on this port are %d\n",
 604                  pf->hw.func_caps.common_cap.maxtc);
 605         if (err) {
 606                 struct ice_vsi *pf_vsi;
 607
 608                 /* FW LLDP is disabled, activate SW DCBX/LLDP mode */
 609                 dev_info(dev, "FW LLDP is disabled, DCBx/LLDP in SW mode.\n");
 610                 clear_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags);
 611                 err = ice_dcb_sw_dflt_cfg(pf, true, locked);
 612                 if (err) {
 613                         dev_err(dev,
 614                                 "Failed to set local DCB config %d\n", err);
 615                         err = -EIO;
 616                         goto dcb_init_err;
 617                 }
 618
 619                 /* If the FW DCBX engine is not running then Rx LLDP packets
 620                  * need to be redirected up the stack.
 621                  */
 622                 pf_vsi = ice_get_main_vsi(pf);
 623                 if (!pf_vsi) {
 624                         dev_err(dev, "Failed to set local DCB config\n");
 625                         err = -EIO;
 626                         goto dcb_init_err;
 627                 }
 628
 629                 ice_cfg_sw_lldp(pf_vsi, false, true);
 630
 631                 pf->dcbx_cap = DCB_CAP_DCBX_HOST | DCB_CAP_DCBX_VER_IEEE;
 632                 return 0;
 633         }
 634
 635         set_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags);
 636
 637         /* DCBX in FW and LLDP enabled in FW */
 638         pf->dcbx_cap = DCB_CAP_DCBX_LLD_MANAGED | DCB_CAP_DCBX_VER_IEEE;
 639
 640         err = ice_dcb_init_cfg(pf, locked);
 641         if (err)
 642                 goto dcb_init_err;
 643
 644         return err;
 645
 646 dcb_init_err:
 647         dev_err(dev, "DCB init failed\n");
 648         return err;
 649 }
 650
 651 /**
 652  * ice_update_dcb_stats - Update DCB stats counters
 653  * @pf: PF whose stats needs to be updated
 654  */
 655 void ice_update_dcb_stats(struct ice_pf *pf)
 656 {
 657         struct ice_hw_port_stats *prev_ps, *cur_ps;
 658         struct ice_hw *hw = &pf->hw;
 659         u8 port;
 660         int i;
 661
 662         port = hw->port_info->lport;
 663         prev_ps = &pf->stats_prev;
 664         cur_ps = &pf->stats;
 665
 666         for (i = 0; i < 8; i++) {
 667                 ice_stat_update32(hw, GLPRT_PXOFFRXC(port, i),
 668                                   pf->stat_prev_loaded,
 669                                   &prev_ps->priority_xoff_rx[i],
 670                                   &cur_ps->priority_xoff_rx[i]);
 671                 ice_stat_update32(hw, GLPRT_PXONRXC(port, i),
 672                                   pf->stat_prev_loaded,
 673                                   &prev_ps->priority_xon_rx[i],
 674                                   &cur_ps->priority_xon_rx[i]);
 675                 ice_stat_update32(hw, GLPRT_PXONTXC(port, i),
 676                                   pf->stat_prev_loaded,
 677                                   &prev_ps->priority_xon_tx[i],
 678                                   &cur_ps->priority_xon_tx[i]);
 679                 ice_stat_update32(hw, GLPRT_PXOFFTXC(port, i),
 680                                   pf->stat_prev_loaded,
 681                                   &prev_ps->priority_xoff_tx[i],
 682                                   &cur_ps->priority_xoff_tx[i]);
 683                 ice_stat_update32(hw, GLPRT_RXON2OFFCNT(port, i),
 684                                   pf->stat_prev_loaded,
 685                                   &prev_ps->priority_xon_2_xoff[i],
 686                                   &cur_ps->priority_xon_2_xoff[i]);
 687         }
 688 }
 689
 690 /**
 691  * ice_tx_prepare_vlan_flags_dcb - prepare VLAN tagging for DCB
 692  * @tx_ring: ring to send buffer on
 693  * @first: pointer to struct ice_tx_buf
 694  */
 695 int
 696 ice_tx_prepare_vlan_flags_dcb(struct ice_ring *tx_ring,
 697                               struct ice_tx_buf *first)
 698 {
 699         struct sk_buff *skb = first->skb;
 700
 701         if (!test_bit(ICE_FLAG_DCB_ENA, tx_ring->vsi->back->flags))
 702                 return 0;
 703
 704         /* Insert 802.1p priority into VLAN header */
 705         if ((first->tx_flags & (ICE_TX_FLAGS_HW_VLAN | ICE_TX_FLAGS_SW_VLAN)) ||
 706             skb->priority != TC_PRIO_CONTROL) {
 707                 first->tx_flags &= ~ICE_TX_FLAGS_VLAN_PR_M;
 708                 /* Mask the lower 3 bits to set the 802.1p priority */
 709                 first->tx_flags |= (skb->priority & 0x7) <<
 710                                    ICE_TX_FLAGS_VLAN_PR_S;
 711                 if (first->tx_flags & ICE_TX_FLAGS_SW_VLAN) {
 712                         struct vlan_ethhdr *vhdr;
 713                         int rc;
 714
 715                         rc = skb_cow_head(skb, 0);
 716                         if (rc < 0)
 717                                 return rc;
 718                         vhdr = (struct vlan_ethhdr *)skb->data;
 719                         vhdr->h_vlan_TCI = htons(first->tx_flags >>
 720                                                  ICE_TX_FLAGS_VLAN_S);
 721                 } else {
 722                         first->tx_flags |= ICE_TX_FLAGS_HW_VLAN;
 723                 }
 724         }
 725
 726         return 0;
 727 }
 728
 729 /**
 730  * ice_dcb_process_lldp_set_mib_change - Process MIB change
 731  * @pf: ptr to ice_pf
 732  * @event: pointer to the admin queue receive event
 733  */
 734 void
 735 ice_dcb_process_lldp_set_mib_change(struct ice_pf *pf,
 736                                     struct ice_rq_event_info *event)
 737 {
 738         struct ice_aqc_port_ets_elem buf = { 0 };
 739         struct device *dev = ice_pf_to_dev(pf);
 740         struct ice_aqc_lldp_get_mib *mib;
 741         struct ice_dcbx_cfg tmp_dcbx_cfg;
 742         bool need_reconfig = false;
 743         struct ice_port_info *pi;
 744         struct ice_vsi *pf_vsi;
 745         u8 type;
 746         int ret;
 747
 748         /* Not DCB capable or capability disabled */
 749         if (!(test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags)))
 750                 return;
 751
 752         if (pf->dcbx_cap & DCB_CAP_DCBX_HOST) {
 753                 dev_dbg(dev, "MIB Change Event in HOST mode\n");
 754                 return;
 755         }
 756
 757         pi = pf->hw.port_info;
 758         mib = (struct ice_aqc_lldp_get_mib *)&event->desc.params.raw;
 759         /* Ignore if event is not for Nearest Bridge */
 760         type = ((mib->type >> ICE_AQ_LLDP_BRID_TYPE_S) &
 761                 ICE_AQ_LLDP_BRID_TYPE_M);
 762         dev_dbg(dev, "LLDP event MIB bridge type 0x%x\n", type);
 763         if (type != ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID)
 764                 return;
 765
 766         /* Check MIB Type and return if event for Remote MIB update */
 767         type = mib->type & ICE_AQ_LLDP_MIB_TYPE_M;
 768         dev_dbg(dev, "LLDP event mib type %s\n", type ? "remote" : "local");
 769         if (type == ICE_AQ_LLDP_MIB_REMOTE) {
 770                 /* Update the remote cached instance and return */
 771                 ret = ice_aq_get_dcb_cfg(pi->hw, ICE_AQ_LLDP_MIB_REMOTE,
 772                                          ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID,
 773                                          &pi->remote_dcbx_cfg);
 774                 if (ret) {
 775                         dev_err(dev, "Failed to get remote DCB config\n");
 776                         return;
 777                 }
 778         }
 779
 780         /* store the old configuration */
 781         tmp_dcbx_cfg = pf->hw.port_info->local_dcbx_cfg;
 782
 783         /* Reset the old DCBX configuration data */
 784         memset(&pi->local_dcbx_cfg, 0, sizeof(pi->local_dcbx_cfg));
 785
 786         /* Get updated DCBX data from firmware */
 787         ret = ice_get_dcb_cfg(pf->hw.port_info);
 788         if (ret) {
 789                 dev_err(dev, "Failed to get DCB config\n");
 790                 return;
 791         }
 792
 793         /* No change detected in DCBX configs */
 794         if (!memcmp(&tmp_dcbx_cfg, &pi->local_dcbx_cfg, sizeof(tmp_dcbx_cfg))) {
 795                 dev_dbg(dev, "No change detected in DCBX configuration.\n");
 796                 return;
 797         }
 798
 799         need_reconfig = ice_dcb_need_recfg(pf, &tmp_dcbx_cfg,
 800                                            &pi->local_dcbx_cfg);
 801         ice_dcbnl_flush_apps(pf, &tmp_dcbx_cfg, &pi->local_dcbx_cfg);
 802         if (!need_reconfig)
 803                 return;
 804
 805         /* Enable DCB tagging only when more than one TC */
 806         if (ice_dcb_get_num_tc(&pi->local_dcbx_cfg) > 1) {
 807                 dev_dbg(dev, "DCB tagging enabled (num TC > 1)\n");
 808                 set_bit(ICE_FLAG_DCB_ENA, pf->flags);
 809         } else {
 810                 dev_dbg(dev, "DCB tagging disabled (num TC = 1)\n");
 811                 clear_bit(ICE_FLAG_DCB_ENA, pf->flags);
 812         }
 813
 814         pf_vsi = ice_get_main_vsi(pf);
 815         if (!pf_vsi) {
 816                 dev_dbg(dev, "PF VSI doesn't exist\n");
 817                 return;
 818         }
 819
 820         rtnl_lock();
 821         ice_dis_vsi(pf_vsi, true);
 822
 823         ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
 824         if (ret) {
 825                 dev_err(dev, "Query Port ETS failed\n");
 826                 rtnl_unlock();
 827                 return;
 828         }
 829
 830         /* changes in configuration update VSI */
 831         ice_pf_dcb_recfg(pf);
 832
 833         ice_ena_vsi(pf_vsi, true);
 834         rtnl_unlock();
 835 }