1 // SPDX-License-Identifier: GPL-2.0
2 /* Copyright (c) 2019, Intel Corporation. */
4 #include "ice_dcb_lib.h"
5 #include "ice_dcb_nl.h"
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
12 void ice_vsi_cfg_netdev_tc(struct ice_vsi *vsi, u8 ena_tc)
14 struct net_device *netdev = vsi->netdev;
15 struct ice_pf *pf = vsi->back;
16 struct ice_dcbx_cfg *dcbcfg;
24 netdev_reset_tc(netdev);
28 if (netdev_set_num_tc(netdev, vsi->tc_cfg.numtc))
31 dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
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);
40 for (i = 0; i < ICE_MAX_USER_PRIORITY; i++) {
41 u8 ets_tc = dcbcfg->etscfg.prio_table[i];
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);
50 * ice_dcb_get_ena_tc - return bitmap of enabled TCs
51 * @dcbcfg: DCB config to evaluate for enabled TCs
53 u8 ice_dcb_get_ena_tc(struct ice_dcbx_cfg *dcbcfg)
55 u8 i, num_tc, ena_tc = 1;
57 num_tc = ice_dcb_get_num_tc(dcbcfg);
59 for (i = 0; i < num_tc; i++)
66 * ice_is_pfc_causing_hung_q
67 * @pf: pointer to PF structure
68 * @txqueue: Tx queue which is supposedly hung queue
70 * find if PFC is causing the hung queue, if yes return true else false
72 bool ice_is_pfc_causing_hung_q(struct ice_pf *pf, unsigned int txqueue)
74 u8 num_tcs = 0, i, tc, up_mapped_tc, up_in_tc = 0;
75 u64 ref_prio_xoff[ICE_MAX_UP];
79 vsi = ice_get_main_vsi(pf);
83 ice_for_each_traffic_class(i)
84 if (vsi->tc_cfg.ena_tc & BIT(i))
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,
94 /* Build a bit map of all UPs associated to the suspect hung queue TC,
95 * so that we check for its counter increment.
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)
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
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];
113 ice_update_dcb_stats(pf);
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])
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
128 static u8 ice_dcb_get_mode(struct ice_port_info *port_info, bool host)
133 mode = DCB_CAP_DCBX_HOST;
135 mode = DCB_CAP_DCBX_LLD_MANAGED;
137 if (port_info->qos_cfg.local_dcbx_cfg.dcbx_mode & ICE_DCBX_MODE_CEE)
138 return mode | DCB_CAP_DCBX_VER_CEE;
140 return mode | DCB_CAP_DCBX_VER_IEEE;
144 * ice_dcb_get_num_tc - Get the number of TCs from DCBX config
145 * @dcbcfg: config to retrieve number of TCs from
147 u8 ice_dcb_get_num_tc(struct ice_dcbx_cfg *dcbcfg)
149 bool tc_unused = false;
154 /* Scan the ETS Config Priority Table to find traffic classes
155 * enabled and create a bitmask of enabled TCs
157 for (i = 0; i < CEE_DCBX_MAX_PRIO; i++)
158 num_tc |= BIT(dcbcfg->etscfg.prio_table[i]);
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)) {
166 pr_err("Non-contiguous TCs - Disabling DCB\n");
174 /* There is always at least 1 TC */
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
186 u8 ice_dcb_get_tc(struct ice_vsi *vsi, int queue_index)
188 return vsi->tx_rings[queue_index]->dcb_tc;
192 * ice_vsi_cfg_dcb_rings - Update rings to reflect DCB TC
193 * @vsi: VSI owner of rings being updated
195 void ice_vsi_cfg_dcb_rings(struct ice_vsi *vsi)
197 struct ice_ring *tx_ring, *rx_ring;
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];
207 for (i = 0; i < vsi->num_rxq; i++) {
208 rx_ring = vsi->rx_rings[i];
214 ice_for_each_traffic_class(n) {
215 if (!(vsi->tc_cfg.ena_tc & BIT(n)))
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];
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
234 int ice_dcb_bwchk(struct ice_pf *pf, struct ice_dcbx_cfg *dcbcfg)
236 struct ice_dcb_ets_cfg *etscfg = &dcbcfg->etscfg;
237 u8 num_tc, total_bw = 0;
240 /* returns number of contigous TCs and 1 TC for non-contigous TCs,
241 * since at least 1 TC has to be configured
243 num_tc = ice_dcb_get_num_tc(dcbcfg);
245 /* no bandwidth checks required if there's only one TC, so assign
246 * all bandwidth to TC0 and return
249 etscfg->tcbwtable[0] = ICE_TC_MAX_BW;
253 for (i = 0; i < num_tc; i++)
254 total_bw += etscfg->tcbwtable[i];
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");
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
272 int ice_pf_dcb_cfg(struct ice_pf *pf, struct ice_dcbx_cfg *new_cfg, bool locked)
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;
280 curr_cfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
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;
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);
291 dev_dbg(dev, "DCB tagging disabled (num TC = 1)\n");
292 clear_bit(ICE_FLAG_DCB_ENA, pf->flags);
295 if (!memcmp(new_cfg, curr_cfg, sizeof(*new_cfg))) {
296 dev_dbg(dev, "No change in DCB config required\n");
300 if (ice_dcb_bwchk(pf, new_cfg))
303 /* Store old config in case FW config fails */
304 old_cfg = kmemdup(curr_cfg, sizeof(*old_cfg), GFP_KERNEL);
308 dev_info(dev, "Commit DCB Configuration to the hardware\n");
309 pf_vsi = ice_get_main_vsi(pf);
311 dev_dbg(dev, "PF VSI doesn't exist\n");
316 /* avoid race conditions by holding the lock while disabling and
317 * re-enabling the VSI
321 ice_dis_vsi(pf_vsi, true);
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));
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.
330 if (pf->hw.port_info->qos_cfg.is_sw_lldp) {
331 ret = ice_set_dcb_cfg(pf->hw.port_info);
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));
340 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
342 dev_err(dev, "Query Port ETS failed\n");
346 ice_pf_dcb_recfg(pf);
349 ice_ena_vsi(pf_vsi, true);
358 * ice_cfg_etsrec_defaults - Set default ETS recommended DCB config
359 * @pi: port information structure
361 static void ice_cfg_etsrec_defaults(struct ice_port_info *pi)
363 struct ice_dcbx_cfg *dcbcfg = &pi->qos_cfg.local_dcbx_cfg;
366 /* Ensure ETS recommended DCB configuration is not already set */
367 if (dcbcfg->etsrec.maxtcs)
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 :
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
386 ice_dcb_need_recfg(struct ice_pf *pf, struct ice_dcbx_cfg *old_cfg,
387 struct ice_dcbx_cfg *new_cfg)
389 struct device *dev = ice_pf_to_dev(pf);
390 bool need_reconfig = false;
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");
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");
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");
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");
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");
426 dev_dbg(dev, "dcb need_reconfig=%d\n", need_reconfig);
427 return need_reconfig;
431 * ice_dcb_rebuild - rebuild DCB post reset
432 * @pf: physical function instance
434 void ice_dcb_rebuild(struct ice_pf *pf)
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;
441 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
443 dev_err(dev, "Query Port ETS failed\n");
447 mutex_lock(&pf->tc_mutex);
449 if (!pf->hw.port_info->qos_cfg.is_sw_lldp)
450 ice_cfg_etsrec_defaults(pf->hw.port_info);
452 ret = ice_set_dcb_cfg(pf->hw.port_info);
454 dev_err(dev, "Failed to set DCB config in rebuild\n");
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");
466 dev_info(dev, "DCB info restored\n");
467 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
469 dev_err(dev, "Query Port ETS failed\n");
473 mutex_unlock(&pf->tc_mutex);
478 dev_err(dev, "Disabling DCB until new settings occur\n");
479 err_cfg = kzalloc(sizeof(*err_cfg), GFP_KERNEL);
481 mutex_unlock(&pf->tc_mutex);
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...
494 /* coverity[check_return] */
495 ice_pf_dcb_cfg(pf, err_cfg, false);
498 mutex_unlock(&pf->tc_mutex);
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
506 static int ice_dcb_init_cfg(struct ice_pf *pf, bool locked)
508 struct ice_dcbx_cfg *newcfg;
509 struct ice_port_info *pi;
512 pi = pf->hw.port_info;
513 newcfg = kmemdup(&pi->qos_cfg.local_dcbx_cfg, sizeof(*newcfg),
518 memset(&pi->qos_cfg.local_dcbx_cfg, 0, sizeof(*newcfg));
520 dev_info(ice_pf_to_dev(pf), "Configuring initial DCB values\n");
521 if (ice_pf_dcb_cfg(pf, newcfg, locked))
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
535 static int ice_dcb_sw_dflt_cfg(struct ice_pf *pf, bool ets_willing, bool locked)
537 struct ice_aqc_port_ets_elem buf = { 0 };
538 struct ice_dcbx_cfg *dcbcfg;
539 struct ice_port_info *pi;
545 dcbcfg = kzalloc(sizeof(*dcbcfg), GFP_KERNEL);
549 memset(&pi->qos_cfg.local_dcbx_cfg, 0, sizeof(*dcbcfg));
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;
556 memcpy(&dcbcfg->etsrec, &dcbcfg->etscfg,
557 sizeof(dcbcfg->etsrec));
558 dcbcfg->etsrec.willing = 0;
560 dcbcfg->pfc.willing = 1;
561 dcbcfg->pfc.pfccap = hw->func_caps.common_cap.maxtc;
564 dcbcfg->app[0].selector = ICE_APP_SEL_ETHTYPE;
565 dcbcfg->app[0].priority = 3;
566 dcbcfg->app[0].prot_id = ICE_APP_PROT_ID_FCOE;
568 ret = ice_pf_dcb_cfg(pf, dcbcfg, locked);
573 return ice_query_port_ets(pi, &buf, sizeof(buf), NULL);
577 * ice_dcb_tc_contig - Check that TCs are contiguous
578 * @prio_table: pointer to priority table
580 * Check if TCs begin with TC0 and are contiguous
582 static bool ice_dcb_tc_contig(u8 *prio_table)
584 bool found_empty = false;
588 /* Create a bitmap of used TCs */
589 for (i = 0; i < CEE_DCBX_MAX_PRIO; i++)
590 used_tc |= BIT(prio_table[i]);
592 for (i = 0; i < CEE_DCBX_MAX_PRIO; i++) {
593 if (used_tc & BIT(i)) {
605 * ice_dcb_noncontig_cfg - Configure DCB for non-contiguous TCs
606 * @pf: pointer to the PF struct
608 * If non-contiguous TCs, then configure SW DCB with TC0 and ETS non-willing
610 static int ice_dcb_noncontig_cfg(struct ice_pf *pf)
612 struct ice_dcbx_cfg *dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
613 struct device *dev = ice_pf_to_dev(pf);
616 /* Configure SW DCB default with ETS non-willing */
617 ret = ice_dcb_sw_dflt_cfg(pf, false, true);
619 dev_err(dev, "Failed to set local DCB config %d\n", ret);
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);
627 dev_err(dev, "Failed to set DCB to unwilling\n");
633 * ice_pf_dcb_recfg - Reconfigure all VEBs and VSIs
634 * @pf: pointer to the PF struct
636 * Assumed caller has already disabled all VSIs before
637 * calling this function. Reconfiguring DCB based on
640 void ice_pf_dcb_recfg(struct ice_pf *pf)
642 struct ice_dcbx_cfg *dcbcfg = &pf->hw.port_info->qos_cfg.local_dcbx_cfg;
646 /* Update each VSI */
647 ice_for_each_vsi(pf, v) {
648 struct ice_vsi *vsi = pf->vsi[v];
653 if (vsi->type == ICE_VSI_PF) {
654 tc_map = ice_dcb_get_ena_tc(dcbcfg);
656 /* If DCBX request non-contiguous TC, then configure
659 if (!ice_dcb_tc_contig(dcbcfg->etscfg.prio_table)) {
660 tc_map = ICE_DFLT_TRAFFIC_CLASS;
661 ice_dcb_noncontig_cfg(pf);
664 tc_map = ICE_DFLT_TRAFFIC_CLASS;
667 ret = ice_vsi_cfg_tc(vsi, tc_map);
669 dev_err(ice_pf_to_dev(pf), "Failed to config TC for VSI index: %d\n",
674 ice_vsi_map_rings_to_vectors(vsi);
675 if (vsi->type == ICE_VSI_PF)
676 ice_dcbnl_set_all(vsi);
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
685 int ice_init_pf_dcb(struct ice_pf *pf, bool locked)
687 struct device *dev = ice_pf_to_dev(pf);
688 struct ice_port_info *port_info;
689 struct ice_hw *hw = &pf->hw;
692 port_info = hw->port_info;
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);
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);
703 struct ice_vsi *pf_vsi;
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);
710 dev_err(dev, "Failed to set local DCB config %d\n",
716 /* If the FW DCBX engine is not running then Rx LLDP packets
717 * need to be redirected up the stack.
719 pf_vsi = ice_get_main_vsi(pf);
721 dev_err(dev, "Failed to set local DCB config\n");
726 ice_cfg_sw_lldp(pf_vsi, false, true);
728 pf->dcbx_cap = ice_dcb_get_mode(port_info, true);
732 set_bit(ICE_FLAG_FW_LLDP_AGENT, pf->flags);
734 /* DCBX/LLDP enabled in FW, set DCBNL mode advertisement */
735 pf->dcbx_cap = ice_dcb_get_mode(port_info, false);
737 err = ice_dcb_init_cfg(pf, locked);
744 dev_err(dev, "DCB init failed\n");
749 * ice_update_dcb_stats - Update DCB stats counters
750 * @pf: PF whose stats needs to be updated
752 void ice_update_dcb_stats(struct ice_pf *pf)
754 struct ice_hw_port_stats *prev_ps, *cur_ps;
755 struct ice_hw *hw = &pf->hw;
759 port = hw->port_info->lport;
760 prev_ps = &pf->stats_prev;
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]);
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
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
796 ice_tx_prepare_vlan_flags_dcb(struct ice_ring *tx_ring,
797 struct ice_tx_buf *first)
799 struct sk_buff *skb = first->skb;
801 if (!test_bit(ICE_FLAG_DCB_ENA, tx_ring->vsi->back->flags))
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
814 first->tx_flags |= ICE_TX_FLAGS_HW_VLAN;
819 * ice_dcb_process_lldp_set_mib_change - Process MIB change
821 * @event: pointer to the admin queue receive event
824 ice_dcb_process_lldp_set_mib_change(struct ice_pf *pf,
825 struct ice_rq_event_info *event)
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;
837 /* Not DCB capable or capability disabled */
838 if (!(test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags)))
841 if (pf->dcbx_cap & DCB_CAP_DCBX_HOST) {
842 dev_dbg(dev, "MIB Change Event in HOST mode\n");
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)
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);
864 dev_err(dev, "Failed to get remote DCB config\n");
869 mutex_lock(&pf->tc_mutex);
871 /* store the old configuration */
872 tmp_dcbx_cfg = pf->hw.port_info->qos_cfg.local_dcbx_cfg;
874 /* Reset the old DCBX configuration data */
875 memset(&pi->qos_cfg.local_dcbx_cfg, 0,
876 sizeof(pi->qos_cfg.local_dcbx_cfg));
878 /* Get updated DCBX data from firmware */
879 ret = ice_get_dcb_cfg(pf->hw.port_info);
881 dev_err(dev, "Failed to get DCB config\n");
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");
892 pf->dcbx_cap = ice_dcb_get_mode(pi, false);
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);
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);
905 dev_dbg(dev, "DCB tagging disabled (num TC = 1)\n");
906 clear_bit(ICE_FLAG_DCB_ENA, pf->flags);
909 pf_vsi = ice_get_main_vsi(pf);
911 dev_dbg(dev, "PF VSI doesn't exist\n");
916 ice_dis_vsi(pf_vsi, true);
918 ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);
920 dev_err(dev, "Query Port ETS failed\n");
924 /* changes in configuration update VSI */
925 ice_pf_dcb_recfg(pf);
927 ice_ena_vsi(pf_vsi, true);
931 mutex_unlock(&pf->tc_mutex);