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->qos_cfg.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_is_pfc_causing_hung_q
  67  * @pf: pointer to PF structure
  68  * @txqueue: Tx queue which is supposedly hung queue
  69  *
  70  * find if PFC is causing the hung queue, if yes return true else false
  71  */
  72 bool ice_is_pfc_causing_hung_q(struct ice_pf *pf, unsigned int txqueue)
  73 {
  74         u8 num_tcs = 0, i, tc, up_mapped_tc, up_in_tc = 0;
  75         u64 ref_prio_xoff[ICE_MAX_UP];
  76         struct ice_vsi *vsi;
  77         u32 up2tc;
  78
  79         vsi = ice_get_main_vsi(pf);
  80         if (!vsi)
  81                 return false;
  82
  83         ice_for_each_traffic_class(i)
  84                 if (vsi->tc_cfg.ena_tc & BIT(i))
  85                         num_tcs++;
  86
  87         /* first find out the TC to which the hung queue belongs to */
  88         for (tc = 0; tc < num_tcs - 1; tc++)
  89                 if (ice_find_q_in_range(vsi->tc_cfg.tc_info[tc].qoffset,
  90                                         vsi->tc_cfg.tc_info[tc + 1].qoffset,
  91                                         txqueue))
  92                         break;
  93
  94         /* Build a bit map of all UPs associated to the suspect hung queue TC,
  95          * so that we check for its counter increment.
  96          */
  97         up2tc = rd32(&pf->hw, PRTDCB_TUP2TC);
  98         for (i = 0; i < ICE_MAX_UP; i++) {
  99                 up_mapped_tc = (up2tc >> (i * 3)) & 0x7;
 100                 if (up_mapped_tc == tc)
 101                         up_in_tc |= BIT(i);
 102         }
 103
 104         /* Now that we figured out that hung queue is PFC enabled, still the
 105          * Tx timeout can be legitimate. So to make sure Tx timeout is
 106          * absolutely caused by PFC storm, check if the counters are
 107          * incrementing.
 108          */
 109         for (i = 0; i < ICE_MAX_UP; i++)
 110                 if (up_in_tc & BIT(i))
 111                         ref_prio_xoff[i] = pf->stats.priority_xoff_rx[i];
 112
 113         ice_update_dcb_stats(pf);
 114
 115         for (i = 0; i < ICE_MAX_UP; i++)
 116                 if (up_in_tc & BIT(i))
 117                         if (pf->stats.priority_xoff_rx[i] > ref_prio_xoff[i])
 118                                 return true;
 119
 120         return false;
 121 }
 122
 123 /**
 124  * ice_dcb_get_mode - gets the DCB mode
 125  * @port_info: pointer to port info structure
 126  * @host: if set it's HOST if not it's MANAGED
 127  */
 128 static u8 ice_dcb_get_mode(struct ice_port_info *port_info, bool host)
 129 {
 130         u8 mode;
 131
 132         if (host)
 133                 mode = DCB_CAP_DCBX_HOST;
 134         else
 135                 mode = DCB_CAP_DCBX_LLD_MANAGED;
 136
 137         if (port_info->qos_cfg.local_dcbx_cfg.dcbx_mode & ICE_DCBX_MODE_CEE)
 138                 return mode | DCB_CAP_DCBX_VER_CEE;
 139         else
 140                 return mode | DCB_CAP_DCBX_VER_IEEE;
 141 }
 142
 143 /**
 144  * ice_dcb_get_num_tc - Get the number of TCs from DCBX config
 145  * @dcbcfg: config to retrieve number of TCs from
 146  */
 147 u8 ice_dcb_get_num_tc(struct ice_dcbx_cfg *dcbcfg)
 148 {
 149         bool tc_unused = false;
 150         u8 num_tc = 0;
 151         u8 ret = 0;
 152         int i;
 153
 154         /* Scan the ETS Config Priority Table to find traffic classes
 155          * enabled and create a bitmask of enabled TCs
 156          */
 157         for (i = 0; i < CEE_DCBX_MAX_PRIO; i++)
 158                 num_tc |= BIT(dcbcfg->etscfg.prio_table[i]);
 159
 160         /* Scan bitmask for contiguous TCs starting with TC0 */
 161         for (i = 0; i < IEEE_8021QAZ_MAX_TCS; i++) {
 162                 if (num_tc & BIT(i)) {
 163                         if (!tc_unused) {
 164                                 ret++;
 165                         } else {
 166                                 pr_err("Non-contiguous TCs - Disabling DCB\n");
 167                                 return 1;
 168                         }
 169                 } else {
 170                         tc_unused = true;
 171                 }
 172         }
 173
 174         /* There is always at least 1 TC */
 175         if (!ret)
 176                 ret = 1;
 177
 178         return ret;
 179 }
 180
 181 /**
 182  * ice_dcb_get_tc - Get the TC associated with the queue
 183  * @vsi: ptr to the VSI
 184  * @queue_index: queue number associated with VSI
 185  */
 186 u8 ice_dcb_get_tc(struct ice_vsi *vsi, int queue_index)
 187 {
 188         return vsi->tx_rings[queue_index]->dcb_tc;
 189 }
 190
 191 /**
 192  * ice_vsi_cfg_dcb_rings - Update rings to reflect DCB TC
 193  * @vsi: VSI owner of rings being updated
 194  */
 195 void ice_vsi_cfg_dcb_rings(struct ice_vsi *vsi)
 196 {
 197         struct ice_ring *tx_ring, *rx_ring;
 198         u16 qoffset, qcount;
 199         int i, n;
 200
 201         if (!test_bit(ICE_FLAG_DCB_ENA, vsi->back->flags)) {
 202                 /* Reset the TC information */
 203                 for (i = 0; i < vsi->num_txq; i++) {
 204                         tx_ring = vsi->tx_rings[i];
 205                         tx_ring->dcb_tc = 0;
 206                 }
 207                 for (i = 0; i < vsi->num_rxq; i++) {
 208                         rx_ring = vsi->rx_rings[i];
 209                         rx_ring->dcb_tc = 0;
 210                 }
 211                 return;
 212         }
 213
 214         ice_for_each_traffic_class(n) {
 215                 if (!(vsi->tc_cfg.ena_tc & BIT(n)))
 216                         break;
 217
 218                 qoffset = vsi->tc_cfg.tc_info[n].qoffset;
 219                 qcount = vsi->tc_cfg.tc_info[n].qcount_tx;
 220                 for (i = qoffset; i < (qoffset + qcount); i++) {
 221                         tx_ring = vsi->tx_rings[i];
 222                         rx_ring = vsi->rx_rings[i];
 223                         tx_ring->dcb_tc = n;
 224                         rx_ring->dcb_tc = n;
 225                 }
 226         }
 227 }
 228
 229 /**
 230  * ice_dcb_bwchk - check if ETS bandwidth input parameters are correct
 231  * @pf: pointer to the PF struct
 232  * @dcbcfg: pointer to DCB config structure
 233  */
 234 int ice_dcb_bwchk(struct ice_pf *pf, struct ice_dcbx_cfg *dcbcfg)
 235 {
 236         struct ice_dcb_ets_cfg *etscfg = &dcbcfg->etscfg;
 237         u8 num_tc, total_bw = 0;
 238         int i;
 239
 240         /* returns number of contigous TCs and 1 TC for non-contigous TCs,
 241          * since at least 1 TC has to be configured
 242          */
 243         num_tc = ice_dcb_get_num_tc(dcbcfg);
 244
 245         /* no bandwidth checks required if there's only one TC, so assign
 246          * all bandwidth to TC0 and return
 247          */
 248         if (num_tc == 1) {
 249                 etscfg->tcbwtable[0] = ICE_TC_MAX_BW;
 250                 return 0;
 251         }
 252
 253         for (i = 0; i < num_tc; i++)
 254                 total_bw += etscfg->tcbwtable[i];
 255
 256         if (!total_bw) {
 257                 etscfg->tcbwtable[0] = ICE_TC_MAX_BW;
 258         } else if (total_bw != ICE_TC_MAX_BW) {
 259                 dev_err(ice_pf_to_dev(pf), "Invalid config, total bandwidth must equal 100\n");
 260                 return -EINVAL;
 261         }
 262
 263         return 0;
 264 }
 265
 266 /**
 267  * ice_pf_dcb_cfg - Apply new DCB configuration
 268  * @pf: pointer to the PF struct
 269  * @new_cfg: DCBX config to apply
 270  * @locked: is the RTNL held
 271  */
 272 int ice_pf_dcb_cfg(struct ice_pf *pf, struct ice_dcbx_cfg *new_cfg, bool locked)
 273 {
 274         struct ice_aqc_port_ets_elem buf = { 0 };
 275         struct ice_dcbx_cfg *old_cfg, *curr_cfg;
 276         struct device *dev = ice_pf_to_dev(pf);
 277         int ret = ICE_DCB_NO_HW_CHG;
 278         struct iidc_event *event;
 279         struct ice_vsi *pf_vsi;
 280
 281         curr_cfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
 282
 283         /* FW does not care if change happened */
 284         if (!pf->hw.port_info->qos_cfg.is_sw_lldp)
 285                 ret = ICE_DCB_HW_CHG_RST;
 286
 287         /* Enable DCB tagging only when more than one TC */
 288         if (ice_dcb_get_num_tc(new_cfg) > 1) {
 289                 dev_dbg(dev, "DCB tagging enabled (num TC > 1)\n");
 290                 set_bit(ICE_FLAG_DCB_ENA, pf->flags);
 291         } else {
 292                 dev_dbg(dev, "DCB tagging disabled (num TC = 1)\n");
 293                 clear_bit(ICE_FLAG_DCB_ENA, pf->flags);
 294         }
 295
 296         if (!memcmp(new_cfg, curr_cfg, sizeof(*new_cfg))) {
 297                 dev_dbg(dev, "No change in DCB config required\n");
 298                 return ret;
 299         }
 300
 301         if (ice_dcb_bwchk(pf, new_cfg))
 302                 return -EINVAL;
 303
 304         /* Store old config in case FW config fails */
 305         old_cfg = kmemdup(curr_cfg, sizeof(*old_cfg), GFP_KERNEL);
 306         if (!old_cfg)
 307                 return -ENOMEM;
 308
 309         dev_info(dev, "Commit DCB Configuration to the hardware\n");
 310         pf_vsi = ice_get_main_vsi(pf);
 311         if (!pf_vsi) {
 312                 dev_dbg(dev, "PF VSI doesn't exist\n");
 313                 ret = -EINVAL;
 314                 goto free_cfg;
 315         }
 316
 317         /* Notify AUX drivers about impending change to TCs */
 318         event = kzalloc(sizeof(*event), GFP_KERNEL);
 319         if (!event) {
 320                 ret = -ENOMEM;
 321                 goto free_cfg;
 322         }
 323
 324         set_bit(IIDC_EVENT_BEFORE_TC_CHANGE, event->type);
 325         ice_send_event_to_aux(pf, event);
 326         kfree(event);
 327
 328         /* avoid race conditions by holding the lock while disabling and
 329          * re-enabling the VSI
 330          */
 331         if (!locked)
 332                 rtnl_lock();
 333         ice_dis_vsi(pf_vsi, true);
 334
 335         memcpy(curr_cfg, new_cfg, sizeof(*curr_cfg));
 336         memcpy(&curr_cfg->etsrec, &curr_cfg->etscfg, sizeof(curr_cfg->etsrec));
 337         memcpy(&new_cfg->etsrec, &curr_cfg->etscfg, sizeof(curr_cfg->etsrec));
 338
 339         /* Only send new config to HW if we are in SW LLDP mode. Otherwise,
 340          * the new config came from the HW in the first place.
 341          */
 342         if (pf->hw.port_info->qos_cfg.is_sw_lldp) {
 343                 ret = ice_set_dcb_cfg(pf->hw.port_info);
 344                 if (ret) {
 345                         dev_err(dev, "Set DCB Config failed\n");
 346                         /* Restore previous settings to local config */
 347                         memcpy(curr_cfg, old_cfg, sizeof(*curr_cfg));
 348                         goto out;
 349                 }
 350         }
 351
 352         ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
 353         if (ret) {
 354                 dev_err(dev, "Query Port ETS failed\n");
 355                 goto out;
 356         }
 357
 358         ice_pf_dcb_recfg(pf);
 359
 360 out:
 361         ice_ena_vsi(pf_vsi, true);
 362         if (!locked)
 363                 rtnl_unlock();
 364 free_cfg:
 365         kfree(old_cfg);
 366         return ret;
 367 }
 368
 369 /**
 370  * ice_cfg_etsrec_defaults - Set default ETS recommended DCB config
 371  * @pi: port information structure
 372  */
 373 static void ice_cfg_etsrec_defaults(struct ice_port_info *pi)
 374 {
 375         struct ice_dcbx_cfg *dcbcfg = &pi->qos_cfg.local_dcbx_cfg;
 376         u8 i;
 377
 378         /* Ensure ETS recommended DCB configuration is not already set */
 379         if (dcbcfg->etsrec.maxtcs)
 380                 return;
 381
 382         /* In CEE mode, set the default to 1 TC */
 383         dcbcfg->etsrec.maxtcs = 1;
 384         for (i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) {
 385                 dcbcfg->etsrec.tcbwtable[i] = i ? 0 : 100;
 386                 dcbcfg->etsrec.tsatable[i] = i ? ICE_IEEE_TSA_STRICT :
 387                                                  ICE_IEEE_TSA_ETS;
 388         }
 389 }
 390
 391 /**
 392  * ice_dcb_need_recfg - Check if DCB needs reconfig
 393  * @pf: board private structure
 394  * @old_cfg: current DCB config
 395  * @new_cfg: new DCB config
 396  */
 397 static bool
 398 ice_dcb_need_recfg(struct ice_pf *pf, struct ice_dcbx_cfg *old_cfg,
 399                    struct ice_dcbx_cfg *new_cfg)
 400 {
 401         struct device *dev = ice_pf_to_dev(pf);
 402         bool need_reconfig = false;
 403
 404         /* Check if ETS configuration has changed */
 405         if (memcmp(&new_cfg->etscfg, &old_cfg->etscfg,
 406                    sizeof(new_cfg->etscfg))) {
 407                 /* If Priority Table has changed reconfig is needed */
 408                 if (memcmp(&new_cfg->etscfg.prio_table,
 409                            &old_cfg->etscfg.prio_table,
 410                            sizeof(new_cfg->etscfg.prio_table))) {
 411                         need_reconfig = true;
 412                         dev_dbg(dev, "ETS UP2TC changed.\n");
 413                 }
 414
 415                 if (memcmp(&new_cfg->etscfg.tcbwtable,
 416                            &old_cfg->etscfg.tcbwtable,
 417                            sizeof(new_cfg->etscfg.tcbwtable)))
 418                         dev_dbg(dev, "ETS TC BW Table changed.\n");
 419
 420                 if (memcmp(&new_cfg->etscfg.tsatable,
 421                            &old_cfg->etscfg.tsatable,
 422                            sizeof(new_cfg->etscfg.tsatable)))
 423                         dev_dbg(dev, "ETS TSA Table changed.\n");
 424         }
 425
 426         /* Check if PFC configuration has changed */
 427         if (memcmp(&new_cfg->pfc, &old_cfg->pfc, sizeof(new_cfg->pfc))) {
 428                 need_reconfig = true;
 429                 dev_dbg(dev, "PFC config change detected.\n");
 430         }
 431
 432         /* Check if APP Table has changed */
 433         if (memcmp(&new_cfg->app, &old_cfg->app, sizeof(new_cfg->app))) {
 434                 need_reconfig = true;
 435                 dev_dbg(dev, "APP Table change detected.\n");
 436         }
 437
 438         dev_dbg(dev, "dcb need_reconfig=%d\n", need_reconfig);
 439         return need_reconfig;
 440 }
 441
 442 /**
 443  * ice_dcb_rebuild - rebuild DCB post reset
 444  * @pf: physical function instance
 445  */
 446 void ice_dcb_rebuild(struct ice_pf *pf)
 447 {
 448         struct ice_aqc_port_ets_elem buf = { 0 };
 449         struct device *dev = ice_pf_to_dev(pf);
 450         struct ice_dcbx_cfg *err_cfg;
 451         enum ice_status ret;
 452
 453         ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
 454         if (ret) {
 455                 dev_err(dev, "Query Port ETS failed\n");
 456                 goto dcb_error;
 457         }
 458
 459         mutex_lock(&pf->tc_mutex);
 460
 461         if (!pf->hw.port_info->qos_cfg.is_sw_lldp)
 462                 ice_cfg_etsrec_defaults(pf->hw.port_info);
 463
 464         ret = ice_set_dcb_cfg(pf->hw.port_info);
 465         if (ret) {
 466                 dev_err(dev, "Failed to set DCB config in rebuild\n");
 467                 goto dcb_error;
 468         }
 469
 470         if (!pf->hw.port_info->qos_cfg.is_sw_lldp) {
 471                 ret = ice_cfg_lldp_mib_change(&pf->hw, true);
 472                 if (ret && !pf->hw.port_info->qos_cfg.is_sw_lldp) {
 473                         dev_err(dev, "Failed to register for MIB changes\n");
 474                         goto dcb_error;
 475                 }
 476         }
 477
 478         dev_info(dev, "DCB info restored\n");
 479         ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
 480         if (ret) {
 481                 dev_err(dev, "Query Port ETS failed\n");
 482                 goto dcb_error;
 483         }
 484
 485         mutex_unlock(&pf->tc_mutex);
 486
 487         return;
 488
 489 dcb_error:
 490         dev_err(dev, "Disabling DCB until new settings occur\n");
 491         err_cfg = kzalloc(sizeof(*err_cfg), GFP_KERNEL);
 492         if (!err_cfg) {
 493                 mutex_unlock(&pf->tc_mutex);
 494                 return;
 495         }
 496
 497         err_cfg->etscfg.willing = true;
 498         err_cfg->etscfg.tcbwtable[0] = ICE_TC_MAX_BW;
 499         err_cfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS;
 500         memcpy(&err_cfg->etsrec, &err_cfg->etscfg, sizeof(err_cfg->etsrec));
 501         /* Coverity warns the return code of ice_pf_dcb_cfg() is not checked
 502          * here as is done for other calls to that function. That check is
 503          * not necessary since this is in this function's error cleanup path.
 504          * Suppress the Coverity warning with the following comment...
 505          */
 506         /* coverity[check_return] */
 507         ice_pf_dcb_cfg(pf, err_cfg, false);
 508         kfree(err_cfg);
 509
 510         mutex_unlock(&pf->tc_mutex);
 511 }
 512
 513 /**
 514  * ice_dcb_init_cfg - set the initial DCB config in SW
 515  * @pf: PF to apply config to
 516  * @locked: Is the RTNL held
 517  */
 518 static int ice_dcb_init_cfg(struct ice_pf *pf, bool locked)
 519 {
 520         struct ice_dcbx_cfg *newcfg;
 521         struct ice_port_info *pi;
 522         int ret = 0;
 523
 524         pi = pf->hw.port_info;
 525         newcfg = kmemdup(&pi->qos_cfg.local_dcbx_cfg, sizeof(*newcfg),
 526                          GFP_KERNEL);
 527         if (!newcfg)
 528                 return -ENOMEM;
 529
 530         memset(&pi->qos_cfg.local_dcbx_cfg, 0, sizeof(*newcfg));
 531
 532         dev_info(ice_pf_to_dev(pf), "Configuring initial DCB values\n");
 533         if (ice_pf_dcb_cfg(pf, newcfg, locked))
 534                 ret = -EINVAL;
 535
 536         kfree(newcfg);
 537
 538         return ret;
 539 }
 540
 541 /**
 542  * ice_dcb_sw_dflt_cfg - Apply a default DCB config
 543  * @pf: PF to apply config to
 544  * @ets_willing: configure ETS willing
 545  * @locked: was this function called with RTNL held
 546  */
 547 static int ice_dcb_sw_dflt_cfg(struct ice_pf *pf, bool ets_willing, bool locked)
 548 {
 549         struct ice_aqc_port_ets_elem buf = { 0 };
 550         struct ice_dcbx_cfg *dcbcfg;
 551         struct ice_port_info *pi;
 552         struct ice_hw *hw;
 553         int ret;
 554
 555         hw = &pf->hw;
 556         pi = hw->port_info;
 557         dcbcfg = kzalloc(sizeof(*dcbcfg), GFP_KERNEL);
 558         if (!dcbcfg)
 559                 return -ENOMEM;
 560
 561         memset(&pi->qos_cfg.local_dcbx_cfg, 0, sizeof(*dcbcfg));
 562
 563         dcbcfg->etscfg.willing = ets_willing ? 1 : 0;
 564         dcbcfg->etscfg.maxtcs = hw->func_caps.common_cap.maxtc;
 565         dcbcfg->etscfg.tcbwtable[0] = 100;
 566         dcbcfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS;
 567
 568         memcpy(&dcbcfg->etsrec, &dcbcfg->etscfg,
 569                sizeof(dcbcfg->etsrec));
 570         dcbcfg->etsrec.willing = 0;
 571
 572         dcbcfg->pfc.willing = 1;
 573         dcbcfg->pfc.pfccap = hw->func_caps.common_cap.maxtc;
 574
 575         dcbcfg->numapps = 1;
 576         dcbcfg->app[0].selector = ICE_APP_SEL_ETHTYPE;
 577         dcbcfg->app[0].priority = 3;
 578         dcbcfg->app[0].prot_id = ETH_P_FCOE;
 579
 580         ret = ice_pf_dcb_cfg(pf, dcbcfg, locked);
 581         kfree(dcbcfg);
 582         if (ret)
 583                 return ret;
 584
 585         return ice_query_port_ets(pi, &buf, sizeof(buf), NULL);
 586 }
 587
 588 /**
 589  * ice_dcb_tc_contig - Check that TCs are contiguous
 590  * @prio_table: pointer to priority table
 591  *
 592  * Check if TCs begin with TC0 and are contiguous
 593  */
 594 static bool ice_dcb_tc_contig(u8 *prio_table)
 595 {
 596         bool found_empty = false;
 597         u8 used_tc = 0;
 598         int i;
 599
 600         /* Create a bitmap of used TCs */
 601         for (i = 0; i < CEE_DCBX_MAX_PRIO; i++)
 602                 used_tc |= BIT(prio_table[i]);
 603
 604         for (i = 0; i < CEE_DCBX_MAX_PRIO; i++) {
 605                 if (used_tc & BIT(i)) {
 606                         if (found_empty)
 607                                 return false;
 608                 } else {
 609                         found_empty = true;
 610                 }
 611         }
 612
 613         return true;
 614 }
 615
 616 /**
 617  * ice_dcb_noncontig_cfg - Configure DCB for non-contiguous TCs
 618  * @pf: pointer to the PF struct
 619  *
 620  * If non-contiguous TCs, then configure SW DCB with TC0 and ETS non-willing
 621  */
 622 static int ice_dcb_noncontig_cfg(struct ice_pf *pf)
 623 {
 624         struct ice_dcbx_cfg *dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
 625         struct device *dev = ice_pf_to_dev(pf);
 626         int ret;
 627
 628         /* Configure SW DCB default with ETS non-willing */
 629         ret = ice_dcb_sw_dflt_cfg(pf, false, true);
 630         if (ret) {
 631                 dev_err(dev, "Failed to set local DCB config %d\n", ret);
 632                 return ret;
 633         }
 634
 635         /* Reconfigure with ETS willing so that FW will send LLDP MIB event */
 636         dcbcfg->etscfg.willing = 1;
 637         ret = ice_set_dcb_cfg(pf->hw.port_info);
 638         if (ret)
 639                 dev_err(dev, "Failed to set DCB to unwilling\n");
 640
 641         return ret;
 642 }
 643
 644 /**
 645  * ice_pf_dcb_recfg - Reconfigure all VEBs and VSIs
 646  * @pf: pointer to the PF struct
 647  *
 648  * Assumed caller has already disabled all VSIs before
 649  * calling this function. Reconfiguring DCB based on
 650  * local_dcbx_cfg.
 651  */
 652 void ice_pf_dcb_recfg(struct ice_pf *pf)
 653 {
 654         struct ice_dcbx_cfg *dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
 655         struct iidc_event *event;
 656         u8 tc_map = 0;
 657         int v, ret;
 658
 659         /* Update each VSI */
 660         ice_for_each_vsi(pf, v) {
 661                 struct ice_vsi *vsi = pf->vsi[v];
 662
 663                 if (!vsi)
 664                         continue;
 665
 666                 if (vsi->type == ICE_VSI_PF) {
 667                         tc_map = ice_dcb_get_ena_tc(dcbcfg);
 668
 669                         /* If DCBX request non-contiguous TC, then configure
 670                          * default TC
 671                          */
 672                         if (!ice_dcb_tc_contig(dcbcfg->etscfg.prio_table)) {
 673                                 tc_map = ICE_DFLT_TRAFFIC_CLASS;
 674                                 ice_dcb_noncontig_cfg(pf);
 675                         }
 676                 } else {
 677                         tc_map = ICE_DFLT_TRAFFIC_CLASS;
 678                 }
 679
 680                 ret = ice_vsi_cfg_tc(vsi, tc_map);
 681                 if (ret) {
 682                         dev_err(ice_pf_to_dev(pf), "Failed to config TC for VSI index: %d\n",
 683                                 vsi->idx);
 684                         continue;
 685                 }
 686
 687                 ice_vsi_map_rings_to_vectors(vsi);
 688                 if (vsi->type == ICE_VSI_PF)
 689                         ice_dcbnl_set_all(vsi);
 690         }
 691         /* Notify the AUX drivers that TC change is finished */
 692         event = kzalloc(sizeof(*event), GFP_KERNEL);
 693         if (!event)
 694                 return;
 695
 696         set_bit(IIDC_EVENT_AFTER_TC_CHANGE, event->type);
 697         ice_send_event_to_aux(pf, event);
 698         kfree(event);
 699 }
 700
 701 /**
 702  * ice_init_pf_dcb - initialize DCB for a PF
 703  * @pf: PF to initialize DCB for
 704  * @locked: Was function called with RTNL held
 705  */
 706 int ice_init_pf_dcb(struct ice_pf *pf, bool locked)
 707 {
 708         struct device *dev = ice_pf_to_dev(pf);
 709         struct ice_port_info *port_info;
 710         struct ice_hw *hw = &pf->hw;
 711         int err;
 712
 713         port_info = hw->port_info;
 714
 715         err = ice_init_dcb(hw, false);
 716         if (err && !port_info->qos_cfg.is_sw_lldp) {
 717                 dev_err(dev, "Error initializing DCB %d\n", err);
 718                 goto dcb_init_err;
 719         }
 720
 721         dev_info(dev, "DCB is enabled in the hardware, max number of TCs supported on this port are %d\n",
 722                  pf->hw.func_caps.common_cap.maxtc);
 723         if (err) {
 724                 struct ice_vsi *pf_vsi;
 725
 726                 /* FW LLDP is disabled, activate SW DCBX/LLDP mode */
 727                 dev_info(dev, "FW LLDP is disabled, DCBx/LLDP in SW mode.\n");
 728                 clear_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags);
 729                 err = ice_dcb_sw_dflt_cfg(pf, true, locked);
 730                 if (err) {
 731                         dev_err(dev, "Failed to set local DCB config %d\n",
 732                                 err);
 733                         err = -EIO;
 734                         goto dcb_init_err;
 735                 }
 736
 737                 /* If the FW DCBX engine is not running then Rx LLDP packets
 738                  * need to be redirected up the stack.
 739                  */
 740                 pf_vsi = ice_get_main_vsi(pf);
 741                 if (!pf_vsi) {
 742                         dev_err(dev, "Failed to set local DCB config\n");
 743                         err = -EIO;
 744                         goto dcb_init_err;
 745                 }
 746
 747                 ice_cfg_sw_lldp(pf_vsi, false, true);
 748
 749                 pf->dcbx_cap = ice_dcb_get_mode(port_info, true);
 750                 return 0;
 751         }
 752
 753         set_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags);
 754
 755         /* DCBX/LLDP enabled in FW, set DCBNL mode advertisement */
 756         pf->dcbx_cap = ice_dcb_get_mode(port_info, false);
 757
 758         err = ice_dcb_init_cfg(pf, locked);
 759         if (err)
 760                 goto dcb_init_err;
 761
 762         return err;
 763
 764 dcb_init_err:
 765         dev_err(dev, "DCB init failed\n");
 766         return err;
 767 }
 768
 769 /**
 770  * ice_update_dcb_stats - Update DCB stats counters
 771  * @pf: PF whose stats needs to be updated
 772  */
 773 void ice_update_dcb_stats(struct ice_pf *pf)
 774 {
 775         struct ice_hw_port_stats *prev_ps, *cur_ps;
 776         struct ice_hw *hw = &pf->hw;
 777         u8 port;
 778         int i;
 779
 780         port = hw->port_info->lport;
 781         prev_ps = &pf->stats_prev;
 782         cur_ps = &pf->stats;
 783
 784         for (i = 0; i < 8; i++) {
 785                 ice_stat_update32(hw, GLPRT_PXOFFRXC(port, i),
 786                                   pf->stat_prev_loaded,
 787                                   &prev_ps->priority_xoff_rx[i],
 788                                   &cur_ps->priority_xoff_rx[i]);
 789                 ice_stat_update32(hw, GLPRT_PXONRXC(port, i),
 790                                   pf->stat_prev_loaded,
 791                                   &prev_ps->priority_xon_rx[i],
 792                                   &cur_ps->priority_xon_rx[i]);
 793                 ice_stat_update32(hw, GLPRT_PXONTXC(port, i),
 794                                   pf->stat_prev_loaded,
 795                                   &prev_ps->priority_xon_tx[i],
 796                                   &cur_ps->priority_xon_tx[i]);
 797                 ice_stat_update32(hw, GLPRT_PXOFFTXC(port, i),
 798                                   pf->stat_prev_loaded,
 799                                   &prev_ps->priority_xoff_tx[i],
 800                                   &cur_ps->priority_xoff_tx[i]);
 801                 ice_stat_update32(hw, GLPRT_RXON2OFFCNT(port, i),
 802                                   pf->stat_prev_loaded,
 803                                   &prev_ps->priority_xon_2_xoff[i],
 804                                   &cur_ps->priority_xon_2_xoff[i]);
 805         }
 806 }
 807
 808 /**
 809  * ice_tx_prepare_vlan_flags_dcb - prepare VLAN tagging for DCB
 810  * @tx_ring: ring to send buffer on
 811  * @first: pointer to struct ice_tx_buf
 812  *
 813  * This should not be called if the outer VLAN is software offloaded as the VLAN
 814  * tag will already be configured with the correct ID and priority bits
 815  */
 816 void
 817 ice_tx_prepare_vlan_flags_dcb(struct ice_ring *tx_ring,
 818                               struct ice_tx_buf *first)
 819 {
 820         struct sk_buff *skb = first->skb;
 821
 822         if (!test_bit(ICE_FLAG_DCB_ENA, tx_ring->vsi->back->flags))
 823                 return;
 824
 825         /* Insert 802.1p priority into VLAN header */
 826         if ((first->tx_flags & ICE_TX_FLAGS_HW_VLAN) ||
 827             skb->priority != TC_PRIO_CONTROL) {
 828                 first->tx_flags &= ~ICE_TX_FLAGS_VLAN_PR_M;
 829                 /* Mask the lower 3 bits to set the 802.1p priority */
 830                 first->tx_flags |= (skb->priority & 0x7) <<
 831                                    ICE_TX_FLAGS_VLAN_PR_S;
 832                 /* if this is not already set it means a VLAN 0 + priority needs
 833                  * to be offloaded
 834                  */
 835                 first->tx_flags |= ICE_TX_FLAGS_HW_VLAN;
 836         }
 837 }
 838
 839 /**
 840  * ice_dcb_process_lldp_set_mib_change - Process MIB change
 841  * @pf: ptr to ice_pf
 842  * @event: pointer to the admin queue receive event
 843  */
 844 void
 845 ice_dcb_process_lldp_set_mib_change(struct ice_pf *pf,
 846                                     struct ice_rq_event_info *event)
 847 {
 848         struct ice_aqc_port_ets_elem buf = { 0 };
 849         struct device *dev = ice_pf_to_dev(pf);
 850         struct ice_aqc_lldp_get_mib *mib;
 851         struct ice_dcbx_cfg tmp_dcbx_cfg;
 852         bool need_reconfig = false;
 853         struct ice_port_info *pi;
 854         struct ice_vsi *pf_vsi;
 855         u8 mib_type;
 856         int ret;
 857
 858         /* Not DCB capable or capability disabled */
 859         if (!(test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags)))
 860                 return;
 861
 862         if (pf->dcbx_cap & DCB_CAP_DCBX_HOST) {
 863                 dev_dbg(dev, "MIB Change Event in HOST mode\n");
 864                 return;
 865         }
 866
 867         pi = pf->hw.port_info;
 868         mib = (struct ice_aqc_lldp_get_mib *)&event->desc.params.raw;
 869         /* Ignore if event is not for Nearest Bridge */
 870         mib_type = ((mib->type >> ICE_AQ_LLDP_BRID_TYPE_S) &
 871                     ICE_AQ_LLDP_BRID_TYPE_M);
 872         dev_dbg(dev, "LLDP event MIB bridge type 0x%x\n", mib_type);
 873         if (mib_type != ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID)
 874                 return;
 875
 876         /* Check MIB Type and return if event for Remote MIB update */
 877         mib_type = mib->type & ICE_AQ_LLDP_MIB_TYPE_M;
 878         dev_dbg(dev, "LLDP event mib type %s\n", mib_type ? "remote" : "local");
 879         if (mib_type == ICE_AQ_LLDP_MIB_REMOTE) {
 880                 /* Update the remote cached instance and return */
 881                 ret = ice_aq_get_dcb_cfg(pi->hw, ICE_AQ_LLDP_MIB_REMOTE,
 882                                          ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID,
 883                                          &pi->qos_cfg.remote_dcbx_cfg);
 884                 if (ret) {
 885                         dev_err(dev, "Failed to get remote DCB config\n");
 886                         return;
 887                 }
 888         }
 889
 890         mutex_lock(&pf->tc_mutex);
 891
 892         /* store the old configuration */
 893         tmp_dcbx_cfg = pf->hw.port_info->qos_cfg.local_dcbx_cfg;
 894
 895         /* Reset the old DCBX configuration data */
 896         memset(&pi->qos_cfg.local_dcbx_cfg, 0,
 897                sizeof(pi->qos_cfg.local_dcbx_cfg));
 898
 899         /* Get updated DCBX data from firmware */
 900         ret = ice_get_dcb_cfg(pf->hw.port_info);
 901         if (ret) {
 902                 dev_err(dev, "Failed to get DCB config\n");
 903                 goto out;
 904         }
 905
 906         /* No change detected in DCBX configs */
 907         if (!memcmp(&tmp_dcbx_cfg, &pi->qos_cfg.local_dcbx_cfg,
 908                     sizeof(tmp_dcbx_cfg))) {
 909                 dev_dbg(dev, "No change detected in DCBX configuration.\n");
 910                 goto out;
 911         }
 912
 913         pf->dcbx_cap = ice_dcb_get_mode(pi, false);
 914
 915         need_reconfig = ice_dcb_need_recfg(pf, &tmp_dcbx_cfg,
 916                                            &pi->qos_cfg.local_dcbx_cfg);
 917         ice_dcbnl_flush_apps(pf, &tmp_dcbx_cfg, &pi->qos_cfg.local_dcbx_cfg);
 918         if (!need_reconfig)
 919                 goto out;
 920
 921         /* Enable DCB tagging only when more than one TC */
 922         if (ice_dcb_get_num_tc(&pi->qos_cfg.local_dcbx_cfg) > 1) {
 923                 dev_dbg(dev, "DCB tagging enabled (num TC > 1)\n");
 924                 set_bit(ICE_FLAG_DCB_ENA, pf->flags);
 925         } else {
 926                 dev_dbg(dev, "DCB tagging disabled (num TC = 1)\n");
 927                 clear_bit(ICE_FLAG_DCB_ENA, pf->flags);
 928         }
 929
 930         pf_vsi = ice_get_main_vsi(pf);
 931         if (!pf_vsi) {
 932                 dev_dbg(dev, "PF VSI doesn't exist\n");
 933                 goto out;
 934         }
 935
 936         rtnl_lock();
 937         ice_dis_vsi(pf_vsi, true);
 938
 939         ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
 940         if (ret) {
 941                 dev_err(dev, "Query Port ETS failed\n");
 942                 goto unlock_rtnl;
 943         }
 944
 945         /* changes in configuration update VSI */
 946         ice_pf_dcb_recfg(pf);
 947
 948         ice_ena_vsi(pf_vsi, true);
 949 unlock_rtnl:
 950         rtnl_unlock();
 951 out:
 952         mutex_unlock(&pf->tc_mutex);
 953 }