linux/drivers/net/ethernet/intel/ice/ice_dcb_nl.c
<<
>>
Prefs
   1// SPDX-License-Identifier: GPL-2.0
   2/* Copyright (c) 2019, Intel Corporation. */
   3
   4#include "ice.h"
   5#include "ice_dcb.h"
   6#include "ice_dcb_lib.h"
   7#include "ice_dcb_nl.h"
   8#include <net/dcbnl.h>
   9
  10/**
  11 * ice_dcbnl_devreset - perform enough of a ifdown/ifup to sync DCBNL info
  12 * @netdev: device associated with interface that needs reset
  13 */
  14static void ice_dcbnl_devreset(struct net_device *netdev)
  15{
  16        struct ice_pf *pf = ice_netdev_to_pf(netdev);
  17
  18        while (ice_is_reset_in_progress(pf->state))
  19                usleep_range(1000, 2000);
  20
  21        dev_close(netdev);
  22        netdev_state_change(netdev);
  23        dev_open(netdev, NULL);
  24        netdev_state_change(netdev);
  25}
  26
  27/**
  28 * ice_dcbnl_getets - retrieve local ETS configuration
  29 * @netdev: the relevant netdev
  30 * @ets: struct to hold ETS configuration
  31 */
  32static int ice_dcbnl_getets(struct net_device *netdev, struct ieee_ets *ets)
  33{
  34        struct ice_dcbx_cfg *dcbxcfg;
  35        struct ice_pf *pf;
  36
  37        pf = ice_netdev_to_pf(netdev);
  38        dcbxcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
  39
  40        ets->willing = dcbxcfg->etscfg.willing;
  41        ets->ets_cap = dcbxcfg->etscfg.maxtcs;
  42        ets->cbs = dcbxcfg->etscfg.cbs;
  43        memcpy(ets->tc_tx_bw, dcbxcfg->etscfg.tcbwtable, sizeof(ets->tc_tx_bw));
  44        memcpy(ets->tc_rx_bw, dcbxcfg->etscfg.tcbwtable, sizeof(ets->tc_rx_bw));
  45        memcpy(ets->tc_tsa, dcbxcfg->etscfg.tsatable, sizeof(ets->tc_tsa));
  46        memcpy(ets->prio_tc, dcbxcfg->etscfg.prio_table, sizeof(ets->prio_tc));
  47        memcpy(ets->tc_reco_bw, dcbxcfg->etsrec.tcbwtable,
  48               sizeof(ets->tc_reco_bw));
  49        memcpy(ets->tc_reco_tsa, dcbxcfg->etsrec.tsatable,
  50               sizeof(ets->tc_reco_tsa));
  51        memcpy(ets->reco_prio_tc, dcbxcfg->etscfg.prio_table,
  52               sizeof(ets->reco_prio_tc));
  53
  54        return 0;
  55}
  56
  57/**
  58 * ice_dcbnl_setets - set IEEE ETS configuration
  59 * @netdev: pointer to relevant netdev
  60 * @ets: struct to hold ETS configuration
  61 */
  62static int ice_dcbnl_setets(struct net_device *netdev, struct ieee_ets *ets)
  63{
  64        struct ice_pf *pf = ice_netdev_to_pf(netdev);
  65        struct ice_dcbx_cfg *new_cfg;
  66        int bwcfg = 0, bwrec = 0;
  67        int err, i, max_tc = 0;
  68
  69        if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) ||
  70            !(pf->dcbx_cap & DCB_CAP_DCBX_VER_IEEE))
  71                return -EINVAL;
  72
  73        new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg;
  74
  75        mutex_lock(&pf->tc_mutex);
  76
  77        new_cfg->etscfg.willing = ets->willing;
  78        new_cfg->etscfg.cbs = ets->cbs;
  79        ice_for_each_traffic_class(i) {
  80                new_cfg->etscfg.tcbwtable[i] = ets->tc_tx_bw[i];
  81                bwcfg += ets->tc_tx_bw[i];
  82                new_cfg->etscfg.tsatable[i] = ets->tc_tsa[i];
  83                new_cfg->etscfg.prio_table[i] = ets->prio_tc[i];
  84                if (ets->prio_tc[i] > max_tc)
  85                        max_tc = ets->prio_tc[i];
  86                new_cfg->etsrec.tcbwtable[i] = ets->tc_reco_bw[i];
  87                bwrec += ets->tc_reco_bw[i];
  88                new_cfg->etsrec.tsatable[i] = ets->tc_reco_tsa[i];
  89                new_cfg->etsrec.prio_table[i] = ets->reco_prio_tc[i];
  90        }
  91
  92        if (ice_dcb_bwchk(pf, new_cfg)) {
  93                err = -EINVAL;
  94                goto ets_out;
  95        }
  96
  97        max_tc = pf->hw.func_caps.common_cap.maxtc;
  98
  99        new_cfg->etscfg.maxtcs = max_tc;
 100
 101        if (!bwcfg)
 102                new_cfg->etscfg.tcbwtable[0] = 100;
 103
 104        if (!bwrec)
 105                new_cfg->etsrec.tcbwtable[0] = 100;
 106
 107        err = ice_pf_dcb_cfg(pf, new_cfg, true);
 108        /* return of zero indicates new cfg applied */
 109        if (err == ICE_DCB_HW_CHG_RST)
 110                ice_dcbnl_devreset(netdev);
 111        if (err == ICE_DCB_NO_HW_CHG)
 112                err = ICE_DCB_HW_CHG_RST;
 113
 114ets_out:
 115        mutex_unlock(&pf->tc_mutex);
 116        return err;
 117}
 118
 119/**
 120 * ice_dcbnl_getnumtcs - Get max number of traffic classes supported
 121 * @dev: pointer to netdev struct
 122 * @tcid: TC ID
 123 * @num: total number of TCs supported by the adapter
 124 *
 125 * Return the total number of TCs supported
 126 */
 127static int
 128ice_dcbnl_getnumtcs(struct net_device *dev, int __always_unused tcid, u8 *num)
 129{
 130        struct ice_pf *pf = ice_netdev_to_pf(dev);
 131
 132        if (!test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags))
 133                return -EINVAL;
 134
 135        *num = pf->hw.func_caps.common_cap.maxtc;
 136        return 0;
 137}
 138
 139/**
 140 * ice_dcbnl_getdcbx - retrieve current DCBX capability
 141 * @netdev: pointer to the netdev struct
 142 */
 143static u8 ice_dcbnl_getdcbx(struct net_device *netdev)
 144{
 145        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 146
 147        return pf->dcbx_cap;
 148}
 149
 150/**
 151 * ice_dcbnl_setdcbx - set required DCBX capability
 152 * @netdev: the corresponding netdev
 153 * @mode: required mode
 154 */
 155static u8 ice_dcbnl_setdcbx(struct net_device *netdev, u8 mode)
 156{
 157        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 158        struct ice_qos_cfg *qos_cfg;
 159
 160        /* if FW LLDP agent is running, DCBNL not allowed to change mode */
 161        if (test_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags))
 162                return ICE_DCB_NO_HW_CHG;
 163
 164        /* No support for LLD_MANAGED modes or CEE+IEEE */
 165        if ((mode & DCB_CAP_DCBX_LLD_MANAGED) ||
 166            ((mode & DCB_CAP_DCBX_VER_IEEE) && (mode & DCB_CAP_DCBX_VER_CEE)) ||
 167            !(mode & DCB_CAP_DCBX_HOST))
 168                return ICE_DCB_NO_HW_CHG;
 169
 170        /* Already set to the given mode no change */
 171        if (mode == pf->dcbx_cap)
 172                return ICE_DCB_NO_HW_CHG;
 173
 174        pf->dcbx_cap = mode;
 175        qos_cfg = &pf->hw.port_info->qos_cfg;
 176        if (mode & DCB_CAP_DCBX_VER_CEE)
 177                qos_cfg->local_dcbx_cfg.dcbx_mode = ICE_DCBX_MODE_CEE;
 178        else
 179                qos_cfg->local_dcbx_cfg.dcbx_mode = ICE_DCBX_MODE_IEEE;
 180
 181        dev_info(ice_pf_to_dev(pf), "DCBx mode = 0x%x\n", mode);
 182        return ICE_DCB_HW_CHG_RST;
 183}
 184
 185/**
 186 * ice_dcbnl_get_perm_hw_addr - MAC address used by DCBX
 187 * @netdev: pointer to netdev struct
 188 * @perm_addr: buffer to return permanent MAC address
 189 */
 190static void ice_dcbnl_get_perm_hw_addr(struct net_device *netdev, u8 *perm_addr)
 191{
 192        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 193        struct ice_port_info *pi = pf->hw.port_info;
 194        int i, j;
 195
 196        memset(perm_addr, 0xff, MAX_ADDR_LEN);
 197
 198        for (i = 0; i < netdev->addr_len; i++)
 199                perm_addr[i] = pi->mac.perm_addr[i];
 200
 201        for (j = 0; j < netdev->addr_len; j++, i++)
 202                perm_addr[i] = pi->mac.perm_addr[j];
 203}
 204
 205/**
 206 * ice_get_pfc_delay - Retrieve PFC Link Delay
 207 * @hw: pointer to HW struct
 208 * @delay: holds the PFC Link Delay value
 209 */
 210static void ice_get_pfc_delay(struct ice_hw *hw, u16 *delay)
 211{
 212        u32 val;
 213
 214        val = rd32(hw, PRTDCB_GENC);
 215        *delay = (u16)((val & PRTDCB_GENC_PFCLDA_M) >> PRTDCB_GENC_PFCLDA_S);
 216}
 217
 218/**
 219 * ice_dcbnl_getpfc - retrieve local IEEE PFC config
 220 * @netdev: pointer to netdev struct
 221 * @pfc: struct to hold PFC info
 222 */
 223static int ice_dcbnl_getpfc(struct net_device *netdev, struct ieee_pfc *pfc)
 224{
 225        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 226        struct ice_port_info *pi = pf->hw.port_info;
 227        struct ice_dcbx_cfg *dcbxcfg;
 228        int i;
 229
 230        dcbxcfg = &pi->qos_cfg.local_dcbx_cfg;
 231        pfc->pfc_cap = dcbxcfg->pfc.pfccap;
 232        pfc->pfc_en = dcbxcfg->pfc.pfcena;
 233        pfc->mbc = dcbxcfg->pfc.mbc;
 234        ice_get_pfc_delay(&pf->hw, &pfc->delay);
 235
 236        ice_for_each_traffic_class(i) {
 237                pfc->requests[i] = pf->stats.priority_xoff_tx[i];
 238                pfc->indications[i] = pf->stats.priority_xoff_rx[i];
 239        }
 240
 241        return 0;
 242}
 243
 244/**
 245 * ice_dcbnl_setpfc - set local IEEE PFC config
 246 * @netdev: pointer to relevant netdev
 247 * @pfc: pointer to struct holding PFC config
 248 */
 249static int ice_dcbnl_setpfc(struct net_device *netdev, struct ieee_pfc *pfc)
 250{
 251        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 252        struct ice_dcbx_cfg *new_cfg;
 253        int err;
 254
 255        if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) ||
 256            !(pf->dcbx_cap & DCB_CAP_DCBX_VER_IEEE))
 257                return -EINVAL;
 258
 259        mutex_lock(&pf->tc_mutex);
 260
 261        new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg;
 262
 263        if (pfc->pfc_cap)
 264                new_cfg->pfc.pfccap = pfc->pfc_cap;
 265        else
 266                new_cfg->pfc.pfccap = pf->hw.func_caps.common_cap.maxtc;
 267
 268        new_cfg->pfc.pfcena = pfc->pfc_en;
 269
 270        err = ice_pf_dcb_cfg(pf, new_cfg, true);
 271        if (err == ICE_DCB_HW_CHG_RST)
 272                ice_dcbnl_devreset(netdev);
 273        if (err == ICE_DCB_NO_HW_CHG)
 274                err = ICE_DCB_HW_CHG_RST;
 275        mutex_unlock(&pf->tc_mutex);
 276        return err;
 277}
 278
 279/**
 280 * ice_dcbnl_get_pfc_cfg - Get CEE PFC config
 281 * @netdev: pointer to netdev struct
 282 * @prio: corresponding user priority
 283 * @setting: the PFC setting for given priority
 284 */
 285static void
 286ice_dcbnl_get_pfc_cfg(struct net_device *netdev, int prio, u8 *setting)
 287{
 288        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 289        struct ice_port_info *pi = pf->hw.port_info;
 290
 291        if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) ||
 292            !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE))
 293                return;
 294
 295        if (prio >= ICE_MAX_USER_PRIORITY)
 296                return;
 297
 298        *setting = (pi->qos_cfg.local_dcbx_cfg.pfc.pfcena >> prio) & 0x1;
 299        dev_dbg(ice_pf_to_dev(pf), "Get PFC Config up=%d, setting=%d, pfcenable=0x%x\n",
 300                prio, *setting, pi->qos_cfg.local_dcbx_cfg.pfc.pfcena);
 301}
 302
 303/**
 304 * ice_dcbnl_set_pfc_cfg - Set CEE PFC config
 305 * @netdev: the corresponding netdev
 306 * @prio: User Priority
 307 * @set: PFC setting to apply
 308 */
 309static void ice_dcbnl_set_pfc_cfg(struct net_device *netdev, int prio, u8 set)
 310{
 311        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 312        struct ice_dcbx_cfg *new_cfg;
 313
 314        if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) ||
 315            !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE))
 316                return;
 317
 318        if (prio >= ICE_MAX_USER_PRIORITY)
 319                return;
 320
 321        new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg;
 322
 323        new_cfg->pfc.pfccap = pf->hw.func_caps.common_cap.maxtc;
 324        if (set)
 325                new_cfg->pfc.pfcena |= BIT(prio);
 326        else
 327                new_cfg->pfc.pfcena &= ~BIT(prio);
 328
 329        dev_dbg(ice_pf_to_dev(pf), "Set PFC config UP:%d set:%d pfcena:0x%x\n",
 330                prio, set, new_cfg->pfc.pfcena);
 331}
 332
 333/**
 334 * ice_dcbnl_getpfcstate - get CEE PFC mode
 335 * @netdev: pointer to netdev struct
 336 */
 337static u8 ice_dcbnl_getpfcstate(struct net_device *netdev)
 338{
 339        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 340        struct ice_port_info *pi = pf->hw.port_info;
 341
 342        /* Return enabled if any UP enabled for PFC */
 343        if (pi->qos_cfg.local_dcbx_cfg.pfc.pfcena)
 344                return 1;
 345
 346        return 0;
 347}
 348
 349/**
 350 * ice_dcbnl_getstate - get DCB enabled state
 351 * @netdev: pointer to netdev struct
 352 */
 353static u8 ice_dcbnl_getstate(struct net_device *netdev)
 354{
 355        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 356        u8 state = 0;
 357
 358        state = test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags);
 359
 360        dev_dbg(ice_pf_to_dev(pf), "DCB enabled state = %d\n", state);
 361        return state;
 362}
 363
 364/**
 365 * ice_dcbnl_setstate - Set CEE DCB state
 366 * @netdev: pointer to relevant netdev
 367 * @state: state value to set
 368 */
 369static u8 ice_dcbnl_setstate(struct net_device *netdev, u8 state)
 370{
 371        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 372
 373        if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) ||
 374            !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE))
 375                return ICE_DCB_NO_HW_CHG;
 376
 377        /* Nothing to do */
 378        if (!!state == test_bit(ICE_FLAG_DCB_ENA, pf->flags))
 379                return ICE_DCB_NO_HW_CHG;
 380
 381        if (state) {
 382                set_bit(ICE_FLAG_DCB_ENA, pf->flags);
 383                memcpy(&pf->hw.port_info->qos_cfg.desired_dcbx_cfg,
 384                       &pf->hw.port_info->qos_cfg.local_dcbx_cfg,
 385                       sizeof(struct ice_dcbx_cfg));
 386        } else {
 387                clear_bit(ICE_FLAG_DCB_ENA, pf->flags);
 388        }
 389
 390        return ICE_DCB_HW_CHG;
 391}
 392
 393/**
 394 * ice_dcbnl_get_pg_tc_cfg_tx - get CEE PG Tx config
 395 * @netdev: pointer to netdev struct
 396 * @prio: the corresponding user priority
 397 * @prio_type: traffic priority type
 398 * @pgid: the BW group ID the traffic class belongs to
 399 * @bw_pct: BW percentage for the corresponding BWG
 400 * @up_map: prio mapped to corresponding TC
 401 */
 402static void
 403ice_dcbnl_get_pg_tc_cfg_tx(struct net_device *netdev, int prio,
 404                           u8 __always_unused *prio_type, u8 *pgid,
 405                           u8 __always_unused *bw_pct,
 406                           u8 __always_unused *up_map)
 407{
 408        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 409        struct ice_port_info *pi = pf->hw.port_info;
 410
 411        if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) ||
 412            !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE))
 413                return;
 414
 415        if (prio >= ICE_MAX_USER_PRIORITY)
 416                return;
 417
 418        *pgid = pi->qos_cfg.local_dcbx_cfg.etscfg.prio_table[prio];
 419        dev_dbg(ice_pf_to_dev(pf), "Get PG config prio=%d tc=%d\n", prio,
 420                *pgid);
 421}
 422
 423/**
 424 * ice_dcbnl_set_pg_tc_cfg_tx - set CEE PG Tx config
 425 * @netdev: pointer to relevant netdev
 426 * @tc: the corresponding traffic class
 427 * @prio_type: the traffic priority type
 428 * @bwg_id: the BW group ID the TC belongs to
 429 * @bw_pct: the BW perventage for the BWG
 430 * @up_map: prio mapped to corresponding TC
 431 */
 432static void
 433ice_dcbnl_set_pg_tc_cfg_tx(struct net_device *netdev, int tc,
 434                           u8 __always_unused prio_type,
 435                           u8 __always_unused bwg_id,
 436                           u8 __always_unused bw_pct, u8 up_map)
 437{
 438        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 439        struct ice_dcbx_cfg *new_cfg;
 440        int i;
 441
 442        if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) ||
 443            !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE))
 444                return;
 445
 446        if (tc >= ICE_MAX_TRAFFIC_CLASS)
 447                return;
 448
 449        new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg;
 450
 451        /* prio_type, bwg_id and bw_pct per UP are not supported */
 452
 453        ice_for_each_traffic_class(i) {
 454                if (up_map & BIT(i))
 455                        new_cfg->etscfg.prio_table[i] = tc;
 456        }
 457        new_cfg->etscfg.tsatable[tc] = ICE_IEEE_TSA_ETS;
 458}
 459
 460/**
 461 * ice_dcbnl_get_pg_bwg_cfg_tx - Get CEE PGBW config
 462 * @netdev: pointer to the netdev struct
 463 * @pgid: corresponding traffic class
 464 * @bw_pct: the BW percentage for the corresponding TC
 465 */
 466static void
 467ice_dcbnl_get_pg_bwg_cfg_tx(struct net_device *netdev, int pgid, u8 *bw_pct)
 468{
 469        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 470        struct ice_port_info *pi = pf->hw.port_info;
 471
 472        if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) ||
 473            !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE))
 474                return;
 475
 476        if (pgid >= ICE_MAX_TRAFFIC_CLASS)
 477                return;
 478
 479        *bw_pct = pi->qos_cfg.local_dcbx_cfg.etscfg.tcbwtable[pgid];
 480        dev_dbg(ice_pf_to_dev(pf), "Get PG BW config tc=%d bw_pct=%d\n",
 481                pgid, *bw_pct);
 482}
 483
 484/**
 485 * ice_dcbnl_set_pg_bwg_cfg_tx - set CEE PG Tx BW config
 486 * @netdev: the corresponding netdev
 487 * @pgid: Correspongind traffic class
 488 * @bw_pct: the BW percentage for the specified TC
 489 */
 490static void
 491ice_dcbnl_set_pg_bwg_cfg_tx(struct net_device *netdev, int pgid, u8 bw_pct)
 492{
 493        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 494        struct ice_dcbx_cfg *new_cfg;
 495
 496        if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) ||
 497            !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE))
 498                return;
 499
 500        if (pgid >= ICE_MAX_TRAFFIC_CLASS)
 501                return;
 502
 503        new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg;
 504
 505        new_cfg->etscfg.tcbwtable[pgid] = bw_pct;
 506}
 507
 508/**
 509 * ice_dcbnl_get_pg_tc_cfg_rx - Get CEE PG Rx config
 510 * @netdev: pointer to netdev struct
 511 * @prio: the corresponding user priority
 512 * @prio_type: the traffic priority type
 513 * @pgid: the PG ID
 514 * @bw_pct: the BW percentage for the corresponding BWG
 515 * @up_map: prio mapped to corresponding TC
 516 */
 517static void
 518ice_dcbnl_get_pg_tc_cfg_rx(struct net_device *netdev, int prio,
 519                           u8 __always_unused *prio_type, u8 *pgid,
 520                           u8 __always_unused *bw_pct,
 521                           u8 __always_unused *up_map)
 522{
 523        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 524        struct ice_port_info *pi = pf->hw.port_info;
 525
 526        if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) ||
 527            !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE))
 528                return;
 529
 530        if (prio >= ICE_MAX_USER_PRIORITY)
 531                return;
 532
 533        *pgid = pi->qos_cfg.local_dcbx_cfg.etscfg.prio_table[prio];
 534}
 535
 536/**
 537 * ice_dcbnl_set_pg_tc_cfg_rx
 538 * @netdev: relevant netdev struct
 539 * @prio: corresponding user priority
 540 * @prio_type: the traffic priority type
 541 * @pgid: the PG ID
 542 * @bw_pct: BW percentage for corresponding BWG
 543 * @up_map: prio mapped to corresponding TC
 544 *
 545 * lldpad requires this function pointer to be non-NULL to complete CEE config.
 546 */
 547static void
 548ice_dcbnl_set_pg_tc_cfg_rx(struct net_device *netdev,
 549                           int __always_unused prio,
 550                           u8 __always_unused prio_type,
 551                           u8 __always_unused pgid,
 552                           u8 __always_unused bw_pct,
 553                           u8 __always_unused up_map)
 554{
 555        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 556
 557        dev_dbg(ice_pf_to_dev(pf), "Rx TC PG Config Not Supported.\n");
 558}
 559
 560/**
 561 * ice_dcbnl_get_pg_bwg_cfg_rx - Get CEE PG BW Rx config
 562 * @netdev: pointer to netdev struct
 563 * @pgid: the corresponding traffic class
 564 * @bw_pct: the BW percentage for the corresponding TC
 565 */
 566static void
 567ice_dcbnl_get_pg_bwg_cfg_rx(struct net_device *netdev, int __always_unused pgid,
 568                            u8 *bw_pct)
 569{
 570        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 571
 572        if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) ||
 573            !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE))
 574                return;
 575
 576        *bw_pct = 0;
 577}
 578
 579/**
 580 * ice_dcbnl_set_pg_bwg_cfg_rx
 581 * @netdev: the corresponding netdev
 582 * @pgid: corresponding TC
 583 * @bw_pct: BW percentage for given TC
 584 *
 585 * lldpad requires this function pointer to be non-NULL to complete CEE config.
 586 */
 587static void
 588ice_dcbnl_set_pg_bwg_cfg_rx(struct net_device *netdev, int __always_unused pgid,
 589                            u8 __always_unused bw_pct)
 590{
 591        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 592
 593        dev_dbg(ice_pf_to_dev(pf), "Rx BWG PG Config Not Supported.\n");
 594}
 595
 596/**
 597 * ice_dcbnl_get_cap - Get DCBX capabilities of adapter
 598 * @netdev: pointer to netdev struct
 599 * @capid: the capability type
 600 * @cap: the capability value
 601 */
 602static u8 ice_dcbnl_get_cap(struct net_device *netdev, int capid, u8 *cap)
 603{
 604        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 605
 606        if (!(test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags)))
 607                return ICE_DCB_NO_HW_CHG;
 608
 609        switch (capid) {
 610        case DCB_CAP_ATTR_PG:
 611                *cap = true;
 612                break;
 613        case DCB_CAP_ATTR_PFC:
 614                *cap = true;
 615                break;
 616        case DCB_CAP_ATTR_UP2TC:
 617                *cap = false;
 618                break;
 619        case DCB_CAP_ATTR_PG_TCS:
 620                *cap = 0x80;
 621                break;
 622        case DCB_CAP_ATTR_PFC_TCS:
 623                *cap = 0x80;
 624                break;
 625        case DCB_CAP_ATTR_GSP:
 626                *cap = false;
 627                break;
 628        case DCB_CAP_ATTR_BCN:
 629                *cap = false;
 630                break;
 631        case DCB_CAP_ATTR_DCBX:
 632                *cap = pf->dcbx_cap;
 633                break;
 634        default:
 635                *cap = false;
 636                break;
 637        }
 638
 639        dev_dbg(ice_pf_to_dev(pf), "DCBX Get Capability cap=%d capval=0x%x\n",
 640                capid, *cap);
 641        return 0;
 642}
 643
 644/**
 645 * ice_dcbnl_getapp - get CEE APP
 646 * @netdev: pointer to netdev struct
 647 * @idtype: the App selector
 648 * @id: the App ethtype or port number
 649 */
 650static int ice_dcbnl_getapp(struct net_device *netdev, u8 idtype, u16 id)
 651{
 652        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 653        struct dcb_app app = {
 654                                .selector = idtype,
 655                                .protocol = id,
 656                             };
 657
 658        if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) ||
 659            !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE))
 660                return -EINVAL;
 661
 662        return dcb_getapp(netdev, &app);
 663}
 664
 665/**
 666 * ice_dcbnl_find_app - Search for APP in given DCB config
 667 * @cfg: struct to hold DCBX config
 668 * @app: struct to hold app data to look for
 669 */
 670static bool
 671ice_dcbnl_find_app(struct ice_dcbx_cfg *cfg,
 672                   struct ice_dcb_app_priority_table *app)
 673{
 674        unsigned int i;
 675
 676        for (i = 0; i < cfg->numapps; i++) {
 677                if (app->selector == cfg->app[i].selector &&
 678                    app->prot_id == cfg->app[i].prot_id &&
 679                    app->priority == cfg->app[i].priority)
 680                        return true;
 681        }
 682
 683        return false;
 684}
 685
 686/**
 687 * ice_dcbnl_setapp - set local IEEE App config
 688 * @netdev: relevant netdev struct
 689 * @app: struct to hold app config info
 690 */
 691static int ice_dcbnl_setapp(struct net_device *netdev, struct dcb_app *app)
 692{
 693        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 694        struct ice_dcb_app_priority_table new_app;
 695        struct ice_dcbx_cfg *old_cfg, *new_cfg;
 696        int ret;
 697
 698        if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) ||
 699            !(pf->dcbx_cap & DCB_CAP_DCBX_VER_IEEE))
 700                return -EINVAL;
 701
 702        mutex_lock(&pf->tc_mutex);
 703
 704        new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg;
 705
 706        old_cfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
 707
 708        if (old_cfg->numapps == ICE_DCBX_MAX_APPS) {
 709                ret = -EINVAL;
 710                goto setapp_out;
 711        }
 712
 713        ret = dcb_ieee_setapp(netdev, app);
 714        if (ret)
 715                goto setapp_out;
 716
 717        new_app.selector = app->selector;
 718        new_app.prot_id = app->protocol;
 719        new_app.priority = app->priority;
 720        if (ice_dcbnl_find_app(old_cfg, &new_app)) {
 721                ret = 0;
 722                goto setapp_out;
 723        }
 724
 725        new_cfg->app[new_cfg->numapps++] = new_app;
 726        ret = ice_pf_dcb_cfg(pf, new_cfg, true);
 727        /* return of zero indicates new cfg applied */
 728        if (ret == ICE_DCB_HW_CHG_RST)
 729                ice_dcbnl_devreset(netdev);
 730        if (ret == ICE_DCB_NO_HW_CHG)
 731                ret = ICE_DCB_HW_CHG_RST;
 732
 733setapp_out:
 734        mutex_unlock(&pf->tc_mutex);
 735        return ret;
 736}
 737
 738/**
 739 * ice_dcbnl_delapp - Delete local IEEE App config
 740 * @netdev: relevant netdev
 741 * @app: struct to hold app too delete
 742 *
 743 * Will not delete first application required by the FW
 744 */
 745static int ice_dcbnl_delapp(struct net_device *netdev, struct dcb_app *app)
 746{
 747        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 748        struct ice_dcbx_cfg *old_cfg, *new_cfg;
 749        unsigned int i, j;
 750        int ret = 0;
 751
 752        if (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED)
 753                return -EINVAL;
 754
 755        mutex_lock(&pf->tc_mutex);
 756        old_cfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
 757
 758        if (old_cfg->numapps <= 1)
 759                goto delapp_out;
 760
 761        ret = dcb_ieee_delapp(netdev, app);
 762        if (ret)
 763                goto delapp_out;
 764
 765        new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg;
 766
 767        for (i = 1; i < new_cfg->numapps; i++) {
 768                if (app->selector == new_cfg->app[i].selector &&
 769                    app->protocol == new_cfg->app[i].prot_id &&
 770                    app->priority == new_cfg->app[i].priority) {
 771                        new_cfg->app[i].selector = 0;
 772                        new_cfg->app[i].prot_id = 0;
 773                        new_cfg->app[i].priority = 0;
 774                        break;
 775                }
 776        }
 777
 778        /* Did not find DCB App */
 779        if (i == new_cfg->numapps) {
 780                ret = -EINVAL;
 781                goto delapp_out;
 782        }
 783
 784        new_cfg->numapps--;
 785
 786        for (j = i; j < new_cfg->numapps; j++) {
 787                new_cfg->app[i].selector = old_cfg->app[j + 1].selector;
 788                new_cfg->app[i].prot_id = old_cfg->app[j + 1].prot_id;
 789                new_cfg->app[i].priority = old_cfg->app[j + 1].priority;
 790        }
 791
 792        ret = ice_pf_dcb_cfg(pf, new_cfg, true);
 793        /* return of zero indicates new cfg applied */
 794        if (ret == ICE_DCB_HW_CHG_RST)
 795                ice_dcbnl_devreset(netdev);
 796        if (ret == ICE_DCB_NO_HW_CHG)
 797                ret = ICE_DCB_HW_CHG_RST;
 798
 799delapp_out:
 800        mutex_unlock(&pf->tc_mutex);
 801        return ret;
 802}
 803
 804/**
 805 * ice_dcbnl_cee_set_all - Commit CEE DCB settings to HW
 806 * @netdev: the corresponding netdev
 807 */
 808static u8 ice_dcbnl_cee_set_all(struct net_device *netdev)
 809{
 810        struct ice_pf *pf = ice_netdev_to_pf(netdev);
 811        struct ice_dcbx_cfg *new_cfg;
 812        int err;
 813
 814        if ((pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) ||
 815            !(pf->dcbx_cap & DCB_CAP_DCBX_VER_CEE))
 816                return ICE_DCB_NO_HW_CHG;
 817
 818        new_cfg = &pf->hw.port_info->qos_cfg.desired_dcbx_cfg;
 819
 820        mutex_lock(&pf->tc_mutex);
 821
 822        err = ice_pf_dcb_cfg(pf, new_cfg, true);
 823
 824        mutex_unlock(&pf->tc_mutex);
 825        return (err != ICE_DCB_HW_CHG_RST) ? ICE_DCB_NO_HW_CHG : err;
 826}
 827
 828static const struct dcbnl_rtnl_ops dcbnl_ops = {
 829        /* IEEE 802.1Qaz std */
 830        .ieee_getets = ice_dcbnl_getets,
 831        .ieee_setets = ice_dcbnl_setets,
 832        .ieee_getpfc = ice_dcbnl_getpfc,
 833        .ieee_setpfc = ice_dcbnl_setpfc,
 834        .ieee_setapp = ice_dcbnl_setapp,
 835        .ieee_delapp = ice_dcbnl_delapp,
 836
 837        /* CEE std */
 838        .getstate = ice_dcbnl_getstate,
 839        .setstate = ice_dcbnl_setstate,
 840        .getpermhwaddr = ice_dcbnl_get_perm_hw_addr,
 841        .setpgtccfgtx = ice_dcbnl_set_pg_tc_cfg_tx,
 842        .setpgbwgcfgtx = ice_dcbnl_set_pg_bwg_cfg_tx,
 843        .setpgtccfgrx = ice_dcbnl_set_pg_tc_cfg_rx,
 844        .setpgbwgcfgrx = ice_dcbnl_set_pg_bwg_cfg_rx,
 845        .getpgtccfgtx = ice_dcbnl_get_pg_tc_cfg_tx,
 846        .getpgbwgcfgtx = ice_dcbnl_get_pg_bwg_cfg_tx,
 847        .getpgtccfgrx = ice_dcbnl_get_pg_tc_cfg_rx,
 848        .getpgbwgcfgrx = ice_dcbnl_get_pg_bwg_cfg_rx,
 849        .setpfccfg = ice_dcbnl_set_pfc_cfg,
 850        .getpfccfg = ice_dcbnl_get_pfc_cfg,
 851        .setall = ice_dcbnl_cee_set_all,
 852        .getcap = ice_dcbnl_get_cap,
 853        .getnumtcs = ice_dcbnl_getnumtcs,
 854        .getpfcstate = ice_dcbnl_getpfcstate,
 855        .getapp = ice_dcbnl_getapp,
 856
 857        /* DCBX configuration */
 858        .getdcbx = ice_dcbnl_getdcbx,
 859        .setdcbx = ice_dcbnl_setdcbx,
 860};
 861
 862/**
 863 * ice_dcbnl_set_all - set all the apps and ieee data from DCBX config
 864 * @vsi: pointer to VSI struct
 865 */
 866void ice_dcbnl_set_all(struct ice_vsi *vsi)
 867{
 868        struct net_device *netdev = vsi->netdev;
 869        struct ice_dcbx_cfg *dcbxcfg;
 870        struct ice_port_info *pi;
 871        struct dcb_app sapp;
 872        struct ice_pf *pf;
 873        unsigned int i;
 874
 875        if (!netdev)
 876                return;
 877
 878        pf = ice_netdev_to_pf(netdev);
 879        pi = pf->hw.port_info;
 880
 881        /* SW DCB taken care of by SW Default Config */
 882        if (pf->dcbx_cap & DCB_CAP_DCBX_HOST)
 883                return;
 884
 885        /* DCB not enabled */
 886        if (!test_bit(ICE_FLAG_DCB_ENA, pf->flags))
 887                return;
 888
 889        dcbxcfg = &pi->qos_cfg.local_dcbx_cfg;
 890
 891        for (i = 0; i < dcbxcfg->numapps; i++) {
 892                u8 prio, tc_map;
 893
 894                prio = dcbxcfg->app[i].priority;
 895                tc_map = BIT(dcbxcfg->etscfg.prio_table[prio]);
 896
 897                /* Add APP only if the TC is enabled for this VSI */
 898                if (tc_map & vsi->tc_cfg.ena_tc) {
 899                        sapp.selector = dcbxcfg->app[i].selector;
 900                        sapp.protocol = dcbxcfg->app[i].prot_id;
 901                        sapp.priority = prio;
 902                        dcb_ieee_setapp(netdev, &sapp);
 903                }
 904        }
 905        /* Notify user-space of the changes */
 906        dcbnl_ieee_notify(netdev, RTM_SETDCB, DCB_CMD_IEEE_SET, 0, 0);
 907}
 908
 909/**
 910 * ice_dcbnl_vsi_del_app - Delete APP on all VSIs
 911 * @vsi: pointer to the main VSI
 912 * @app: APP to delete
 913 *
 914 * Delete given APP from all the VSIs for given PF
 915 */
 916static void
 917ice_dcbnl_vsi_del_app(struct ice_vsi *vsi,
 918                      struct ice_dcb_app_priority_table *app)
 919{
 920        struct dcb_app sapp;
 921        int err;
 922
 923        sapp.selector = app->selector;
 924        sapp.protocol = app->prot_id;
 925        sapp.priority = app->priority;
 926        err = ice_dcbnl_delapp(vsi->netdev, &sapp);
 927        dev_dbg(ice_pf_to_dev(vsi->back), "Deleting app for VSI idx=%d err=%d sel=%d proto=0x%x, prio=%d\n",
 928                vsi->idx, err, app->selector, app->prot_id, app->priority);
 929}
 930
 931/**
 932 * ice_dcbnl_flush_apps - Delete all removed APPs
 933 * @pf: the corresponding PF
 934 * @old_cfg: old DCBX configuration data
 935 * @new_cfg: new DCBX configuration data
 936 *
 937 * Find and delete all APPS that are not present in the passed
 938 * DCB configuration
 939 */
 940void
 941ice_dcbnl_flush_apps(struct ice_pf *pf, struct ice_dcbx_cfg *old_cfg,
 942                     struct ice_dcbx_cfg *new_cfg)
 943{
 944        struct ice_vsi *main_vsi = ice_get_main_vsi(pf);
 945        unsigned int i;
 946
 947        if (!main_vsi)
 948                return;
 949
 950        for (i = 0; i < old_cfg->numapps; i++) {
 951                struct ice_dcb_app_priority_table app = old_cfg->app[i];
 952
 953                /* The APP is not available anymore delete it */
 954                if (!ice_dcbnl_find_app(new_cfg, &app))
 955                        ice_dcbnl_vsi_del_app(main_vsi, &app);
 956        }
 957}
 958
 959/**
 960 * ice_dcbnl_setup - setup DCBNL
 961 * @vsi: VSI to get associated netdev from
 962 */
 963void ice_dcbnl_setup(struct ice_vsi *vsi)
 964{
 965        struct net_device *netdev = vsi->netdev;
 966        struct ice_pf *pf;
 967
 968        pf = ice_netdev_to_pf(netdev);
 969        if (!test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags))
 970                return;
 971
 972        netdev->dcbnl_ops = &dcbnl_ops;
 973        ice_dcbnl_set_all(vsi);
 974}
 975