linux/drivers/net/ethernet/intel/ice/ice_dcb_lib.c
<<
>>
Prefs
   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 */
  12void 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 */
  53u8 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 */
  72bool 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 */
 128static 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 */
 147u8 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 */
 186u8 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 */
 195void 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 */
 234int 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 */
 272int 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 ice_vsi *pf_vsi;
 279
 280        curr_cfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
 281
 282        /* FW does not care if change happened */
 283        if (!pf->hw.port_info->qos_cfg.is_sw_lldp)
 284                ret = ICE_DCB_HW_CHG_RST;
 285
 286        /* Enable DCB tagging only when more than one TC */
 287        if (ice_dcb_get_num_tc(new_cfg) > 1) {
 288                dev_dbg(dev, "DCB tagging enabled (num TC > 1)\n");
 289                set_bit(ICE_FLAG_DCB_ENA, pf->flags);
 290        } else {
 291                dev_dbg(dev, "DCB tagging disabled (num TC = 1)\n");
 292                clear_bit(ICE_FLAG_DCB_ENA, pf->flags);
 293        }
 294
 295        if (!memcmp(new_cfg, curr_cfg, sizeof(*new_cfg))) {
 296                dev_dbg(dev, "No change in DCB config required\n");
 297                return ret;
 298        }
 299
 300        if (ice_dcb_bwchk(pf, new_cfg))
 301                return -EINVAL;
 302
 303        /* Store old config in case FW config fails */
 304        old_cfg = kmemdup(curr_cfg, sizeof(*old_cfg), GFP_KERNEL);
 305        if (!old_cfg)
 306                return -ENOMEM;
 307
 308        dev_info(dev, "Commit DCB Configuration to the hardware\n");
 309        pf_vsi = ice_get_main_vsi(pf);
 310        if (!pf_vsi) {
 311                dev_dbg(dev, "PF VSI doesn't exist\n");
 312                ret = -EINVAL;
 313                goto free_cfg;
 314        }
 315
 316        /* avoid race conditions by holding the lock while disabling and
 317         * re-enabling the VSI
 318         */
 319        if (!locked)
 320                rtnl_lock();
 321        ice_dis_vsi(pf_vsi, true);
 322
 323        memcpy(curr_cfg, new_cfg, sizeof(*curr_cfg));
 324        memcpy(&curr_cfg->etsrec, &curr_cfg->etscfg, sizeof(curr_cfg->etsrec));
 325        memcpy(&new_cfg->etsrec, &curr_cfg->etscfg, sizeof(curr_cfg->etsrec));
 326
 327        /* Only send new config to HW if we are in SW LLDP mode. Otherwise,
 328         * the new config came from the HW in the first place.
 329         */
 330        if (pf->hw.port_info->qos_cfg.is_sw_lldp) {
 331                ret = ice_set_dcb_cfg(pf->hw.port_info);
 332                if (ret) {
 333                        dev_err(dev, "Set DCB Config failed\n");
 334                        /* Restore previous settings to local config */
 335                        memcpy(curr_cfg, old_cfg, sizeof(*curr_cfg));
 336                        goto out;
 337                }
 338        }
 339
 340        ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
 341        if (ret) {
 342                dev_err(dev, "Query Port ETS failed\n");
 343                goto out;
 344        }
 345
 346        ice_pf_dcb_recfg(pf);
 347
 348out:
 349        ice_ena_vsi(pf_vsi, true);
 350        if (!locked)
 351                rtnl_unlock();
 352free_cfg:
 353        kfree(old_cfg);
 354        return ret;
 355}
 356
 357/**
 358 * ice_cfg_etsrec_defaults - Set default ETS recommended DCB config
 359 * @pi: port information structure
 360 */
 361static void ice_cfg_etsrec_defaults(struct ice_port_info *pi)
 362{
 363        struct ice_dcbx_cfg *dcbcfg = &pi->qos_cfg.local_dcbx_cfg;
 364        u8 i;
 365
 366        /* Ensure ETS recommended DCB configuration is not already set */
 367        if (dcbcfg->etsrec.maxtcs)
 368                return;
 369
 370        /* In CEE mode, set the default to 1 TC */
 371        dcbcfg->etsrec.maxtcs = 1;
 372        for (i = 0; i < ICE_MAX_TRAFFIC_CLASS; i++) {
 373                dcbcfg->etsrec.tcbwtable[i] = i ? 0 : 100;
 374                dcbcfg->etsrec.tsatable[i] = i ? ICE_IEEE_TSA_STRICT :
 375                                                 ICE_IEEE_TSA_ETS;
 376        }
 377}
 378
 379/**
 380 * ice_dcb_need_recfg - Check if DCB needs reconfig
 381 * @pf: board private structure
 382 * @old_cfg: current DCB config
 383 * @new_cfg: new DCB config
 384 */
 385static bool
 386ice_dcb_need_recfg(struct ice_pf *pf, struct ice_dcbx_cfg *old_cfg,
 387                   struct ice_dcbx_cfg *new_cfg)
 388{
 389        struct device *dev = ice_pf_to_dev(pf);
 390        bool need_reconfig = false;
 391
 392        /* Check if ETS configuration has changed */
 393        if (memcmp(&new_cfg->etscfg, &old_cfg->etscfg,
 394                   sizeof(new_cfg->etscfg))) {
 395                /* If Priority Table has changed reconfig is needed */
 396                if (memcmp(&new_cfg->etscfg.prio_table,
 397                           &old_cfg->etscfg.prio_table,
 398                           sizeof(new_cfg->etscfg.prio_table))) {
 399                        need_reconfig = true;
 400                        dev_dbg(dev, "ETS UP2TC changed.\n");
 401                }
 402
 403                if (memcmp(&new_cfg->etscfg.tcbwtable,
 404                           &old_cfg->etscfg.tcbwtable,
 405                           sizeof(new_cfg->etscfg.tcbwtable)))
 406                        dev_dbg(dev, "ETS TC BW Table changed.\n");
 407
 408                if (memcmp(&new_cfg->etscfg.tsatable,
 409                           &old_cfg->etscfg.tsatable,
 410                           sizeof(new_cfg->etscfg.tsatable)))
 411                        dev_dbg(dev, "ETS TSA Table changed.\n");
 412        }
 413
 414        /* Check if PFC configuration has changed */
 415        if (memcmp(&new_cfg->pfc, &old_cfg->pfc, sizeof(new_cfg->pfc))) {
 416                need_reconfig = true;
 417                dev_dbg(dev, "PFC config change detected.\n");
 418        }
 419
 420        /* Check if APP Table has changed */
 421        if (memcmp(&new_cfg->app, &old_cfg->app, sizeof(new_cfg->app))) {
 422                need_reconfig = true;
 423                dev_dbg(dev, "APP Table change detected.\n");
 424        }
 425
 426        dev_dbg(dev, "dcb need_reconfig=%d\n", need_reconfig);
 427        return need_reconfig;
 428}
 429
 430/**
 431 * ice_dcb_rebuild - rebuild DCB post reset
 432 * @pf: physical function instance
 433 */
 434void ice_dcb_rebuild(struct ice_pf *pf)
 435{
 436        struct ice_aqc_port_ets_elem buf = { 0 };
 437        struct device *dev = ice_pf_to_dev(pf);
 438        struct ice_dcbx_cfg *err_cfg;
 439        enum ice_status ret;
 440
 441        ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
 442        if (ret) {
 443                dev_err(dev, "Query Port ETS failed\n");
 444                goto dcb_error;
 445        }
 446
 447        mutex_lock(&pf->tc_mutex);
 448
 449        if (!pf->hw.port_info->qos_cfg.is_sw_lldp)
 450                ice_cfg_etsrec_defaults(pf->hw.port_info);
 451
 452        ret = ice_set_dcb_cfg(pf->hw.port_info);
 453        if (ret) {
 454                dev_err(dev, "Failed to set DCB config in rebuild\n");
 455                goto dcb_error;
 456        }
 457
 458        if (!pf->hw.port_info->qos_cfg.is_sw_lldp) {
 459                ret = ice_cfg_lldp_mib_change(&pf->hw, true);
 460                if (ret && !pf->hw.port_info->qos_cfg.is_sw_lldp) {
 461                        dev_err(dev, "Failed to register for MIB changes\n");
 462                        goto dcb_error;
 463                }
 464        }
 465
 466        dev_info(dev, "DCB info restored\n");
 467        ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
 468        if (ret) {
 469                dev_err(dev, "Query Port ETS failed\n");
 470                goto dcb_error;
 471        }
 472
 473        mutex_unlock(&pf->tc_mutex);
 474
 475        return;
 476
 477dcb_error:
 478        dev_err(dev, "Disabling DCB until new settings occur\n");
 479        err_cfg = kzalloc(sizeof(*err_cfg), GFP_KERNEL);
 480        if (!err_cfg) {
 481                mutex_unlock(&pf->tc_mutex);
 482                return;
 483        }
 484
 485        err_cfg->etscfg.willing = true;
 486        err_cfg->etscfg.tcbwtable[0] = ICE_TC_MAX_BW;
 487        err_cfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS;
 488        memcpy(&err_cfg->etsrec, &err_cfg->etscfg, sizeof(err_cfg->etsrec));
 489        /* Coverity warns the return code of ice_pf_dcb_cfg() is not checked
 490         * here as is done for other calls to that function. That check is
 491         * not necessary since this is in this function's error cleanup path.
 492         * Suppress the Coverity warning with the following comment...
 493         */
 494        /* coverity[check_return] */
 495        ice_pf_dcb_cfg(pf, err_cfg, false);
 496        kfree(err_cfg);
 497
 498        mutex_unlock(&pf->tc_mutex);
 499}
 500
 501/**
 502 * ice_dcb_init_cfg - set the initial DCB config in SW
 503 * @pf: PF to apply config to
 504 * @locked: Is the RTNL held
 505 */
 506static int ice_dcb_init_cfg(struct ice_pf *pf, bool locked)
 507{
 508        struct ice_dcbx_cfg *newcfg;
 509        struct ice_port_info *pi;
 510        int ret = 0;
 511
 512        pi = pf->hw.port_info;
 513        newcfg = kmemdup(&pi->qos_cfg.local_dcbx_cfg, sizeof(*newcfg),
 514                         GFP_KERNEL);
 515        if (!newcfg)
 516                return -ENOMEM;
 517
 518        memset(&pi->qos_cfg.local_dcbx_cfg, 0, sizeof(*newcfg));
 519
 520        dev_info(ice_pf_to_dev(pf), "Configuring initial DCB values\n");
 521        if (ice_pf_dcb_cfg(pf, newcfg, locked))
 522                ret = -EINVAL;
 523
 524        kfree(newcfg);
 525
 526        return ret;
 527}
 528
 529/**
 530 * ice_dcb_sw_dflt_cfg - Apply a default DCB config
 531 * @pf: PF to apply config to
 532 * @ets_willing: configure ETS willing
 533 * @locked: was this function called with RTNL held
 534 */
 535static int ice_dcb_sw_dflt_cfg(struct ice_pf *pf, bool ets_willing, bool locked)
 536{
 537        struct ice_aqc_port_ets_elem buf = { 0 };
 538        struct ice_dcbx_cfg *dcbcfg;
 539        struct ice_port_info *pi;
 540        struct ice_hw *hw;
 541        int ret;
 542
 543        hw = &pf->hw;
 544        pi = hw->port_info;
 545        dcbcfg = kzalloc(sizeof(*dcbcfg), GFP_KERNEL);
 546        if (!dcbcfg)
 547                return -ENOMEM;
 548
 549        memset(&pi->qos_cfg.local_dcbx_cfg, 0, sizeof(*dcbcfg));
 550
 551        dcbcfg->etscfg.willing = ets_willing ? 1 : 0;
 552        dcbcfg->etscfg.maxtcs = hw->func_caps.common_cap.maxtc;
 553        dcbcfg->etscfg.tcbwtable[0] = 100;
 554        dcbcfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS;
 555
 556        memcpy(&dcbcfg->etsrec, &dcbcfg->etscfg,
 557               sizeof(dcbcfg->etsrec));
 558        dcbcfg->etsrec.willing = 0;
 559
 560        dcbcfg->pfc.willing = 1;
 561        dcbcfg->pfc.pfccap = hw->func_caps.common_cap.maxtc;
 562
 563        dcbcfg->numapps = 1;
 564        dcbcfg->app[0].selector = ICE_APP_SEL_ETHTYPE;
 565        dcbcfg->app[0].priority = 3;
 566        dcbcfg->app[0].prot_id = ETH_P_FCOE;
 567
 568        ret = ice_pf_dcb_cfg(pf, dcbcfg, locked);
 569        kfree(dcbcfg);
 570        if (ret)
 571                return ret;
 572
 573        return ice_query_port_ets(pi, &buf, sizeof(buf), NULL);
 574}
 575
 576/**
 577 * ice_dcb_tc_contig - Check that TCs are contiguous
 578 * @prio_table: pointer to priority table
 579 *
 580 * Check if TCs begin with TC0 and are contiguous
 581 */
 582static bool ice_dcb_tc_contig(u8 *prio_table)
 583{
 584        bool found_empty = false;
 585        u8 used_tc = 0;
 586        int i;
 587
 588        /* Create a bitmap of used TCs */
 589        for (i = 0; i < CEE_DCBX_MAX_PRIO; i++)
 590                used_tc |= BIT(prio_table[i]);
 591
 592        for (i = 0; i < CEE_DCBX_MAX_PRIO; i++) {
 593                if (used_tc & BIT(i)) {
 594                        if (found_empty)
 595                                return false;
 596                } else {
 597                        found_empty = true;
 598                }
 599        }
 600
 601        return true;
 602}
 603
 604/**
 605 * ice_dcb_noncontig_cfg - Configure DCB for non-contiguous TCs
 606 * @pf: pointer to the PF struct
 607 *
 608 * If non-contiguous TCs, then configure SW DCB with TC0 and ETS non-willing
 609 */
 610static int ice_dcb_noncontig_cfg(struct ice_pf *pf)
 611{
 612        struct ice_dcbx_cfg *dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
 613        struct device *dev = ice_pf_to_dev(pf);
 614        int ret;
 615
 616        /* Configure SW DCB default with ETS non-willing */
 617        ret = ice_dcb_sw_dflt_cfg(pf, false, true);
 618        if (ret) {
 619                dev_err(dev, "Failed to set local DCB config %d\n", ret);
 620                return ret;
 621        }
 622
 623        /* Reconfigure with ETS willing so that FW will send LLDP MIB event */
 624        dcbcfg->etscfg.willing = 1;
 625        ret = ice_set_dcb_cfg(pf->hw.port_info);
 626        if (ret)
 627                dev_err(dev, "Failed to set DCB to unwilling\n");
 628
 629        return ret;
 630}
 631
 632/**
 633 * ice_pf_dcb_recfg - Reconfigure all VEBs and VSIs
 634 * @pf: pointer to the PF struct
 635 *
 636 * Assumed caller has already disabled all VSIs before
 637 * calling this function. Reconfiguring DCB based on
 638 * local_dcbx_cfg.
 639 */
 640void ice_pf_dcb_recfg(struct ice_pf *pf)
 641{
 642        struct ice_dcbx_cfg *dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
 643        u8 tc_map = 0;
 644        int v, ret;
 645
 646        /* Update each VSI */
 647        ice_for_each_vsi(pf, v) {
 648                struct ice_vsi *vsi = pf->vsi[v];
 649
 650                if (!vsi)
 651                        continue;
 652
 653                if (vsi->type == ICE_VSI_PF) {
 654                        tc_map = ice_dcb_get_ena_tc(dcbcfg);
 655
 656                        /* If DCBX request non-contiguous TC, then configure
 657                         * default TC
 658                         */
 659                        if (!ice_dcb_tc_contig(dcbcfg->etscfg.prio_table)) {
 660                                tc_map = ICE_DFLT_TRAFFIC_CLASS;
 661                                ice_dcb_noncontig_cfg(pf);
 662                        }
 663                } else {
 664                        tc_map = ICE_DFLT_TRAFFIC_CLASS;
 665                }
 666
 667                ret = ice_vsi_cfg_tc(vsi, tc_map);
 668                if (ret) {
 669                        dev_err(ice_pf_to_dev(pf), "Failed to config TC for VSI index: %d\n",
 670                                vsi->idx);
 671                        continue;
 672                }
 673
 674                ice_vsi_map_rings_to_vectors(vsi);
 675                if (vsi->type == ICE_VSI_PF)
 676                        ice_dcbnl_set_all(vsi);
 677        }
 678}
 679
 680/**
 681 * ice_init_pf_dcb - initialize DCB for a PF
 682 * @pf: PF to initialize DCB for
 683 * @locked: Was function called with RTNL held
 684 */
 685int ice_init_pf_dcb(struct ice_pf *pf, bool locked)
 686{
 687        struct device *dev = ice_pf_to_dev(pf);
 688        struct ice_port_info *port_info;
 689        struct ice_hw *hw = &pf->hw;
 690        int err;
 691
 692        port_info = hw->port_info;
 693
 694        err = ice_init_dcb(hw, false);
 695        if (err && !port_info->qos_cfg.is_sw_lldp) {
 696                dev_err(dev, "Error initializing DCB %d\n", err);
 697                goto dcb_init_err;
 698        }
 699
 700        dev_info(dev, "DCB is enabled in the hardware, max number of TCs supported on this port are %d\n",
 701                 pf->hw.func_caps.common_cap.maxtc);
 702        if (err) {
 703                struct ice_vsi *pf_vsi;
 704
 705                /* FW LLDP is disabled, activate SW DCBX/LLDP mode */
 706                dev_info(dev, "FW LLDP is disabled, DCBx/LLDP in SW mode.\n");
 707                clear_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags);
 708                err = ice_dcb_sw_dflt_cfg(pf, true, locked);
 709                if (err) {
 710                        dev_err(dev, "Failed to set local DCB config %d\n",
 711                                err);
 712                        err = -EIO;
 713                        goto dcb_init_err;
 714                }
 715
 716                /* If the FW DCBX engine is not running then Rx LLDP packets
 717                 * need to be redirected up the stack.
 718                 */
 719                pf_vsi = ice_get_main_vsi(pf);
 720                if (!pf_vsi) {
 721                        dev_err(dev, "Failed to set local DCB config\n");
 722                        err = -EIO;
 723                        goto dcb_init_err;
 724                }
 725
 726                ice_cfg_sw_lldp(pf_vsi, false, true);
 727
 728                pf->dcbx_cap = ice_dcb_get_mode(port_info, true);
 729                return 0;
 730        }
 731
 732        set_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags);
 733
 734        /* DCBX/LLDP enabled in FW, set DCBNL mode advertisement */
 735        pf->dcbx_cap = ice_dcb_get_mode(port_info, false);
 736
 737        err = ice_dcb_init_cfg(pf, locked);
 738        if (err)
 739                goto dcb_init_err;
 740
 741        return err;
 742
 743dcb_init_err:
 744        dev_err(dev, "DCB init failed\n");
 745        return err;
 746}
 747
 748/**
 749 * ice_update_dcb_stats - Update DCB stats counters
 750 * @pf: PF whose stats needs to be updated
 751 */
 752void ice_update_dcb_stats(struct ice_pf *pf)
 753{
 754        struct ice_hw_port_stats *prev_ps, *cur_ps;
 755        struct ice_hw *hw = &pf->hw;
 756        u8 port;
 757        int i;
 758
 759        port = hw->port_info->lport;
 760        prev_ps = &pf->stats_prev;
 761        cur_ps = &pf->stats;
 762
 763        for (i = 0; i < 8; i++) {
 764                ice_stat_update32(hw, GLPRT_PXOFFRXC(port, i),
 765                                  pf->stat_prev_loaded,
 766                                  &prev_ps->priority_xoff_rx[i],
 767                                  &cur_ps->priority_xoff_rx[i]);
 768                ice_stat_update32(hw, GLPRT_PXONRXC(port, i),
 769                                  pf->stat_prev_loaded,
 770                                  &prev_ps->priority_xon_rx[i],
 771                                  &cur_ps->priority_xon_rx[i]);
 772                ice_stat_update32(hw, GLPRT_PXONTXC(port, i),
 773                                  pf->stat_prev_loaded,
 774                                  &prev_ps->priority_xon_tx[i],
 775                                  &cur_ps->priority_xon_tx[i]);
 776                ice_stat_update32(hw, GLPRT_PXOFFTXC(port, i),
 777                                  pf->stat_prev_loaded,
 778                                  &prev_ps->priority_xoff_tx[i],
 779                                  &cur_ps->priority_xoff_tx[i]);
 780                ice_stat_update32(hw, GLPRT_RXON2OFFCNT(port, i),
 781                                  pf->stat_prev_loaded,
 782                                  &prev_ps->priority_xon_2_xoff[i],
 783                                  &cur_ps->priority_xon_2_xoff[i]);
 784        }
 785}
 786
 787/**
 788 * ice_tx_prepare_vlan_flags_dcb - prepare VLAN tagging for DCB
 789 * @tx_ring: ring to send buffer on
 790 * @first: pointer to struct ice_tx_buf
 791 *
 792 * This should not be called if the outer VLAN is software offloaded as the VLAN
 793 * tag will already be configured with the correct ID and priority bits
 794 */
 795void
 796ice_tx_prepare_vlan_flags_dcb(struct ice_ring *tx_ring,
 797                              struct ice_tx_buf *first)
 798{
 799        struct sk_buff *skb = first->skb;
 800
 801        if (!test_bit(ICE_FLAG_DCB_ENA, tx_ring->vsi->back->flags))
 802                return;
 803
 804        /* Insert 802.1p priority into VLAN header */
 805        if ((first->tx_flags & ICE_TX_FLAGS_HW_VLAN) ||
 806            skb->priority != TC_PRIO_CONTROL) {
 807                first->tx_flags &= ~ICE_TX_FLAGS_VLAN_PR_M;
 808                /* Mask the lower 3 bits to set the 802.1p priority */
 809                first->tx_flags |= (skb->priority & 0x7) <<
 810                                   ICE_TX_FLAGS_VLAN_PR_S;
 811                /* if this is not already set it means a VLAN 0 + priority needs
 812                 * to be offloaded
 813                 */
 814                first->tx_flags |= ICE_TX_FLAGS_HW_VLAN;
 815        }
 816}
 817
 818/**
 819 * ice_dcb_process_lldp_set_mib_change - Process MIB change
 820 * @pf: ptr to ice_pf
 821 * @event: pointer to the admin queue receive event
 822 */
 823void
 824ice_dcb_process_lldp_set_mib_change(struct ice_pf *pf,
 825                                    struct ice_rq_event_info *event)
 826{
 827        struct ice_aqc_port_ets_elem buf = { 0 };
 828        struct device *dev = ice_pf_to_dev(pf);
 829        struct ice_aqc_lldp_get_mib *mib;
 830        struct ice_dcbx_cfg tmp_dcbx_cfg;
 831        bool need_reconfig = false;
 832        struct ice_port_info *pi;
 833        struct ice_vsi *pf_vsi;
 834        u8 mib_type;
 835        int ret;
 836
 837        /* Not DCB capable or capability disabled */
 838        if (!(test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags)))
 839                return;
 840
 841        if (pf->dcbx_cap & DCB_CAP_DCBX_HOST) {
 842                dev_dbg(dev, "MIB Change Event in HOST mode\n");
 843                return;
 844        }
 845
 846        pi = pf->hw.port_info;
 847        mib = (struct ice_aqc_lldp_get_mib *)&event->desc.params.raw;
 848        /* Ignore if event is not for Nearest Bridge */
 849        mib_type = ((mib->type >> ICE_AQ_LLDP_BRID_TYPE_S) &
 850                    ICE_AQ_LLDP_BRID_TYPE_M);
 851        dev_dbg(dev, "LLDP event MIB bridge type 0x%x\n", mib_type);
 852        if (mib_type != ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID)
 853                return;
 854
 855        /* Check MIB Type and return if event for Remote MIB update */
 856        mib_type = mib->type & ICE_AQ_LLDP_MIB_TYPE_M;
 857        dev_dbg(dev, "LLDP event mib type %s\n", mib_type ? "remote" : "local");
 858        if (mib_type == ICE_AQ_LLDP_MIB_REMOTE) {
 859                /* Update the remote cached instance and return */
 860                ret = ice_aq_get_dcb_cfg(pi->hw, ICE_AQ_LLDP_MIB_REMOTE,
 861                                         ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID,
 862                                         &pi->qos_cfg.remote_dcbx_cfg);
 863                if (ret) {
 864                        dev_err(dev, "Failed to get remote DCB config\n");
 865                        return;
 866                }
 867        }
 868
 869        mutex_lock(&pf->tc_mutex);
 870
 871        /* store the old configuration */
 872        tmp_dcbx_cfg = pf->hw.port_info->qos_cfg.local_dcbx_cfg;
 873
 874        /* Reset the old DCBX configuration data */
 875        memset(&pi->qos_cfg.local_dcbx_cfg, 0,
 876               sizeof(pi->qos_cfg.local_dcbx_cfg));
 877
 878        /* Get updated DCBX data from firmware */
 879        ret = ice_get_dcb_cfg(pf->hw.port_info);
 880        if (ret) {
 881                dev_err(dev, "Failed to get DCB config\n");
 882                goto out;
 883        }
 884
 885        /* No change detected in DCBX configs */
 886        if (!memcmp(&tmp_dcbx_cfg, &pi->qos_cfg.local_dcbx_cfg,
 887                    sizeof(tmp_dcbx_cfg))) {
 888                dev_dbg(dev, "No change detected in DCBX configuration.\n");
 889                goto out;
 890        }
 891
 892        pf->dcbx_cap = ice_dcb_get_mode(pi, false);
 893
 894        need_reconfig = ice_dcb_need_recfg(pf, &tmp_dcbx_cfg,
 895                                           &pi->qos_cfg.local_dcbx_cfg);
 896        ice_dcbnl_flush_apps(pf, &tmp_dcbx_cfg, &pi->qos_cfg.local_dcbx_cfg);
 897        if (!need_reconfig)
 898                goto out;
 899
 900        /* Enable DCB tagging only when more than one TC */
 901        if (ice_dcb_get_num_tc(&pi->qos_cfg.local_dcbx_cfg) > 1) {
 902                dev_dbg(dev, "DCB tagging enabled (num TC > 1)\n");
 903                set_bit(ICE_FLAG_DCB_ENA, pf->flags);
 904        } else {
 905                dev_dbg(dev, "DCB tagging disabled (num TC = 1)\n");
 906                clear_bit(ICE_FLAG_DCB_ENA, pf->flags);
 907        }
 908
 909        pf_vsi = ice_get_main_vsi(pf);
 910        if (!pf_vsi) {
 911                dev_dbg(dev, "PF VSI doesn't exist\n");
 912                goto out;
 913        }
 914
 915        rtnl_lock();
 916        ice_dis_vsi(pf_vsi, true);
 917
 918        ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
 919        if (ret) {
 920                dev_err(dev, "Query Port ETS failed\n");
 921                goto unlock_rtnl;
 922        }
 923
 924        /* changes in configuration update VSI */
 925        ice_pf_dcb_recfg(pf);
 926
 927        ice_ena_vsi(pf_vsi, true);
 928unlock_rtnl:
 929        rtnl_unlock();
 930out:
 931        mutex_unlock(&pf->tc_mutex);
 932}
 933