Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 884714ce authored by David S. Miller's avatar David S. Miller
Browse files

Merge branch '100GbE' of git://git.kernel.org/pub/scm/linux/kernel/git/jkirsher/next-queue 



Jeff Kirsher says:

====================
100GbE Intel Wired LAN Driver Updates 2019-05-23

This series contains updates to ice driver only.

Anirudh cleans up white space issues and other code formatting issues in the
driver.  Also implemented LLDP persistence across reboots and start/stop of the
LLDP agent.  Updated print statements for driver capabilities to include
if it is a device or function capability.

Bruce cleaned up variable declarations by removing unneeded assignment.

Dave fixes a potential hang due to a couple of flows that recursively
acquire the RTNL lock which results in a deadlock.

Tony updates the driver to advertise what link modes we are capable of
when the user does not request a specific link mode.

Usha fixes up the LLDP MIB change event handling by cleaning up
workarounds and print the DCB configuration changes detected.

Brett fixes the driver to handle failures in the VF reset path, which
was failing to free resources upon an error.

Richard fixed the reported of stats via ethtool to align with our other
Intel drivers.

Jesse optimizes the transmit buffer and ring structures to have more
efficient ordering to get hot cache lines to have packed data.  Also
optimized the VF structure to use less memory, since it is used hundreds
of times throughout the driver.
====================

Signed-off-by: default avatarDavid S. Miller <davem@davemloft.net>
parents 9395da4e feee3cb3

drivers/net/ethernet/intel/ice/ice.h

