X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fbnx2x%2Fbnx2x.c;h=17b6817b612755cacc4a5b6d80521d6b18d9724f;hb=6d13ea8e8e49ab957deae2bba5ecf4a4bfe747d1;hp=93f8586b555e9c4cf85f0367231853826756bfa0;hpb=ba7eeb035a5f442414f9dca6c12a9105a16576aa;p=dpdk.git

diff --git a/drivers/net/bnx2x/bnx2x.c b/drivers/net/bnx2x/bnx2x.c
index 93f8586b55..17b6817b61 100644
--- a/drivers/net/bnx2x/bnx2x.c
+++ b/drivers/net/bnx2x/bnx2x.c
@@ -25,11 +25,12 @@
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <zlib.h>
+#include <rte_string_fns.h>
 
 #define BNX2X_PMD_VER_PREFIX "BNX2X PMD"
 #define BNX2X_PMD_VERSION_MAJOR 1
 #define BNX2X_PMD_VERSION_MINOR 0
-#define BNX2X_PMD_VERSION_REVISION 6
+#define BNX2X_PMD_VERSION_REVISION 7
 #define BNX2X_PMD_VERSION_PATCH 1
 
 static inline const char *
@@ -112,6 +113,7 @@ static void bnx2x_pf_disable(struct bnx2x_softc *sc);
 static void bnx2x_update_rx_prod(struct bnx2x_softc *sc,
 				 struct bnx2x_fastpath *fp,
 				 uint16_t rx_bd_prod, uint16_t rx_cq_prod);
+static void bnx2x_link_report_locked(struct bnx2x_softc *sc);
 static void bnx2x_link_report(struct bnx2x_softc *sc);
 void bnx2x_link_status_update(struct bnx2x_softc *sc);
 static int bnx2x_alloc_mem(struct bnx2x_softc *sc);
@@ -122,7 +124,7 @@ static __rte_noinline
 int bnx2x_nic_load(struct bnx2x_softc *sc);
 
 static int bnx2x_handle_sp_tq(struct bnx2x_softc *sc);
-static void bnx2x_handle_fp_tq(struct bnx2x_fastpath *fp, int scan_fp);
+static void bnx2x_handle_fp_tq(struct bnx2x_fastpath *fp);
 static void bnx2x_ack_sb(struct bnx2x_softc *sc, uint8_t igu_sb_id,
 			 uint8_t storm, uint16_t index, uint8_t op,
 			 uint8_t update);
@@ -183,6 +185,7 @@ bnx2x_dma_alloc(struct bnx2x_softc *sc, size_t size, struct bnx2x_dma *dma,
 	}
 	dma->paddr = (uint64_t) z->iova;
 	dma->vaddr = z->addr;
+	dma->mzone = (const void *)z;
 
 	PMD_DRV_LOG(DEBUG, sc,
 		    "%s: virt=%p phys=%" PRIx64, msg, dma->vaddr, dma->paddr);
@@ -190,6 +193,19 @@ bnx2x_dma_alloc(struct bnx2x_softc *sc, size_t size, struct bnx2x_dma *dma,
 	return 0;
 }
 
+void bnx2x_dma_free(struct bnx2x_dma *dma)
+{
+	if (dma->mzone == NULL)
+		return;
+
+	rte_memzone_free((const struct rte_memzone *)dma->mzone);
+	dma->sc = NULL;
+	dma->paddr = 0;
+	dma->vaddr = NULL;
+	dma->nseg = 0;
+	dma->mzone = NULL;
+}
+
 static int bnx2x_acquire_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
 {
 	uint32_t lock_status;
@@ -198,7 +214,12 @@ static int bnx2x_acquire_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
 	uint32_t hw_lock_control_reg;
 	int cnt;
 
+#ifndef RTE_LIBRTE_BNX2X_DEBUG_PERIODIC
+	if (resource)
+		PMD_INIT_FUNC_TRACE(sc);
+#else
 	PMD_INIT_FUNC_TRACE(sc);
+#endif
 
 	/* validate the resource is within range */
 	if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
@@ -234,7 +255,8 @@ static int bnx2x_acquire_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
 		DELAY(5000);
 	}
 
-	PMD_DRV_LOG(NOTICE, sc, "Resource lock timeout!");
+	PMD_DRV_LOG(NOTICE, sc, "Resource 0x%x resource_bit 0x%x lock timeout!",
+		    resource, resource_bit);
 	return -1;
 }
 
