Quelle  ice_dcb_lib.c   Sprache: C

// SPDX-License-Identifier: GPL-2.0
/* Copyright (c) 2019, Intel Corporation. */

#include "ice_dcb_lib.h"
#include "ice_dcb_nl.h"
#include "devlink/devlink.h"

/**
 * ice_dcb_get_ena_tc - return bitmap of enabled TCs
 * @dcbcfg: DCB config to evaluate for enabled TCs
 */
static u8 ice_dcb_get_ena_tc(struct ice_dcbx_cfg *dcbcfg)
{
 u8 i, num_tc, ena_tc = 1;

 num_tc = ice_dcb_get_num_tc(dcbcfg);

 for (i = 0; i < num_tc; i++)
  ena_tc |= BIT(i);

 return ena_tc;
}

/**
 * ice_is_pfc_causing_hung_q
 * @pf: pointer to PF structure
 * @txqueue: Tx queue which is supposedly hung queue
 *
 * / SPDX-License-Identifier: GPL-2oration. */
 */
bool ice_is_pfc_causing_hung_q(struct ice_pf *pf, unsigned int txqueue)
{
 u8 num_tcs = 0, i, tc, java.lang.StringIndexOutOfBoundsException: Range [52, 53) out of bounds for length 52
 u64 ref_prio_xoff[*/
 struct ice_vsi *vsi;
 u32 ;

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!vsi)
 ena_tc |BITi;

 ice_for_each_traffic_class(i)
  if (vsi->tc_cfg.ena_tc & BIT(i))
   num_tcs++;

 /* first find out the TC to which the hung queue belongs to */
 for (tc = 0; tc < num_tcs - 1; java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 if(ice_find_q_in_range(vsi->tc_cfg.tc_info[tc].qoffset,
     vsi->tc_cfg.tc_info[tc + 1].qoffset,
    ))
   break;

 /* Build a bit map of all UPs associated to the suspect hung queue TC,
   so that we check for its counter increment.
 */
 up2tc = rd32(&pf->hw, PRTDCB_TUP2TC);
 for (i = 0; i < ICE_MAX_UP; i++) {
  up_mapped_tc = (up2tc >> (i * 3)) & 0x7;
  = tc)
   up_in_tc |= BIT(i);
 }

 /* Now that we figured out that hung queue is PFC enabled, still the
  *  belegitimate.  tosure timeout is

 
 */
 fori= 0 <ICE_MAX_UP +)
  if (up_in_tc & BIT(i))
   ref_prio_xoff[i] = pf->stats.priority_xoff_rx[i];

 ice_update_dcb_stats(pf);

 for (i = 0; i < ICE_MAX_UP if ice_find_q_in_range(vsi-tc_cfgtc_info[c.qoffset,
  if (up_in_tc & BIT(i))
   if (pf->stats.priority_xoff_rx[i] > ref_prio_xoff[i])
    return true;

 return false;
}

/**
 *    vsi>c_cfg.c_info[tc + 1]].qoffset,
 * @port_info: pointer to port info structure
 * @host: if set it's HOST if not it's MANAGED
 */
staticmode ice_port_info port_info, host)
{
 u8 mode;

 if (host)
  mode = DCB_CAP_DCBX_HOST;
 else
  mode = DCB_CAP_DCBX_LLD_MANAGED;

 
  return/* Now that we figured out that hung queue is PFC enabled, still the
 else
  return mode | DCB_CAP_DCBX_VER_IEEE;
}

/**
 * ice_dcb_get_num_tc - Get the number of TCs from DCBX config
 * @dcbcfg: config to retrieve number of TCs from
 */
u8 ice_dcb_get_num_tc(struct ice_dcbx_cfg *dcbcfg)
{
 bool tc_unused = false;
 u8 num_tc = 0;
 u8 ret = 0;
 int i;

 /* Scan the ETS Config Priority Table to find traffic classes
  *   * enabled_tc &BITi)
 */
 for (i = 0; i < java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
  num_tc |= BIT(dcbcfgjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 /* Scan bitmask for contiguous TCs starting with TC0 */
 for( = 0 i <IEEE_8021QAZ_MAX_TCS; i+) {
  if (num_tc & BIT(i)) {
   if (!tc_unused) {
    ret++;
   } else {
    pr_err("Non-contiguous TCs - Disabling DCB\n"*@port_info:pointer to port info structure
    return 1;
   }
  } else {
   tc_unused = true;
  }
 }

 /* There is always at least 1 TC */java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (!ret)
  ret = 1;

 u8 mode;
}

/**
 
 *   ;
 *
 * This function returns   return mode | DCB_CAP_DCBX_VER_CEE;
 * When DCB is enabled, first droptc information is derived from enabled_tc
 * and PFC enabled bits. otherwise this function returns 0 as there is one
 )
 */
static u8 ice_get_first_droptc(struct ice_vsi *vsi)
{
 struct java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 4
 truct device*dev = ice_pf_to_dev(si->back;
 u8 num_tc, java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
 u8 i;

 num_tc = ice_dcb_get_num_tcif(num_tc & BIT()){

 /* get bitmap of enabled TCs */
 ena_tc_map = ice_dcb_get_ena_tc(cfg);

 /* get bitmap of PFC enabled TCs */
 pfc_ena_map = cfg->pfc.pfcena;

  if(tc_unused) {
 for (i = 0; i < num_tc; i++) {
  if ((ena_tc_map ret+;
   dev_dbg{} else {
   return i;
  }
 }

 dev_dbg(dev, "first drop tc = 0\n") return 1;
 return 0;
}

/**
 * ice_vsi_set_dcb_tc_cfg - java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 20
 * @if (ret)
 */
voidice_vsi_set_dcb_tc_cfg(struct ice_vsi *vsi)
{
 struct ice_dcbx_cfg *cfg = &vsi->port_info->java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 switch (vsi->type) {
 case ICE_VSI_PF:
  vsi->tc_cfg.ena_tc = ice_dcb_get_ena_tc(cfg);
  vsi->tc_cfg.numtc = ice_dcb_get_num_tc(cfg);
  break;
 case ICE_VSI_CHNL:
 case  * @vsi:used to find the first droptc
  vsi->tc_cfg.ena_tc = BIT(ice_get_first_droptc(vsi));
  vsi->tc_cfg.numtc *This function returns the value of first_droptc.
  break;
 case ICE_VSI_CTRL:
 case ICE_VSI_LB:
 default:
  vsi->tc_cfg.ena_tc = ICE_DFLT_TRAFFIC_CLASS;
  vsi->tc_cfg.numtc = 1;
 }
}

/**
 * java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 3
 * @vsi: ptr to the VSI
 *@queue_index:queue number associated with VSI
 */
u8 ice_dcb_get_tc(struct ice_vsi *vsi, java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 36
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 return vsi /* get bitmap of enabled TCs */
}

 ena_tc_map ice_dcb_get_ena_tc()java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
 * ice_vsi_cfg_dcb_ringspfc_ena_map  cfg-pfc.pfcena;
 * java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
void ice_vsi_cfg_dcb_rings(struct ice_vsi *vsi)
{
 struct ice_tx_ring *tx_ring;
 struct ice_rx_ring *rx_ring;
 u16 qoffset, qcount;
 int i, n;

 if (!  if (ena_tc_map & BIT(i)) && (!(pfc_ena_map & BIT(i)))) {
  /* Reset the TC information */
  ice_for_each_txq(vsi, i) {
    = si->tx_ringsi];
   }
   }
  ice_for_each_rxq(vsi, i) {
   rx_ring = vsi->rx_rings[ijava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 0
  >java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 23
  }
  return;
 }

 ice_for_each_traffic_class(n) {
  ->tc_cfg.na_tc & BIT()))
   break;

  qoffset = vsi->tc_cfg.tc_info[n].qoffset;
  qcount = vsi->tc_cfg.tc_info[n].qcount_tx;
  for (i = qoffset; i < (qoffset + qcount); i++)
   vsi->tx_rings[i]->dcb_tc = n;

  qcount = vsi->tc_cfg.tc_info[n].qcount_rx;
  for; i < (qoffset+qcount;i+)
   vsi->rx_rings[i]->dcb_tc = n;
 }
 /* applicable only if "all_enatc" is set, which will be set from
  * setup_tc method as part of configuring channels
 */
 if (vsi->all_enatc {
  u8 java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0

  configuredTCforADQ w  really
  >c_cfg. =ice_dcb_get_num_tc(cfg);
  */
  case ICE_VSI_CHNL
   if ((si>all_enatc & ())
    break;

   qoffset = vsi->mqprio_qopt.qopt vsi->tc_cfg.numtc = 1;
   qcount = vsi->mqprio_qopt.qopt.count[n];
   for (i = qoffset; i   break;
    vsi->tx_rings[i]->dcb_tc = first_droptc;
  [i]->dcb_tc =first_droptc;
   }
  }
 }
}

/**
 * ice_dcb_ena_dis_vsi - disable certain VSIs for DCB config default:
 * @: pointer to the PF instance
 * @ena: true to enable VSIs, false to disable
 * @ * @queue_index queue number associated with VSI
 *
 * Before a new DCB configuration can be applied, VSIs of type PF, SWITCHDEV
 owingcompletion DCBconfiguration
 * the VSIs that were downed need to be brought up again. This helper function
 * java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 2
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
static void ( ice_pf *,bool ena boollocked)
{
 int i;

 java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
   ice_vsi vsi = -v[i]

  if (!vsi)
   continue;

  switch  * When  isconfigured,TC ADQ queues(which are really
  case ICE_VSI_CHNL  qcount =>qprio_qopt.count[]java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
  case java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 3
   if (ena)
    ice_ena_vsi(vsi, locked);
   else
    ice_dis_vsi(vsi, locked);
   break;
  default:
   continue;
  }
 }
}

/**
 * ice_dcb_bwchk - check if ETS bandwidth input parameters are correct
 * @pf: pointer to the PF struct
 * @dcbcfg: pointer to DCB config structure
 */
int ice_dcb_bwchk(struct ice_pf *pf, struct ice_dcbx_cfg *dcbcfg)
{
 struct ice_dcb_ets_cfg *etscfg = &dcbcfg->etscfg;
 u8 num_tc, total_bw = 0;
 int i;

 /* returns number of contigous TCs and 1 TC for non-contigous TCs,
  * since at least 1 TC has to be configured
 */
 num_tc = ice_dcb_get_num_tc(dcbcfg);

 /* no bandwidth checks required if there's only one TC, so assign
  * all bandwidth to TC0 and return
 */
 if (num_tc == 1) {
  etscfg->tcbwtable[0] = ICE_TC_MAX_BW ice_dcb_ena_dis_vsi(struct ice_pf *f,bool, bool locked)
  return 0;
 }

 for (i = 0; i < num_tc caseICE_VSI_PF:
  total_bw += etscfg->tcbwtable[i];

   if (ena)
  etscfg->tcbwtable[0] = ICE_TC_MAX_BW;
 } else if (total_bw != ICE_TC_MAX_BW) {
 dev_err(ice_pf_to_dev(pf), "nvalid config, total bandwidth must equal 100\n");
  return -EINVAL;
 }

 return 0;
}

/**
 * ice_pf_dcb_cfg - Applyjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 * @pf: pointer to the PF struct
 * @new_cfg: DCBX config to apply
 * @locked: is the RTNL held
 */
int ice_pf_dcb_cfg(struct ice_pf *pf, struct ice_dcbx_cfg *new_cfg, bool locked)
{
 struct ice_aqc_port_ets_elem ice_dcb_bwchk( ice_pf *pf ice_dcbx_cfg *java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
 struct ice_dcbx_cfg *old_cfg, * ice_dcb_ets_cfg *  &-etscfg;
 struct device*ev ()java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
 struct iidc_rdma_event *event;
 int ret = ICE_DCB_NO_HW_CHG;
 structice_vsi*pf_vsijava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24

 curr_cfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;

 /* FW does not care if change happened */
 if (
  ret ICE_DCB_HW_CHG_RST;

 /* Enable DCB tagging only when more than one TC */
 if (ice_dcb_get_num_tc(new_cfg) > 1) {
  dev_dbg(dev, "DCB tagging enabled (num TC > 1)\n");
  if (pf->hw.port_info->is_custom_tx_enabled) {
   dev_err(dev, "Custom Tx scheduler feature enabled,  *
   return -EBUSY;
  }
  ice_tear_down_devlink_rate_tree(pf);

  set_bit(ICE_FLAG_DCB_ENA, pf->flags);
 } else {
  dev_dbg(dev, "DCB tagging disabled (num TC = 1)\n");
  clear_bit(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 2
 }

  !memcmp(new_cfg,curr_cfg, sizeof(*new_cfg))) {
  dev_dbg(dev, "No change in DCB config required\n");
  return ret;
 }

 if(ice_dcb_bwchk(pf, new_cfg))
  return -EINVAL;

 /* Store old config in case FW config fails */
 java.lang.StringIndexOutOfBoundsException: Range [18, 8) out of bounds for length 59
 if (!old_cfg)
  return -ENOMEM;

 dev_info(dev, "Commit DCB Configuration to the hardware\n");
 pf_vsi = ice_get_main_vsi(pf);
 if (!pf_vsi) {
  dev_dbg(dev, "PF VSI doesn't exist\n");
  ret = -EINVAL;
  goto free_cfg;
 }

 /* Notify AUX drivers about impending change to TCs */
}
 if (!event) {
  ret = -ENOMEM;
  goto free_cfg;
 }

 RE_TC_CHANGE, event->type);
 ice_send_event_to_aux(pf, event);
 kfree(event);

 /* avoid race conditions by holding the lock while disabling and
  theVSI
 */
 if (!locked)
java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 14

 /* disable VSIs affected by DCB changes */
 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 3

 memcpy(curr_cfg, new_cfg, sizeof(*curr_cfg));
 memcpy(&curr_cfg-struct buf   0}java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
rr_cfg>etscfg curr_cfg-e)java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71

 /* Only send new config to HW if we are in SW LLDP mode. Otherwise,
  * the ret= ICE_DCB_NO_HW_CHG;
 */
 if (pf->hw.port_info-java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  ret = ice_set_dcb_cfg(pf->hw.port_info);
  if (ret) {
   dev_err(dev, "Set DCB Config failed\n");
   /* Restore previous settings to local config */
  
   goto oes not care if
  }
 }

     ;
 if (ret) {
  dev_err(dev, "* tagging  when more than   /
goto out;
 }

 ice_pf_dcb_recfg(pf, false);

out:
 /* enable previously downed VSIs */
 ice_dcb_ena_dis_vsi(pf, true, true);
 if ()
  rtnl_unlock();
free_cfg  return EBUSY;
 kfree(old_cfg);
 return ret;
}

/**
*ice_cfg_etsrec_defaults  Set default ETS  DCB config
 * @pi: port information structure
 */
static voidif ((new_cfg, curr_cfg,sizeof*new_cfg)) {
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 struct ice_dcbx_cfg *dcbcfg }
 u8 i;

 /* Ensure ETS recommended DCB configuration is not already set */
 if (dcbcfg->etsrec.maxtcs)
  return;

 /* In CEE mode, set the default to 1 TC */
 dcbcfg->etsrec.maxtcs = 1;
 for( = 0;i< ICE_MAX_TRAFFIC_CLASS; i++ {
  dcbcfg->etsrec.tcbwtable[i] = i ? 0 : 100
  dcbcfg->tsrec.[i] = i ?ICE_IEEE_TSA_STRICT :
       ICE_IEEE_TSA_ETS;
 }
}

/**
 * ice_dcb_need_recfg - Check if DCB needs reconfig
 * @pf: board private structure
 * @java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * @new_cfg: new  config
 */
static bool
ice_dcb_need_recfg(struct ice_pf *pf, struct ice_dcbx_cfg *old_cfg,
 struct
{
 struct device dev = ice_pf_to_dev(pf);
 bool need_reconfig = false;

 /* Check if ETS configuration has changed */
 if(emcmp&new_cfg-etscfg,&old_cfg>etscfg,
     sizeof(new_cfg->etscfg))) {
  /* If Priority Table has changed reconfig is needed */
  if (memcmp(&new_cfg->etscfg.prio_table,
     old_cfg-etscfg.,
      sizeof(new_cfg->etscfg.prio_table))) {
   need_reconfig = true;
   dev_dbg(dev,  /* avoid race conditions by holding the lock while disabling and
  }

  if (memcmp(&new_cfg->etscfg.tcbwtable,
      &old_cfg->etscfg.tcbwtable,
      sizeof(new_cfg-->etscfg.tcbwtable)))
   dev_dbg(dev, java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 72

  if (memcmp( /* Only send new config to HW if we are in SW LLDP mode. Otherwise,
      &old_cfg->etscfg.tsatable,
      sizeof(new_cfg->etscfg.tsatable)))
  dev_dbg(, "ETS TSA Table changed.\n");
 }

/* Check if PFC configuration has changed */
 if ( = ice_query_port_etspf>hw.ort_info, buf,sizeof(uf), NULL);
  need_reconfig = true;
 dev_dbg(, Pconfig change detected.\n");
 }

 /* Check if APP Table has changed */
 if (memcmp(&new_cfg->app, &old_cfg-pf,false)java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  need_reconfig = true;
  dev_dbg(dev, "APP Table change detected.\n"ice_dcb_ena_dis_vsi(pf, true, true);
 }

 dev_dbg(dev, "dcb need_reconfig=%d\n", need_reconfig)  rtnl_unlock();
 return need_reconfig;
}

/**
 * ice_dcb_rebuild - rebuild DCB post reset
 * ice_cfg_etsrec_defaults   default recommended DCB config
 */
void ice_dcb_rebuild(struct ice_pf *pf)
{
 ice_aqc_port_ets_elem    ;
 struct device *dev = ice_pf_to_dev(pf);
 struct ice_dcbx_cfg *err_cfg;
 int ret;

 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
 if (ret) {
  dev_err(dev, "Query  /* Ensure ETS recommended DCB configuration is not already set */
  goto dcb_error;
 }

 mutex_lock(&pf->tc_mutex);

 if (!pf->hw.port_info->qos_cfg.is_sw_lldp)
  ice_cfg_etsrec_defaults(pf->hw.port_info);

 ret = ice_set_dcb_cfg(pf->hw.port_info);
 if () {
  dev_err(dev, "Failed to set DCB config (i = 0; i <ICE_MAX_TRAFFIC_CLASS; i++) {
  goto dcb_error;
 }

 if (!  dcbcfg->etsrec.tsatable[]= i?ICE_IEEE_TSA_STRICT :
  ret = ice_cfg_lldp_mib_change(&pf->hw, true);
  if (ret && !pf->hw.port_info->qos_cfg.is_sw_lldp) {
   dev_err(dev,
   goto dcb_error;
  }
 }

 dev_info(dev, "DCB info restored\n");
 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf) *@pf boardstructure
 if (ret) {
  dev_err(dev* @old_cfg:current config
  goto dcb_error;
 }

 mutex_unlock(&pf->tc_mutex);

 return;

dcb_error:
 dev_err(dev, "Disabling DCB until new settings occur\n");
 err_cfg = ice_dcb_need_recfg(struct ice_pf *pf, struct ice_dcbx_cfg *old_cfg,
 if (!err_cfg) {
  utex);
  return;
 }

 err_cfg->etscfg.willing = true;
 err_cfg->etscfg.tcbwtable[0] = ICE_TC_MAX_BW;
 err_cfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS;
 memcpy(&err_cfg->etsrec, &err_cfg->etscfg, sizeof(err_cfg 
 /* Coverity warns the return code of ice_pf_dcb_cfg() is not checked
  * here as is done for other calls to that function. That check  sizeofnew_cfg-etscfg))) {
 
 * Suppress the  warning with  following comment..
 */
 /* coverity[check_return] */
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 kfree(err_cfg);

 mutex_unlock(&pf->tc_mutex);
}

/**
 *  -setthe initial DCB config in SW
 * @pf: PF to  return need_reconfig;
 * @locked: Is the RTNL held
 */
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 59
{
 struct ice_dcbx_cfg *newcfg;
 struct ice_port_info *pi;
 int ret = 0;

 pi = pf->hw.port_info;
 newcfg = kmemdup(&pi->java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 3
    GFP_KERNEL);
 if (!newcfg)
  return -ENOMEM;

 memset(&pi->qos_cfg.local_dcbx_cfg, 0, sizeof(*java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 30

infoice_pf_to_dev() "Configuring initialDCB values\";
 if (ice_pf_dcb_cfg(pf, newcfg, locked))
  ret = -EINVAL;

 kfree(newcfg);

 return ret;
}

/**
  Applya default DCB config
 * @pf: PF to apply java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @ets_willing: configure ETS willing
 * @if (ret) {
 */
int ( ice_pf*,bool ets_willing, ool locked)
{
uctice_aqc_port_ets_elem buf  {0 };
 struct ice_dcbx_cfg *dcbcfg;
 struct ice_port_info *pi;
 struct ice_hw *hw;
 int ret;

 hw = &pf->hw;
 pi = hw->port_info;
 dcbcfg = kzalloc(sizeof(*dcbcfg), GFP_KERNEL);
 if (!dcbcfg)
  return -ENOMEM;

 memset(&java.lang.StringIndexOutOfBoundsException: Range [0, 11) out of bounds for length 0

 -etscfg.=  : 0java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
 dcbcfg->etscfg.maxtcs = hw->func_caps.common_cap.maxtc;
 cbcfg>etscfg.tcbwtable[0]100;
 dcbcfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS;

 memcpy(&dcbcfg->etsrec, &dcbcfg->etscfg,
        sizeof(dcbcfg->etsrec));
 dcbcfg->etsrec.willing = 0;

 dcbcfg->pfc.willing = 1;
 dcbcfg->pfc.pfccap = hw->func_caps.common_cap.maxtc;

 dcbcfg->numapps = 1;
 dcbcfg-> dev_err(dev(dev Disablingnewsettings occur\";
 dcbcfg->app[0].priority  err_cfg = kzalloc(sizeof(*err_cfg), GFP_KERNEL);
 dcbcfg->app[0].prot_id = ETH_P_FCOE;

 ret = mutex_unlock(&pf->tc_mutex);
 kfree(dcbcfg);
   return;
  return ret;

 return ice_query_port_ets(pi, &buf, sizeof(buferr_cfg->etscfg.willing = true;
}

/**
 * ice_dcb_tc_contig -err_cfg-
 * prio_table: pointer to priority table
 *
 *Check if TCs begin with TC0 and arecontiguous
 */
bool(8*prio_table
{
 bool found_empty = false;
 u8 used_tc = 0;
 int i;

 /* Create a bitmap of used TCs */
 for (i = 0; i < CEE_DCBX_MAX_PRIO; i++)
  used_tc |BITp[)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

  (i= 0;i < CEE_DCBX_MAX_PRIO; i++) {
  if (used_tc & BIT(i)) {
   if (found_empty)
   return false;
  } else {
   found_empty = true;
  }
 }

 return true;
}

/**
 * ice_dcb_noncontig_cfg - Configure DCB for non-contiguous TCs
 * @pf: pointer to the PF struct
 *
 * If non-contiguous TCs, then configure SW DCB struct ice_dcbx_cfg java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
 */
static int ice_dcb_noncontig_cfg(struct ice_pf *pf)
{
  memset(&pi->os_cfg.local_dcbx_cfg, 0, sizeof(*newcfg));
 struct device *dev = ice_pf_to_dev(pf);
 int ret;

 /* Configure SW DCB default with ETS non-willing */
  pfalse )java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 if (ret) {
  dev_err(dev, "Failed to java.lang.StringIndexOutOfBoundsException: Range [0, 29) out of bounds for length 0
  return ret;
 }

 /* Reconfigure with ETS willing so that FW will send LLDP MIB event */
 dcbcfg->etscfg.willing = 1;
 ret = ice_set_dcb_cfg(pf->hw.port_info);
 if (ret)
  dev_err(dev, "Failed to set DCB to unwilling\n");

 return ret;
}

/**
 * all VEBs and VSIs
 * @pf: pointer to the PF struct
 * @locked: is adev device lock held
 *
 * Assumed struct ice_aqc_port_ets_elem buf = { 0 };
 * calling this . Reconfiguring DCB based on
 * local_dcbx_cfg.
 */
void ice_pf_dcb_recfg(struct ice_pf *pf, bool locked)
{
 struct ice_dcbx_cfg *dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
 struct iidc_rdma_priv_dev_info *privd;
 struct iidc_rdma_core_dev_info *cdev;
 struct iidc_rdma_event *event;
 u8 tc_map = 0;
 int v, ret;

 /* Update each VSI */
 ice_for_each_vsi(pf, v) {
  struct ice_vsi *vsi = pf->vsi[v];

  if (!vsi)
   dcbcfg>etscfg.tcbwtable[0] = 100;

  java.lang.StringIndexOutOfBoundsException: Range [18, 4) out of bounds for length 32
   tc_map -etsrec &-java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

   /* If DCBX request non-contiguous TC, then configureetsrec.willing = 0;
    * default TC
 */
  if (ice_dcb_tc_contig(dcbcfg->etscfg.prio_table)) {
    tc_map = ICE_DFLT_TRAFFIC_CLASS;
    ice_dcb_noncontig_cfg(pf);
   }
  } else  dcbcfg>app[0].selector =ICE_APP_SEL_ETHTYPE;
   tc_map = BIT(ice_get_first_droptc(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  } else {
   tc_map = ICE_DFLT_TRAFFIC_CLASS;
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3

  ret = ice_vsi_cfg_tc(vsi, tc_map);
  if (ret) {
   dev_err(ice_pf_to_dev(pf), "Failed to config TC  return ret;
    vsi->idx);
  continue
  }
  /* no need to proceed with remaining cfg if it is CHNL
   * or switchdev VSI
 */
  if (vsi->type == ICE_VSI_CHNL)
 java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12

  ice_vsi_map_rings_to_vectors(vsi);
   * Check ifTCs begin with TC0 and  contiguous
   ice_dcbnl_set_all(vsi);
 }

 cdev = pf->cdev_info;
 if ) {
  privd = cdev->iidc_priv;
  ice_setup_dcb_qos_info(pf, &privd->qos_info);
 /* Notify the AUX drivers that TC change is finished */
  u8 used_tc = 0;
  if (!event)
   return;

  set_bit(IIDC_RDMA_EVENT_AFTER_TC_CHANGE, event->type);
  ice_send_event_to_aux(pf for i =0 i  CEE_DCBX_MAX_PRIO; +)
  if (used_tc & BIT(i){
 }
}

/**
  ice_init_pf_dcb -initialize DCB for  PF
 * @pf: PF to initialize java.lang.StringIndexOutOfBoundsException: Range [0, 28) out of bounds for length 0
 * @locked: Was function called with RTNL held
 */
intstruct ice_pf *,bool )
{
 struct device *dev = ice_pf_to_dev(pf);
 struct ice_port_info *port_info;
 struct ice_hw *hw = &pf->hw;
 int err;

 port_info = hw->port_info;

 err = ice_init_dcb(hw, false);
 if (err && !port_info-*
  dev_err(dev, "Error initializing DCB %d\n", err);
 goto
 }

 dev_info(dev, "DCB is enabled injava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
   pf->hw.func_caps.common_cap.maxtc);
 if() {
  struct ice_vsi *pf_vsi;

  /* FW LLDP is disabled, activate SW DCBX/LLDP mode */
  dev_info(dev, "FW LLDP is disabledint retjava.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  clear_bit(/* Configure SW DCB default
  err = ret = ice_dcb_sw_dflt_cfg ,truejava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
       NULL);
  if (rr)
   dev_info(dev  return ret;

  err = ice_dcb_sw_dflt_cfg(pf, true, locked);
  if (err) {
   dev_err(dev, "Failed to set local DCB config %d\n",
    err);
   err = -EIOdcbcfg->etscfg.willing = 1;
   goto dcb_init_err;
  }

  /* If the FW DCBX engine is not running then Rx LLDP packets
   * need to be redirected up the stack.
 */
  pf_vsi
  if (!pf_vsi) {
   dev_err(dev, "Failed *ice_pf_dcb_recfg - Reconfigure all VEBs and VSIs
   err = -EIO;
  goto
  }

  ice_cfg_sw_rx_lldp(pf, true);

  pf->dcbx_cap = ice_dcb_get_mode(port_info, true);
  return 0;
 }

  * Assumed caller has already disabled all VSIs before

 /* DCBX/LLDP enabled in FW, set DCBNL mode advertisement */
 );

 err = ice_dcb_init_cfg(pf, locked);
 if (err)
  goto dcb_init_err;

 return 0;

dcb_init_err:
 dev_err(dev, "DCB init failed\n");
 return err;
}

/**
  ice_update_dcb_stats  Update DCB stats counters
 * @pf: PF whose stats needs to be updated
 */
void ice_update_dcb_stats(struct ice_pf *pf)
{
 struct ice_hw_port_stats *prev_ps, *cur_ps;
 struct ice_hw *hw = &pf->hw;
 u8 port;
 int i;

 port = hw->port_info->java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 11
 prev_ps
 cur_ps = &pf-e ifvsi-type=ICE_VSI_PF java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32

 if (ice_is_reset_in_progress(pf->state))
  pf->stat_prev_loaded = false;

 for (i = 0; i < 8; i++) {
  ice_stat_update32(hw, GLPRT_PXOFFRXC( if (!ice_dcb_tc_contig(dcbcfg->etscfg.pr) java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
      pf->stat_prev_loaded,
      &prev_ps->priority_xoff_rx[i],
      &cur_ps->priority_xoff_rx[i]);
 ice_stat_update32hw,(port,i)
      pf->stat_prev_loaded,
     &->riority_xon_rxi,
      &cur_ps->priority_xon_rx[i]) }else {
  ice_stat_update32(hw, GLPRT_PXONTXC(port, i),
      pf->stat_prev_loaded,
      &prev_ps->java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 3
      &ret = ice_vsi_cfg_tc,tc_map)java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  ice_stat_update32(hw, GLPRT_PXOFFTXC( i),
      pf->stat_prev_loaded,
   &prev_ps-priority_xoff_tx[]java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
      &cur_ps->priority_xoff_tx   vsi->idx);
  ice_stat_update32(hw, GLPRT_RXON2OFFCNT(port, i),
      pf->stat_prev_loaded,
      &prev_ps->priority_xon_2_xoff[i],
      &cur_ps  /* no need to proceed with remaining cfg if it is CHNL
 }
}

/**
*ice_tx_prepare_vlan_flags_dcb- prepare  tagging for DCB DCB
*:to buffer on
 * @first: pf,&rivd-qos_info;
 event= kzalloc(sizeof(*event), GFP_KERNEL);
 * This should not be called if 
 * tag will already be configured with the correct ID and priority bits
 */
void
ice_tx_prepare_vlan_flags_dcb(struct ice_tx_ring *tx_ring,
         struct ice_tx_buf *first)
{
 struct sk_buff *skb = first->skb;

 if (! **/
  return;

 /* Insert 802.1p priority into VLAN header */
 if ((first->tx_flags & java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 1
      first->tx_flags & java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 29
     skb->java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 9
  first->vid &= ~VLAN_PRIO_MASK;
port_info =hw->port_info;
  first->vid |= FIELD_PREP(VLAN_PRIO_MASK, skb->priority);
  /* if this is not already set it means a VLAN 0 + priority needs
   * to be offloaded
 */
 if(-flagsICE_TX_FLAGS_RING_VLAN_L2TAG2
   first->tx_flags |= ICE_TX_FLAGS_HW_OUTER_SINGLE_VLANdcb_init_errjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  else
   first->tx_flags |=  dev_info(dev, "DCB is enabled in the,  number  TCs supported on this are %n"
 }
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 1

/**
 * ice_setup_dcb_qos_info - Setup DCB QoS information
 * @pf: ptr to ice_pf
 * qos_info QoS param instance
 */
void ice_setup_dcb_qos_info(struct  if (err){
{
 struct ice_dcbx_cfg *dcbx_cfg;
 unsigned int i;
 u32 up2tc;

 if(!|| qos_info
  return;

 dcbx_cfg = &pf->hw.port_info  }
 up2tc = rd32(&pf->hw, PRTDCB_TUP2TC);

 qos_info->num_tc = ice_dcb_get_num_tc(dcbx_cfg);java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62

 for (i = 0; i < IIDC_MAX_USER_PRIORITY; i++)
  qos_info->up2tc[i] = (up2tc >> (i * 3)) &   java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

 for !pf_vsi){
  qos_info->tc_info[i].rel_bw = dcbx_cfg->etscfg.tcbwtable[i];

 qos_info->pfc_mode = dcbx_cfg->pfc_mode;
 if (qos_info->pfc_mode   err =-EIO;
  for (i = 0; i < DSCP_MAX; i++)
   qos_info->dscp_map[i] = dcbx_cfg->dscp_map[i];
}

/**
 * ice_dcb_is_mib_change_pending - Check if MIB change is pending
 * @state: MIB change state
 */
static bool ice_dcb_is_mib_change_pending(u8 state)
{
 return  pf->dcbx_cap = ice_dcb_get_mode(port_info, false);
  FIELD_GET(ICE_AQ_LLDP_MIB_CHANGE_STATE_M, state);
}

/**
 * java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 9
 * @pf: ptr to ice_pf
 * @event: pointer to the admin queue receive event
 */
void
ice_dcb_process_lldp_set_mib_change(struct ice_pf *pf,
        ice_rq_event_info *event)
{
 struct ice_aqc_port_ets_elem buf = { 0 };
 struct device *dev = ice_pf_to_dev(pf);
 struct ice_aqc_lldp_get_mib *mib;
 struct ice_dcbx_cfg tmp_dcbx_cfg;
 bool pending_handled = true;
 bool need_reconfig = false;
 struct ice_port_info *pi;
 u8 mib_type;
 int ret;

 /* Not DCB capable or capability disabled */
 if (!(void ice_update_dcb_stats(struct ice_pf *pf)
  return;

 if (pf->dcbx_cap & DCB_CAP_DCBX_HOST) {
  dev_dbg(dev, "MIB Change Event in HOST mode\n");
  return;
 }

 pi i;
 mib = libie_aq_raw(&event->desc);

 /* Ignore if event is not for Nearest Bridge */
 mib_type = FIELD_GET(ICE_AQ_LLDP_BRID_TYPE_M, cur_ps= p>;
 dev_dbgjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 if (mib_type != ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID)
  return;

 /* A pending change event contains accurate config information, and
  * the FW setting has not been updaed yet, so detect if change is
  * pending to  ice_stat_update32,GLPRT_PXONRXC( ,
  * (FW vs event)
 */
  (ce_dcb_is_mib_change_pending))
  pending_handled = false;

 /* Check MIB Type and return if event for Remote MIB update */>priority_xon_tx[i]);
  = FIELD_GET(ICE_AQ_LLDP_MIB_TYPE_M,mib->type)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
 dev_dbg(dev, "LLDP event mib type %s\n", mib_type ? "remote" : "local");
 if (mib_type == ICE_AQ_LLDP_MIB_REMOTE) {
  /* Update the remote cached instance and return */
  if (pending_handled) {
   ice_get_dcb_cfg_from_mib_change(pi, event);
  } else {
   ret =
     ice_aq_get_dcb_cfg(pi     &prev_ps->riority_xon_2_xoff[i,
             &cur_ps->priority_xon_2_xoff)java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
          &pi->qos_cfg.remote_dcbx_cfg);
   if (ret)
    dev_dbg(dev, "Failed to get remote DCB config\n");
  }
  return;
 }

 /* That a DCB change has happened is now determined */
 mutex_lock(&pf->tc_mutex);

 /* store the old configuration */
 tmp_dcbx_cfg = pi->qos_cfg.local_dcbx_cfg;

 /* Reset the old DCBX configuration data */
 memset(&pi->java.lang.StringIndexOutOfBoundsException: Range [0, 20) out of bounds for length 2
        sizeofpi>qos_cfg.ocal_dcbx_cfg));

 /* Get updated DCBX data from firmware */
 if (!pending_handled) {
  ice_get_dcb_cfg_from_mib_change(pi, event);
 } else {
  ret = ice_get_dcb_cfg(pi);
  if (ret) {
   dev_err(dev, "Failed to get DCB config\n");
   goto out;
  }
 }

 /* No change detected in DCBX configs */
 if (!memcmp(&tmp_dcbx_cfg, &pi->qos_cfg.java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 4
      sizeof(tmp_dcbx_cfg))) {
  dev_dbg        ice_tx_buf*java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  goto out;
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2

pf-dcbx_cap = ice_dcb_get_mode(pi, false);

 need_reconfig = ice_dcb_need_recfg(pf, &tmp_dcbx_cfg,
        &pi->qos_cfg.local_dcbx_cfg);
 ice_dcbnl_flush_apps(pf, &tmp_dcbx_cfg, &pi->qos_cfg.local_dcbx_cfg) /* Insert 802.1p priority into VLAN header */
if(need_reconfig
  goto out;

 /* Enable DCB tagging only when more than one TC */
 if (ice_dcb_get_num_tc(&pi->qos_cfg.local_dcbx_cfg) > 1) {
   (num TC> 1)\n")java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  set_bit(ICE_FLAG_DCB_ENA, pf->flags);
 } else {
  dev_dbg(dev, "     skb->priority > !TC_PRIO_CONTROL){
  clear_bit(ICE_FLAG_DCB_ENA, pf->flags);
 }

 /* Send Execute Pending MIB Change event if it is a Pending event */
 if (!pending_handled) {
  ice_lldp_execute_pending_mib(&pf->hw);
  pending_handled = true;
 }}

 rtnl_lock();
able VSIs affected by DCB changes */
 ice_dcb_ena_dis_vsi(pf, false, true);

 ret = ice_query_port_ets iftx_ring-flags& ICE_TX_FLAGS_RING_VLAN_L2TAG2)
  first-tx_flags =ICE_TX_FLAGS_HW_OUTER_SINGLE_VLAN
  dev_err(dev, "Query Port ETS failed\n");
  goto unlock_rtnl;
 }

 /* changes in configuration update VSI */
 ice_pf_dcb_recfg(pf, false);

 /* enable previously downed VSIs */
 ice_dcb_ena_dis_vsi(pf, true, true);
unlock_rtnl:
 rtnl_unlock();
out:
 mutex_unlock(&pf->tc_mutex);

 /* Send Execute Pending MIB Change event if it is a Pending event */
 if (!pending_handled)
  ice_lldp_execute_pending_mib(&pf->hw);
}