+6 −7
Original line number Diff line number Diff line
@@ -277,10 +277,10 @@ struct ice_vsi { 
	struct list_head tmp_sync_list;		/* MAC filters to be synced */

	struct list_head tmp_unsync_list;	/* MAC filters to be unsynced */



	u8 irqs_ready;

	u8 current_isup;		 /* Sync 'link up' logging */

	u8 stat_offsets_loaded;

	u8 vlan_ena;

	u8 irqs_ready:1;

	u8 current_isup:1;		 /* Sync 'link up' logging */

	u8 stat_offsets_loaded:1;

	u8 vlan_ena:1;



	/* queue information */

	u8 tx_mapping_mode;		 /* ICE_MAP_MODE_[CONTIG|SCATTER] */
@@ -330,7 +330,7 @@ enum ice_pf_flags { 
	ICE_FLAG_DCB_CAPABLE,

	ICE_FLAG_DCB_ENA,

	ICE_FLAG_LINK_DOWN_ON_CLOSE_ENA,

	ICE_FLAG_DISABLE_FW_LLDP,

	ICE_FLAG_ENABLE_FW_LLDP,

	ICE_FLAG_ETHTOOL_CTXT,		/* set when ethtool holds RTNL lock */

	ICE_PF_FLAGS_NBITS		/* must be last */

};
@@ -384,7 +384,7 @@ struct ice_pf { 
	struct ice_hw_port_stats stats;

	struct ice_hw_port_stats stats_prev;

	struct ice_hw hw;

	u8 stat_prev_loaded;	/* has previous stats been loaded */

	u8 stat_prev_loaded:1; /* has previous stats been loaded */

#ifdef CONFIG_DCB

	u16 dcbx_cap;

#endif /* CONFIG_DCB */
@@ -451,7 +451,6 @@ int ice_set_rss(struct ice_vsi *vsi, u8 *seed, u8 *lut, u16 lut_size); 
int ice_get_rss(struct ice_vsi *vsi, u8 *seed, u8 *lut, u16 lut_size);

void ice_fill_rss_lut(u8 *lut, u16 rss_table_size, u16 rss_size);

void ice_print_link_msg(struct ice_vsi *vsi, bool isup);

void ice_napi_del(struct ice_vsi *vsi);

#ifdef CONFIG_DCB

int ice_pf_ena_all_vsi(struct ice_pf *pf, bool locked);

void ice_pf_dis_all_vsi(struct ice_pf *pf, bool locked);

drivers/net/ethernet/intel/ice/ice_common.c

+30 −26
Original line number Diff line number Diff line
@@ -1447,6 +1447,7 @@ ice_parse_caps(struct ice_hw *hw, void *buf, u32 cap_count, 
	struct ice_hw_func_caps *func_p = NULL;

	struct ice_hw_dev_caps *dev_p = NULL;

	struct ice_hw_common_caps *caps;

	char const *prefix;

	u32 i;



	if (!buf)
@@ -1457,9 +1458,11 @@ ice_parse_caps(struct ice_hw *hw, void *buf, u32 cap_count, 
	if (opc == ice_aqc_opc_list_dev_caps) {

		dev_p = &hw->dev_caps;

		caps = &dev_p->common_cap;

		prefix = "dev cap";

	} else if (opc == ice_aqc_opc_list_func_caps) {

		func_p = &hw->func_caps;

		caps = &func_p->common_cap;

		prefix = "func cap";

	} else {

		ice_debug(hw, ICE_DBG_INIT, "wrong opcode\n");

		return;
@@ -1475,28 +1478,29 @@ ice_parse_caps(struct ice_hw *hw, void *buf, u32 cap_count, 
		case ICE_AQC_CAPS_VALID_FUNCTIONS:

			caps->valid_functions = number;

			ice_debug(hw, ICE_DBG_INIT,

				  "HW caps: Valid Functions = %d\n",

				  "%s: valid functions = %d\n", prefix,

				  caps->valid_functions);

			break;

		case ICE_AQC_CAPS_SRIOV:

			caps->sr_iov_1_1 = (number == 1);

			ice_debug(hw, ICE_DBG_INIT,

				  "HW caps: SR-IOV = %d\n", caps->sr_iov_1_1);

				  "%s: SR-IOV = %d\n", prefix,

				  caps->sr_iov_1_1);

			break;

		case ICE_AQC_CAPS_VF:

			if (dev_p) {

				dev_p->num_vfs_exposed = number;

				ice_debug(hw, ICE_DBG_INIT,

					  "HW caps: VFs exposed = %d\n",

					  "%s: VFs exposed = %d\n", prefix,

					  dev_p->num_vfs_exposed);

			} else if (func_p) {

				func_p->num_allocd_vfs = number;

				func_p->vf_base_id = logical_id;

				ice_debug(hw, ICE_DBG_INIT,

					  "HW caps: VFs allocated = %d\n",

					  "%s: VFs allocated = %d\n", prefix,

					  func_p->num_allocd_vfs);

				ice_debug(hw, ICE_DBG_INIT,

					  "HW caps: VF base_id = %d\n",

					  "%s: VF base_id = %d\n", prefix,

					  func_p->vf_base_id);

			}

			break;
@@ -1504,69 +1508,69 @@ ice_parse_caps(struct ice_hw *hw, void *buf, u32 cap_count, 
			if (dev_p) {

				dev_p->num_vsi_allocd_to_host = number;

				ice_debug(hw, ICE_DBG_INIT,

					  "HW caps: Dev.VSI cnt = %d\n",

					  "%s: num VSI alloc to host = %d\n",

					  prefix,

					  dev_p->num_vsi_allocd_to_host);

			} else if (func_p) {

				func_p->guar_num_vsi =

					ice_get_num_per_func(hw, ICE_MAX_VSI);

				ice_debug(hw, ICE_DBG_INIT,

					  "HW caps: Func.VSI cnt = %d\n",

					  number);

					  "%s: num guaranteed VSI (fw) = %d\n",

					  prefix, number);

				ice_debug(hw, ICE_DBG_INIT,

					  "%s: num guaranteed VSI = %d\n",

					  prefix, func_p->guar_num_vsi);

			}

			break;

		case ICE_AQC_CAPS_RSS:

			caps->rss_table_size = number;

			caps->rss_table_entry_width = logical_id;

			ice_debug(hw, ICE_DBG_INIT,

				  "HW caps: RSS table size = %d\n",

				  "%s: RSS table size = %d\n", prefix,

				  caps->rss_table_size);

			ice_debug(hw, ICE_DBG_INIT,

				  "HW caps: RSS table width = %d\n",

				  "%s: RSS table width = %d\n", prefix,

				  caps->rss_table_entry_width);

			break;

		case ICE_AQC_CAPS_RXQS:

			caps->num_rxq = number;

			caps->rxq_first_id = phys_id;

			ice_debug(hw, ICE_DBG_INIT,

				  "HW caps: Num Rx Qs = %d\n", caps->num_rxq);

				  "%s: num Rx queues = %d\n", prefix,

				  caps->num_rxq);

			ice_debug(hw, ICE_DBG_INIT,

				  "HW caps: Rx first queue ID = %d\n",

				  "%s: Rx first queue ID = %d\n", prefix,

				  caps->rxq_first_id);

			break;

		case ICE_AQC_CAPS_TXQS:

			caps->num_txq = number;

			caps->txq_first_id = phys_id;

			ice_debug(hw, ICE_DBG_INIT,

				  "HW caps: Num Tx Qs = %d\n", caps->num_txq);

				  "%s: num Tx queues = %d\n", prefix,

				  caps->num_txq);

			ice_debug(hw, ICE_DBG_INIT,

				  "HW caps: Tx first queue ID = %d\n",

				  "%s: Tx first queue ID = %d\n", prefix,

				  caps->txq_first_id);

			break;

		case ICE_AQC_CAPS_MSIX:

			caps->num_msix_vectors = number;

			caps->msix_vector_first_id = phys_id;

			ice_debug(hw, ICE_DBG_INIT,

				  "HW caps: MSIX vector count = %d\n",

				  "%s: MSIX vector count = %d\n", prefix,

				  caps->num_msix_vectors);

			ice_debug(hw, ICE_DBG_INIT,

				  "HW caps: MSIX first vector index = %d\n",

				  "%s: MSIX first vector index = %d\n", prefix,

				  caps->msix_vector_first_id);

			break;

		case ICE_AQC_CAPS_MAX_MTU:

			caps->max_mtu = number;

			if (dev_p)

				ice_debug(hw, ICE_DBG_INIT,

					  "HW caps: Dev.MaxMTU = %d\n",

					  caps->max_mtu);

			else if (func_p)

				ice_debug(hw, ICE_DBG_INIT,

					  "HW caps: func.MaxMTU = %d\n",

					  caps->max_mtu);

			ice_debug(hw, ICE_DBG_INIT, "%s: max MTU = %d\n",

				  prefix, caps->max_mtu);

			break;

		default:

			ice_debug(hw, ICE_DBG_INIT,

				  "HW caps: Unknown capability[%d]: 0x%x\n", i,

				  cap);

				  "%s: unknown capability[%d]: 0x%x\n", prefix,

				  i, cap);

			break;

		}

	}