@@ -245,13 +267,18 @@ static int bnx2x_release_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
 	int func = SC_FUNC(sc);
 	uint32_t hw_lock_control_reg;
 
+#ifndef RTE_LIBRTE_BNX2X_DEBUG_PERIODIC
+	if (resource)
+		PMD_INIT_FUNC_TRACE(sc);
+#else
 	PMD_INIT_FUNC_TRACE(sc);
+#endif
 
 	/* validate the resource is within range */
 	if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
 		PMD_DRV_LOG(NOTICE, sc,
-			    "resource 0x%x > HW_LOCK_MAX_RESOURCE_VALUE",
-			    resource);
+			    "(resource 0x%x > HW_LOCK_MAX_RESOURCE_VALUE)"
+			    " resource_bit 0x%x", resource, resource_bit);
 		return -1;
 	}
 
@@ -275,6 +302,18 @@ static int bnx2x_release_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
 	return 0;
 }
 
+static void bnx2x_acquire_phy_lock(struct bnx2x_softc *sc)
+{
+	BNX2X_PHY_LOCK(sc);
+	bnx2x_acquire_hw_lock(sc, HW_LOCK_RESOURCE_MDIO);
+}
+
+static void bnx2x_release_phy_lock(struct bnx2x_softc *sc)
+{
+	bnx2x_release_hw_lock(sc, HW_LOCK_RESOURCE_MDIO);
+	BNX2X_PHY_UNLOCK(sc);
+}
+
 /* copy command into DMAE command memory and set DMAE command Go */
 void bnx2x_post_dmae(struct bnx2x_softc *sc, struct dmae_command *dmae, int idx)
 {
@@ -1075,6 +1114,12 @@ bnx2x_sp_post(struct bnx2x_softc *sc, int command, int cid, uint32_t data_hi,
 		    atomic_load_acq_long(&sc->cq_spq_left),
 		    atomic_load_acq_long(&sc->eq_spq_left));
 
+	/* RAMROD completion is processed in bnx2x_intr_legacy()
+	 * which can run from different contexts.
+	 * Ask bnx2x_intr_intr() to process RAMROD
+	 * completion whenever it gets scheduled.
+	 */
+	rte_atomic32_set(&sc->scan_fp, 1);
 	bnx2x_sp_prod_update(sc);
 
 	return 0;
@@ -2152,8 +2197,8 @@ int bnx2x_tx_encap(struct bnx2x_tx_queue *txq, struct rte_mbuf *m0)
 			tx_start_bd->vlan_or_ethertype =
 			    rte_cpu_to_le_16(pkt_prod);
 		else {
-			struct ether_hdr *eh =
-			    rte_pktmbuf_mtod(m0, struct ether_hdr *);
+			struct rte_ether_hdr *eh =
+			    rte_pktmbuf_mtod(m0, struct rte_ether_hdr *);
 
 			tx_start_bd->vlan_or_ethertype =
 			    rte_cpu_to_le_16(rte_be_to_cpu_16(eh->ether_type));
@@ -2163,8 +2208,8 @@ int bnx2x_tx_encap(struct bnx2x_tx_queue *txq, struct rte_mbuf *m0)
 	bd_prod = NEXT_TX_BD(bd_prod);
 	if (IS_VF(sc)) {
 		struct eth_tx_parse_bd_e2 *tx_parse_bd;
-		const struct ether_hdr *eh =
-		    rte_pktmbuf_mtod(m0, struct ether_hdr *);
+		const struct rte_ether_hdr *eh =
+		    rte_pktmbuf_mtod(m0, struct rte_ether_hdr *);
 		uint8_t mac_type = UNICAST_ADDRESS;
 
 		tx_parse_bd =
@@ -2411,6 +2456,7 @@ static int bnx2x_alloc_mem(struct bnx2x_softc *sc)
 
 static void bnx2x_free_fw_stats_mem(struct bnx2x_softc *sc)
 {
+	bnx2x_dma_free(&sc->fw_stats_dma);
 	sc->fw_stats_num = 0;
 
 	sc->fw_stats_req_size = 0;
@@ -2903,7 +2949,7 @@ static void bnx2x_link_attn(struct bnx2x_softc *sc)
 		}
 	}
 
-	bnx2x_link_report(sc);
+	bnx2x_link_report_locked(sc);
 
 	if (IS_MF(sc)) {
 		bnx2x_link_sync_notify(sc);
@@ -2942,6 +2988,7 @@ static void bnx2x_attn_int_asserted(struct bnx2x_softc *sc, uint32_t asserted)
 	if (asserted & ATTN_HARD_WIRED_MASK) {
 		if (asserted & ATTN_NIG_FOR_FUNC) {
 
+			bnx2x_acquire_phy_lock(sc);
 			/* save nig interrupt mask */
 			nig_mask = REG_RD(sc, nig_int_mask_addr);
 
@@ -3039,6 +3086,7 @@ static void bnx2x_attn_int_asserted(struct bnx2x_softc *sc, uint32_t asserted)
 
 		REG_WR(sc, nig_int_mask_addr, nig_mask);
 
+		bnx2x_release_phy_lock(sc);
 	}
 }
 
@@ -3838,8 +3886,10 @@ static void bnx2x_attn_int_deasserted3(struct bnx2x_softc *sc, uint32_t attn)
 			if (sc->link_vars.periodic_flags &
 			    ELINK_PERIODIC_FLAGS_LINK_EVENT) {
 				/* sync with link */
+				bnx2x_acquire_phy_lock(sc);
 				sc->link_vars.periodic_flags &=
 				    ~ELINK_PERIODIC_FLAGS_LINK_EVENT;
+				bnx2x_release_phy_lock(sc);
 				if (IS_MF(sc)) {
 					bnx2x_link_sync_notify(sc);
 				}
@@ -4029,7 +4079,9 @@ static void bnx2x_attn_int_deasserted0(struct bnx2x_softc *sc, uint32_t attn)
 	}
 
 	if ((attn & sc->link_vars.aeu_int_mask) && sc->port.pmf) {
+		bnx2x_acquire_phy_lock(sc);
 		elink_handle_module_detect_int(&sc->link_params);
+		bnx2x_release_phy_lock(sc);
 	}
 
 	if (attn & HW_INTERRUT_ASSERT_SET_0) {
@@ -4171,6 +4223,9 @@ static uint16_t bnx2x_update_dsb_idx(struct bnx2x_softc *sc)
 	struct host_sp_status_block *def_sb = sc->def_sb;
 	uint16_t rc = 0;
 
+	if (!def_sb)
+		return 0;
+
 	mb();			/* status block is written to by the chip */
 
 	if (sc->def_att_idx != def_sb->atten_status_block.attn_bits_index) {
@@ -4490,25 +4545,29 @@ static int bnx2x_handle_sp_tq(struct bnx2x_softc *sc)
 	return rc;
 }
 
-static void bnx2x_handle_fp_tq(struct bnx2x_fastpath *fp, int scan_fp)
+static void bnx2x_handle_fp_tq(struct bnx2x_fastpath *fp)
 {
 	struct bnx2x_softc *sc = fp->sc;
 	uint8_t more_rx = FALSE;
 
+	/* Make sure FP is initialized */
+	if (!fp->sb_running_index)
+		return;
+
 	PMD_DEBUG_PERIODIC_LOG(DEBUG, sc,
 			       "---> FP TASK QUEUE (%d) <--", fp->index);
 
 	/* update the fastpath index */
 	bnx2x_update_fp_sb_idx(fp);
 
-	if (scan_fp) {
+	if (rte_atomic32_read(&sc->scan_fp) == 1) {
 		if (bnx2x_has_rx_work(fp)) {
 			more_rx = bnx2x_rxeof(sc, fp);
 		}
 
 		if (more_rx) {
 			/* still more work to do */
-			bnx2x_handle_fp_tq(fp, scan_fp);
+			bnx2x_handle_fp_tq(fp);
 			return;
 		}
 	}
@@ -4524,7 +4583,7 @@ static void bnx2x_handle_fp_tq(struct bnx2x_fastpath *fp, int scan_fp)
  * then calls a separate routine to handle the various
  * interrupt causes: link, RX, and TX.
  */
-int bnx2x_intr_legacy(struct bnx2x_softc *sc, int scan_fp)
+int bnx2x_intr_legacy(struct bnx2x_softc *sc)
 {
 	struct bnx2x_fastpath *fp;
 	uint32_t status, mask;
@@ -4553,12 +4612,18 @@ int bnx2x_intr_legacy(struct bnx2x_softc *sc, int scan_fp)
 		fp = &sc->fp[i];
 		mask = (0x2 << (fp->index + CNIC_SUPPORT(sc)));
 		if (status & mask) {
-			bnx2x_handle_fp_tq(fp, scan_fp);
+		/* acknowledge and disable further fastpath interrupts */
+			bnx2x_ack_sb(sc, fp->igu_sb_id, USTORM_ID,
+				     0, IGU_INT_DISABLE, 0);
+			bnx2x_handle_fp_tq(fp);
 			status &= ~mask;
 		}
 	}
 
 	if (unlikely(status & 0x1)) {
+		/* acknowledge and disable further slowpath interrupts */
+		bnx2x_ack_sb(sc, sc->igu_dsb_id, USTORM_ID,
+			     0, IGU_INT_DISABLE, 0);
 		rc = bnx2x_handle_sp_tq(sc);
 		status &= ~0x1;
 	}
@@ -5773,7 +5838,7 @@ static int bnx2x_set_power_state(struct bnx2x_softc *sc, uint8_t state)
 
 	/* If there is no power capability, silently succeed */
 	if (!(sc->devinfo.pcie_cap_flags & BNX2X_PM_CAPABLE_FLAG)) {
-		PMD_DRV_LOG(WARNING, sc, "No power capability");
+		PMD_DRV_LOG(INFO, sc, "No power capability");
 		return 0;
 	}
 
@@ -6861,7 +6926,7 @@ bnx2x_fill_report_data(struct bnx2x_softc *sc, struct bnx2x_link_report_data *da
 }
 
 /* report link status to OS, should be called under phy_lock */
-static void bnx2x_link_report(struct bnx2x_softc *sc)
+static void bnx2x_link_report_locked(struct bnx2x_softc *sc)
 {
 	struct bnx2x_link_report_data cur_data;
 
@@ -6882,14 +6947,19 @@ static void bnx2x_link_report(struct bnx2x_softc *sc)
 		return;
 	}
 
+	ELINK_DEBUG_P2(sc, "Change in link status : cur_data = %lx, last_reported_link = %lx",
+		       cur_data.link_report_flags,
+		       sc->last_reported_link.link_report_flags);
+
 	sc->link_cnt++;
 
+	ELINK_DEBUG_P1(sc, "link status change count = %x", sc->link_cnt);
 	/* report new link params and remember the state for the next time */
 	rte_memcpy(&sc->last_reported_link, &cur_data, sizeof(cur_data));
 
 	if (bnx2x_test_bit(BNX2X_LINK_REPORT_LINK_DOWN,
 			 &cur_data.link_report_flags)) {
-		PMD_DRV_LOG(INFO, sc, "NIC Link is Down");
+		ELINK_DEBUG_P0(sc, "NIC Link is Down");
 	} else {
 		__rte_unused const char *duplex;
 		__rte_unused const char *flow;
@@ -6897,8 +6967,10 @@ static void bnx2x_link_report(struct bnx2x_softc *sc)
 		if (bnx2x_test_and_clear_bit(BNX2X_LINK_REPORT_FULL_DUPLEX,
 					   &cur_data.link_report_flags)) {
 			duplex = "full";
+				ELINK_DEBUG_P0(sc, "link set to full duplex");
 		} else {
 			duplex = "half";
+				ELINK_DEBUG_P0(sc, "link set to half duplex");
 		}
 
 /*
@@ -6935,6 +7007,14 @@ static void bnx2x_link_report(struct bnx2x_softc *sc)
 	}
 }
 
+static void
+bnx2x_link_report(struct bnx2x_softc *sc)
+{
+	bnx2x_acquire_phy_lock(sc);
+	bnx2x_link_report_locked(sc);
+	bnx2x_release_phy_lock(sc);
+}
+
 void bnx2x_link_status_update(struct bnx2x_softc *sc)
 {
 	if (sc->state != BNX2X_STATE_OPEN) {
@@ -7000,7 +7080,7 @@ void bnx2x_link_status_update(struct bnx2x_softc *sc)
 		}
 		bnx2x_link_report(sc);
 	} else {
-		bnx2x_link_report(sc);
+		bnx2x_link_report_locked(sc);
 		bnx2x_stats_handle(sc, STATS_EVENT_LINK_UP);
 	}
 }
@@ -7013,6 +7093,8 @@ static int bnx2x_initial_phy_init(struct bnx2x_softc *sc, int load_mode)
 
 	bnx2x_set_requested_fc(sc);
 
+	bnx2x_acquire_phy_lock(sc);
+
 	if (load_mode == LOAD_DIAG) {
 		lp->loopback_mode = ELINK_LOOPBACK_XGXS;
 /* Prefer doing PHY loopback at 10G speed, if possible */
@@ -7032,6 +7114,8 @@ static int bnx2x_initial_phy_init(struct bnx2x_softc *sc, int load_mode)
 
 	rc = elink_phy_init(&sc->link_params, &sc->link_vars);
 
+	bnx2x_release_phy_lock(sc);
+
 	bnx2x_calc_fc_adv(sc);
 
 	if (sc->link_vars.link_up) {
@@ -7070,7 +7154,7 @@ void bnx2x_periodic_callout(struct bnx2x_softc *sc)
 {
 	if ((sc->state != BNX2X_STATE_OPEN) ||
 	    (atomic_load_acq_long(&sc->periodic_flags) == PERIODIC_STOP)) {
-		PMD_DRV_LOG(INFO, sc, "periodic callout exit (state=0x%x)",
+		PMD_DRV_LOG(DEBUG, sc, "periodic callout exit (state=0x%x)",
 			    sc->state);
 		return;
 	}
@@ -7082,7 +7166,9 @@ void bnx2x_periodic_callout(struct bnx2x_softc *sc)
  */
 		mb();
 		if (sc->port.pmf) {
+			bnx2x_acquire_phy_lock(sc);
 			elink_period_func(&sc->link_params, &sc->link_vars);
+			bnx2x_release_phy_lock(sc);
 		}
 	}
 #ifdef BNX2X_PULSE
@@ -8017,6 +8103,27 @@ static int bnx2x_get_shmem_info(struct bnx2x_softc *sc)
 		    ~ELINK_FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED;
 	}
 
+	val = sc->devinfo.bc_ver >> 8;
+	if (val < BNX2X_BC_VER) {
+		/* for now only warn later we might need to enforce this */
+		PMD_DRV_LOG(NOTICE, sc, "This driver needs bc_ver %X but found %X, please upgrade BC\n",
+			    BNX2X_BC_VER, val);
+	}
+	sc->link_params.feature_config_flags |=
+				(val >= REQ_BC_VER_4_VRFY_FIRST_PHY_OPT_MDL) ?
+				ELINK_FEATURE_CONFIG_BC_SUPPORTS_OPT_MDL_VRFY :
+				0;
+
+	sc->link_params.feature_config_flags |=
+		(val >= REQ_BC_VER_4_VRFY_SPECIFIC_PHY_OPT_MDL) ?
+		ELINK_FEATURE_CONFIG_BC_SUPPORTS_DUAL_PHY_OPT_MDL_VRFY : 0;
+	sc->link_params.feature_config_flags |=
+		(val >= REQ_BC_VER_4_VRFY_AFEX_SUPPORTED) ?
+		ELINK_FEATURE_CONFIG_BC_SUPPORTS_AFEX : 0;
+	sc->link_params.feature_config_flags |=
+		(val >= REQ_BC_VER_4_SFP_TX_DISABLE_SUPPORTED) ?
+		ELINK_FEATURE_CONFIG_BC_SUPPORTS_SFP_TX_DISABLED : 0;
+
 	/* get the initial value of the link params */
 	sc->link_params.multi_phy_config =
 	    SHMEM_RD(sc, dev_info.port_hw_config[port].multi_phy_config);
@@ -8262,7 +8369,7 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
 		 ((sc->devinfo.bc_ver >> 24) & 0xff),
 		 ((sc->devinfo.bc_ver >> 16) & 0xff),
 		 ((sc->devinfo.bc_ver >> 8) & 0xff));
-	PMD_DRV_LOG(INFO, sc, "Bootcode version: %s", sc->devinfo.bc_ver_str);
+	PMD_DRV_LOG(DEBUG, sc, "Bootcode version: %s", sc->devinfo.bc_ver_str);
 
 	/* get the bootcode shmem address */
 	sc->devinfo.mf_cfg_base = bnx2x_get_shmem_mf_cfg_base(sc);
@@ -9341,6 +9448,8 @@ static int bnx2x_prev_unload(struct bnx2x_softc *sc)
 	uint32_t fw, hw_lock_reg, hw_lock_val;
 	uint32_t rc = 0;
 
+	PMD_INIT_FUNC_TRACE(sc);
+
 	/*
 	 * Clear HW from errors which may have resulted from an interrupted
 	 * DMAE transaction.
@@ -9348,22 +9457,23 @@ static int bnx2x_prev_unload(struct bnx2x_softc *sc)
 	bnx2x_prev_interrupted_dmae(sc);
 
 	/* Release previously held locks */
-	if (SC_FUNC(sc) <= 5)
-		hw_lock_reg = (MISC_REG_DRIVER_CONTROL_1 + SC_FUNC(sc) * 8);
-	else
-		hw_lock_reg =
-		    (MISC_REG_DRIVER_CONTROL_7 + (SC_FUNC(sc) - 6) * 8);
+	hw_lock_reg = (SC_FUNC(sc) <= 5) ?
+			(MISC_REG_DRIVER_CONTROL_1 + SC_FUNC(sc) * 8) :
+			(MISC_REG_DRIVER_CONTROL_7 + (SC_FUNC(sc) - 6) * 8);
 
 	hw_lock_val = (REG_RD(sc, hw_lock_reg));
 	if (hw_lock_val) {
 		if (hw_lock_val & HW_LOCK_RESOURCE_NVRAM) {
+			PMD_DRV_LOG(DEBUG, sc, "Releasing previously held NVRAM lock\n");
 			REG_WR(sc, MCP_REG_MCPR_NVM_SW_ARB,
 			       (MCPR_NVM_SW_ARB_ARB_REQ_CLR1 << SC_PORT(sc)));
 		}
+		PMD_DRV_LOG(DEBUG, sc, "Releasing previously held HW lock\n");
 		REG_WR(sc, hw_lock_reg, 0xffffffff);
 	}
 
 	if (MCPR_ACCESS_LOCK_LOCK & REG_RD(sc, MCP_REG_MCPR_ACCESS_LOCK)) {
+		PMD_DRV_LOG(DEBUG, sc, "Releasing previously held ALR\n");
 		REG_WR(sc, MCP_REG_MCPR_ACCESS_LOCK, 0);
 	}
 
@@ -9693,6 +9803,8 @@ int bnx2x_attach(struct bnx2x_softc *sc)
 		sc->fw_seq =
 		    (SHMEM_RD(sc, func_mb[SC_FW_MB_IDX(sc)].drv_mb_header) &
 		     DRV_MSG_SEQ_NUMBER_MASK);
+		PMD_DRV_LOG(DEBUG, sc, "prev unload fw_seq 0x%04x",
+			    sc->fw_seq);
 		bnx2x_prev_unload(sc);
 	}
 
@@ -9834,8 +9946,10 @@ static void bnx2x_common_init_phy(struct bnx2x_softc *sc)
 		shmem2_base[1] = SHMEM2_RD(sc, other_shmem2_base_addr);
 	}
 
+	bnx2x_acquire_phy_lock(sc);
 	elink_common_init_phy(sc, shmem_base, shmem2_base,
 			      sc->devinfo.chip_id, 0);
+	bnx2x_release_phy_lock(sc);
 }
 
 static void bnx2x_pf_disable(struct bnx2x_softc *sc)
@@ -11314,7 +11428,9 @@ static int bnx2x_init_hw_func(struct bnx2x_softc *sc)
 static void bnx2x_link_reset(struct bnx2x_softc *sc)
 {
 	if (!BNX2X_NOMCP(sc)) {
+		bnx2x_acquire_phy_lock(sc);
 		elink_lfa_reset(&sc->link_params, &sc->link_vars);
+		bnx2x_release_phy_lock(sc);
 	} else {
 		if (!CHIP_REV_IS_SLOW(sc)) {
 			PMD_DRV_LOG(WARNING, sc,
@@ -11668,53 +11784,47 @@ static const char *get_bnx2x_flags(uint32_t flags)
 
 	for (i = 0; i < 5; i++)
 		if (flags & (1 << i)) {
-			strcat(flag_str, flag[i]);
+			strlcat(flag_str, flag[i], sizeof(flag_str));
 			flags ^= (1 << i);
 		}
 	if (flags) {
 		static char unknown[BNX2X_INFO_STR_MAX];
 		snprintf(unknown, 32, "Unknown flag mask %x", flags);
-		strcat(flag_str, unknown);
+		strlcat(flag_str, unknown, sizeof(flag_str));
 	}
 	return flag_str;
 }
 
-/*
- * Prints useful adapter info.
- */
+/* Prints useful adapter info. */
 void bnx2x_print_adapter_info(struct bnx2x_softc *sc)
 {
 	int i = 0;
-	__rte_unused uint32_t ext_phy_type;
 
-	PMD_INIT_FUNC_TRACE(sc);
-	if (sc->link_vars.phy_flags & PHY_XGXS_FLAG)
-		ext_phy_type = ELINK_XGXS_EXT_PHY_TYPE(REG_RD(sc,
-							      sc->
-							      devinfo.shmem_base
-							      + offsetof(struct
-									 shmem_region,
-									 dev_info.port_hw_config
-									 [0].external_phy_config)));
-	else
-		ext_phy_type = ELINK_SERDES_EXT_PHY_TYPE(REG_RD(sc,
-								sc->
-								devinfo.shmem_base
-								+
-								offsetof(struct
-									 shmem_region,
-									 dev_info.port_hw_config
-									 [0].external_phy_config)));
-
-	PMD_DRV_LOG(INFO, sc, "\n\n===================================\n");
+	PMD_DRV_LOG(INFO, sc, "========================================");
+	/* DPDK and Driver versions */
+	PMD_DRV_LOG(INFO, sc, "%12s : %s", "DPDK",
+			rte_version());
+	PMD_DRV_LOG(INFO, sc, "%12s : %s", "Driver",
+			bnx2x_pmd_version());
+	/* Firmware versions. */
+	PMD_DRV_LOG(INFO, sc, "%12s : %d.%d.%d",
+		     "Firmware",
+		     BNX2X_5710_FW_MAJOR_VERSION,
+		     BNX2X_5710_FW_MINOR_VERSION,
+		     BNX2X_5710_FW_REVISION_VERSION);
+	PMD_DRV_LOG(INFO, sc, "%12s : %s",
+		     "Bootcode", sc->devinfo.bc_ver_str);
 	/* Hardware chip info. */
 	PMD_DRV_LOG(INFO, sc, "%12s : %#08x", "ASIC", sc->devinfo.chip_id);
 	PMD_DRV_LOG(INFO, sc, "%12s : %c%d", "Rev", (CHIP_REV(sc) >> 12) + 'A',
 		     (CHIP_METAL(sc) >> 4));
-
-	/* Bus info. */
-	PMD_DRV_LOG(INFO, sc,
-		    "%12s : %d, ", "Bus PCIe", sc->devinfo.pcie_link_width);
+	/* Bus PCIe info. */
+	PMD_DRV_LOG(INFO, sc, "%12s : 0x%x", "Vendor Id",
+		    sc->devinfo.vendor_id);
+	PMD_DRV_LOG(INFO, sc, "%12s : 0x%x", "Device Id",
+		    sc->devinfo.device_id);
+	PMD_DRV_LOG(INFO, sc, "%12s : width x%d, ", "Bus PCIe",
+		    sc->devinfo.pcie_link_width);
 	switch (sc->devinfo.pcie_link_speed) {
 	case 1:
 		PMD_DRV_LOG(INFO, sc, "%23s", "2.5 Gbps");
@@ -11728,62 +11838,45 @@ void bnx2x_print_adapter_info(struct bnx2x_softc *sc)
 	default:
 		PMD_DRV_LOG(INFO, sc, "%33s", "Unknown link speed");
 	}
-
 	/* Device features. */
 	PMD_DRV_LOG(INFO, sc, "%12s : ", "Flags");
-
 	/* Miscellaneous flags. */
 	if (sc->devinfo.pcie_cap_flags & BNX2X_MSI_CAPABLE_FLAG) {
 		PMD_DRV_LOG(INFO, sc, "%18s", "MSI");
 		i++;
 	}
-
 	if (sc->devinfo.pcie_cap_flags & BNX2X_MSIX_CAPABLE_FLAG) {
 		if (i > 0)
 			PMD_DRV_LOG(INFO, sc, "|");
 		PMD_DRV_LOG(INFO, sc, "%20s", "MSI-X");
 		i++;
 	}
+	PMD_DRV_LOG(INFO, sc, "%12s : %s", "OVLAN", (OVLAN(sc) ? "YES" : "NO"));
+	PMD_DRV_LOG(INFO, sc, "%12s : %s", "MF", (IS_MF(sc) ? "YES" : "NO"));
+	PMD_DRV_LOG(INFO, sc, "========================================");
+}
 
-	if (IS_PF(sc)) {
-		PMD_DRV_LOG(INFO, sc, "%12s : ", "Queues");
-		switch (sc->sp->rss_rdata.rss_mode) {
-		case ETH_RSS_MODE_DISABLED:
-			PMD_DRV_LOG(INFO, sc, "%19s", "None");
-			break;
-		case ETH_RSS_MODE_REGULAR:
-			PMD_DRV_LOG(INFO, sc,
-				    "%18s : %d", "RSS", sc->num_queues);
-			break;
-		default:
-			PMD_DRV_LOG(INFO, sc, "%22s", "Unknown");
-			break;
-		}
-	}
-
-	/* RTE and Driver versions */
-	PMD_DRV_LOG(INFO, sc, "%12s : %s", "DPDK",
-			rte_version());
-	PMD_DRV_LOG(INFO, sc, "%12s : %s", "Driver",
-			bnx2x_pmd_version());
+/* Prints useful device info. */
+void bnx2x_print_device_info(struct bnx2x_softc *sc)
+{
+	__rte_unused uint32_t ext_phy_type;
+	uint32_t offset, reg_val;
 
-	/* Firmware versions and device features. */
-	PMD_DRV_LOG(INFO, sc, "%12s : %d.%d.%d",
-		     "Firmware",
-		     BNX2X_5710_FW_MAJOR_VERSION,
-		     BNX2X_5710_FW_MINOR_VERSION,
-		     BNX2X_5710_FW_REVISION_VERSION);
-	PMD_DRV_LOG(INFO, sc, "%12s : %s",
-		     "Bootcode", sc->devinfo.bc_ver_str);
+	PMD_INIT_FUNC_TRACE(sc);
+	offset = offsetof(struct shmem_region,
+			  dev_info.port_hw_config[0].external_phy_config);
+	reg_val = REG_RD(sc, sc->devinfo.shmem_base + offset);
+	if (sc->link_vars.phy_flags & PHY_XGXS_FLAG)
+		ext_phy_type = ELINK_XGXS_EXT_PHY_TYPE(reg_val);
+	else
+		ext_phy_type = ELINK_SERDES_EXT_PHY_TYPE(reg_val);
 
-	PMD_DRV_LOG(INFO, sc, "\n\n===================================\n");
+	/* Device features. */
 	PMD_DRV_LOG(INFO, sc, "%12s : %u", "Bnx2x Func", sc->pcie_func);
 	PMD_DRV_LOG(INFO, sc,
 		    "%12s : %s", "Bnx2x Flags", get_bnx2x_flags(sc->flags));
 	PMD_DRV_LOG(INFO, sc, "%12s : %s", "DMAE Is",
 		     (sc->dmae_ready ? "Ready" : "Not Ready"));
-	PMD_DRV_LOG(INFO, sc, "%12s : %s", "OVLAN", (OVLAN(sc) ? "YES" : "NO"));
-	PMD_DRV_LOG(INFO, sc, "%12s : %s", "MF", (IS_MF(sc) ? "YES" : "NO"));
 	PMD_DRV_LOG(INFO, sc, "%12s : %u", "MTU", sc->mtu);
 	PMD_DRV_LOG(INFO, sc,
 		    "%12s : %s", "PHY Type", get_ext_phy_type(ext_phy_type));
@@ -11799,9 +11892,30 @@ void bnx2x_print_adapter_info(struct bnx2x_softc *sc)
 	if (sc->recovery_state)
 		PMD_DRV_LOG(INFO, sc, "%12s : %s", "Recovery",
 			     get_recovery_state(sc->recovery_state));
+	/* Queue info. */
+	if (IS_PF(sc)) {
+		switch (sc->sp->rss_rdata.rss_mode) {
+		case ETH_RSS_MODE_DISABLED:
+			PMD_DRV_LOG(INFO, sc, "%12s : %s", "Queues", "RSS mode - None");
+			break;
+		case ETH_RSS_MODE_REGULAR:
+			PMD_DRV_LOG(INFO, sc, "%12s : %s,", "Queues", "RSS mode - Regular");
+			PMD_DRV_LOG(INFO, sc, "%16d", sc->num_queues);
+			break;
+		default:
+			PMD_DRV_LOG(INFO, sc, "%12s : %s", "Queues", "RSS mode - Unknown");
+			break;
+		}
+	}
 	PMD_DRV_LOG(INFO, sc, "%12s : CQ = %lx,  EQ = %lx", "SPQ Left",
 		     sc->cq_spq_left, sc->eq_spq_left);
+
 	PMD_DRV_LOG(INFO, sc,
 		    "%12s : %x", "Switch", sc->link_params.switch_cfg);
-	PMD_DRV_LOG(INFO, sc, "\n\n===================================\n");
+	PMD_DRV_LOG(INFO, sc, "pcie_bus=%d, pcie_device=%d",
+			sc->pcie_bus, sc->pcie_device);
+	PMD_DRV_LOG(INFO, sc, "bar0.addr=%p, bar1.addr=%p",
+			sc->bar[BAR0].base_addr, sc->bar[BAR1].base_addr);
+	PMD_DRV_LOG(INFO, sc, "port=%d, path=%d, vnic=%d, func=%d",
+			PORT_ID(sc), PATH_ID(sc), VNIC_ID(sc), FUNC_ID(sc));
 }