drivers/net/ethernet/intel/ice/ice_dcb.c

+16 −5
Original line number Diff line number Diff line
@@ -82,12 +82,14 @@ ice_aq_cfg_lldp_mib_change(struct ice_hw *hw, bool ena_update, 
 * @hw: pointer to the HW struct

 * @shutdown_lldp_agent: True if LLDP Agent needs to be Shutdown

 *			 False if LLDP Agent needs to be Stopped

 * @persist: True if Stop/Shutdown of LLDP Agent needs to be persistent across

 *	     reboots

 * @cd: pointer to command details structure or NULL

 *

 * Stop or Shutdown the embedded LLDP Agent (0x0A05)

 */

enum ice_status

ice_aq_stop_lldp(struct ice_hw *hw, bool shutdown_lldp_agent,

ice_aq_stop_lldp(struct ice_hw *hw, bool shutdown_lldp_agent, bool persist,

		 struct ice_sq_cd *cd)

{

	struct ice_aqc_lldp_stop *cmd;
@@ -100,17 +102,22 @@ ice_aq_stop_lldp(struct ice_hw *hw, bool shutdown_lldp_agent, 
	if (shutdown_lldp_agent)

		cmd->command |= ICE_AQ_LLDP_AGENT_SHUTDOWN;



	if (persist)

		cmd->command |= ICE_AQ_LLDP_AGENT_PERSIST_DIS;



	return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);

}



/**

 * ice_aq_start_lldp

 * @hw: pointer to the HW struct

 * @persist: True if Start of LLDP Agent needs to be persistent across reboots

 * @cd: pointer to command details structure or NULL

 *

 * Start the embedded LLDP Agent on all ports. (0x0A06)

 */

enum ice_status ice_aq_start_lldp(struct ice_hw *hw, struct ice_sq_cd *cd)

enum ice_status

ice_aq_start_lldp(struct ice_hw *hw, bool persist, struct ice_sq_cd *cd)

{

	struct ice_aqc_lldp_start *cmd;

	struct ice_aq_desc desc;
@@ -121,6 +128,9 @@ enum ice_status ice_aq_start_lldp(struct ice_hw *hw, struct ice_sq_cd *cd) 


	cmd->command = ICE_AQ_LLDP_AGENT_START;



	if (persist)

		cmd->command |= ICE_AQ_LLDP_AGENT_PERSIST_ENA;



	return ice_aq_send_cmd(hw, &desc, NULL, 0, cd);

}
@@ -163,7 +173,7 @@ ice_aq_set_lldp_mib(struct ice_hw *hw, u8 mib_type, void *buf, u16 buf_size, 
 *

 * Get the DCBX status from the Firmware

 */

u8 ice_get_dcbx_status(struct ice_hw *hw)

static u8 ice_get_dcbx_status(struct ice_hw *hw)

{

	u32 reg;
@@ -614,7 +624,8 @@ ice_parse_org_tlv(struct ice_lldp_org_tlv *tlv, struct ice_dcbx_cfg *dcbcfg) 
 *

 * Parse DCB configuration from the LLDPDU

 */

enum ice_status ice_lldp_to_dcb_cfg(u8 *lldpmib, struct ice_dcbx_cfg *dcbcfg)

static enum ice_status

ice_lldp_to_dcb_cfg(u8 *lldpmib, struct ice_dcbx_cfg *dcbcfg)

{

	struct ice_lldp_org_tlv *tlv;

	enum ice_status ret = 0;
@@ -664,7 +675,7 @@ enum ice_status ice_lldp_to_dcb_cfg(u8 *lldpmib, struct ice_dcbx_cfg *dcbcfg) 
 *

 * Query DCB configuration from the firmware

 */

static enum ice_status

enum ice_status

ice_aq_get_dcb_cfg(struct ice_hw *hw, u8 mib_type, u8 bridgetype,

		   struct ice_dcbx_cfg *dcbcfg)

{

drivers/net/ethernet/intel/ice/ice_dcb.h

+8 −4
Original line number Diff line number Diff line
@@ -120,8 +120,9 @@ struct ice_cee_app_prio { 
	u8 prio_map;

} __packed;



u8 ice_get_dcbx_status(struct ice_hw *hw);

enum ice_status ice_lldp_to_dcb_cfg(u8 *lldpmib, struct ice_dcbx_cfg *dcbcfg);

enum ice_status

ice_aq_get_dcb_cfg(struct ice_hw *hw, u8 mib_type, u8 bridgetype,

		   struct ice_dcbx_cfg *dcbcfg);

enum ice_status ice_get_dcb_cfg(struct ice_port_info *pi);

enum ice_status ice_set_dcb_cfg(struct ice_port_info *pi);

enum ice_status ice_init_dcb(struct ice_hw *hw);
@@ -131,9 +132,10 @@ ice_query_port_ets(struct ice_port_info *pi, 
		   struct ice_sq_cd *cmd_details);

#ifdef CONFIG_DCB

enum ice_status

ice_aq_stop_lldp(struct ice_hw *hw, bool shutdown_lldp_agent,

ice_aq_stop_lldp(struct ice_hw *hw, bool shutdown_lldp_agent, bool persist,

		 struct ice_sq_cd *cd);

enum ice_status ice_aq_start_lldp(struct ice_hw *hw, struct ice_sq_cd *cd);

enum ice_status

ice_aq_start_lldp(struct ice_hw *hw, bool persist, struct ice_sq_cd *cd);

enum ice_status

ice_aq_start_stop_dcbx(struct ice_hw *hw, bool start_dcbx_agent,

		       bool *dcbx_agent_status, struct ice_sq_cd *cd);
@@ -144,6 +146,7 @@ ice_aq_cfg_lldp_mib_change(struct ice_hw *hw, bool ena_update, 
static inline enum ice_status

ice_aq_stop_lldp(struct ice_hw __always_unused *hw,

		 bool __always_unused shutdown_lldp_agent,

		 bool __always_unused persist,

		 struct ice_sq_cd __always_unused *cd)

{

	return 0;
@@ -151,6 +154,7 @@ ice_aq_stop_lldp(struct ice_hw __always_unused *hw, 


static inline enum ice_status

ice_aq_start_lldp(struct ice_hw __always_unused *hw,

		  bool __always_unused persist,

		  struct ice_sq_cd __always_unused *cd)

{

	return 0;

drivers/net/ethernet/intel/ice/ice_dcb_lib.c

+157 −55
Original line number Diff line number Diff line
@@ -133,8 +133,10 @@ static void ice_pf_dcb_recfg(struct ice_pf *pf) 
 * ice_pf_dcb_cfg - Apply new DCB configuration

 * @pf: pointer to the PF struct

 * @new_cfg: DCBX config to apply

 * @locked: is the RTNL held

 */

static int ice_pf_dcb_cfg(struct ice_pf *pf, struct ice_dcbx_cfg *new_cfg)

static

int ice_pf_dcb_cfg(struct ice_pf *pf, struct ice_dcbx_cfg *new_cfg, bool locked)

{

	struct ice_dcbx_cfg *old_cfg, *curr_cfg;

	struct ice_aqc_port_ets_elem buf = { 0 };
@@ -163,6 +165,7 @@ static int ice_pf_dcb_cfg(struct ice_pf *pf, struct ice_dcbx_cfg *new_cfg) 
	/* avoid race conditions by holding the lock while disabling and

	 * re-enabling the VSI

	 */

	if (!locked)

		rtnl_lock();

	ice_pf_dis_all_vsi(pf, true);
@@ -192,6 +195,7 @@ static int ice_pf_dcb_cfg(struct ice_pf *pf, struct ice_dcbx_cfg *new_cfg) 


out:

	ice_pf_ena_all_vsi(pf, true);

	if (!locked)

		rtnl_unlock();

	devm_kfree(&pf->pdev->dev, old_cfg);

	return ret;
@@ -271,15 +275,16 @@ void ice_dcb_rebuild(struct ice_pf *pf) 
	prev_cfg->etscfg.tcbwtable[0] = ICE_TC_MAX_BW;

	prev_cfg->etscfg.tsatable[0] = ICE_IEEE_TSA_ETS;

	memcpy(&prev_cfg->etsrec, &prev_cfg->etscfg, sizeof(prev_cfg->etsrec));

	ice_pf_dcb_cfg(pf, prev_cfg);

	ice_pf_dcb_cfg(pf, prev_cfg, false);

	devm_kfree(&pf->pdev->dev, prev_cfg);

}



/**

 * ice_dcb_init_cfg - set the initial DCB config in SW

 * @pf: pf to apply config to

 * @locked: Is the RTNL held

 */

static int ice_dcb_init_cfg(struct ice_pf *pf)

static int ice_dcb_init_cfg(struct ice_pf *pf, bool locked)

{

	struct ice_dcbx_cfg *newcfg;

	struct ice_port_info *pi;
@@ -294,7 +299,7 @@ static int ice_dcb_init_cfg(struct ice_pf *pf) 
	memset(&pi->local_dcbx_cfg, 0, sizeof(*newcfg));



	dev_info(&pf->pdev->dev, "Configuring initial DCB values\n");

	if (ice_pf_dcb_cfg(pf, newcfg))

	if (ice_pf_dcb_cfg(pf, newcfg, locked))

		ret = -EINVAL;



	devm_kfree(&pf->pdev->dev, newcfg);
@@ -305,8 +310,9 @@ static int ice_dcb_init_cfg(struct ice_pf *pf) 
/**

 * ice_dcb_sw_default_config - Apply a default DCB config

 * @pf: pf to apply config to

 * @locked: was this function called with RTNL held

 */

static int ice_dcb_sw_dflt_cfg(struct ice_pf *pf)

static int ice_dcb_sw_dflt_cfg(struct ice_pf *pf, bool locked)

{

	struct ice_aqc_port_ets_elem buf = { 0 };

	struct ice_dcbx_cfg *dcbcfg;
@@ -338,7 +344,7 @@ static int ice_dcb_sw_dflt_cfg(struct ice_pf *pf) 
	dcbcfg->app[0].priority = 3;

	dcbcfg->app[0].prot_id = ICE_APP_PROT_ID_FCOE;



	ret = ice_pf_dcb_cfg(pf, dcbcfg);

	ret = ice_pf_dcb_cfg(pf, dcbcfg, locked);

	devm_kfree(&pf->pdev->dev, dcbcfg);

	if (ret)

		return ret;
@@ -349,8 +355,9 @@ static int ice_dcb_sw_dflt_cfg(struct ice_pf *pf) 
/**

 * ice_init_pf_dcb - initialize DCB for a PF

 * @pf: pf to initiialize DCB for

 * @locked: Was function called with RTNL held

 */

int ice_init_pf_dcb(struct ice_pf *pf)

int ice_init_pf_dcb(struct ice_pf *pf, bool locked)

{

	struct device *dev = &pf->pdev->dev;

	struct ice_port_info *port_info;
@@ -360,33 +367,10 @@ int ice_init_pf_dcb(struct ice_pf *pf) 


	port_info = hw->port_info;



	/* check if device is DCB capable */

	if (!hw->func_caps.common_cap.dcb) {

		dev_dbg(dev, "DCB not supported\n");

		return -EOPNOTSUPP;

	}



	/* Best effort to put DCBx and LLDP into a good state */

	port_info->dcbx_status = ice_get_dcbx_status(hw);

	if (port_info->dcbx_status != ICE_DCBX_STATUS_DONE &&

	    port_info->dcbx_status != ICE_DCBX_STATUS_IN_PROGRESS) {

		bool dcbx_status;



		/* Attempt to start LLDP engine. Ignore errors

		 * as this will error if it is already started

		 */

		ice_aq_start_lldp(hw, NULL);



		/* Attempt to start DCBX. Ignore errors as this

		 * will error if it is already started

		 */

		ice_aq_start_stop_dcbx(hw, true, &dcbx_status, NULL);

	}



	err = ice_init_dcb(hw);

	if (err) {

		/* FW LLDP not in usable state, default to SW DCBx/LLDP */

		dev_info(&pf->pdev->dev, "FW LLDP not in usable state\n");

		/* FW LLDP is not active, default to SW DCBx/LLDP */

		dev_info(&pf->pdev->dev, "FW LLDP is not active\n");

		hw->port_info->dcbx_status = ICE_DCBX_STATUS_NOT_STARTED;

		hw->port_info->is_sw_lldp = true;

	}
@@ -398,6 +382,9 @@ int ice_init_pf_dcb(struct ice_pf *pf) 
	if (port_info->is_sw_lldp) {

		sw_default = 1;

		dev_info(&pf->pdev->dev, "DCBx/LLDP in SW mode.\n");

		clear_bit(ICE_FLAG_ENABLE_FW_LLDP, pf->flags);

	} else {

		set_bit(ICE_FLAG_ENABLE_FW_LLDP, pf->flags);

	}



	if (port_info->dcbx_status == ICE_DCBX_STATUS_NOT_STARTED) {
@@ -406,7 +393,7 @@ int ice_init_pf_dcb(struct ice_pf *pf) 
	}



	if (sw_default) {

		err = ice_dcb_sw_dflt_cfg(pf);

		err = ice_dcb_sw_dflt_cfg(pf, locked);

		if (err) {

			dev_err(&pf->pdev->dev,

				"Failed to set local DCB config %d\n", err);
@@ -425,7 +412,7 @@ int ice_init_pf_dcb(struct ice_pf *pf) 


	set_bit(ICE_FLAG_DCB_CAPABLE, pf->flags);



	err = ice_dcb_init_cfg(pf);

	err = ice_dcb_init_cfg(pf, locked);

	if (err)

		goto dcb_init_err;
@@ -514,6 +501,55 @@ ice_tx_prepare_vlan_flags_dcb(struct ice_ring *tx_ring, 
	return 0;

}



/**

 * ice_dcb_need_recfg - Check if DCB needs reconfig

 * @pf: board private structure

 * @old_cfg: current DCB config

 * @new_cfg: new DCB config

 */

static bool ice_dcb_need_recfg(struct ice_pf *pf, struct ice_dcbx_cfg *old_cfg,

			       struct ice_dcbx_cfg *new_cfg)

{

	bool need_reconfig = false;



	/* Check if ETS configuration has changed */

	if (memcmp(&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.prio_table,

			   sizeof(new_cfg->etscfg.prio_table))) {

			need_reconfig = true;

			dev_dbg(&pf->pdev->dev, "ETS UP2TC changed.\n");

		}



		if (memcmp(&new_cfg->etscfg.tcbwtable,

			   &old_cfg->etscfg.tcbwtable,

			   sizeof(new_cfg->etscfg.tcbwtable)))

			dev_dbg(&pf->pdev->dev, "ETS TC BW Table changed.\n");



		if (memcmp(&new_cfg->etscfg.tsatable,

			   &old_cfg->etscfg.tsatable,

			   sizeof(new_cfg->etscfg.tsatable)))

			dev_dbg(&pf->pdev->dev, "ETS TSA Table changed.\n");

	}



	/* Check if PFC configuration has changed */

	if (memcmp(&new_cfg->pfc, &old_cfg->pfc, sizeof(new_cfg->pfc))) {

		need_reconfig = true;

		dev_dbg(&pf->pdev->dev, "PFC config change detected.\n");

	}



	/* Check if APP Table has changed */

	if (memcmp(&new_cfg->app, &old_cfg->app, sizeof(new_cfg->app))) {

		need_reconfig = true;

		dev_dbg(&pf->pdev->dev, "APP Table change detected.\n");

	}



	dev_dbg(&pf->pdev->dev, "dcb need_reconfig=%d\n", need_reconfig);

	return need_reconfig;

}



/**

 * ice_dcb_process_lldp_set_mib_change - Process MIB change

 * @pf: ptr to ice_pf
@@ -523,29 +559,95 @@ void 
ice_dcb_process_lldp_set_mib_change(struct ice_pf *pf,

				    struct ice_rq_event_info *event)

{

	if (pf->dcbx_cap & DCB_CAP_DCBX_LLD_MANAGED) {

		struct ice_dcbx_cfg *dcbcfg, *prev_cfg;

		int err;

	struct ice_aqc_port_ets_elem buf = { 0 };

	struct ice_aqc_lldp_get_mib *mib;

	struct ice_dcbx_cfg tmp_dcbx_cfg;

	bool need_reconfig = false;

	struct ice_port_info *pi;

	u8 type;

	int ret;



		prev_cfg = &pf->hw.port_info->local_dcbx_cfg;

		dcbcfg = devm_kmemdup(&pf->pdev->dev, prev_cfg,

				      sizeof(*dcbcfg), GFP_KERNEL);

		if (!dcbcfg)

	/* Not DCB capable or capability disabled */

	if (!(test_bit(ICE_FLAG_DCB_CAPABLE, pf->flags)))

		return;



		err = ice_lldp_to_dcb_cfg(event->msg_buf, dcbcfg);

		if (!err)

			ice_pf_dcb_cfg(pf, dcbcfg);

	if (pf->dcbx_cap & DCB_CAP_DCBX_HOST) {

		dev_dbg(&pf->pdev->dev,

			"MIB Change Event in HOST mode\n");

		return;

	}



		devm_kfree(&pf->pdev->dev, dcbcfg);

	pi = pf->hw.port_info;

	mib = (struct ice_aqc_lldp_get_mib *)&event->desc.params.raw;

	/* Ignore if event is not for Nearest Bridge */

	type = ((mib->type >> ICE_AQ_LLDP_BRID_TYPE_S) &

		ICE_AQ_LLDP_BRID_TYPE_M);

	dev_dbg(&pf->pdev->dev, "LLDP event MIB bridge type 0x%x\n", type);

	if (type != ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID)

		return;



	/* Check MIB Type and return if event for Remote MIB update */

	type = mib->type & ICE_AQ_LLDP_MIB_TYPE_M;

	dev_dbg(&pf->pdev->dev,

		"LLDP event mib type %s\n", type ? "remote" : "local");

	if (type == ICE_AQ_LLDP_MIB_REMOTE) {

		/* Update the remote cached instance and return */

		ret = ice_aq_get_dcb_cfg(pi->hw, ICE_AQ_LLDP_MIB_REMOTE,

					 ICE_AQ_LLDP_BRID_TYPE_NEAREST_BRID,

					 &pi->remote_dcbx_cfg);

		if (ret) {

			dev_err(&pf->pdev->dev, "Failed to get remote DCB config\n");

			return;

		}

	}



	/* store the old configuration */

	tmp_dcbx_cfg = pf->hw.port_info->local_dcbx_cfg;



	/* Reset the old DCBx configuration data */

	memset(&pi->local_dcbx_cfg, 0, sizeof(pi->local_dcbx_cfg));



	/* Get updated DCBx data from firmware */

		err = ice_get_dcb_cfg(pf->hw.port_info);

		if (err)

			dev_err(&pf->pdev->dev,

				"Failed to get DCB config\n");

	} else {

	ret = ice_get_dcb_cfg(pf->hw.port_info);

	if (ret) {

		dev_err(&pf->pdev->dev, "Failed to get DCB config\n");

		return;

	}



	/* No change detected in DCBX configs */

	if (!memcmp(&tmp_dcbx_cfg, &pi->local_dcbx_cfg, sizeof(tmp_dcbx_cfg))) {

		dev_dbg(&pf->pdev->dev,

			"MIB Change Event in HOST mode\n");

			"No change detected in DCBX configuration.\n");

		return;

	}



	need_reconfig = ice_dcb_need_recfg(pf, &tmp_dcbx_cfg,

					   &pi->local_dcbx_cfg);

	if (!need_reconfig)

		return;



	/* Enable DCB tagging only when more than one TC */

	if (ice_dcb_get_num_tc(&pi->local_dcbx_cfg) > 1) {

		dev_dbg(&pf->pdev->dev, "DCB tagging enabled (num TC > 1)\n");

		set_bit(ICE_FLAG_DCB_ENA, pf->flags);

	} else {

		dev_dbg(&pf->pdev->dev, "DCB tagging disabled (num TC = 1)\n");

		clear_bit(ICE_FLAG_DCB_ENA, pf->flags);

	}



	rtnl_lock();

	ice_pf_dis_all_vsi(pf, true);



	ret = ice_query_port_ets(pf->hw.port_info, &buf, sizeof(buf), NULL);

	if (ret) {

		dev_err(&pf->pdev->dev, "Query Port ETS failed\n");

		rtnl_unlock();

		return;

	}



	/* changes in configuration update VSI */

	ice_pf_dcb_recfg(pf);



	ice_pf_ena_all_vsi(pf, true);

	rtnl_unlock();

}