New upstream version 16.11.9upstream/16.11.9 upstream-16.11-stable

Change-Id: Ia1ac246c53e5050b6a29d6952fb668ad6c782996 Signed-off-by: Luca Boccassi <luca.boccassi@gmail.com>
author: Luca Boccassi <luca.boccassi@gmail.com> 2019-03-20 14:45:09 +0000
committer: Luca Boccassi <luca.boccassi@gmail.com> 2019-03-20 14:45:37 +0000
commit: f7a9461e29147c47ce2bb81bd157ac1833cf5eb1 (patch)
tree: 6f3b4f4850cf9f116acc1dda3f0515259673e13b
parent: 8e6d9d118f6105a3627b64a7949e1fb0b145879e (diff)
115 files changed, 2198 insertions, 1412 deletions
diff --git a/app/test-pmd/cmdline.c b/app/test-pmd/cmdline.c
index 7dbe2456..7590d1bd 100644
--- a/app/test-pmd/cmdline.c
+++ b/app/test-pmd/cmdline.c
@@ -190,11 +190,8 @@ static void cmd_help_long_parsed(void *parsed_result,
 			" by masks on port X. size is used to indicate the"
 			" hardware supported reta size\n\n"
 
-			"show port rss-hash ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|"
-			"ipv4-sctp|ipv4-other|ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|"
-			"ipv6-other|l2-payload|ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex [key]\n"
-			"    Display the RSS hash functions and RSS hash key"
-			" of port X\n\n"
+			"show port (port_id) rss-hash [key]\n"
+			"    Display the RSS hash functions and RSS hash key of port\n\n"
 
 			"clear port (info|stats|xstats|fdir|stat_qmap) (port_id|all)\n"
 			"    Clear information for port_id, or all.\n\n"
@@ -2109,8 +2106,7 @@ static void cmd_showport_rss_hash_parsed(void *parsed_result,
 {
 	struct cmd_showport_rss_hash *res = parsed_result;
 
-	port_rss_hash_conf_show(res->port_id, res->rss_type,
-				show_rss_key != NULL);
+	port_rss_hash_conf_show(res->port_id, show_rss_key != NULL);
 }
 
 cmdline_parse_token_string_t cmd_showport_rss_hash_show =
@@ -2122,29 +2118,18 @@ cmdline_parse_token_num_t cmd_showport_rss_hash_port_id =
 cmdline_parse_token_string_t cmd_showport_rss_hash_rss_hash =
 	TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, rss_hash,
 				 "rss-hash");
-cmdline_parse_token_string_t cmd_showport_rss_hash_rss_hash_info =
-	TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, rss_type,
-				 "ipv4#ipv4-frag#ipv4-tcp#ipv4-udp#ipv4-sctp#"
-				 "ipv4-other#ipv6#ipv6-frag#ipv6-tcp#ipv6-udp#"
-				 "ipv6-sctp#ipv6-other#l2-payload#ipv6-ex#"
-				 "ipv6-tcp-ex#ipv6-udp-ex");
 cmdline_parse_token_string_t cmd_showport_rss_hash_rss_key =
 	TOKEN_STRING_INITIALIZER(struct cmd_showport_rss_hash, key, "key");
 
 cmdline_parse_inst_t cmd_showport_rss_hash = {
 	.f = cmd_showport_rss_hash_parsed,
 	.data = NULL,
-	.help_str =
-		"show port X rss-hash ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|"
-		"ipv4-sctp|ipv4-other|ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|"
-		"ipv6-sctp|ipv6-other|l2-payload|"
-		"ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex (X = port number)\n",
+	.help_str = "show port <port_id> rss-hash",
 	.tokens = {
 		(void *)&cmd_showport_rss_hash_show,
 		(void *)&cmd_showport_rss_hash_port,
 		(void *)&cmd_showport_rss_hash_port_id,
 		(void *)&cmd_showport_rss_hash_rss_hash,
-		(void *)&cmd_showport_rss_hash_rss_hash_info,
 		NULL,
 	},
 };
@@ -2152,17 +2137,12 @@ cmdline_parse_inst_t cmd_showport_rss_hash = {
 cmdline_parse_inst_t cmd_showport_rss_hash_key = {
 	.f = cmd_showport_rss_hash_parsed,
 	.data = (void *)1,
-	.help_str =
-		"show port X rss-hash ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|"
-		"ipv4-sctp|ipv4-other|ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|"
-		"ipv6-sctp|ipv6-other|l2-payload|"
-		"ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex key (X = port number)\n",
+	.help_str = "show port <port_id> rss-hash key",
 	.tokens = {
 		(void *)&cmd_showport_rss_hash_show,
 		(void *)&cmd_showport_rss_hash_port,
 		(void *)&cmd_showport_rss_hash_port_id,
 		(void *)&cmd_showport_rss_hash_rss_hash,
-		(void *)&cmd_showport_rss_hash_rss_hash_info,
 		(void *)&cmd_showport_rss_hash_rss_key,
 		NULL,
 	},
@@ -3501,7 +3481,7 @@ cmdline_parse_token_string_t cmd_csum_tunnel_csum =
 				csum, "csum");
 cmdline_parse_token_string_t cmd_csum_tunnel_parse =
 	TOKEN_STRING_INITIALIZER(struct cmd_csum_tunnel_result,
-				parse, "parse_tunnel");
+				parse, "parse-tunnel");
 cmdline_parse_token_string_t cmd_csum_tunnel_onoff =
 	TOKEN_STRING_INITIALIZER(struct cmd_csum_tunnel_result,
 				onoff, "on#off");
@@ -3513,7 +3493,7 @@ cmdline_parse_inst_t cmd_csum_tunnel = {
 	.f = cmd_csum_tunnel_parsed,
 	.data = NULL,
 	.help_str = "enable/disable parsing of tunnels for csum engine: "
-	"csum parse_tunnel on|off <tx-port>",
+	"csum parse-tunnel on|off <tx-port>",
 	.tokens = {
 		(void *)&cmd_csum_tunnel_csum,
 		(void *)&cmd_csum_tunnel_parse,
@@ -6241,7 +6221,6 @@ static void cmd_quit_parsed(__attribute__((unused)) void *parsed_result,
 			    struct cmdline *cl,
 			    __attribute__((unused)) void *data)
 {
-	pmd_test_exit();
 	cmdline_quit(cl);
 }
 
diff --git a/app/test-pmd/config.c b/app/test-pmd/config.c
index 130ff148..f427a830 100644
--- a/app/test-pmd/config.c
+++ b/app/test-pmd/config.c
@@ -1004,9 +1004,9 @@ port_rss_reta_info(portid_t port_id,
  * key of the port.
  */
 void
-port_rss_hash_conf_show(portid_t port_id, char rss_info[], int show_rss_key)
+port_rss_hash_conf_show(portid_t port_id, int show_rss_key)
 {
-	struct rte_eth_rss_conf rss_conf;
+	struct rte_eth_rss_conf rss_conf = {0};
 	uint8_t rss_key[RSS_HASH_KEY_LENGTH];
 	uint64_t rss_hf;
 	uint8_t i;
@@ -1017,7 +1017,6 @@ port_rss_hash_conf_show(portid_t port_id, char rss_info[], int show_rss_key)
 	if (port_id_is_invalid(port_id, ENABLED_WARN))
 		return;
 
-	memset(&dev_info, 0, sizeof(dev_info));
 	rte_eth_dev_info_get(port_id, &dev_info);
 	if (dev_info.hash_key_size > 0 &&
 			dev_info.hash_key_size <= sizeof(rss_key))
@@ -1027,12 +1026,6 @@ port_rss_hash_conf_show(portid_t port_id, char rss_info[], int show_rss_key)
 		return;
 	}
 
-	rss_conf.rss_hf = 0;
-	for (i = 0; i < RTE_DIM(rss_type_table); i++) {
-		if (!strcmp(rss_info, rss_type_table[i].str))
-			rss_conf.rss_hf = rss_type_table[i].rss_type;
-	}
-
 	/* Get RSS hash key if asked to display it */
 	rss_conf.rss_key = (show_rss_key) ? rss_key : NULL;
 	rss_conf.rss_key_len = hash_key_size;
diff --git a/app/test-pmd/csumonly.c b/app/test-pmd/csumonly.c
index 57e6ae27..3bf07a42 100644
--- a/app/test-pmd/csumonly.c
+++ b/app/test-pmd/csumonly.c
@@ -142,7 +142,9 @@ parse_ipv4(struct ipv4_hdr *ipv4_hdr, struct testpmd_offload_info *info)
 	if (info->l4_proto == IPPROTO_TCP) {
 		tcp_hdr = (struct tcp_hdr *)((char *)ipv4_hdr + info->l3_len);
 		info->l4_len = (tcp_hdr->data_off & 0xf0) >> 2;
-	} else
+	} else if (info->l4_proto == IPPROTO_UDP)
+		info->l4_len = sizeof(struct udp_hdr);
+	else
 		info->l4_len = 0;
 }
 
@@ -159,7 +161,9 @@ parse_ipv6(struct ipv6_hdr *ipv6_hdr, struct testpmd_offload_info *info)
 	if (info->l4_proto == IPPROTO_TCP) {
 		tcp_hdr = (struct tcp_hdr *)((char *)ipv6_hdr + info->l3_len);
 		info->l4_len = (tcp_hdr->data_off & 0xf0) >> 2;
-	} else
+	} else if (info->l4_proto == IPPROTO_UDP)
+		info->l4_len = sizeof(struct udp_hdr);
+	else
 		info->l4_len = 0;
 }
 
diff --git a/app/test-pmd/testpmd.c b/app/test-pmd/testpmd.c
index e48cf8a1..a6d80f35 100644
--- a/app/test-pmd/testpmd.c
+++ b/app/test-pmd/testpmd.c
@@ -358,14 +358,14 @@ set_default_fwd_lcores_config(void)
 
 	nb_lc = 0;
 	for (i = 0; i < RTE_MAX_LCORE; i++) {
+		if (!rte_lcore_is_enabled(i))
+			continue;
 		sock_num = rte_lcore_to_socket_id(i) + 1;
 		if (sock_num > max_socket) {
 			if (sock_num > RTE_MAX_NUMA_NODES)
 				rte_exit(EXIT_FAILURE, "Total sockets greater than %u\n", RTE_MAX_NUMA_NODES);
 			max_socket = sock_num;
 		}
-		if (!rte_lcore_is_enabled(i))
-			continue;
 		if (i == rte_get_master_lcore())
 			continue;
 		fwd_lcores_cpuids[nb_lc++] = i;
diff --git a/app/test-pmd/testpmd.h b/app/test-pmd/testpmd.h
index aad598e5..b52a19d9 100644
--- a/app/test-pmd/testpmd.h
+++ b/app/test-pmd/testpmd.h
@@ -579,8 +579,7 @@ int set_queue_rate_limit(portid_t port_id, uint16_t queue_idx, uint16_t rate);
 int set_vf_rate_limit(portid_t port_id, uint16_t vf, uint16_t rate,
 				uint64_t q_msk);
 
-void port_rss_hash_conf_show(portid_t port_id, char rss_info[],
-			     int show_rss_key);
+void port_rss_hash_conf_show(portid_t port_id, int show_rss_key);
 void port_rss_hash_key_update(portid_t port_id, char rss_type[],
 			      uint8_t *hash_key, uint hash_key_len);
 void get_syn_filter(uint8_t port_id);
diff --git a/app/test/test_acl.h b/app/test/test_acl.h
index 421f3109..6f5c485a 100644
--- a/app/test/test_acl.h
+++ b/app/test/test_acl.h
@@ -109,34 +109,40 @@ enum {
 struct rte_acl_ipv4vlan_rule invalid_layout_rules[] = {
 		/* test src and dst address */
 		{
-				.data = {.userdata = 1, .category_mask = 1},
+				.data = {.userdata = 1, .category_mask = 1,
+					.priority = 1},
 				.src_addr = IPv4(10,0,0,0),
 				.src_mask_len = 24,
 		},
 		{
-				.data = {.userdata = 2, .category_mask = 1},
+				.data = {.userdata = 2, .category_mask = 1,
+					.priority = 1},
 				.dst_addr = IPv4(10,0,0,0),
 				.dst_mask_len = 24,
 		},
 		/* test src and dst ports */
 		{
-				.data = {.userdata = 3, .category_mask = 1},
+				.data = {.userdata = 3, .category_mask = 1,
+					.priority = 1},
 				.dst_port_low = 100,
 				.dst_port_high = 100,
 		},
 		{
-				.data = {.userdata = 4, .category_mask = 1},
+				.data = {.userdata = 4, .category_mask = 1,
+					.priority = 1},
 				.src_port_low = 100,
 				.src_port_high = 100,
 		},
 		/* test proto */
 		{
-				.data = {.userdata = 5, .category_mask = 1},
+				.data = {.userdata = 5, .category_mask = 1,
+					.priority = 1},
 				.proto = 0xf,
 				.proto_mask = 0xf
 		},
 		{
-				.data = {.userdata = 6, .category_mask = 1},
+				.data = {.userdata = 6, .category_mask = 1,
+					.priority = 1},
 				.dst_port_low = 0xf,
 				.dst_port_high = 0xf,
 		}
diff --git a/app/test/test_common.c b/app/test/test_common.c
index 8effa2f9..afd2b99f 100644
--- a/app/test/test_common.c
+++ b/app/test/test_common.c
@@ -159,12 +159,44 @@ test_align(void)
 }
 
 static int
+test_fls(void)
+{
+	struct fls_test_vector {
+		uint32_t arg;
+		int rc;
+	};
+	int expected, rc;
+	uint32_t i, arg;
+
+	const struct fls_test_vector test[] = {
+		{0x0, 0},
+		{0x1, 1},
+		{0x4000, 15},
+		{0x80000000, 32},
+	};
+
+	for (i = 0; i < RTE_DIM(test); i++) {
+		arg = test[i].arg;
+		rc = rte_fls_u32(arg);
+		expected = test[i].rc;
+		if (rc != expected) {
+			printf("Wrong rte_fls_u32(0x%x) rc=%d, expected=%d\n",
+				arg, rc, expected);
+			return TEST_FAILED;
+		}
+	}
+
+	return 0;
+}
+
+static int
 test_common(void)
 {
 	int ret = 0;
 	ret |= test_align();
 	ret |= test_macros(0);
 	ret |= test_misc();
+	ret |= test_fls();
 
 	return ret;
 }
diff --git a/app/test/test_cryptodev.c b/app/test/test_cryptodev.c
index a1f8717b..209c4024 100644
--- a/app/test/test_cryptodev.c
+++ b/app/test/test_cryptodev.c
@@ -557,7 +557,7 @@ test_device_configure_invalid_queue_pair_ids(void)
 
 
 	/* valid - max value queue pairs */
-	ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE;
+	ts_params->conf.nb_queue_pairs = orig_nb_qps;
 
 	TEST_ASSERT_SUCCESS(rte_cryptodev_configure(ts_params->valid_devs[0],
 			&ts_params->conf),
@@ -588,7 +588,7 @@ test_device_configure_invalid_queue_pair_ids(void)
 
 
 	/* invalid - max value + 1 queue pairs */
-	ts_params->conf.nb_queue_pairs = MAX_NUM_QPS_PER_QAT_DEVICE + 1;
+	ts_params->conf.nb_queue_pairs = orig_nb_qps + 1;
 
 	TEST_ASSERT_FAIL(rte_cryptodev_configure(ts_params->valid_devs[0],
 			&ts_params->conf),
@@ -735,7 +735,7 @@ test_queue_pair_descriptor_setup(void)
 	/* test invalid queue pair id */
 	qp_conf.nb_descriptors = DEFAULT_NUM_OPS_INFLIGHT;	/*valid */
 
-	qp_id = DEFAULT_NUM_QPS_PER_QAT_DEVICE;		/*invalid */
+	qp_id = ts_params->conf.nb_queue_pairs;		/*invalid */
 
 	TEST_ASSERT_FAIL(rte_cryptodev_queue_pair_setup(
 			ts_params->valid_devs[0],
diff --git a/app/test/test_hash.c b/app/test/test_hash.c
index 2c87efe6..c55ec0da 100644
--- a/app/test/test_hash.c
+++ b/app/test/test_hash.c
@@ -110,29 +110,23 @@ static uint32_t pseudo_hash(__attribute__((unused)) const void *keys,
 	return 3;
 }
 
+#define UNIT_TEST_HASH_VERBOSE	0
 /*
  * Print out result of unit test hash operation.
  */
-#if defined(UNIT_TEST_HASH_VERBOSE)
 static void print_key_info(const char *msg, const struct flow_key *key,
 								int32_t pos)
 {
-	uint8_t *p = (uint8_t *)key;
-	unsigned i;
-
-	printf("%s key:0x", msg);
-	for (i = 0; i < sizeof(struct flow_key); i++) {
-		printf("%02X", p[i]);
+	if (UNIT_TEST_HASH_VERBOSE) {
+		const uint8_t *p = (const uint8_t *)key;
+		unsigned int i;
+
+		printf("%s key:0x", msg);
+		for (i = 0; i < sizeof(struct flow_key); i++)
+			printf("%02X", p[i]);
+		printf(" @ pos %d\n", pos);
 	}
-	printf(" @ pos %d\n", pos);
-}
-#else
-static void print_key_info(__attribute__((unused)) const char *msg,
-		__attribute__((unused)) const struct flow_key *key,
-		__attribute__((unused)) int32_t pos)
-{
 }
-#endif
 
 /* Keys used by unit test functions */
 static struct flow_key keys[5] = { {
diff --git a/app/test/test_hash_perf.c b/app/test/test_hash_perf.c
index c0051b20..b0514b10 100644
--- a/app/test/test_hash_perf.c
+++ b/app/test/test_hash_perf.c
@@ -49,7 +49,8 @@
 #define MAX_ENTRIES (1 << 19)
 #define KEYS_TO_ADD (MAX_ENTRIES * 3 / 4) /* 75% table utilization */
 #define NUM_LOOKUPS (KEYS_TO_ADD * 5) /* Loop among keys added, several times */
-#define BUCKET_SIZE 4
+/* BUCKET_SIZE should be same as RTE_HASH_BUCKET_ENTRIES in rte_hash library */
+#define BUCKET_SIZE 8
 #define NUM_BUCKETS (MAX_ENTRIES / BUCKET_SIZE)
 #define MAX_KEYSIZE 64
 #define NUM_KEYSIZES 10
diff --git a/app/test/test_kni.c b/app/test/test_kni.c
index db17fdf3..c6e34d40 100644
--- a/app/test/test_kni.c
+++ b/app/test/test_kni.c
@@ -36,6 +36,7 @@
 #include <unistd.h>
 #include <string.h>
 #include <sys/wait.h>
+#include <dirent.h>
 
 #include "test.h"
 
@@ -57,6 +58,8 @@
 
 #define IFCONFIG      "/sbin/ifconfig "
 #define TEST_KNI_PORT "test_kni_port"
+#define KNI_MODULE_PATH "/sys/module/rte_kni"
+#define KNI_MODULE_PARAM_LO KNI_MODULE_PATH"/parameters/lo_mode"
 #define KNI_TEST_MAX_PORTS 4
 /* The threshold number of mbufs to be transmitted or received. */
 #define KNI_NUM_MBUF_THRESHOLD 100
@@ -472,13 +475,28 @@ static int
 test_kni(void)
 {
 	int ret = -1;
-	uint8_t nb_ports, port_id;
+	uint8_t port_id;
 	struct rte_kni *kni;
 	struct rte_mempool *mp;
 	struct rte_kni_conf conf;
 	struct rte_eth_dev_info info;
 	struct rte_kni_ops ops;
 
+	FILE *fd;
+	DIR *dir;
+	char buf[16];
+
+	dir = opendir(KNI_MODULE_PATH);
+	if (!dir) {
+		if (errno == ENOENT) {
+			printf("Cannot run UT due to missing rte_kni module\n");
+			return -1;
+		}
+		printf("opendir: %s", strerror(errno));
+		return -1;
+	}
+	closedir(dir);
+
 	/* Initialize KNI subsytem */
 	rte_kni_init(KNI_TEST_MAX_PORTS);
 
@@ -493,12 +511,6 @@ test_kni(void)
 		return -1;
 	}
 
-	nb_ports = rte_eth_dev_count();
-	if (nb_ports == 0) {
-		printf("no supported nic port found\n");
-		return -1;
-	}
-
 	/* configuring port 0 for the test is enough */
 	port_id = 0;
 	ret = rte_eth_dev_configure(port_id, 1, 1, &port_conf);
@@ -527,9 +539,25 @@ test_kni(void)
 	rte_eth_promiscuous_enable(port_id);
 
 	/* basic test of kni processing */
-	ret = test_kni_processing(port_id, mp);
-	if (ret < 0)
-		goto fail;
+	fd = fopen(KNI_MODULE_PARAM_LO, "r");
+	if (fd == NULL) {
+		printf("fopen: %s", strerror(errno));
+		return -1;
+	}
+	memset(&buf, 0, sizeof(buf));
+	if (fgets(buf, sizeof(buf), fd)) {
+		if (!strncmp(buf, "lo_mode_fifo", strlen("lo_mode_fifo")) ||
+			!strncmp(buf, "lo_mode_fifo_skb",
+				  strlen("lo_mode_fifo_skb"))) {
+			ret = test_kni_processing(port_id, mp);
+			if (ret < 0) {
+				fclose(fd);
+				goto fail;
+			}
+		} else
+			printf("test_kni_processing skipped because of missing rte_kni module lo_mode argument\n");
+	}
+	fclose(fd);
 
 	/* test of allocating KNI with NULL mempool pointer */
 	memset(&info, 0, sizeof(info));
diff --git a/app/test/test_reorder.c b/app/test/test_reorder.c
index add45511..d7dab321 100644
--- a/app/test/test_reorder.c
+++ b/app/test/test_reorder.c
@@ -300,7 +300,7 @@ test_reorder_drain(void)
 		goto exit;
 	}
 	if (robufs[0] != NULL)
-		rte_pktmbuf_free(robufs[i]);
+		rte_pktmbuf_free(robufs[0]);
 
 	/* Insert more packets
 	 * RB[] = {NULL, NULL, NULL, NULL}
diff --git a/config/common_base b/config/common_base
index 802fb5e3..4f448068 100644
--- a/config/common_base
+++ b/config/common_base
@@ -98,6 +98,14 @@ CONFIG_RTE_EAL_VFIO=n
 CONFIG_RTE_MALLOC_DEBUG=n
 CONFIG_RTE_USE_LIBBSD=n
 
+#
+# Recognize/ignore the AVX/AVX512 CPU flags for performance/power testing.
+# AVX512 is marked as experimental for now, will enable it after enough
+# field test and possible optimization.
+#
+CONFIG_RTE_ENABLE_AVX=y
+CONFIG_RTE_ENABLE_AVX512=n
+
 # Default driver path (or "" to disable)
 CONFIG_RTE_EAL_PMD_PATH=""
 
diff --git a/config/defconfig_arm64-armv8a-linuxapp-gcc b/config/defconfig_arm64-armv8a-linuxapp-gcc
index 6321884c..3dbf69e5 100644
--- a/config/defconfig_arm64-armv8a-linuxapp-gcc
+++ b/config/defconfig_arm64-armv8a-linuxapp-gcc
@@ -41,6 +41,7 @@ CONFIG_RTE_FORCE_INTRINSICS=y
 
 CONFIG_RTE_TOOLCHAIN="gcc"
 CONFIG_RTE_TOOLCHAIN_GCC=y
+CONFIG_RTE_MAX_LCORE=256
 
 CONFIG_RTE_EAL_IGB_UIO=n
 
diff --git a/doc/guides/contributing/documentation.rst b/doc/guides/contributing/documentation.rst
index 2cfb1a29..2545abc7 100644
--- a/doc/guides/contributing/documentation.rst
+++ b/doc/guides/contributing/documentation.rst
@@ -81,7 +81,7 @@ added to by the developer.
 * **API documentation**
 
   The API documentation explains how to use the public DPDK functions.
-  The `API index page <http://dpdk.org/doc/api/>`_ shows the generated API documentation with related groups of functions.
+  The `API index page <http://doc.dpdk.org/api/>`_ shows the generated API documentation with related groups of functions.
 
   The API documentation should be updated via Doxygen comments when new functions are added.
 
@@ -669,7 +669,7 @@ The following are some guidelines for use of Doxygen in the DPDK API documentati
        */
 
   In the API documentation the functions will be rendered as links, see the
-  `online section of the rte_ethdev.h docs <http://dpdk.org/doc/api/rte__ethdev_8h.html>`_ that contains the above text.
+  `online section of the rte_ethdev.h docs <http://doc.dpdk.org/api/rte__ethdev_8h.html>`_ that contains the above text.
 
 * The ``@see`` keyword can be used to create a *see also* link to another file or library.
   This directive should be placed on one line at the bottom of the documentation section.
diff --git a/doc/guides/contributing/patches.rst b/doc/guides/contributing/patches.rst
index 729aea71..db851b51 100644
--- a/doc/guides/contributing/patches.rst
+++ b/doc/guides/contributing/patches.rst
@@ -22,9 +22,9 @@ The DPDK development process has the following features:
 * Patches are reviewed publicly on the mailing list.
 * Successfully reviewed patches are merged to the master branch of the repository.
 
-The mailing list for DPDK development is `dev@dpdk.org <http://dpdk.org/ml/archives/dev/>`_.
-Contributors will need to `register for the mailing list <http://dpdk.org/ml/listinfo/dev>`_ in order to submit patches.
-It is also worth registering for the DPDK `Patchwork <http://dpdk.org/dev/patchwork/project/dpdk/list/>`_
+The mailing list for DPDK development is `dev@dpdk.org <http://mails.dpdk.org/archives/dev/>`_.
+Contributors will need to `register for the mailing list <http://mails.dpdk.org/listinfo/dev>`_ in order to submit patches.
+It is also worth registering for the DPDK `Patchwork <http://patches.dpdk.org/project/dpdk/list/>`_
 
 The development process requires some familiarity with the ``git`` version control system.
 Refer to the `Pro Git Book <http://www.git-scm.com/book/>`_ for further information.
@@ -347,7 +347,7 @@ If the patch is in relation to a previous email thread you can add it to the sam
    git send-email --to dev@dpdk.org --in-reply-to <1234-foo@bar.com> 000*.patch
 
 The Message ID can be found in the raw text of emails or at the top of each Patchwork patch,
-`for example <http://dpdk.org/dev/patchwork/patch/7646/>`_.
+`for example <http://patches.dpdk.org/patch/7646/>`_.
 Shallow threading (``--thread --no-chain-reply-to``) is preferred for a patch series.
 
 Once submitted your patches will appear on the mailing list and in Patchwork.
diff --git a/doc/guides/cryptodevs/qat.rst b/doc/guides/cryptodevs/qat.rst
index 2173819e..c46a62ea 100644
--- a/doc/guides/cryptodevs/qat.rst
+++ b/doc/guides/cryptodevs/qat.rst
@@ -89,7 +89,7 @@ To use the DPDK QAT PMD an SRIOV-enabled QAT kernel driver is required. The
 VF devices exposed by this driver will be used by QAT PMD.
 
 To enable QAT in DPDK, follow the instructions mentioned in
-http://dpdk.org/doc/guides/linux_gsg/build_dpdk.html
+http://doc.dpdk.org/guides/linux_gsg/build_dpdk.html
 
 Quick instructions as follows:
 
@@ -107,7 +107,6 @@ For **Intel QuickAssist Technology C62x** and **Intel QuickAssist Technology C3x
 device, kernel 4.5 or greater is needed.
 See instructions for `Installation using kernel.org driver`_ below.
 
-
 Installation using 01.org QAT driver
 ------------------------------------
 
diff --git a/doc/guides/freebsd_gsg/install_from_ports.rst b/doc/guides/freebsd_gsg/install_from_ports.rst
index 81770291..44bbdfef 100644
--- a/doc/guides/freebsd_gsg/install_from_ports.rst
+++ b/doc/guides/freebsd_gsg/install_from_ports.rst
@@ -89,7 +89,7 @@ environmental variables should be set as below:
 .. note::
 
    To install a copy of the DPDK compiled using gcc, please download the
-   official DPDK package from http://dpdk.org/ and install manually using
+   official DPDK package from http://core.dpdk.org/download/ and install manually using
    the instructions given in the next chapter, :ref:`building_from_source`
 
 An example application can therefore be copied to a user's home directory and
diff --git a/doc/guides/howto/flow_bifurcation.rst b/doc/guides/howto/flow_bifurcation.rst
index 0d7226ae..cf5d6942 100644
--- a/doc/guides/howto/flow_bifurcation.rst
+++ b/doc/guides/howto/flow_bifurcation.rst
@@ -296,4 +296,4 @@ The typical procedure to achieve this is as follows:
      'not involved', while ``00`` or no mask means 'involved'.
 
    * For more details of the configuration, refer to the
-     `cloud filter test plan <http://dpdk.org/browse/tools/dts/tree/test_plans/cloud_filter_test_plan.rst>`_
+     `cloud filter test plan <http://git.dpdk.org/tools/dts/tree/test_plans/cloud_filter_test_plan.rst>`_
diff --git a/doc/guides/linux_gsg/nic_perf_intel_platform.rst b/doc/guides/linux_gsg/nic_perf_intel_platform.rst
index d4a83624..e6cf1b94 100644
--- a/doc/guides/linux_gsg/nic_perf_intel_platform.rst
+++ b/doc/guides/linux_gsg/nic_perf_intel_platform.rst
@@ -64,7 +64,7 @@ This aligns with the previous output which showed that each channel has one memo
 Network Interface Card Requirements
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
-Use a `DPDK supported <http://dpdk.org/doc/nics>`_ high end NIC such as the Intel XL710 40GbE.
+Use a `DPDK supported <http://core.dpdk.org/supported/>`_ high end NIC such as the Intel XL710 40GbE.
 
 Make sure each NIC has been flashed the latest version of NVM/firmware.
 
diff --git a/doc/guides/linux_gsg/sys_reqs.rst b/doc/guides/linux_gsg/sys_reqs.rst
index 3d743421..4845ca45 100644
--- a/doc/guides/linux_gsg/sys_reqs.rst
+++ b/doc/guides/linux_gsg/sys_reqs.rst
@@ -86,6 +86,12 @@ Compilation of the DPDK
 
 .. note::
 
+*   Library for handling NUMA (Non Uniform Memory Access).
+
+    * numactl-devel in Red Hat/Fedora;
+
+    * libnuma-dev in Debian/Ubuntu;
+
     Python, version 2.6 or 2.7, to use various helper scripts included in the DPDK package.
 
 
diff --git a/doc/guides/nics/ena.rst b/doc/guides/nics/ena.rst
index 073b35ae..9062d7bf 100644
--- a/doc/guides/nics/ena.rst
+++ b/doc/guides/nics/ena.rst
@@ -187,11 +187,20 @@ Prerequisites
 -------------
 
 #. Prepare the system as recommended by DPDK suite.  This includes environment
-   variables, hugepages configuration, tool-chains and configuration
+   variables, hugepages configuration, tool-chains and configuration.
 
-#. Insert igb_uio kernel module using the command 'modprobe igb_uio'
+#. ENA PMD can operate with ``vfio-pci`` or ``igb_uio`` driver.
 
-#. Bind the intended ENA device to igb_uio module
+#. Insert ``vfio-pci`` or ``igb_uio`` kernel module using the command
+   ``modprobe vfio-pci`` or ``modprobe igb_uio`` respectively.
+
+#. For ``vfio-pci`` users only:
+   Please make sure that ``IOMMU`` is enabled in your system,
+   or use ``vfio`` driver in ``noiommu`` mode::
+
+     echo 1 > /sys/module/vfio/parameters/enable_unsafe_noiommu_mode
+
+#. Bind the intended ENA device to ``vfio-pci`` or ``igb_uio`` module.
 
 
 At this point the system should be ready to run DPDK applications. Once the
diff --git a/doc/guides/nics/enic.rst b/doc/guides/nics/enic.rst
index c535b589..7738829e 100644
--- a/doc/guides/nics/enic.rst
+++ b/doc/guides/nics/enic.rst
@@ -39,7 +39,7 @@ How to obtain ENIC PMD integrated DPDK
 --------------------------------------
 
 ENIC PMD support is integrated into the DPDK suite. dpdk-<version>.tar.gz
-should be downloaded from http://dpdk.org
+should be downloaded from http://core.dpdk.org/download/
 
 
 Configuration information
@@ -140,6 +140,35 @@ Masking of these feilds for partial match is also supported.
 Without advanced filter support, the flow director is limited to IPv4
 perfect filtering of the 5-tuple with no masking of fields supported.
 
+Ingress VLAN Rewrite
+--------------------
+
+VIC adapters can tag, untag, or modify the VLAN headers of ingress
+packets. The ingress VLAN rewrite mode controls this behavior. By
+default, it is set to pass-through, where the NIC does not modify the
+VLAN header in any way so that the application can see the original
+header. This mode is sufficient for many applications, but may not be
+suitable for others. Such applications may change the mode by setting
+``devargs`` parameter ``ig-vlan-rewrite`` to one of the following.
+
+- ``pass``: Pass-through mode. The NIC does not modify the VLAN
+  header. This is the default mode.
+
+- ``priority``: Priority-tag default VLAN mode. If the ingress packet
+  is tagged with the default VLAN, the NIC replaces its VLAN header
+  with the priority tag (VLAN ID 0).
+
+- ``trunk``: Default trunk mode. The NIC tags untagged ingress packets
+  with the default VLAN. Tagged ingress packets are not modified. To
+  the application, every packet appears as tagged.
+
+- ``untag``: Untag default VLAN mode. If the ingress packet is tagged
+  with the default VLAN, the NIC removes or untags its VLAN header so
+  that the application sees an untagged packet. As a result, the
+  default VLAN becomes `untagged`. This mode can be useful for
+  applications such as OVS-DPDK performance benchmarks that utilize
+  only the default VLAN and want to see only untagged packets.
+
 Limitations
 -----------
 
@@ -153,9 +182,10 @@ Limitations
   In test setups where an Ethernet port of a Cisco adapter in TRUNK mode is
   connected point-to-point to another adapter port or connected though a router
   instead of a switch, all ingress packets will be VLAN tagged. Programs such
-  as l3fwd which do not account for VLAN tags in packets will misbehave. The
-  solution is to enable VLAN stripping on ingress. The follow code fragment is
-  example of how to accomplish this:
+  as l3fwd may not account for VLAN tags in packets and may misbehave. One
+  solution is to enable VLAN stripping on ingress so the VLAN tag is removed
+  from the packet and put into the mbuf->vlan_tci field. Here is an example
+  of how to accomplish this:
 
 .. code-block:: console
 
@@ -163,6 +193,14 @@ Limitations
      vlan_offload |= ETH_VLAN_STRIP_OFFLOAD;
      rte_eth_dev_set_vlan_offload(port, vlan_offload);
 
+Another alternative is modify the adapter's ingress VLAN rewrite mode so that
+packets with the default VLAN tag are stripped by the adapter and presented to
+DPDK as untagged packets. In this case mbuf->vlan_tci and the PKT_RX_VLAN and
+PKT_RX_VLAN_STRIPPED mbuf flags would not be set. This mode is enabled with the
+``devargs`` parameter ``ig-vlan-rewrite=untag``. For example::
+
+    -w 12:00.0,ig-vlan-rewrite=untag
+
 - Limited flow director support on 1200 series and 1300 series Cisco VIC
   adapters with old firmware. Please see :ref:`enic-flow-director`.
 
diff --git a/doc/guides/nics/features/ena.ini b/doc/guides/nics/features/ena.ini
index 74969fd0..d607fcc3 100644
--- a/doc/guides/nics/features/ena.ini
+++ b/doc/guides/nics/features/ena.ini
@@ -22,5 +22,6 @@ Inner L4 checksum    = Y
 Basic stats          = Y
 Extended stats       = Y
 Linux UIO            = Y
+Linux VFIO           = Y
 x86-32               = Y
 x86-64               = Y
diff --git a/doc/guides/rel_notes/release_16_11.rst b/doc/guides/rel_notes/release_16_11.rst
index 012cf73a..5d54b23a 100644
--- a/doc/guides/rel_notes/release_16_11.rst
+++ b/doc/guides/rel_notes/release_16_11.rst
@@ -1363,3 +1363,120 @@ Fixes in 16.11 LTS Release
 * test/hash: fix potential memory leak
 * test/virtual_pmd: add MAC address setting fake op
 * vhost: fix missing increment of log cache count
+
+16.11.9
+~~~~~~~
+
+* acl: forbid rule with priority zero
+* app/testpmd: fix csum parse-tunnel command invocation
+* app/testpmd: fix displaying RSS hash functions
+* app/testpmd: fix duplicate exit
+* app/testpmd: fix L4 length for UDP checksum
+* app/testpmd: optimize mbuf pool allocation
+* build: enable ARM NEON flag when __aarch64__ defined
+* bus/pci: fix allocation of device path
+* config: enable more than 128 cores for arm64
+* config: make AVX and AVX512 configurable
+* doc: add VFIO in ENA guide
+* doc: fix formatting in IP reassembly app guide
+* doc: fix NUMA library name in Linux guide
+* doc: fix typo in testpmd guide
+* doc: fix wrong usage of bind command
+* eal: fix build
+* eal: fix build with gcc 9.0
+* eal: fix build with -O1
+* eal: introduce rte version of fls
+* eal/linux: fix memory leak of logid
+* eal/linux: handle UIO read failure in interrupt handler
+* eal: use correct data type for bitmap slab operations
+* ethdev: fix doxygen comment to be with structure
+* ethdev: fix invalid configuration after failure
+* ethdev: fix queue start and stop
+* examples/ipv4_multicast: fix leak of cloned packets
+* examples/vhost: remove unnecessary constant
+* fix dpdk.org URLs
+* fix global variable issues
+* hash: fix key store element alignment
+* hash: remove unnecessary pause
+* igb_uio: fix unexpected removal for hot-unplug
+* igb_uio: issue FLR during open and release of device file
+* igb_uio: remove device reset in open
+* igb_uio: remove device reset in release
+* ip_frag: check fragment length of incoming packet
+* ip_frag: fix overflow in key comparison
+* ip_frag: use key length for key comparison
+* kni: fix build on CentOS 7.4
+* kni: fix build on Linux < 3.14
+* kni: fix build on Linux 4.19
+* kni: fix build on Suse 12 SP3
+* kni: fix kernel FIFO synchronization
+* kni: fix possible uninitialized variable
+* kni: fix SLE version detection
+* kvargs: fix processing a null list
+* mk: disable gcc AVX512F support
+* net/bnx2x: fix call to link handling periodic function
+* net/bnx2x: fix logging to include device name
+* net/bnx2x: fix to add PHY lock
+* net/bnx2x: fix to disable further interrupts
+* net/bnx2x: fix VF link state update
+* net/bnxt: fix uninitialized pointer access in Tx
+* net/bnxt: reduce polling interval for valid bit
+* net/bnxt: remove excess log messages
+* net/bnxt: set a VNIC as default only once
+* net/bnxt: set MAC filtering as outer for non tunnel frames
+* net/bonding: do not ignore RSS key on device config
+* net/bonding: fix crash when stopping mode 4 port
+* net/bonding: fix Rx slave fairness
+* net/bonding: reduce slave starvation on Rx poll
+* net/bonding: stop and deactivate slaves on stop
+* net/bonding: support matching QinQ ethertype
+* net/bonding: use evenly distributed default RSS RETA
+* net/e1000/base: fix uninitialized variable
+* net/e1000: do not error out if Rx drop enable is set
+* net/ena: fix passing RSS hash to mbuf
+* net/enic: add dependency on librte_kvargs
+* net/enic: add devarg to specify ingress VLAN rewrite mode
+* net/enic: do not use non-standard integer types
+* net/enic: set Rx VLAN offload flag for non-stripped packets
+* net: fix build with pedantic
+* net/i40e/base: correct global reset timeout calculation
+* net/i40e/base: fix partition id calculation for X722
+* net/i40e/base: gracefully clean the resources
+* net/i40e/base: properly clean resources
+* net/i40e: enable loopback function for X722 MAC
+* net/i40e: fix send admin queue command before init
+* net/i40e: fix X710 Rx after reading some registers
+* net/i40e: keep promiscuous on if allmulticast is enabled
+* net/i40e: update Tx offload mask
+* net/igb: update Tx offload mask
+* net/ixgbe: fix maximum wait time in comment
+* net/ixgbe: fix TDH register write
+* net/ixgbe: update Tx offload mask
+* net/ixgbevf: fix link state
+* net/ixgbe: wait longer for link after fiber MAC setup
+* net/mlx5: fix build on PPC64
+* net/nfp: fix live MAC changes not supported
+* net/nfp: fix mbuf flags with checksum good
+* net/nfp: fix RSS
+* net/thunderx: fix Tx desc corruption in scatter-gather mode
+* net/vhost: fix parameters string
+* net/virtio: add missing supported features
+* net/virtio: register/unregister intr handler on start/stop
+* net/virtio-user: do not reset owner when driver resets
+* net/virtio-user: fix typo in error message
+* pci: fix parsing of address without function number
+* test/crypto: fix number of queue pairs
+* test/hash: fix bucket size in perf test
+* test/hash: fix build
+* test/kni: check module dependency
+* test/reorder: fix out of bound access
+* usertools: check for lspci dependency
+* version: 16.11.9-rc1
+* version: 16.11.9-rc2
+* vfio: fix build
+* vfio: fix build on old kernel
+* vhost: fix corner case for enqueue operation
+* vhost: fix payload size of reply
+* vhost: remove unneeded null pointer check
+* vhost-user: drop connection on message handling failures
+* vhost-user: fix false negative in handling user messages
diff --git a/doc/guides/sample_app_ug/ip_reassembly.rst b/doc/guides/sample_app_ug/ip_reassembly.rst
index 3c5cc708..4c75bd08 100644
--- a/doc/guides/sample_app_ug/ip_reassembly.rst
+++ b/doc/guides/sample_app_ug/ip_reassembly.rst
@@ -50,8 +50,8 @@ There are two key differences from the L2 Forwarding sample application:
 
 *   The second difference is that the application differentiates between IP and non-IP traffic by means of offload flags.
 
-The Longest Prefix Match (LPM for IPv4, LPM6 for IPv6) table is used to store/lookup an outgoing port number, associated with that IPv4 address. Any unmatched packets are forwarded to the originating port.Compiling the Application
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
+The Longest Prefix Match (LPM for IPv4, LPM6 for IPv6) table is used to store/lookup an outgoing port number,
+associated with that IPv4 address. Any unmatched packets are forwarded to the originating port.
 
 To compile the application:
 
diff --git a/doc/guides/sample_app_ug/ipv4_multicast.rst b/doc/guides/sample_app_ug/ipv4_multicast.rst
index 72da8c42..6badc681 100644
--- a/doc/guides/sample_app_ug/ipv4_multicast.rst
+++ b/doc/guides/sample_app_ug/ipv4_multicast.rst
@@ -365,7 +365,6 @@ It is the mcast_out_pkt() function that performs the packet duplication (either
         hdr->pkt.in_port = pkt->pkt.in_port;
         hdr->pkt.vlan_macip = pkt->pkt.vlan_macip;
         hdr->pkt.hash = pkt->pkt.hash;
-        hdr->ol_flags = pkt->ol_flags;
         rte_mbuf_sanity_check(hdr, RTE_MBUF_PKT, 1);
 
         return hdr;
diff --git a/doc/guides/sample_app_ug/vhost.rst b/doc/guides/sample_app_ug/vhost.rst
index 1f6d0d96..c9a605fc 100644
--- a/doc/guides/sample_app_ug/vhost.rst
+++ b/doc/guides/sample_app_ug/vhost.rst
@@ -115,7 +115,7 @@ could be done by:
 .. code-block:: console
 
    modprobe uio_pci_generic
-   $RTE_SDK/tools/dpdk-devbind.py -b=uio_pci_generic 0000:00:04.0
+   $RTE_SDK/tools/dpdk-devbind.py -b uio_pci_generic 0000:00:04.0
 
 Then start testpmd for packet forwarding testing.
 
diff --git a/doc/guides/testpmd_app_ug/run_app.rst b/doc/guides/testpmd_app_ug/run_app.rst
index ac7d4582..65d54224 100644
--- a/doc/guides/testpmd_app_ug/run_app.rst
+++ b/doc/guides/testpmd_app_ug/run_app.rst
@@ -337,7 +337,7 @@ The commandline options are:
 
        io (the default)
        mac
-       mac_swap
+       macswap
        flowgen
        rxonly
        txonly
diff --git a/doc/guides/testpmd_app_ug/testpmd_funcs.rst b/doc/guides/testpmd_app_ug/testpmd_funcs.rst
index a906974f..45280c1c 100644
--- a/doc/guides/testpmd_app_ug/testpmd_funcs.rst
+++ b/doc/guides/testpmd_app_ug/testpmd_funcs.rst
@@ -201,7 +201,7 @@ show port rss-hash
 
 Display the RSS hash functions and RSS hash key of a port::
 
-   testpmd> show port (port_id) rss-hash ipv4|ipv4-frag|ipv4-tcp|ipv4-udp|ipv4-sctp|ipv4-other|ipv6|ipv6-frag|ipv6-tcp|ipv6-udp|ipv6-sctp|ipv6-other|l2-payload|ipv6-ex|ipv6-tcp-ex|ipv6-udp-ex [key]
+   testpmd> show port (port_id) rss-hash [key]
 
 clear port
 ~~~~~~~~~~
diff --git a/drivers/net/bnx2x/bnx2x.c b/drivers/net/bnx2x/bnx2x.c
index f1de3362..7cf9d1c4 100644
--- a/drivers/net/bnx2x/bnx2x.c
+++ b/drivers/net/bnx2x/bnx2x.c
@@ -114,6 +114,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);
@@ -181,13 +182,14 @@ bnx2x_dma_alloc(struct bnx2x_softc *sc, size_t size, struct bnx2x_dma *dma,
 					SOCKET_ID_ANY,
 					0, align);
 	if (z == NULL) {
-		PMD_DRV_LOG(ERR, "DMA alloc failed for %s", msg);
+		PMD_DRV_LOG(ERR, sc, "DMA alloc failed for %s", msg);
 		return -ENOMEM;
 	}
 	dma->paddr = (uint64_t) z->phys_addr;
 	dma->vaddr = z->addr;
 
-	PMD_DRV_LOG(DEBUG, "%s: virt=%p phys=%" PRIx64, msg, dma->vaddr, dma->paddr);
+	PMD_DRV_LOG(DEBUG, sc,
+		    "%s: virt=%p phys=%" PRIx64, msg, dma->vaddr, dma->paddr);
 
 	return 0;
 }
@@ -200,11 +202,16 @@ static int bnx2x_acquire_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
 	uint32_t hw_lock_control_reg;
 	int cnt;
 
-	PMD_INIT_FUNC_TRACE();
+#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,
+		PMD_DRV_LOG(NOTICE, sc,
 			    "resource 0x%x > HW_LOCK_MAX_RESOURCE_VALUE",
 			    resource);
 		return -1;
@@ -220,7 +227,7 @@ static int bnx2x_acquire_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
 	/* validate the resource is not already taken */
 	lock_status = REG_RD(sc, hw_lock_control_reg);
 	if (lock_status & resource_bit) {
-		PMD_DRV_LOG(NOTICE,
+		PMD_DRV_LOG(NOTICE, sc,
 			    "resource in use (status 0x%x bit 0x%x)",
 			    lock_status, resource_bit);
 		return -1;
@@ -236,7 +243,8 @@ static int bnx2x_acquire_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
 		DELAY(5000);
 	}
 
-	PMD_DRV_LOG(NOTICE, "Resource lock timeout!");
+	PMD_DRV_LOG(NOTICE, sc, "Resource 0x%x resource_bit 0x%x lock timeout!",
+		    resource, resource_bit);
 	return -1;
 }
 
@@ -247,13 +255,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;
 
-	PMD_INIT_FUNC_TRACE();
+#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,
-			    "resource 0x%x > HW_LOCK_MAX_RESOURCE_VALUE",
-			    resource);
+		PMD_DRV_LOG(NOTICE, sc,
+			    "(resource 0x%x > HW_LOCK_MAX_RESOURCE_VALUE)"
+			    " resource_bit 0x%x", resource, resource_bit);
 		return -1;
 	}
 
@@ -267,7 +280,7 @@ static int bnx2x_release_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
 	/* validate the resource is currently taken */
 	lock_status = REG_RD(sc, hw_lock_control_reg);
 	if (!(lock_status & resource_bit)) {
-		PMD_DRV_LOG(NOTICE,
+		PMD_DRV_LOG(NOTICE, sc,
 			    "resource not in use (status 0x%x bit 0x%x)",
 			    lock_status, resource_bit);
 		return -1;
@@ -277,6 +290,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)
 {
@@ -369,7 +394,7 @@ bnx2x_issue_dmae_with_comp(struct bnx2x_softc *sc, struct dmae_command *dmae)
 		if (!timeout ||
 		    (sc->recovery_state != BNX2X_RECOVERY_DONE &&
 		     sc->recovery_state != BNX2X_RECOVERY_NIC_LOADING)) {
-			PMD_DRV_LOG(INFO, "DMAE timeout!");
+			PMD_DRV_LOG(INFO, sc, "DMAE timeout!");
 			return DMAE_TIMEOUT;
 		}
 
@@ -378,7 +403,7 @@ bnx2x_issue_dmae_with_comp(struct bnx2x_softc *sc, struct dmae_command *dmae)
 	}
 
 	if (*wb_comp & DMAE_PCI_ERR_FLAG) {
-		PMD_DRV_LOG(INFO, "DMAE PCI error!");
+		PMD_DRV_LOG(INFO, sc, "DMAE PCI error!");
 		return DMAE_PCI_ERROR;
 	}
 
@@ -537,7 +562,7 @@ void
 elink_cb_event_log(__rte_unused struct bnx2x_softc *sc,
 		   __rte_unused const elink_log_id_t elink_log_id, ...)
 {
-	PMD_DRV_LOG(DEBUG, "ELINK EVENT LOG (%d)", elink_log_id);
+	PMD_DRV_LOG(DEBUG, sc, "ELINK EVENT LOG (%d)", elink_log_id);
 }
 
 static int bnx2x_set_spio(struct bnx2x_softc *sc, int spio, uint32_t mode)
@@ -546,7 +571,7 @@ static int bnx2x_set_spio(struct bnx2x_softc *sc, int spio, uint32_t mode)
 
 	/* Only 2 SPIOs are configurable */
 	if ((spio != MISC_SPIO_SPIO4) && (spio != MISC_SPIO_SPIO5)) {
-		PMD_DRV_LOG(NOTICE, "Invalid SPIO 0x%x", spio);
+		PMD_DRV_LOG(NOTICE, sc, "Invalid SPIO 0x%x", spio);
 		return -1;
 	}
 
@@ -596,7 +621,7 @@ static int bnx2x_gpio_read(struct bnx2x_softc *sc, int gpio_num, uint8_t port)
 	uint32_t gpio_reg;
 
 	if (gpio_num > MISC_REGISTERS_GPIO_3) {
-		PMD_DRV_LOG(NOTICE, "Invalid GPIO %d", gpio_num);
+		PMD_DRV_LOG(NOTICE, sc, "Invalid GPIO %d", gpio_num);
 		return -1;
 	}
 
@@ -621,7 +646,7 @@ bnx2x_gpio_write(struct bnx2x_softc *sc, int gpio_num, uint32_t mode, uint8_t po
 	uint32_t gpio_reg;
 
 	if (gpio_num > MISC_REGISTERS_GPIO_3) {
-		PMD_DRV_LOG(NOTICE, "Invalid GPIO %d", gpio_num);
+		PMD_DRV_LOG(NOTICE, sc, "Invalid GPIO %d", gpio_num);
 		return -1;
 	}
 
@@ -690,7 +715,8 @@ bnx2x_gpio_mult_write(struct bnx2x_softc *sc, uint8_t pins, uint32_t mode)
 		break;
 
 	default:
-		PMD_DRV_LOG(NOTICE, "Invalid GPIO mode assignment %d", mode);
+		PMD_DRV_LOG(NOTICE, sc,
+			    "Invalid GPIO mode assignment %d", mode);
 		bnx2x_release_hw_lock(sc, HW_LOCK_RESOURCE_GPIO);
 		return -1;
 	}
@@ -716,7 +742,7 @@ bnx2x_gpio_int_write(struct bnx2x_softc *sc, int gpio_num, uint32_t mode,
 	uint32_t gpio_reg;
 
 	if (gpio_num > MISC_REGISTERS_GPIO_3) {
-		PMD_DRV_LOG(NOTICE, "Invalid GPIO %d", gpio_num);
+		PMD_DRV_LOG(NOTICE, sc, "Invalid GPIO %d", gpio_num);
 		return -1;
 	}
 
@@ -793,7 +819,7 @@ elink_cb_fw_command(struct bnx2x_softc *sc, uint32_t command, uint32_t param)
 	SHMEM_WR(sc, func_mb[mb_idx].drv_mb_param, param);
 	SHMEM_WR(sc, func_mb[mb_idx].drv_mb_header, (command | seq));
 
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 		    "wrote command 0x%08x to FW MB param 0x%08x",
 		    (command | seq), param);
 
@@ -808,7 +834,7 @@ elink_cb_fw_command(struct bnx2x_softc *sc, uint32_t command, uint32_t param)
 		rc &= FW_MSG_CODE_MASK;
 	} else {
 		/* Ruh-roh! */
-		PMD_DRV_LOG(NOTICE, "FW failed to respond!");
+		PMD_DRV_LOG(NOTICE, sc, "FW failed to respond!");
 		rc = 0;
 	}
 
@@ -1026,12 +1052,12 @@ bnx2x_sp_post(struct bnx2x_softc *sc, int command, int cid, uint32_t data_hi,
 
 	if (common) {
 		if (!atomic_load_acq_long(&sc->eq_spq_left)) {
-			PMD_DRV_LOG(INFO, "EQ ring is full!");
+			PMD_DRV_LOG(INFO, sc, "EQ ring is full!");
 			return -1;
 		}
 	} else {
 		if (!atomic_load_acq_long(&sc->cq_spq_left)) {
-			PMD_DRV_LOG(INFO, "SPQ ring is full!");
+			PMD_DRV_LOG(INFO, sc, "SPQ ring is full!");
 			return -1;
 		}
 	}
@@ -1064,7 +1090,7 @@ bnx2x_sp_post(struct bnx2x_softc *sc, int command, int cid, uint32_t data_hi,
 		atomic_subtract_acq_long(&sc->cq_spq_left, 1);
 	}
 
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 		    "SPQE[%x] (%x:%x) (cmd, common?) (%d,%d) hw_cid %x"
 		    "data (%x:%x) type(0x%x) left (CQ, EQ) (%lx,%lx)",
 		    sc->spq_prod_idx,
@@ -1137,44 +1163,45 @@ bnx2x_sp_event(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp,
 	enum ecore_queue_cmd drv_cmd = ECORE_Q_CMD_MAX;
 	struct ecore_queue_sp_obj *q_obj = &BNX2X_SP_OBJ(sc, fp).q_obj;
 
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 		    "fp=%d cid=%d got ramrod #%d state is %x type is %d",
 		    fp->index, cid, command, sc->state,
 		    rr_cqe->ramrod_cqe.ramrod_type);
 
 	switch (command) {
 	case (RAMROD_CMD_ID_ETH_CLIENT_UPDATE):
-		PMD_DRV_LOG(DEBUG, "got UPDATE ramrod. CID %d", cid);
+		PMD_DRV_LOG(DEBUG, sc, "got UPDATE ramrod. CID %d", cid);
 		drv_cmd = ECORE_Q_CMD_UPDATE;
 		break;
 
 	case (RAMROD_CMD_ID_ETH_CLIENT_SETUP):
-		PMD_DRV_LOG(DEBUG, "got MULTI[%d] setup ramrod", cid);
+		PMD_DRV_LOG(DEBUG, sc, "got MULTI[%d] setup ramrod", cid);
 		drv_cmd = ECORE_Q_CMD_SETUP;
 		break;
 
 	case (RAMROD_CMD_ID_ETH_TX_QUEUE_SETUP):
-		PMD_DRV_LOG(DEBUG, "got MULTI[%d] tx-only setup ramrod", cid);
+		PMD_DRV_LOG(DEBUG, sc,
+			    "got MULTI[%d] tx-only setup ramrod", cid);
 		drv_cmd = ECORE_Q_CMD_SETUP_TX_ONLY;
 		break;
 
 	case (RAMROD_CMD_ID_ETH_HALT):
-		PMD_DRV_LOG(DEBUG, "got MULTI[%d] halt ramrod", cid);
+		PMD_DRV_LOG(DEBUG, sc, "got MULTI[%d] halt ramrod", cid);
 		drv_cmd = ECORE_Q_CMD_HALT;
 		break;
 
 	case (RAMROD_CMD_ID_ETH_TERMINATE):
-		PMD_DRV_LOG(DEBUG, "got MULTI[%d] teminate ramrod", cid);
+		PMD_DRV_LOG(DEBUG, sc, "got MULTI[%d] teminate ramrod", cid);
 		drv_cmd = ECORE_Q_CMD_TERMINATE;
 		break;
 
 	case (RAMROD_CMD_ID_ETH_EMPTY):
-		PMD_DRV_LOG(DEBUG, "got MULTI[%d] empty ramrod", cid);
+		PMD_DRV_LOG(DEBUG, sc, "got MULTI[%d] empty ramrod", cid);
 		drv_cmd = ECORE_Q_CMD_EMPTY;
 		break;
 
 	default:
-		PMD_DRV_LOG(DEBUG,
+		PMD_DRV_LOG(DEBUG, sc,
 			    "ERROR: unexpected MC reply (%d)"
 			    "on fp[%d]", command, fp->index);
 		return;
@@ -1196,7 +1223,7 @@ bnx2x_sp_event(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp,
 
 	atomic_add_acq_long(&sc->cq_spq_left, 1);
 
-	PMD_DRV_LOG(DEBUG, "sc->cq_spq_left 0x%lx",
+	PMD_DRV_LOG(DEBUG, sc, "sc->cq_spq_left 0x%lx",
 		    atomic_load_acq_long(&sc->cq_spq_left));
 }
 
@@ -1392,7 +1419,7 @@ bnx2x_del_all_macs(struct bnx2x_softc *sc, struct ecore_vlan_mac_obj *mac_obj,
 
 	rc = mac_obj->delete_all(sc, mac_obj, &vlan_mac_flags, &ramrod_flags);
 	if (rc < 0)
-		PMD_DRV_LOG(ERR, "Failed to delete MACs (%d)", rc);
+		PMD_DRV_LOG(ERR, sc, "Failed to delete MACs (%d)", rc);
 
 	return rc;
 }
@@ -1543,13 +1570,13 @@ static int bnx2x_nic_load_no_mcp(struct bnx2x_softc *sc)
 	int path = SC_PATH(sc);
 	int port = SC_PORT(sc);
 
-	PMD_DRV_LOG(INFO, "NO MCP - load counts[%d]      %d, %d, %d",
+	PMD_DRV_LOG(INFO, sc, "NO MCP - load counts[%d]      %d, %d, %d",
 		    path, load_count[path][0], load_count[path][1],
 		    load_count[path][2]);
 
 	load_count[path][0]++;
 	load_count[path][1 + port]++;
-	PMD_DRV_LOG(INFO, "NO MCP - new load counts[%d]  %d, %d, %d",
+	PMD_DRV_LOG(INFO, sc, "NO MCP - new load counts[%d]  %d, %d, %d",
 		    path, load_count[path][0], load_count[path][1],
 		    load_count[path][2]);
 	if (load_count[path][0] == 1)
@@ -1566,12 +1593,12 @@ static int bnx2x_nic_unload_no_mcp(struct bnx2x_softc *sc)
 	int port = SC_PORT(sc);
 	int path = SC_PATH(sc);
 
-	PMD_DRV_LOG(INFO, "NO MCP - load counts[%d]      %d, %d, %d",
+	PMD_DRV_LOG(INFO, sc, "NO MCP - load counts[%d]      %d, %d, %d",
 		    path, load_count[path][0], load_count[path][1],
 		    load_count[path][2]);
 	load_count[path][0]--;
 	load_count[path][1 + port]--;
-	PMD_DRV_LOG(INFO, "NO MCP - new load counts[%d]  %d, %d, %d",
+	PMD_DRV_LOG(INFO, sc, "NO MCP - new load counts[%d]  %d, %d, %d",
 		    path, load_count[path][0], load_count[path][1],
 		    load_count[path][2]);
 	if (load_count[path][0] == 0) {
@@ -1651,7 +1678,7 @@ static int bnx2x_func_wait_started(struct bnx2x_softc *sc)
 		 */
 		struct ecore_func_state_params func_params = { NULL };
 
-		PMD_DRV_LOG(NOTICE, "Unexpected function state! "
+		PMD_DRV_LOG(NOTICE, sc, "Unexpected function state! "
 			    "Forcing STARTED-->TX_STOPPED-->STARTED");
 
 		func_params.f_obj = &sc->func_obj;
@@ -1675,7 +1702,7 @@ static int bnx2x_stop_queue(struct bnx2x_softc *sc, int index)
 	struct ecore_queue_state_params q_params = { NULL };
 	int rc;
 
-	PMD_DRV_LOG(DEBUG, "stopping queue %d cid %d", index, fp->index);
+	PMD_DRV_LOG(DEBUG, sc, "stopping queue %d cid %d", index, fp->index);
 
 	q_params.q_obj = &sc->sp_objs[fp->index].q_obj;
 	/* We want to wait for completion in this context */
@@ -1726,7 +1753,7 @@ static uint8_t bnx2x_wait_sp_comp(struct bnx2x_softc *sc, unsigned long mask)
 
 	tmp = atomic_load_acq_long(&sc->sp_state);
 	if (tmp & mask) {
-		PMD_DRV_LOG(INFO, "Filtering completion timed out: "
+		PMD_DRV_LOG(INFO, sc, "Filtering completion timed out: "
 			    "sp_state 0x%lx, mask 0x%lx", tmp, mask);
 		return FALSE;
 	}
@@ -1752,7 +1779,7 @@ static int bnx2x_func_stop(struct bnx2x_softc *sc)
 	 */
 	rc = ecore_func_state_change(sc, &func_params);
 	if (rc) {
-		PMD_DRV_LOG(NOTICE, "FUNC_STOP ramrod failed. "
+		PMD_DRV_LOG(NOTICE, sc, "FUNC_STOP ramrod failed. "
 			    "Running a dry transaction");
 		bnx2x_set_bit(RAMROD_DRV_CLR_ONLY, &func_params.ramrod_flags);
 		return ecore_func_state_change(sc, &func_params);
@@ -1801,14 +1828,16 @@ bnx2x_chip_cleanup(struct bnx2x_softc *sc, uint32_t unload_mode, uint8_t keep_li
 	rc = bnx2x_del_all_macs(sc, &sc->sp_objs[0].mac_obj, ECORE_ETH_MAC,
 			      FALSE);
 	if (rc < 0) {
-		PMD_DRV_LOG(NOTICE, "Failed to delete all ETH MACs (%d)", rc);
+		PMD_DRV_LOG(NOTICE, sc,
+			    "Failed to delete all ETH MACs (%d)", rc);
 	}
 
 	/* Clean up UC list  */
 	rc = bnx2x_del_all_macs(sc, &sc->sp_objs[0].mac_obj, ECORE_UC_LIST_MAC,
 			      TRUE);
 	if (rc < 0) {
-		PMD_DRV_LOG(NOTICE, "Failed to delete UC MACs list (%d)", rc);
+		PMD_DRV_LOG(NOTICE, sc,
+			    "Failed to delete UC MACs list (%d)", rc);
 	}
 
 	/* Disable LLH */
@@ -1831,7 +1860,7 @@ bnx2x_chip_cleanup(struct bnx2x_softc *sc, uint32_t unload_mode, uint8_t keep_li
 	rparam.mcast_obj = &sc->mcast_obj;
 	rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_DEL);
 	if (rc < 0) {
-		PMD_DRV_LOG(NOTICE,
+		PMD_DRV_LOG(NOTICE, sc,
 			    "Failed to send DEL MCAST command (%d)", rc);
 	}
 
@@ -1848,7 +1877,7 @@ bnx2x_chip_cleanup(struct bnx2x_softc *sc, uint32_t unload_mode, uint8_t keep_li
 	 */
 	rc = bnx2x_func_wait_started(sc);
 	if (rc) {
-		PMD_DRV_LOG(NOTICE, "bnx2x_func_wait_started failed");
+		PMD_DRV_LOG(NOTICE, sc, "bnx2x_func_wait_started failed");
 	}
 
 	/*
@@ -1866,14 +1895,14 @@ bnx2x_chip_cleanup(struct bnx2x_softc *sc, uint32_t unload_mode, uint8_t keep_li
 	 * very wrong has happen.
 	 */
 	if (!bnx2x_wait_sp_comp(sc, ~0x0UL)) {
-		PMD_DRV_LOG(NOTICE, "Common slow path ramrods got stuck!");
+		PMD_DRV_LOG(NOTICE, sc, "Common slow path ramrods got stuck!");
 	}
 
 unload_error:
 
 	rc = bnx2x_func_stop(sc);
 	if (rc) {
-		PMD_DRV_LOG(NOTICE, "Function stop failed!");
+		PMD_DRV_LOG(NOTICE, sc, "Function stop failed!");
 	}
 
 	/* disable HW interrupts */
@@ -1882,7 +1911,7 @@ unload_error:
 	/* Reset the chip */
 	rc = bnx2x_reset_hw(sc, reset_code);
 	if (rc) {
-		PMD_DRV_LOG(NOTICE, "Hardware reset failed");
+		PMD_DRV_LOG(NOTICE, sc, "Hardware reset failed");
 	}
 
 	/* Report UNLOAD_DONE to MCP */
@@ -1893,7 +1922,7 @@ static void bnx2x_disable_close_the_gate(struct bnx2x_softc *sc)
 {
 	uint32_t val;
 
-	PMD_DRV_LOG(DEBUG, "Disabling 'close the gates'");
+	PMD_DRV_LOG(DEBUG, sc, "Disabling 'close the gates'");
 
 	val = REG_RD(sc, MISC_REG_AEU_GENERAL_MASK);
 	val &= ~(MISC_AEU_GENERAL_MASK_REG_AEU_PXP_CLOSE_MASK |
@@ -1924,7 +1953,7 @@ static void bnx2x_squeeze_objects(struct bnx2x_softc *sc)
 	rc = mac_obj->delete_all(sc, &sc->sp_objs->mac_obj, &vlan_mac_flags,
 				 &ramrod_flags);
 	if (rc != 0) {
-		PMD_DRV_LOG(NOTICE, "Failed to clean ETH MACs (%d)", rc);
+		PMD_DRV_LOG(NOTICE, sc, "Failed to clean ETH MACs (%d)", rc);
 	}
 
 	/* Cleanup UC list */
@@ -1932,7 +1961,8 @@ static void bnx2x_squeeze_objects(struct bnx2x_softc *sc)
 	bnx2x_set_bit(ECORE_UC_LIST_MAC, &vlan_mac_flags);
 	rc = mac_obj->delete_all(sc, mac_obj, &vlan_mac_flags, &ramrod_flags);
 	if (rc != 0) {
-		PMD_DRV_LOG(NOTICE, "Failed to clean UC list MACs (%d)", rc);
+		PMD_DRV_LOG(NOTICE, sc,
+			    "Failed to clean UC list MACs (%d)", rc);
 	}
 
 	/* Now clean mcast object... */
@@ -1943,7 +1973,7 @@ static void bnx2x_squeeze_objects(struct bnx2x_softc *sc)
 	/* Add a DEL command... */
 	rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_DEL);
 	if (rc < 0) {
-		PMD_DRV_LOG(NOTICE,
+		PMD_DRV_LOG(NOTICE, sc,
 			    "Failed to send DEL MCAST command (%d)", rc);
 	}
 
@@ -1952,7 +1982,7 @@ static void bnx2x_squeeze_objects(struct bnx2x_softc *sc)
 	rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_CONT);
 	while (rc != 0) {
 		if (rc < 0) {
-			PMD_DRV_LOG(NOTICE,
+			PMD_DRV_LOG(NOTICE, sc,
 				    "Failed to clean MCAST object (%d)", rc);
 			return;
 		}
@@ -1969,7 +1999,7 @@ bnx2x_nic_unload(struct bnx2x_softc *sc, uint32_t unload_mode, uint8_t keep_link
 	uint8_t global = FALSE;
 	uint32_t val;
 
-	PMD_DRV_LOG(DEBUG, "Starting NIC unload...");
+	PMD_DRV_LOG(DEBUG, sc, "Starting NIC unload...");
 
 	/* stop the periodic callout */
 	bnx2x_periodic_stop(sc);
@@ -1996,7 +2026,7 @@ bnx2x_nic_unload(struct bnx2x_softc *sc, uint32_t unload_mode, uint8_t keep_link
 		bnx2x_release_leader_lock(sc);
 		mb();
 
-		PMD_DRV_LOG(NOTICE, "Can't unload in closed or error state");
+		PMD_DRV_LOG(NOTICE, sc, "Can't unload in closed or error state");
 		return -1;
 	}
 
@@ -2101,7 +2131,7 @@ bnx2x_nic_unload(struct bnx2x_softc *sc, uint32_t unload_mode, uint8_t keep_link
 		bnx2x_disable_close_the_gate(sc);
 	}
 
-	PMD_DRV_LOG(DEBUG, "Ended NIC unload");
+	PMD_DRV_LOG(DEBUG, sc, "Ended NIC unload");
 
 	return 0;
 }
@@ -2249,7 +2279,7 @@ static void bnx2x_ilt_set_info(struct bnx2x_softc *sc)
 	struct ecore_ilt *ilt = sc->ilt;
 	uint16_t line = 0;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	ilt->start_line = FUNC_ILT_BASE(SC_FUNC(sc));
 
@@ -2403,7 +2433,7 @@ static int bnx2x_alloc_mem(struct bnx2x_softc *sc)
 	bnx2x_alloc_ilt_lines_mem(sc);
 
 	if (ecore_ilt_mem_op(sc, ILT_MEMOP_ALLOC)) {
-		PMD_DRV_LOG(NOTICE, "ecore_ilt_mem_op ILT_MEMOP_ALLOC failed");
+		PMD_DRV_LOG(NOTICE, sc, "ecore_ilt_mem_op ILT_MEMOP_ALLOC failed");
 		bnx2x_free_mem(sc);
 		return -1;
 	}
@@ -2606,7 +2636,7 @@ static void bnx2x_set_pf_load(struct bnx2x_softc *sc)
 
 	bnx2x_acquire_hw_lock(sc, HW_LOCK_RESOURCE_RECOVERY_REG);
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	val = REG_RD(sc, BNX2X_RECOVERY_GLOB_REG);
 
@@ -2659,14 +2689,14 @@ static uint8_t bnx2x_clear_pf_load(struct bnx2x_softc *sc)
 /* send load requrest to mcp and analyze response */
 static int bnx2x_nic_load_request(struct bnx2x_softc *sc, uint32_t * load_code)
 {
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	/* init fw_seq */
 	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, "initial fw_seq 0x%04x", sc->fw_seq);
+	PMD_DRV_LOG(DEBUG, sc, "initial fw_seq 0x%04x", sc->fw_seq);
 
 #ifdef BNX2X_PULSE
 	/* get the current FW pulse sequence */
@@ -2685,13 +2715,13 @@ static int bnx2x_nic_load_request(struct bnx2x_softc *sc, uint32_t * load_code)
 
 	/* if the MCP fails to respond we must abort */
 	if (!(*load_code)) {
-		PMD_DRV_LOG(NOTICE, "MCP response failure!");
+		PMD_DRV_LOG(NOTICE, sc, "MCP response failure!");
 		return -1;
 	}
 
 	/* if MCP refused then must abort */
 	if ((*load_code) == FW_MSG_CODE_DRV_LOAD_REFUSED) {
-		PMD_DRV_LOG(NOTICE, "MCP refused load request");
+		PMD_DRV_LOG(NOTICE, sc, "MCP refused load request");
 		return -1;
 	}
 
@@ -2718,12 +2748,12 @@ static int bnx2x_nic_load_analyze_req(struct bnx2x_softc *sc, uint32_t load_code
 
 		/* read loaded FW from chip */
 		loaded_fw = REG_RD(sc, XSEM_REG_PRAM);
-		PMD_DRV_LOG(DEBUG, "loaded FW 0x%08x / my FW 0x%08x",
+		PMD_DRV_LOG(DEBUG, sc, "loaded FW 0x%08x / my FW 0x%08x",
 			    loaded_fw, my_fw);
 
 		/* abort nic load if version mismatch */
 		if (my_fw != loaded_fw) {
-			PMD_DRV_LOG(NOTICE,
+			PMD_DRV_LOG(NOTICE, sc,
 				    "FW 0x%08x already loaded (mine is 0x%08x)",
 				    loaded_fw, my_fw);
 			return -1;
@@ -2738,7 +2768,7 @@ static void bnx2x_nic_load_pmf(struct bnx2x_softc *sc, uint32_t load_code)
 {
 	uint32_t ncsi_oem_data_addr;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	if ((load_code == FW_MSG_CODE_DRV_LOAD_COMMON) ||
 	    (load_code == FW_MSG_CODE_DRV_LOAD_COMMON_CHIP) ||
@@ -2753,7 +2783,7 @@ static void bnx2x_nic_load_pmf(struct bnx2x_softc *sc, uint32_t load_code)
 		sc->port.pmf = 0;
 	}
 
-	PMD_DRV_LOG(DEBUG, "pmf %d", sc->port.pmf);
+	PMD_DRV_LOG(DEBUG, sc, "pmf %d", sc->port.pmf);
 
 	if (load_code == FW_MSG_CODE_DRV_LOAD_COMMON_CHIP) {
 		if (SHMEM2_HAS(sc, ncsi_oem_data_addr)) {
@@ -2796,10 +2826,10 @@ static void bnx2x_read_mf_cfg(struct bnx2x_softc *sc)
 
 	if (sc->devinfo.mf_info.mf_config[SC_VN(sc)] &
 	    FUNC_MF_CFG_FUNC_DISABLED) {
-		PMD_DRV_LOG(DEBUG, "mf_cfg function disabled");
+		PMD_DRV_LOG(DEBUG, sc, "mf_cfg function disabled");
 		sc->flags |= BNX2X_MF_FUNC_DIS;
 	} else {
-		PMD_DRV_LOG(DEBUG, "mf_cfg function enabled");
+		PMD_DRV_LOG(DEBUG, sc, "mf_cfg function enabled");
 		sc->flags &= ~BNX2X_MF_FUNC_DIS;
 	}
 }
@@ -2820,7 +2850,7 @@ static int bnx2x_acquire_alr(struct bnx2x_softc *sc)
 	}
 
 	if (!(val & (1L << 31))) {
-		PMD_DRV_LOG(NOTICE, "Cannot acquire MCP access lock register");
+		PMD_DRV_LOG(NOTICE, sc, "Cannot acquire MCP access lock register");
 		return -1;
 	}
 
@@ -2848,7 +2878,7 @@ static void bnx2x_fan_failure(struct bnx2x_softc *sc)
 		 ext_phy_config);
 
 	/* log the failure */
-	PMD_DRV_LOG(INFO,
+	PMD_DRV_LOG(INFO, sc,
 		    "Fan Failure has caused the driver to shutdown "
 		    "the card to prevent permanent damage. "
 		    "Please contact OEM Support for assistance");
@@ -2905,7 +2935,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);
@@ -2926,7 +2956,7 @@ static void bnx2x_attn_int_asserted(struct bnx2x_softc *sc, uint32_t asserted)
 	uint32_t cnt;
 
 	if (sc->attn_state & asserted) {
-		PMD_DRV_LOG(ERR, "IGU ERROR attn=0x%08x", asserted);
+		PMD_DRV_LOG(ERR, sc, "IGU ERROR attn=0x%08x", asserted);
 	}
 
 	bnx2x_acquire_hw_lock(sc, HW_LOCK_RESOURCE_PORT0_ATT_MASK + port);
@@ -2944,6 +2974,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);
 
@@ -2958,45 +2989,45 @@ static void bnx2x_attn_int_asserted(struct bnx2x_softc *sc, uint32_t asserted)
 		}
 
 		if (asserted & ATTN_SW_TIMER_4_FUNC) {
-			PMD_DRV_LOG(DEBUG, "ATTN_SW_TIMER_4_FUNC!");
+			PMD_DRV_LOG(DEBUG, sc, "ATTN_SW_TIMER_4_FUNC!");
 		}
 
 		if (asserted & GPIO_2_FUNC) {
-			PMD_DRV_LOG(DEBUG, "GPIO_2_FUNC!");
+			PMD_DRV_LOG(DEBUG, sc, "GPIO_2_FUNC!");
 		}
 
 		if (asserted & GPIO_3_FUNC) {
-			PMD_DRV_LOG(DEBUG, "GPIO_3_FUNC!");
+			PMD_DRV_LOG(DEBUG, sc, "GPIO_3_FUNC!");
 		}
 
 		if (asserted & GPIO_4_FUNC) {
-			PMD_DRV_LOG(DEBUG, "GPIO_4_FUNC!");
+			PMD_DRV_LOG(DEBUG, sc, "GPIO_4_FUNC!");
 		}
 
 		if (port == 0) {
 			if (asserted & ATTN_GENERAL_ATTN_1) {
-				PMD_DRV_LOG(DEBUG, "ATTN_GENERAL_ATTN_1!");
+				PMD_DRV_LOG(DEBUG, sc, "ATTN_GENERAL_ATTN_1!");
 				REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_1, 0x0);
 			}
 			if (asserted & ATTN_GENERAL_ATTN_2) {
-				PMD_DRV_LOG(DEBUG, "ATTN_GENERAL_ATTN_2!");
+				PMD_DRV_LOG(DEBUG, sc, "ATTN_GENERAL_ATTN_2!");
 				REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_2, 0x0);
 			}
 			if (asserted & ATTN_GENERAL_ATTN_3) {
-				PMD_DRV_LOG(DEBUG, "ATTN_GENERAL_ATTN_3!");
+				PMD_DRV_LOG(DEBUG, sc, "ATTN_GENERAL_ATTN_3!");
 				REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_3, 0x0);
 			}
 		} else {
 			if (asserted & ATTN_GENERAL_ATTN_4) {
-				PMD_DRV_LOG(DEBUG, "ATTN_GENERAL_ATTN_4!");
+				PMD_DRV_LOG(DEBUG, sc, "ATTN_GENERAL_ATTN_4!");
 				REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_4, 0x0);
 			}
 			if (asserted & ATTN_GENERAL_ATTN_5) {
-				PMD_DRV_LOG(DEBUG, "ATTN_GENERAL_ATTN_5!");
+				PMD_DRV_LOG(DEBUG, sc, "ATTN_GENERAL_ATTN_5!");
 				REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_5, 0x0);
 			}
 			if (asserted & ATTN_GENERAL_ATTN_6) {
-				PMD_DRV_LOG(DEBUG, "ATTN_GENERAL_ATTN_6!");
+				PMD_DRV_LOG(DEBUG, sc, "ATTN_GENERAL_ATTN_6!");
 				REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_6, 0x0);
 			}
 		}
@@ -3010,7 +3041,7 @@ static void bnx2x_attn_int_asserted(struct bnx2x_softc *sc, uint32_t asserted)
 		reg_addr = (BAR_IGU_INTMEM + IGU_CMD_ATTN_BIT_SET_UPPER * 8);
 	}
 
-	PMD_DRV_LOG(DEBUG, "about to mask 0x%08x at %s addr 0x%08x",
+	PMD_DRV_LOG(DEBUG, sc, "about to mask 0x%08x at %s addr 0x%08x",
 		    asserted,
 		    (sc->devinfo.int_block == INT_BLOCK_HC) ? "HC" : "IGU",
 		    reg_addr);
@@ -3032,7 +3063,7 @@ static void bnx2x_attn_int_asserted(struct bnx2x_softc *sc, uint32_t asserted)
 				 && (++cnt < MAX_IGU_ATTN_ACK_TO));
 
 			if (!igu_acked) {
-				PMD_DRV_LOG(ERR,
+				PMD_DRV_LOG(ERR, sc,
 					    "Failed to verify IGU ack on time");
 			}
 
@@ -3041,6 +3072,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);
 	}
 }
 
@@ -3048,7 +3080,7 @@ static void
 bnx2x_print_next_block(__rte_unused struct bnx2x_softc *sc, __rte_unused int idx,
 		     __rte_unused const char *blk)
 {
-	PMD_DRV_LOG(INFO, "%s%s", idx ? ", " : "", blk);
+	PMD_DRV_LOG(INFO, sc, "%s%s", idx ? ", " : "", blk);
 }
 
 static int
@@ -3356,7 +3388,7 @@ bnx2x_parity_attn(struct bnx2x_softc *sc, uint8_t * global, uint8_t print,
 	    (sig[2] & HW_PRTY_ASSERT_SET_2) ||
 	    (sig[3] & HW_PRTY_ASSERT_SET_3) ||
 	    (sig[4] & HW_PRTY_ASSERT_SET_4)) {
-		PMD_DRV_LOG(ERR,
+		PMD_DRV_LOG(ERR, sc,
 			    "Parity error: HW block parity attention:"
 			    "[0]:0x%08x [1]:0x%08x [2]:0x%08x [3]:0x%08x [4]:0x%08x",
 			    (uint32_t) (sig[0] & HW_PRTY_ASSERT_SET_0),
@@ -3366,7 +3398,7 @@ bnx2x_parity_attn(struct bnx2x_softc *sc, uint8_t * global, uint8_t print,
 			    (uint32_t) (sig[4] & HW_PRTY_ASSERT_SET_4));
 
 		if (print)
-			PMD_DRV_LOG(INFO, "Parity errors detected in blocks: ");
+			PMD_DRV_LOG(INFO, sc, "Parity errors detected in blocks: ");
 
 		par_num =
 		    bnx2x_check_blocks_with_parity0(sc, sig[0] &
@@ -3390,7 +3422,7 @@ bnx2x_parity_attn(struct bnx2x_softc *sc, uint8_t * global, uint8_t print,
 						  par_num, print);
 
 		if (print)
-			PMD_DRV_LOG(INFO, "");
+			PMD_DRV_LOG(INFO, sc, "");
 
 		return TRUE;
 	}
@@ -3422,64 +3454,64 @@ static void bnx2x_attn_int_deasserted4(struct bnx2x_softc *sc, uint32_t attn)
 
 	if (attn & AEU_INPUTS_ATTN_BITS_PGLUE_HW_INTERRUPT) {
 		val = REG_RD(sc, PGLUE_B_REG_PGLUE_B_INT_STS_CLR);
-		PMD_DRV_LOG(INFO, "ERROR: PGLUE hw attention 0x%08x", val);
+		PMD_DRV_LOG(INFO, sc, "ERROR: PGLUE hw attention 0x%08x", val);
 		if (val & PGLUE_B_PGLUE_B_INT_STS_REG_ADDRESS_ERROR)
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_ADDRESS_ERROR");
 		if (val & PGLUE_B_PGLUE_B_INT_STS_REG_INCORRECT_RCV_BEHAVIOR)
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_INCORRECT_RCV_BEHAVIOR");
 		if (val & PGLUE_B_PGLUE_B_INT_STS_REG_WAS_ERROR_ATTN)
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_WAS_ERROR_ATTN");
 		if (val & PGLUE_B_PGLUE_B_INT_STS_REG_VF_LENGTH_VIOLATION_ATTN)
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_VF_LENGTH_VIOLATION_ATTN");
 		if (val &
 		    PGLUE_B_PGLUE_B_INT_STS_REG_VF_GRC_SPACE_VIOLATION_ATTN)
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_VF_GRC_SPACE_VIOLATION_ATTN");
 		if (val &
 		    PGLUE_B_PGLUE_B_INT_STS_REG_VF_MSIX_BAR_VIOLATION_ATTN)
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_VF_MSIX_BAR_VIOLATION_ATTN");
 		if (val & PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_ERROR_ATTN)
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_ERROR_ATTN");
 		if (val & PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_IN_TWO_RCBS_ATTN)
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_TCPL_IN_TWO_RCBS_ATTN");
 		if (val & PGLUE_B_PGLUE_B_INT_STS_REG_CSSNOOP_FIFO_OVERFLOW)
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "ERROR: PGLUE_B_PGLUE_B_INT_STS_REG_CSSNOOP_FIFO_OVERFLOW");
 	}
 
 	if (attn & AEU_INPUTS_ATTN_BITS_ATC_HW_INTERRUPT) {
 		val = REG_RD(sc, ATC_REG_ATC_INT_STS_CLR);
-		PMD_DRV_LOG(INFO, "ERROR: ATC hw attention 0x%08x", val);
+		PMD_DRV_LOG(INFO, sc, "ERROR: ATC hw attention 0x%08x", val);
 		if (val & ATC_ATC_INT_STS_REG_ADDRESS_ERROR)
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "ERROR: ATC_ATC_INT_STS_REG_ADDRESS_ERROR");
 		if (val & ATC_ATC_INT_STS_REG_ATC_TCPL_TO_NOT_PEND)
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "ERROR: ATC_ATC_INT_STS_REG_ATC_TCPL_TO_NOT_PEND");
 		if (val & ATC_ATC_INT_STS_REG_ATC_GPA_MULTIPLE_HITS)
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "ERROR: ATC_ATC_INT_STS_REG_ATC_GPA_MULTIPLE_HITS");
 		if (val & ATC_ATC_INT_STS_REG_ATC_RCPL_TO_EMPTY_CNT)
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "ERROR: ATC_ATC_INT_STS_REG_ATC_RCPL_TO_EMPTY_CNT");
 		if (val & ATC_ATC_INT_STS_REG_ATC_TCPL_ERROR)
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "ERROR: ATC_ATC_INT_STS_REG_ATC_TCPL_ERROR");
 		if (val & ATC_ATC_INT_STS_REG_ATC_IREQ_LESS_THAN_STU)
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "ERROR: ATC_ATC_INT_STS_REG_ATC_IREQ_LESS_THAN_STU");
 	}
 
 	if (attn & (AEU_INPUTS_ATTN_BITS_PGLUE_PARITY_ERROR |
 		    AEU_INPUTS_ATTN_BITS_ATC_PARITY_ERROR)) {
-		PMD_DRV_LOG(INFO,
+		PMD_DRV_LOG(INFO, sc,
 			    "ERROR: FATAL parity attention set4 0x%08x",
 			    (uint32_t) (attn &
 					(AEU_INPUTS_ATTN_BITS_PGLUE_PARITY_ERROR
@@ -3602,11 +3634,11 @@ static void bnx2x_dcc_event(struct bnx2x_softc *sc, uint32_t dcc_event)
  */
 		if (sc->devinfo.
 		    mf_info.mf_config[SC_VN(sc)] & FUNC_MF_CFG_FUNC_DISABLED) {
-			PMD_DRV_LOG(DEBUG, "mf_cfg function disabled");
+			PMD_DRV_LOG(DEBUG, sc, "mf_cfg function disabled");
 			sc->flags |= BNX2X_MF_FUNC_DIS;
 			bnx2x_e1h_disable(sc);
 		} else {
-			PMD_DRV_LOG(DEBUG, "mf_cfg function enabled");
+			PMD_DRV_LOG(DEBUG, sc, "mf_cfg function enabled");
 			sc->flags &= ~BNX2X_MF_FUNC_DIS;
 			bnx2x_e1h_enable(sc);
 		}
@@ -3661,7 +3693,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
 	last_idx =
 	    REG_RD8(sc, BAR_XSTRORM_INTMEM + XSTORM_ASSERT_LIST_INDEX_OFFSET);
 	if (last_idx)
-		PMD_DRV_LOG(ERR, "XSTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
+		PMD_DRV_LOG(ERR, sc, "XSTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
 
 	/* print the asserts */
 	for (i = 0; i < STORM_ASSERT_ARRAY_SIZE; i++) {
@@ -3683,7 +3715,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
 			   12);
 
 		if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
-			PMD_DRV_LOG(ERR,
+			PMD_DRV_LOG(ERR, sc,
 				    "XSTORM_ASSERT_INDEX 0x%x = 0x%08x 0x%08x 0x%08x 0x%08x",
 				    i, row3, row2, row1, row0);
 			rc++;
@@ -3696,7 +3728,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
 	last_idx =
 	    REG_RD8(sc, BAR_TSTRORM_INTMEM + TSTORM_ASSERT_LIST_INDEX_OFFSET);
 	if (last_idx) {
-		PMD_DRV_LOG(ERR, "TSTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
+		PMD_DRV_LOG(ERR, sc, "TSTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
 	}
 
 	/* print the asserts */
@@ -3719,7 +3751,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
 			   12);
 
 		if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
-			PMD_DRV_LOG(ERR,
+			PMD_DRV_LOG(ERR, sc,
 				    "TSTORM_ASSERT_INDEX 0x%x = 0x%08x 0x%08x 0x%08x 0x%08x",
 				    i, row3, row2, row1, row0);
 			rc++;
@@ -3732,7 +3764,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
 	last_idx =
 	    REG_RD8(sc, BAR_CSTRORM_INTMEM + CSTORM_ASSERT_LIST_INDEX_OFFSET);
 	if (last_idx) {
-		PMD_DRV_LOG(ERR, "CSTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
+		PMD_DRV_LOG(ERR, sc, "CSTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
 	}
 
 	/* print the asserts */
@@ -3755,7 +3787,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
 			   12);
 
 		if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
-			PMD_DRV_LOG(ERR,
+			PMD_DRV_LOG(ERR, sc,
 				    "CSTORM_ASSERT_INDEX 0x%x = 0x%08x 0x%08x 0x%08x 0x%08x",
 				    i, row3, row2, row1, row0);
 			rc++;
@@ -3768,7 +3800,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
 	last_idx =
 	    REG_RD8(sc, BAR_USTRORM_INTMEM + USTORM_ASSERT_LIST_INDEX_OFFSET);
 	if (last_idx) {
-		PMD_DRV_LOG(ERR, "USTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
+		PMD_DRV_LOG(ERR, sc, "USTORM_ASSERT_LIST_INDEX 0x%x", last_idx);
 	}
 
 	/* print the asserts */
@@ -3791,7 +3823,7 @@ static int bnx2x_mc_assert(struct bnx2x_softc *sc)
 			   12);
 
 		if (row0 != COMMON_ASM_INVALID_ASSERT_OPCODE) {
-			PMD_DRV_LOG(ERR,
+			PMD_DRV_LOG(ERR, sc,
 				    "USTORM_ASSERT_INDEX 0x%x = 0x%08x 0x%08x 0x%08x 0x%08x",
 				    i, row3, row2, row1, row0);
 			rc++;
@@ -3840,8 +3872,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);
 				}
@@ -3856,7 +3890,7 @@ static void bnx2x_attn_int_deasserted3(struct bnx2x_softc *sc, uint32_t attn)
 
 		} else if (attn & BNX2X_MC_ASSERT_BITS) {
 
-			PMD_DRV_LOG(ERR, "MC assert!");
+			PMD_DRV_LOG(ERR, sc, "MC assert!");
 			bnx2x_mc_assert(sc);
 			REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_10, 0);
 			REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_9, 0);
@@ -3866,24 +3900,24 @@ static void bnx2x_attn_int_deasserted3(struct bnx2x_softc *sc, uint32_t attn)
 
 		} else if (attn & BNX2X_MCP_ASSERT) {
 
-			PMD_DRV_LOG(ERR, "MCP assert!");
+			PMD_DRV_LOG(ERR, sc, "MCP assert!");
 			REG_WR(sc, MISC_REG_AEU_GENERAL_ATTN_11, 0);
 
 		} else {
-			PMD_DRV_LOG(ERR,
+			PMD_DRV_LOG(ERR, sc,
 				    "Unknown HW assert! (attn 0x%08x)", attn);
 		}
 	}
 
 	if (attn & EVEREST_LATCHED_ATTN_IN_USE_MASK) {
-		PMD_DRV_LOG(ERR, "LATCHED attention 0x%08x (masked)", attn);
+		PMD_DRV_LOG(ERR, sc, "LATCHED attention 0x%08x (masked)", attn);
 		if (attn & BNX2X_GRC_TIMEOUT) {
 			val = REG_RD(sc, MISC_REG_GRC_TIMEOUT_ATTN);
-			PMD_DRV_LOG(ERR, "GRC time-out 0x%08x", val);
+			PMD_DRV_LOG(ERR, sc, "GRC time-out 0x%08x", val);
 		}
 		if (attn & BNX2X_GRC_RSV) {
 			val = REG_RD(sc, MISC_REG_GRC_RSV_ATTN);
-			PMD_DRV_LOG(ERR, "GRC reserved 0x%08x", val);
+			PMD_DRV_LOG(ERR, sc, "GRC reserved 0x%08x", val);
 		}
 		REG_WR(sc, MISC_REG_AEU_CLR_LATCH_SIGNAL, 0x7ff);
 	}
@@ -3898,24 +3932,24 @@ static void bnx2x_attn_int_deasserted2(struct bnx2x_softc *sc, uint32_t attn)
 
 	if (attn & AEU_INPUTS_ATTN_BITS_CFC_HW_INTERRUPT) {
 		val = REG_RD(sc, CFC_REG_CFC_INT_STS_CLR);
-		PMD_DRV_LOG(ERR, "CFC hw attention 0x%08x", val);
+		PMD_DRV_LOG(ERR, sc, "CFC hw attention 0x%08x", val);
 /* CFC error attention */
 		if (val & 0x2) {
-			PMD_DRV_LOG(ERR, "FATAL error from CFC");
+			PMD_DRV_LOG(ERR, sc, "FATAL error from CFC");
 		}
 	}
 
 	if (attn & AEU_INPUTS_ATTN_BITS_PXP_HW_INTERRUPT) {
 		val = REG_RD(sc, PXP_REG_PXP_INT_STS_CLR_0);
-		PMD_DRV_LOG(ERR, "PXP hw attention-0 0x%08x", val);
+		PMD_DRV_LOG(ERR, sc, "PXP hw attention-0 0x%08x", val);
 /* RQ_USDMDP_FIFO_OVERFLOW */
 		if (val & 0x18000) {
-			PMD_DRV_LOG(ERR, "FATAL error from PXP");
+			PMD_DRV_LOG(ERR, sc, "FATAL error from PXP");
 		}
 
 		if (!CHIP_IS_E1x(sc)) {
 			val = REG_RD(sc, PXP_REG_PXP_INT_STS_CLR_1);
-			PMD_DRV_LOG(ERR, "PXP hw attention-1 0x%08x", val);
+			PMD_DRV_LOG(ERR, sc, "PXP hw attention-1 0x%08x", val);
 		}
 	}
 #define PXP2_EOP_ERROR_BIT  PXP2_PXP2_INT_STS_CLR_0_REG_WR_PGLUE_EOP_ERROR
@@ -3943,7 +3977,7 @@ static void bnx2x_attn_int_deasserted2(struct bnx2x_softc *sc, uint32_t attn)
 				val0 = REG_RD(sc, PXP2_REG_PXP2_INT_STS_CLR_0);
 
 			/* print the register, since no one can restore it */
-			PMD_DRV_LOG(ERR,
+			PMD_DRV_LOG(ERR, sc,
 				    "PXP2_REG_PXP2_INT_STS_CLR_0 0x%08x", val0);
 
 			/*
@@ -3951,7 +3985,7 @@ static void bnx2x_attn_int_deasserted2(struct bnx2x_softc *sc, uint32_t attn)
 			 * then notify
 			 */
 			if (val0 & PXP2_EOP_ERROR_BIT) {
-				PMD_DRV_LOG(ERR, "PXP2_WR_PGLUE_EOP_ERROR");
+				PMD_DRV_LOG(ERR, sc, "PXP2_WR_PGLUE_EOP_ERROR");
 
 				/*
 				 * if only PXP2_PXP2_INT_STS_0_REG_WR_PGLUE_EOP_ERROR is
@@ -3972,7 +4006,7 @@ static void bnx2x_attn_int_deasserted2(struct bnx2x_softc *sc, uint32_t attn)
 		val &= ~(attn & HW_INTERRUT_ASSERT_SET_2);
 		REG_WR(sc, reg_offset, val);
 
-		PMD_DRV_LOG(ERR,
+		PMD_DRV_LOG(ERR, sc,
 			    "FATAL HW block attention set2 0x%x",
 			    (uint32_t) (attn & HW_INTERRUT_ASSERT_SET_2));
 		rte_panic("HW block attention set2");
@@ -3987,10 +4021,10 @@ static void bnx2x_attn_int_deasserted1(struct bnx2x_softc *sc, uint32_t attn)
 
 	if (attn & AEU_INPUTS_ATTN_BITS_DOORBELLQ_HW_INTERRUPT) {
 		val = REG_RD(sc, DORQ_REG_DORQ_INT_STS_CLR);
-		PMD_DRV_LOG(ERR, "DB hw attention 0x%08x", val);
+		PMD_DRV_LOG(ERR, sc, "DB hw attention 0x%08x", val);
 /* DORQ discard attention */
 		if (val & 0x2) {
-			PMD_DRV_LOG(ERR, "FATAL error from DORQ");
+			PMD_DRV_LOG(ERR, sc, "FATAL error from DORQ");
 		}
 	}
 
@@ -4002,7 +4036,7 @@ static void bnx2x_attn_int_deasserted1(struct bnx2x_softc *sc, uint32_t attn)
 		val &= ~(attn & HW_INTERRUT_ASSERT_SET_1);
 		REG_WR(sc, reg_offset, val);
 
-		PMD_DRV_LOG(ERR,
+		PMD_DRV_LOG(ERR, sc,
 			    "FATAL HW block attention set1 0x%08x",
 			    (uint32_t) (attn & HW_INTERRUT_ASSERT_SET_1));
 		rte_panic("HW block attention set1");
@@ -4023,7 +4057,7 @@ static void bnx2x_attn_int_deasserted0(struct bnx2x_softc *sc, uint32_t attn)
 		val &= ~AEU_INPUTS_ATTN_BITS_SPIO5;
 		REG_WR(sc, reg_offset, val);
 
-		PMD_DRV_LOG(WARNING, "SPIO5 hw attention");
+		PMD_DRV_LOG(WARNING, sc, "SPIO5 hw attention");
 
 /* Fan failure attention */
 		elink_hw_reset_phy(&sc->link_params);
@@ -4031,7 +4065,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) {
@@ -4113,14 +4149,14 @@ static void bnx2x_attn_int_deasserted(struct bnx2x_softc *sc, uint32_t deasserte
 	}
 
 	val = ~deasserted;
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 		    "about to mask 0x%08x at %s addr 0x%08x", val,
 		    (sc->devinfo.int_block == INT_BLOCK_HC) ? "HC" : "IGU",
 		    reg_addr);
 	REG_WR(sc, reg_addr, val);
 
 	if (~sc->attn_state & deasserted) {
-		PMD_DRV_LOG(ERR, "IGU error");
+		PMD_DRV_LOG(ERR, sc, "IGU error");
 	}
 
 	reg_addr = port ? MISC_REG_AEU_MASK_ATTN_FUNC_1 :
@@ -4150,12 +4186,12 @@ static void bnx2x_attn_int(struct bnx2x_softc *sc)
 	uint32_t asserted = attn_bits & ~attn_ack & ~attn_state;
 	uint32_t deasserted = ~attn_bits & attn_ack & attn_state;
 
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 		    "attn_bits 0x%08x attn_ack 0x%08x asserted 0x%08x deasserted 0x%08x",
 		    attn_bits, attn_ack, asserted, deasserted);
 
 	if (~(attn_bits ^ attn_ack) & (attn_bits ^ attn_state)) {
-		PMD_DRV_LOG(ERR, "BAD attention state");
+		PMD_DRV_LOG(ERR, sc, "BAD attention state");
 	}
 
 	/* handle bits that were raised */
@@ -4212,7 +4248,7 @@ static void bnx2x_handle_mcast_eqe(struct bnx2x_softc *sc)
 	if (sc->mcast_obj.check_pending(&sc->mcast_obj)) {
 		rc = ecore_config_mcast(sc, &rparam, ECORE_MCAST_CMD_CONT);
 		if (rc < 0) {
-			PMD_DRV_LOG(INFO,
+			PMD_DRV_LOG(INFO, sc,
 				    "Failed to send pending mcast commands (%d)",
 				    rc);
 		}
@@ -4232,17 +4268,17 @@ bnx2x_handle_classification_eqe(struct bnx2x_softc *sc, union event_ring_elem *e
 
 	switch (le32toh(elem->message.data.eth_event.echo) >> BNX2X_SWCID_SHIFT) {
 	case ECORE_FILTER_MAC_PENDING:
-		PMD_DRV_LOG(DEBUG, "Got SETUP_MAC completions");
+		PMD_DRV_LOG(DEBUG, sc, "Got SETUP_MAC completions");
 		vlan_mac_obj = &sc->sp_objs[cid].mac_obj;
 		break;
 
 	case ECORE_FILTER_MCAST_PENDING:
-		PMD_DRV_LOG(DEBUG, "Got SETUP_MCAST completions");
+		PMD_DRV_LOG(DEBUG, sc, "Got SETUP_MCAST completions");
 		bnx2x_handle_mcast_eqe(sc);
 		return;
 
 	default:
-		PMD_DRV_LOG(NOTICE, "Unsupported classification command: %d",
+		PMD_DRV_LOG(NOTICE, sc, "Unsupported classification command: %d",
 			    elem->message.data.eth_event.echo);
 		return;
 	}
@@ -4250,9 +4286,10 @@ bnx2x_handle_classification_eqe(struct bnx2x_softc *sc, union event_ring_elem *e
 	rc = vlan_mac_obj->complete(sc, vlan_mac_obj, elem, &ramrod_flags);
 
 	if (rc < 0) {
-		PMD_DRV_LOG(NOTICE, "Failed to schedule new commands (%d)", rc);
+		PMD_DRV_LOG(NOTICE, sc,
+			    "Failed to schedule new commands (%d)", rc);
 	} else if (rc > 0) {
-		PMD_DRV_LOG(DEBUG, "Scheduled next pending commands...");
+		PMD_DRV_LOG(DEBUG, sc, "Scheduled next pending commands...");
 	}
 }
 
@@ -4316,7 +4353,7 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
 /* handle eq element */
 		switch (opcode) {
 		case EVENT_RING_OPCODE_STAT_QUERY:
-			PMD_DEBUG_PERIODIC_LOG(DEBUG, "got statistics completion event %d",
+			PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "got statistics completion event %d",
 				    sc->stats_comp++);
 			/* nothing to do with stats comp */
 			goto next_spqe;
@@ -4324,7 +4361,7 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
 		case EVENT_RING_OPCODE_CFC_DEL:
 			/* handle according to cid range */
 			/* we may want to verify here that the sc state is HALTING */
-			PMD_DRV_LOG(DEBUG, "got delete ramrod for MULTI[%d]",
+			PMD_DRV_LOG(DEBUG, sc, "got delete ramrod for MULTI[%d]",
 				    cid);
 			q_obj = bnx2x_cid_to_q_obj(sc, cid);
 			if (q_obj->complete_cmd(sc, q_obj, ECORE_Q_CMD_CFC_DEL)) {
@@ -4333,14 +4370,14 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
 			goto next_spqe;
 
 		case EVENT_RING_OPCODE_STOP_TRAFFIC:
-			PMD_DRV_LOG(DEBUG, "got STOP TRAFFIC");
+			PMD_DRV_LOG(DEBUG, sc, "got STOP TRAFFIC");
 			if (f_obj->complete_cmd(sc, f_obj, ECORE_F_CMD_TX_STOP)) {
 				break;
 			}
 			goto next_spqe;
 
 		case EVENT_RING_OPCODE_START_TRAFFIC:
-			PMD_DRV_LOG(DEBUG, "got START TRAFFIC");
+			PMD_DRV_LOG(DEBUG, sc, "got START TRAFFIC");
 			if (f_obj->complete_cmd
 			    (sc, f_obj, ECORE_F_CMD_TX_START)) {
 				break;
@@ -4350,7 +4387,7 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
 		case EVENT_RING_OPCODE_FUNCTION_UPDATE:
 			echo = elem->message.data.function_update_event.echo;
 			if (echo == SWITCH_UPDATE) {
-				PMD_DRV_LOG(DEBUG,
+				PMD_DRV_LOG(DEBUG, sc,
 					    "got FUNC_SWITCH_UPDATE ramrod");
 				if (f_obj->complete_cmd(sc, f_obj,
 							ECORE_F_CMD_SWITCH_UPDATE))
@@ -4358,7 +4395,7 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
 					break;
 				}
 			} else {
-				PMD_DRV_LOG(DEBUG,
+				PMD_DRV_LOG(DEBUG, sc,
 					    "AFEX: ramrod completed FUNCTION_UPDATE");
 				f_obj->complete_cmd(sc, f_obj,
 						    ECORE_F_CMD_AFEX_UPDATE);
@@ -4374,14 +4411,14 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
 			goto next_spqe;
 
 		case EVENT_RING_OPCODE_FUNCTION_START:
-			PMD_DRV_LOG(DEBUG, "got FUNC_START ramrod");
+			PMD_DRV_LOG(DEBUG, sc, "got FUNC_START ramrod");
 			if (f_obj->complete_cmd(sc, f_obj, ECORE_F_CMD_START)) {
 				break;
 			}
 			goto next_spqe;
 
 		case EVENT_RING_OPCODE_FUNCTION_STOP:
-			PMD_DRV_LOG(DEBUG, "got FUNC_STOP ramrod");
+			PMD_DRV_LOG(DEBUG, sc, "got FUNC_STOP ramrod");
 			if (f_obj->complete_cmd(sc, f_obj, ECORE_F_CMD_STOP)) {
 				break;
 			}
@@ -4393,7 +4430,7 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
 		case (EVENT_RING_OPCODE_RSS_UPDATE_RULES | BNX2X_STATE_OPENING_WAITING_PORT):
 			cid =
 			    elem->message.data.eth_event.echo & BNX2X_SWCID_MASK;
-			PMD_DRV_LOG(DEBUG, "got RSS_UPDATE ramrod. CID %d",
+			PMD_DRV_LOG(DEBUG, sc, "got RSS_UPDATE ramrod. CID %d",
 				    cid);
 			rss_raw->clear_pending(rss_raw);
 			break;
@@ -4404,7 +4441,7 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
 		case (EVENT_RING_OPCODE_CLASSIFICATION_RULES | BNX2X_STATE_OPEN):
 		case (EVENT_RING_OPCODE_CLASSIFICATION_RULES | BNX2X_STATE_DIAG):
 		case (EVENT_RING_OPCODE_CLASSIFICATION_RULES | BNX2X_STATE_CLOSING_WAITING_HALT):
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "got (un)set mac ramrod");
 			bnx2x_handle_classification_eqe(sc, elem);
 			break;
@@ -4412,7 +4449,7 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
 		case (EVENT_RING_OPCODE_MULTICAST_RULES | BNX2X_STATE_OPEN):
 		case (EVENT_RING_OPCODE_MULTICAST_RULES | BNX2X_STATE_DIAG):
 		case (EVENT_RING_OPCODE_MULTICAST_RULES | BNX2X_STATE_CLOSING_WAITING_HALT):
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "got mcast ramrod");
 			bnx2x_handle_mcast_eqe(sc);
 			break;
@@ -4420,14 +4457,14 @@ static void bnx2x_eq_int(struct bnx2x_softc *sc)
 		case (EVENT_RING_OPCODE_FILTERS_RULES | BNX2X_STATE_OPEN):
 		case (EVENT_RING_OPCODE_FILTERS_RULES | BNX2X_STATE_DIAG):
 		case (EVENT_RING_OPCODE_FILTERS_RULES | BNX2X_STATE_CLOSING_WAITING_HALT):
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "got rx_mode ramrod");
 			bnx2x_handle_rx_mode_eqe(sc);
 			break;
 
 		default:
 			/* unknown event log error and continue */
-			PMD_DRV_LOG(INFO, "Unknown EQ event %d, sc->state 0x%x",
+			PMD_DRV_LOG(INFO, sc, "Unknown EQ event %d, sc->state 0x%x",
 				    elem->message.opcode, sc->state);
 		}
 
@@ -4453,12 +4490,16 @@ static int bnx2x_handle_sp_tq(struct bnx2x_softc *sc)
 	uint16_t status;
 	int rc = 0;
 
+	PMD_DRV_LOG(DEBUG, sc, "---> SP TASK <---");
+
 	/* what work needs to be performed? */
 	status = bnx2x_update_dsb_idx(sc);
 
+	PMD_DRV_LOG(DEBUG, sc, "dsb status 0x%04x", status);
+
 	/* HW attentions */
 	if (status & BNX2X_DEF_SB_ATT_IDX) {
-		PMD_DRV_LOG(DEBUG, "---> ATTN INTR <---");
+		PMD_DRV_LOG(DEBUG, sc, "---> ATTN INTR <---");
 		bnx2x_attn_int(sc);
 		status &= ~BNX2X_DEF_SB_ATT_IDX;
 		rc = 1;
@@ -4467,7 +4508,7 @@ static int bnx2x_handle_sp_tq(struct bnx2x_softc *sc)
 	/* SP events: STAT_QUERY and others */
 	if (status & BNX2X_DEF_SB_IDX) {
 /* handle EQ completions */
-		PMD_DEBUG_PERIODIC_LOG(DEBUG, "---> EQ INTR <---");
+		PMD_DRV_LOG(DEBUG, sc, "---> EQ INTR <---");
 		bnx2x_eq_int(sc);
 		bnx2x_ack_sb(sc, sc->igu_dsb_id, USTORM_ID,
 			   le16toh(sc->def_idx), IGU_INT_NOP, 1);
@@ -4476,7 +4517,7 @@ static int bnx2x_handle_sp_tq(struct bnx2x_softc *sc)
 
 	/* if status is non zero then something went wrong */
 	if (unlikely(status)) {
-		PMD_DRV_LOG(INFO,
+		PMD_DRV_LOG(INFO, sc,
 			    "Got an unknown SP interrupt! (0x%04x)", status);
 	}
 
@@ -4492,7 +4533,8 @@ static void bnx2x_handle_fp_tq(struct bnx2x_fastpath *fp, int scan_fp)
 	struct bnx2x_softc *sc = fp->sc;
 	uint8_t more_rx = FALSE;
 
-	PMD_DRV_LOG(DEBUG, "---> FP TASK QUEUE (%d) <--", fp->index);
+	PMD_DEBUG_PERIODIC_LOG(DEBUG, sc,
+			       "---> FP TASK QUEUE (%d) <--", fp->index);
 
 	/* update the fastpath index */
 	bnx2x_update_fp_sb_idx(fp);
@@ -4542,25 +4584,31 @@ int bnx2x_intr_legacy(struct bnx2x_softc *sc, int scan_fp)
 		return 0;
 	}
 
-	PMD_DEBUG_PERIODIC_LOG(DEBUG, "Interrupt status 0x%04x", status);
+	PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "Interrupt status 0x%04x", status);
 	//bnx2x_dump_status_block(sc);
 
 	FOR_EACH_ETH_QUEUE(sc, i) {
 		fp = &sc->fp[i];
 		mask = (0x2 << (fp->index + CNIC_SUPPORT(sc)));
 		if (status & mask) {
+		/* 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, scan_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;
 	}
 
 	if (unlikely(status)) {
-		PMD_DRV_LOG(WARNING,
+		PMD_DRV_LOG(WARNING, sc,
 			    "Unexpected fastpath status (0x%08x)!", status);
 	}
 
@@ -4596,7 +4644,7 @@ static void bnx2x_init_func_obj(struct bnx2x_softc *sc)
 {
 	sc->dmae_ready = 0;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	ecore_init_func_obj(sc,
 			    &sc->func_obj,
@@ -4612,7 +4660,7 @@ static int bnx2x_init_hw(struct bnx2x_softc *sc, uint32_t load_code)
 	struct ecore_func_state_params func_params = { NULL };
 	int rc;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	/* prepare the parameters for function state transitions */
 	bnx2x_set_bit(RAMROD_COMP_WAIT, &func_params.ramrod_flags);
@@ -5201,7 +5249,7 @@ static void bnx2x_init_internal(struct bnx2x_softc *sc, uint32_t load_code)
 		break;
 
 	default:
-		PMD_DRV_LOG(NOTICE, "Unknown load_code (0x%x) from MCP",
+		PMD_DRV_LOG(NOTICE, sc, "Unknown load_code (0x%x) from MCP",
 			    load_code);
 		break;
 	}
@@ -5292,7 +5340,7 @@ bnx2x_extract_max_cfg(__rte_unused struct bnx2x_softc *sc, uint32_t mf_cfg)
 			    FUNC_MF_CFG_MAX_BW_SHIFT);
 
 	if (!max_cfg) {
-		PMD_DRV_LOG(DEBUG,
+		PMD_DRV_LOG(DEBUG, sc,
 			    "Max BW configured to 0 - using 100 instead");
 		max_cfg = 100;
 	}
@@ -5556,7 +5604,7 @@ static void bnx2x_igu_int_enable(struct bnx2x_softc *sc)
 
 	val |= IGU_PF_CONF_FUNC_EN;
 
-	PMD_DRV_LOG(DEBUG, "write 0x%x to IGU mode %s",
+	PMD_DRV_LOG(DEBUG, sc, "write 0x%x to IGU mode %s",
 		    val, ((msix) ? "MSI-X" : ((msi) ? "MSI" : "INTx")));
 
 	REG_WR(sc, IGU_REG_PF_CONFIGURATION, val);
@@ -5604,7 +5652,7 @@ static void bnx2x_hc_int_disable(struct bnx2x_softc *sc)
 
 	REG_WR(sc, addr, val);
 	if (REG_RD(sc, addr) != val) {
-		PMD_DRV_LOG(ERR, "proper val not read from HC IGU!");
+		PMD_DRV_LOG(ERR, sc, "proper val not read from HC IGU!");
 	}
 }
 
@@ -5615,14 +5663,14 @@ static void bnx2x_igu_int_disable(struct bnx2x_softc *sc)
 	val &= ~(IGU_PF_CONF_MSI_MSIX_EN |
 		 IGU_PF_CONF_INT_LINE_EN | IGU_PF_CONF_ATTN_BIT_EN);
 
-	PMD_DRV_LOG(DEBUG, "write %x to IGU", val);
+	PMD_DRV_LOG(DEBUG, sc, "write %x to IGU", val);
 
 	/* flush all outstanding writes */
 	mb();
 
 	REG_WR(sc, IGU_REG_PF_CONFIGURATION, val);
 	if (REG_RD(sc, IGU_REG_PF_CONFIGURATION) != val) {
-		PMD_DRV_LOG(ERR, "proper val not read from IGU!");
+		PMD_DRV_LOG(ERR, sc, "proper val not read from IGU!");
 	}
 }
 
@@ -5639,7 +5687,7 @@ static void bnx2x_nic_init(struct bnx2x_softc *sc, int load_code)
 {
 	int i;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	for (i = 0; i < sc->num_queues; i++) {
 		bnx2x_init_eth_fp(sc, i);
@@ -5769,7 +5817,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, "No power capability");
+		PMD_DRV_LOG(WARNING, sc, "No power capability");
 		return 0;
 	}
 
@@ -5814,7 +5862,7 @@ static int bnx2x_set_power_state(struct bnx2x_softc *sc, uint8_t state)
 		break;
 
 	default:
-		PMD_DRV_LOG(NOTICE, "Can't support PCI power state = %d",
+		PMD_DRV_LOG(NOTICE, sc, "Can't support PCI power state = %d",
 			    state);
 		return -1;
 	}
@@ -5832,7 +5880,7 @@ static uint8_t bnx2x_trylock_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
 
 	/* Validating that the resource is within range */
 	if (resource > HW_LOCK_MAX_RESOURCE_VALUE) {
-		PMD_DRV_LOG(INFO,
+		PMD_DRV_LOG(INFO, sc,
 			    "resource(0x%x) > HW_LOCK_MAX_RESOURCE_VALUE(0x%x)",
 			    resource, HW_LOCK_MAX_RESOURCE_VALUE);
 		return FALSE;
@@ -5852,7 +5900,7 @@ static uint8_t bnx2x_trylock_hw_lock(struct bnx2x_softc *sc, uint32_t resource)
 		return TRUE;
 	}
 
-	PMD_DRV_LOG(NOTICE, "Failed to get a resource lock 0x%x", resource);
+	PMD_DRV_LOG(NOTICE, sc, "Failed to get a resource lock 0x%x", resource);
 
 	return FALSE;
 }
@@ -5945,7 +5993,7 @@ static int bnx2x_er_poll_igu_vq(struct bnx2x_softc *sc)
 	} while (cnt-- > 0);
 
 	if (cnt <= 0) {
-		PMD_DRV_LOG(NOTICE, "Still pending IGU requests bits=0x%08x!",
+		PMD_DRV_LOG(NOTICE, sc, "Still pending IGU requests bits=0x%08x!",
 			    pend_bits);
 		return -1;
 	}
@@ -6026,7 +6074,7 @@ static int bnx2x_init_shmem(struct bnx2x_softc *sc)
 
 	} while (cnt++ < (MCP_TIMEOUT / MCP_ONE_TIMEOUT));
 
-	PMD_DRV_LOG(NOTICE, "BAD MCP validity signature");
+	PMD_DRV_LOG(NOTICE, sc, "BAD MCP validity signature");
 
 	return -1;
 }
@@ -6181,7 +6229,7 @@ static int bnx2x_process_kill(struct bnx2x_softc *sc, uint8_t global)
 	} while (cnt-- > 0);
 
 	if (cnt <= 0) {
-		PMD_DRV_LOG(NOTICE,
+		PMD_DRV_LOG(NOTICE, sc,
 			    "ERROR: Tetris buffer didn't get empty or there "
 			    "are still outstanding read requests after 1s! "
 			    "sr_cnt=0x%08x, blk_cnt=0x%08x, port_is_idle_0=0x%08x, "
@@ -6254,14 +6302,14 @@ static int bnx2x_leader_reset(struct bnx2x_softc *sc)
 		load_code = bnx2x_fw_command(sc, DRV_MSG_CODE_LOAD_REQ,
 					   DRV_MSG_CODE_LOAD_REQ_WITH_LFA);
 		if (!load_code) {
-			PMD_DRV_LOG(NOTICE, "MCP response failure, aborting");
+			PMD_DRV_LOG(NOTICE, sc, "MCP response failure, aborting");
 			rc = -1;
 			goto exit_leader_reset;
 		}
 
 		if ((load_code != FW_MSG_CODE_DRV_LOAD_COMMON_CHIP) &&
 		    (load_code != FW_MSG_CODE_DRV_LOAD_COMMON)) {
-			PMD_DRV_LOG(NOTICE,
+			PMD_DRV_LOG(NOTICE, sc,
 				    "MCP unexpected response, aborting");
 			rc = -1;
 			goto exit_leader_reset2;
@@ -6269,7 +6317,7 @@ static int bnx2x_leader_reset(struct bnx2x_softc *sc)
 
 		load_code = bnx2x_fw_command(sc, DRV_MSG_CODE_LOAD_DONE, 0);
 		if (!load_code) {
-			PMD_DRV_LOG(NOTICE, "MCP response failure, aborting");
+			PMD_DRV_LOG(NOTICE, sc, "MCP response failure, aborting");
 			rc = -1;
 			goto exit_leader_reset2;
 		}
@@ -6277,7 +6325,7 @@ static int bnx2x_leader_reset(struct bnx2x_softc *sc)
 
 	/* try to recover after the failure */
 	if (bnx2x_process_kill(sc, global)) {
-		PMD_DRV_LOG(NOTICE, "Something bad occurred on engine %d!",
+		PMD_DRV_LOG(NOTICE, sc, "Something bad occurred on engine %d!",
 			    SC_PATH(sc));
 		rc = -1;
 		goto exit_leader_reset2;
@@ -6436,12 +6484,12 @@ bnx2x_pf_rx_q_prep(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp,
 	/* validate rings have enough entries to cross high thresholds */
 	if (sc->dropless_fc &&
 	    pause->bd_th_hi + FW_PREFETCH_CNT > sc->rx_ring_size) {
-		PMD_DRV_LOG(WARNING, "rx bd ring threshold limit");
+		PMD_DRV_LOG(WARNING, sc, "rx bd ring threshold limit");
 	}
 
 	if (sc->dropless_fc &&
 	    pause->rcq_th_hi + FW_PREFETCH_CNT > USABLE_RCQ_ENTRIES(rxq)) {
-		PMD_DRV_LOG(WARNING, "rcq ring threshold limit");
+		PMD_DRV_LOG(WARNING, sc, "rcq ring threshold limit");
 	}
 
 	pause->pri_map = 1;
@@ -6512,7 +6560,7 @@ bnx2x_setup_queue(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp, uint8_t lea
 	struct ecore_queue_setup_params *setup_params = &q_params.params.setup;
 	int rc;
 
-	PMD_DRV_LOG(DEBUG, "setting up queue %d", fp->index);
+	PMD_DRV_LOG(DEBUG, sc, "setting up queue %d", fp->index);
 
 	bnx2x_ack_sb(sc, fp->igu_sb_id, USTORM_ID, 0, IGU_INT_ENABLE, 0);
 
@@ -6530,11 +6578,11 @@ bnx2x_setup_queue(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp, uint8_t lea
 	/* Change the state to INIT */
 	rc = ecore_queue_state_change(sc, &q_params);
 	if (rc) {
-		PMD_DRV_LOG(NOTICE, "Queue(%d) INIT failed", fp->index);
+		PMD_DRV_LOG(NOTICE, sc, "Queue(%d) INIT failed", fp->index);
 		return rc;
 	}
 
-	PMD_DRV_LOG(DEBUG, "init complete");
+	PMD_DRV_LOG(DEBUG, sc, "init complete");
 
 	/* now move the Queue to the SETUP state */
 	memset(setup_params, 0, sizeof(*setup_params));
@@ -6558,7 +6606,7 @@ bnx2x_setup_queue(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp, uint8_t lea
 	/* change the state to SETUP */
 	rc = ecore_queue_state_change(sc, &q_params);
 	if (rc) {
-		PMD_DRV_LOG(NOTICE, "Queue(%d) SETUP failed", fp->index);
+		PMD_DRV_LOG(NOTICE, sc, "Queue(%d) SETUP failed", fp->index);
 		return rc;
 	}
 
@@ -6686,11 +6734,11 @@ bnx2x_set_mac_one(struct bnx2x_softc *sc, uint8_t * mac,
 	rc = ecore_config_vlan_mac(sc, &ramrod_param);
 
 	if (rc == ECORE_EXISTS) {
-		PMD_DRV_LOG(INFO, "Failed to schedule ADD operations (EEXIST)");
+		PMD_DRV_LOG(INFO, sc, "Failed to schedule ADD operations (EEXIST)");
 /* do not treat adding same MAC as error */
 		rc = 0;
 	} else if (rc < 0) {
-		PMD_DRV_LOG(ERR,
+		PMD_DRV_LOG(ERR, sc,
 			    "%s MAC failed (%d)", (set ? "Set" : "Delete"), rc);
 	}
 
@@ -6701,7 +6749,7 @@ static int bnx2x_set_eth_mac(struct bnx2x_softc *sc, uint8_t set)
 {
 	unsigned long ramrod_flags = 0;
 
-	PMD_DRV_LOG(DEBUG, "Adding Ethernet MAC");
+	PMD_DRV_LOG(DEBUG, sc, "Adding Ethernet MAC");
 
 	bnx2x_set_bit(RAMROD_COMP_WAIT, &ramrod_flags);
 
@@ -6857,7 +6905,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;
 
@@ -6878,14 +6926,19 @@ static void bnx2x_link_report(struct bnx2x_softc *sc)
 		return;
 	}
 
+	PMD_DRV_LOG(INFO, sc, "Change in link status : cur_data = %lx, last_reported_link = %lx\n",
+		    cur_data.link_report_flags,
+		    sc->last_reported_link.link_report_flags);
+
 	sc->link_cnt++;
 
+	PMD_DRV_LOG(INFO, sc, "link status change count = %x\n", sc->link_cnt);
 	/* report new link params and remember the state for the next time */
 	(void)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, "NIC Link is Down");
+		PMD_DRV_LOG(INFO, sc, "NIC Link is Down");
 	} else {
 		__rte_unused const char *duplex;
 		__rte_unused const char *flow;
@@ -6925,12 +6978,20 @@ static void bnx2x_link_report(struct bnx2x_softc *sc)
 			flow = "none";
 		}
 
-		PMD_DRV_LOG(INFO,
+		PMD_DRV_LOG(INFO, sc,
 			    "NIC Link is Up, %d Mbps %s duplex, Flow control: %s",
 			    cur_data.line_speed, duplex, flow);
 	}
 }
 
+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) {
@@ -6996,7 +7057,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);
 	}
 }
@@ -7019,6 +7080,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 */
@@ -7038,6 +7101,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) {
@@ -7080,7 +7145,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(WARNING, "periodic callout exit (state=0x%x)",
+		PMD_DRV_LOG(INFO, sc, "periodic callout exit (state=0x%x)",
 			    sc->state);
 		return;
 	}
@@ -7092,7 +7157,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
@@ -7117,7 +7184,7 @@ void bnx2x_periodic_callout(struct bnx2x_softc *sc)
 		if ((drv_pulse != mcp_pulse) &&
 		    (drv_pulse != ((mcp_pulse + 1) & MCP_PULSE_SEQ_MASK))) {
 			/* someone lost a heartbeat... */
-			PMD_DRV_LOG(ERR,
+			PMD_DRV_LOG(ERR, sc,
 				    "drv_pulse (0x%x) != mcp_pulse (0x%x)",
 				    drv_pulse, mcp_pulse);
 		}
@@ -7133,7 +7200,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
 	uint32_t load_code = 0;
 	int i, rc = 0;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	sc->state = BNX2X_STATE_OPENING_WAITING_LOAD;
 
@@ -7187,7 +7254,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
 				goto bnx2x_nic_load_error2;
 			}
 		} else {
-			PMD_DRV_LOG(INFO, "Device has no MCP!");
+			PMD_DRV_LOG(INFO, sc, "Device has no MCP!");
 			load_code = bnx2x_nic_load_no_mcp(sc);
 		}
 
@@ -7199,7 +7266,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
 
 /* Initialize HW */
 		if (bnx2x_init_hw(sc, load_code) != 0) {
-			PMD_DRV_LOG(NOTICE, "HW init failed");
+			PMD_DRV_LOG(NOTICE, sc, "HW init failed");
 			bnx2x_fw_command(sc, DRV_MSG_CODE_LOAD_DONE, 0);
 			sc->state = BNX2X_STATE_CLOSED;
 			rc = -ENXIO;
@@ -7219,7 +7286,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
 		sc->state = BNX2X_STATE_OPENING_WAITING_PORT;
 		rc = bnx2x_func_start(sc);
 		if (rc) {
-			PMD_DRV_LOG(NOTICE, "Function start failed!");
+			PMD_DRV_LOG(NOTICE, sc, "Function start failed!");
 			bnx2x_fw_command(sc, DRV_MSG_CODE_LOAD_DONE, 0);
 			sc->state = BNX2X_STATE_ERROR;
 			goto bnx2x_nic_load_error3;
@@ -7230,7 +7297,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
 			load_code =
 			    bnx2x_fw_command(sc, DRV_MSG_CODE_LOAD_DONE, 0);
 			if (!load_code) {
-				PMD_DRV_LOG(NOTICE,
+				PMD_DRV_LOG(NOTICE, sc,
 					    "MCP response failure, aborting");
 				sc->state = BNX2X_STATE_ERROR;
 				rc = -ENXIO;
@@ -7241,7 +7308,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
 
 	rc = bnx2x_setup_leading(sc);
 	if (rc) {
-		PMD_DRV_LOG(NOTICE, "Setup leading failed!");
+		PMD_DRV_LOG(NOTICE, sc, "Setup leading failed!");
 		sc->state = BNX2X_STATE_ERROR;
 		goto bnx2x_nic_load_error3;
 	}
@@ -7253,7 +7320,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
 			rc = bnx2x_vf_setup_queue(sc, &sc->fp[i], FALSE);
 
 		if (rc) {
-			PMD_DRV_LOG(NOTICE, "Queue(%d) setup failed", i);
+			PMD_DRV_LOG(NOTICE, sc, "Queue(%d) setup failed", i);
 			sc->state = BNX2X_STATE_ERROR;
 			goto bnx2x_nic_load_error3;
 		}
@@ -7261,7 +7328,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
 
 	rc = bnx2x_init_rss_pf(sc);
 	if (rc) {
-		PMD_DRV_LOG(NOTICE, "PF RSS init failed");
+		PMD_DRV_LOG(NOTICE, sc, "PF RSS init failed");
 		sc->state = BNX2X_STATE_ERROR;
 		goto bnx2x_nic_load_error3;
 	}
@@ -7277,7 +7344,7 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
 	}
 
 	if (rc) {
-		PMD_DRV_LOG(NOTICE, "Setting Ethernet MAC failed");
+		PMD_DRV_LOG(NOTICE, sc, "Setting Ethernet MAC failed");
 		sc->state = BNX2X_STATE_ERROR;
 		goto bnx2x_nic_load_error3;
 	}
@@ -7329,13 +7396,13 @@ int bnx2x_nic_load(struct bnx2x_softc *sc)
 
 	/* wait for all pending SP commands to complete */
 	if (IS_PF(sc) && !bnx2x_wait_sp_comp(sc, ~0x0UL)) {
-		PMD_DRV_LOG(NOTICE, "Timeout waiting for all SPs to complete!");
+		PMD_DRV_LOG(NOTICE, sc, "Timeout waiting for all SPs to complete!");
 		bnx2x_periodic_stop(sc);
 		bnx2x_nic_unload(sc, UNLOAD_CLOSE, FALSE);
 		return -ENXIO;
 	}
 
-	PMD_DRV_LOG(DEBUG, "NIC successfully loaded");
+	PMD_DRV_LOG(DEBUG, sc, "NIC successfully loaded");
 
 	return 0;
 
@@ -7384,7 +7451,7 @@ int bnx2x_init(struct bnx2x_softc *sc)
 
 	/* Check if the driver is still running and bail out if it is. */
 	if (sc->state != BNX2X_STATE_CLOSED) {
-		PMD_DRV_LOG(DEBUG, "Init called while driver is running!");
+		PMD_DRV_LOG(DEBUG, sc, "Init called while driver is running!");
 		rc = 0;
 		goto bnx2x_init_done;
 	}
@@ -7422,7 +7489,7 @@ int bnx2x_init(struct bnx2x_softc *sc)
 				     && (!global ||!other_load_status))
 				    && bnx2x_trylock_leader_lock(sc)
 				    && !bnx2x_leader_reset(sc)) {
-					PMD_DRV_LOG(INFO,
+					PMD_DRV_LOG(INFO, sc,
 						    "Recovered during init");
 					break;
 				}
@@ -7432,7 +7499,7 @@ int bnx2x_init(struct bnx2x_softc *sc)
 
 				sc->recovery_state = BNX2X_RECOVERY_FAILED;
 
-				PMD_DRV_LOG(NOTICE,
+				PMD_DRV_LOG(NOTICE, sc,
 					    "Recovery flow hasn't properly "
 					    "completed yet, try again later. "
 					    "If you still see this message after a "
@@ -7451,7 +7518,7 @@ int bnx2x_init(struct bnx2x_softc *sc)
 bnx2x_init_done:
 
 	if (rc) {
-		PMD_DRV_LOG(NOTICE, "Initialization failed, "
+		PMD_DRV_LOG(NOTICE, sc, "Initialization failed, "
 			    "stack notified driver is NOT running!");
 	}
 
@@ -7483,7 +7550,7 @@ static void bnx2x_get_function_num(struct bnx2x_softc *sc)
 		sc->pfunc_abs = (sc->pfunc_rel | sc->path_id);
 	}
 
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 		    "Relative function %d, Absolute function %d, Path %d",
 		    sc->pfunc_rel, sc->pfunc_abs, sc->path_id);
 }
@@ -7520,14 +7587,14 @@ static uint32_t bnx2x_pcie_capability_read(struct bnx2x_softc *sc, int reg)
 	/* ensure PCIe capability is enabled */
 	caps = pci_find_cap(sc, PCIY_EXPRESS, BNX2X_PCI_CAP);
 	if (NULL != caps) {
-		PMD_DRV_LOG(DEBUG, "Found PCIe capability: "
+		PMD_DRV_LOG(DEBUG, sc, "Found PCIe capability: "
 			    "id=0x%04X type=0x%04X addr=0x%08X",
 			    caps->id, caps->type, caps->addr);
 		pci_read(sc, (caps->addr + reg), &ret, 2);
 		return ret;
 	}
 
-	PMD_DRV_LOG(WARNING, "PCIe capability NOT FOUND!!!");
+	PMD_DRV_LOG(WARNING, sc, "PCIe capability NOT FOUND!!!");
 
 	return 0;
 }
@@ -7545,7 +7612,7 @@ static uint8_t bnx2x_is_pcie_pending(struct bnx2x_softc *sc)
 */
 static void bnx2x_probe_pci_caps(struct bnx2x_softc *sc)
 {
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	struct bnx2x_pci_cap *caps;
 	uint16_t link_status;
@@ -7556,7 +7623,7 @@ static void bnx2x_probe_pci_caps(struct bnx2x_softc *sc)
 	/* check if PCI Power Management is enabled */
 	caps = pci_find_cap(sc, PCIY_PMG, BNX2X_PCI_CAP);
 	if (NULL != caps) {
-		PMD_DRV_LOG(DEBUG, "Found PM capability: "
+		PMD_DRV_LOG(DEBUG, sc, "Found PM capability: "
 			    "id=0x%04X type=0x%04X addr=0x%08X",
 			    caps->id, caps->type, caps->addr);
 
@@ -7570,7 +7637,7 @@ static void bnx2x_probe_pci_caps(struct bnx2x_softc *sc)
 	sc->devinfo.pcie_link_width =
 	    ((link_status & PCIM_LINK_STA_WIDTH) >> 4);
 
-	PMD_DRV_LOG(DEBUG, "PCIe link speed=%d width=%d",
+	PMD_DRV_LOG(DEBUG, sc, "PCIe link speed=%d width=%d",
 		    sc->devinfo.pcie_link_speed, sc->devinfo.pcie_link_width);
 
 	sc->devinfo.pcie_cap_flags |= BNX2X_PCIE_CAPABLE_FLAG;
@@ -7578,7 +7645,7 @@ static void bnx2x_probe_pci_caps(struct bnx2x_softc *sc)
 	/* check if MSI capability is enabled */
 	caps = pci_find_cap(sc, PCIY_MSI, BNX2X_PCI_CAP);
 	if (NULL != caps) {
-		PMD_DRV_LOG(DEBUG, "Found MSI capability at 0x%04x", reg);
+		PMD_DRV_LOG(DEBUG, sc, "Found MSI capability at 0x%04x", reg);
 
 		sc->devinfo.pcie_cap_flags |= BNX2X_MSI_CAPABLE_FLAG;
 		sc->devinfo.pcie_msi_cap_reg = caps->addr;
@@ -7587,7 +7654,7 @@ static void bnx2x_probe_pci_caps(struct bnx2x_softc *sc)
 	/* check if MSI-X capability is enabled */
 	caps = pci_find_cap(sc, PCIY_MSIX, BNX2X_PCI_CAP);
 	if (NULL != caps) {
-		PMD_DRV_LOG(DEBUG, "Found MSI-X capability at 0x%04x", reg);
+		PMD_DRV_LOG(DEBUG, sc, "Found MSI-X capability at 0x%04x", reg);
 
 		sc->devinfo.pcie_cap_flags |= BNX2X_MSIX_CAPABLE_FLAG;
 		sc->devinfo.pcie_msix_cap_reg = caps->addr;
@@ -7607,7 +7674,7 @@ static int bnx2x_get_shmem_mf_cfg_info_sd(struct bnx2x_softc *sc)
 	mf_info->multi_vnics_mode = 1;
 
 	if (!VALID_OVLAN(mf_info->ext_id)) {
-		PMD_DRV_LOG(NOTICE, "Invalid VLAN (%d)", mf_info->ext_id);
+		PMD_DRV_LOG(NOTICE, sc, "Invalid VLAN (%d)", mf_info->ext_id);
 		return 1;
 	}
 
@@ -7731,14 +7798,14 @@ static int bnx2x_check_valid_mf_cfg(struct bnx2x_softc *sc)
 	/* various MF mode sanity checks... */
 
 	if (mf_info->mf_config[SC_VN(sc)] & FUNC_MF_CFG_FUNC_HIDE) {
-		PMD_DRV_LOG(NOTICE,
+		PMD_DRV_LOG(NOTICE, sc,
 			    "Enumerated function %d is marked as hidden",
 			    SC_PORT(sc));
 		return 1;
 	}
 
 	if ((mf_info->vnics_per_port > 1) && !mf_info->multi_vnics_mode) {
-		PMD_DRV_LOG(NOTICE, "vnics_per_port=%d multi_vnics_mode=%d",
+		PMD_DRV_LOG(NOTICE, sc, "vnics_per_port=%d multi_vnics_mode=%d",
 			    mf_info->vnics_per_port, mf_info->multi_vnics_mode);
 		return 1;
 	}
@@ -7746,13 +7813,13 @@ static int bnx2x_check_valid_mf_cfg(struct bnx2x_softc *sc)
 	if (mf_info->mf_mode == MULTI_FUNCTION_SD) {
 /* vnic id > 0 must have valid ovlan in switch-dependent mode */
 		if ((SC_VN(sc) > 0) && !VALID_OVLAN(OVLAN(sc))) {
-			PMD_DRV_LOG(NOTICE, "mf_mode=SD vnic_id=%d ovlan=%d",
+			PMD_DRV_LOG(NOTICE, sc, "mf_mode=SD vnic_id=%d ovlan=%d",
 				    SC_VN(sc), OVLAN(sc));
 			return 1;
 		}
 
 		if (!VALID_OVLAN(OVLAN(sc)) && mf_info->multi_vnics_mode) {
-			PMD_DRV_LOG(NOTICE,
+			PMD_DRV_LOG(NOTICE, sc,
 				    "mf_mode=SD multi_vnics_mode=%d ovlan=%d",
 				    mf_info->multi_vnics_mode, OVLAN(sc));
 			return 1;
@@ -7771,7 +7838,7 @@ static int bnx2x_check_valid_mf_cfg(struct bnx2x_softc *sc)
 			      && !VALID_OVLAN(ovlan1))
 			     || ((!mf_info->multi_vnics_mode)
 				 && VALID_OVLAN(ovlan1)))) {
-				PMD_DRV_LOG(NOTICE,
+				PMD_DRV_LOG(NOTICE, sc,
 					    "mf_mode=SD function %d MF config "
 					    "mismatch, multi_vnics_mode=%d ovlan=%d",
 					    i, mf_info->multi_vnics_mode,
@@ -7795,7 +7862,7 @@ static int bnx2x_check_valid_mf_cfg(struct bnx2x_softc *sc)
 				    && !(mf_cfg2 & FUNC_MF_CFG_FUNC_HIDE)
 				    && VALID_OVLAN(ovlan2)
 				    && (ovlan1 == ovlan2)) {
-					PMD_DRV_LOG(NOTICE,
+					PMD_DRV_LOG(NOTICE, sc,
 						    "mf_mode=SD functions %d and %d "
 						    "have the same ovlan (%d)",
 						    i, j, ovlan1);
@@ -7825,7 +7892,7 @@ static int bnx2x_get_mf_cfg_info(struct bnx2x_softc *sc)
 	}
 
 	if (sc->devinfo.mf_cfg_base == SHMEM_MF_CFG_ADDR_NONE) {
-		PMD_DRV_LOG(NOTICE, "Invalid mf_cfg_base!");
+		PMD_DRV_LOG(NOTICE, sc, "Invalid mf_cfg_base!");
 		return 1;
 	}
 
@@ -7843,7 +7910,7 @@ static int bnx2x_get_mf_cfg_info(struct bnx2x_softc *sc)
 		if (mac_upper != FUNC_MF_CFG_UPPERMAC_DEFAULT) {
 			mf_info->mf_mode = MULTI_FUNCTION_SI;
 		} else {
-			PMD_DRV_LOG(NOTICE,
+			PMD_DRV_LOG(NOTICE, sc,
 				    "Invalid config for Switch Independent mode");
 		}
 
@@ -7859,7 +7926,7 @@ static int bnx2x_get_mf_cfg_info(struct bnx2x_softc *sc)
 		    FUNC_MF_CFG_E1HOV_TAG_DEFAULT) {
 			mf_info->mf_mode = MULTI_FUNCTION_SD;
 		} else {
-			PMD_DRV_LOG(NOTICE,
+			PMD_DRV_LOG(NOTICE, sc,
 				    "Invalid config for Switch Dependent mode");
 		}
 
@@ -7883,14 +7950,14 @@ static int bnx2x_get_mf_cfg_info(struct bnx2x_softc *sc)
 		    (mac_upper != FUNC_MF_CFG_UPPERMAC_DEFAULT)) {
 			mf_info->mf_mode = MULTI_FUNCTION_AFEX;
 		} else {
-			PMD_DRV_LOG(NOTICE, "Invalid config for AFEX mode");
+			PMD_DRV_LOG(NOTICE, sc, "Invalid config for AFEX mode");
 		}
 
 		break;
 
 	default:
 
-		PMD_DRV_LOG(NOTICE, "Unknown MF mode (0x%08x)",
+		PMD_DRV_LOG(NOTICE, sc, "Unknown MF mode (0x%08x)",
 			    (val & SHARED_FEAT_CFG_FORCE_SF_MODE_MASK));
 
 		return 1;
@@ -7922,7 +7989,7 @@ static int bnx2x_get_mf_cfg_info(struct bnx2x_softc *sc)
 	if (mf_info->mf_mode == SINGLE_FUNCTION) {
 /* invalid MF config */
 		if (SC_VN(sc) >= 1) {
-			PMD_DRV_LOG(NOTICE, "VNIC ID >= 1 in SF mode");
+			PMD_DRV_LOG(NOTICE, sc, "VNIC ID >= 1 in SF mode");
 			return 1;
 		}
 
@@ -7951,7 +8018,7 @@ static int bnx2x_get_mf_cfg_info(struct bnx2x_softc *sc)
 
 	default:
 
-		PMD_DRV_LOG(NOTICE, "Get MF config failed (mf_mode=0x%08x)",
+		PMD_DRV_LOG(NOTICE, sc, "Get MF config failed (mf_mode=0x%08x)",
 			    mf_info->mf_mode);
 		return 1;
 	}
@@ -7979,7 +8046,7 @@ static int bnx2x_get_shmem_info(struct bnx2x_softc *sc)
 	int port;
 	uint32_t mac_hi, mac_lo, val;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	port = SC_PORT(sc);
 	mac_hi = mac_lo = 0;
@@ -8053,7 +8120,7 @@ static int bnx2x_get_shmem_info(struct bnx2x_softc *sc)
 
 	if ((mac_lo == 0) && (mac_hi == 0)) {
 		*sc->mac_addr_str = 0;
-		PMD_DRV_LOG(NOTICE, "No Ethernet address programmed!");
+		PMD_DRV_LOG(NOTICE, sc, "No Ethernet address programmed!");
 	} else {
 		sc->link_params.mac_addr[0] = (uint8_t) (mac_hi >> 8);
 		sc->link_params.mac_addr[1] = (uint8_t) (mac_hi);
@@ -8069,7 +8136,8 @@ static int bnx2x_get_shmem_info(struct bnx2x_softc *sc)
 			 sc->link_params.mac_addr[3],
 			 sc->link_params.mac_addr[4],
 			 sc->link_params.mac_addr[5]);
-		PMD_DRV_LOG(DEBUG, "Ethernet address: %s", sc->mac_addr_str);
+		PMD_DRV_LOG(DEBUG, sc,
+			    "Ethernet address: %s", sc->mac_addr_str);
 	}
 
 	return 0;
@@ -8084,24 +8152,24 @@ static void bnx2x_media_detect(struct bnx2x_softc *sc)
 	case ELINK_ETH_PHY_XFP_FIBER:
 	case ELINK_ETH_PHY_KR:
 	case ELINK_ETH_PHY_CX4:
-		PMD_DRV_LOG(INFO, "Found 10GBase-CX4 media.");
+		PMD_DRV_LOG(INFO, sc, "Found 10GBase-CX4 media.");
 		sc->media = IFM_10G_CX4;
 		break;
 	case ELINK_ETH_PHY_DA_TWINAX:
-		PMD_DRV_LOG(INFO, "Found 10Gb Twinax media.");
+		PMD_DRV_LOG(INFO, sc, "Found 10Gb Twinax media.");
 		sc->media = IFM_10G_TWINAX;
 		break;
 	case ELINK_ETH_PHY_BASE_T:
-		PMD_DRV_LOG(INFO, "Found 10GBase-T media.");
+		PMD_DRV_LOG(INFO, sc, "Found 10GBase-T media.");
 		sc->media = IFM_10G_T;
 		break;
 	case ELINK_ETH_PHY_NOT_PRESENT:
-		PMD_DRV_LOG(INFO, "Media not present.");
+		PMD_DRV_LOG(INFO, sc, "Media not present.");
 		sc->media = 0;
 		break;
 	case ELINK_ETH_PHY_UNSPECIFIED:
 	default:
-		PMD_DRV_LOG(INFO, "Unknown media!");
+		PMD_DRV_LOG(INFO, sc, "Unknown media!");
 		sc->media = 0;
 		break;
 	}
@@ -8164,7 +8232,7 @@ static int bnx2x_get_igu_cam_info(struct bnx2x_softc *sc)
 	sc->igu_sb_cnt = min(sc->igu_sb_cnt, igu_sb_cnt);
 
 	if (igu_sb_cnt == 0) {
-		PMD_DRV_LOG(ERR, "CAM configuration error");
+		PMD_DRV_LOG(ERR, sc, "CAM configuration error");
 		return -1;
 	}
 
@@ -8201,7 +8269,7 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
 		sc->devinfo.chip_id |= 0x1;
 	}
 
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 		    "chip_id=0x%08x (num=0x%04x rev=0x%01x metal=0x%02x bond=0x%01x)",
 		    sc->devinfo.chip_id,
 		    ((sc->devinfo.chip_id >> 16) & 0xffff),
@@ -8212,7 +8280,7 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
 	val = (REG_RD(sc, 0x2874) & 0x55);
 	if ((sc->devinfo.chip_id & 0x1) || (CHIP_IS_E1H(sc) && (val == 0x55))) {
 		sc->flags |= BNX2X_ONE_PORT_FLAG;
-		PMD_DRV_LOG(DEBUG, "single port device");
+		PMD_DRV_LOG(DEBUG, sc, "single port device");
 	}
 
 	/* set the doorbell size */
@@ -8236,7 +8304,7 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
 		sc->devinfo.chip_port_mode =
 		    (val) ? CHIP_4_PORT_MODE : CHIP_2_PORT_MODE;
 
-		PMD_DRV_LOG(DEBUG, "Port mode = %s", (val) ? "4" : "2");
+		PMD_DRV_LOG(DEBUG, sc, "Port mode = %s", (val) ? "4" : "2");
 	}
 
 	/* get the function and path info for the device */
@@ -8251,7 +8319,7 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
 
 	if (!sc->devinfo.shmem_base) {
 /* this should ONLY prevent upcoming shmem reads */
-		PMD_DRV_LOG(INFO, "MCP not active");
+		PMD_DRV_LOG(INFO, sc, "MCP not active");
 		sc->flags |= BNX2X_NO_MCP_FLAG;
 		return 0;
 	}
@@ -8260,7 +8328,7 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
 	val = SHMEM_RD(sc, validity_map[SC_PORT(sc)]);
 	if ((val & (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB)) !=
 	    (SHR_MEM_VALIDITY_DEV_INFO | SHR_MEM_VALIDITY_MB)) {
-		PMD_DRV_LOG(NOTICE, "Invalid SHMEM validity signature: 0x%08x",
+		PMD_DRV_LOG(NOTICE, sc, "Invalid SHMEM validity signature: 0x%08x",
 			    val);
 		return 0;
 	}
@@ -8273,7 +8341,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, "Bootcode version: %s", sc->devinfo.bc_ver_str);
+	PMD_DRV_LOG(INFO, 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);
@@ -8328,7 +8396,7 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
 			}
 
 			if (REG_RD(sc, IGU_REG_RESET_MEMORIES)) {
-				PMD_DRV_LOG(NOTICE,
+				PMD_DRV_LOG(NOTICE, sc,
 					    "FORCING IGU Normal Mode failed!!!");
 				bnx2x_release_hw_lock(sc, HW_LOCK_RESOURCE_RESET);
 				return -1;
@@ -8336,10 +8404,10 @@ static int bnx2x_get_device_info(struct bnx2x_softc *sc)
 		}
 
 		if (val & IGU_BLOCK_CONFIGURATION_REG_BACKWARD_COMP_EN) {
-			PMD_DRV_LOG(DEBUG, "IGU Backward Compatible Mode");
+			PMD_DRV_LOG(DEBUG, sc, "IGU Backward Compatible Mode");
 			sc->devinfo.int_block |= INT_BLOCK_MODE_BW_COMP;
 		} else {
-			PMD_DRV_LOG(DEBUG, "IGU Normal Mode");
+			PMD_DRV_LOG(DEBUG, sc, "IGU Normal Mode");
 		}
 
 		rc = bnx2x_get_igu_cam_info(sc);
@@ -8413,7 +8481,7 @@ bnx2x_link_settings_supported(struct bnx2x_softc *sc, uint32_t switch_cfg)
 	}
 
 	if (!(sc->port.supported[0] || sc->port.supported[1])) {
-		PMD_DRV_LOG(ERR,
+		PMD_DRV_LOG(ERR, sc,
 			    "Invalid phy config in NVRAM (PHY1=0x%08x PHY2=0x%08x)",
 			    SHMEM_RD(sc,
 				     dev_info.port_hw_config
@@ -8439,7 +8507,7 @@ bnx2x_link_settings_supported(struct bnx2x_softc *sc, uint32_t switch_cfg)
 				   NIG_REG_XGXS0_CTRL_PHY_ADDR + port * 0x18);
 			break;
 		default:
-			PMD_DRV_LOG(ERR,
+			PMD_DRV_LOG(ERR, sc,
 				    "Invalid switch config in"
 				    "link_config=0x%08x",
 				    sc->port.link_config[0]);
@@ -8447,7 +8515,7 @@ bnx2x_link_settings_supported(struct bnx2x_softc *sc, uint32_t switch_cfg)
 		}
 	}
 
-	PMD_DRV_LOG(INFO, "PHY addr 0x%08x", sc->port.phy_addr);
+	PMD_DRV_LOG(INFO, sc, "PHY addr 0x%08x", sc->port.phy_addr);
 
 	/* mask what we support according to speed_cap_mask per configuration */
 	for (idx = 0; idx < cfg_size; idx++) {
@@ -8500,7 +8568,7 @@ bnx2x_link_settings_supported(struct bnx2x_softc *sc, uint32_t switch_cfg)
 		}
 	}
 
-	PMD_DRV_LOG(INFO, "PHY supported 0=0x%08x 1=0x%08x",
+	PMD_DRV_LOG(INFO, sc, "PHY supported 0=0x%08x 1=0x%08x",
 		    sc->port.supported[0], sc->port.supported[1]);
 }
 
@@ -8559,7 +8627,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
 				sc->port.advertising[idx] |=
 				    (ADVERTISED_10baseT_Full | ADVERTISED_TP);
 			} else {
-				PMD_DRV_LOG(ERR,
+				PMD_DRV_LOG(ERR, sc,
 					    "Invalid NVRAM config link_config=0x%08x "
 					    "speed_cap_mask=0x%08x",
 					    link_config,
@@ -8579,7 +8647,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
 				sc->port.advertising[idx] |=
 				    (ADVERTISED_10baseT_Half | ADVERTISED_TP);
 			} else {
-				PMD_DRV_LOG(ERR,
+				PMD_DRV_LOG(ERR, sc,
 					    "Invalid NVRAM config link_config=0x%08x "
 					    "speed_cap_mask=0x%08x",
 					    link_config,
@@ -8598,7 +8666,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
 				sc->port.advertising[idx] |=
 				    (ADVERTISED_100baseT_Full | ADVERTISED_TP);
 			} else {
-				PMD_DRV_LOG(ERR,
+				PMD_DRV_LOG(ERR, sc,
 					    "Invalid NVRAM config link_config=0x%08x "
 					    "speed_cap_mask=0x%08x",
 					    link_config,
@@ -8618,7 +8686,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
 				sc->port.advertising[idx] |=
 				    (ADVERTISED_100baseT_Half | ADVERTISED_TP);
 			} else {
-				PMD_DRV_LOG(ERR,
+				PMD_DRV_LOG(ERR, sc,
 					    "Invalid NVRAM config link_config=0x%08x "
 					    "speed_cap_mask=0x%08x",
 					    link_config,
@@ -8636,7 +8704,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
 				sc->port.advertising[idx] |=
 				    (ADVERTISED_1000baseT_Full | ADVERTISED_TP);
 			} else {
-				PMD_DRV_LOG(ERR,
+				PMD_DRV_LOG(ERR, sc,
 					    "Invalid NVRAM config link_config=0x%08x "
 					    "speed_cap_mask=0x%08x",
 					    link_config,
@@ -8654,7 +8722,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
 				sc->port.advertising[idx] |=
 				    (ADVERTISED_2500baseX_Full | ADVERTISED_TP);
 			} else {
-				PMD_DRV_LOG(ERR,
+				PMD_DRV_LOG(ERR, sc,
 					    "Invalid NVRAM config link_config=0x%08x "
 					    "speed_cap_mask=0x%08x",
 					    link_config,
@@ -8673,7 +8741,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
 				    (ADVERTISED_10000baseT_Full |
 				     ADVERTISED_FIBRE);
 			} else {
-				PMD_DRV_LOG(ERR,
+				PMD_DRV_LOG(ERR, sc,
 					    "Invalid NVRAM config link_config=0x%08x "
 					    "speed_cap_mask=0x%08x",
 					    link_config,
@@ -8688,7 +8756,7 @@ static void bnx2x_link_settings_requested(struct bnx2x_softc *sc)
 			break;
 
 		default:
-			PMD_DRV_LOG(ERR,
+			PMD_DRV_LOG(ERR, sc,
 				    "Invalid NVRAM config link_config=0x%08x "
 				    "speed_cap_mask=0x%08x", link_config,
 				    sc->link_params.speed_cap_mask[idx]);
@@ -8719,7 +8787,7 @@ static void bnx2x_get_phy_info(struct bnx2x_softc *sc)
 	uint8_t port = SC_PORT(sc);
 	uint32_t eee_mode;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	/* shmem data already read in bnx2x_get_shmem_info() */
 
@@ -8879,7 +8947,7 @@ int bnx2x_alloc_hsi_mem(struct bnx2x_softc *sc)
 		snprintf(buf, sizeof(buf), "fp_%d_sb", i);
 		if (bnx2x_dma_alloc(sc, sizeof(union bnx2x_host_hc_status_block),
 				  &fp->sb_dma, buf, RTE_CACHE_LINE_SIZE) != 0) {
-			PMD_DRV_LOG(NOTICE, "Failed to alloc %s", buf);
+			PMD_DRV_LOG(NOTICE, sc, "Failed to alloc %s", buf);
 			return -1;
 		} else {
 			if (CHIP_IS_E2E3(sc)) {
@@ -8969,7 +9037,7 @@ static int bnx2x_prev_mcp_done(struct bnx2x_softc *sc)
 	uint32_t rc = bnx2x_fw_command(sc, DRV_MSG_CODE_UNLOAD_DONE,
 				     DRV_MSG_CODE_UNLOAD_SKIP_LINK_RESET);
 	if (!rc) {
-		PMD_DRV_LOG(NOTICE, "MCP response failure, aborting");
+		PMD_DRV_LOG(NOTICE, sc, "MCP response failure, aborting");
 		return -1;
 	}
 
@@ -9001,12 +9069,12 @@ static uint8_t bnx2x_prev_is_path_marked(struct bnx2x_softc *sc)
 	tmp = bnx2x_prev_path_get_entry(sc);
 	if (tmp) {
 		if (tmp->aer) {
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "Path %d/%d/%d was marked by AER",
 				    sc->pcie_bus, sc->pcie_device, SC_PATH(sc));
 		} else {
 			rc = TRUE;
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "Path %d/%d/%d was already cleaned from previous drivers",
 				    sc->pcie_bus, sc->pcie_device, SC_PATH(sc));
 		}
@@ -9027,11 +9095,11 @@ static int bnx2x_prev_mark_path(struct bnx2x_softc *sc, uint8_t after_undi)
 	tmp = bnx2x_prev_path_get_entry(sc);
 	if (tmp) {
 		if (!tmp->aer) {
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "Re-marking AER in path %d/%d/%d",
 				    sc->pcie_bus, sc->pcie_device, SC_PATH(sc));
 		} else {
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "Removing AER indication from path %d/%d/%d",
 				    sc->pcie_bus, sc->pcie_device, SC_PATH(sc));
 			tmp->aer = 0;
@@ -9047,7 +9115,7 @@ static int bnx2x_prev_mark_path(struct bnx2x_softc *sc, uint8_t after_undi)
 	tmp = rte_malloc("", sizeof(struct bnx2x_prev_list_node),
 			 RTE_CACHE_LINE_SIZE);
 	if (!tmp) {
-		PMD_DRV_LOG(NOTICE, "Failed to allocate 'bnx2x_prev_list_node'");
+		PMD_DRV_LOG(NOTICE, sc, "Failed to allocate 'bnx2x_prev_list_node'");
 		return -1;
 	}
 
@@ -9072,13 +9140,13 @@ static int bnx2x_do_flr(struct bnx2x_softc *sc)
 
 	/* only E2 and onwards support FLR */
 	if (CHIP_IS_E1x(sc)) {
-		PMD_DRV_LOG(WARNING, "FLR not supported in E1H");
+		PMD_DRV_LOG(WARNING, sc, "FLR not supported in E1H");
 		return -1;
 	}
 
 	/* only bootcode REQ_BC_VER_4_INITIATE_FLR and onwards support flr */
 	if (sc->devinfo.bc_ver < REQ_BC_VER_4_INITIATE_FLR) {
-		PMD_DRV_LOG(WARNING,
+		PMD_DRV_LOG(WARNING, sc,
 			    "FLR not supported by BC_VER: 0x%08x",
 			    sc->devinfo.bc_ver);
 		return -1;
@@ -9095,7 +9163,7 @@ static int bnx2x_do_flr(struct bnx2x_softc *sc)
 		}
 	}
 
-	PMD_DRV_LOG(NOTICE, "PCIE transaction is not cleared, "
+	PMD_DRV_LOG(NOTICE, sc, "PCIE transaction is not cleared, "
 		    "proceeding with reset anyway");
 
 clear:
@@ -9243,7 +9311,7 @@ static int bnx2x_prev_unload_common(struct bnx2x_softc *sc)
 		if (reset_reg & MISC_REGISTERS_RESET_REG_1_RST_DORQ) {
 			tmp_reg = REG_RD(sc, DORQ_REG_NORM_CID_OFST);
 			if (tmp_reg == 0x7) {
-				PMD_DRV_LOG(DEBUG, "UNDI previously loaded");
+				PMD_DRV_LOG(DEBUG, sc, "UNDI previously loaded");
 				prev_undi = TRUE;
 				/* clear the UNDI indication */
 				REG_WR(sc, DORQ_REG_NORM_CID_OFST, 0);
@@ -9262,7 +9330,7 @@ static int bnx2x_prev_unload_common(struct bnx2x_softc *sc)
 				break;
 			}
 
-			PMD_DRV_LOG(DEBUG, "BRB still has 0x%08x", tmp_reg);
+			PMD_DRV_LOG(DEBUG, sc, "BRB still has 0x%08x", tmp_reg);
 
 			/* reset timer as long as BRB actually gets emptied */
 			if (prev_brb > tmp_reg) {
@@ -9280,7 +9348,7 @@ static int bnx2x_prev_unload_common(struct bnx2x_softc *sc)
 		}
 
 		if (!timer_count) {
-			PMD_DRV_LOG(NOTICE, "Failed to empty BRB");
+			PMD_DRV_LOG(NOTICE, sc, "Failed to empty BRB");
 		}
 	}
 
@@ -9335,7 +9403,7 @@ static int bnx2x_prev_unload_uncommon(struct bnx2x_softc *sc)
 		return 0;
 	}
 
-	PMD_DRV_LOG(INFO, "Could not FLR");
+	PMD_DRV_LOG(INFO, sc, "Could not FLR");
 
 	/* Close the MCP request, return failure */
 	rc = bnx2x_prev_mcp_done(sc);
@@ -9352,6 +9420,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.
@@ -9359,22 +9429,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);
 	}
 
@@ -9382,7 +9453,7 @@ static int bnx2x_prev_unload(struct bnx2x_softc *sc)
 		/* Lock MCP using an unload request */
 		fw = bnx2x_fw_command(sc, DRV_MSG_CODE_UNLOAD_REQ_WOL_DIS, 0);
 		if (!fw) {
-			PMD_DRV_LOG(NOTICE, "MCP response failure, aborting");
+			PMD_DRV_LOG(NOTICE, sc, "MCP response failure, aborting");
 			rc = -1;
 			break;
 		}
@@ -9402,7 +9473,7 @@ static int bnx2x_prev_unload(struct bnx2x_softc *sc)
 	} while (--time_counter);
 
 	if (!time_counter || rc) {
-		PMD_DRV_LOG(NOTICE, "Failed to unload previous driver!");
+		PMD_DRV_LOG(NOTICE, sc, "Failed to unload previous driver!");
 		rc = -1;
 	}
 
@@ -9419,7 +9490,7 @@ bnx2x_dcbx_set_state(struct bnx2x_softc *sc, uint8_t dcb_on, uint32_t dcbx_enabl
 		sc->dcb_state = FALSE;
 		sc->dcbx_enabled = BNX2X_DCBX_ENABLED_INVALID;
 	}
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 		    "DCB state [%s:%s]",
 		    dcb_on ? "ON" : "OFF",
 		    (dcbx_enabled == BNX2X_DCBX_ENABLED_OFF) ? "user-mode" :
@@ -9452,7 +9523,7 @@ static void bnx2x_init_multi_cos(struct bnx2x_softc *sc)
 		if (cos < sc->max_cos) {
 			sc->prio_to_cos[pri] = cos;
 		} else {
-			PMD_DRV_LOG(WARNING,
+			PMD_DRV_LOG(WARNING, sc,
 				    "Invalid COS %d for priority %d "
 				    "(max COS is %d), setting to 0", cos, pri,
 				    (sc->max_cos - 1));
@@ -9473,7 +9544,7 @@ static int bnx2x_pci_get_caps(struct bnx2x_softc *sc)
 	cap = sc->pci_caps = rte_zmalloc("caps", sizeof(struct bnx2x_pci_cap),
 					 RTE_CACHE_LINE_SIZE);
 	if (!cap) {
-		PMD_DRV_LOG(NOTICE, "Failed to allocate memory");
+		PMD_DRV_LOG(NOTICE, sc, "Failed to allocate memory");
 		return -ENOMEM;
 	}
 
@@ -9484,7 +9555,7 @@ static int bnx2x_pci_get_caps(struct bnx2x_softc *sc)
 	pci_read(sc, PCIR_STATUS, &status, 2);
 	if (!(status & PCIM_STATUS_CAPPRESENT)) {
 #endif
-		PMD_DRV_LOG(NOTICE, "PCIe capability reading failed");
+		PMD_DRV_LOG(NOTICE, sc, "PCIe capability reading failed");
 		return -1;
 	}
 
@@ -9504,7 +9575,7 @@ static int bnx2x_pci_get_caps(struct bnx2x_softc *sc)
 					sizeof(struct bnx2x_pci_cap),
 					RTE_CACHE_LINE_SIZE);
 		if (!cap->next) {
-			PMD_DRV_LOG(NOTICE, "Failed to allocate memory");
+			PMD_DRV_LOG(NOTICE, sc, "Failed to allocate memory");
 			return -ENOMEM;
 		}
 		cap = cap->next;
@@ -9540,25 +9611,25 @@ void bnx2x_load_firmware(struct bnx2x_softc *sc)
 		? FW_NAME_57711 : FW_NAME_57810;
 	f = open(fwname, O_RDONLY);
 	if (f < 0) {
-		PMD_DRV_LOG(NOTICE, "Can't open firmware file");
+		PMD_DRV_LOG(NOTICE, sc, "Can't open firmware file");
 		return;
 	}
 
 	if (fstat(f, &st) < 0) {
-		PMD_DRV_LOG(NOTICE, "Can't stat firmware file");
+		PMD_DRV_LOG(NOTICE, sc, "Can't stat firmware file");
 		close(f);
 		return;
 	}
 
 	sc->firmware = rte_zmalloc("bnx2x_fw", st.st_size, RTE_CACHE_LINE_SIZE);
 	if (!sc->firmware) {
-		PMD_DRV_LOG(NOTICE, "Can't allocate memory for firmware");
+		PMD_DRV_LOG(NOTICE, sc, "Can't allocate memory for firmware");
 		close(f);
 		return;
 	}
 
 	if (read(f, sc->firmware, st.st_size) != st.st_size) {
-		PMD_DRV_LOG(NOTICE, "Can't read firmware data");
+		PMD_DRV_LOG(NOTICE, sc, "Can't read firmware data");
 		close(f);
 		return;
 	}
@@ -9566,10 +9637,11 @@ void bnx2x_load_firmware(struct bnx2x_softc *sc)
 
 	sc->fw_len = st.st_size;
 	if (sc->fw_len < FW_HEADER_LEN) {
-		PMD_DRV_LOG(NOTICE, "Invalid fw size: %" PRIu64, sc->fw_len);
+		PMD_DRV_LOG(NOTICE, sc,
+			    "Invalid fw size: %" PRIu64, sc->fw_len);
 		return;
 	}
-	PMD_DRV_LOG(DEBUG, "fw_len = %" PRIu64, sc->fw_len);
+	PMD_DRV_LOG(DEBUG, sc, "fw_len = %" PRIu64, sc->fw_len);
 }
 
 static void
@@ -9636,11 +9708,11 @@ int bnx2x_attach(struct bnx2x_softc *sc)
 {
 	int rc;
 
-	PMD_DRV_LOG(DEBUG, "Starting attach...");
+	PMD_DRV_LOG(DEBUG, sc, "Starting attach...");
 
 	rc = bnx2x_pci_get_caps(sc);
 	if (rc) {
-		PMD_DRV_LOG(NOTICE, "PCIe caps reading was failed");
+		PMD_DRV_LOG(NOTICE, sc, "PCIe caps reading was failed");
 		return rc;
 	}
 
@@ -9679,7 +9751,7 @@ int bnx2x_attach(struct bnx2x_softc *sc)
 
 		/* get device info and set params */
 		if (bnx2x_get_device_info(sc) != 0) {
-			PMD_DRV_LOG(NOTICE, "getting device info");
+			PMD_DRV_LOG(NOTICE, sc, "getting device info");
 			return -ENXIO;
 		}
 
@@ -9703,6 +9775,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);
 	}
 
@@ -9778,7 +9852,7 @@ bnx2x_igu_clear_sb_gen(struct bnx2x_softc *sc, uint8_t func, uint8_t idu_sb_id,
 
 	mb();
 
-	PMD_DRV_LOG(DEBUG, "write 0x%08x to IGU(via GRC) addr 0x%x",
+	PMD_DRV_LOG(DEBUG, sc, "write 0x%08x to IGU(via GRC) addr 0x%x",
 		    ctl, igu_addr_ctl);
 	REG_WR(sc, igu_addr_ctl, ctl);
 
@@ -9790,7 +9864,7 @@ bnx2x_igu_clear_sb_gen(struct bnx2x_softc *sc, uint8_t func, uint8_t idu_sb_id,
 	}
 
 	if (!(REG_RD(sc, igu_addr_ack) & sb_bit)) {
-		PMD_DRV_LOG(DEBUG,
+		PMD_DRV_LOG(DEBUG, sc,
 			    "Unable to finish IGU cleanup: "
 			    "idu_sb_id %d offset %d bit %d (cnt %d)",
 			    idu_sb_id, idu_sb_id / 32, idu_sb_id % 32, cnt);
@@ -9810,7 +9884,7 @@ static void bnx2x_reset_common(struct bnx2x_softc *sc)
 {
 	uint32_t val = 0x1400;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	/* reset_common */
 	REG_WR(sc, (GRCBASE_MISC + MISC_REGISTERS_RESET_REG_1_CLEAR),
@@ -9844,8 +9918,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)
@@ -10019,7 +10095,8 @@ static int bnx2x_init_hw_common(struct bnx2x_softc *sc)
 	uint8_t abs_func_id;
 	uint32_t val;
 
-	PMD_DRV_LOG(DEBUG, "starting common init for func %d", SC_ABS_FUNC(sc));
+	PMD_DRV_LOG(DEBUG, sc,
+		    "starting common init for func %d", SC_ABS_FUNC(sc));
 
 	/*
 	 * take the RESET lock to protect undi_unload flow from accessing
@@ -10102,12 +10179,12 @@ static int bnx2x_init_hw_common(struct bnx2x_softc *sc)
 
 	val = REG_RD(sc, PXP2_REG_RQ_CFG_DONE);
 	if (val != 1) {
-		PMD_DRV_LOG(NOTICE, "PXP2 CFG failed");
+		PMD_DRV_LOG(NOTICE, sc, "PXP2 CFG failed");
 		return -1;
 	}
 	val = REG_RD(sc, PXP2_REG_RD_INIT_DONE);
 	if (val != 1) {
-		PMD_DRV_LOG(NOTICE, "PXP2 RD_INIT failed");
+		PMD_DRV_LOG(NOTICE, sc, "PXP2 RD_INIT failed");
 		return -1;
 	}
 
@@ -10229,7 +10306,7 @@ static int bnx2x_init_hw_common(struct bnx2x_softc *sc)
 		} while (factor-- && (val != 1));
 
 		if (val != 1) {
-			PMD_DRV_LOG(NOTICE, "ATC_INIT failed");
+			PMD_DRV_LOG(NOTICE, sc, "ATC_INIT failed");
 			return -1;
 		}
 	}
@@ -10367,7 +10444,7 @@ static int bnx2x_init_hw_common(struct bnx2x_softc *sc)
 
 	if (sizeof(union cdu_context) != 1024) {
 /* we currently assume that a context is 1024 bytes */
-		PMD_DRV_LOG(NOTICE,
+		PMD_DRV_LOG(NOTICE, sc,
 			    "please adjust the size of cdu_context(%ld)",
 			    (long)sizeof(union cdu_context));
 	}
@@ -10429,17 +10506,17 @@ static int bnx2x_init_hw_common(struct bnx2x_softc *sc)
 	/* finish CFC init */
 	val = reg_poll(sc, CFC_REG_LL_INIT_DONE, 1, 100, 10);
 	if (val != 1) {
-		PMD_DRV_LOG(NOTICE, "CFC LL_INIT failed");
+		PMD_DRV_LOG(NOTICE, sc, "CFC LL_INIT failed");
 		return -1;
 	}
 	val = reg_poll(sc, CFC_REG_AC_INIT_DONE, 1, 100, 10);
 	if (val != 1) {
-		PMD_DRV_LOG(NOTICE, "CFC AC_INIT failed");
+		PMD_DRV_LOG(NOTICE, sc, "CFC AC_INIT failed");
 		return -1;
 	}
 	val = reg_poll(sc, CFC_REG_CAM_INIT_DONE, 1, 100, 10);
 	if (val != 1) {
-		PMD_DRV_LOG(NOTICE, "CFC CAM_INIT failed");
+		PMD_DRV_LOG(NOTICE, sc, "CFC CAM_INIT failed");
 		return -1;
 	}
 	REG_WR(sc, CFC_REG_DEBUG0, 0);
@@ -10492,7 +10569,7 @@ static int bnx2x_init_hw_port(struct bnx2x_softc *sc)
 	uint32_t low, high;
 	uint32_t val;
 
-	PMD_DRV_LOG(DEBUG, "starting port init for port %d", port);
+	PMD_DRV_LOG(DEBUG, sc, "starting port init for port %d", port);
 
 	REG_WR(sc, NIG_REG_MASK_INTERRUPT_PORT0 + port * 4, 0);
 
@@ -10719,7 +10796,7 @@ bnx2x_flr_clnup_poll_hw_counter(struct bnx2x_softc *sc, uint32_t reg,
 	uint32_t val = bnx2x_flr_clnup_reg_poll(sc, reg, 0, poll_cnt);
 
 	if (val != 0) {
-		PMD_DRV_LOG(NOTICE, "%s usage count=%d", msg, val);
+		PMD_DRV_LOG(NOTICE, sc, "%s usage count=%d", msg, val);
 		return -1;
 	}
 
@@ -10811,7 +10888,7 @@ bnx2x_send_final_clnup(struct bnx2x_softc *sc, uint8_t clnup_func,
 	int ret = 0;
 
 	if (REG_RD(sc, comp_addr)) {
-		PMD_DRV_LOG(NOTICE,
+		PMD_DRV_LOG(NOTICE, sc,
 			    "Cleanup complete was not 0 before sending");
 		return -1;
 	}
@@ -10824,8 +10901,8 @@ bnx2x_send_final_clnup(struct bnx2x_softc *sc, uint8_t clnup_func,
 	REG_WR(sc, XSDM_REG_OPERATION_GEN, op_gen_command);
 
 	if (bnx2x_flr_clnup_reg_poll(sc, comp_addr, 1, poll_cnt) != 1) {
-		PMD_DRV_LOG(NOTICE, "FW final cleanup did not succeed");
-		PMD_DRV_LOG(DEBUG, "At timeout completion address contained %x",
+		PMD_DRV_LOG(NOTICE, sc, "FW final cleanup did not succeed");
+		PMD_DRV_LOG(DEBUG, sc, "At timeout completion address contained %x",
 			    (REG_RD(sc, comp_addr)));
 		rte_panic("FLR cleanup failed");
 		return -1;
@@ -10941,28 +11018,30 @@ static void bnx2x_hw_enable_status(struct bnx2x_softc *sc)
 	__rte_unused uint32_t val;
 
 	val = REG_RD(sc, CFC_REG_WEAK_ENABLE_PF);
-	PMD_DRV_LOG(DEBUG, "CFC_REG_WEAK_ENABLE_PF is 0x%x", val);
+	PMD_DRV_LOG(DEBUG, sc, "CFC_REG_WEAK_ENABLE_PF is 0x%x", val);
 
 	val = REG_RD(sc, PBF_REG_DISABLE_PF);
-	PMD_DRV_LOG(DEBUG, "PBF_REG_DISABLE_PF is 0x%x", val);
+	PMD_DRV_LOG(DEBUG, sc, "PBF_REG_DISABLE_PF is 0x%x", val);
 
 	val = REG_RD(sc, IGU_REG_PCI_PF_MSI_EN);
-	PMD_DRV_LOG(DEBUG, "IGU_REG_PCI_PF_MSI_EN is 0x%x", val);
+	PMD_DRV_LOG(DEBUG, sc, "IGU_REG_PCI_PF_MSI_EN is 0x%x", val);
 
 	val = REG_RD(sc, IGU_REG_PCI_PF_MSIX_EN);
-	PMD_DRV_LOG(DEBUG, "IGU_REG_PCI_PF_MSIX_EN is 0x%x", val);
+	PMD_DRV_LOG(DEBUG, sc, "IGU_REG_PCI_PF_MSIX_EN is 0x%x", val);
 
 	val = REG_RD(sc, IGU_REG_PCI_PF_MSIX_FUNC_MASK);
-	PMD_DRV_LOG(DEBUG, "IGU_REG_PCI_PF_MSIX_FUNC_MASK is 0x%x", val);
+	PMD_DRV_LOG(DEBUG, sc, "IGU_REG_PCI_PF_MSIX_FUNC_MASK is 0x%x", val);
 
 	val = REG_RD(sc, PGLUE_B_REG_SHADOW_BME_PF_7_0_CLR);
-	PMD_DRV_LOG(DEBUG, "PGLUE_B_REG_SHADOW_BME_PF_7_0_CLR is 0x%x", val);
+	PMD_DRV_LOG(DEBUG, sc,
+		    "PGLUE_B_REG_SHADOW_BME_PF_7_0_CLR is 0x%x", val);
 
 	val = REG_RD(sc, PGLUE_B_REG_FLR_REQUEST_PF_7_0_CLR);
-	PMD_DRV_LOG(DEBUG, "PGLUE_B_REG_FLR_REQUEST_PF_7_0_CLR is 0x%x", val);
+	PMD_DRV_LOG(DEBUG, sc,
+		    "PGLUE_B_REG_FLR_REQUEST_PF_7_0_CLR is 0x%x", val);
 
 	val = REG_RD(sc, PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER);
-	PMD_DRV_LOG(DEBUG, "PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER is 0x%x",
+	PMD_DRV_LOG(DEBUG, sc, "PGLUE_B_REG_INTERNAL_PFID_ENABLE_MASTER is 0x%x",
 		    val);
 }
 
@@ -11006,7 +11085,7 @@ static int bnx2x_pf_flr_clnup(struct bnx2x_softc *sc)
 
 	/* Verify no pending pci transactions */
 	if (bnx2x_is_pcie_pending(sc)) {
-		PMD_DRV_LOG(NOTICE, "PCIE Transactions still pending");
+		PMD_DRV_LOG(NOTICE, sc, "PCIE Transactions still pending");
 	}
 
 	/* Debug */
@@ -11033,13 +11112,13 @@ static int bnx2x_init_hw_func(struct bnx2x_softc *sc)
 	int main_mem_width, rc;
 	uint32_t i;
 
-	PMD_DRV_LOG(DEBUG, "starting func init for func %d", func);
+	PMD_DRV_LOG(DEBUG, sc, "starting func init for func %d", func);
 
 	/* FLR cleanup */
 	if (!CHIP_IS_E1x(sc)) {
 		rc = bnx2x_pf_flr_clnup(sc);
 		if (rc) {
-			PMD_DRV_LOG(NOTICE, "FLR cleanup failed!");
+			PMD_DRV_LOG(NOTICE, sc, "FLR cleanup failed!");
 			return rc;
 		}
 	}
@@ -11286,7 +11365,7 @@ static int bnx2x_init_hw_func(struct bnx2x_softc *sc)
 
 		val = REG_RD(sc, main_mem_prty_clr);
 		if (val) {
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "Parity errors in HC block during function init (0x%x)!",
 				    val);
 		}
@@ -11321,10 +11400,12 @@ 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,
+			PMD_DRV_LOG(WARNING, sc,
 				    "Bootcode is missing - cannot reset link");
 		}
 	}
@@ -11354,7 +11435,7 @@ static void bnx2x_reset_port(struct bnx2x_softc *sc)
 	/* Check for BRB port occupancy */
 	val = REG_RD(sc, BRB1_REG_PORT_NUM_OCC_BLOCKS_0 + port * 4);
 	if (val) {
-		PMD_DRV_LOG(DEBUG,
+		PMD_DRV_LOG(DEBUG, sc,
 			    "BRB1 is not empty, %d blocks are occupied", val);
 	}
 }
@@ -11548,10 +11629,10 @@ static int ecore_gunzip(struct bnx2x_softc *sc, const uint8_t * zbuf, int len)
 	int ret;
 	int data_begin = cut_gzip_prefix(zbuf, len);
 
-	PMD_DRV_LOG(DEBUG, "ecore_gunzip %d", len);
+	PMD_DRV_LOG(DEBUG, sc, "ecore_gunzip %d", len);
 
 	if (data_begin <= 0) {
-		PMD_DRV_LOG(NOTICE, "bad gzip prefix");
+		PMD_DRV_LOG(NOTICE, sc, "bad gzip prefix");
 		return -1;
 	}
 
@@ -11563,19 +11644,19 @@ static int ecore_gunzip(struct bnx2x_softc *sc, const uint8_t * zbuf, int len)
 
 	ret = inflateInit2(&zlib_stream, -MAX_WBITS);
 	if (ret != Z_OK) {
-		PMD_DRV_LOG(NOTICE, "zlib inflateInit2 error");
+		PMD_DRV_LOG(NOTICE, sc, "zlib inflateInit2 error");
 		return ret;
 	}
 
 	ret = inflate(&zlib_stream, Z_FINISH);
 	if ((ret != Z_STREAM_END) && (ret != Z_OK)) {
-		PMD_DRV_LOG(NOTICE, "zlib inflate error: %d %s", ret,
+		PMD_DRV_LOG(NOTICE, sc, "zlib inflate error: %d %s", ret,
 			    zlib_stream.msg);
 	}
 
 	sc->gz_outlen = zlib_stream.total_out;
 	if (sc->gz_outlen & 0x3) {
-		PMD_DRV_LOG(NOTICE, "firmware is not aligned. gz_outlen == %d",
+		PMD_DRV_LOG(NOTICE, sc, "firmware is not aligned. gz_outlen == %d",
 			    sc->gz_outlen);
 	}
 	sc->gz_outlen >>= 2;
@@ -11605,7 +11686,7 @@ ecore_storm_memset_struct(struct bnx2x_softc *sc, uint32_t addr, size_t size,
 	}
 }
 
-static const char *get_ext_phy_type(uint32_t ext_phy_type)
+__rte_unused static const char *get_ext_phy_type(uint32_t ext_phy_type)
 {
 	uint32_t phy_type_idx = ext_phy_type >> 8;
 	static const char *types[] =
@@ -11623,7 +11704,7 @@ static const char *get_ext_phy_type(uint32_t ext_phy_type)
 		return types[13];
 }
 
-static const char *get_state(uint32_t state)
+__rte_unused static const char *get_state(uint32_t state)
 {
 	uint32_t state_idx = state >> 12;
 	static const char *states[] = { "CLOSED", "OPENING_WAIT4_LOAD",
@@ -11639,7 +11720,7 @@ static const char *get_state(uint32_t state)
 		return states[0x10];
 }
 
-static const char *get_recovery_state(uint32_t state)
+__rte_unused static const char *get_recovery_state(uint32_t state)
 {
 	static const char *states[] = { "NONE", "DONE", "INIT",
 		"WAIT", "FAILED", "NIC_LOADING"
@@ -11647,7 +11728,7 @@ static const char *get_recovery_state(uint32_t state)
 	return states[state];
 }
 
-static const char *get_rx_mode(uint32_t mode)
+__rte_unused static const char *get_rx_mode(uint32_t mode)
 {
 	static const char *modes[] = { "NONE", "NORMAL", "ALLMULTI",
 		"PROMISC", "MAX_MULTICAST", "ERROR"
@@ -11662,7 +11743,7 @@ static const char *get_rx_mode(uint32_t mode)
 }
 
 #define BNX2X_INFO_STR_MAX 256
-static const char *get_bnx2x_flags(uint32_t flags)
+__rte_unused static const char *get_bnx2x_flags(uint32_t flags)
 {
 	int i;
 	static const char *flag[] = { "ONE_PORT ", "NO_ISCSI ",
@@ -11694,7 +11775,7 @@ void bnx2x_print_adapter_info(struct bnx2x_softc *sc)
 	int i = 0;
 	__rte_unused uint32_t ext_phy_type;
 
-	PMD_INIT_FUNC_TRACE();
+	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->
@@ -11713,97 +11794,102 @@ void bnx2x_print_adapter_info(struct bnx2x_softc *sc)
 									 dev_info.port_hw_config
 									 [0].external_phy_config)));
 
-	PMD_INIT_LOG(DEBUG, "\n\n===================================\n");
+	PMD_DRV_LOG(INFO, sc, "\n\n===================================\n");
 	/* Hardware chip info. */
-	PMD_INIT_LOG(DEBUG, "%12s : %#08x", "ASIC", sc->devinfo.chip_id);
-	PMD_INIT_LOG(DEBUG, "%12s : %c%d", "Rev", (CHIP_REV(sc) >> 12) + 'A',
+	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_INIT_LOG(DEBUG, "%12s : %d, ", "Bus PCIe", sc->devinfo.pcie_link_width);
+	PMD_DRV_LOG(INFO, sc,
+		    "%12s : %d, ", "Bus PCIe", sc->devinfo.pcie_link_width);
 	switch (sc->devinfo.pcie_link_speed) {
 	case 1:
-		PMD_INIT_LOG(DEBUG, "%23s", "2.5 Gbps");
+		PMD_DRV_LOG(INFO, sc, "%23s", "2.5 Gbps");
 		break;
 	case 2:
-		PMD_INIT_LOG(DEBUG, "%21s", "5 Gbps");
+		PMD_DRV_LOG(INFO, sc, "%21s", "5 Gbps");
 		break;
 	case 4:
-		PMD_INIT_LOG(DEBUG, "%21s", "8 Gbps");
+		PMD_DRV_LOG(INFO, sc, "%21s", "8 Gbps");
 		break;
 	default:
-		PMD_INIT_LOG(DEBUG, "%33s", "Unknown link speed");
+		PMD_DRV_LOG(INFO, sc, "%33s", "Unknown link speed");
 	}
 
 	/* Device features. */
-	PMD_INIT_LOG(DEBUG, "%12s : ", "Flags");
+	PMD_DRV_LOG(INFO, sc, "%12s : ", "Flags");
 
 	/* Miscellaneous flags. */
 	if (sc->devinfo.pcie_cap_flags & BNX2X_MSI_CAPABLE_FLAG) {
-		PMD_INIT_LOG(DEBUG, "%18s", "MSI");
+		PMD_DRV_LOG(INFO, sc, "%18s", "MSI");
 		i++;
 	}
 
 	if (sc->devinfo.pcie_cap_flags & BNX2X_MSIX_CAPABLE_FLAG) {
 		if (i > 0)
-			PMD_INIT_LOG(DEBUG, "|");
-		PMD_INIT_LOG(DEBUG, "%20s", "MSI-X");
+			PMD_DRV_LOG(INFO, sc, "|");
+		PMD_DRV_LOG(INFO, sc, "%20s", "MSI-X");
 		i++;
 	}
 
 	if (IS_PF(sc)) {
-		PMD_INIT_LOG(DEBUG, "%12s : ", "Queues");
+		PMD_DRV_LOG(INFO, sc, "%12s : ", "Queues");
 		switch (sc->sp->rss_rdata.rss_mode) {
 		case ETH_RSS_MODE_DISABLED:
-			PMD_INIT_LOG(DEBUG, "%19s", "None");
+			PMD_DRV_LOG(INFO, sc, "%19s", "None");
 			break;
 		case ETH_RSS_MODE_REGULAR:
-			PMD_INIT_LOG(DEBUG, "%18s : %d", "RSS", sc->num_queues);
+			PMD_DRV_LOG(INFO, sc,
+				    "%18s : %d", "RSS", sc->num_queues);
 			break;
 		default:
-			PMD_INIT_LOG(DEBUG, "%22s", "Unknown");
+			PMD_DRV_LOG(INFO, sc, "%22s", "Unknown");
 			break;
 		}
 	}
 
 	/* RTE and Driver versions */
-	PMD_INIT_LOG(DEBUG, "%12s : %s", "DPDK",
-		     rte_version());
-	PMD_INIT_LOG(DEBUG, "%12s : %s", "Driver",
-		     bnx2x_pmd_version());
+	PMD_DRV_LOG(INFO, sc, "%12s : %s", "DPDK",
+			rte_version());
+	PMD_DRV_LOG(INFO, sc, "%12s : %s", "Driver",
+			bnx2x_pmd_version());
 
 	/* Firmware versions and device features. */
-	PMD_INIT_LOG(DEBUG, "%12s : %d.%d.%d",
+	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_INIT_LOG(DEBUG, "%12s : %s",
+	PMD_DRV_LOG(INFO, sc, "%12s : %s",
 		     "Bootcode", sc->devinfo.bc_ver_str);
 
-	PMD_INIT_LOG(DEBUG, "\n\n===================================\n");
-	PMD_INIT_LOG(DEBUG, "%12s : %u", "Bnx2x Func", sc->pcie_func);
-	PMD_INIT_LOG(DEBUG, "%12s : %s", "Bnx2x Flags", get_bnx2x_flags(sc->flags));
-	PMD_INIT_LOG(DEBUG, "%12s : %s", "DMAE Is",
+	PMD_DRV_LOG(INFO, sc, "\n\n===================================\n");
+	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_INIT_LOG(DEBUG, "%12s : %s", "OVLAN", (OVLAN(sc) ? "YES" : "NO"));
-	PMD_INIT_LOG(DEBUG, "%12s : %s", "MF", (IS_MF(sc) ? "YES" : "NO"));
-	PMD_INIT_LOG(DEBUG, "%12s : %u", "MTU", sc->mtu);
-	PMD_INIT_LOG(DEBUG, "%12s : %s", "PHY Type", get_ext_phy_type(ext_phy_type));
-	PMD_INIT_LOG(DEBUG, "%12s : %x:%x:%x:%x:%x:%x", "MAC Addr",
+	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));
+	PMD_DRV_LOG(INFO, sc, "%12s : %x:%x:%x:%x:%x:%x", "MAC Addr",
 			sc->link_params.mac_addr[0],
 			sc->link_params.mac_addr[1],
 			sc->link_params.mac_addr[2],
 			sc->link_params.mac_addr[3],
 			sc->link_params.mac_addr[4],
 			sc->link_params.mac_addr[5]);
-	PMD_INIT_LOG(DEBUG, "%12s : %s", "RX Mode", get_rx_mode(sc->rx_mode));
-	PMD_INIT_LOG(DEBUG, "%12s : %s", "State", get_state(sc->state));
+	PMD_DRV_LOG(INFO, sc, "%12s : %s", "RX Mode", get_rx_mode(sc->rx_mode));
+	PMD_DRV_LOG(INFO, sc, "%12s : %s", "State", get_state(sc->state));
 	if (sc->recovery_state)
-		PMD_INIT_LOG(DEBUG, "%12s : %s", "Recovery",
+		PMD_DRV_LOG(INFO, sc, "%12s : %s", "Recovery",
 			     get_recovery_state(sc->recovery_state));
-	PMD_INIT_LOG(DEBUG, "%12s : CQ = %lx,  EQ = %lx", "SPQ Left",
+	PMD_DRV_LOG(INFO, sc, "%12s : CQ = %lx,  EQ = %lx", "SPQ Left",
 		     sc->cq_spq_left, sc->eq_spq_left);
-	PMD_INIT_LOG(DEBUG, "%12s : %x", "Switch", sc->link_params.switch_cfg);
-	PMD_INIT_LOG(DEBUG, "\n\n===================================\n");
+	PMD_DRV_LOG(INFO, sc,
+		    "%12s : %x", "Switch", sc->link_params.switch_cfg);
+	PMD_DRV_LOG(INFO, sc, "\n\n===================================\n");
 }
diff --git a/drivers/net/bnx2x/bnx2x.h b/drivers/net/bnx2x/bnx2x.h
index 57093054..5dfd2f8e 100644
--- a/drivers/net/bnx2x/bnx2x.h
+++ b/drivers/net/bnx2x/bnx2x.h
@@ -725,6 +725,13 @@ struct bnx2x_port {
 
     uint32_t    phy_addr;
 
+	/* Used to synchronize phy accesses. */
+	rte_spinlock_t	phy_mtx;
+	char		phy_mtx_name[32];
+
+#define BNX2X_PHY_LOCK(sc)          rte_spinlock_lock(&sc->port.phy_mtx)
+#define BNX2X_PHY_UNLOCK(sc)        rte_spinlock_unlock(&sc->port.phy_mtx)
+
     /*
      * MCP scratchpad address for port specific statistics.
      * The device is responsible for writing statistcss
@@ -803,6 +810,10 @@ struct bnx2x_mf_info {
 
 /* Device information data structure. */
 struct bnx2x_devinfo {
+#if 1
+#define NAME_SIZE 128
+	char name[NAME_SIZE];
+#endif
 	/* PCIe info */
 	uint16_t vendor_id;
 	uint16_t device_id;
@@ -1418,7 +1429,7 @@ struct bnx2x_func_init_params {
 static inline void
 bnx2x_reg_write8(struct bnx2x_softc *sc, size_t offset, uint8_t val)
 {
-	PMD_DEBUG_PERIODIC_LOG(DEBUG, "offset=0x%08lx val=0x%02x",
+	PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "offset=0x%08lx val=0x%02x",
 			       (unsigned long)offset, val);
 	*((volatile uint8_t*)
 	  ((uintptr_t)sc->bar[BAR0].base_addr + offset)) = val;
@@ -1429,10 +1440,10 @@ bnx2x_reg_write16(struct bnx2x_softc *sc, size_t offset, uint16_t val)
 {
 #ifdef RTE_LIBRTE_BNX2X_DEBUG_PERIODIC
 	if ((offset % 2) != 0)
-		PMD_DRV_LOG(NOTICE, "Unaligned 16-bit write to 0x%08lx",
+		PMD_DRV_LOG(NOTICE, sc, "Unaligned 16-bit write to 0x%08lx",
 			    (unsigned long)offset);
 #endif
-	PMD_DEBUG_PERIODIC_LOG(DEBUG, "offset=0x%08lx val=0x%04x",
+	PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "offset=0x%08lx val=0x%04x",
 			       (unsigned long)offset, val);
 	*((volatile uint16_t*)
 	  ((uintptr_t)sc->bar[BAR0].base_addr + offset)) = val;
@@ -1443,11 +1454,11 @@ bnx2x_reg_write32(struct bnx2x_softc *sc, size_t offset, uint32_t val)
 {
 #ifdef RTE_LIBRTE_BNX2X_DEBUG_PERIODIC
 	if ((offset % 4) != 0)
-		PMD_DRV_LOG(NOTICE, "Unaligned 32-bit write to 0x%08lx",
+		PMD_DRV_LOG(NOTICE, sc, "Unaligned 32-bit write to 0x%08lx",
 			    (unsigned long)offset);
 #endif
 
-	PMD_DEBUG_PERIODIC_LOG(DEBUG, "offset=0x%08lx val=0x%08x",
+	PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "offset=0x%08lx val=0x%08x",
 			       (unsigned long)offset, val);
 	*((volatile uint32_t*)
 	  ((uintptr_t)sc->bar[BAR0].base_addr + offset)) = val;
@@ -1460,7 +1471,7 @@ bnx2x_reg_read8(struct bnx2x_softc *sc, size_t offset)
 
 	val = (uint8_t)(*((volatile uint8_t*)
 			  ((uintptr_t)sc->bar[BAR0].base_addr + offset)));
-	PMD_DEBUG_PERIODIC_LOG(DEBUG, "offset=0x%08lx val=0x%02x",
+	PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "offset=0x%08lx val=0x%02x",
 			       (unsigned long)offset, val);
 
 	return val;
@@ -1473,13 +1484,13 @@ bnx2x_reg_read16(struct bnx2x_softc *sc, size_t offset)
 
 #ifdef RTE_LIBRTE_BNX2X_DEBUG_PERIODIC
 	if ((offset % 2) != 0)
-		PMD_DRV_LOG(NOTICE, "Unaligned 16-bit read from 0x%08lx",
+		PMD_DRV_LOG(NOTICE, sc, "Unaligned 16-bit read from 0x%08lx",
 			    (unsigned long)offset);
 #endif
 
 	val = (uint16_t)(*((volatile uint16_t*)
 			   ((uintptr_t)sc->bar[BAR0].base_addr + offset)));
-	PMD_DEBUG_PERIODIC_LOG(DEBUG, "offset=0x%08lx val=0x%08x",
+	PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "offset=0x%08lx val=0x%08x",
 			       (unsigned long)offset, val);
 
 	return val;
@@ -1492,13 +1503,13 @@ bnx2x_reg_read32(struct bnx2x_softc *sc, size_t offset)
 
 #ifdef RTE_LIBRTE_BNX2X_DEBUG_PERIODIC
 	if ((offset % 4) != 0)
-		PMD_DRV_LOG(NOTICE, "Unaligned 32-bit read from 0x%08lx",
+		PMD_DRV_LOG(NOTICE, sc, "Unaligned 32-bit read from 0x%08lx",
 			    (unsigned long)offset);
 #endif
 
 	val = (uint32_t)(*((volatile uint32_t*)
 			   ((uintptr_t)sc->bar[BAR0].base_addr + offset)));
-	PMD_DEBUG_PERIODIC_LOG(DEBUG, "offset=0x%08lx val=0x%08x",
+	PMD_DEBUG_PERIODIC_LOG(DEBUG, sc, "offset=0x%08lx val=0x%08x",
 			       (unsigned long)offset, val);
 
 	return val;
@@ -1976,7 +1987,7 @@ bnx2x_set_rx_mode(struct bnx2x_softc *sc)
 			bnx2x_vf_set_rx_mode(sc);
 		}
 	} else {
-		PMD_DRV_LOG(NOTICE, "Card is not ready to change mode");
+		PMD_DRV_LOG(NOTICE, sc, "Card is not ready to change mode");
 	}
 }
 
@@ -1984,7 +1995,7 @@ static inline int pci_read(struct bnx2x_softc *sc, size_t addr,
 			   void *val, uint8_t size)
 {
 	if (rte_eal_pci_read_config(sc->pci_dev, val, size, addr) <= 0) {
-		PMD_DRV_LOG(ERR, "Can't read from PCI config space");
+		PMD_DRV_LOG(ERR, sc, "Can't read from PCI config space");
 		return ENXIO;
 	}
 
@@ -1997,7 +2008,7 @@ static inline int pci_write_word(struct bnx2x_softc *sc, size_t addr, off_t val)
 
 	if (rte_eal_pci_write_config(sc->pci_dev, &val16,
 				     sizeof(val16), addr) <= 0) {
-		PMD_DRV_LOG(ERR, "Can't write to PCI config space");
+		PMD_DRV_LOG(ERR, sc, "Can't write to PCI config space");
 		return ENXIO;
 	}
 
@@ -2009,7 +2020,7 @@ static inline int pci_write_long(struct bnx2x_softc *sc, size_t addr, off_t val)
 	uint32_t val32 = val;
 	if (rte_eal_pci_write_config(sc->pci_dev, &val32,
 				     sizeof(val32), addr) <= 0) {
-		PMD_DRV_LOG(ERR, "Can't write to PCI config space");
+		PMD_DRV_LOG(ERR, sc, "Can't write to PCI config space");
 		return ENXIO;
 	}
 
diff --git a/drivers/net/bnx2x/bnx2x_ethdev.c b/drivers/net/bnx2x/bnx2x_ethdev.c
index a8aebbe3..d3733f7a 100644
--- a/drivers/net/bnx2x/bnx2x_ethdev.c
+++ b/drivers/net/bnx2x/bnx2x_ethdev.c
@@ -82,7 +82,7 @@ bnx2x_link_update(struct rte_eth_dev *dev)
 {
 	struct bnx2x_softc *sc = dev->data->dev_private;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 	bnx2x_link_status_update(sc);
 	mb();
 	dev->data->dev_link.link_speed = sc->link_vars.line_speed;
@@ -105,7 +105,7 @@ bnx2x_interrupt_action(struct rte_eth_dev *dev)
 	struct bnx2x_softc *sc = dev->data->dev_private;
 	uint32_t link_status;
 
-	PMD_DEBUG_PERIODIC_LOG(INFO, "Interrupt handled");
+	PMD_DEBUG_PERIODIC_LOG(INFO, sc, "Interrupt handled");
 
 	bnx2x_intr_legacy(sc, 0);
 
@@ -122,8 +122,11 @@ static __rte_unused void
 bnx2x_interrupt_handler(__rte_unused struct rte_intr_handle *handle, void *param)
 {
 	struct rte_eth_dev *dev = (struct rte_eth_dev *)param;
+	struct bnx2x_softc *sc = dev->data->dev_private;
 
+	atomic_store_rel_long(&sc->periodic_flags, PERIODIC_STOP);
 	bnx2x_interrupt_action(dev);
+	atomic_store_rel_long(&sc->periodic_flags, PERIODIC_GO);
 	rte_intr_enable(&(dev->pci_dev->intr_handle));
 }
 
@@ -137,34 +140,34 @@ bnx2x_dev_configure(struct rte_eth_dev *dev)
 	struct bnx2x_softc *sc = dev->data->dev_private;
 	int mp_ncpus = sysconf(_SC_NPROCESSORS_CONF);
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	if (dev->data->dev_conf.rxmode.jumbo_frame)
 		sc->mtu = dev->data->dev_conf.rxmode.max_rx_pkt_len;
 
 	if (dev->data->nb_tx_queues > dev->data->nb_rx_queues) {
-		PMD_DRV_LOG(ERR, "The number of TX queues is greater than number of RX queues");
+		PMD_DRV_LOG(ERR, sc, "The number of TX queues is greater than number of RX queues");
 		return -EINVAL;
 	}
 
 	sc->num_queues = MAX(dev->data->nb_rx_queues, dev->data->nb_tx_queues);
 	if (sc->num_queues > mp_ncpus) {
-		PMD_DRV_LOG(ERR, "The number of queues is more than number of CPUs");
+		PMD_DRV_LOG(ERR, sc, "The number of queues is more than number of CPUs");
 		return -EINVAL;
 	}
 
-	PMD_DRV_LOG(DEBUG, "num_queues=%d, mtu=%d",
+	PMD_DRV_LOG(DEBUG, sc, "num_queues=%d, mtu=%d",
 		       sc->num_queues, sc->mtu);
 
 	/* allocate ilt */
 	if (bnx2x_alloc_ilt_mem(sc) != 0) {
-		PMD_DRV_LOG(ERR, "bnx2x_alloc_ilt_mem was failed");
+		PMD_DRV_LOG(ERR, sc, "bnx2x_alloc_ilt_mem was failed");
 		return -ENXIO;
 	}
 
 	/* allocate the host hardware/software hsi structures */
 	if (bnx2x_alloc_hsi_mem(sc) != 0) {
-		PMD_DRV_LOG(ERR, "bnx2x_alloc_hsi_mem was failed");
+		PMD_DRV_LOG(ERR, sc, "bnx2x_alloc_hsi_mem was failed");
 		bnx2x_free_ilt_mem(sc);
 		return -ENXIO;
 	}
@@ -178,11 +181,11 @@ bnx2x_dev_start(struct rte_eth_dev *dev)
 	struct bnx2x_softc *sc = dev->data->dev_private;
 	int ret = 0;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	ret = bnx2x_init(sc);
 	if (ret) {
-		PMD_DRV_LOG(DEBUG, "bnx2x_init failed (%d)", ret);
+		PMD_DRV_LOG(DEBUG, sc, "bnx2x_init failed (%d)", ret);
 		return -1;
 	}
 
@@ -191,12 +194,12 @@ bnx2x_dev_start(struct rte_eth_dev *dev)
 				bnx2x_interrupt_handler, (void *)dev);
 
 		if(rte_intr_enable(&(dev->pci_dev->intr_handle)))
-			PMD_DRV_LOG(ERR, "rte_intr_enable failed");
+			PMD_DRV_LOG(ERR, sc, "rte_intr_enable failed");
 	}
 
 	ret = bnx2x_dev_rx_init(dev);
 	if (ret != 0) {
-		PMD_DRV_LOG(DEBUG, "bnx2x_dev_rx_init returned error code");
+		PMD_DRV_LOG(DEBUG, sc, "bnx2x_dev_rx_init returned error code");
 		return -3;
 	}
 
@@ -212,7 +215,7 @@ bnx2x_dev_stop(struct rte_eth_dev *dev)
 	struct bnx2x_softc *sc = dev->data->dev_private;
 	int ret = 0;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	if (IS_PF(sc)) {
 		rte_intr_disable(&(dev->pci_dev->intr_handle));
@@ -222,7 +225,7 @@ bnx2x_dev_stop(struct rte_eth_dev *dev)
 
 	ret = bnx2x_nic_unload(sc, UNLOAD_NORMAL, FALSE);
 	if (ret) {
-		PMD_DRV_LOG(DEBUG, "bnx2x_nic_unload failed (%d)", ret);
+		PMD_DRV_LOG(DEBUG, sc, "bnx2x_nic_unload failed (%d)", ret);
 		return;
 	}
 
@@ -234,7 +237,7 @@ bnx2x_dev_close(struct rte_eth_dev *dev)
 {
 	struct bnx2x_softc *sc = dev->data->dev_private;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	if (IS_VF(sc))
 		bnx2x_vf_close(sc);
@@ -254,7 +257,7 @@ bnx2x_promisc_enable(struct rte_eth_dev *dev)
 {
 	struct bnx2x_softc *sc = dev->data->dev_private;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 	sc->rx_mode = BNX2X_RX_MODE_PROMISC;
 	if (rte_eth_allmulticast_get(dev->data->port_id) == 1)
 		sc->rx_mode = BNX2X_RX_MODE_ALLMULTI_PROMISC;
@@ -266,7 +269,7 @@ bnx2x_promisc_disable(struct rte_eth_dev *dev)
 {
 	struct bnx2x_softc *sc = dev->data->dev_private;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 	sc->rx_mode = BNX2X_RX_MODE_NORMAL;
 	if (rte_eth_allmulticast_get(dev->data->port_id) == 1)
 		sc->rx_mode = BNX2X_RX_MODE_ALLMULTI;
@@ -278,7 +281,7 @@ bnx2x_dev_allmulticast_enable(struct rte_eth_dev *dev)
 {
 	struct bnx2x_softc *sc = dev->data->dev_private;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 	sc->rx_mode = BNX2X_RX_MODE_ALLMULTI;
 	if (rte_eth_promiscuous_get(dev->data->port_id) == 1)
 		sc->rx_mode = BNX2X_RX_MODE_ALLMULTI_PROMISC;
@@ -290,7 +293,7 @@ bnx2x_dev_allmulticast_disable(struct rte_eth_dev *dev)
 {
 	struct bnx2x_softc *sc = dev->data->dev_private;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 	sc->rx_mode = BNX2X_RX_MODE_NORMAL;
 	if (rte_eth_promiscuous_get(dev->data->port_id) == 1)
 		sc->rx_mode = BNX2X_RX_MODE_PROMISC;
@@ -300,7 +303,9 @@ bnx2x_dev_allmulticast_disable(struct rte_eth_dev *dev)
 static int
 bnx2x_dev_link_update(struct rte_eth_dev *dev, __rte_unused int wait_to_complete)
 {
-	PMD_INIT_FUNC_TRACE();
+	struct bnx2x_softc *sc = dev->data->dev_private;
+
+	PMD_INIT_FUNC_TRACE(sc);
 
 	int old_link_status = dev->data->dev_link.link_status;
 
@@ -319,7 +324,7 @@ bnx2xvf_dev_link_update(struct rte_eth_dev *dev, __rte_unused int wait_to_comple
 
 	bnx2x_check_bull(sc);
 	if (sc->old_bulletin.valid_bitmap & (1 << CHANNEL_DOWN)) {
-		PMD_DRV_LOG(ERR, "PF indicated channel is down."
+		PMD_DRV_LOG(ERR, sc, "PF indicated channel is down."
 				"VF device is no longer operational");
 		dev->data->dev_link.link_status = ETH_LINK_DOWN;
 	}
@@ -335,7 +340,7 @@ bnx2x_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
 	uint64_t brb_drops;
 	uint64_t brb_truncates;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	bnx2x_stats_handle(sc, STATS_EVENT_UPDATE);
 
@@ -520,27 +525,35 @@ bnx2x_common_dev_init(struct rte_eth_dev *eth_dev, int is_vf)
 {
 	int ret = 0;
 	struct rte_pci_device *pci_dev;
+	struct rte_pci_addr pci_addr;
 	struct bnx2x_softc *sc;
 
-	PMD_INIT_FUNC_TRACE();
+	/* Extract key data structures */
+	sc = eth_dev->data->dev_private;
+	pci_dev = eth_dev->pci_dev;
+	pci_addr = pci_dev->addr;
+
+	snprintf(sc->devinfo.name, NAME_SIZE, PCI_SHORT_PRI_FMT ":dpdk-port-%u",
+		 pci_addr.bus, pci_addr.devid, pci_addr.function,
+		 eth_dev->data->port_id);
+
+	PMD_INIT_FUNC_TRACE(sc);
 
 	eth_dev->dev_ops = is_vf ? &bnx2xvf_eth_dev_ops : &bnx2x_eth_dev_ops;
-	pci_dev = eth_dev->pci_dev;
 
 	rte_eth_copy_pci_info(eth_dev, pci_dev);
 
-	sc = eth_dev->data->dev_private;
 	sc->pcie_bus    = pci_dev->addr.bus;
 	sc->pcie_device = pci_dev->addr.devid;
 
-	if (is_vf)
-		sc->flags = BNX2X_IS_VF_FLAG;
-
 	sc->devinfo.vendor_id    = pci_dev->id.vendor_id;
 	sc->devinfo.device_id    = pci_dev->id.device_id;
 	sc->devinfo.subvendor_id = pci_dev->id.subsystem_vendor_id;
 	sc->devinfo.subdevice_id = pci_dev->id.subsystem_device_id;
 
+	if (is_vf)
+		sc->flags = BNX2X_IS_VF_FLAG;
+
 	sc->pcie_func = pci_dev->addr.function;
 	sc->bar[BAR0].base_addr = (void *)pci_dev->mem_resource[0].addr;
 	if (is_vf)
@@ -568,19 +581,19 @@ bnx2x_common_dev_init(struct rte_eth_dev *eth_dev, int is_vf)
 	sc->pci_dev = pci_dev;
 	ret = bnx2x_attach(sc);
 	if (ret) {
-		PMD_DRV_LOG(ERR, "bnx2x_attach failed (%d)", ret);
+		PMD_DRV_LOG(ERR, sc, "bnx2x_attach failed (%d)", ret);
 		return ret;
 	}
 
 	eth_dev->data->mac_addrs = (struct ether_addr *)sc->link_params.mac_addr;
 
-	PMD_DRV_LOG(INFO, "pcie_bus=%d, pcie_device=%d",
+	PMD_DRV_LOG(INFO, sc, "pcie_bus=%d, pcie_device=%d",
 			sc->pcie_bus, sc->pcie_device);
-	PMD_DRV_LOG(INFO, "bar0.addr=%p, bar1.addr=%p",
+	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, "port=%d, path=%d, vnic=%d, func=%d",
+	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));
-	PMD_DRV_LOG(INFO, "portID=%d vendorID=0x%x deviceID=0x%x",
+	PMD_DRV_LOG(INFO, sc, "portID=%d vendorID=0x%x deviceID=0x%x",
 			eth_dev->data->port_id, pci_dev->id.vendor_id, pci_dev->id.device_id);
 
 	if (IS_VF(sc)) {
@@ -614,14 +627,16 @@ bnx2x_common_dev_init(struct rte_eth_dev *eth_dev, int is_vf)
 static int
 eth_bnx2x_dev_init(struct rte_eth_dev *eth_dev)
 {
-	PMD_INIT_FUNC_TRACE();
+	struct bnx2x_softc *sc = eth_dev->data->dev_private;
+	PMD_INIT_FUNC_TRACE(sc);
 	return bnx2x_common_dev_init(eth_dev, 0);
 }
 
 static int
 eth_bnx2xvf_dev_init(struct rte_eth_dev *eth_dev)
 {
-	PMD_INIT_FUNC_TRACE();
+	struct bnx2x_softc *sc = eth_dev->data->dev_private;
+	PMD_INIT_FUNC_TRACE(sc);
 	return bnx2x_common_dev_init(eth_dev, 1);
 }
 
diff --git a/drivers/net/bnx2x/bnx2x_logs.h b/drivers/net/bnx2x/bnx2x_logs.h
index dff014d7..7b6252fd 100644
--- a/drivers/net/bnx2x/bnx2x_logs.h
+++ b/drivers/net/bnx2x/bnx2x_logs.h
@@ -11,13 +11,14 @@
 #ifndef _PMD_LOGS_H_
 #define _PMD_LOGS_H_
 
-#define PMD_INIT_LOG(level, fmt, args...) \
-	RTE_LOG(level, PMD, "%s(): " fmt "\n", __func__, ##args)
+#define PMD_INIT_LOG(level, sc, fmt, args...) \
+	RTE_LOG(level, PMD, \
+	"[bnx2x_pmd: %s] %s() " fmt "\n", (sc)->devinfo.name, __func__, ##args)
 
 #ifdef RTE_LIBRTE_BNX2X_DEBUG_INIT
-#define PMD_INIT_FUNC_TRACE() PMD_INIT_LOG(DEBUG, " >>")
+#define PMD_INIT_FUNC_TRACE(sc) PMD_INIT_LOG(DEBUG, sc, " >>")
 #else
-#define PMD_INIT_FUNC_TRACE() do { } while(0)
+#define PMD_INIT_FUNC_TRACE(sc) do { (void)sc; } while(0)
 #endif
 
 #ifdef RTE_LIBRTE_BNX2X_DEBUG_RX
@@ -42,20 +43,22 @@
 #endif
 
 #ifdef RTE_LIBRTE_BNX2X_DEBUG
-#define PMD_DRV_LOG_RAW(level, fmt, args...) \
-	RTE_LOG(level, PMD, "%s(): " fmt, __func__, ## args)
+#define PMD_DRV_LOG_RAW(level, sc, fmt, args...) \
+	RTE_LOG(level, PMD, "[%s:%d(%s)] " fmt,	__func__, __LINE__, \
+		(sc)->devinfo.name ? (sc)->devinfo.name : "", ## args)
 #else
-#define PMD_DRV_LOG_RAW(level, fmt, args...) do { } while (0)
+#define PMD_DRV_LOG_RAW(level, sc, fmt, args...) do { } while (0)
 #endif
 
-#define PMD_DRV_LOG(level, fmt, args...) \
-	PMD_DRV_LOG_RAW(level, fmt "\n", ## args)
+#define PMD_DRV_LOG(level, sc, fmt, args...) \
+	PMD_DRV_LOG_RAW(level, sc, fmt "\n", ## args)
 
 #ifdef RTE_LIBRTE_BNX2X_DEBUG_PERIODIC
-#define PMD_DEBUG_PERIODIC_LOG(level, fmt, args...) \
-	RTE_LOG(level, PMD, "%s(): " fmt "\n", __func__, ## args)
+#define PMD_DEBUG_PERIODIC_LOG(level, sc, fmt, args...) \
+	RTE_LOG(level, PMD, "%s(%s): " fmt "\n", __func__, \
+		(sc)->devinfo.name ? (sc)->devinfo.name : "", ## args)
 #else
-#define PMD_DEBUG_PERIODIC_LOG(level, fmt, args...) do { } while(0)
+#define PMD_DEBUG_PERIODIC_LOG(level, sc, fmt, args...) do { } while (0)
 #endif
 
 
diff --git a/drivers/net/bnx2x/bnx2x_rxtx.c b/drivers/net/bnx2x/bnx2x_rxtx.c
index adf03092..a9b8e565 100644
--- a/drivers/net/bnx2x/bnx2x_rxtx.c
+++ b/drivers/net/bnx2x/bnx2x_rxtx.c
@@ -78,7 +78,7 @@ bnx2x_dev_rx_queue_setup(struct rte_eth_dev *dev,
 	rxq = rte_zmalloc_socket("ethdev RX queue", sizeof(struct bnx2x_rx_queue),
 				 RTE_CACHE_LINE_SIZE, socket_id);
 	if (NULL == rxq) {
-		PMD_INIT_LOG(ERR, "rte_zmalloc for rxq failed!");
+		PMD_DRV_LOG(ERR, sc, "rte_zmalloc for rxq failed!");
 		return -ENOMEM;
 	}
 	rxq->sc = sc;
@@ -94,7 +94,7 @@ bnx2x_dev_rx_queue_setup(struct rte_eth_dev *dev,
 	sc->rx_ring_size = USABLE_RX_BD(rxq);
 	rxq->nb_cq_pages = RCQ_BD_PAGES(rxq);
 
-	PMD_INIT_LOG(DEBUG, "fp[%02d] req_bd=%u, usable_bd=%lu, "
+	PMD_DRV_LOG(DEBUG, sc, "fp[%02d] req_bd=%u, usable_bd=%lu, "
 		       "total_bd=%lu, rx_pages=%u, cq_pages=%u",
 		       queue_idx, nb_desc, (unsigned long)USABLE_RX_BD(rxq),
 		       (unsigned long)TOTAL_RX_BD(rxq), rxq->nb_rx_pages,
@@ -276,7 +276,7 @@ bnx2x_dev_tx_queue_setup(struct rte_eth_dev *dev,
 	txq->tx_free_thresh = min(txq->tx_free_thresh,
 				  txq->nb_tx_desc - BDS_PER_TX_PKT);
 
-	PMD_INIT_LOG(DEBUG, "fp[%02d] req_bd=%u, thresh=%u, usable_bd=%lu, "
+	PMD_DRV_LOG(DEBUG, sc, "fp[%02d] req_bd=%u, thresh=%u, usable_bd=%lu, "
 		     "total_bd=%lu, tx_pages=%u",
 		     queue_idx, nb_desc, txq->tx_free_thresh,
 		     (unsigned long)USABLE_TX_BD(txq),
@@ -302,7 +302,7 @@ bnx2x_dev_tx_queue_setup(struct rte_eth_dev *dev,
 		return -ENOMEM;
 	}
 
-	/* PMD_DRV_LOG(DEBUG, "sw_ring=%p hw_ring=%p dma_addr=0x%"PRIx64,
+	/* PMD_DRV_LOG(DEBUG, sc, "sw_ring=%p hw_ring=%p dma_addr=0x%"PRIx64,
 	   txq->sw_ring, txq->tx_ring, txq->tx_ring_phys_addr); */
 
 	/* Link TX pages */
@@ -311,7 +311,9 @@ bnx2x_dev_tx_queue_setup(struct rte_eth_dev *dev,
 		busaddr = txq->tx_ring_phys_addr + BNX2X_PAGE_SIZE * (i % txq->nb_tx_pages);
 		tx_n_bd->addr_hi = rte_cpu_to_le_32(U64_HI(busaddr));
 		tx_n_bd->addr_lo = rte_cpu_to_le_32(U64_LO(busaddr));
-		/* PMD_DRV_LOG(DEBUG, "link tx page %lu", (TOTAL_TX_BD_PER_PAGE * i - 1)); */
+		/* PMD_DRV_LOG(DEBUG, sc, "link tx page %lu",
+		 *          (TOTAL_TX_BD_PER_PAGE * i - 1));
+		 */
 	}
 
 	txq->queue_id = queue_idx;
@@ -461,9 +463,10 @@ bnx2x_dev_rx_init(struct rte_eth_dev *dev)
 void
 bnx2x_dev_clear_queues(struct rte_eth_dev *dev)
 {
+	struct bnx2x_softc *sc = dev->data->dev_private;
 	uint8_t i;
 
-	PMD_INIT_FUNC_TRACE();
+	PMD_INIT_FUNC_TRACE(sc);
 
 	for (i = 0; i < dev->data->nb_tx_queues; i++) {
 		struct bnx2x_tx_queue *txq = dev->data->tx_queues[i];
diff --git a/drivers/net/bnx2x/bnx2x_stats.c b/drivers/net/bnx2x/bnx2x_stats.c
index c489cbee..2a068acb 100644
--- a/drivers/net/bnx2x/bnx2x_stats.c
+++ b/drivers/net/bnx2x/bnx2x_stats.c
@@ -84,7 +84,7 @@ bnx2x_storm_stats_post(struct bnx2x_softc *sc)
 		sc->fw_stats_req->hdr.drv_stats_counter =
 			htole16(sc->stats_counter++);
 
-		PMD_DEBUG_PERIODIC_LOG(DEBUG,
+		PMD_DEBUG_PERIODIC_LOG(DEBUG, sc,
 				"sending statistics ramrod %d",
 				le16toh(sc->fw_stats_req->hdr.drv_stats_counter));
 
@@ -156,7 +156,7 @@ bnx2x_stats_comp(struct bnx2x_softc *sc)
 
 	while (*stats_comp != DMAE_COMP_VAL) {
 		if (!cnt) {
-			PMD_DRV_LOG(ERR, "Timeout waiting for stats finished");
+			PMD_DRV_LOG(ERR, sc, "Timeout waiting for stats finished");
 			break;
 		}
 
@@ -191,7 +191,7 @@ bnx2x_stats_pmf_update(struct bnx2x_softc *sc)
 	}
 	/* sanity */
 	if (!sc->port.pmf || !sc->port.port_stx) {
-		PMD_DRV_LOG(ERR, "BUG!");
+		PMD_DRV_LOG(ERR, sc, "BUG!");
 		return;
 	}
 
@@ -241,7 +241,7 @@ bnx2x_port_stats_init(struct bnx2x_softc *sc)
 
     /* sanity */
     if (!sc->link_vars.link_up || !sc->port.pmf) {
-	PMD_DRV_LOG(ERR, "BUG!");
+	PMD_DRV_LOG(ERR, sc, "BUG!");
 	return;
     }
 
@@ -465,7 +465,7 @@ bnx2x_func_stats_init(struct bnx2x_softc *sc)
 
     /* sanity */
     if (!sc->func_stx) {
-	PMD_DRV_LOG(ERR, "BUG!");
+	PMD_DRV_LOG(ERR, sc, "BUG!");
 	return;
     }
 
@@ -799,12 +799,12 @@ bnx2x_hw_stats_update(struct bnx2x_softc *sc)
 	break;
 
     case ELINK_MAC_TYPE_NONE: /* unreached */
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 	      "stats updated by DMAE but no MAC active");
 	return -1;
 
     default: /* unreached */
-	PMD_DRV_LOG(ERR, "stats update failed, unknown MAC type");
+	PMD_DRV_LOG(ERR, sc, "stats update failed, unknown MAC type");
     }
 
     ADD_EXTEND_64(pstats->brb_drop_hi, pstats->brb_drop_lo,
@@ -839,7 +839,7 @@ bnx2x_hw_stats_update(struct bnx2x_softc *sc)
 	nig_timer_max = SHMEM_RD(sc, port_mb[SC_PORT(sc)].stat_nig_timer);
 	if (nig_timer_max != estats->nig_timer_max) {
 	    estats->nig_timer_max = nig_timer_max;
-	    PMD_DRV_LOG(ERR, "invalid NIG timer max (%u)",
+	    PMD_DRV_LOG(ERR, sc, "invalid NIG timer max (%u)",
 		  estats->nig_timer_max);
 	}
     }
@@ -861,7 +861,7 @@ bnx2x_storm_stats_validate_counters(struct bnx2x_softc *sc)
 
     /* are storm stats valid? */
     if (le16toh(counters->xstats_counter) != cur_stats_counter) {
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 	      "stats not updated by xstorm, "
 	      "counter 0x%x != stats_counter 0x%x",
 	      le16toh(counters->xstats_counter), sc->stats_counter);
@@ -869,7 +869,7 @@ bnx2x_storm_stats_validate_counters(struct bnx2x_softc *sc)
     }
 
     if (le16toh(counters->ustats_counter) != cur_stats_counter) {
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 	      "stats not updated by ustorm, "
 	      "counter 0x%x != stats_counter 0x%x",
 	      le16toh(counters->ustats_counter), sc->stats_counter);
@@ -877,7 +877,7 @@ bnx2x_storm_stats_validate_counters(struct bnx2x_softc *sc)
     }
 
     if (le16toh(counters->cstats_counter) != cur_stats_counter) {
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 	      "stats not updated by cstorm, "
 	      "counter 0x%x != stats_counter 0x%x",
 	      le16toh(counters->cstats_counter), sc->stats_counter);
@@ -885,7 +885,7 @@ bnx2x_storm_stats_validate_counters(struct bnx2x_softc *sc)
     }
 
     if (le16toh(counters->tstats_counter) != cur_stats_counter) {
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 	      "stats not updated by tstorm, "
 	      "counter 0x%x != stats_counter 0x%x",
 	      le16toh(counters->tstats_counter), sc->stats_counter);
@@ -931,12 +931,13 @@ bnx2x_storm_stats_update(struct bnx2x_softc *sc)
 
 		uint32_t diff;
 
-		/* PMD_DRV_LOG(DEBUG,
+		/* PMD_DRV_LOG(DEBUG, sc,
 				"queue[%d]: ucast_sent 0x%x bcast_sent 0x%x mcast_sent 0x%x",
 				i, xclient->ucast_pkts_sent, xclient->bcast_pkts_sent,
 				xclient->mcast_pkts_sent);
 
-		PMD_DRV_LOG(DEBUG, "---------------"); */
+		PMD_DRV_LOG(DEBUG, sc, "---------------");
+		 */
 
 		UPDATE_QSTAT(tclient->rcv_bcast_bytes,
 				total_broadcast_bytes_received);
@@ -1290,7 +1291,7 @@ void bnx2x_stats_handle(struct bnx2x_softc *sc, enum bnx2x_stats_event event)
 	bnx2x_stats_stm[state][event].action(sc);
 
 	if (event != STATS_EVENT_UPDATE) {
-		PMD_DRV_LOG(DEBUG,
+		PMD_DRV_LOG(DEBUG, sc,
 				"state %d -> event %d -> state %d",
 				state, event, sc->stats_state);
 	}
@@ -1304,7 +1305,7 @@ bnx2x_port_stats_base_init(struct bnx2x_softc *sc)
 
     /* sanity */
     if (!sc->port.pmf || !sc->port.port_stx) {
-	PMD_DRV_LOG(ERR, "BUG!");
+	PMD_DRV_LOG(ERR, sc, "BUG!");
 	return;
     }
 
@@ -1476,7 +1477,7 @@ bnx2x_stats_init(struct bnx2x_softc *sc)
 		sc->func_stx = 0;
 	}
 
-	PMD_DRV_LOG(DEBUG, "port_stx 0x%x func_stx 0x%x",
+	PMD_DRV_LOG(DEBUG, sc, "port_stx 0x%x func_stx 0x%x",
 			sc->port.port_stx, sc->func_stx);
 
 	/* pmf should retrieve port statistics from SP on a non-init*/
diff --git a/drivers/net/bnx2x/bnx2x_vfpf.c b/drivers/net/bnx2x/bnx2x_vfpf.c
index 0ca0df87..e58e9af8 100644
--- a/drivers/net/bnx2x/bnx2x_vfpf.c
+++ b/drivers/net/bnx2x/bnx2x_vfpf.c
@@ -40,12 +40,12 @@ bnx2x_check_bull(struct bnx2x_softc *sc)
 			if (bull->crc == bnx2x_vf_crc(bull))
 				break;
 
-			PMD_DRV_LOG(ERR, "bad crc on bulletin board. contained %x computed %x",
+			PMD_DRV_LOG(ERR, sc, "bad crc on bulletin board. contained %x computed %x",
 					bull->crc, bnx2x_vf_crc(bull));
 			++tries;
 		}
 		if (tries == BNX2X_VF_BULLETIN_TRIES) {
-			PMD_DRV_LOG(ERR, "pf to vf bulletin board crc was wrong %d consecutive times. Aborting",
+			PMD_DRV_LOG(ERR, sc, "pf to vf bulletin board crc was wrong %d consecutive times. Aborting",
 					tries);
 			return FALSE;
 		}
@@ -85,7 +85,7 @@ bnx2x_vf_prep(struct bnx2x_softc *sc, struct vf_first_tlv *first_tlv,
 
 	rte_spinlock_lock(&sc->vf2pf_lock);
 
-	PMD_DRV_LOG(DEBUG, "Preparing %d tlv for sending", type);
+	PMD_DRV_LOG(DEBUG, sc, "Preparing %d tlv for sending", type);
 
 	memset(mbox, 0, sizeof(struct bnx2x_vf_mbx_msg));
 
@@ -100,7 +100,7 @@ static void
 bnx2x_vf_finalize(struct bnx2x_softc *sc,
 		  __rte_unused struct vf_first_tlv *first_tlv)
 {
-	PMD_DRV_LOG(DEBUG, "done sending [%d] tlv over vf pf channel",
+	PMD_DRV_LOG(DEBUG, sc, "done sending [%d] tlv over vf pf channel",
 		    first_tlv->tl.type);
 
 	rte_spinlock_unlock(&sc->vf2pf_lock);
@@ -119,14 +119,14 @@ bnx2x_do_req4pf(struct bnx2x_softc *sc, phys_addr_t phys_addr)
 	uint8_t i;
 
 	if (*status) {
-		PMD_DRV_LOG(ERR, "status should be zero before message"
+		PMD_DRV_LOG(ERR, sc, "status should be zero before message"
 				 " to pf was sent");
 		return -EINVAL;
 	}
 
 	bnx2x_check_bull(sc);
 	if (sc->old_bulletin.valid_bitmap & (1 << CHANNEL_DOWN)) {
-		PMD_DRV_LOG(ERR, "channel is down. Aborting message sending");
+		PMD_DRV_LOG(ERR, sc, "channel is down. Aborting message sending");
 		return -EINVAL;
 	}
 
@@ -146,11 +146,11 @@ bnx2x_do_req4pf(struct bnx2x_softc *sc, phys_addr_t phys_addr)
 	}
 
 	if (!*status) {
-		PMD_DRV_LOG(ERR, "Response from PF timed out");
+		PMD_DRV_LOG(ERR, sc, "Response from PF timed out");
 		return -EAGAIN;
 	}
 
-	PMD_DRV_LOG(DEBUG, "Response from PF was received");
+	PMD_DRV_LOG(DEBUG, sc, "Response from PF was received");
 	return 0;
 }
 
@@ -198,7 +198,7 @@ int bnx2x_loop_obtain_resources(struct bnx2x_softc *sc)
 	int rc;
 
 	do {
-		PMD_DRV_LOG(DEBUG, "trying to get resources");
+		PMD_DRV_LOG(DEBUG, sc, "trying to get resources");
 
 		rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
 		if (rc)
@@ -210,11 +210,11 @@ int bnx2x_loop_obtain_resources(struct bnx2x_softc *sc)
 
 		/* check PF to request acceptance */
 		if (sc_resp->status == BNX2X_VF_STATUS_SUCCESS) {
-			PMD_DRV_LOG(DEBUG, "resources obtained successfully");
+			PMD_DRV_LOG(DEBUG, sc, "resources obtained successfully");
 			res_obtained = true;
 		} else if (sc_resp->status == BNX2X_VF_STATUS_NO_RESOURCES &&
 			   tries < BNX2X_VF_OBTAIN_MAX_TRIES) {
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 			   "PF cannot allocate requested amount of resources");
 
 			res_query = &sc->vf2pf_mbox->query[0].acquire.res_query;
@@ -230,7 +230,7 @@ int bnx2x_loop_obtain_resources(struct bnx2x_softc *sc)
 
 			memset(&sc->vf2pf_mbox->resp, 0, sizeof(union resp_tlvs));
 		} else {
-			PMD_DRV_LOG(ERR, "Failed to get the requested "
+			PMD_DRV_LOG(ERR, sc, "Failed to get the requested "
 					 "amount of resources: %d.",
 					 sc_resp->status);
 			return -EINVAL;
@@ -299,7 +299,7 @@ int bnx2x_vf_get_resources(struct bnx2x_softc *sc, uint8_t tx_count, uint8_t rx_
 	sc->doorbell_size = sc_resp.db_size;
 	sc->flags |= BNX2X_NO_WOL_FLAG | BNX2X_NO_ISCSI_OOO_FLAG | BNX2X_NO_ISCSI_FLAG | BNX2X_NO_FCOE_FLAG;
 
-	PMD_DRV_LOG(DEBUG, "status block count = %d, base status block = %x",
+	PMD_DRV_LOG(DEBUG, sc, "status block count = %d, base status block = %x",
 		sc->igu_sb_cnt, sc->igu_base_sb);
 	strncpy(sc->fw_ver, sc_resp.fw_ver, sizeof(sc->fw_ver));
 
@@ -336,7 +336,7 @@ bnx2x_vf_close(struct bnx2x_softc *sc)
 
 		rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
 		if (rc || reply->status != BNX2X_VF_STATUS_SUCCESS)
-			PMD_DRV_LOG(ERR, "Failed to release VF");
+			PMD_DRV_LOG(ERR, sc, "Failed to release VF");
 
 		bnx2x_vf_finalize(sc, &query->first_tlv);
 	}
@@ -370,12 +370,12 @@ bnx2x_vf_init(struct bnx2x_softc *sc)
 	if (rc)
 		goto out;
 	if (reply->status != BNX2X_VF_STATUS_SUCCESS) {
-		PMD_DRV_LOG(ERR, "Failed to init VF");
+		PMD_DRV_LOG(ERR, sc, "Failed to init VF");
 		rc = -EINVAL;
 		goto out;
 	}
 
-	PMD_DRV_LOG(DEBUG, "VF was initialized");
+	PMD_DRV_LOG(DEBUG, sc, "VF was initialized");
 out:
 	bnx2x_vf_finalize(sc, &query->first_tlv);
 	return rc;
@@ -406,7 +406,7 @@ bnx2x_vf_unload(struct bnx2x_softc *sc)
 
 			rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
 			if (rc || reply->status != BNX2X_VF_STATUS_SUCCESS)
-				PMD_DRV_LOG(ERR,
+				PMD_DRV_LOG(ERR, sc,
 					    "Bad reply for vf_q %d teardown", i);
 
 			bnx2x_vf_finalize(sc, &query_op->first_tlv);
@@ -426,7 +426,7 @@ bnx2x_vf_unload(struct bnx2x_softc *sc)
 
 		rc = bnx2x_do_req4pf(sc, sc->vf2pf_mbox_mapping.paddr);
 		if (rc || reply->status != BNX2X_VF_STATUS_SUCCESS)
-			PMD_DRV_LOG(ERR,
+			PMD_DRV_LOG(ERR, sc,
 				    "Bad reply from PF for close message");
 
 		bnx2x_vf_finalize(sc, &query->first_tlv);
@@ -453,7 +453,7 @@ bnx2x_vf_rx_q_prep(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp,
 
 	rxq = sc->rx_queues[fp->index];
 	if (!rxq) {
-		PMD_DRV_LOG(ERR, "RX queue %d is NULL", fp->index);
+		PMD_DRV_LOG(ERR, sc, "RX queue %d is NULL", fp->index);
 		return;
 	}
 
@@ -477,7 +477,7 @@ bnx2x_vf_tx_q_prep(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp,
 
 	txq = sc->tx_queues[fp->index];
 	if (!txq) {
-		PMD_DRV_LOG(ERR, "TX queue %d is NULL", fp->index);
+		PMD_DRV_LOG(ERR, sc, "TX queue %d is NULL", fp->index);
 		return;
 	}
 
@@ -514,7 +514,7 @@ bnx2x_vf_setup_queue(struct bnx2x_softc *sc, struct bnx2x_fastpath *fp, int lead
 	if (rc)
 		goto out;
 	if (reply->status != BNX2X_VF_STATUS_SUCCESS) {
-		PMD_DRV_LOG(ERR, "Failed to setup VF queue[%d]",
+		PMD_DRV_LOG(ERR, sc, "Failed to setup VF queue[%d]",
 				 fp->index);
 		rc = -EINVAL;
 	}
@@ -569,7 +569,7 @@ bnx2x_vf_set_mac(struct bnx2x_softc *sc, int set)
 	}
 
 	if (BNX2X_VF_STATUS_SUCCESS != reply->status) {
-		PMD_DRV_LOG(ERR, "Bad reply from PF for SET MAC message: %d",
+		PMD_DRV_LOG(ERR, sc, "Bad reply from PF for SET MAC message: %d",
 				reply->status);
 		rc = -EINVAL;
 	}
@@ -611,7 +611,7 @@ bnx2x_vf_config_rss(struct bnx2x_softc *sc,
 		goto out;
 
 	if (reply->status != BNX2X_VF_STATUS_SUCCESS) {
-		PMD_DRV_LOG(ERR, "Failed to configure RSS");
+		PMD_DRV_LOG(ERR, sc, "Failed to configure RSS");
 		rc = -EINVAL;
 	}
 out:
@@ -655,7 +655,7 @@ bnx2x_vf_set_rx_mode(struct bnx2x_softc *sc)
 		query->rx_mask |= VFPF_RX_MASK_ACCEPT_BROADCAST;
 		break;
 	default:
-		PMD_DRV_LOG(ERR, "BAD rx mode (%d)", sc->rx_mode);
+		PMD_DRV_LOG(ERR, sc, "BAD rx mode (%d)", sc->rx_mode);
 		rc = -EINVAL;
 		goto out;
 	}
@@ -669,7 +669,7 @@ bnx2x_vf_set_rx_mode(struct bnx2x_softc *sc)
 		goto out;
 
 	if (reply->status != BNX2X_VF_STATUS_SUCCESS) {
-		PMD_DRV_LOG(ERR, "Failed to set RX mode");
+		PMD_DRV_LOG(ERR, sc, "Failed to set RX mode");
 		rc = -EINVAL;
 	}
 
diff --git a/drivers/net/bnx2x/ecore_init.h b/drivers/net/bnx2x/ecore_init.h
index d25e2803..7a96be7b 100644
--- a/drivers/net/bnx2x/ecore_init.h
+++ b/drivers/net/bnx2x/ecore_init.h
@@ -743,7 +743,7 @@ static inline void ecore_disable_blocks_parity(struct bnx2x_softc *sc)
 		if (dis_mask) {
 			REG_WR(sc, ecore_blocks_parity_data[i].mask_addr,
 			       dis_mask);
-			ECORE_MSG("Setting parity mask "
+			ECORE_MSG(sc, "Setting parity mask "
 						 "for %s to\t\t0x%x",
 				    ecore_blocks_parity_data[i].name, dis_mask);
 		}
@@ -778,7 +778,7 @@ static inline void ecore_clear_blocks_parity(struct bnx2x_softc *sc)
 			reg_val = REG_RD(sc, ecore_blocks_parity_data[i].
 					 sts_clr_addr);
 			if (reg_val & reg_mask)
-				ECORE_MSG("Parity errors in %s: 0x%x",
+				ECORE_MSG(sc, "Parity errors in %s: 0x%x",
 					   ecore_blocks_parity_data[i].name,
 					   reg_val & reg_mask);
 		}
@@ -787,7 +787,7 @@ static inline void ecore_clear_blocks_parity(struct bnx2x_softc *sc)
 	/* Check if there were parity attentions in MCP */
 	reg_val = REG_RD(sc, MISC_REG_AEU_AFTER_INVERT_4_MCP);
 	if (reg_val & mcp_aeu_bits)
-		ECORE_MSG("Parity error in MCP: 0x%x",
+		ECORE_MSG(sc, "Parity error in MCP: 0x%x",
 			   reg_val & mcp_aeu_bits);
 
 	/* Clear parity attentions in MCP:
diff --git a/drivers/net/bnx2x/ecore_init_ops.h b/drivers/net/bnx2x/ecore_init_ops.h
index b6f98324..474185bd 100644
--- a/drivers/net/bnx2x/ecore_init_ops.h
+++ b/drivers/net/bnx2x/ecore_init_ops.h
@@ -426,20 +426,20 @@ static void ecore_init_pxp_arb(struct bnx2x_softc *sc, int r_order,
 	uint32_t val, i;
 
 	if (r_order > MAX_RD_ORD) {
-		ECORE_MSG("read order of %d  order adjusted to %d",
+		ECORE_MSG(sc, "read order of %d  order adjusted to %d",
 			   r_order, MAX_RD_ORD);
 		r_order = MAX_RD_ORD;
 	}
 	if (w_order > MAX_WR_ORD) {
-		ECORE_MSG("write order of %d  order adjusted to %d",
+		ECORE_MSG(sc, "write order of %d  order adjusted to %d",
 			   w_order, MAX_WR_ORD);
 		w_order = MAX_WR_ORD;
 	}
 	if (CHIP_REV_IS_FPGA(sc)) {
-		ECORE_MSG("write order adjusted to 1 for FPGA");
+		ECORE_MSG(sc, "write order adjusted to 1 for FPGA");
 		w_order = 0;
 	}
-	ECORE_MSG("read order %d  write order %d", r_order, w_order);
+	ECORE_MSG(sc, "read order %d  write order %d", r_order, w_order);
 
 	for (i = 0; i < NUM_RD_Q-1; i++) {
 		REG_WR(sc, read_arb_addr[i].l, read_arb_data[i][r_order].l);
diff --git a/drivers/net/bnx2x/ecore_reg.h b/drivers/net/bnx2x/ecore_reg.h
index d8203b45..33cea4eb 100644
--- a/drivers/net/bnx2x/ecore_reg.h
+++ b/drivers/net/bnx2x/ecore_reg.h
@@ -1969,6 +1969,7 @@
 #define HW_LOCK_MAX_RESOURCE_VALUE		 31
 #define HW_LOCK_RESOURCE_DRV_FLAGS		 10
 #define HW_LOCK_RESOURCE_GPIO			 1
+#define HW_LOCK_RESOURCE_MDIO			 0
 #define HW_LOCK_RESOURCE_NVRAM			 12
 #define HW_LOCK_RESOURCE_PORT0_ATT_MASK		 3
 #define HW_LOCK_RESOURCE_RECOVERY_LEADER_0	 8
diff --git a/drivers/net/bnx2x/ecore_sp.c b/drivers/net/bnx2x/ecore_sp.c
index e6fecd88..07376d85 100644
--- a/drivers/net/bnx2x/ecore_sp.c
+++ b/drivers/net/bnx2x/ecore_sp.c
@@ -55,14 +55,14 @@ ecore_exe_queue_init(struct bnx2x_softc *sc __rte_unused,
 	o->execute = exec;
 	o->get = get;
 
-	ECORE_MSG("Setup the execution queue with the chunk length of %d",
+	ECORE_MSG(sc, "Setup the execution queue with the chunk length of %d",
 		  exe_len);
 }
 
 static void ecore_exe_queue_free_elem(struct bnx2x_softc *sc __rte_unused,
 				      struct ecore_exeq_elem *elem)
 {
-	ECORE_MSG("Deleting an exe_queue element");
+	ECORE_MSG(sc, "Deleting an exe_queue element");
 	ECORE_FREE(sc, elem, sizeof(*elem));
 }
 
@@ -108,7 +108,7 @@ static int ecore_exe_queue_add(struct bnx2x_softc *sc,
 		/* Check if this request is ok */
 		rc = o->validate(sc, o->owner, elem);
 		if (rc) {
-			ECORE_MSG("Preamble failed: %d", rc);
+			ECORE_MSG(sc, "Preamble failed: %d", rc);
 			goto free_and_exit;
 		}
 	}
@@ -178,8 +178,8 @@ static int ecore_exe_queue_step(struct bnx2x_softc *sc,
 	 */
 	if (!ECORE_LIST_IS_EMPTY(&o->pending_comp)) {
 		if (ECORE_TEST_BIT(RAMROD_DRV_CLR_ONLY, ramrod_flags)) {
-			ECORE_MSG
-			    ("RAMROD_DRV_CLR_ONLY requested: resetting a pending_comp list");
+			ECORE_MSG(sc,
+				  "RAMROD_DRV_CLR_ONLY requested: resetting a pending_comp list");
 			__ecore_exe_queue_reset_pending(sc, o);
 		} else {
 			return ECORE_PENDING;
@@ -242,7 +242,7 @@ static struct ecore_exeq_elem *ecore_exe_queue_alloc_elem(struct
 							  bnx2x_softc *sc
 							  __rte_unused)
 {
-	ECORE_MSG("Allocating a new exe_queue element");
+	ECORE_MSG(sc, "Allocating a new exe_queue element");
 	return ECORE_ZALLOC(sizeof(struct ecore_exeq_elem), GFP_ATOMIC, sc);
 }
 
@@ -292,14 +292,14 @@ static int ecore_state_wait(struct bnx2x_softc *sc, int state,
 	if (CHIP_REV_IS_EMUL(sc))
 		cnt *= 20;
 
-	ECORE_MSG("waiting for state to become %d", state);
+	ECORE_MSG(sc, "waiting for state to become %d", state);
 
 	ECORE_MIGHT_SLEEP();
 	while (cnt--) {
 		bnx2x_intr_legacy(sc, 1);
 		if (!ECORE_TEST_BIT(state, pstate)) {
 #ifdef ECORE_STOP_ON_ERROR
-			ECORE_MSG("exit  (cnt %d)", 5000 - cnt);
+			ECORE_MSG(sc, "exit  (cnt %d)", 5000 - cnt);
 #endif
 			return ECORE_SUCCESS;
 		}
@@ -311,7 +311,7 @@ static int ecore_state_wait(struct bnx2x_softc *sc, int state,
 	}
 
 	/* timeout! */
-	PMD_DRV_LOG(ERR, "timeout waiting for state %d", state);
+	PMD_DRV_LOG(ERR, sc, "timeout waiting for state %d", state);
 #ifdef ECORE_STOP_ON_ERROR
 	ecore_panic();
 #endif
@@ -372,11 +372,11 @@ static int __ecore_vlan_mac_h_write_trylock(struct bnx2x_softc *sc __rte_unused,
 					    struct ecore_vlan_mac_obj *o)
 {
 	if (o->head_reader) {
-		ECORE_MSG("vlan_mac_lock writer - There are readers; Busy");
+		ECORE_MSG(sc, "vlan_mac_lock writer - There are readers; Busy");
 		return ECORE_BUSY;
 	}
 
-	ECORE_MSG("vlan_mac_lock writer - Taken");
+	ECORE_MSG(sc, "vlan_mac_lock writer - Taken");
 	return ECORE_SUCCESS;
 }
 
@@ -396,13 +396,13 @@ static void __ecore_vlan_mac_h_exec_pending(struct bnx2x_softc *sc,
 	int rc;
 	unsigned long ramrod_flags = o->saved_ramrod_flags;
 
-	ECORE_MSG("vlan_mac_lock execute pending command with ramrod flags %lu",
+	ECORE_MSG(sc, "vlan_mac_lock execute pending command with ramrod flags %lu",
 		  ramrod_flags);
 	o->head_exe_request = FALSE;
 	o->saved_ramrod_flags = 0;
 	rc = ecore_exe_queue_step(sc, &o->exe_queue, &ramrod_flags);
 	if (rc != ECORE_SUCCESS) {
-		PMD_DRV_LOG(ERR,
+		PMD_DRV_LOG(ERR, sc,
 			    "execution of pending commands failed with rc %d",
 			    rc);
 #ifdef ECORE_STOP_ON_ERROR
@@ -427,7 +427,7 @@ static void __ecore_vlan_mac_h_pend(struct bnx2x_softc *sc __rte_unused,
 {
 	o->head_exe_request = TRUE;
 	o->saved_ramrod_flags = ramrod_flags;
-	ECORE_MSG("Placing pending execution with ramrod flags %lu",
+	ECORE_MSG(sc, "Placing pending execution with ramrod flags %lu",
 		  ramrod_flags);
 }
 
@@ -448,8 +448,8 @@ static void __ecore_vlan_mac_h_write_unlock(struct bnx2x_softc *sc,
 	 * executed. If so, execute again. [Ad infinitum]
 	 */
 	while (o->head_exe_request) {
-		ECORE_MSG
-		    ("vlan_mac_lock - writer release encountered a pending request");
+		ECORE_MSG(sc,
+			  "vlan_mac_lock - writer release encountered a pending request");
 		__ecore_vlan_mac_h_exec_pending(sc, o);
 	}
 }
@@ -485,7 +485,8 @@ static int __ecore_vlan_mac_h_read_lock(struct bnx2x_softc *sc __rte_unused,
 {
 	/* If we got here, we're holding lock --> no WRITER exists */
 	o->head_reader++;
-	ECORE_MSG("vlan_mac_lock - locked reader - number %d", o->head_reader);
+	ECORE_MSG(sc,
+		  "vlan_mac_lock - locked reader - number %d", o->head_reader);
 
 	return ECORE_SUCCESS;
 }
@@ -524,14 +525,14 @@ static void __ecore_vlan_mac_h_read_unlock(struct bnx2x_softc *sc,
 					   struct ecore_vlan_mac_obj *o)
 {
 	if (!o->head_reader) {
-		PMD_DRV_LOG(ERR,
+		PMD_DRV_LOG(ERR, sc,
 			    "Need to release vlan mac reader lock, but lock isn't taken");
 #ifdef ECORE_STOP_ON_ERROR
 		ecore_panic();
 #endif
 	} else {
 		o->head_reader--;
-		PMD_DRV_LOG(INFO,
+		PMD_DRV_LOG(INFO, sc,
 			    "vlan_mac_lock - decreased readers to %d",
 			    o->head_reader);
 	}
@@ -540,7 +541,7 @@ static void __ecore_vlan_mac_h_read_unlock(struct bnx2x_softc *sc,
 	 * was last - if so we need to execute the command.
 	 */
 	if (!o->head_reader && o->head_exe_request) {
-		PMD_DRV_LOG(INFO,
+		PMD_DRV_LOG(INFO, sc,
 			    "vlan_mac_lock - reader release encountered a pending request");
 
 		/* Writer release will do the trick */
@@ -583,10 +584,10 @@ static int ecore_get_n_elements(struct bnx2x_softc *sc,
 	uint8_t *next = base;
 	int counter = 0, read_lock;
 
-	ECORE_MSG("get_n_elements - taking vlan_mac_lock (reader)");
+	ECORE_MSG(sc, "get_n_elements - taking vlan_mac_lock (reader)");
 	read_lock = ecore_vlan_mac_h_read_lock(sc, o);
 	if (read_lock != ECORE_SUCCESS)
-		PMD_DRV_LOG(ERR,
+		PMD_DRV_LOG(ERR, sc,
 			    "get_n_elements failed to get vlan mac reader lock; Access without lock");
 
 	/* traverse list */
@@ -595,15 +596,15 @@ static int ecore_get_n_elements(struct bnx2x_softc *sc,
 		if (counter < n) {
 			ECORE_MEMCPY(next, &pos->u, size);
 			counter++;
-			ECORE_MSG
-			    ("copied element number %d to address %p element was:",
+			    ECORE_MSG
+			    (sc, "copied element number %d to address %p element was:",
 			     counter, next);
 			next += stride + size;
 		}
 	}
 
 	if (read_lock == ECORE_SUCCESS) {
-		ECORE_MSG("get_n_elements - releasing vlan_mac_lock (reader)");
+		ECORE_MSG(sc, "get_n_elements - releasing vlan_mac_lock (reader)");
 		ecore_vlan_mac_h_read_unlock(sc, o);
 	}
 
@@ -617,7 +618,7 @@ static int ecore_check_mac_add(struct bnx2x_softc *sc __rte_unused,
 {
 	struct ecore_vlan_mac_registry_elem *pos;
 
-	ECORE_MSG("Checking MAC %02x:%02x:%02x:%02x:%02x:%02x for ADD command",
+	ECORE_MSG(sc, "Checking MAC %02x:%02x:%02x:%02x:%02x:%02x for ADD command",
 		  data->mac.mac[0], data->mac.mac[1], data->mac.mac[2],
 		  data->mac.mac[3], data->mac.mac[4], data->mac.mac[5]);
 
@@ -646,7 +647,7 @@ static struct ecore_vlan_mac_registry_elem *ecore_check_mac_del(struct bnx2x_sof
 {
 	struct ecore_vlan_mac_registry_elem *pos;
 
-	ECORE_MSG("Checking MAC %02x:%02x:%02x:%02x:%02x:%02x for DEL command",
+	ECORE_MSG(sc, "Checking MAC %02x:%02x:%02x:%02x:%02x:%02x for DEL command",
 		  data->mac.mac[0], data->mac.mac[1], data->mac.mac[2],
 		  data->mac.mac[3], data->mac.mac[4], data->mac.mac[5]);
 
@@ -724,7 +725,7 @@ static void ecore_set_mac_in_nig(struct bnx2x_softc *sc,
 	if (index > ECORE_LLH_CAM_MAX_PF_LINE)
 		return;
 
-	ECORE_MSG("Going to %s LLH configuration at entry %d",
+	ECORE_MSG(sc, "Going to %s LLH configuration at entry %d",
 		  (add ? "ADD" : "DELETE"), index);
 
 	if (add) {
@@ -840,7 +841,7 @@ static void ecore_set_one_mac_e2(struct bnx2x_softc *sc,
 	ecore_vlan_mac_set_cmd_hdr_e2(o, add, CLASSIFY_RULE_OPCODE_MAC,
 				      &rule_entry->mac.header);
 
-	ECORE_MSG("About to %s MAC %02x:%02x:%02x:%02x:%02x:%02x for Queue %d",
+	ECORE_MSG(sc, "About to %s MAC %02x:%02x:%02x:%02x:%02x:%02x for Queue %d",
 		  (add ? "add" : "delete"), mac[0], mac[1], mac[2], mac[3],
 		  mac[4], mac[5], raw->cl_id);
 
@@ -945,7 +946,7 @@ static void ecore_vlan_mac_set_rdata_e1x(struct bnx2x_softc *sc
 	ecore_vlan_mac_set_cfg_entry_e1x(o, add, opcode, mac, vlan_id,
 					 cfg_entry);
 
-	ECORE_MSG("%s MAC %02x:%02x:%02x:%02x:%02x:%02x CLID %d CAM offset %d",
+	ECORE_MSG(sc, "%s MAC %02x:%02x:%02x:%02x:%02x:%02x CLID %d CAM offset %d",
 		  (add ? "setting" : "clearing"),
 		  mac[0], mac[1], mac[2], mac[3], mac[4], mac[5],
 		  o->raw.cl_id, cam_offset);
@@ -1090,8 +1091,8 @@ static int ecore_validate_vlan_mac_add(struct bnx2x_softc *sc,
 	/* Check the registry */
 	rc = o->check_add(sc, o, &elem->cmd_data.vlan_mac.u);
 	if (rc) {
-		ECORE_MSG
-		    ("ADD command is not allowed considering current registry state.");
+		ECORE_MSG(sc,
+			  "ADD command is not allowed considering current registry state.");
 		return rc;
 	}
 
@@ -1099,7 +1100,7 @@ static int ecore_validate_vlan_mac_add(struct bnx2x_softc *sc,
 	 * MAC/VLAN/VLAN-MAC. Return an error if there is.
 	 */
 	if (exeq->get(exeq, elem)) {
-		ECORE_MSG("There is a pending ADD command already");
+		ECORE_MSG(sc, "There is a pending ADD command already");
 		return ECORE_EXISTS;
 	}
 
@@ -1138,8 +1139,8 @@ static int ecore_validate_vlan_mac_del(struct bnx2x_softc *sc,
 	 */
 	pos = o->check_del(sc, o, &elem->cmd_data.vlan_mac.u);
 	if (!pos) {
-		ECORE_MSG
-		    ("DEL command is not allowed considering current registry state");
+		ECORE_MSG(sc,
+			  "DEL command is not allowed considering current registry state");
 		return ECORE_EXISTS;
 	}
 
@@ -1151,13 +1152,13 @@ static int ecore_validate_vlan_mac_del(struct bnx2x_softc *sc,
 	/* Check for MOVE commands */
 	query_elem.cmd_data.vlan_mac.cmd = ECORE_VLAN_MAC_MOVE;
 	if (exeq->get(exeq, &query_elem)) {
-		PMD_DRV_LOG(ERR, "There is a pending MOVE command already");
+		PMD_DRV_LOG(ERR, sc, "There is a pending MOVE command already");
 		return ECORE_INVAL;
 	}
 
 	/* Check for DEL commands */
 	if (exeq->get(exeq, elem)) {
-		ECORE_MSG("There is a pending DEL command already");
+		ECORE_MSG(sc, "There is a pending DEL command already");
 		return ECORE_EXISTS;
 	}
 
@@ -1165,7 +1166,7 @@ static int ecore_validate_vlan_mac_del(struct bnx2x_softc *sc,
 	if (!(ECORE_TEST_BIT(ECORE_DONT_CONSUME_CAM_CREDIT,
 			     &elem->cmd_data.vlan_mac.vlan_mac_flags) ||
 	      o->put_credit(o))) {
-		PMD_DRV_LOG(ERR, "Failed to return a credit");
+		PMD_DRV_LOG(ERR, sc, "Failed to return a credit");
 		return ECORE_INVAL;
 	}
 
@@ -1198,8 +1199,8 @@ static int ecore_validate_vlan_mac_move(struct bnx2x_softc *sc,
 	 * state.
 	 */
 	if (!src_o->check_move(sc, src_o, dest_o, &elem->cmd_data.vlan_mac.u)) {
-		ECORE_MSG
-		    ("MOVE command is not allowed considering current registry state");
+		ECORE_MSG(sc,
+			  "MOVE command is not allowed considering current registry state");
 		return ECORE_INVAL;
 	}
 
@@ -1212,21 +1213,21 @@ static int ecore_validate_vlan_mac_move(struct bnx2x_softc *sc,
 	/* Check DEL on source */
 	query_elem.cmd_data.vlan_mac.cmd = ECORE_VLAN_MAC_DEL;
 	if (src_exeq->get(src_exeq, &query_elem)) {
-		PMD_DRV_LOG(ERR,
+		PMD_DRV_LOG(ERR, sc,
 			    "There is a pending DEL command on the source queue already");
 		return ECORE_INVAL;
 	}
 
 	/* Check MOVE on source */
 	if (src_exeq->get(src_exeq, elem)) {
-		ECORE_MSG("There is a pending MOVE command already");
+		ECORE_MSG(sc, "There is a pending MOVE command already");
 		return ECORE_EXISTS;
 	}
 
 	/* Check ADD on destination */
 	query_elem.cmd_data.vlan_mac.cmd = ECORE_VLAN_MAC_ADD;
 	if (dest_exeq->get(dest_exeq, &query_elem)) {
-		PMD_DRV_LOG(ERR,
+		PMD_DRV_LOG(ERR, sc,
 			    "There is a pending ADD command on the destination queue already");
 		return ECORE_INVAL;
 	}
@@ -1331,7 +1332,7 @@ static int __ecore_vlan_mac_execute_step(struct bnx2x_softc *sc,
 
 	ECORE_SPIN_LOCK_BH(&o->exe_queue.lock);
 
-	ECORE_MSG("vlan_mac_execute_step - trying to take writer lock");
+	ECORE_MSG(sc, "vlan_mac_execute_step - trying to take writer lock");
 	rc = __ecore_vlan_mac_h_write_trylock(sc, o);
 
 	if (rc != ECORE_SUCCESS) {
@@ -1428,17 +1429,17 @@ static int ecore_optimize_vlan_mac(struct bnx2x_softc *sc,
 				    &pos->cmd_data.vlan_mac.vlan_mac_flags)) {
 			if ((query.cmd_data.vlan_mac.cmd ==
 			     ECORE_VLAN_MAC_ADD) && !o->put_credit(o)) {
-				PMD_DRV_LOG(ERR,
+				PMD_DRV_LOG(ERR, sc,
 					    "Failed to return the credit for the optimized ADD command");
 				return ECORE_INVAL;
 			} else if (!o->get_credit(o)) {	/* VLAN_MAC_DEL */
-				PMD_DRV_LOG(ERR,
+				PMD_DRV_LOG(ERR, sc,
 					    "Failed to recover the credit from the optimized DEL command");
 				return ECORE_INVAL;
 			}
 		}
 
-		ECORE_MSG("Optimizing %s command",
+		ECORE_MSG(sc, "Optimizing %s command",
 			  (elem->cmd_data.vlan_mac.cmd == ECORE_VLAN_MAC_ADD) ?
 			  "ADD" : "DEL");
 
@@ -1488,7 +1489,7 @@ static int ecore_vlan_mac_get_registry_elem(struct bnx2x_softc *sc,
 			return ECORE_INVAL;
 		}
 
-		ECORE_MSG("Got cam offset %d", reg_elem->cam_offset);
+		ECORE_MSG(sc, "Got cam offset %d", reg_elem->cam_offset);
 
 		/* Set a VLAN-MAC data */
 		ECORE_MEMCPY(&reg_elem->u, &elem->cmd_data.vlan_mac.u,
@@ -1697,8 +1698,8 @@ int ecore_config_vlan_mac(struct bnx2x_softc *sc,
 		rc = ECORE_PENDING;
 
 	if (ECORE_TEST_BIT(RAMROD_DRV_CLR_ONLY, ramrod_flags)) {
-		ECORE_MSG
-		    ("RAMROD_DRV_CLR_ONLY requested: clearing a pending bit.");
+		ECORE_MSG(sc,
+			  "RAMROD_DRV_CLR_ONLY requested: clearing a pending bit.");
 		raw->clear_pending(raw);
 	}
 
@@ -1777,7 +1778,7 @@ static int ecore_vlan_mac_del_all(struct bnx2x_softc *sc,
 		    *vlan_mac_flags) {
 			rc = exeq->remove(sc, exeq->owner, exeq_pos);
 			if (rc) {
-				PMD_DRV_LOG(ERR, "Failed to remove command");
+				PMD_DRV_LOG(ERR, sc, "Failed to remove command");
 				ECORE_SPIN_UNLOCK_BH(&exeq->lock);
 				return rc;
 			}
@@ -1802,7 +1803,7 @@ static int ecore_vlan_mac_del_all(struct bnx2x_softc *sc,
 	ECORE_CLEAR_BIT_NA(RAMROD_EXEC, &p.ramrod_flags);
 	ECORE_CLEAR_BIT_NA(RAMROD_CONT, &p.ramrod_flags);
 
-	ECORE_MSG("vlan_mac_del_all -- taking vlan_mac_lock (reader)");
+	ECORE_MSG(sc, "vlan_mac_del_all -- taking vlan_mac_lock (reader)");
 	read_lock = ecore_vlan_mac_h_read_lock(sc, o);
 	if (read_lock != ECORE_SUCCESS)
 		return read_lock;
@@ -1814,7 +1815,7 @@ static int ecore_vlan_mac_del_all(struct bnx2x_softc *sc,
 			ECORE_MEMCPY(&p.user_req.u, &pos->u, sizeof(pos->u));
 			rc = ecore_config_vlan_mac(sc, &p);
 			if (rc < 0) {
-				PMD_DRV_LOG(ERR,
+				PMD_DRV_LOG(ERR, sc,
 					    "Failed to add a new DEL command");
 				ecore_vlan_mac_h_read_unlock(sc, o);
 				return rc;
@@ -1822,7 +1823,7 @@ static int ecore_vlan_mac_del_all(struct bnx2x_softc *sc,
 		}
 	}
 
-	ECORE_MSG("vlan_mac_del_all -- releasing vlan_mac_lock (reader)");
+	ECORE_MSG(sc, "vlan_mac_del_all -- releasing vlan_mac_lock (reader)");
 	ecore_vlan_mac_h_read_unlock(sc, o);
 
 	p.ramrod_flags = *ramrod_flags;
@@ -2009,7 +2010,7 @@ static int ecore_set_rx_mode_e1x(struct bnx2x_softc *sc,
 	    mac_filters->unmatched_unicast | mask :
 	    mac_filters->unmatched_unicast & ~mask;
 
-	ECORE_MSG("drop_ucast 0x%xdrop_mcast 0x%x accp_ucast 0x%x"
+	ECORE_MSG(sc, "drop_ucast 0x%xdrop_mcast 0x%x accp_ucast 0x%x"
 		  "accp_mcast 0x%xaccp_bcast 0x%x",
 		  mac_filters->ucast_drop_all, mac_filters->mcast_drop_all,
 		  mac_filters->ucast_accept_all, mac_filters->mcast_accept_all,
@@ -2155,8 +2156,8 @@ static int ecore_set_rx_mode_e2(struct bnx2x_softc *sc,
 	 */
 	ecore_rx_mode_set_rdata_hdr_e2(p->cid, &data->header, rule_idx);
 
-	ECORE_MSG
-	    ("About to configure %d rules, rx_accept_flags 0x%lx, tx_accept_flags 0x%lx",
+	    ECORE_MSG
+	    (sc, "About to configure %d rules, rx_accept_flags 0x%lx, tx_accept_flags 0x%lx",
 	     data->header.rule_cnt, p->rx_accept_flags, p->tx_accept_flags);
 
 	/* No need for an explicit memory barrier here as long we would
@@ -2209,7 +2210,7 @@ int ecore_config_rx_mode(struct bnx2x_softc *sc,
 				return rc;
 		}
 	} else {
-		ECORE_MSG("ERROR: config_rx_mode is NULL");
+		ECORE_MSG(sc, "ERROR: config_rx_mode is NULL");
 		return -1;
 	}
 
@@ -2290,7 +2291,7 @@ static int ecore_mcast_enqueue_cmd(struct bnx2x_softc *sc __rte_unused,
 	if (!new_cmd)
 		return ECORE_NOMEM;
 
-	ECORE_MSG("About to enqueue a new %d command. macs_list_len=%d",
+	ECORE_MSG(sc, "About to enqueue a new %d command. macs_list_len=%d",
 		  cmd, macs_list_len);
 
 	ECORE_LIST_INIT(&new_cmd->data.macs_head);
@@ -2326,7 +2327,7 @@ static int ecore_mcast_enqueue_cmd(struct bnx2x_softc *sc __rte_unused,
 
 	default:
 		ECORE_FREE(sc, new_cmd, total_sz);
-		PMD_DRV_LOG(ERR, "Unknown command: %d", cmd);
+		PMD_DRV_LOG(ERR, sc, "Unknown command: %d", cmd);
 		return ECORE_INVAL;
 	}
 
@@ -2438,11 +2439,11 @@ static void ecore_mcast_set_one_rule_e2(struct bnx2x_softc *sc __rte_unused,
 		break;
 
 	default:
-		PMD_DRV_LOG(ERR, "Unknown command: %d", cmd);
+		PMD_DRV_LOG(ERR, sc, "Unknown command: %d", cmd);
 		return;
 	}
 
-	ECORE_MSG("%s bin %d",
+	ECORE_MSG(sc, "%s bin %d",
 		  ((rx_tx_add_flag & ETH_MULTICAST_RULES_CMD_IS_ADD) ?
 		   "Setting" : "Clearing"), bin);
 
@@ -2477,7 +2478,7 @@ static int ecore_mcast_handle_restore_cmd_e2(struct bnx2x_softc *sc,
 
 		cnt++;
 
-		ECORE_MSG("About to configure a bin %d", cur_bin);
+		ECORE_MSG(sc, "About to configure a bin %d", cur_bin);
 
 		/* Break if we reached the maximum number
 		 * of rules.
@@ -2509,8 +2510,8 @@ static void ecore_mcast_hdl_pending_add_e2(struct bnx2x_softc *sc,
 
 		cnt++;
 
-		ECORE_MSG
-		    ("About to configure %02x:%02x:%02x:%02x:%02x:%02x mcast MAC",
+		    ECORE_MSG
+		    (sc, "About to configure %02x:%02x:%02x:%02x:%02x:%02x mcast MAC",
 		     pmac_pos->mac[0], pmac_pos->mac[1], pmac_pos->mac[2],
 		     pmac_pos->mac[3], pmac_pos->mac[4], pmac_pos->mac[5]);
 
@@ -2545,7 +2546,7 @@ static void ecore_mcast_hdl_pending_del_e2(struct bnx2x_softc *sc,
 
 		cmd_pos->data.macs_num--;
 
-		ECORE_MSG("Deleting MAC. %d left,cnt is %d",
+		ECORE_MSG(sc, "Deleting MAC. %d left,cnt is %d",
 			  cmd_pos->data.macs_num, cnt);
 
 		/* Break if we reached the maximum
@@ -2604,7 +2605,8 @@ static int ecore_mcast_handle_pending_cmds_e2(struct bnx2x_softc *sc, struct
 			break;
 
 		default:
-			PMD_DRV_LOG(ERR, "Unknown command: %d", cmd_pos->type);
+			PMD_DRV_LOG(ERR, sc,
+				    "Unknown command: %d", cmd_pos->type);
 			return ECORE_INVAL;
 		}
 
@@ -2641,8 +2643,8 @@ static void ecore_mcast_hdl_add(struct bnx2x_softc *sc,
 
 		cnt++;
 
-		ECORE_MSG
-		    ("About to configure %02x:%02x:%02x:%02x:%02x:%02x mcast MAC",
+		    ECORE_MSG
+		    (sc, "About to configure %02x:%02x:%02x:%02x:%02x:%02x mcast MAC",
 		     mlist_pos->mac[0], mlist_pos->mac[1], mlist_pos->mac[2],
 		     mlist_pos->mac[3], mlist_pos->mac[4], mlist_pos->mac[5]);
 	}
@@ -2662,7 +2664,8 @@ static void ecore_mcast_hdl_del(struct bnx2x_softc *sc,
 
 		cnt++;
 
-		ECORE_MSG("Deleting MAC. %d left", p->mcast_list_len - i - 1);
+		ECORE_MSG(sc,
+			  "Deleting MAC. %d left", p->mcast_list_len - i - 1);
 	}
 
 	*line_idx = cnt;
@@ -2688,7 +2691,7 @@ static int ecore_mcast_handle_current_cmd(struct bnx2x_softc *sc, struct
 	struct ecore_mcast_obj *o = p->mcast_obj;
 	int cnt = start_cnt;
 
-	ECORE_MSG("p->mcast_list_len=%d", p->mcast_list_len);
+	ECORE_MSG(sc, "p->mcast_list_len=%d", p->mcast_list_len);
 
 	switch (cmd) {
 	case ECORE_MCAST_CMD_ADD:
@@ -2704,7 +2707,7 @@ static int ecore_mcast_handle_current_cmd(struct bnx2x_softc *sc, struct
 		break;
 
 	default:
-		PMD_DRV_LOG(ERR, "Unknown command: %d", cmd);
+		PMD_DRV_LOG(ERR, sc, "Unknown command: %d", cmd);
 		return ECORE_INVAL;
 	}
 
@@ -2749,7 +2752,7 @@ static int ecore_mcast_validate_e2(__rte_unused struct bnx2x_softc *sc,
 		break;
 
 	default:
-		PMD_DRV_LOG(ERR, "Unknown command: %d", cmd);
+		PMD_DRV_LOG(ERR, sc, "Unknown command: %d", cmd);
 		return ECORE_INVAL;
 	}
 
@@ -2935,8 +2938,8 @@ static void ecore_mcast_hdl_add_e1h(struct bnx2x_softc *sc __rte_unused,
 		bit = ecore_mcast_bin_from_mac(mlist_pos->mac);
 		ECORE_57711_SET_MC_FILTER(mc_filter, bit);
 
-		ECORE_MSG
-		    ("About to configure %02x:%02x:%02x:%02x:%02x:%02x mcast MAC, bin %d",
+		    ECORE_MSG
+		    (sc, "About to configure %02x:%02x:%02x:%02x:%02x:%02x mcast MAC, bin %d",
 		     mlist_pos->mac[0], mlist_pos->mac[1], mlist_pos->mac[2],
 		     mlist_pos->mac[3], mlist_pos->mac[4], mlist_pos->mac[5],
 		     bit);
@@ -2956,7 +2959,7 @@ static void ecore_mcast_hdl_restore_e1h(struct bnx2x_softc *sc
 	for (bit = ecore_mcast_get_next_bin(o, 0);
 	     bit >= 0; bit = ecore_mcast_get_next_bin(o, bit + 1)) {
 		ECORE_57711_SET_MC_FILTER(mc_filter, bit);
-		ECORE_MSG("About to set bin %d", bit);
+		ECORE_MSG(sc, "About to set bin %d", bit);
 	}
 }
 
@@ -2987,7 +2990,7 @@ static int ecore_mcast_setup_e1h(struct bnx2x_softc *sc,
 			break;
 
 		case ECORE_MCAST_CMD_DEL:
-			ECORE_MSG("Invalidating multicast MACs configuration");
+			ECORE_MSG(sc, "Invalidating multicast MACs configuration");
 
 			/* clear the registry */
 			ECORE_MEMSET(o->registry.aprox_match.vec, 0,
@@ -2999,7 +3002,7 @@ static int ecore_mcast_setup_e1h(struct bnx2x_softc *sc,
 			break;
 
 		default:
-			PMD_DRV_LOG(ERR, "Unknown command: %d", cmd);
+			PMD_DRV_LOG(ERR, sc, "Unknown command: %d", cmd);
 			return ECORE_INVAL;
 		}
 
@@ -3050,8 +3053,8 @@ int ecore_config_mcast(struct bnx2x_softc *sc,
 	if ((!p->mcast_list_len) && (!o->check_sched(o)))
 		return ECORE_SUCCESS;
 
-	ECORE_MSG
-	    ("o->total_pending_num=%d p->mcast_list_len=%d o->max_cmd_len=%d",
+	    ECORE_MSG
+	    (sc, "o->total_pending_num=%d p->mcast_list_len=%d o->max_cmd_len=%d",
 	     o->total_pending_num, p->mcast_list_len, o->max_cmd_len);
 
 	/* Enqueue the current command to the pending list if we can't complete
@@ -3480,7 +3483,7 @@ static int ecore_setup_rss(struct bnx2x_softc *sc,
 
 	ECORE_MEMSET(data, 0, sizeof(*data));
 
-	ECORE_MSG("Configuring RSS");
+	ECORE_MSG(sc, "Configuring RSS");
 
 	/* Set an echo field */
 	data->echo = ECORE_CPU_TO_LE32((r->cid & ECORE_SWCID_MASK) |
@@ -3494,7 +3497,7 @@ static int ecore_setup_rss(struct bnx2x_softc *sc,
 
 	data->rss_mode = rss_mode;
 
-	ECORE_MSG("rss_mode=%d", rss_mode);
+	ECORE_MSG(sc, "rss_mode=%d", rss_mode);
 
 	/* RSS capabilities */
 	if (ECORE_TEST_BIT(ECORE_RSS_IPV4, &p->rss_flags))
@@ -3534,7 +3537,7 @@ static int ecore_setup_rss(struct bnx2x_softc *sc,
 	/* RSS engine ID */
 	data->rss_engine_id = o->engine_id;
 
-	ECORE_MSG("rss_engine_id=%d", data->rss_engine_id);
+	ECORE_MSG(sc, "rss_engine_id=%d", data->rss_engine_id);
 
 	/* Indirection table */
 	ECORE_MEMCPY(data->indirection_table, p->ind_table,
@@ -3629,15 +3632,15 @@ int ecore_queue_state_change(struct bnx2x_softc *sc,
 	/* Check that the requested transition is legal */
 	rc = o->check_transition(sc, o, params);
 	if (rc) {
-		PMD_DRV_LOG(ERR, "check transition returned an error. rc %d",
+		PMD_DRV_LOG(ERR, sc, "check transition returned an error. rc %d",
 			    rc);
 		return ECORE_INVAL;
 	}
 
 	/* Set "pending" bit */
-	ECORE_MSG("pending bit was=%lx", o->pending);
+	ECORE_MSG(sc, "pending bit was=%lx", o->pending);
 	pending_bit = o->set_pending(o, params);
-	ECORE_MSG("pending bit now=%lx", o->pending);
+	ECORE_MSG(sc, "pending bit now=%lx", o->pending);
 
 	/* Don't send a command if only driver cleanup was requested */
 	if (ECORE_TEST_BIT(RAMROD_DRV_CLR_ONLY, &params->ramrod_flags))
@@ -3704,7 +3707,7 @@ static int ecore_queue_comp_cmd(struct bnx2x_softc *sc __rte_unused,
 	unsigned long cur_pending = o->pending;
 
 	if (!ECORE_TEST_AND_CLEAR_BIT(cmd, &cur_pending)) {
-		PMD_DRV_LOG(ERR,
+		PMD_DRV_LOG(ERR, sc,
 			    "Bad MC reply %d for queue %d in state %d pending 0x%lx, next_state %d",
 			    cmd, o->cids[ECORE_PRIMARY_CID_INDEX], o->state,
 			    cur_pending, o->next_state);
@@ -3715,15 +3718,15 @@ static int ecore_queue_comp_cmd(struct bnx2x_softc *sc __rte_unused,
 		/* >= because tx only must always be smaller than cos since the
 		 * primary connection supports COS 0
 		 */
-		PMD_DRV_LOG(ERR,
+		PMD_DRV_LOG(ERR, sc,
 			    "illegal value for next tx_only: %d. max cos was %d",
 			    o->next_tx_only, o->max_cos);
 
-	ECORE_MSG("Completing command %d for queue %d, setting state to %d",
+	ECORE_MSG(sc, "Completing command %d for queue %d, setting state to %d",
 		  cmd, o->cids[ECORE_PRIMARY_CID_INDEX], o->next_state);
 
 	if (o->next_tx_only)	/* print num tx-only if any exist */
-		ECORE_MSG("primary cid %d: num tx-only cons %d",
+		ECORE_MSG(sc, "primary cid %d: num tx-only cons %d",
 			  o->cids[ECORE_PRIMARY_CID_INDEX], o->next_tx_only);
 
 	o->state = o->next_state;
@@ -3784,7 +3787,7 @@ static void ecore_q_fill_init_general_data(struct bnx2x_softc *sc __rte_unused,
 	    ECORE_TEST_BIT(ECORE_Q_FLG_FCOE, flags) ?
 	    LLFC_TRAFFIC_TYPE_FCOE : LLFC_TRAFFIC_TYPE_NW;
 
-	ECORE_MSG("flags: active %d, cos %d, stats en %d",
+	ECORE_MSG(sc, "flags: active %d, cos %d, stats en %d",
 		  gen_data->activate_flg, gen_data->cos,
 		  gen_data->statistics_en_flg);
 }
@@ -3925,7 +3928,7 @@ static void ecore_q_fill_setup_tx_only(struct bnx2x_softc *sc, struct ecore_queu
 	ecore_q_fill_init_tx_data(&cmd_params->params.tx_only.txq_params,
 				  &data->tx, &cmd_params->params.tx_only.flags);
 
-	ECORE_MSG("cid %d, tx bd page lo %x hi %x",
+	ECORE_MSG(sc, "cid %d, tx bd page lo %x hi %x",
 		  cmd_params->q_obj->cids[0],
 		  data->tx.tx_bd_page_base.lo, data->tx.tx_bd_page_base.hi);
 }
@@ -3975,9 +3978,9 @@ static int ecore_q_init(struct bnx2x_softc *sc,
 
 	/* Set CDU context validation values */
 	for (cos = 0; cos < o->max_cos; cos++) {
-		ECORE_MSG("setting context validation. cid %d, cos %d",
+		ECORE_MSG(sc, "setting context validation. cid %d, cos %d",
 			  o->cids[cos], cos);
-		ECORE_MSG("context pointer %p", init->cxts[cos]);
+		ECORE_MSG(sc, "context pointer %p", init->cxts[cos]);
 		ECORE_SET_CTX_VALIDATION(sc, init->cxts[cos], o->cids[cos]);
 	}
 
@@ -4061,15 +4064,15 @@ static int ecore_q_send_setup_tx_only(struct bnx2x_softc *sc, struct ecore_queue
 
 	if (ECORE_TEST_BIT(ECORE_Q_TYPE_FWD, &o->type))
 		ramrod = RAMROD_CMD_ID_ETH_FORWARD_SETUP;
-	ECORE_MSG("sending forward tx-only ramrod");
+	ECORE_MSG(sc, "sending forward tx-only ramrod");
 
 	if (cid_index >= o->max_cos) {
-		PMD_DRV_LOG(ERR, "queue[%d]: cid_index (%d) is out of range",
+		PMD_DRV_LOG(ERR, sc, "queue[%d]: cid_index (%d) is out of range",
 			    o->cl_id, cid_index);
 		return ECORE_INVAL;
 	}
 
-	ECORE_MSG("parameters received: cos: %d sp-id: %d",
+	ECORE_MSG(sc, "parameters received: cos: %d sp-id: %d",
 		  tx_only_params->gen_params.cos,
 		  tx_only_params->gen_params.spcl_id);
 
@@ -4079,8 +4082,8 @@ static int ecore_q_send_setup_tx_only(struct bnx2x_softc *sc, struct ecore_queue
 	/* Fill the ramrod data */
 	ecore_q_fill_setup_tx_only(sc, params, rdata);
 
-	ECORE_MSG
-	    ("sending tx-only ramrod: cid %d, client-id %d, sp-client id %d, cos %d",
+	    ECORE_MSG
+	    (sc, "sending tx-only ramrod: cid %d, client-id %d, sp-client id %d, cos %d",
 	     o->cids[cid_index], rdata->general.client_id,
 	     rdata->general.sp_client_id, rdata->general.cos);
 
@@ -4175,7 +4178,7 @@ static int ecore_q_send_update(struct bnx2x_softc *sc,
 	uint8_t cid_index = update_params->cid_index;
 
 	if (cid_index >= o->max_cos) {
-		PMD_DRV_LOG(ERR, "queue[%d]: cid_index (%d) is out of range",
+		PMD_DRV_LOG(ERR, sc, "queue[%d]: cid_index (%d) is out of range",
 			    o->cl_id, cid_index);
 		return ECORE_INVAL;
 	}
@@ -4269,7 +4272,7 @@ static int ecore_q_send_cfc_del(struct bnx2x_softc *sc,
 	uint8_t cid_idx = params->params.cfc_del.cid_index;
 
 	if (cid_idx >= o->max_cos) {
-		PMD_DRV_LOG(ERR, "queue[%d]: cid_index (%d) is out of range",
+		PMD_DRV_LOG(ERR, sc, "queue[%d]: cid_index (%d) is out of range",
 			    o->cl_id, cid_idx);
 		return ECORE_INVAL;
 	}
@@ -4285,7 +4288,7 @@ static int ecore_q_send_terminate(struct bnx2x_softc *sc, struct ecore_queue_sta
 	uint8_t cid_index = params->params.terminate.cid_index;
 
 	if (cid_index >= o->max_cos) {
-		PMD_DRV_LOG(ERR, "queue[%d]: cid_index (%d) is out of range",
+		PMD_DRV_LOG(ERR, sc, "queue[%d]: cid_index (%d) is out of range",
 			    o->cl_id, cid_index);
 		return ECORE_INVAL;
 	}
@@ -4329,7 +4332,7 @@ static int ecore_queue_send_cmd_cmn(struct bnx2x_softc *sc, struct ecore_queue_s
 	case ECORE_Q_CMD_EMPTY:
 		return ecore_q_send_empty(sc, params);
 	default:
-		PMD_DRV_LOG(ERR, "Unknown command: %d", params->cmd);
+		PMD_DRV_LOG(ERR, sc, "Unknown command: %d", params->cmd);
 		return ECORE_INVAL;
 	}
 }
@@ -4352,7 +4355,7 @@ static int ecore_queue_send_cmd_e1x(struct bnx2x_softc *sc,
 	case ECORE_Q_CMD_EMPTY:
 		return ecore_queue_send_cmd_cmn(sc, params);
 	default:
-		PMD_DRV_LOG(ERR, "Unknown command: %d", params->cmd);
+		PMD_DRV_LOG(ERR, sc, "Unknown command: %d", params->cmd);
 		return ECORE_INVAL;
 	}
 }
@@ -4375,7 +4378,7 @@ static int ecore_queue_send_cmd_e2(struct bnx2x_softc *sc,
 	case ECORE_Q_CMD_EMPTY:
 		return ecore_queue_send_cmd_cmn(sc, params);
 	default:
-		PMD_DRV_LOG(ERR, "Unknown command: %d", params->cmd);
+		PMD_DRV_LOG(ERR, sc, "Unknown command: %d", params->cmd);
 		return ECORE_INVAL;
 	}
 }
@@ -4418,7 +4421,7 @@ static int ecore_queue_chk_transition(struct bnx2x_softc *sc __rte_unused,
 	 * the previous one.
 	 */
 	if (o->pending) {
-		PMD_DRV_LOG(ERR, "Blocking transition since pending was %lx",
+		PMD_DRV_LOG(ERR, sc, "Blocking transition since pending was %lx",
 			    o->pending);
 		return ECORE_BUSY;
 	}
@@ -4545,19 +4548,19 @@ static int ecore_queue_chk_transition(struct bnx2x_softc *sc __rte_unused,
 
 		break;
 	default:
-		PMD_DRV_LOG(ERR, "Illegal state: %d", state);
+		PMD_DRV_LOG(ERR, sc, "Illegal state: %d", state);
 	}
 
 	/* Transition is assured */
 	if (next_state != ECORE_Q_STATE_MAX) {
-		ECORE_MSG("Good state transition: %d(%d)->%d",
+		ECORE_MSG(sc, "Good state transition: %d(%d)->%d",
 			  state, cmd, next_state);
 		o->next_state = next_state;
 		o->next_tx_only = next_tx_only;
 		return ECORE_SUCCESS;
 	}
 
-	ECORE_MSG("Bad state transition request: %d %d", state, cmd);
+	ECORE_MSG(sc, "Bad state transition request: %d %d", state, cmd);
 
 	return ECORE_INVAL;
 }
@@ -4608,18 +4611,18 @@ static int ecore_queue_chk_fwd_transition(struct bnx2x_softc *sc __rte_unused,
 
 		break;
 	default:
-		PMD_DRV_LOG(ERR, "Illegal state: %d", state);
+		PMD_DRV_LOG(ERR, sc, "Illegal state: %d", state);
 	}
 
 	/* Transition is assured */
 	if (next_state != ECORE_Q_STATE_MAX) {
-		ECORE_MSG("Good state transition: %d(%d)->%d",
+		ECORE_MSG(sc, "Good state transition: %d(%d)->%d",
 			  state, cmd, next_state);
 		o->next_state = next_state;
 		return ECORE_SUCCESS;
 	}
 
-	ECORE_MSG("Bad state transition request: %d %d", state, cmd);
+	ECORE_MSG(sc, "Bad state transition request: %d %d", state, cmd);
 	return ECORE_INVAL;
 }
 
@@ -4699,14 +4702,14 @@ ecore_func_state_change_comp(struct bnx2x_softc *sc __rte_unused,
 	unsigned long cur_pending = o->pending;
 
 	if (!ECORE_TEST_AND_CLEAR_BIT(cmd, &cur_pending)) {
-		PMD_DRV_LOG(ERR,
+		PMD_DRV_LOG(ERR, sc,
 			    "Bad MC reply %d for func %d in state %d pending 0x%lx, next_state %d",
 			    cmd, ECORE_FUNC_ID(sc), o->state, cur_pending,
 			    o->next_state);
 		return ECORE_INVAL;
 	}
 
-	ECORE_MSG("Completing command %d for func %d, setting state to %d",
+	ECORE_MSG(sc, "Completing command %d for func %d, setting state to %d",
 		  cmd, ECORE_FUNC_ID(sc), o->next_state);
 
 	o->state = o->next_state;
@@ -4829,18 +4832,19 @@ static int ecore_func_chk_transition(struct bnx2x_softc *sc __rte_unused,
 
 		break;
 	default:
-		PMD_DRV_LOG(ERR, "Unknown state: %d", state);
+		PMD_DRV_LOG(ERR, sc, "Unknown state: %d", state);
 	}
 
 	/* Transition is assured */
 	if (next_state != ECORE_F_STATE_MAX) {
-		ECORE_MSG("Good function state transition: %d(%d)->%d",
+		ECORE_MSG(sc, "Good function state transition: %d(%d)->%d",
 			  state, cmd, next_state);
 		o->next_state = next_state;
 		return ECORE_SUCCESS;
 	}
 
-	ECORE_MSG("Bad function state transition request: %d %d", state, cmd);
+	ECORE_MSG(sc,
+		  "Bad function state transition request: %d %d", state, cmd);
 
 	return ECORE_INVAL;
 }
@@ -4930,13 +4934,13 @@ static int ecore_func_hw_init(struct bnx2x_softc *sc,
 	const struct ecore_func_sp_drv_ops *drv = o->drv;
 	int rc = 0;
 
-	ECORE_MSG("function %d  load_code %x",
+	ECORE_MSG(sc, "function %d  load_code %x",
 		  ECORE_ABS_FUNC_ID(sc), load_code);
 
 	/* Prepare FW */
 	rc = drv->init_fw(sc);
 	if (rc) {
-		PMD_DRV_LOG(ERR, "Error loading firmware");
+		PMD_DRV_LOG(ERR, sc, "Error loading firmware");
 		goto init_err;
 	}
 
@@ -4967,7 +4971,7 @@ static int ecore_func_hw_init(struct bnx2x_softc *sc,
 
 		break;
 	default:
-		PMD_DRV_LOG(ERR, "Unknown load_code (0x%x) from MCP",
+		PMD_DRV_LOG(ERR, sc, "Unknown load_code (0x%x) from MCP",
 			    load_code);
 		rc = ECORE_INVAL;
 	}
@@ -5043,7 +5047,7 @@ static int ecore_func_hw_reset(struct bnx2x_softc *sc,
 	struct ecore_func_sp_obj *o = params->f_obj;
 	const struct ecore_func_sp_drv_ops *drv = o->drv;
 
-	ECORE_MSG("function %d  reset_phase %x", ECORE_ABS_FUNC_ID(sc),
+	ECORE_MSG(sc, "function %d  reset_phase %x", ECORE_ABS_FUNC_ID(sc),
 		  reset_phase);
 
 	switch (reset_phase) {
@@ -5057,7 +5061,7 @@ static int ecore_func_hw_reset(struct bnx2x_softc *sc,
 		ecore_func_reset_func(sc, drv);
 		break;
 	default:
-		PMD_DRV_LOG(ERR, "Unknown reset_phase (0x%x) from MCP",
+		PMD_DRV_LOG(ERR, sc, "Unknown reset_phase (0x%x) from MCP",
 			    reset_phase);
 		break;
 	}
@@ -5148,7 +5152,7 @@ static int ecore_func_send_afex_update(struct bnx2x_softc *sc, struct ecore_func
 	 *  read and we will have to put a full memory barrier there
 	 *  (inside ecore_sp_post()).
 	 */
-	ECORE_MSG("afex: sending func_update vif_id 0x%x dvlan 0x%x prio 0x%x",
+	ECORE_MSG(sc, "afex: sending func_update vif_id 0x%x dvlan 0x%x prio 0x%x",
 		  rdata->vif_id,
 		  rdata->afex_default_vlan, rdata->allowed_priorities);
 
@@ -5186,8 +5190,8 @@ inline int ecore_func_send_afex_viflists(struct bnx2x_softc *sc,
 	 *  (inside ecore_sp_post()).
 	 */
 
-	ECORE_MSG
-	    ("afex: ramrod lists, cmd 0x%x index 0x%x func_bit_map 0x%x func_to_clr 0x%x",
+	    ECORE_MSG
+	    (sc, "afex: ramrod lists, cmd 0x%x index 0x%x func_bit_map 0x%x func_to_clr 0x%x",
 	     rdata->afex_vif_list_command, rdata->vif_list_index,
 	     rdata->func_bit_map, rdata->func_to_clear);
 
@@ -5258,7 +5262,7 @@ static int ecore_func_send_cmd(struct bnx2x_softc *sc,
 	case ECORE_F_CMD_SWITCH_UPDATE:
 		return ecore_func_send_switch_update(sc, params);
 	default:
-		PMD_DRV_LOG(ERR, "Unknown command: %d", params->cmd);
+		PMD_DRV_LOG(ERR, sc, "Unknown command: %d", params->cmd);
 		return ECORE_INVAL;
 	}
 }
@@ -5319,7 +5323,7 @@ int ecore_func_state_change(struct bnx2x_softc *sc,
 		}
 		if (rc == ECORE_BUSY) {
 			ECORE_MUTEX_UNLOCK(&o->one_pending_mutex);
-			PMD_DRV_LOG(ERR,
+			PMD_DRV_LOG(ERR, sc,
 				    "timeout waiting for previous ramrod completion");
 			return rc;
 		}
diff --git a/drivers/net/bnx2x/ecore_sp.h b/drivers/net/bnx2x/ecore_sp.h
index 9c1f55df..b8fad246 100644
--- a/drivers/net/bnx2x/ecore_sp.h
+++ b/drivers/net/bnx2x/ecore_sp.h
@@ -217,8 +217,8 @@ ECORE_CRC32_LE(uint32_t seed, uint8_t *mac, uint32_t len)
     } while (0)
 
 
-#define ECORE_MSG(m, ...) \
-	PMD_DRV_LOG(DEBUG, m, ##__VA_ARGS__)
+#define ECORE_MSG(sc, m, ...) \
+	PMD_DRV_LOG(DEBUG, sc, m, ##__VA_ARGS__)
 
 typedef struct _ecore_list_entry_t
 {
diff --git a/drivers/net/bnx2x/elink.c b/drivers/net/bnx2x/elink.c
index 89747104..95b4e759 100644
--- a/drivers/net/bnx2x/elink.c
+++ b/drivers/net/bnx2x/elink.c
@@ -944,7 +944,7 @@ static int elink_check_lfa(struct elink_params *params)
 	 * to verify DCC bit is cleared in any case!
 	 */
 	if (additional_config & NO_LFA_DUE_TO_DCC_MASK) {
-		PMD_DRV_LOG(DEBUG, "No LFA due to DCC flap after clp exit");
+		PMD_DRV_LOG(DEBUG, sc, "No LFA due to DCC flap after clp exit");
 		REG_WR(sc, params->lfa_base +
 		       offsetof(struct shmem_lfa, additional_config),
 		       additional_config & ~NO_LFA_DUE_TO_DCC_MASK);
@@ -985,7 +985,7 @@ static int elink_check_lfa(struct elink_params *params)
 			   offsetof(struct shmem_lfa, req_duplex));
 	req_val = params->req_duplex[0] | (params->req_duplex[1] << 16);
 	if ((saved_val & lfa_mask) != (req_val & lfa_mask)) {
-		PMD_DRV_LOG(INFO, "Duplex mismatch %x vs. %x",
+		PMD_DRV_LOG(INFO, sc, "Duplex mismatch %x vs. %x",
 			    (saved_val & lfa_mask), (req_val & lfa_mask));
 		return LFA_DUPLEX_MISMATCH;
 	}
@@ -994,7 +994,7 @@ static int elink_check_lfa(struct elink_params *params)
 			   offsetof(struct shmem_lfa, req_flow_ctrl));
 	req_val = params->req_flow_ctrl[0] | (params->req_flow_ctrl[1] << 16);
 	if ((saved_val & lfa_mask) != (req_val & lfa_mask)) {
-		PMD_DRV_LOG(DEBUG, "Flow control mismatch %x vs. %x",
+		PMD_DRV_LOG(DEBUG, sc, "Flow control mismatch %x vs. %x",
 			    (saved_val & lfa_mask), (req_val & lfa_mask));
 		return LFA_FLOW_CTRL_MISMATCH;
 	}
@@ -1003,7 +1003,7 @@ static int elink_check_lfa(struct elink_params *params)
 			   offsetof(struct shmem_lfa, req_line_speed));
 	req_val = params->req_line_speed[0] | (params->req_line_speed[1] << 16);
 	if ((saved_val & lfa_mask) != (req_val & lfa_mask)) {
-		PMD_DRV_LOG(DEBUG, "Link speed mismatch %x vs. %x",
+		PMD_DRV_LOG(DEBUG, sc, "Link speed mismatch %x vs. %x",
 			    (saved_val & lfa_mask), (req_val & lfa_mask));
 		return LFA_LINK_SPEED_MISMATCH;
 	}
@@ -1014,7 +1014,7 @@ static int elink_check_lfa(struct elink_params *params)
 						     speed_cap_mask[cfg_idx]));
 
 		if (cur_speed_cap_mask != params->speed_cap_mask[cfg_idx]) {
-			PMD_DRV_LOG(DEBUG, "Speed Cap mismatch %x vs. %x",
+			PMD_DRV_LOG(DEBUG, sc, "Speed Cap mismatch %x vs. %x",
 				    cur_speed_cap_mask,
 				    params->speed_cap_mask[cfg_idx]);
 			return LFA_SPEED_CAP_MISMATCH;
@@ -1027,7 +1027,7 @@ static int elink_check_lfa(struct elink_params *params)
 	    REQ_FC_AUTO_ADV_MASK;
 
 	if ((uint16_t) cur_req_fc_auto_adv != params->req_fc_auto_adv) {
-		PMD_DRV_LOG(DEBUG, "Flow Ctrl AN mismatch %x vs. %x",
+		PMD_DRV_LOG(DEBUG, sc, "Flow Ctrl AN mismatch %x vs. %x",
 			    cur_req_fc_auto_adv, params->req_fc_auto_adv);
 		return LFA_FLOW_CTRL_MISMATCH;
 	}
@@ -1040,7 +1040,8 @@ static int elink_check_lfa(struct elink_params *params)
 	     (params->eee_mode & ELINK_EEE_MODE_ENABLE_LPI)) ||
 	    ((eee_status & SHMEM_EEE_REQUESTED_BIT) ^
 	     (params->eee_mode & ELINK_EEE_MODE_ADV_LPI))) {
-		PMD_DRV_LOG(DEBUG, "EEE mismatch %x vs. %x", params->eee_mode,
+		PMD_DRV_LOG(DEBUG, sc,
+			    "EEE mismatch %x vs. %x", params->eee_mode,
 			    eee_status);
 		return LFA_EEE_MISMATCH;
 	}
@@ -1059,7 +1060,7 @@ static void elink_get_epio(struct bnx2x_softc *sc, uint32_t epio_pin,
 	*en = 0;
 	/* Sanity check */
 	if (epio_pin > 31) {
-		PMD_DRV_LOG(DEBUG, "Invalid EPIO pin %d to get", epio_pin);
+		PMD_DRV_LOG(DEBUG, sc, "Invalid EPIO pin %d to get", epio_pin);
 		return;
 	}
 
@@ -1077,10 +1078,10 @@ static void elink_set_epio(struct bnx2x_softc *sc, uint32_t epio_pin, uint32_t e
 
 	/* Sanity check */
 	if (epio_pin > 31) {
-		PMD_DRV_LOG(DEBUG, "Invalid EPIO pin %d to set", epio_pin);
+		PMD_DRV_LOG(DEBUG, sc, "Invalid EPIO pin %d to set", epio_pin);
 		return;
 	}
-	PMD_DRV_LOG(DEBUG, "Setting EPIO pin %d to %d", epio_pin, en);
+	PMD_DRV_LOG(DEBUG, sc, "Setting EPIO pin %d to %d", epio_pin, en);
 	epio_mask = 1 << epio_pin;
 	/* Set this EPIO to output */
 	gp_output = REG_RD(sc, MCP_REG_MCPR_GP_OUTPUTS);
@@ -1211,7 +1212,7 @@ static void elink_set_mdio_clk(struct bnx2x_softc *sc, uint32_t emac_base)
 	new_mode |= clc_cnt;
 	new_mode |= (EMAC_MDIO_MODE_CLAUSE_45);
 
-	PMD_DRV_LOG(DEBUG, "Changing emac_mode from 0x%x to 0x%x",
+	PMD_DRV_LOG(DEBUG, sc, "Changing emac_mode from 0x%x to 0x%x",
 		    cur_mode, new_mode);
 	REG_WR(sc, emac_base + EMAC_REG_EMAC_MDIO_MODE, new_mode);
 	DELAY(40);
@@ -1264,9 +1265,9 @@ static void elink_emac_init(struct elink_params *params)
 	timeout = 200;
 	do {
 		val = REG_RD(sc, emac_base + EMAC_REG_EMAC_MODE);
-		PMD_DRV_LOG(DEBUG, "EMAC reset reg is %u", val);
+		PMD_DRV_LOG(DEBUG, sc, "EMAC reset reg is %u", val);
 		if (!timeout) {
-			PMD_DRV_LOG(DEBUG, "EMAC timeout!");
+			PMD_DRV_LOG(DEBUG, sc, "EMAC timeout!");
 			return;
 		}
 		timeout--;
@@ -1329,7 +1330,7 @@ static void elink_umac_enable(struct elink_params *params,
 	REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
 	       (MISC_REGISTERS_RESET_REG_2_UMAC0 << params->port));
 
-	PMD_DRV_LOG(DEBUG, "enabling UMAC");
+	PMD_DRV_LOG(DEBUG, sc, "enabling UMAC");
 
 	/* This register opens the gate for the UMAC despite its name */
 	REG_WR(sc, NIG_REG_EGRESS_EMAC0_PORT + params->port * 4, 1);
@@ -1352,7 +1353,7 @@ static void elink_umac_enable(struct elink_params *params,
 		val |= (3 << 2);
 		break;
 	default:
-		PMD_DRV_LOG(DEBUG, "Invalid speed for UMAC %d",
+		PMD_DRV_LOG(DEBUG, sc, "Invalid speed for UMAC %d",
 			    vars->line_speed);
 		break;
 	}
@@ -1370,7 +1371,7 @@ static void elink_umac_enable(struct elink_params *params,
 
 	/* Configure UMAC for EEE */
 	if (vars->eee_status & SHMEM_EEE_ADV_STATUS_MASK) {
-		PMD_DRV_LOG(DEBUG, "configured UMAC for EEE");
+		PMD_DRV_LOG(DEBUG, sc, "configured UMAC for EEE");
 		REG_WR(sc, umac_base + UMAC_REG_UMAC_EEE_CTRL,
 		       UMAC_UMAC_EEE_CTRL_REG_EEE_EN);
 		REG_WR(sc, umac_base + UMAC_REG_EEE_WAKE_TIMER, 0x11);
@@ -1428,7 +1429,7 @@ static void elink_xmac_init(struct elink_params *params, uint32_t max_speed)
 	    is_port4mode &&
 	    (REG_RD(sc, MISC_REG_RESET_REG_2) &
 	     MISC_REGISTERS_RESET_REG_2_XMAC)) {
-		PMD_DRV_LOG(DEBUG, "XMAC already out of reset in 4-port mode");
+		PMD_DRV_LOG(DEBUG, sc, "XMAC already out of reset in 4-port mode");
 		return;
 	}
 
@@ -1440,7 +1441,7 @@ static void elink_xmac_init(struct elink_params *params, uint32_t max_speed)
 	REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_SET,
 	       MISC_REGISTERS_RESET_REG_2_XMAC);
 	if (is_port4mode) {
-		PMD_DRV_LOG(DEBUG, "Init XMAC to 2 ports x 10G per path");
+		PMD_DRV_LOG(DEBUG, sc, "Init XMAC to 2 ports x 10G per path");
 
 		/* Set the number of ports on the system side to up to 2 */
 		REG_WR(sc, MISC_REG_XMAC_CORE_PORT_MODE, 1);
@@ -1451,12 +1452,12 @@ static void elink_xmac_init(struct elink_params *params, uint32_t max_speed)
 		/* Set the number of ports on the system side to 1 */
 		REG_WR(sc, MISC_REG_XMAC_CORE_PORT_MODE, 0);
 		if (max_speed == ELINK_SPEED_10000) {
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "Init XMAC to 10G x 1 port per path");
 			/* Set the number of ports on the Warp Core to 10G */
 			REG_WR(sc, MISC_REG_XMAC_PHY_PORT_MODE, 3);
 		} else {
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "Init XMAC to 20G x 2 ports per path");
 			/* Set the number of ports on the Warp Core to 20G */
 			REG_WR(sc, MISC_REG_XMAC_PHY_PORT_MODE, 1);
@@ -1489,7 +1490,7 @@ static void elink_set_xmac_rxtx(struct elink_params *params, uint8_t en)
 		       (pfc_ctrl & ~(1 << 1)));
 		REG_WR(sc, xmac_base + XMAC_REG_PFC_CTRL_HI,
 		       (pfc_ctrl | (1 << 1)));
-		PMD_DRV_LOG(DEBUG, "Disable XMAC on port %x", port);
+		PMD_DRV_LOG(DEBUG, sc, "Disable XMAC on port %x", port);
 		val = REG_RD(sc, xmac_base + XMAC_REG_CTRL);
 		if (en)
 			val |= (XMAC_CTRL_REG_TX_EN | XMAC_CTRL_REG_RX_EN);
@@ -1504,7 +1505,7 @@ static elink_status_t elink_xmac_enable(struct elink_params *params,
 {
 	uint32_t val, xmac_base;
 	struct bnx2x_softc *sc = params->sc;
-	PMD_DRV_LOG(DEBUG, "enabling XMAC");
+	PMD_DRV_LOG(DEBUG, sc, "enabling XMAC");
 
 	xmac_base = (params->port) ? GRCBASE_XMAC1 : GRCBASE_XMAC0;
 
@@ -1541,7 +1542,7 @@ static elink_status_t elink_xmac_enable(struct elink_params *params,
 	elink_update_pfc_xmac(params, vars);
 
 	if (vars->eee_status & SHMEM_EEE_ADV_STATUS_MASK) {
-		PMD_DRV_LOG(DEBUG, "Setting XMAC for EEE");
+		PMD_DRV_LOG(DEBUG, sc, "Setting XMAC for EEE");
 		REG_WR(sc, xmac_base + XMAC_REG_EEE_TIMERS_HI, 0x1380008);
 		REG_WR(sc, xmac_base + XMAC_REG_EEE_CTRL, 0x1);
 	} else {
@@ -1577,7 +1578,7 @@ static elink_status_t elink_emac_enable(struct elink_params *params,
 	uint32_t emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
 	uint32_t val;
 
-	PMD_DRV_LOG(DEBUG, "enabling EMAC");
+	PMD_DRV_LOG(DEBUG, sc, "enabling EMAC");
 
 	/* Disable BMAC */
 	REG_WR(sc, GRCBASE_MISC + MISC_REGISTERS_RESET_REG_2_CLEAR,
@@ -1591,14 +1592,14 @@ static elink_status_t elink_emac_enable(struct elink_params *params,
 				      PORT_HW_CFG_LANE_SWAP_CFG_MASTER_MASK) >>
 				     PORT_HW_CFG_LANE_SWAP_CFG_MASTER_SHIFT);
 
-		PMD_DRV_LOG(DEBUG, "XGXS");
+		PMD_DRV_LOG(DEBUG, sc, "XGXS");
 		/* select the master lanes (out of 0-3) */
 		REG_WR(sc, NIG_REG_XGXS_LANE_SEL_P0 + port * 4, ser_lane);
 		/* select XGXS */
 		REG_WR(sc, NIG_REG_XGXS_SERDES0_MODE_SEL + port * 4, 1);
 
 	} else {		/* SerDes */
-		PMD_DRV_LOG(DEBUG, "SerDes");
+		PMD_DRV_LOG(DEBUG, sc, "SerDes");
 		/* select SerDes */
 		REG_WR(sc, NIG_REG_XGXS_SERDES0_MODE_SEL + port * 4, 0);
 	}
@@ -1644,7 +1645,7 @@ static elink_status_t elink_emac_enable(struct elink_params *params,
 	 */
 	elink_cb_reg_write(sc, emac_base + EMAC_REG_RX_PFC_MODE, 0);
 	if (params->feature_config_flags & ELINK_FEATURE_CONFIG_PFC_ENABLED) {
-		PMD_DRV_LOG(DEBUG, "PFC is enabled");
+		PMD_DRV_LOG(DEBUG, sc, "PFC is enabled");
 		/* Enable PFC again */
 		elink_cb_reg_write(sc, emac_base + EMAC_REG_RX_PFC_MODE,
 				   EMAC_REG_RX_PFC_MODE_RX_EN |
@@ -1764,7 +1765,7 @@ static void elink_update_pfc_bmac2(struct elink_params *params,
 	REG_WR_DMAE(sc, bmac_addr + BIGMAC2_REGISTER_TX_CONTROL, wb_data, 2);
 
 	if (params->feature_config_flags & ELINK_FEATURE_CONFIG_PFC_ENABLED) {
-		PMD_DRV_LOG(DEBUG, "PFC is enabled");
+		PMD_DRV_LOG(DEBUG, sc, "PFC is enabled");
 		/* Enable PFC RX & TX & STATS and set 8 COS  */
 		wb_data[0] = 0x0;
 		wb_data[0] |= (1 << 0);	/* RX */
@@ -1778,7 +1779,7 @@ static void elink_update_pfc_bmac2(struct elink_params *params,
 		/* Clear the force Xon */
 		wb_data[0] &= ~(1 << 2);
 	} else {
-		PMD_DRV_LOG(DEBUG, "PFC is disabled");
+		PMD_DRV_LOG(DEBUG, sc, "PFC is disabled");
 		/* Disable PFC RX & TX & STATS and set 8 COS */
 		wb_data[0] = 0x8;
 		wb_data[1] = 0;
@@ -1804,7 +1805,7 @@ static void elink_update_pfc_bmac2(struct elink_params *params,
 	val = 0x3;		/* Enable RX and TX */
 	if (is_lb) {
 		val |= 0x4;	/* Local loopback */
-		PMD_DRV_LOG(DEBUG, "enable bmac loopback");
+		PMD_DRV_LOG(DEBUG, sc, "enable bmac loopback");
 	}
 	/* When PFC enabled, Pass pause frames towards the NIG. */
 	if (params->feature_config_flags & ELINK_FEATURE_CONFIG_PFC_ENABLED)
@@ -1898,7 +1899,7 @@ static void elink_update_pfc_nig(struct elink_params *params,
 
 	int set_pfc = params->feature_config_flags &
 	    ELINK_FEATURE_CONFIG_PFC_ENABLED;
-	PMD_DRV_LOG(DEBUG, "updating pfc nig parameters");
+	PMD_DRV_LOG(DEBUG, sc, "updating pfc nig parameters");
 
 	/* When NIG_LLH0_XCM_MASK_REG_LLHX_XCM_MASK_BCN bit is set
 	 * MAC control frames (that are not pause packets)
@@ -2010,7 +2011,7 @@ elink_status_t elink_update_pfc(struct elink_params *params,
 	if (!vars->link_up)
 		return elink_status;
 
-	PMD_DRV_LOG(DEBUG, "About to update PFC in BMAC");
+	PMD_DRV_LOG(DEBUG, sc, "About to update PFC in BMAC");
 
 	if (CHIP_IS_E3(sc)) {
 		if (vars->mac_type == ELINK_MAC_TYPE_XMAC)
@@ -2020,7 +2021,7 @@ elink_status_t elink_update_pfc(struct elink_params *params,
 		if ((val &
 		     (MISC_REGISTERS_RESET_REG_2_RST_BMAC0 << params->port))
 		    == 0) {
-			PMD_DRV_LOG(DEBUG, "About to update PFC in EMAC");
+			PMD_DRV_LOG(DEBUG, sc, "About to update PFC in EMAC");
 			elink_emac_enable(params, vars, 0);
 			return elink_status;
 		}
@@ -2049,7 +2050,7 @@ static elink_status_t elink_bmac1_enable(struct elink_params *params,
 	uint32_t wb_data[2];
 	uint32_t val;
 
-	PMD_DRV_LOG(DEBUG, "Enabling BigMAC1");
+	PMD_DRV_LOG(DEBUG, sc, "Enabling BigMAC1");
 
 	/* XGXS control */
 	wb_data[0] = 0x3c;
@@ -2068,7 +2069,7 @@ static elink_status_t elink_bmac1_enable(struct elink_params *params,
 	val = 0x3;
 	if (is_lb) {
 		val |= 0x4;
-		PMD_DRV_LOG(DEBUG, "enable bmac loopback");
+		PMD_DRV_LOG(DEBUG, sc, "enable bmac loopback");
 	}
 	wb_data[0] = val;
 	wb_data[1] = 0;
@@ -2109,7 +2110,7 @@ static elink_status_t elink_bmac2_enable(struct elink_params *params,
 	    NIG_REG_INGRESS_BMAC0_MEM;
 	uint32_t wb_data[2];
 
-	PMD_DRV_LOG(DEBUG, "Enabling BigMAC2");
+	PMD_DRV_LOG(DEBUG, sc, "Enabling BigMAC2");
 
 	wb_data[0] = 0;
 	wb_data[1] = 0;
@@ -2247,7 +2248,7 @@ static elink_status_t elink_pbf_update(struct elink_params *params,
 	/* Wait for init credit */
 	init_crd = REG_RD(sc, PBF_REG_P0_INIT_CRD + port * 4);
 	crd = REG_RD(sc, PBF_REG_P0_CREDIT + port * 8);
-	PMD_DRV_LOG(DEBUG, "init_crd 0x%x  crd 0x%x", init_crd, crd);
+	PMD_DRV_LOG(DEBUG, sc, "init_crd 0x%x  crd 0x%x", init_crd, crd);
 
 	while ((init_crd != crd) && count) {
 		DELAY(1000 * 5);
@@ -2256,7 +2257,7 @@ static elink_status_t elink_pbf_update(struct elink_params *params,
 	}
 	crd = REG_RD(sc, PBF_REG_P0_CREDIT + port * 8);
 	if (init_crd != crd) {
-		PMD_DRV_LOG(DEBUG, "BUG! init_crd 0x%x != crd 0x%x",
+		PMD_DRV_LOG(DEBUG, sc, "BUG! init_crd 0x%x != crd 0x%x",
 			    init_crd, crd);
 		return ELINK_STATUS_ERROR;
 	}
@@ -2283,13 +2284,13 @@ static elink_status_t elink_pbf_update(struct elink_params *params,
 			init_crd = thresh + 553 - 22;
 			break;
 		default:
-			PMD_DRV_LOG(DEBUG, "Invalid line_speed 0x%x",
+			PMD_DRV_LOG(DEBUG, sc, "Invalid line_speed 0x%x",
 				    line_speed);
 			return ELINK_STATUS_ERROR;
 		}
 	}
 	REG_WR(sc, PBF_REG_P0_INIT_CRD + port * 4, init_crd);
-	PMD_DRV_LOG(DEBUG, "PBF updated to speed %d credit %d",
+	PMD_DRV_LOG(DEBUG, sc, "PBF updated to speed %d credit %d",
 		    line_speed, init_crd);
 
 	/* Probe the credit changes */
@@ -2379,7 +2380,7 @@ static elink_status_t elink_cl22_write(struct bnx2x_softc *sc,
 		}
 	}
 	if (tmp & EMAC_MDIO_COMM_START_BUSY) {
-		PMD_DRV_LOG(DEBUG, "write phy register failed");
+		PMD_DRV_LOG(DEBUG, sc, "write phy register failed");
 		rc = ELINK_STATUS_TIMEOUT;
 	}
 	REG_WR(sc, phy->mdio_ctrl + EMAC_REG_EMAC_MDIO_MODE, mode);
@@ -2415,7 +2416,7 @@ static elink_status_t elink_cl22_read(struct bnx2x_softc *sc,
 		}
 	}
 	if (val & EMAC_MDIO_COMM_START_BUSY) {
-		PMD_DRV_LOG(DEBUG, "read phy register failed");
+		PMD_DRV_LOG(DEBUG, sc, "read phy register failed");
 
 		*ret_val = 0;
 		rc = ELINK_STATUS_TIMEOUT;
@@ -2456,7 +2457,7 @@ static elink_status_t elink_cl45_read(struct bnx2x_softc *sc,
 		}
 	}
 	if (val & EMAC_MDIO_COMM_START_BUSY) {
-		PMD_DRV_LOG(DEBUG, "read phy register failed");
+		PMD_DRV_LOG(DEBUG, sc, "read phy register failed");
 		elink_cb_event_log(sc, ELINK_LOG_ID_MDIO_ACCESS_TIMEOUT);	// "MDC/MDIO access timeout"
 
 		*ret_val = 0;
@@ -2480,7 +2481,7 @@ static elink_status_t elink_cl45_read(struct bnx2x_softc *sc,
 			}
 		}
 		if (val & EMAC_MDIO_COMM_START_BUSY) {
-			PMD_DRV_LOG(DEBUG, "read phy register failed");
+			PMD_DRV_LOG(DEBUG, sc, "read phy register failed");
 			elink_cb_event_log(sc, ELINK_LOG_ID_MDIO_ACCESS_TIMEOUT);	// "MDC/MDIO access timeout"
 
 			*ret_val = 0;
@@ -2532,7 +2533,7 @@ static elink_status_t elink_cl45_write(struct bnx2x_softc *sc,
 		}
 	}
 	if (tmp & EMAC_MDIO_COMM_START_BUSY) {
-		PMD_DRV_LOG(DEBUG, "write phy register failed");
+		PMD_DRV_LOG(DEBUG, sc, "write phy register failed");
 		elink_cb_event_log(sc, ELINK_LOG_ID_MDIO_ACCESS_TIMEOUT);	// "MDC/MDIO access timeout"
 
 		rc = ELINK_STATUS_TIMEOUT;
@@ -2554,7 +2555,7 @@ static elink_status_t elink_cl45_write(struct bnx2x_softc *sc,
 			}
 		}
 		if (tmp & EMAC_MDIO_COMM_START_BUSY) {
-			PMD_DRV_LOG(DEBUG, "write phy register failed");
+			PMD_DRV_LOG(DEBUG, sc, "write phy register failed");
 			elink_cb_event_log(sc, ELINK_LOG_ID_MDIO_ACCESS_TIMEOUT);	// "MDC/MDIO access timeout"
 
 			rc = ELINK_STATUS_TIMEOUT;
@@ -2677,7 +2678,7 @@ static elink_status_t elink_eee_set_timers(struct elink_params *params,
 	} else if ((params->eee_mode & ELINK_EEE_MODE_ENABLE_LPI) &&
 		   (params->eee_mode & ELINK_EEE_MODE_OVERRIDE_NVRAM) &&
 		   (params->eee_mode & ELINK_EEE_MODE_OUTPUT_TIME)) {
-		PMD_DRV_LOG(DEBUG, "Error: Tx LPI is enabled with timer 0");
+		PMD_DRV_LOG(DEBUG, sc, "Error: Tx LPI is enabled with timer 0");
 		return ELINK_STATUS_ERROR;
 	}
 
@@ -2744,11 +2745,11 @@ static elink_status_t elink_eee_advertise(struct elink_phy *phy,
 	REG_WR(sc, MISC_REG_CPMU_LP_MASK_EXT_P0 + (params->port << 2), 0xfc20);
 
 	if (modes & SHMEM_EEE_10G_ADV) {
-		PMD_DRV_LOG(DEBUG, "Advertise 10GBase-T EEE");
+		PMD_DRV_LOG(DEBUG, sc, "Advertise 10GBase-T EEE");
 		val |= 0x8;
 	}
 	if (modes & SHMEM_EEE_1G_ADV) {
-		PMD_DRV_LOG(DEBUG, "Advertise 1GBase-T EEE");
+		PMD_DRV_LOG(DEBUG, sc, "Advertise 1GBase-T EEE");
 		val |= 0x4;
 	}
 
@@ -2788,7 +2789,7 @@ static void elink_eee_an_resolve(struct elink_phy *phy,
 		if (adv & 0x2) {
 			if (vars->line_speed == ELINK_SPEED_100)
 				neg = 1;
-			PMD_DRV_LOG(DEBUG, "EEE negotiated - 100M");
+			PMD_DRV_LOG(DEBUG, sc, "EEE negotiated - 100M");
 		}
 	}
 	if (lp & 0x14) {
@@ -2796,7 +2797,7 @@ static void elink_eee_an_resolve(struct elink_phy *phy,
 		if (adv & 0x14) {
 			if (vars->line_speed == ELINK_SPEED_1000)
 				neg = 1;
-			PMD_DRV_LOG(DEBUG, "EEE negotiated - 1G");
+			PMD_DRV_LOG(DEBUG, sc, "EEE negotiated - 1G");
 		}
 	}
 	if (lp & 0x68) {
@@ -2804,7 +2805,7 @@ static void elink_eee_an_resolve(struct elink_phy *phy,
 		if (adv & 0x68) {
 			if (vars->line_speed == ELINK_SPEED_10000)
 				neg = 1;
-			PMD_DRV_LOG(DEBUG, "EEE negotiated - 10G");
+			PMD_DRV_LOG(DEBUG, sc, "EEE negotiated - 10G");
 		}
 	}
 
@@ -2812,7 +2813,7 @@ static void elink_eee_an_resolve(struct elink_phy *phy,
 	vars->eee_status |= (lp_adv << SHMEM_EEE_LP_ADV_STATUS_SHIFT);
 
 	if (neg) {
-		PMD_DRV_LOG(DEBUG, "EEE is active");
+		PMD_DRV_LOG(DEBUG, sc, "EEE is active");
 		vars->eee_status |= SHMEM_EEE_ACTIVE_BIT;
 	}
 }
@@ -2842,7 +2843,7 @@ static void elink_bsc_module_sel(struct elink_params *params)
 				   e3_cmn_pin_cfg));
 	i2c_val[I2C_BSC0] = (sfp_ctrl & PORT_HW_CFG_E3_I2C_MUX0_MASK) > 0;
 	i2c_val[I2C_BSC1] = (sfp_ctrl & PORT_HW_CFG_E3_I2C_MUX1_MASK) > 0;
-	PMD_DRV_LOG(DEBUG, "Setting BSC switch");
+	PMD_DRV_LOG(DEBUG, sc, "Setting BSC switch");
 	for (idx = 0; idx < I2C_SWITCH_WIDTH; idx++)
 		elink_set_cfg_pin(sc, i2c_pins[idx], i2c_val[idx]);
 }
@@ -2858,7 +2859,7 @@ static elink_status_t elink_bsc_read(struct elink_params *params,
 	elink_status_t rc = ELINK_STATUS_OK;
 
 	if (xfer_cnt > 16) {
-		PMD_DRV_LOG(DEBUG, "invalid xfer_cnt %d. Max is 16 bytes",
+		PMD_DRV_LOG(DEBUG, sc, "invalid xfer_cnt %d. Max is 16 bytes",
 			    xfer_cnt);
 		return ELINK_STATUS_ERROR;
 	}
@@ -2890,7 +2891,7 @@ static elink_status_t elink_bsc_read(struct elink_params *params,
 		DELAY(10);
 		val = REG_RD(sc, MCP_REG_MCPR_IMC_COMMAND);
 		if (i++ > 1000) {
-			PMD_DRV_LOG(DEBUG, "wr 0 byte timed out after %d try",
+			PMD_DRV_LOG(DEBUG, sc, "wr 0 byte timed out after %d try",
 				    i);
 			rc = ELINK_STATUS_TIMEOUT;
 			break;
@@ -2914,7 +2915,8 @@ static elink_status_t elink_bsc_read(struct elink_params *params,
 		DELAY(10);
 		val = REG_RD(sc, MCP_REG_MCPR_IMC_COMMAND);
 		if (i++ > 1000) {
-			PMD_DRV_LOG(DEBUG, "rd op timed out after %d try", i);
+			PMD_DRV_LOG(DEBUG, sc,
+				    "rd op timed out after %d try", i);
 			rc = ELINK_STATUS_TIMEOUT;
 			break;
 		}
@@ -3059,7 +3061,7 @@ static void elink_serdes_deassert(struct bnx2x_softc *sc, uint8_t port)
 {
 	uint32_t val;
 
-	PMD_DRV_LOG(DEBUG, "elink_serdes_deassert");
+	PMD_DRV_LOG(DEBUG, sc, "elink_serdes_deassert");
 
 	val = ELINK_SERDES_RESET_BITS << (port * 16);
 
@@ -3094,7 +3096,7 @@ static void elink_xgxs_deassert(struct elink_params *params)
 	struct bnx2x_softc *sc = params->sc;
 	uint8_t port;
 	uint32_t val;
-	PMD_DRV_LOG(DEBUG, "elink_xgxs_deassert");
+	PMD_DRV_LOG(DEBUG, sc, "elink_xgxs_deassert");
 	port = params->port;
 
 	val = ELINK_XGXS_RESET_BITS << (port * 16);
@@ -3145,7 +3147,7 @@ static void elink_calc_ieee_aneg_adv(struct elink_phy *phy,
 		*ieee_fc |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_NONE;
 		break;
 	}
-	PMD_DRV_LOG(DEBUG, "ieee_fc = 0x%x", *ieee_fc);
+	PMD_DRV_LOG(DEBUG, params->sc, "ieee_fc = 0x%x", *ieee_fc);
 }
 
 static void set_phy_vars(struct elink_params *params, struct elink_vars *vars)
@@ -3179,7 +3181,7 @@ static void set_phy_vars(struct elink_params *params, struct elink_vars *vars)
 		    ELINK_SPEED_AUTO_NEG)
 			vars->link_status |= LINK_STATUS_AUTO_NEGOTIATE_ENABLED;
 
-		PMD_DRV_LOG(DEBUG, "req_flow_ctrl %x, req_line_speed %x,"
+		PMD_DRV_LOG(DEBUG, params->sc, "req_flow_ctrl %x, req_line_speed %x,"
 			    " speed_cap_mask %x",
 			    params->phy[actual_phy_idx].req_flow_ctrl,
 			    params->phy[actual_phy_idx].req_line_speed,
@@ -3210,7 +3212,7 @@ static void elink_ext_phy_set_pause(struct elink_params *params,
 	    MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) {
 		val |= MDIO_AN_REG_ADV_PAUSE_PAUSE;
 	}
-	PMD_DRV_LOG(DEBUG, "Ext phy AN advertize 0x%x", val);
+	PMD_DRV_LOG(DEBUG, sc, "Ext phy AN advertize 0x%x", val);
 	elink_cl45_write(sc, phy, MDIO_AN_DEVAD, MDIO_AN_REG_ADV_PAUSE, val);
 }
 
@@ -3289,7 +3291,7 @@ static void elink_ext_phy_update_adv_fc(struct elink_phy *phy,
 	}
 	pause_result = (ld_pause & MDIO_AN_REG_ADV_PAUSE_MASK) >> 8;
 	pause_result |= (lp_pause & MDIO_AN_REG_ADV_PAUSE_MASK) >> 10;
-	PMD_DRV_LOG(DEBUG, "Ext PHY pause result 0x%x", pause_result);
+	PMD_DRV_LOG(DEBUG, sc, "Ext PHY pause result 0x%x", pause_result);
 	elink_pause_resolve(vars, pause_result);
 
 }
@@ -3358,7 +3360,7 @@ static void elink_warpcore_enable_AN_KR2(struct elink_phy *phy,
 		{MDIO_WC_DEVAD, MDIO_WC_REG_ETA_CL73_LD_BAM_CODE, 0x0157},
 		{MDIO_WC_DEVAD, MDIO_WC_REG_ETA_CL73_LD_UD_CODE, 0x0620}
 	};
-	PMD_DRV_LOG(DEBUG, "Enabling 20G-KR2");
+	PMD_DRV_LOG(DEBUG, sc, "Enabling 20G-KR2");
 
 	elink_cl45_read_or_write(sc, phy, MDIO_WC_DEVAD,
 				 MDIO_WC_REG_CL49_USERB0_CTRL, (3 << 6));
@@ -3395,7 +3397,7 @@ static void elink_disable_kr2(struct elink_params *params,
 		{MDIO_WC_DEVAD, MDIO_WC_REG_ETA_CL73_LD_BAM_CODE, 0x0002},
 		{MDIO_WC_DEVAD, MDIO_WC_REG_ETA_CL73_LD_UD_CODE, 0x0000}
 	};
-	PMD_DRV_LOG(DEBUG, "Disabling 20G-KR2");
+	PMD_DRV_LOG(DEBUG, sc, "Disabling 20G-KR2");
 
 	for (i = 0; i < ARRAY_SIZE(reg_set); i++)
 		elink_cl45_write(sc, phy, reg_set[i].devad, reg_set[i].reg,
@@ -3411,7 +3413,7 @@ static void elink_warpcore_set_lpi_passthrough(struct elink_phy *phy,
 {
 	struct bnx2x_softc *sc = params->sc;
 
-	PMD_DRV_LOG(DEBUG, "Configure WC for LPI pass through");
+	PMD_DRV_LOG(DEBUG, sc, "Configure WC for LPI pass through");
 	elink_cl45_write(sc, phy, MDIO_WC_DEVAD,
 			 MDIO_WC_REG_EEE_COMBO_CONTROL0, 0x7c);
 	elink_cl45_read_or_write(sc, phy, MDIO_WC_DEVAD,
@@ -3449,7 +3451,7 @@ static void elink_warpcore_enable_AN_KR(struct elink_phy *phy,
 		{MDIO_PMA_DEVAD, MDIO_WC_REG_PMD_KR_CONTROL, 0x2},
 		{MDIO_WC_DEVAD, MDIO_WC_REG_CL72_USERB0_CL72_TX_FIR_TAP, 0},
 	};
-	PMD_DRV_LOG(DEBUG, "Enable Auto Negotiation for KR");
+	PMD_DRV_LOG(DEBUG, sc, "Enable Auto Negotiation for KR");
 	/* Set to default registers that may be overriden by 10G force */
 	for (i = 0; i < ARRAY_SIZE(reg_set); i++)
 		elink_cl45_write(sc, phy, reg_set[i].devad, reg_set[i].reg,
@@ -3471,7 +3473,7 @@ static void elink_warpcore_enable_AN_KR(struct elink_phy *phy,
 
 		/* Enable CL37 1G Parallel Detect */
 		elink_cl45_read_or_write(sc, phy, MDIO_WC_DEVAD, addr, 0x1);
-		PMD_DRV_LOG(DEBUG, "Advertize 1G");
+		PMD_DRV_LOG(DEBUG, sc, "Advertize 1G");
 	}
 	if (((vars->line_speed == ELINK_SPEED_AUTO_NEG) &&
 	     (phy->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) ||
@@ -3485,7 +3487,7 @@ static void elink_warpcore_enable_AN_KR(struct elink_phy *phy,
 		elink_cl45_write(sc, phy, MDIO_AN_DEVAD,
 				 MDIO_WC_REG_PAR_DET_10G_CTRL, 1);
 		elink_set_aer_mmd(params, phy);
-		PMD_DRV_LOG(DEBUG, "Advertize 10G");
+		PMD_DRV_LOG(DEBUG, sc, "Advertize 10G");
 	}
 
 	/* Set Transmit PMD settings */
@@ -3522,7 +3524,7 @@ static void elink_warpcore_enable_AN_KR(struct elink_phy *phy,
 		elink_cl45_read_or_write(sc, phy, MDIO_WC_DEVAD,
 					 MDIO_WC_REG_DIGITAL6_MP5_NEXTPAGECTRL,
 					 1);
-		PMD_DRV_LOG(DEBUG, "Enable CL37 BAM on KR");
+		PMD_DRV_LOG(DEBUG, sc, "Enable CL37 BAM on KR");
 	}
 
 	/* Advertise pause */
@@ -3859,7 +3861,7 @@ static void elink_warpcore_set_sgmii_speed(struct elink_phy *phy,
 		elink_cl45_read_or_write(sc, phy, MDIO_WC_DEVAD,
 					 MDIO_WC_REG_COMBO_IEEE0_MIICTRL,
 					 0x1000);
-		PMD_DRV_LOG(DEBUG, "set SGMII AUTONEG");
+		PMD_DRV_LOG(DEBUG, sc, "set SGMII AUTONEG");
 	} else {
 		elink_cl45_read(sc, phy, MDIO_WC_DEVAD,
 				MDIO_WC_REG_COMBO_IEEE0_MIICTRL, &val16);
@@ -3874,7 +3876,7 @@ static void elink_warpcore_set_sgmii_speed(struct elink_phy *phy,
 			val16 |= 0x0040;
 			break;
 		default:
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "Speed not supported: 0x%x",
 				    phy->req_line_speed);
 			return;
@@ -3886,11 +3888,11 @@ static void elink_warpcore_set_sgmii_speed(struct elink_phy *phy,
 		elink_cl45_write(sc, phy, MDIO_WC_DEVAD,
 				 MDIO_WC_REG_COMBO_IEEE0_MIICTRL, val16);
 
-		PMD_DRV_LOG(DEBUG, "set SGMII force speed %d",
+		PMD_DRV_LOG(DEBUG, sc, "set SGMII force speed %d",
 			    phy->req_line_speed);
 		elink_cl45_read(sc, phy, MDIO_WC_DEVAD,
 				MDIO_WC_REG_COMBO_IEEE0_MIICTRL, &val16);
-		PMD_DRV_LOG(DEBUG, "  (readback) %x", val16);
+		PMD_DRV_LOG(DEBUG, sc, "  (readback) %x", val16);
 	}
 
 	/* SGMII Slave mode and disable signal detect */
@@ -4001,7 +4003,7 @@ static elink_status_t elink_get_mod_abs_int_cfg(struct bnx2x_softc *sc,
 		 */
 		if ((cfg_pin < PIN_CFG_GPIO0_P0) ||
 		    (cfg_pin > PIN_CFG_GPIO3_P1)) {
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "No cfg pin %x for module detect indication",
 				    cfg_pin);
 			return ELINK_STATUS_ERROR;
@@ -4093,7 +4095,7 @@ static void elink_warpcore_config_runtime(struct elink_phy *phy,
 						 0x1200);
 
 				vars->rx_tx_asic_rst--;
-				PMD_DRV_LOG(DEBUG, "0x%x retry left",
+				PMD_DRV_LOG(DEBUG, sc, "0x%x retry left",
 					    vars->rx_tx_asic_rst);
 			}
 			break;
@@ -4115,10 +4117,10 @@ static void elink_warpcore_config_sfi(struct elink_phy *phy,
 	if ((params->req_line_speed[ELINK_LINK_CONFIG_IDX(ELINK_INT_PHY)] ==
 	     ELINK_SPEED_10000) &&
 	    (phy->media_type != ELINK_ETH_PHY_SFP_1G_FIBER)) {
-		PMD_DRV_LOG(DEBUG, "Setting 10G SFI");
+		PMD_DRV_LOG(DEBUG, params->sc, "Setting 10G SFI");
 		elink_warpcore_set_10G_XFI(phy, params, 0);
 	} else {
-		PMD_DRV_LOG(DEBUG, "Setting 1G Fiber");
+		PMD_DRV_LOG(DEBUG, params->sc, "Setting 1G Fiber");
 		elink_warpcore_set_sgmii_speed(phy, params, 1, 0);
 	}
 }
@@ -4135,7 +4137,7 @@ static void elink_sfp_e3_set_transmitter(struct elink_params *params,
 				  dev_info.port_hw_config[port].e3_sfp_ctrl)) &
 	    PORT_HW_CFG_E3_TX_LASER_MASK;
 	/* Set the !tx_en since this pin is DISABLE_TX_LASER */
-	PMD_DRV_LOG(DEBUG, "Setting WC TX to %d", tx_en);
+	PMD_DRV_LOG(DEBUG, sc, "Setting WC TX to %d", tx_en);
 
 	/* For 20G, the expected pin to be used is 3 pins after the current */
 	elink_set_cfg_pin(sc, cfg_pin, tx_en ^ 1);
@@ -4156,7 +4158,7 @@ static uint8_t elink_warpcore_config_init(struct elink_phy *phy,
 					 dev_info.port_hw_config[params->port].
 					 default_cfg)) &
 			 PORT_HW_CFG_NET_SERDES_IF_MASK);
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 		    "Begin Warpcore init, link_speed %d, "
 		    "serdes_net_if = 0x%x", vars->line_speed, serdes_net_if);
 	elink_set_aer_mmd(params, phy);
@@ -4167,7 +4169,7 @@ static uint8_t elink_warpcore_config_init(struct elink_phy *phy,
 	     ((phy->req_line_speed == ELINK_SPEED_100) ||
 	      (phy->req_line_speed == ELINK_SPEED_10)))) {
 		vars->phy_flags |= PHY_SGMII_FLAG;
-		PMD_DRV_LOG(DEBUG, "Setting SGMII mode");
+		PMD_DRV_LOG(DEBUG, sc, "Setting SGMII mode");
 		elink_warpcore_clear_regs(phy, params, lane);
 		elink_warpcore_set_sgmii_speed(phy, params, 0, 1);
 	} else {
@@ -4177,7 +4179,7 @@ static uint8_t elink_warpcore_config_init(struct elink_phy *phy,
 			if (params->loopback_mode != ELINK_LOOPBACK_EXT)
 				elink_warpcore_enable_AN_KR(phy, params, vars);
 			else {
-				PMD_DRV_LOG(DEBUG, "Setting KR 10G-Force");
+				PMD_DRV_LOG(DEBUG, sc, "Setting KR 10G-Force");
 				elink_warpcore_set_10G_KR(phy, params);
 			}
 			break;
@@ -4185,14 +4187,14 @@ static uint8_t elink_warpcore_config_init(struct elink_phy *phy,
 		case PORT_HW_CFG_NET_SERDES_IF_XFI:
 			elink_warpcore_clear_regs(phy, params, lane);
 			if (vars->line_speed == ELINK_SPEED_10000) {
-				PMD_DRV_LOG(DEBUG, "Setting 10G XFI");
+				PMD_DRV_LOG(DEBUG, sc, "Setting 10G XFI");
 				elink_warpcore_set_10G_XFI(phy, params, 1);
 			} else {
 				if (ELINK_SINGLE_MEDIA_DIRECT(params)) {
-					PMD_DRV_LOG(DEBUG, "1G Fiber");
+					PMD_DRV_LOG(DEBUG, sc, "1G Fiber");
 					fiber_mode = 1;
 				} else {
-					PMD_DRV_LOG(DEBUG, "10/100/1G SGMII");
+					PMD_DRV_LOG(DEBUG, sc, "10/100/1G SGMII");
 					fiber_mode = 0;
 				}
 				elink_warpcore_set_sgmii_speed(phy,
@@ -4221,10 +4223,10 @@ static uint8_t elink_warpcore_config_init(struct elink_phy *phy,
 
 		case PORT_HW_CFG_NET_SERDES_IF_DXGXS:
 			if (vars->line_speed != ELINK_SPEED_20000) {
-				PMD_DRV_LOG(DEBUG, "Speed not supported yet");
+				PMD_DRV_LOG(DEBUG, sc, "Speed not supported yet");
 				return 0;
 			}
-			PMD_DRV_LOG(DEBUG, "Setting 20G DXGXS");
+			PMD_DRV_LOG(DEBUG, sc, "Setting 20G DXGXS");
 			elink_warpcore_set_20G_DXGXS(sc, phy, lane);
 			/* Issue Module detection */
 
@@ -4234,12 +4236,12 @@ static uint8_t elink_warpcore_config_init(struct elink_phy *phy,
 			if (!params->loopback_mode) {
 				elink_warpcore_enable_AN_KR(phy, params, vars);
 			} else {
-				PMD_DRV_LOG(DEBUG, "Setting KR 20G-Force");
+				PMD_DRV_LOG(DEBUG, sc, "Setting KR 20G-Force");
 				elink_warpcore_set_20G_force_KR2(phy, params);
 			}
 			break;
 		default:
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "Unsupported Serdes Net Interface 0x%x",
 				    serdes_net_if);
 			return 0;
@@ -4248,7 +4250,7 @@ static uint8_t elink_warpcore_config_init(struct elink_phy *phy,
 
 	/* Take lane out of reset after configuration is finished */
 	elink_warpcore_reset_lane(sc, phy, 0);
-	PMD_DRV_LOG(DEBUG, "Exit config init");
+	PMD_DRV_LOG(DEBUG, sc, "Exit config init");
 
 	return 0;
 }
@@ -4313,7 +4315,7 @@ static void elink_set_warpcore_loopback(struct elink_phy *phy,
 	struct bnx2x_softc *sc = params->sc;
 	uint16_t val16;
 	uint32_t lane;
-	PMD_DRV_LOG(DEBUG, "Setting Warpcore loopback type %x, speed %d",
+	PMD_DRV_LOG(DEBUG, sc, "Setting Warpcore loopback type %x, speed %d",
 		    params->loopback_mode, phy->req_line_speed);
 
 	if (phy->req_line_speed < ELINK_SPEED_10000 ||
@@ -4358,7 +4360,7 @@ static void elink_sync_link(struct elink_params *params,
 		vars->phy_flags |= PHY_PHYSICAL_LINK_FLAG;
 	vars->link_up = (vars->link_status & LINK_STATUS_LINK_UP);
 	if (vars->link_up) {
-		PMD_DRV_LOG(DEBUG, "phy link up");
+		PMD_DRV_LOG(DEBUG, sc, "phy link up");
 
 		vars->phy_link_up = 1;
 		vars->duplex = DUPLEX_FULL;
@@ -4436,7 +4438,7 @@ static void elink_sync_link(struct elink_params *params,
 				vars->mac_type = ELINK_MAC_TYPE_EMAC;
 		}
 	} else {		/* Link down */
-		PMD_DRV_LOG(DEBUG, "phy link down");
+		PMD_DRV_LOG(DEBUG, sc, "phy link down");
 
 		vars->phy_link_up = 0;
 
@@ -4493,7 +4495,7 @@ void elink_link_status_update(struct elink_params *params,
 	params->phy[ELINK_EXT_PHY2].media_type =
 	    (media_types & PORT_HW_CFG_MEDIA_TYPE_PHY2_MASK) >>
 	    PORT_HW_CFG_MEDIA_TYPE_PHY2_SHIFT;
-	PMD_DRV_LOG(DEBUG, "media_types = 0x%x", media_types);
+	PMD_DRV_LOG(DEBUG, sc, "media_types = 0x%x", media_types);
 
 	/* Sync AEU offset */
 	sync_offset = params->shmem_base +
@@ -4514,9 +4516,9 @@ void elink_link_status_update(struct elink_params *params,
 		vars->link_attr_sync = SHMEM2_RD(sc,
 						 link_attr_sync[params->port]);
 
-	PMD_DRV_LOG(DEBUG, "link_status 0x%x  phy_link_up %x int_mask 0x%x",
+	PMD_DRV_LOG(DEBUG, sc, "link_status 0x%x  phy_link_up %x int_mask 0x%x",
 		    vars->link_status, vars->phy_link_up, vars->aeu_int_mask);
-	PMD_DRV_LOG(DEBUG, "line_speed %x  duplex %x  flow_ctrl 0x%x",
+	PMD_DRV_LOG(DEBUG, sc, "line_speed %x  duplex %x  flow_ctrl 0x%x",
 		    vars->line_speed, vars->duplex, vars->flow_ctrl);
 }
 
@@ -4577,7 +4579,7 @@ static elink_status_t elink_reset_unicore(struct elink_params *params,
 	elink_cb_event_log(sc, ELINK_LOG_ID_PHY_UNINITIALIZED, params->port);	// "Warning: PHY was not initialized,"
 	// " Port %d",
 
-	PMD_DRV_LOG(DEBUG, "BUG! XGXS is still in reset!");
+	PMD_DRV_LOG(DEBUG, sc, "BUG! XGXS is still in reset!");
 	return ELINK_STATUS_ERROR;
 
 }
@@ -4636,7 +4638,7 @@ static void elink_set_parallel_detection(struct elink_phy *phy,
 		control2 |= MDIO_SERDES_DIGITAL_A_1000X_CONTROL2_PRL_DT_EN;
 	else
 		control2 &= ~MDIO_SERDES_DIGITAL_A_1000X_CONTROL2_PRL_DT_EN;
-	PMD_DRV_LOG(DEBUG, "phy->speed_cap_mask = 0x%x, control2 = 0x%x",
+	PMD_DRV_LOG(DEBUG, sc, "phy->speed_cap_mask = 0x%x, control2 = 0x%x",
 		    phy->speed_cap_mask, control2);
 	CL22_WR_OVER_CL45(sc, phy,
 			  MDIO_REG_BANK_SERDES_DIGITAL,
@@ -4644,7 +4646,7 @@ static void elink_set_parallel_detection(struct elink_phy *phy,
 
 	if ((phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT) &&
 	    (phy->speed_cap_mask & PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) {
-		PMD_DRV_LOG(DEBUG, "XGXS");
+		PMD_DRV_LOG(DEBUG, sc, "XGXS");
 
 		CL22_WR_OVER_CL45(sc, phy,
 				  MDIO_REG_BANK_10G_PARALLEL_DETECT,
@@ -4797,7 +4799,7 @@ static void elink_program_serdes(struct elink_phy *phy,
 			  MDIO_REG_BANK_SERDES_DIGITAL,
 			  MDIO_SERDES_DIGITAL_MISC1, &reg_val);
 	/* Clearing the speed value before setting the right speed */
-	PMD_DRV_LOG(DEBUG, "MDIO_REG_BANK_SERDES_DIGITAL = 0x%x", reg_val);
+	PMD_DRV_LOG(DEBUG, sc, "MDIO_REG_BANK_SERDES_DIGITAL = 0x%x", reg_val);
 
 	reg_val &= ~(MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_MASK |
 		     MDIO_SERDES_DIGITAL_MISC1_FORCE_SPEED_SEL);
@@ -4865,7 +4867,7 @@ static void elink_restart_autoneg(struct elink_phy *phy,
 	struct bnx2x_softc *sc = params->sc;
 	uint16_t mii_control;
 
-	PMD_DRV_LOG(DEBUG, "elink_restart_autoneg");
+	PMD_DRV_LOG(DEBUG, sc, "elink_restart_autoneg");
 	/* Enable and restart BAM/CL37 aneg */
 
 	if (enable_cl73) {
@@ -4885,7 +4887,7 @@ static void elink_restart_autoneg(struct elink_phy *phy,
 		CL22_RD_OVER_CL45(sc, phy,
 				  MDIO_REG_BANK_COMBO_IEEE0,
 				  MDIO_COMBO_IEEE0_MII_CONTROL, &mii_control);
-		PMD_DRV_LOG(DEBUG,
+		PMD_DRV_LOG(DEBUG, sc,
 			    "elink_restart_autoneg mii_control before = 0x%x",
 			    mii_control);
 		CL22_WR_OVER_CL45(sc, phy,
@@ -4944,7 +4946,7 @@ static void elink_initialize_sgmii_process(struct elink_phy *phy,
 			break;
 		default:
 			/* Invalid speed for SGMII */
-			PMD_DRV_LOG(DEBUG, "Invalid line_speed 0x%x",
+			PMD_DRV_LOG(DEBUG, sc, "Invalid line_speed 0x%x",
 				    vars->line_speed);
 			break;
 		}
@@ -4979,7 +4981,7 @@ static elink_status_t elink_direct_parallel_detect_used(struct elink_phy *phy,
 			  MDIO_REG_BANK_SERDES_DIGITAL,
 			  MDIO_SERDES_DIGITAL_A_1000X_STATUS2, &status2_1000x);
 	if (status2_1000x & MDIO_SERDES_DIGITAL_A_1000X_STATUS2_AN_DISABLED) {
-		PMD_DRV_LOG(DEBUG, "1G parallel detect link on port %d",
+		PMD_DRV_LOG(DEBUG, sc, "1G parallel detect link on port %d",
 			    params->port);
 		return ELINK_STATUS_ERROR;
 	}
@@ -4989,7 +4991,7 @@ static elink_status_t elink_direct_parallel_detect_used(struct elink_phy *phy,
 			  MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_STATUS, &pd_10g);
 
 	if (pd_10g & MDIO_10G_PARALLEL_DETECT_PAR_DET_10G_STATUS_PD_LINK) {
-		PMD_DRV_LOG(DEBUG, "10G parallel detect link on port %d",
+		PMD_DRV_LOG(DEBUG, sc, "10G parallel detect link on port %d",
 			    params->port);
 		return ELINK_STATUS_ERROR;
 	}
@@ -5020,7 +5022,7 @@ static void elink_update_adv_fc(struct elink_phy *phy,
 				MDIO_CL73_IEEEB1_AN_ADV1_PAUSE_MASK) >> 8;
 		pause_result |= (lp_pause &
 				 MDIO_CL73_IEEEB1_AN_LP_ADV1_PAUSE_MASK) >> 10;
-		PMD_DRV_LOG(DEBUG, "pause_result CL73 0x%x", pause_result);
+		PMD_DRV_LOG(DEBUG, sc, "pause_result CL73 0x%x", pause_result);
 	} else {
 		CL22_RD_OVER_CL45(sc, phy,
 				  MDIO_REG_BANK_COMBO_IEEE0,
@@ -5033,7 +5035,7 @@ static void elink_update_adv_fc(struct elink_phy *phy,
 				MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) >> 5;
 		pause_result |= (lp_pause &
 				 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_MASK) >> 7;
-		PMD_DRV_LOG(DEBUG, "pause_result CL37 0x%x", pause_result);
+		PMD_DRV_LOG(DEBUG, sc, "pause_result CL37 0x%x", pause_result);
 	}
 	elink_pause_resolve(vars, pause_result);
 
@@ -5062,7 +5064,7 @@ static void elink_flow_ctrl_resolve(struct elink_phy *phy,
 		}
 		elink_update_adv_fc(phy, params, vars, gp_status);
 	}
-	PMD_DRV_LOG(DEBUG, "flow_ctrl 0x%x", vars->flow_ctrl);
+	PMD_DRV_LOG(DEBUG, params->sc, "flow_ctrl 0x%x", vars->flow_ctrl);
 }
 
 static void elink_check_fallback_to_cl37(struct elink_phy *phy,
@@ -5070,13 +5072,13 @@ static void elink_check_fallback_to_cl37(struct elink_phy *phy,
 {
 	struct bnx2x_softc *sc = params->sc;
 	uint16_t rx_status, ustat_val, cl37_fsm_received;
-	PMD_DRV_LOG(DEBUG, "elink_check_fallback_to_cl37");
+	PMD_DRV_LOG(DEBUG, sc, "elink_check_fallback_to_cl37");
 	/* Step 1: Make sure signal is detected */
 	CL22_RD_OVER_CL45(sc, phy,
 			  MDIO_REG_BANK_RX0, MDIO_RX0_RX_STATUS, &rx_status);
 	if ((rx_status & MDIO_RX0_RX_STATUS_SIGDET) !=
 	    (MDIO_RX0_RX_STATUS_SIGDET)) {
-		PMD_DRV_LOG(DEBUG, "Signal is not detected. Restoring CL73."
+		PMD_DRV_LOG(DEBUG, sc, "Signal is not detected. Restoring CL73."
 			    "rx_status(0x80b0) = 0x%x", rx_status);
 		CL22_WR_OVER_CL45(sc, phy,
 				  MDIO_REG_BANK_CL73_IEEEB0,
@@ -5093,7 +5095,7 @@ static void elink_check_fallback_to_cl37(struct elink_phy *phy,
 	      MDIO_CL73_USERB0_CL73_USTAT1_AN_GOOD_CHECK_BAM37)) !=
 	    (MDIO_CL73_USERB0_CL73_USTAT1_LINK_STATUS_CHECK |
 	     MDIO_CL73_USERB0_CL73_USTAT1_AN_GOOD_CHECK_BAM37)) {
-		PMD_DRV_LOG(DEBUG, "CL73 state-machine is not stable. "
+		PMD_DRV_LOG(DEBUG, sc, "CL73 state-machine is not stable. "
 			    "ustat_val(0x8371) = 0x%x", ustat_val);
 		return;
 	}
@@ -5108,7 +5110,7 @@ static void elink_check_fallback_to_cl37(struct elink_phy *phy,
 	      MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_BRCM_OUI_MSG)) !=
 	    (MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_OVER1G_MSG |
 	     MDIO_REMOTE_PHY_MISC_RX_STATUS_CL37_FSM_RECEIVED_BRCM_OUI_MSG)) {
-		PMD_DRV_LOG(DEBUG, "No CL37 FSM were received. "
+		PMD_DRV_LOG(DEBUG, sc, "No CL37 FSM were received. "
 			    "misc_rx_status(0x8330) = 0x%x", cl37_fsm_received);
 		return;
 	}
@@ -5124,7 +5126,7 @@ static void elink_check_fallback_to_cl37(struct elink_phy *phy,
 			  MDIO_CL73_IEEEB0_CL73_AN_CONTROL, 0);
 	/* Restart CL37 autoneg */
 	elink_restart_autoneg(phy, params, 0);
-	PMD_DRV_LOG(DEBUG, "Disabling CL73, and restarting CL37 autoneg");
+	PMD_DRV_LOG(DEBUG, sc, "Disabling CL73, and restarting CL37 autoneg");
 }
 
 static void elink_xgxs_an_resolve(struct elink_phy *phy,
@@ -5148,7 +5150,7 @@ static elink_status_t elink_get_link_speed_duplex(struct elink_phy *phy,
 	if (phy->req_line_speed == ELINK_SPEED_AUTO_NEG)
 		vars->link_status |= LINK_STATUS_AUTO_NEGOTIATE_ENABLED;
 	if (is_link_up) {
-		PMD_DRV_LOG(DEBUG, "phy link up");
+		PMD_DRV_LOG(DEBUG, params->sc, "phy link up");
 
 		vars->phy_link_up = 1;
 		vars->link_status |= LINK_STATUS_LINK_UP;
@@ -5189,7 +5191,7 @@ static elink_status_t elink_get_link_speed_duplex(struct elink_phy *phy,
 
 		case ELINK_GP_STATUS_5G:
 		case ELINK_GP_STATUS_6G:
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, params->sc,
 				    "link speed unsupported  gp_status 0x%x",
 				    speed_mask);
 			return ELINK_STATUS_ERROR;
@@ -5209,13 +5211,13 @@ static elink_status_t elink_get_link_speed_duplex(struct elink_phy *phy,
 			vars->link_status |= ELINK_LINK_20GTFD;
 			break;
 		default:
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, params->sc,
 				    "link speed unsupported gp_status 0x%x",
 				    speed_mask);
 			return ELINK_STATUS_ERROR;
 		}
 	} else {		/* link_down */
-		PMD_DRV_LOG(DEBUG, "phy link down");
+		PMD_DRV_LOG(DEBUG, params->sc, "phy link down");
 
 		vars->phy_link_up = 0;
 
@@ -5223,7 +5225,7 @@ static elink_status_t elink_get_link_speed_duplex(struct elink_phy *phy,
 		vars->flow_ctrl = ELINK_FLOW_CTRL_NONE;
 		vars->mac_type = ELINK_MAC_TYPE_NONE;
 	}
-	PMD_DRV_LOG(DEBUG, " phy_link_up %x line_speed %d",
+	PMD_DRV_LOG(DEBUG, params->sc, " phy_link_up %x line_speed %d",
 		    vars->phy_link_up, vars->line_speed);
 	return ELINK_STATUS_OK;
 }
@@ -5246,7 +5248,7 @@ static uint8_t elink_link_settings_status(struct elink_phy *phy,
 	if (gp_status & MDIO_GP_STATUS_TOP_AN_STATUS1_LINK_STATUS)
 		link_up = 1;
 	speed_mask = gp_status & ELINK_GP_STATUS_SPEED_MASK;
-	PMD_DRV_LOG(DEBUG, "gp_status 0x%x, is_link_up %d, speed_mask 0x%x",
+	PMD_DRV_LOG(DEBUG, sc, "gp_status 0x%x, is_link_up %d, speed_mask 0x%x",
 		    gp_status, link_up, speed_mask);
 	rc = elink_get_link_speed_duplex(phy, params, vars, link_up, speed_mask,
 					 duplex);
@@ -5296,7 +5298,7 @@ static uint8_t elink_link_settings_status(struct elink_phy *phy,
 			    LINK_STATUS_LINK_PARTNER_10GXFD_CAPABLE;
 	}
 
-	PMD_DRV_LOG(DEBUG, "duplex %x  flow_ctrl 0x%x link_status 0x%x",
+	PMD_DRV_LOG(DEBUG, sc, "duplex %x  flow_ctrl 0x%x link_status 0x%x",
 		    vars->duplex, vars->flow_ctrl, vars->link_status);
 	return rc;
 }
@@ -5322,7 +5324,7 @@ static uint8_t elink_warpcore_read_status(struct elink_phy *phy,
 		uint16_t temp_link_up;
 		elink_cl45_read(sc, phy, MDIO_WC_DEVAD, 1, &temp_link_up);
 		elink_cl45_read(sc, phy, MDIO_WC_DEVAD, 1, &link_up);
-		PMD_DRV_LOG(DEBUG, "PCS RX link status = 0x%x-->0x%x",
+		PMD_DRV_LOG(DEBUG, sc, "PCS RX link status = 0x%x-->0x%x",
 			    temp_link_up, link_up);
 		link_up &= (1 << 2);
 		if (link_up)
@@ -5330,7 +5332,7 @@ static uint8_t elink_warpcore_read_status(struct elink_phy *phy,
 	} else {
 		elink_cl45_read(sc, phy, MDIO_WC_DEVAD,
 				MDIO_WC_REG_GP2_STATUS_GP_2_1, &gp_status1);
-		PMD_DRV_LOG(DEBUG, "0x81d1 = 0x%x", gp_status1);
+		PMD_DRV_LOG(DEBUG, sc, "0x81d1 = 0x%x", gp_status1);
 		/* Check for either KR, 1G, or AN up. */
 		link_up = ((gp_status1 >> 8) |
 			   (gp_status1 >> 12) | (gp_status1)) & (1 << lane);
@@ -5400,7 +5402,7 @@ static uint8_t elink_warpcore_read_status(struct elink_phy *phy,
 		elink_cl45_read(sc, phy, MDIO_WC_DEVAD,
 				MDIO_WC_REG_GP2_STATUS_GP_2_3, &gp_speed);
 	}
-	PMD_DRV_LOG(DEBUG, "lane %d gp_speed 0x%x", lane, gp_speed);
+	PMD_DRV_LOG(DEBUG, sc, "lane %d gp_speed 0x%x", lane, gp_speed);
 
 	if ((lane & 1) == 0)
 		gp_speed <<= 8;
@@ -5416,7 +5418,7 @@ static uint8_t elink_warpcore_read_status(struct elink_phy *phy,
 	    (!(phy->flags & ELINK_FLAGS_WC_DUAL_MODE)))
 		vars->rx_tx_asic_rst = MAX_KR_LINK_RETRY;
 
-	PMD_DRV_LOG(DEBUG, "duplex %x  flow_ctrl 0x%x link_status 0x%x",
+	PMD_DRV_LOG(DEBUG, sc, "duplex %x  flow_ctrl 0x%x link_status 0x%x",
 		    vars->duplex, vars->flow_ctrl, vars->link_status);
 	return rc;
 }
@@ -5463,7 +5465,7 @@ static elink_status_t elink_emac_program(struct elink_params *params,
 	uint8_t port = params->port;
 	uint16_t mode = 0;
 
-	PMD_DRV_LOG(DEBUG, "setting link speed & duplex");
+	PMD_DRV_LOG(DEBUG, sc, "setting link speed & duplex");
 	elink_bits_dis(sc, GRCBASE_EMAC0 + port * 0x400 +
 		       EMAC_REG_EMAC_MODE,
 		       (EMAC_MODE_25G_MODE |
@@ -5487,7 +5489,8 @@ static elink_status_t elink_emac_program(struct elink_params *params,
 
 	default:
 		/* 10G not valid for EMAC */
-		PMD_DRV_LOG(DEBUG, "Invalid line_speed 0x%x", vars->line_speed);
+		PMD_DRV_LOG(DEBUG, sc,
+			    "Invalid line_speed 0x%x", vars->line_speed);
 		return ELINK_STATUS_ERROR;
 	}
 
@@ -5539,7 +5542,7 @@ static uint8_t elink_xgxs_config_init(struct elink_phy *phy,
 		if (vars->line_speed != ELINK_SPEED_AUTO_NEG ||
 		    (ELINK_SINGLE_MEDIA_DIRECT(params) &&
 		     params->loopback_mode == ELINK_LOOPBACK_EXT)) {
-			PMD_DRV_LOG(DEBUG, "not SGMII, no AN");
+			PMD_DRV_LOG(DEBUG, params->sc, "not SGMII, no AN");
 
 			/* Disable autoneg */
 			elink_set_autoneg(phy, params, vars, 0);
@@ -5548,7 +5551,7 @@ static uint8_t elink_xgxs_config_init(struct elink_phy *phy,
 			elink_program_serdes(phy, params, vars);
 
 		} else {	/* AN_mode */
-			PMD_DRV_LOG(DEBUG, "not SGMII, AN");
+			PMD_DRV_LOG(DEBUG, params->sc, "not SGMII, AN");
 
 			/* AN enabled */
 			elink_set_brcm_cl37_advertisement(phy, params);
@@ -5565,7 +5568,7 @@ static uint8_t elink_xgxs_config_init(struct elink_phy *phy,
 		}
 
 	} else {		/* SGMII mode */
-		PMD_DRV_LOG(DEBUG, "SGMII");
+		PMD_DRV_LOG(DEBUG, params->sc, "SGMII");
 
 		elink_initialize_sgmii_process(phy, params, vars);
 	}
@@ -5634,7 +5637,7 @@ static uint16_t elink_wait_reset_complete(struct bnx2x_softc *sc,
 		elink_cb_event_log(sc, ELINK_LOG_ID_PHY_UNINITIALIZED, params->port);	// "Warning: PHY was not initialized,"
 	// " Port %d",
 
-	PMD_DRV_LOG(DEBUG, "control reg 0x%x (after %d ms)", ctrl, cnt);
+	PMD_DRV_LOG(DEBUG, sc, "control reg 0x%x (after %d ms)", ctrl, cnt);
 	return cnt;
 }
 
@@ -5652,35 +5655,35 @@ static void elink_link_int_enable(struct elink_params *params)
 	} else if (params->switch_cfg == ELINK_SWITCH_CFG_10G) {
 		mask = (ELINK_NIG_MASK_XGXS0_LINK10G |
 			ELINK_NIG_MASK_XGXS0_LINK_STATUS);
-		PMD_DRV_LOG(DEBUG, "enabled XGXS interrupt");
+		PMD_DRV_LOG(DEBUG, sc, "enabled XGXS interrupt");
 		if (!(ELINK_SINGLE_MEDIA_DIRECT(params)) &&
 		    params->phy[ELINK_INT_PHY].type !=
 		    PORT_HW_CFG_XGXS_EXT_PHY_TYPE_FAILURE) {
 			mask |= ELINK_NIG_MASK_MI_INT;
-			PMD_DRV_LOG(DEBUG, "enabled external phy int");
+			PMD_DRV_LOG(DEBUG, sc, "enabled external phy int");
 		}
 
 	} else {		/* SerDes */
 		mask = ELINK_NIG_MASK_SERDES0_LINK_STATUS;
-		PMD_DRV_LOG(DEBUG, "enabled SerDes interrupt");
+		PMD_DRV_LOG(DEBUG, sc, "enabled SerDes interrupt");
 		if (!(ELINK_SINGLE_MEDIA_DIRECT(params)) &&
 		    params->phy[ELINK_INT_PHY].type !=
 		    PORT_HW_CFG_SERDES_EXT_PHY_TYPE_NOT_CONN) {
 			mask |= ELINK_NIG_MASK_MI_INT;
-			PMD_DRV_LOG(DEBUG, "enabled external phy int");
+			PMD_DRV_LOG(DEBUG, sc, "enabled external phy int");
 		}
 	}
 	elink_bits_en(sc, NIG_REG_MASK_INTERRUPT_PORT0 + port * 4, mask);
 
-	PMD_DRV_LOG(DEBUG, "port %x, is_xgxs %x, int_status 0x%x", port,
+	PMD_DRV_LOG(DEBUG, sc, "port %x, is_xgxs %x, int_status 0x%x", port,
 		    (params->switch_cfg == ELINK_SWITCH_CFG_10G),
 		    REG_RD(sc, NIG_REG_STATUS_INTERRUPT_PORT0 + port * 4));
-	PMD_DRV_LOG(DEBUG, " int_mask 0x%x, MI_INT %x, SERDES_LINK %x",
+	PMD_DRV_LOG(DEBUG, sc, " int_mask 0x%x, MI_INT %x, SERDES_LINK %x",
 		    REG_RD(sc, NIG_REG_MASK_INTERRUPT_PORT0 + port * 4),
 		    REG_RD(sc, NIG_REG_EMAC0_STATUS_MISC_MI_INT + port * 0x18),
 		    REG_RD(sc,
 			   NIG_REG_SERDES0_STATUS_LINK_STATUS + port * 0x3c));
-	PMD_DRV_LOG(DEBUG, " 10G %x, XGXS_LINK %x",
+	PMD_DRV_LOG(DEBUG, sc, " 10G %x, XGXS_LINK %x",
 		    REG_RD(sc, NIG_REG_XGXS0_STATUS_LINK10G + port * 0x68),
 		    REG_RD(sc, NIG_REG_XGXS0_STATUS_LINK_STATUS + port * 0x68));
 }
@@ -5696,7 +5699,7 @@ static void elink_rearm_latch_signal(struct bnx2x_softc *sc, uint8_t port,
 	 */
 	/* Read Latched signals */
 	latch_status = REG_RD(sc, NIG_REG_LATCH_STATUS_0 + port * 8);
-	PMD_DRV_LOG(DEBUG, "latch_status = 0x%x", latch_status);
+	PMD_DRV_LOG(DEBUG, sc, "latch_status = 0x%x", latch_status);
 	/* Handle only those with latched-signal=up. */
 	if (exp_mi_int)
 		elink_bits_en(sc,
@@ -5748,7 +5751,7 @@ static void elink_link_int_ack(struct elink_params *params,
 			} else
 				mask = ELINK_NIG_STATUS_SERDES0_LINK_STATUS;
 		}
-		PMD_DRV_LOG(DEBUG, "Ack link up interrupt with mask 0x%x",
+		PMD_DRV_LOG(DEBUG, sc, "Ack link up interrupt with mask 0x%x",
 			    mask);
 		elink_bits_en(sc,
 			      NIG_REG_STATUS_INTERRUPT_PORT0 + port * 4, mask);
@@ -5811,7 +5814,7 @@ static void elink_set_xgxs_loopback(struct elink_phy *phy,
 	if (phy->req_line_speed != ELINK_SPEED_1000) {
 		uint32_t md_devad = 0;
 
-		PMD_DRV_LOG(DEBUG, "XGXS 10G loopback enable");
+		PMD_DRV_LOG(DEBUG, sc, "XGXS 10G loopback enable");
 
 		if (!CHIP_IS_E3(sc)) {
 			/* Change the uni_phy_addr in the nig */
@@ -5843,7 +5846,7 @@ static void elink_set_xgxs_loopback(struct elink_phy *phy,
 		}
 	} else {
 		uint16_t mii_ctrl;
-		PMD_DRV_LOG(DEBUG, "XGXS 1G loopback enable");
+		PMD_DRV_LOG(DEBUG, sc, "XGXS 1G loopback enable");
 		elink_cl45_read(sc, phy, 5,
 				(MDIO_REG_BANK_COMBO_IEEE0 +
 				 (MDIO_COMBO_IEEE0_MII_CONTROL & 0xf)),
@@ -5867,8 +5870,9 @@ elink_status_t elink_set_led(struct elink_params *params,
 	uint32_t tmp;
 	uint32_t emac_base = port ? GRCBASE_EMAC1 : GRCBASE_EMAC0;
 	struct bnx2x_softc *sc = params->sc;
-	PMD_DRV_LOG(DEBUG, "elink_set_led: port %x, mode %d", port, mode);
-	PMD_DRV_LOG(DEBUG, "speed 0x%x, hw_led_mode 0x%x", speed, hw_led_mode);
+	PMD_DRV_LOG(DEBUG, sc, "elink_set_led: port %x, mode %d", port, mode);
+	PMD_DRV_LOG(DEBUG, sc,
+		    "speed 0x%x, hw_led_mode 0x%x", speed, hw_led_mode);
 	/* In case */
 	for (phy_idx = ELINK_EXT_PHY1; phy_idx < ELINK_MAX_PHYS; phy_idx++) {
 		if (params->phy[phy_idx].set_link_led) {
@@ -5987,7 +5991,8 @@ elink_status_t elink_set_led(struct elink_params *params,
 
 	default:
 		rc = ELINK_STATUS_ERROR;
-		PMD_DRV_LOG(DEBUG, "elink_set_led: Invalid led mode %d", mode);
+		PMD_DRV_LOG(DEBUG, sc,
+			    "elink_set_led: Invalid led mode %d", mode);
 		break;
 	}
 	return rc;
@@ -6054,7 +6059,7 @@ static elink_status_t elink_link_initialize(struct elink_params *params,
 			if (phy_index == ELINK_EXT_PHY2 &&
 			    (elink_phy_selection(params) ==
 			     PORT_HW_CFG_PHY_SELECTION_FIRST_PHY)) {
-				PMD_DRV_LOG(DEBUG,
+				PMD_DRV_LOG(DEBUG, sc,
 					    "Not initializing second phy");
 				continue;
 			}
@@ -6095,7 +6100,7 @@ static void elink_common_ext_link_reset(__rte_unused struct elink_phy *phy,
 			    MISC_REGISTERS_GPIO_OUTPUT_LOW, gpio_port);
 	elink_cb_gpio_write(sc, MISC_REGISTERS_GPIO_2,
 			    MISC_REGISTERS_GPIO_OUTPUT_LOW, gpio_port);
-	PMD_DRV_LOG(DEBUG, "reset external PHY");
+	PMD_DRV_LOG(DEBUG, sc, "reset external PHY");
 }
 
 static elink_status_t elink_update_link_down(struct elink_params *params,
@@ -6104,7 +6109,7 @@ static elink_status_t elink_update_link_down(struct elink_params *params,
 	struct bnx2x_softc *sc = params->sc;
 	uint8_t port = params->port;
 
-	PMD_DRV_LOG(DEBUG, "Port %x: Link is down", port);
+	PMD_DRV_LOG(DEBUG, sc, "Port %x: Link is down", port);
 	elink_set_led(params, vars, ELINK_LED_MODE_OFF, 0);
 	vars->phy_flags &= ~PHY_PHYSICAL_LINK_FLAG;
 	/* Indicate no mac active */
@@ -6165,7 +6170,7 @@ static elink_status_t elink_update_link_up(struct elink_params *params,
 		if (link_10g) {
 			if (elink_xmac_enable(params, vars, 0) ==
 			    ELINK_STATUS_NO_LINK) {
-				PMD_DRV_LOG(DEBUG, "Found errors on XMAC");
+				PMD_DRV_LOG(DEBUG, sc, "Found errors on XMAC");
 				vars->link_up = 0;
 				vars->phy_flags |= PHY_HALF_OPEN_CONN_FLAG;
 				vars->link_status &= ~LINK_STATUS_LINK_UP;
@@ -6177,7 +6182,7 @@ static elink_status_t elink_update_link_up(struct elink_params *params,
 
 		if ((vars->eee_status & SHMEM_EEE_ACTIVE_BIT) &&
 		    (vars->eee_status & SHMEM_EEE_LPI_REQUESTED_BIT)) {
-			PMD_DRV_LOG(DEBUG, "Enabling LPI assertion");
+			PMD_DRV_LOG(DEBUG, sc, "Enabling LPI assertion");
 			REG_WR(sc, MISC_REG_CPMU_LP_FW_ENABLE_P0 +
 			       (params->port << 2), 1);
 			REG_WR(sc, MISC_REG_CPMU_LP_DR_ENABLE, 1);
@@ -6189,7 +6194,7 @@ static elink_status_t elink_update_link_up(struct elink_params *params,
 		if (link_10g) {
 			if (elink_bmac_enable(params, vars, 0, 1) ==
 			    ELINK_STATUS_NO_LINK) {
-				PMD_DRV_LOG(DEBUG, "Found errors on BMAC");
+				PMD_DRV_LOG(DEBUG, sc, "Found errors on BMAC");
 				vars->link_up = 0;
 				vars->phy_flags |= PHY_HALF_OPEN_CONN_FLAG;
 				vars->link_status &= ~LINK_STATUS_LINK_UP;
@@ -6274,19 +6279,19 @@ elink_status_t elink_link_update(struct elink_params * params,
 	if (USES_WARPCORE(sc))
 		elink_set_aer_mmd(params, &params->phy[ELINK_INT_PHY]);
 
-	PMD_DRV_LOG(DEBUG, "port %x, XGXS?%x, int_status 0x%x",
+	PMD_DRV_LOG(DEBUG, sc, "port %x, XGXS?%x, int_status 0x%x",
 		    port, (vars->phy_flags & PHY_XGXS_FLAG),
 		    REG_RD(sc, NIG_REG_STATUS_INTERRUPT_PORT0 + port * 4));
 
 	is_mi_int = (uint8_t) (REG_RD(sc, NIG_REG_EMAC0_STATUS_MISC_MI_INT +
 				      port * 0x18) > 0);
-	PMD_DRV_LOG(DEBUG, "int_mask 0x%x MI_INT %x, SERDES_LINK %x",
+	PMD_DRV_LOG(DEBUG, sc, "int_mask 0x%x MI_INT %x, SERDES_LINK %x",
 		    REG_RD(sc, NIG_REG_MASK_INTERRUPT_PORT0 + port * 4),
 		    is_mi_int,
 		    REG_RD(sc,
 			   NIG_REG_SERDES0_STATUS_LINK_STATUS + port * 0x3c));
 
-	PMD_DRV_LOG(DEBUG, " 10G %x, XGXS_LINK %x",
+	PMD_DRV_LOG(DEBUG, sc, " 10G %x, XGXS_LINK %x",
 		    REG_RD(sc, NIG_REG_XGXS0_STATUS_LINK10G + port * 0x68),
 		    REG_RD(sc, NIG_REG_XGXS0_STATUS_LINK_STATUS + port * 0x68));
 
@@ -6310,10 +6315,10 @@ elink_status_t elink_link_update(struct elink_params * params,
 		cur_link_up = phy->read_status(phy, params,
 					       &phy_vars[phy_index]);
 		if (cur_link_up) {
-			PMD_DRV_LOG(DEBUG, "phy in index %d link is up",
+			PMD_DRV_LOG(DEBUG, sc, "phy in index %d link is up",
 				    phy_index);
 		} else {
-			PMD_DRV_LOG(DEBUG, "phy in index %d link is down",
+			PMD_DRV_LOG(DEBUG, sc, "phy in index %d link is down",
 				    phy_index);
 			continue;
 		}
@@ -6346,7 +6351,7 @@ elink_status_t elink_link_update(struct elink_params * params,
 				 * to link up by itself (using configuration)
 				 * - DEFAULT should be overriden during initialiazation
 				 */
-				PMD_DRV_LOG(DEBUG, "Invalid link indication"
+				PMD_DRV_LOG(DEBUG, sc, "Invalid link indication"
 					    "mpc=0x%x. DISABLING LINK !!!",
 					    params->multi_phy_config);
 				ext_phy_link_up = 0;
@@ -6384,7 +6389,7 @@ elink_status_t elink_link_update(struct elink_params * params,
 		 */
 		if (active_external_phy == ELINK_EXT_PHY1) {
 			if (params->phy[ELINK_EXT_PHY2].phy_specific_func) {
-				PMD_DRV_LOG(DEBUG, "Disabling TX on EXT_PHY2");
+				PMD_DRV_LOG(DEBUG, sc, "Disabling TX on EXT_PHY2");
 				params->phy[ELINK_EXT_PHY2].
 				    phy_specific_func(&params->
 						      phy[ELINK_EXT_PHY2],
@@ -6402,7 +6407,7 @@ elink_status_t elink_link_update(struct elink_params * params,
 
 		vars->eee_status = phy_vars[active_external_phy].eee_status;
 
-		PMD_DRV_LOG(DEBUG, "Active external phy selected: %x",
+		PMD_DRV_LOG(DEBUG, sc, "Active external phy selected: %x",
 			    active_external_phy);
 	}
 
@@ -6416,7 +6421,7 @@ elink_status_t elink_link_update(struct elink_params * params,
 			break;
 		}
 	}
-	PMD_DRV_LOG(DEBUG, "vars->flow_ctrl = 0x%x, vars->link_status = 0x%x,"
+	PMD_DRV_LOG(DEBUG, sc, "vars->flow_ctrl = 0x%x, vars->link_status = 0x%x,"
 		    " ext_phy_line_speed = %d", vars->flow_ctrl,
 		    vars->link_status, ext_phy_line_speed);
 	/* Upon link speed change set the NIG into drain mode. Comes to
@@ -6427,7 +6432,7 @@ elink_status_t elink_link_update(struct elink_params * params,
 	if (vars->phy_link_up) {
 		if (!(ELINK_SINGLE_MEDIA_DIRECT(params)) && ext_phy_link_up &&
 		    (ext_phy_line_speed != vars->line_speed)) {
-			PMD_DRV_LOG(DEBUG, "Internal link speed %d is"
+			PMD_DRV_LOG(DEBUG, sc, "Internal link speed %d is"
 				    " different than the external"
 				    " link speed %d", vars->line_speed,
 				    ext_phy_line_speed);
@@ -6453,7 +6458,7 @@ elink_status_t elink_link_update(struct elink_params * params,
 	 * initialize it
 	 */
 	if (!(ELINK_SINGLE_MEDIA_DIRECT(params))) {
-		PMD_DRV_LOG(DEBUG, "ext_phy_link_up = %d, int_link_up = %d,"
+		PMD_DRV_LOG(DEBUG, sc, "ext_phy_link_up = %d, int_link_up = %d,"
 			    " init_preceding = %d", ext_phy_link_up,
 			    vars->phy_link_up,
 			    params->phy[ELINK_EXT_PHY1].flags &
@@ -6518,7 +6523,7 @@ static void elink_save_spirom_version(struct bnx2x_softc *sc,
 				      __rte_unused uint8_t port,
 				      uint32_t spirom_ver, uint32_t ver_addr)
 {
-	PMD_DRV_LOG(DEBUG, "FW version 0x%x:0x%x for port %d",
+	PMD_DRV_LOG(DEBUG, sc, "FW version 0x%x:0x%x for port %d",
 		    (uint16_t) (spirom_ver >> 16), (uint16_t) spirom_ver, port);
 
 	if (ver_addr)
@@ -6584,7 +6589,7 @@ static void elink_8073_resolve_fc(struct elink_phy *phy,
 				 MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) >> 7;
 
 		elink_pause_resolve(vars, pause_result);
-		PMD_DRV_LOG(DEBUG, "Ext PHY CL37 pause result 0x%x",
+		PMD_DRV_LOG(DEBUG, sc, "Ext PHY CL37 pause result 0x%x",
 			    pause_result);
 	}
 }
@@ -6628,7 +6633,7 @@ static elink_status_t elink_8073_8727_external_rom_boot(struct bnx2x_softc *sc,
 	do {
 		count++;
 		if (count > 300) {
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "elink_8073_8727_external_rom_boot port %x:"
 				    "Download failed. fw version = 0x%x",
 				    port, fw_ver1);
@@ -6653,7 +6658,7 @@ static elink_status_t elink_8073_8727_external_rom_boot(struct bnx2x_softc *sc,
 			 MDIO_PMA_DEVAD, MDIO_PMA_REG_MISC_CTRL1, 0x0000);
 	elink_save_bnx2x_spirom_ver(sc, phy, port);
 
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 		    "elink_8073_8727_external_rom_boot port %x:"
 		    "Download complete. fw version = 0x%x", port, fw_ver1);
 
@@ -6714,10 +6719,10 @@ static elink_status_t elink_8073_xaui_wa(struct bnx2x_softc *sc,
 		 * these bits indicate 2.5G or 1G link up).
 		 */
 		if (!(val & (1 << 14)) || !(val & (1 << 13))) {
-			PMD_DRV_LOG(DEBUG, "XAUI work-around not required");
+			PMD_DRV_LOG(DEBUG, sc, "XAUI work-around not required");
 			return ELINK_STATUS_OK;
 		} else if (!(val & (1 << 15))) {
-			PMD_DRV_LOG(DEBUG, "bit 15 went off");
+			PMD_DRV_LOG(DEBUG, sc, "bit 15 went off");
 			/* If bit 15 is 0, then poll Dev1, Reg $C841 until it's
 			 * MSB (bit15) goes to 1 (indicating that the XAUI
 			 * workaround has completed), then continue on with
@@ -6729,7 +6734,7 @@ static elink_status_t elink_8073_xaui_wa(struct bnx2x_softc *sc,
 						MDIO_PMA_REG_8073_XAUI_WA,
 						&val);
 				if (val & (1 << 15)) {
-					PMD_DRV_LOG(DEBUG,
+					PMD_DRV_LOG(DEBUG, sc,
 						    "XAUI workaround has completed");
 					return ELINK_STATUS_OK;
 				}
@@ -6739,7 +6744,7 @@ static elink_status_t elink_8073_xaui_wa(struct bnx2x_softc *sc,
 		}
 		DELAY(1000 * 3);
 	}
-	PMD_DRV_LOG(DEBUG, "Warning: XAUI work-around timeout !!!");
+	PMD_DRV_LOG(DEBUG, sc, "Warning: XAUI work-around timeout !!!");
 	return ELINK_STATUS_ERROR;
 }
 
@@ -6781,7 +6786,7 @@ static void elink_8073_set_pause_cl37(struct elink_params *params,
 	    MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH) {
 		cl37_val |= MDIO_COMBO_IEEE0_AUTO_NEG_ADV_PAUSE_BOTH;
 	}
-	PMD_DRV_LOG(DEBUG, "Ext phy AN advertize cl37 0x%x", cl37_val);
+	PMD_DRV_LOG(DEBUG, sc, "Ext phy AN advertize cl37 0x%x", cl37_val);
 
 	elink_cl45_write(sc, phy,
 			 MDIO_AN_DEVAD, MDIO_AN_REG_CL37_FC_LD, cl37_val);
@@ -6812,7 +6817,7 @@ static uint8_t elink_8073_config_init(struct elink_phy *phy,
 	struct bnx2x_softc *sc = params->sc;
 	uint16_t val = 0, tmp1;
 	uint8_t gpio_port;
-	PMD_DRV_LOG(DEBUG, "Init 8073");
+	PMD_DRV_LOG(DEBUG, sc, "Init 8073");
 
 	if (CHIP_IS_E2(sc))
 		gpio_port = SC_PATH(sc);
@@ -6833,12 +6838,12 @@ static uint8_t elink_8073_config_init(struct elink_phy *phy,
 
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_RXSTAT, &tmp1);
 
-	PMD_DRV_LOG(DEBUG, "Before rom RX_ALARM(port1): 0x%x", tmp1);
+	PMD_DRV_LOG(DEBUG, sc, "Before rom RX_ALARM(port1): 0x%x", tmp1);
 
 	/* Swap polarity if required - Must be done only in non-1G mode */
 	if (params->lane_config & PORT_HW_CFG_SWAP_PHY_POLARITY_ENABLED) {
 		/* Configure the 8073 to swap _P and _N of the KR lines */
-		PMD_DRV_LOG(DEBUG, "Swapping polarity for the 8073");
+		PMD_DRV_LOG(DEBUG, sc, "Swapping polarity for the 8073");
 		/* 10G Rx/Tx and 1G Tx signal polarity swap */
 		elink_cl45_read(sc, phy,
 				MDIO_PMA_DEVAD,
@@ -6860,11 +6865,11 @@ static uint8_t elink_8073_config_init(struct elink_phy *phy,
 				MDIO_AN_DEVAD, MDIO_AN_REG_8073_BAM, &val);
 		elink_cl45_write(sc, phy,
 				 MDIO_AN_DEVAD, MDIO_AN_REG_8073_BAM, val | 1);
-		PMD_DRV_LOG(DEBUG, "Enable CL37 BAM on KR");
+		PMD_DRV_LOG(DEBUG, sc, "Enable CL37 BAM on KR");
 	}
 	if (params->loopback_mode == ELINK_LOOPBACK_EXT) {
 		elink_807x_force_10G(sc, phy);
-		PMD_DRV_LOG(DEBUG, "Forced speed 10G on 807X");
+		PMD_DRV_LOG(DEBUG, sc, "Forced speed 10G on 807X");
 		return ELINK_STATUS_OK;
 	} else {
 		elink_cl45_write(sc, phy,
@@ -6890,7 +6895,7 @@ static uint8_t elink_8073_config_init(struct elink_phy *phy,
 		    (PORT_HW_CFG_SPEED_CAPABILITY_D0_1G |
 		     PORT_HW_CFG_SPEED_CAPABILITY_D0_2_5G))
 			val |= (1 << 5);
-		PMD_DRV_LOG(DEBUG, "807x autoneg val = 0x%x", val);
+		PMD_DRV_LOG(DEBUG, sc, "807x autoneg val = 0x%x", val);
 	}
 
 	elink_cl45_write(sc, phy, MDIO_AN_DEVAD, MDIO_AN_REG_ADV, val);
@@ -6904,13 +6909,13 @@ static uint8_t elink_8073_config_init(struct elink_phy *phy,
 		elink_cl45_read(sc, phy,
 				MDIO_PMA_DEVAD, MDIO_PMA_REG_8073_CHIP_REV,
 				&phy_ver);
-		PMD_DRV_LOG(DEBUG, "Add 2.5G");
+		PMD_DRV_LOG(DEBUG, sc, "Add 2.5G");
 		if (phy_ver > 0)
 			tmp1 |= 1;
 		else
 			tmp1 &= 0xfffe;
 	} else {
-		PMD_DRV_LOG(DEBUG, "Disable 2.5G");
+		PMD_DRV_LOG(DEBUG, sc, "Disable 2.5G");
 		tmp1 &= 0xfffe;
 	}
 
@@ -6944,7 +6949,7 @@ static uint8_t elink_8073_config_init(struct elink_phy *phy,
 	/* Restart autoneg */
 	DELAY(1000 * 500);
 	elink_cl45_write(sc, phy, MDIO_AN_DEVAD, MDIO_AN_REG_CTRL, 0x1200);
-	PMD_DRV_LOG(DEBUG, "807x Autoneg Restart: Advertise 1G=%x, 10G=%x",
+	PMD_DRV_LOG(DEBUG, sc, "807x Autoneg Restart: Advertise 1G=%x, 10G=%x",
 		    ((val & (1 << 5)) > 0), ((val & (1 << 7)) > 0));
 	return ELINK_STATUS_OK;
 }
@@ -6961,12 +6966,12 @@ static uint8_t elink_8073_read_status(struct elink_phy *phy,
 
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_STAT, &val1);
 
-	PMD_DRV_LOG(DEBUG, "8703 LASI status 0x%x", val1);
+	PMD_DRV_LOG(DEBUG, sc, "8703 LASI status 0x%x", val1);
 
 	/* Clear the interrupt LASI status register */
 	elink_cl45_read(sc, phy, MDIO_PCS_DEVAD, MDIO_PCS_REG_STATUS, &val2);
 	elink_cl45_read(sc, phy, MDIO_PCS_DEVAD, MDIO_PCS_REG_STATUS, &val1);
-	PMD_DRV_LOG(DEBUG, "807x PCS status 0x%x->0x%x", val2, val1);
+	PMD_DRV_LOG(DEBUG, sc, "807x PCS status 0x%x->0x%x", val2, val1);
 	/* Clear MSG-OUT */
 	elink_cl45_read(sc, phy,
 			MDIO_PMA_DEVAD, MDIO_PMA_REG_M8051_MSGOUT_REG, &val1);
@@ -6974,16 +6979,16 @@ static uint8_t elink_8073_read_status(struct elink_phy *phy,
 	/* Check the LASI */
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_RXSTAT, &val2);
 
-	PMD_DRV_LOG(DEBUG, "KR 0x9003 0x%x", val2);
+	PMD_DRV_LOG(DEBUG, sc, "KR 0x9003 0x%x", val2);
 
 	/* Check the link status */
 	elink_cl45_read(sc, phy, MDIO_PCS_DEVAD, MDIO_PCS_REG_STATUS, &val2);
-	PMD_DRV_LOG(DEBUG, "KR PCS status 0x%x", val2);
+	PMD_DRV_LOG(DEBUG, sc, "KR PCS status 0x%x", val2);
 
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val2);
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val1);
 	link_up = ((val1 & 4) == 4);
-	PMD_DRV_LOG(DEBUG, "PMA_REG_STATUS=0x%x", val1);
+	PMD_DRV_LOG(DEBUG, sc, "PMA_REG_STATUS=0x%x", val1);
 
 	if (link_up && ((phy->req_line_speed != ELINK_SPEED_10000))) {
 		if (elink_8073_xaui_wa(sc, phy) != 0)
@@ -6997,7 +7002,7 @@ static uint8_t elink_8073_read_status(struct elink_phy *phy,
 	/* Check the link status on 1.1.2 */
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val2);
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val1);
-	PMD_DRV_LOG(DEBUG, "KR PMA status 0x%x->0x%x,"
+	PMD_DRV_LOG(DEBUG, sc, "KR PMA status 0x%x->0x%x,"
 		    "an_link_status=0x%x", val2, val1, an1000_status);
 
 	link_up = (((val1 & 4) == 4) || (an1000_status & (1 << 1)));
@@ -7023,21 +7028,21 @@ static uint8_t elink_8073_read_status(struct elink_phy *phy,
 	if ((link_status & (1 << 2)) && (!(link_status & (1 << 15)))) {
 		link_up = 1;
 		vars->line_speed = ELINK_SPEED_10000;
-		PMD_DRV_LOG(DEBUG, "port %x: External link up in 10G",
+		PMD_DRV_LOG(DEBUG, sc, "port %x: External link up in 10G",
 			    params->port);
 	} else if ((link_status & (1 << 1)) && (!(link_status & (1 << 14)))) {
 		link_up = 1;
 		vars->line_speed = ELINK_SPEED_2500;
-		PMD_DRV_LOG(DEBUG, "port %x: External link up in 2.5G",
+		PMD_DRV_LOG(DEBUG, sc, "port %x: External link up in 2.5G",
 			    params->port);
 	} else if ((link_status & (1 << 0)) && (!(link_status & (1 << 13)))) {
 		link_up = 1;
 		vars->line_speed = ELINK_SPEED_1000;
-		PMD_DRV_LOG(DEBUG, "port %x: External link up in 1G",
+		PMD_DRV_LOG(DEBUG, sc, "port %x: External link up in 1G",
 			    params->port);
 	} else {
 		link_up = 0;
-		PMD_DRV_LOG(DEBUG, "port %x: External link is down",
+		PMD_DRV_LOG(DEBUG, sc, "port %x: External link is down",
 			    params->port);
 	}
 
@@ -7052,7 +7057,7 @@ static uint8_t elink_8073_read_status(struct elink_phy *phy,
 			 * when it`s in 10G mode.
 			 */
 			if (vars->line_speed == ELINK_SPEED_1000) {
-				PMD_DRV_LOG(DEBUG, "Swapping 1G polarity for"
+				PMD_DRV_LOG(DEBUG, sc, "Swapping 1G polarity for"
 					    "the 8073");
 				val1 |= (1 << 3);
 			} else
@@ -7091,7 +7096,7 @@ static void elink_8073_link_reset(__rte_unused struct elink_phy *phy,
 		gpio_port = SC_PATH(sc);
 	else
 		gpio_port = params->port;
-	PMD_DRV_LOG(DEBUG, "Setting 8073 port %d into low power mode",
+	PMD_DRV_LOG(DEBUG, sc, "Setting 8073 port %d into low power mode",
 		    gpio_port);
 	elink_cb_gpio_write(sc, MISC_REGISTERS_GPIO_2,
 			    MISC_REGISTERS_GPIO_OUTPUT_LOW, gpio_port);
@@ -7106,7 +7111,7 @@ static uint8_t elink_8705_config_init(struct elink_phy *phy,
 					     *vars)
 {
 	struct bnx2x_softc *sc = params->sc;
-	PMD_DRV_LOG(DEBUG, "init 8705");
+	PMD_DRV_LOG(DEBUG, sc, "init 8705");
 	/* Restore normal power mode */
 	elink_cb_gpio_write(sc, MISC_REGISTERS_GPIO_2,
 			    MISC_REGISTERS_GPIO_OUTPUT_HIGH, params->port);
@@ -7134,21 +7139,21 @@ static uint8_t elink_8705_read_status(struct elink_phy *phy,
 	uint8_t link_up = 0;
 	uint16_t val1, rx_sd;
 	struct bnx2x_softc *sc = params->sc;
-	PMD_DRV_LOG(DEBUG, "read status 8705");
+	PMD_DRV_LOG(DEBUG, sc, "read status 8705");
 	elink_cl45_read(sc, phy,
 			MDIO_WIS_DEVAD, MDIO_WIS_REG_LASI_STATUS, &val1);
-	PMD_DRV_LOG(DEBUG, "8705 LASI status 0x%x", val1);
+	PMD_DRV_LOG(DEBUG, sc, "8705 LASI status 0x%x", val1);
 
 	elink_cl45_read(sc, phy,
 			MDIO_WIS_DEVAD, MDIO_WIS_REG_LASI_STATUS, &val1);
-	PMD_DRV_LOG(DEBUG, "8705 LASI status 0x%x", val1);
+	PMD_DRV_LOG(DEBUG, sc, "8705 LASI status 0x%x", val1);
 
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_SD, &rx_sd);
 
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, 0xc809, &val1);
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, 0xc809, &val1);
 
-	PMD_DRV_LOG(DEBUG, "8705 1.c809 val=0x%x", val1);
+	PMD_DRV_LOG(DEBUG, sc, "8705 1.c809 val=0x%x", val1);
 	link_up = ((rx_sd & 0x1) && (val1 & (1 << 9))
 		   && ((val1 & (1 << 8)) == 0));
 	if (link_up) {
@@ -7172,13 +7177,13 @@ static void elink_set_disable_pmd_transmit(struct elink_params *params,
 	if (pmd_dis) {
 		if (params->feature_config_flags &
 		    ELINK_FEATURE_CONFIG_BC_SUPPORTS_SFP_TX_DISABLED) {
-			PMD_DRV_LOG(DEBUG, "Disabling PMD transmitter");
+			PMD_DRV_LOG(DEBUG, sc, "Disabling PMD transmitter");
 		} else {
-			PMD_DRV_LOG(DEBUG, "NOT disabling PMD transmitter");
+			PMD_DRV_LOG(DEBUG, sc, "NOT disabling PMD transmitter");
 			return;
 		}
 	} else {
-		PMD_DRV_LOG(DEBUG, "Enabling PMD transmitter");
+		PMD_DRV_LOG(DEBUG, sc, "Enabling PMD transmitter");
 	}
 	elink_cl45_write(sc, phy,
 			 MDIO_PMA_DEVAD, MDIO_PMA_REG_TX_DISABLE, pmd_dis);
@@ -7212,7 +7217,7 @@ static void elink_sfp_e1e2_set_transmitter(struct elink_params *params,
 			    offsetof(struct shmem_region,
 				     dev_info.port_hw_config[port].sfp_ctrl)) &
 	    PORT_HW_CFG_TX_LASER_MASK;
-	PMD_DRV_LOG(DEBUG, "Setting transmitter tx_en=%x for port %x "
+	PMD_DRV_LOG(DEBUG, sc, "Setting transmitter tx_en=%x for port %x "
 		    "mode = %x", tx_en, port, tx_en_mode);
 	switch (tx_en_mode) {
 	case PORT_HW_CFG_TX_LASER_MDIO:
@@ -7248,7 +7253,8 @@ static void elink_sfp_e1e2_set_transmitter(struct elink_params *params,
 			break;
 		}
 	default:
-		PMD_DRV_LOG(DEBUG, "Invalid TX_LASER_MDIO 0x%x", tx_en_mode);
+		PMD_DRV_LOG(DEBUG, sc,
+			    "Invalid TX_LASER_MDIO 0x%x", tx_en_mode);
 		break;
 	}
 }
@@ -7257,7 +7263,7 @@ static void elink_sfp_set_transmitter(struct elink_params *params,
 				      struct elink_phy *phy, uint8_t tx_en)
 {
 	struct bnx2x_softc *sc = params->sc;
-	PMD_DRV_LOG(DEBUG, "Setting SFP+ transmitter to %d", tx_en);
+	PMD_DRV_LOG(DEBUG, sc, "Setting SFP+ transmitter to %d", tx_en);
 	if (CHIP_IS_E3(sc))
 		elink_sfp_e3_set_transmitter(params, phy, tx_en);
 	else
@@ -7278,7 +7284,7 @@ static elink_status_t elink_8726_read_sfp_module_eeprom(struct elink_phy *phy,
 	uint16_t val = 0;
 	uint16_t i;
 	if (byte_cnt > ELINK_SFP_EEPROM_PAGE_SIZE) {
-		PMD_DRV_LOG(DEBUG, "Reading from eeprom is limited to 0xf");
+		PMD_DRV_LOG(DEBUG, sc, "Reading from eeprom is limited to 0xf");
 		return ELINK_STATUS_ERROR;
 	}
 	/* Set the read command byte count */
@@ -7309,7 +7315,7 @@ static elink_status_t elink_8726_read_sfp_module_eeprom(struct elink_phy *phy,
 
 	if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) !=
 	    MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE) {
-		PMD_DRV_LOG(DEBUG,
+		PMD_DRV_LOG(DEBUG, sc,
 			    "Got bad status 0x%x when reading from SFP+ EEPROM",
 			    (val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK));
 		return ELINK_STATUS_ERROR;
@@ -7350,7 +7356,7 @@ static void elink_warpcore_power_module(struct elink_params *params,
 
 	if (pin_cfg == PIN_CFG_NA)
 		return;
-	PMD_DRV_LOG(DEBUG, "Setting SFP+ module power to %d using pin cfg %d",
+	PMD_DRV_LOG(DEBUG, sc, "Setting SFP+ module power to %d using pin cfg %d",
 		    power, pin_cfg);
 	/* Low ==> corresponding SFP+ module is powered
 	 * high ==> the SFP+ module is powered down
@@ -7375,7 +7381,7 @@ static elink_status_t elink_warpcore_read_sfp_module_eeprom(__rte_unused struct
 	struct bnx2x_softc *sc = params->sc;
 
 	if (byte_cnt > ELINK_SFP_EEPROM_PAGE_SIZE) {
-		PMD_DRV_LOG(DEBUG,
+		PMD_DRV_LOG(DEBUG, sc,
 			    "Reading from eeprom is limited to 16 bytes");
 		return ELINK_STATUS_ERROR;
 	}
@@ -7417,7 +7423,7 @@ static elink_status_t elink_8727_read_sfp_module_eeprom(struct elink_phy *phy,
 	uint16_t val, i;
 
 	if (byte_cnt > ELINK_SFP_EEPROM_PAGE_SIZE) {
-		PMD_DRV_LOG(DEBUG, "Reading from eeprom is limited to 0xf");
+		PMD_DRV_LOG(DEBUG, sc, "Reading from eeprom is limited to 0xf");
 		return ELINK_STATUS_ERROR;
 	}
 
@@ -7471,7 +7477,7 @@ static elink_status_t elink_8727_read_sfp_module_eeprom(struct elink_phy *phy,
 
 	if ((val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK) !=
 	    MDIO_PMA_REG_SFP_TWO_WIRE_STATUS_COMPLETE) {
-		PMD_DRV_LOG(DEBUG,
+		PMD_DRV_LOG(DEBUG, sc,
 			    "Got bad status 0x%x when reading from SFP+ EEPROM",
 			    (val & MDIO_PMA_REG_SFP_TWO_WIRE_CTRL_STATUS_MASK));
 		return ELINK_STATUS_TIMEOUT;
@@ -7512,7 +7518,8 @@ static elink_status_t elink_read_sfp_module_eeprom(struct elink_phy *phy,
 	read_sfp_module_eeprom_func_p read_func;
 
 	if ((dev_addr != 0xa0) && (dev_addr != 0xa2)) {
-		PMD_DRV_LOG(DEBUG, "invalid dev_addr 0x%x", dev_addr);
+		PMD_DRV_LOG(DEBUG, params->sc,
+			    "invalid dev_addr 0x%x", dev_addr);
 		return ELINK_STATUS_ERROR;
 	}
 
@@ -7558,7 +7565,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
 					 ELINK_I2C_DEV_ADDR_A0,
 					 ELINK_SFP_EEPROM_CON_TYPE_ADDR,
 					 2, (uint8_t *) val) != 0) {
-		PMD_DRV_LOG(DEBUG, "Failed to read from SFP+ module EEPROM");
+		PMD_DRV_LOG(DEBUG, sc, "Failed to read from SFP+ module EEPROM");
 		return ELINK_STATUS_ERROR;
 	}
 
@@ -7577,7 +7584,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
 							 1,
 							 &copper_module_type) !=
 			    0) {
-				PMD_DRV_LOG(DEBUG,
+				PMD_DRV_LOG(DEBUG, sc,
 					    "Failed to read copper-cable-type"
 					    " from SFP+ EEPROM");
 				return ELINK_STATUS_ERROR;
@@ -7585,7 +7592,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
 
 			if (copper_module_type &
 			    ELINK_SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_ACTIVE) {
-				PMD_DRV_LOG(DEBUG,
+				PMD_DRV_LOG(DEBUG, sc,
 					    "Active Copper cable detected");
 				if (phy->type ==
 				    PORT_HW_CFG_XGXS_EXT_PHY_TYPE_DIRECT)
@@ -7595,11 +7602,11 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
 			} else if (copper_module_type &
 				   ELINK_SFP_EEPROM_FC_TX_TECH_BITMASK_COPPER_PASSIVE)
 			{
-				PMD_DRV_LOG(DEBUG,
+				PMD_DRV_LOG(DEBUG, sc,
 					    "Passive Copper cable detected");
 				*edc_mode = ELINK_EDC_MODE_PASSIVE_DAC;
 			} else {
-				PMD_DRV_LOG(DEBUG,
+				PMD_DRV_LOG(DEBUG, sc,
 					    "Unknown copper-cable-type 0x%x !!!",
 					    copper_module_type);
 				return ELINK_STATUS_ERROR;
@@ -7612,7 +7619,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
 		if ((val[1] & (ELINK_SFP_EEPROM_COMP_CODE_SR_MASK |
 			       ELINK_SFP_EEPROM_COMP_CODE_LR_MASK |
 			       ELINK_SFP_EEPROM_COMP_CODE_LRM_MASK)) == 0) {
-			PMD_DRV_LOG(DEBUG, "1G SFP module detected");
+			PMD_DRV_LOG(DEBUG, sc, "1G SFP module detected");
 			gport = params->port;
 			phy->media_type = ELINK_ETH_PHY_SFP_1G_FIBER;
 			if (phy->req_line_speed != ELINK_SPEED_1000) {
@@ -7628,7 +7635,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
 			}
 		} else {
 			int idx, cfg_idx = 0;
-			PMD_DRV_LOG(DEBUG, "10G Optic module detected");
+			PMD_DRV_LOG(DEBUG, sc, "10G Optic module detected");
 			for (idx = ELINK_INT_PHY; idx < ELINK_MAX_PHYS; idx++) {
 				if (params->phy[idx].type == phy->type) {
 					cfg_idx = ELINK_LINK_CONFIG_IDX(idx);
@@ -7640,7 +7647,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
 		}
 		break;
 	default:
-		PMD_DRV_LOG(DEBUG, "Unable to determine module type 0x%x !!!",
+		PMD_DRV_LOG(DEBUG, sc, "Unable to determine module type 0x%x !!!",
 			    val[0]);
 		return ELINK_STATUS_ERROR;
 	}
@@ -7670,7 +7677,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
 						 ELINK_SFP_EEPROM_OPTIONS_ADDR,
 						 ELINK_SFP_EEPROM_OPTIONS_SIZE,
 						 options) != 0) {
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "Failed to read Option field from module EEPROM");
 			return ELINK_STATUS_ERROR;
 		}
@@ -7679,7 +7686,7 @@ static elink_status_t elink_get_edc_mode(struct elink_phy *phy,
 		else
 			*edc_mode = ELINK_EDC_MODE_LIMITING;
 	}
-	PMD_DRV_LOG(DEBUG, "EDC mode is set to 0x%x", *edc_mode);
+	PMD_DRV_LOG(DEBUG, sc, "EDC mode is set to 0x%x", *edc_mode);
 	return ELINK_STATUS_OK;
 }
 
@@ -7701,7 +7708,7 @@ static elink_status_t elink_verify_sfp_module(struct elink_phy *phy,
 			      config));
 	if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
 	    PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_NO_ENFORCEMENT) {
-		PMD_DRV_LOG(DEBUG, "NOT enforcing module verification");
+		PMD_DRV_LOG(DEBUG, sc, "NOT enforcing module verification");
 		return ELINK_STATUS_OK;
 	}
 
@@ -7713,21 +7720,21 @@ static elink_status_t elink_verify_sfp_module(struct elink_phy *phy,
 		   ELINK_FEATURE_CONFIG_BC_SUPPORTS_OPT_MDL_VRFY) {
 		/* Use first phy request only in case of non-dual media */
 		if (ELINK_DUAL_MEDIA(params)) {
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "FW does not support OPT MDL verification");
 			return ELINK_STATUS_ERROR;
 		}
 		cmd = DRV_MSG_CODE_VRFY_FIRST_PHY_OPT_MDL;
 	} else {
 		/* No support in OPT MDL detection */
-		PMD_DRV_LOG(DEBUG, "FW does not support OPT MDL verification");
+		PMD_DRV_LOG(DEBUG, sc, "FW does not support OPT MDL verification");
 		return ELINK_STATUS_ERROR;
 	}
 
 	fw_cmd_param = ELINK_FW_PARAM_SET(phy->addr, phy->type, phy->mdio_ctrl);
 	fw_resp = elink_cb_fw_command(sc, cmd, fw_cmd_param);
 	if (fw_resp == FW_MSG_CODE_VRFY_OPT_MDL_SUCCESS) {
-		PMD_DRV_LOG(DEBUG, "Approved module");
+		PMD_DRV_LOG(DEBUG, sc, "Approved module");
 		return ELINK_STATUS_OK;
 	}
 
@@ -7783,7 +7790,7 @@ static elink_status_t elink_wait_for_sfp_module_initialized(struct elink_phy
 							  ELINK_I2C_DEV_ADDR_A0,
 							  1, 1, &val);
 		if (rc == 0) {
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, params->sc,
 				    "SFP+ module initialization took %d ms",
 				    timeout * 5);
 			return ELINK_STATUS_OK;
@@ -7834,17 +7841,18 @@ static elink_status_t elink_8726_set_limiting_mode(struct bnx2x_softc *sc,
 	elink_cl45_read(sc, phy,
 			MDIO_PMA_DEVAD,
 			MDIO_PMA_REG_ROM_VER2, &cur_limiting_mode);
-	PMD_DRV_LOG(DEBUG, "Current Limiting mode is 0x%x", cur_limiting_mode);
+	PMD_DRV_LOG(DEBUG, sc,
+		    "Current Limiting mode is 0x%x", cur_limiting_mode);
 
 	if (edc_mode == ELINK_EDC_MODE_LIMITING) {
-		PMD_DRV_LOG(DEBUG, "Setting LIMITING MODE");
+		PMD_DRV_LOG(DEBUG, sc, "Setting LIMITING MODE");
 		elink_cl45_write(sc, phy,
 				 MDIO_PMA_DEVAD,
 				 MDIO_PMA_REG_ROM_VER2,
 				 ELINK_EDC_MODE_LIMITING);
 	} else {		/* LRM mode ( default ) */
 
-		PMD_DRV_LOG(DEBUG, "Setting LRM MODE");
+		PMD_DRV_LOG(DEBUG, sc, "Setting LRM MODE");
 
 		/* Changing to LRM mode takes quite few seconds. So do it only
 		 * if current mode is limiting (default is LRM)
@@ -7934,7 +7942,7 @@ static void elink_8727_specific_func(struct elink_phy *phy,
 				 val);
 		break;
 	default:
-		PMD_DRV_LOG(DEBUG, "Function 0x%x not supported by 8727",
+		PMD_DRV_LOG(DEBUG, sc, "Function 0x%x not supported by 8727",
 			    action);
 		return;
 	}
@@ -7962,14 +7970,14 @@ static void elink_set_e1e2_module_fault_led(struct elink_params *params,
 			uint8_t gpio_port = elink_get_gpio_port(params);
 			uint16_t gpio_pin = fault_led_gpio -
 			    PORT_HW_CFG_FAULT_MODULE_LED_GPIO0;
-			PMD_DRV_LOG(DEBUG, "Set fault module-detected led "
+			PMD_DRV_LOG(DEBUG, sc, "Set fault module-detected led "
 				    "pin %x port %x mode %x",
 				    gpio_pin, gpio_port, gpio_mode);
 			elink_cb_gpio_write(sc, gpio_pin, gpio_mode, gpio_port);
 		}
 		break;
 	default:
-		PMD_DRV_LOG(DEBUG, "Error: Invalid fault led mode 0x%x",
+		PMD_DRV_LOG(DEBUG, sc, "Error: Invalid fault led mode 0x%x",
 			    fault_led_gpio);
 	}
 }
@@ -7985,7 +7993,7 @@ static void elink_set_e3_module_fault_led(struct elink_params *params,
 				   dev_info.port_hw_config[port].e3_sfp_ctrl)) &
 		   PORT_HW_CFG_E3_FAULT_MDL_LED_MASK) >>
 	    PORT_HW_CFG_E3_FAULT_MDL_LED_SHIFT;
-	PMD_DRV_LOG(DEBUG, "Setting Fault LED to %d using pin cfg %d",
+	PMD_DRV_LOG(DEBUG, sc, "Setting Fault LED to %d using pin cfg %d",
 		    gpio_mode, pin_cfg);
 	elink_set_cfg_pin(sc, pin_cfg, gpio_mode);
 }
@@ -7994,7 +8002,8 @@ static void elink_set_sfp_module_fault_led(struct elink_params *params,
 					   uint8_t gpio_mode)
 {
 	struct bnx2x_softc *sc = params->sc;
-	PMD_DRV_LOG(DEBUG, "Setting SFP+ module fault LED to %d", gpio_mode);
+	PMD_DRV_LOG(DEBUG, sc,
+		    "Setting SFP+ module fault LED to %d", gpio_mode);
 	if (CHIP_IS_E3(sc)) {
 		/* Low ==> if SFP+ module is supported otherwise
 		 * High ==> if SFP+ module is not on the approved vendor list
@@ -8021,7 +8030,7 @@ static void elink_warpcore_hw_reset(__rte_unused struct elink_phy *phy,
 static void elink_power_sfp_module(struct elink_params *params,
 				   struct elink_phy *phy, uint8_t power)
 {
-	PMD_DRV_LOG(DEBUG, "Setting SFP+ power to %x", power);
+	PMD_DRV_LOG(DEBUG, params->sc, "Setting SFP+ power to %x", power);
 
 	switch (phy->type) {
 	case PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BNX2X8727:
@@ -8107,16 +8116,16 @@ static elink_status_t elink_sfp_module_detection(struct elink_phy *phy,
 				       config));
 	/* Enabled transmitter by default */
 	elink_sfp_set_transmitter(params, phy, 1);
-	PMD_DRV_LOG(DEBUG, "SFP+ module plugged in/out detected on port %d",
+	PMD_DRV_LOG(DEBUG, sc, "SFP+ module plugged in/out detected on port %d",
 		    params->port);
 	/* Power up module */
 	elink_power_sfp_module(params, phy, 1);
 	if (elink_get_edc_mode(phy, params, &edc_mode) != 0) {
-		PMD_DRV_LOG(DEBUG, "Failed to get valid module type");
+		PMD_DRV_LOG(DEBUG, sc, "Failed to get valid module type");
 		return ELINK_STATUS_ERROR;
 	} else if (elink_verify_sfp_module(phy, params) != 0) {
 		/* Check SFP+ module compatibility */
-		PMD_DRV_LOG(DEBUG, "Module verification failed!!");
+		PMD_DRV_LOG(DEBUG, sc, "Module verification failed!!");
 		rc = ELINK_STATUS_ERROR;
 		/* Turn on fault module-detected led */
 		elink_set_sfp_module_fault_led(params,
@@ -8125,7 +8134,7 @@ static elink_status_t elink_sfp_module_detection(struct elink_phy *phy,
 		/* Check if need to power down the SFP+ module */
 		if ((val & PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_MASK) ==
 		    PORT_FEAT_CFG_OPT_MDL_ENFRCMNT_POWER_DOWN) {
-			PMD_DRV_LOG(DEBUG, "Shutdown SFP+ module!!");
+			PMD_DRV_LOG(DEBUG, sc, "Shutdown SFP+ module!!");
 			elink_power_sfp_module(params, phy, 0);
 			return rc;
 		}
@@ -8166,7 +8175,7 @@ void elink_handle_module_detect_int(struct elink_params *params)
 	if (elink_get_mod_abs_int_cfg(sc, params->shmem_base,
 				      params->port, &gpio_num, &gpio_port) ==
 	    ELINK_STATUS_ERROR) {
-		PMD_DRV_LOG(DEBUG, "Failed to get MOD_ABS interrupt config");
+		PMD_DRV_LOG(DEBUG, sc, "Failed to get MOD_ABS interrupt config");
 		return;
 	}
 
@@ -8206,7 +8215,7 @@ void elink_handle_module_detect_int(struct elink_params *params)
 				}
 			}
 		} else {
-			PMD_DRV_LOG(DEBUG, "SFP+ module is not initialized");
+			PMD_DRV_LOG(DEBUG, sc, "SFP+ module is not initialized");
 		}
 	} else {
 		elink_cb_gpio_int_write(sc, gpio_num,
@@ -8251,7 +8260,7 @@ static uint8_t elink_8706_8726_read_status(struct elink_phy *phy,
 	uint8_t link_up = 0;
 	uint16_t val1, val2, rx_sd, pcs_status;
 	struct bnx2x_softc *sc = params->sc;
-	PMD_DRV_LOG(DEBUG, "XGXS 8706/8726");
+	PMD_DRV_LOG(DEBUG, sc, "XGXS 8706/8726");
 	/* Clear RX Alarm */
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_RXSTAT, &val2);
 
@@ -8261,7 +8270,8 @@ static uint8_t elink_8706_8726_read_status(struct elink_phy *phy,
 	/* Clear LASI indication */
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_STAT, &val1);
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_STAT, &val2);
-	PMD_DRV_LOG(DEBUG, "8706/8726 LASI status 0x%x--> 0x%x", val1, val2);
+	PMD_DRV_LOG(DEBUG, sc,
+		    "8706/8726 LASI status 0x%x--> 0x%x", val1, val2);
 
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_RX_SD, &rx_sd);
 	elink_cl45_read(sc, phy,
@@ -8269,7 +8279,7 @@ static uint8_t elink_8706_8726_read_status(struct elink_phy *phy,
 	elink_cl45_read(sc, phy, MDIO_AN_DEVAD, MDIO_AN_REG_LINK_STATUS, &val2);
 	elink_cl45_read(sc, phy, MDIO_AN_DEVAD, MDIO_AN_REG_LINK_STATUS, &val2);
 
-	PMD_DRV_LOG(DEBUG, "8706/8726 rx_sd 0x%x pcs_status 0x%x 1Gbps"
+	PMD_DRV_LOG(DEBUG, sc, "8706/8726 rx_sd 0x%x pcs_status 0x%x 1Gbps"
 		    " link_status 0x%x", rx_sd, pcs_status, val2);
 	/* Link is up if both bit 0 of pmd_rx_sd and bit 0 of pcs_status
 	 * are set, or if the autoneg bit 1 is set
@@ -8323,7 +8333,7 @@ static uint8_t elink_8706_config_init(struct elink_phy *phy,
 			break;
 		DELAY(1000 * 10);
 	}
-	PMD_DRV_LOG(DEBUG, "XGXS 8706 is initialized after %d ms", cnt);
+	PMD_DRV_LOG(DEBUG, sc, "XGXS 8706 is initialized after %d ms", cnt);
 	if ((params->feature_config_flags &
 	     ELINK_FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED)) {
 		uint8_t i;
@@ -8337,14 +8347,14 @@ static uint8_t elink_8706_config_init(struct elink_phy *phy,
 			val &= ~0x7;
 			/* Set control bits according to configuration */
 			val |= (phy->rx_preemphasis[i] & 0x7);
-			PMD_DRV_LOG(DEBUG, "Setting RX Equalizer to BNX2X8706"
+			PMD_DRV_LOG(DEBUG, sc, "Setting RX Equalizer to BNX2X8706"
 				    " reg 0x%x <-- val 0x%x", reg, val);
 			elink_cl45_write(sc, phy, MDIO_XS_DEVAD, reg, val);
 		}
 	}
 	/* Force speed */
 	if (phy->req_line_speed == ELINK_SPEED_10000) {
-		PMD_DRV_LOG(DEBUG, "XGXS 8706 force 10Gbps");
+		PMD_DRV_LOG(DEBUG, sc, "XGXS 8706 force 10Gbps");
 
 		elink_cl45_write(sc, phy,
 				 MDIO_PMA_DEVAD,
@@ -8358,7 +8368,7 @@ static uint8_t elink_8706_config_init(struct elink_phy *phy,
 		/* Force 1Gbps using autoneg with 1G advertisement */
 
 		/* Allow CL37 through CL73 */
-		PMD_DRV_LOG(DEBUG, "XGXS 8706 AutoNeg");
+		PMD_DRV_LOG(DEBUG, sc, "XGXS 8706 AutoNeg");
 		elink_cl45_write(sc, phy,
 				 MDIO_AN_DEVAD, MDIO_AN_REG_CL37_CL73, 0x040c);
 
@@ -8393,7 +8403,7 @@ static uint8_t elink_8706_config_init(struct elink_phy *phy,
 	& PORT_HW_CFG_TX_LASER_MASK;
 
 	if (tx_en_mode == PORT_HW_CFG_TX_LASER_GPIO0) {
-		PMD_DRV_LOG(DEBUG, "Enabling TXONOFF_PWRDN_DIS");
+		PMD_DRV_LOG(DEBUG, sc, "Enabling TXONOFF_PWRDN_DIS");
 		elink_cl45_read(sc, phy,
 				MDIO_PMA_DEVAD, MDIO_PMA_REG_DIGITAL_CTRL,
 				&tmp1);
@@ -8420,7 +8430,7 @@ static void elink_8726_config_loopback(struct elink_phy *phy,
 				       struct elink_params *params)
 {
 	struct bnx2x_softc *sc = params->sc;
-	PMD_DRV_LOG(DEBUG, "PMA/PMD ext_phy_loopback: 8726");
+	PMD_DRV_LOG(DEBUG, sc, "PMA/PMD ext_phy_loopback: 8726");
 	elink_cl45_write(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 0x0001);
 }
 
@@ -8472,7 +8482,7 @@ static uint8_t elink_8726_read_status(struct elink_phy *phy,
 				MDIO_PMA_DEVAD, MDIO_PMA_REG_PHY_IDENTIFIER,
 				&val1);
 		if (val1 & (1 << 15)) {
-			PMD_DRV_LOG(DEBUG, "Tx is disabled");
+			PMD_DRV_LOG(DEBUG, sc, "Tx is disabled");
 			link_up = 0;
 			vars->line_speed = 0;
 		}
@@ -8485,7 +8495,7 @@ static uint8_t elink_8726_config_init(struct elink_phy *phy,
 				      struct elink_vars *vars)
 {
 	struct bnx2x_softc *sc = params->sc;
-	PMD_DRV_LOG(DEBUG, "Initializing BNX2X8726");
+	PMD_DRV_LOG(DEBUG, sc, "Initializing BNX2X8726");
 
 	elink_cl45_write(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 1 << 15);
 	elink_wait_reset_complete(sc, phy, params);
@@ -8500,7 +8510,7 @@ static uint8_t elink_8726_config_init(struct elink_phy *phy,
 	elink_sfp_module_detection(phy, params);
 
 	if (phy->req_line_speed == ELINK_SPEED_1000) {
-		PMD_DRV_LOG(DEBUG, "Setting 1G force");
+		PMD_DRV_LOG(DEBUG, sc, "Setting 1G force");
 		elink_cl45_write(sc, phy,
 				 MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 0x40);
 		elink_cl45_write(sc, phy,
@@ -8515,7 +8525,7 @@ static uint8_t elink_8726_config_init(struct elink_phy *phy,
 		   ((phy->speed_cap_mask &
 		     PORT_HW_CFG_SPEED_CAPABILITY_D0_10G) !=
 		    PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) {
-		PMD_DRV_LOG(DEBUG, "Setting 1G clause37");
+		PMD_DRV_LOG(DEBUG, sc, "Setting 1G clause37");
 		/* Set Flow control */
 		elink_ext_phy_set_pause(params, phy, vars);
 		elink_cl45_write(sc, phy, MDIO_AN_DEVAD, MDIO_AN_REG_ADV, 0x20);
@@ -8543,7 +8553,7 @@ static uint8_t elink_8726_config_init(struct elink_phy *phy,
 	/* Set TX PreEmphasis if needed */
 	if ((params->feature_config_flags &
 	     ELINK_FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED)) {
-		PMD_DRV_LOG(DEBUG,
+		PMD_DRV_LOG(DEBUG, sc,
 			    "Setting TX_CTRL1 0x%x, TX_CTRL2 0x%x",
 			    phy->tx_preemphasis[0], phy->tx_preemphasis[1]);
 		elink_cl45_write(sc, phy,
@@ -8565,7 +8575,7 @@ static void elink_8726_link_reset(struct elink_phy *phy,
 				  struct elink_params *params)
 {
 	struct bnx2x_softc *sc = params->sc;
-	PMD_DRV_LOG(DEBUG, "elink_8726_link_reset port %d", params->port);
+	PMD_DRV_LOG(DEBUG, sc, "elink_8726_link_reset port %d", params->port);
 	/* Set serial boot control for external load */
 	elink_cl45_write(sc, phy,
 			 MDIO_PMA_DEVAD, MDIO_PMA_REG_GEN_CTRL, 0x0001);
@@ -8638,14 +8648,14 @@ static void elink_8727_config_speed(struct elink_phy *phy,
 	/* Set option 1G speed */
 	if ((phy->req_line_speed == ELINK_SPEED_1000) ||
 	    (phy->media_type == ELINK_ETH_PHY_SFP_1G_FIBER)) {
-		PMD_DRV_LOG(DEBUG, "Setting 1G force");
+		PMD_DRV_LOG(DEBUG, sc, "Setting 1G force");
 		elink_cl45_write(sc, phy,
 				 MDIO_PMA_DEVAD, MDIO_PMA_REG_CTRL, 0x40);
 		elink_cl45_write(sc, phy,
 				 MDIO_PMA_DEVAD, MDIO_PMA_REG_10G_CTRL2, 0xD);
 		elink_cl45_read(sc, phy,
 				MDIO_PMA_DEVAD, MDIO_PMA_REG_10G_CTRL2, &tmp1);
-		PMD_DRV_LOG(DEBUG, "1.7 = 0x%x", tmp1);
+		PMD_DRV_LOG(DEBUG, sc, "1.7 = 0x%x", tmp1);
 		/* Power down the XAUI until link is up in case of dual-media
 		 * and 1G
 		 */
@@ -8665,7 +8675,7 @@ static void elink_8727_config_speed(struct elink_phy *phy,
 		     PORT_HW_CFG_SPEED_CAPABILITY_D0_10G) !=
 		    PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) {
 
-		PMD_DRV_LOG(DEBUG, "Setting 1G clause37");
+		PMD_DRV_LOG(DEBUG, sc, "Setting 1G clause37");
 		elink_cl45_write(sc, phy,
 				 MDIO_AN_DEVAD, MDIO_AN_REG_8727_MISC_CTRL, 0);
 		elink_cl45_write(sc, phy,
@@ -8699,7 +8709,7 @@ static uint8_t elink_8727_config_init(struct elink_phy *phy,
 
 	elink_wait_reset_complete(sc, phy, params);
 
-	PMD_DRV_LOG(DEBUG, "Initializing BNX2X8727");
+	PMD_DRV_LOG(DEBUG, sc, "Initializing BNX2X8727");
 
 	elink_8727_specific_func(phy, params, ELINK_PHY_INIT);
 	/* Initially configure MOD_ABS to interrupt when module is
@@ -8732,7 +8742,7 @@ static uint8_t elink_8727_config_init(struct elink_phy *phy,
 	/* Set TX PreEmphasis if needed */
 	if ((params->feature_config_flags &
 	     ELINK_FEATURE_CONFIG_OVERRIDE_PREEMPHASIS_ENABLED)) {
-		PMD_DRV_LOG(DEBUG, "Setting TX_CTRL1 0x%x, TX_CTRL2 0x%x",
+		PMD_DRV_LOG(DEBUG, sc, "Setting TX_CTRL1 0x%x, TX_CTRL2 0x%x",
 			    phy->tx_preemphasis[0], phy->tx_preemphasis[1]);
 		elink_cl45_write(sc, phy,
 				 MDIO_PMA_DEVAD, MDIO_PMA_REG_8727_TX_CTRL1,
@@ -8754,7 +8764,7 @@ static uint8_t elink_8727_config_init(struct elink_phy *phy,
 
 	if (tx_en_mode == PORT_HW_CFG_TX_LASER_GPIO0) {
 
-		PMD_DRV_LOG(DEBUG, "Enabling TXONOFF_PWRDN_DIS");
+		PMD_DRV_LOG(DEBUG, sc, "Enabling TXONOFF_PWRDN_DIS");
 		elink_cl45_read(sc, phy,
 				MDIO_PMA_DEVAD, MDIO_PMA_REG_8727_OPT_CFG_REG,
 				&tmp2);
@@ -8786,7 +8796,7 @@ static void elink_8727_handle_mod_abs(struct elink_phy *phy,
 	if (mod_abs & (1 << 8)) {
 
 		/* Module is absent */
-		PMD_DRV_LOG(DEBUG, "MOD_ABS indication show module is absent");
+		PMD_DRV_LOG(DEBUG, sc, "MOD_ABS indication show module is absent");
 		phy->media_type = ELINK_ETH_PHY_NOT_PRESENT;
 		/* 1. Set mod_abs to detect next module
 		 *    presence event
@@ -8811,7 +8821,7 @@ static void elink_8727_handle_mod_abs(struct elink_phy *phy,
 
 	} else {
 		/* Module is present */
-		PMD_DRV_LOG(DEBUG, "MOD_ABS indication show module is present");
+		PMD_DRV_LOG(DEBUG, sc, "MOD_ABS indication show module is present");
 		/* First disable transmitter, and if the module is ok, the
 		 * module_detection will enable it
 		 * 1. Set mod_abs to detect next module absent event ( bit 8)
@@ -8842,14 +8852,14 @@ static void elink_8727_handle_mod_abs(struct elink_phy *phy,
 		if (elink_wait_for_sfp_module_initialized(phy, params) == 0) {
 			elink_sfp_module_detection(phy, params);
 		} else {
-			PMD_DRV_LOG(DEBUG, "SFP+ module is not initialized");
+			PMD_DRV_LOG(DEBUG, sc, "SFP+ module is not initialized");
 		}
 
 		/* Reconfigure link speed based on module type limitations */
 		elink_8727_config_speed(phy, params);
 	}
 
-	PMD_DRV_LOG(DEBUG, "8727 RX_ALARM_STATUS 0x%x", rx_alarm_status);
+	PMD_DRV_LOG(DEBUG, sc, "8727 RX_ALARM_STATUS 0x%x", rx_alarm_status);
 	/* No need to check link status in case of module plugged in/out */
 }
 
@@ -8872,14 +8882,14 @@ static uint8_t elink_8727_read_status(struct elink_phy *phy,
 	elink_cl45_read(sc, phy,
 			MDIO_PMA_DEVAD, MDIO_PMA_LASI_RXSTAT, &rx_alarm_status);
 	vars->line_speed = 0;
-	PMD_DRV_LOG(DEBUG, "8727 RX_ALARM_STATUS  0x%x", rx_alarm_status);
+	PMD_DRV_LOG(DEBUG, sc, "8727 RX_ALARM_STATUS  0x%x", rx_alarm_status);
 
 	elink_sfp_mask_fault(sc, phy, MDIO_PMA_LASI_TXSTAT,
 			     MDIO_PMA_LASI_TXCTRL);
 
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_STAT, &val1);
 
-	PMD_DRV_LOG(DEBUG, "8727 LASI status 0x%x", val1);
+	PMD_DRV_LOG(DEBUG, sc, "8727 LASI status 0x%x", val1);
 
 	/* Clear MSG-OUT */
 	elink_cl45_read(sc, phy,
@@ -8897,7 +8907,7 @@ static uint8_t elink_8727_read_status(struct elink_phy *phy,
 		if ((val1 & (1 << 8)) == 0) {
 			if (!CHIP_IS_E1x(sc))
 				oc_port = SC_PATH(sc) + (params->port << 1);
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "8727 Power fault has been detected on port %d",
 				    oc_port);
 			elink_cb_event_log(sc, ELINK_LOG_ID_OVER_CURRENT, oc_port);	//"Error: Power fault on Port %d has "
@@ -8940,10 +8950,10 @@ static uint8_t elink_8727_read_status(struct elink_phy *phy,
 	}
 
 	if (!(phy->flags & ELINK_FLAGS_SFP_NOT_APPROVED)) {
-		PMD_DRV_LOG(DEBUG, "Enabling 8727 TX laser");
+		PMD_DRV_LOG(DEBUG, sc, "Enabling 8727 TX laser");
 		elink_sfp_set_transmitter(params, phy, 1);
 	} else {
-		PMD_DRV_LOG(DEBUG, "Tx is disabled");
+		PMD_DRV_LOG(DEBUG, sc, "Tx is disabled");
 		return 0;
 	}
 
@@ -8957,16 +8967,16 @@ static uint8_t elink_8727_read_status(struct elink_phy *phy,
 	if ((link_status & (1 << 2)) && (!(link_status & (1 << 15)))) {
 		link_up = 1;
 		vars->line_speed = ELINK_SPEED_10000;
-		PMD_DRV_LOG(DEBUG, "port %x: External link up in 10G",
+		PMD_DRV_LOG(DEBUG, sc, "port %x: External link up in 10G",
 			    params->port);
 	} else if ((link_status & (1 << 0)) && (!(link_status & (1 << 13)))) {
 		link_up = 1;
 		vars->line_speed = ELINK_SPEED_1000;
-		PMD_DRV_LOG(DEBUG, "port %x: External link up in 1G",
+		PMD_DRV_LOG(DEBUG, sc, "port %x: External link up in 1G",
 			    params->port);
 	} else {
 		link_up = 0;
-		PMD_DRV_LOG(DEBUG, "port %x: External link is down",
+		PMD_DRV_LOG(DEBUG, sc, "port %x: External link is down",
 			    params->port);
 	}
 
@@ -8986,7 +8996,7 @@ static uint8_t elink_8727_read_status(struct elink_phy *phy,
 	if (link_up) {
 		elink_ext_phy_resolve_fc(phy, params, vars);
 		vars->duplex = DUPLEX_FULL;
-		PMD_DRV_LOG(DEBUG, "duplex = 0x%x", vars->duplex);
+		PMD_DRV_LOG(DEBUG, sc, "duplex = 0x%x", vars->duplex);
 	}
 
 	if ((ELINK_DUAL_MEDIA(params)) &&
@@ -9058,7 +9068,7 @@ static void elink_save_848xx_spirom_version(struct elink_phy *phy,
 			DELAY(5);
 		}
 		if (cnt == 100) {
-			PMD_DRV_LOG(DEBUG, "Unable to read 848xx "
+			PMD_DRV_LOG(DEBUG, sc, "Unable to read 848xx "
 				    "phy fw version(1)");
 			elink_save_spirom_version(sc, port, 0, phy->ver_addr);
 			return;
@@ -9075,7 +9085,7 @@ static void elink_save_848xx_spirom_version(struct elink_phy *phy,
 			DELAY(5);
 		}
 		if (cnt == 100) {
-			PMD_DRV_LOG(DEBUG, "Unable to read 848xx phy fw "
+			PMD_DRV_LOG(DEBUG, sc, "Unable to read 848xx phy fw "
 				    "version(2)");
 			elink_save_spirom_version(sc, port, 0, phy->ver_addr);
 			return;
@@ -9188,7 +9198,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
 		autoneg_val |= (1 << 9 | 1 << 12);
 		if (phy->req_duplex == DUPLEX_FULL)
 			an_1000_val |= (1 << 9);
-		PMD_DRV_LOG(DEBUG, "Advertising 1G");
+		PMD_DRV_LOG(DEBUG, sc, "Advertising 1G");
 	} else
 		an_1000_val &= ~((1 << 8) | (1 << 9));
 
@@ -9204,7 +9214,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
 			 */
 			autoneg_val |= (1 << 9 | 1 << 12);
 			an_10_100_val |= (1 << 8);
-			PMD_DRV_LOG(DEBUG, "Advertising 100M-FD");
+			PMD_DRV_LOG(DEBUG, sc, "Advertising 100M-FD");
 		}
 
 		if (phy->speed_cap_mask &
@@ -9213,7 +9223,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
 			 */
 			autoneg_val |= (1 << 9 | 1 << 12);
 			an_10_100_val |= (1 << 7);
-			PMD_DRV_LOG(DEBUG, "Advertising 100M-HD");
+			PMD_DRV_LOG(DEBUG, sc, "Advertising 100M-HD");
 		}
 
 		if ((phy->speed_cap_mask &
@@ -9221,7 +9231,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
 		    (phy->supported & ELINK_SUPPORTED_10baseT_Full)) {
 			an_10_100_val |= (1 << 6);
 			autoneg_val |= (1 << 9 | 1 << 12);
-			PMD_DRV_LOG(DEBUG, "Advertising 10M-FD");
+			PMD_DRV_LOG(DEBUG, sc, "Advertising 10M-FD");
 		}
 
 		if ((phy->speed_cap_mask &
@@ -9229,7 +9239,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
 		    (phy->supported & ELINK_SUPPORTED_10baseT_Half)) {
 			an_10_100_val |= (1 << 5);
 			autoneg_val |= (1 << 9 | 1 << 12);
-			PMD_DRV_LOG(DEBUG, "Advertising 10M-HD");
+			PMD_DRV_LOG(DEBUG, sc, "Advertising 10M-HD");
 		}
 	}
 
@@ -9244,7 +9254,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
 				 (1 << 15 | 1 << 9 | 7 << 0));
 		/* The PHY needs this set even for forced link. */
 		an_10_100_val |= (1 << 8) | (1 << 7);
-		PMD_DRV_LOG(DEBUG, "Setting 100M force");
+		PMD_DRV_LOG(DEBUG, sc, "Setting 100M force");
 	}
 	if ((phy->req_line_speed == ELINK_SPEED_10) &&
 	    (phy->supported &
@@ -9253,7 +9263,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
 		elink_cl45_write(sc, phy,
 				 MDIO_AN_DEVAD, MDIO_AN_REG_8481_AUX_CTRL,
 				 (1 << 15 | 1 << 9 | 7 << 0));
-		PMD_DRV_LOG(DEBUG, "Setting 10M force");
+		PMD_DRV_LOG(DEBUG, sc, "Setting 10M force");
 	}
 
 	elink_cl45_write(sc, phy,
@@ -9277,7 +9287,7 @@ static elink_status_t elink_848xx_cmn_config_init(struct elink_phy *phy,
 	     (phy->speed_cap_mask &
 	      PORT_HW_CFG_SPEED_CAPABILITY_D0_10G)) ||
 	    (phy->req_line_speed == ELINK_SPEED_10000)) {
-		PMD_DRV_LOG(DEBUG, "Advertising 10G");
+		PMD_DRV_LOG(DEBUG, sc, "Advertising 10G");
 		/* Restart autoneg for 10G */
 
 		elink_cl45_read_or_write(sc, phy,
@@ -9333,7 +9343,7 @@ static elink_status_t elink_84833_cmd_hdlr(struct elink_phy *phy,
 		DELAY(1000 * 1);
 	}
 	if (idx >= PHY84833_CMDHDLR_WAIT) {
-		PMD_DRV_LOG(DEBUG, "FW cmd: FW not ready.");
+		PMD_DRV_LOG(DEBUG, sc, "FW cmd: FW not ready.");
 		return ELINK_STATUS_ERROR;
 	}
 
@@ -9355,7 +9365,7 @@ static elink_status_t elink_84833_cmd_hdlr(struct elink_phy *phy,
 	}
 	if ((idx >= PHY84833_CMDHDLR_WAIT) ||
 	    (val == PHY84833_STATUS_CMD_COMPLETE_ERROR)) {
-		PMD_DRV_LOG(DEBUG, "FW cmd failed.");
+		PMD_DRV_LOG(DEBUG, sc, "FW cmd failed.");
 		return ELINK_STATUS_ERROR;
 	}
 	/* Gather returning data */
@@ -9397,7 +9407,7 @@ static elink_status_t elink_84833_pair_swap_cfg(struct elink_phy *phy,
 				      PHY84833_CMD_SET_PAIR_SWAP, data,
 				      PHY84833_CMDHDLR_MAX_ARGS);
 	if (status == ELINK_STATUS_OK) {
-		PMD_DRV_LOG(DEBUG, "Pairswap OK, val=0x%x", data[1]);
+		PMD_DRV_LOG(DEBUG, sc, "Pairswap OK, val=0x%x", data[1]);
 	}
 
 	return status;
@@ -9473,7 +9483,8 @@ static void elink_84833_hw_reset_phy(struct elink_phy *phy,
 	elink_cb_gpio_mult_write(sc, reset_gpios,
 				 MISC_REGISTERS_GPIO_OUTPUT_LOW);
 	DELAY(10);
-	PMD_DRV_LOG(DEBUG, "84833 hw reset on pin values 0x%x", reset_gpios);
+	PMD_DRV_LOG(DEBUG, sc,
+		    "84833 hw reset on pin values 0x%x", reset_gpios);
 }
 
 static elink_status_t elink_8483x_disable_eee(struct elink_phy *phy,
@@ -9483,13 +9494,13 @@ static elink_status_t elink_8483x_disable_eee(struct elink_phy *phy,
 	elink_status_t rc;
 	uint16_t cmd_args = 0;
 
-	PMD_DRV_LOG(DEBUG, "Don't Advertise 10GBase-T EEE");
+	PMD_DRV_LOG(DEBUG, params->sc, "Don't Advertise 10GBase-T EEE");
 
 	/* Prevent Phy from working in EEE and advertising it */
 	rc = elink_84833_cmd_hdlr(phy, params,
 				  PHY84833_CMD_SET_EEE_MODE, &cmd_args, 1);
 	if (rc != ELINK_STATUS_OK) {
-		PMD_DRV_LOG(DEBUG, "EEE disable failed.");
+		PMD_DRV_LOG(DEBUG, params->sc, "EEE disable failed.");
 		return rc;
 	}
 
@@ -9506,7 +9517,7 @@ static elink_status_t elink_8483x_enable_eee(struct elink_phy *phy,
 	rc = elink_84833_cmd_hdlr(phy, params,
 				  PHY84833_CMD_SET_EEE_MODE, &cmd_args, 1);
 	if (rc != ELINK_STATUS_OK) {
-		PMD_DRV_LOG(DEBUG, "EEE enable failed.");
+		PMD_DRV_LOG(DEBUG, params->sc, "EEE enable failed.");
 		return rc;
 	}
 
@@ -9599,7 +9610,7 @@ static uint8_t elink_848x3_config_init(struct elink_phy *phy,
 
 	elink_cl45_write(sc, phy, MDIO_CTL_DEVAD,
 			 MDIO_CTL_REG_84823_MEDIA, val);
-	PMD_DRV_LOG(DEBUG, "Multi_phy config = 0x%x, Media control = 0x%x",
+	PMD_DRV_LOG(DEBUG, sc, "Multi_phy config = 0x%x, Media control = 0x%x",
 		    params->multi_phy_config, val);
 
 	if ((phy->type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BNX2X84833) ||
@@ -9615,7 +9626,7 @@ static uint8_t elink_848x3_config_init(struct elink_phy *phy,
 					  PHY84833_CMD_SET_EEE_MODE, cmd_args,
 					  PHY84833_CMDHDLR_MAX_ARGS);
 		if (rc != ELINK_STATUS_OK) {
-			PMD_DRV_LOG(DEBUG, "Cfg AutogrEEEn failed.");
+			PMD_DRV_LOG(DEBUG, sc, "Cfg AutogrEEEn failed.");
 		}
 	}
 	if (initialize) {
@@ -9652,7 +9663,7 @@ static uint8_t elink_848x3_config_init(struct elink_phy *phy,
 	    elink_eee_has_cap(params)) {
 		rc = elink_eee_initial_config(params, vars, SHMEM_EEE_10G_ADV);
 		if (rc != ELINK_STATUS_OK) {
-			PMD_DRV_LOG(DEBUG, "Failed to configure EEE timers");
+			PMD_DRV_LOG(DEBUG, sc, "Failed to configure EEE timers");
 			elink_8483x_disable_eee(phy, params, vars);
 			return rc;
 		}
@@ -9665,7 +9676,7 @@ static uint8_t elink_848x3_config_init(struct elink_phy *phy,
 		else
 			rc = elink_8483x_disable_eee(phy, params, vars);
 		if (rc != ELINK_STATUS_OK) {
-			PMD_DRV_LOG(DEBUG, "Failed to set EEE advertisement");
+			PMD_DRV_LOG(DEBUG, sc, "Failed to set EEE advertisement");
 			return rc;
 		}
 	} else {
@@ -9697,7 +9708,7 @@ static uint8_t elink_848xx_read_status(struct elink_phy *phy,
 	elink_cl45_read(sc, phy, MDIO_AN_DEVAD, 0xFFFA, &val1);
 	elink_cl45_read(sc, phy,
 			MDIO_PMA_DEVAD, MDIO_PMA_REG_8481_PMD_SIGNAL, &val2);
-	PMD_DRV_LOG(DEBUG, "BNX2X848xx: PMD_SIGNAL 1.a811 = 0x%x", val2);
+	PMD_DRV_LOG(DEBUG, sc, "BNX2X848xx: PMD_SIGNAL 1.a811 = 0x%x", val2);
 
 	/* Check link 10G */
 	if (val2 & (1 << 11)) {
@@ -9719,7 +9730,8 @@ static uint8_t elink_848xx_read_status(struct elink_phy *phy,
 				MDIO_AN_REG_8481_EXPANSION_REG_RD_RW,
 				&legacy_status);
 
-		PMD_DRV_LOG(DEBUG, "Legacy speed status = 0x%x", legacy_status);
+		PMD_DRV_LOG(DEBUG, sc,
+			    "Legacy speed status = 0x%x", legacy_status);
 		link_up = ((legacy_status & (1 << 11)) == (1 << 11));
 		legacy_speed = (legacy_status & (3 << 9));
 		if (legacy_speed == (0 << 9))
@@ -9749,7 +9761,7 @@ static uint8_t elink_848xx_read_status(struct elink_phy *phy,
 			else
 				vars->duplex = DUPLEX_HALF;
 
-			PMD_DRV_LOG(DEBUG,
+			PMD_DRV_LOG(DEBUG, sc,
 				    "Link is up in %dMbps, is_duplex_full= %d",
 				    vars->line_speed,
 				    (vars->duplex == DUPLEX_FULL));
@@ -9771,7 +9783,7 @@ static uint8_t elink_848xx_read_status(struct elink_phy *phy,
 		}
 	}
 	if (link_up) {
-		PMD_DRV_LOG(DEBUG, "BNX2X848x3: link speed is %d",
+		PMD_DRV_LOG(DEBUG, sc, "BNX2X848x3: link speed is %d",
 			    vars->line_speed);
 		elink_ext_phy_resolve_fc(phy, params, vars);
 
@@ -9888,7 +9900,7 @@ static void elink_848xx_set_link_led(struct elink_phy *phy,
 	switch (mode) {
 	case ELINK_LED_MODE_OFF:
 
-		PMD_DRV_LOG(DEBUG, "Port 0x%x: LED MODE OFF", port);
+		PMD_DRV_LOG(DEBUG, sc, "Port 0x%x: LED MODE OFF", port);
 
 		if ((params->hw_led_mode << SHARED_HW_CFG_LED_MODE_SHIFT) ==
 		    SHARED_HW_CFG_LED_EXTPHY1) {
@@ -9918,7 +9930,8 @@ static void elink_848xx_set_link_led(struct elink_phy *phy,
 		break;
 	case ELINK_LED_MODE_FRONT_PANEL_OFF:
 
-		PMD_DRV_LOG(DEBUG, "Port 0x%x: LED MODE FRONT PANEL OFF", port);
+		PMD_DRV_LOG(DEBUG, sc,
+			    "Port 0x%x: LED MODE FRONT PANEL OFF", port);
 
 		if ((params->hw_led_mode << SHARED_HW_CFG_LED_MODE_SHIFT) ==
 		    SHARED_HW_CFG_LED_EXTPHY1) {
@@ -9968,7 +9981,7 @@ static void elink_848xx_set_link_led(struct elink_phy *phy,
 		break;
 	case ELINK_LED_MODE_ON:
 
-		PMD_DRV_LOG(DEBUG, "Port 0x%x: LED MODE ON", port);
+		PMD_DRV_LOG(DEBUG, sc, "Port 0x%x: LED MODE ON", port);
 
 		if ((params->hw_led_mode << SHARED_HW_CFG_LED_MODE_SHIFT) ==
 		    SHARED_HW_CFG_LED_EXTPHY1) {
@@ -10028,7 +10041,7 @@ static void elink_848xx_set_link_led(struct elink_phy *phy,
 
 	case ELINK_LED_MODE_OPER:
 
-		PMD_DRV_LOG(DEBUG, "Port 0x%x: LED MODE OPER", port);
+		PMD_DRV_LOG(DEBUG, sc, "Port 0x%x: LED MODE OPER", port);
 
 		if ((params->hw_led_mode << SHARED_HW_CFG_LED_MODE_SHIFT) ==
 		    SHARED_HW_CFG_LED_EXTPHY1) {
@@ -10043,7 +10056,7 @@ static void elink_848xx_set_link_led(struct elink_phy *phy,
 			      >>
 			      MDIO_PMA_REG_8481_LINK_SIGNAL_LED4_ENABLE_SHIFT))
 			{
-				PMD_DRV_LOG(DEBUG, "Setting LINK_SIGNAL");
+				PMD_DRV_LOG(DEBUG, sc, "Setting LINK_SIGNAL");
 				elink_cl45_write(sc, phy,
 						 MDIO_PMA_DEVAD,
 						 MDIO_PMA_REG_8481_LINK_SIGNAL,
@@ -10156,7 +10169,7 @@ static uint8_t elink_54618se_config_init(struct elink_phy *phy,
 	uint16_t autoneg_val, an_1000_val, an_10_100_val, fc_val, temp;
 	uint32_t cfg_pin;
 
-	PMD_DRV_LOG(DEBUG, "54618SE cfg init");
+	PMD_DRV_LOG(DEBUG, sc, "54618SE cfg init");
 	DELAY(1000 * 1);
 
 	/* This works with E3 only, no need to check the chip
@@ -10229,7 +10242,7 @@ static uint8_t elink_54618se_config_init(struct elink_phy *phy,
 		autoneg_val |= (1 << 9 | 1 << 12);
 		if (phy->req_duplex == DUPLEX_FULL)
 			an_1000_val |= (1 << 9);
-		PMD_DRV_LOG(DEBUG, "Advertising 1G");
+		PMD_DRV_LOG(DEBUG, sc, "Advertising 1G");
 	} else
 		an_1000_val &= ~((1 << 8) | (1 << 9));
 
@@ -10242,25 +10255,25 @@ static uint8_t elink_54618se_config_init(struct elink_phy *phy,
 		    PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF) {
 			an_10_100_val |= (1 << 5);
 			autoneg_val |= (1 << 9 | 1 << 12);
-			PMD_DRV_LOG(DEBUG, "Advertising 10M-HD");
+			PMD_DRV_LOG(DEBUG, sc, "Advertising 10M-HD");
 		}
 		if (phy->speed_cap_mask &
 		    PORT_HW_CFG_SPEED_CAPABILITY_D0_10M_HALF) {
 			an_10_100_val |= (1 << 6);
 			autoneg_val |= (1 << 9 | 1 << 12);
-			PMD_DRV_LOG(DEBUG, "Advertising 10M-FD");
+			PMD_DRV_LOG(DEBUG, sc, "Advertising 10M-FD");
 		}
 		if (phy->speed_cap_mask &
 		    PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_HALF) {
 			an_10_100_val |= (1 << 7);
 			autoneg_val |= (1 << 9 | 1 << 12);
-			PMD_DRV_LOG(DEBUG, "Advertising 100M-HD");
+			PMD_DRV_LOG(DEBUG, sc, "Advertising 100M-HD");
 		}
 		if (phy->speed_cap_mask &
 		    PORT_HW_CFG_SPEED_CAPABILITY_D0_100M_FULL) {
 			an_10_100_val |= (1 << 8);
 			autoneg_val |= (1 << 9 | 1 << 12);
-			PMD_DRV_LOG(DEBUG, "Advertising 100M-FD");
+			PMD_DRV_LOG(DEBUG, sc, "Advertising 100M-FD");
 		}
 	}
 
@@ -10269,12 +10282,12 @@ static uint8_t elink_54618se_config_init(struct elink_phy *phy,
 		autoneg_val |= (1 << 13);
 		/* Enabled AUTO-MDIX when autoneg is disabled */
 		elink_cl22_write(sc, phy, 0x18, (1 << 15 | 1 << 9 | 7 << 0));
-		PMD_DRV_LOG(DEBUG, "Setting 100M force");
+		PMD_DRV_LOG(DEBUG, sc, "Setting 100M force");
 	}
 	if (phy->req_line_speed == ELINK_SPEED_10) {
 		/* Enabled AUTO-MDIX when autoneg is disabled */
 		elink_cl22_write(sc, phy, 0x18, (1 << 15 | 1 << 9 | 7 << 0));
-		PMD_DRV_LOG(DEBUG, "Setting 10M force");
+		PMD_DRV_LOG(DEBUG, sc, "Setting 10M force");
 	}
 
 	if ((phy->flags & ELINK_FLAGS_EEE) && elink_eee_has_cap(params)) {
@@ -10289,7 +10302,7 @@ static uint8_t elink_54618se_config_init(struct elink_phy *phy,
 
 		rc = elink_eee_initial_config(params, vars, SHMEM_EEE_1G_ADV);
 		if (rc != ELINK_STATUS_OK) {
-			PMD_DRV_LOG(DEBUG, "Failed to configure EEE timers");
+			PMD_DRV_LOG(DEBUG, sc, "Failed to configure EEE timers");
 			elink_eee_disable(phy, params, vars);
 		} else if ((params->eee_mode & ELINK_EEE_MODE_ADV_LPI) &&
 			   (phy->req_duplex == DUPLEX_FULL) &&
@@ -10303,7 +10316,7 @@ static uint8_t elink_54618se_config_init(struct elink_phy *phy,
 			elink_eee_advertise(phy, params, vars,
 					    SHMEM_EEE_1G_ADV);
 		} else {
-			PMD_DRV_LOG(DEBUG, "Don't Advertise 1GBase-T EEE");
+			PMD_DRV_LOG(DEBUG, sc, "Don't Advertise 1GBase-T EEE");
 			elink_eee_disable(phy, params, vars);
 		}
 	} else {
@@ -10315,10 +10328,10 @@ static uint8_t elink_54618se_config_init(struct elink_phy *phy,
 			if (params->feature_config_flags &
 			    ELINK_FEATURE_CONFIG_AUTOGREEEN_ENABLED) {
 				temp = 6;
-				PMD_DRV_LOG(DEBUG, "Enabling Auto-GrEEEn");
+				PMD_DRV_LOG(DEBUG, sc, "Enabling Auto-GrEEEn");
 			} else {
 				temp = 0;
-				PMD_DRV_LOG(DEBUG, "Don't Adv. EEE");
+				PMD_DRV_LOG(DEBUG, sc, "Don't Adv. EEE");
 			}
 			elink_cl45_write(sc, phy, MDIO_AN_DEVAD,
 					 MDIO_AN_REG_EEE_ADV, temp);
@@ -10346,7 +10359,7 @@ static void elink_5461x_set_link_led(struct elink_phy *phy,
 	elink_cl22_read(sc, phy, MDIO_REG_GPHY_SHADOW, &temp);
 	temp &= 0xff00;
 
-	PMD_DRV_LOG(DEBUG, "54618x set link led (mode=%x)", mode);
+	PMD_DRV_LOG(DEBUG, sc, "54618x set link led (mode=%x)", mode);
 	switch (mode) {
 	case ELINK_LED_MODE_FRONT_PANEL_OFF:
 	case ELINK_LED_MODE_OFF:
@@ -10404,7 +10417,7 @@ static uint8_t elink_54618se_read_status(struct elink_phy *phy,
 
 	/* Get speed operation status */
 	elink_cl22_read(sc, phy, MDIO_REG_GPHY_AUX_STATUS, &legacy_status);
-	PMD_DRV_LOG(DEBUG, "54618SE read_status: 0x%x", legacy_status);
+	PMD_DRV_LOG(DEBUG, sc, "54618SE read_status: 0x%x", legacy_status);
 
 	/* Read status to clear the PHY interrupt. */
 	elink_cl22_read(sc, phy, MDIO_REG_INTR_STATUS, &val);
@@ -10436,7 +10449,7 @@ static uint8_t elink_54618se_read_status(struct elink_phy *phy,
 		} else		/* Should not happen */
 			vars->line_speed = 0;
 
-		PMD_DRV_LOG(DEBUG,
+		PMD_DRV_LOG(DEBUG, sc,
 			    "Link is up in %dMbps, is_duplex_full= %d",
 			    vars->line_speed, (vars->duplex == DUPLEX_FULL));
 
@@ -10450,7 +10463,7 @@ static uint8_t elink_54618se_read_status(struct elink_phy *phy,
 			vars->link_status |=
 			    LINK_STATUS_PARALLEL_DETECTION_USED;
 
-		PMD_DRV_LOG(DEBUG, "BNX2X54618SE: link speed is %d",
+		PMD_DRV_LOG(DEBUG, sc, "BNX2X54618SE: link speed is %d",
 			    vars->line_speed);
 
 		elink_ext_phy_resolve_fc(phy, params, vars);
@@ -10498,7 +10511,7 @@ static void elink_54618se_config_loopback(struct elink_phy *phy,
 	uint16_t val;
 	uint32_t umac_base = params->port ? GRCBASE_UMAC1 : GRCBASE_UMAC0;
 
-	PMD_DRV_LOG(DEBUG, "2PMA/PMD ext_phy_loopback: 54618se");
+	PMD_DRV_LOG(DEBUG, sc, "2PMA/PMD ext_phy_loopback: 54618se");
 
 	/* Enable master/slave manual mmode and set to master */
 	/* mii write 9 [bits set 11 12] */
@@ -10549,7 +10562,7 @@ static uint8_t elink_7101_config_init(struct elink_phy *phy,
 {
 	uint16_t fw_ver1, fw_ver2, val;
 	struct bnx2x_softc *sc = params->sc;
-	PMD_DRV_LOG(DEBUG, "Setting the SFX7101 LASI indication");
+	PMD_DRV_LOG(DEBUG, sc, "Setting the SFX7101 LASI indication");
 
 	/* Restore normal power mode */
 	elink_cb_gpio_write(sc, MISC_REGISTERS_GPIO_2,
@@ -10559,7 +10572,7 @@ static uint8_t elink_7101_config_init(struct elink_phy *phy,
 	elink_wait_reset_complete(sc, phy, params);
 
 	elink_cl45_write(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_CTRL, 0x1);
-	PMD_DRV_LOG(DEBUG, "Setting the SFX7101 LED to blink on traffic");
+	PMD_DRV_LOG(DEBUG, sc, "Setting the SFX7101 LED to blink on traffic");
 	elink_cl45_write(sc, phy,
 			 MDIO_PMA_DEVAD, MDIO_PMA_REG_7107_LED_CNTL, (1 << 3));
 
@@ -10590,10 +10603,10 @@ static uint8_t elink_7101_read_status(struct elink_phy *phy,
 	uint16_t val1, val2;
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_STAT, &val2);
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_LASI_STAT, &val1);
-	PMD_DRV_LOG(DEBUG, "10G-base-T LASI status 0x%x->0x%x", val2, val1);
+	PMD_DRV_LOG(DEBUG, sc, "10G-base-T LASI status 0x%x->0x%x", val2, val1);
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val2);
 	elink_cl45_read(sc, phy, MDIO_PMA_DEVAD, MDIO_PMA_REG_STATUS, &val1);
-	PMD_DRV_LOG(DEBUG, "10G-base-T PMA status 0x%x->0x%x", val2, val1);
+	PMD_DRV_LOG(DEBUG, sc, "10G-base-T PMA status 0x%x->0x%x", val2, val1);
 	link_up = ((val1 & 4) == 4);
 	/* If link is up print the AN outcome of the SFX7101 PHY */
 	if (link_up) {
@@ -10602,7 +10615,7 @@ static uint8_t elink_7101_read_status(struct elink_phy *phy,
 				&val2);
 		vars->line_speed = ELINK_SPEED_10000;
 		vars->duplex = DUPLEX_FULL;
-		PMD_DRV_LOG(DEBUG, "SFX7101 AN status 0x%x->Master=%x",
+		PMD_DRV_LOG(DEBUG, sc, "SFX7101 AN status 0x%x->Master=%x",
 			    val2, (val2 & (1 << 14)));
 		elink_ext_phy_10G_an_resolve(sc, phy, vars);
 		elink_ext_phy_resolve_fc(phy, params, vars);
@@ -11209,7 +11222,7 @@ static uint32_t elink_get_ext_phy_config(struct bnx2x_softc *sc,
 						 external_phy_config2));
 		break;
 	default:
-		PMD_DRV_LOG(DEBUG, "Invalid phy_index %d", phy_index);
+		PMD_DRV_LOG(DEBUG, sc, "Invalid phy_index %d", phy_index);
 		return ELINK_STATUS_ERROR;
 	}
 
@@ -11232,7 +11245,7 @@ static elink_status_t elink_populate_int_phy(struct bnx2x_softc *sc,
 	    (REG_RD(sc, MISC_REG_CHIP_NUM) << 16) |
 	    ((REG_RD(sc, MISC_REG_CHIP_REV) & 0xf) << 12);
 
-	PMD_DRV_LOG(DEBUG, ":chip_id = 0x%x", chip_id);
+	PMD_DRV_LOG(DEBUG, sc, ":chip_id = 0x%x", chip_id);
 	if (USES_WARPCORE(sc)) {
 		uint32_t serdes_net_if;
 		phy_addr = REG_RD(sc, MISC_REG_WC0_CTRL_PHY_ADDR);
@@ -11309,7 +11322,7 @@ static elink_status_t elink_populate_int_phy(struct bnx2x_softc *sc,
 			phy->flags &= ~ELINK_FLAGS_TX_ERROR_CHECK;
 			break;
 		default:
-			PMD_DRV_LOG(DEBUG, "Unknown WC interface type 0x%x",
+			PMD_DRV_LOG(DEBUG, sc, "Unknown WC interface type 0x%x",
 				    serdes_net_if);
 			break;
 		}
@@ -11337,7 +11350,7 @@ static elink_status_t elink_populate_int_phy(struct bnx2x_softc *sc,
 			*phy = phy_xgxs;
 			break;
 		default:
-			PMD_DRV_LOG(DEBUG, "Invalid switch_cfg");
+			PMD_DRV_LOG(DEBUG, sc, "Invalid switch_cfg");
 			return ELINK_STATUS_ERROR;
 		}
 	}
@@ -11350,7 +11363,7 @@ static elink_status_t elink_populate_int_phy(struct bnx2x_softc *sc,
 	else
 		phy->def_md_devad = ELINK_DEFAULT_PHY_DEV_ADDR;
 
-	PMD_DRV_LOG(DEBUG, "Internal phy port=%d, addr=0x%x, mdio_ctl=0x%x",
+	PMD_DRV_LOG(DEBUG, sc, "Internal phy port=%d, addr=0x%x, mdio_ctl=0x%x",
 		    port, phy->addr, phy->mdio_ctrl);
 
 	elink_populate_preemphasis(sc, shmem_base, phy, port, ELINK_INT_PHY);
@@ -11477,9 +11490,9 @@ static elink_status_t elink_populate_ext_phy(struct bnx2x_softc *sc,
 					    ELINK_SUPPORTED_100baseT_Full);
 	}
 
-	PMD_DRV_LOG(DEBUG, "phy_type 0x%x port %d found in index %d",
+	PMD_DRV_LOG(DEBUG, sc, "phy_type 0x%x port %d found in index %d",
 		    phy_type, port, phy_index);
-	PMD_DRV_LOG(DEBUG, "             addr=0x%x, mdio_ctl=0x%x",
+	PMD_DRV_LOG(DEBUG, sc, "             addr=0x%x, mdio_ctl=0x%x",
 		    phy->addr, phy->mdio_ctrl);
 	return ELINK_STATUS_OK;
 }
@@ -11528,7 +11541,7 @@ static void elink_phy_def_cfg(struct elink_params *params,
 							 speed_capability_mask));
 	}
 
-	PMD_DRV_LOG(DEBUG,
+	PMD_DRV_LOG(DEBUG, sc,
 		    "Default config phy idx %x cfg 0x%x speed_cap_mask 0x%x",
 		    phy_index, link_config, phy->speed_cap_mask);
 
@@ -11617,7 +11630,7 @@ elink_status_t elink_phy_probe(struct elink_params * params)
 	struct bnx2x_softc *sc = params->sc;
 	struct elink_phy *phy;
 	params->num_phys = 0;
-	PMD_DRV_LOG(DEBUG, "Begin phy probe");
+	PMD_DRV_LOG(DEBUG, sc, "Begin phy probe");
 
 	phy_config_swapped = params->multi_phy_config &
 	    PORT_HW_CFG_PHY_SWAPPED_ENABLED;
@@ -11630,7 +11643,7 @@ elink_status_t elink_phy_probe(struct elink_params * params)
 			else if (phy_index == ELINK_EXT_PHY2)
 				actual_phy_idx = ELINK_EXT_PHY1;
 		}
-		PMD_DRV_LOG(DEBUG, "phy_config_swapped %x, phy_index %x,"
+		PMD_DRV_LOG(DEBUG, sc, "phy_config_swapped %x, phy_index %x,"
 			    " actual_phy_idx %x", phy_config_swapped,
 			    phy_index, actual_phy_idx);
 		phy = &params->phy[actual_phy_idx];
@@ -11638,7 +11651,7 @@ elink_status_t elink_phy_probe(struct elink_params * params)
 				       params->shmem2_base, params->port,
 				       phy) != ELINK_STATUS_OK) {
 			params->num_phys = 0;
-			PMD_DRV_LOG(DEBUG, "phy probe failed in phy index %d",
+			PMD_DRV_LOG(DEBUG, sc, "phy probe failed in phy index %d",
 				    phy_index);
 			for (phy_index = ELINK_INT_PHY;
 			     phy_index < ELINK_MAX_PHYS; phy_index++)
@@ -11679,7 +11692,8 @@ elink_status_t elink_phy_probe(struct elink_params * params)
 		params->num_phys++;
 	}
 
-	PMD_DRV_LOG(DEBUG, "End phy probe. #phys found %x", params->num_phys);
+	PMD_DRV_LOG(DEBUG, sc,
+		    "End phy probe. #phys found %x", params->num_phys);
 	return ELINK_STATUS_OK;
 }
 
@@ -11849,7 +11863,7 @@ static elink_status_t elink_avoid_link_flap(struct elink_params *params,
 	for (phy_idx = ELINK_INT_PHY; phy_idx < params->num_phys; phy_idx++) {
 		struct elink_phy *phy = &params->phy[phy_idx];
 		if (phy->phy_specific_func) {
-			PMD_DRV_LOG(DEBUG, "Calling PHY specific func");
+			PMD_DRV_LOG(DEBUG, sc, "Calling PHY specific func");
 			phy->phy_specific_func(phy, params, ELINK_PHY_INIT);
 		}
 		if ((phy->media_type == ELINK_ETH_PHY_SFPP_10G_FIBER) ||
@@ -11969,12 +11983,13 @@ elink_status_t elink_phy_init(struct elink_params *params,
 {
 	int lfa_status;
 	struct bnx2x_softc *sc = params->sc;
-	PMD_DRV_LOG(DEBUG, "Phy Initialization started");
-	PMD_DRV_LOG(DEBUG, "(1) req_speed %d, req_flowctrl %d",
+	PMD_DRV_LOG(DEBUG, sc, "Phy Initialization started");
+	PMD_DRV_LOG(DEBUG, sc, "(1) req_speed %d, req_flowctrl %d",
 		    params->req_line_speed[0], params->req_flow_ctrl[0]);
-	PMD_DRV_LOG(DEBUG, "(2) req_speed %d, req_flowctrl %d",
+	PMD_DRV_LOG(DEBUG, sc, "(2) req_speed %d, req_flowctrl %d",
 		    params->req_line_speed[1], params->req_flow_ctrl[1]);
-	PMD_DRV_LOG(DEBUG, "req_adv_flow_ctrl 0x%x", params->req_fc_auto_adv);
+	PMD_DRV_LOG(DEBUG, sc,
+		    "req_adv_flow_ctrl 0x%x", params->req_fc_auto_adv);
 	vars->link_status = 0;
 	vars->phy_link_up = 0;
 	vars->link_up = 0;
@@ -11991,11 +12006,13 @@ elink_status_t elink_phy_init(struct elink_params *params,
 	lfa_status = elink_check_lfa(params);
 
 	if (lfa_status == 0) {
-		PMD_DRV_LOG(DEBUG, "Link Flap Avoidance in progress");
+		PMD_DRV_LOG(DEBUG, sc,
+			    "Link Flap Avoidance in progress");
 		return elink_avoid_link_flap(params, vars);
 	}
 
-	PMD_DRV_LOG(DEBUG, "Cannot avoid link flap lfa_sta=0x%x", lfa_status);
+	PMD_DRV_LOG(DEBUG, sc,
+		    "Cannot avoid link flap lfa_sta=0x%x", lfa_status);
 	elink_cannot_avoid_link_flap(params, vars, lfa_status);
 
 	/* Disable attentions */
@@ -12011,12 +12028,12 @@ elink_status_t elink_phy_init(struct elink_params *params,
 		vars->link_status |= LINK_STATUS_PFC_ENABLED;
 
 	if ((params->num_phys == 0) && !CHIP_REV_IS_SLOW(sc)) {
-		PMD_DRV_LOG(DEBUG, "No phy found for initialization !!");
+		PMD_DRV_LOG(DEBUG, sc, "No phy found for initialization !!");
 		return ELINK_STATUS_ERROR;
 	}
 	set_phy_vars(params, vars);
 
-	PMD_DRV_LOG(DEBUG, "Num of phys on board: %d", params->num_phys);
+	PMD_DRV_LOG(DEBUG, sc, "Num of phys on board: %d", params->num_phys);
 
 	switch (params->loopback_mode) {
 	case ELINK_LOOPBACK_BMAC:
@@ -12059,7 +12076,7 @@ static elink_status_t elink_link_reset(struct elink_params *params,
 {
 	struct bnx2x_softc *sc = params->sc;
 	uint8_t phy_index, port = params->port, clear_latch_ind = 0;
-	PMD_DRV_LOG(DEBUG, "Resetting the link of port %d", port);
+	PMD_DRV_LOG(DEBUG, sc, "Resetting the link of port %d", port);
 	/* Disable attentions */
 	vars->link_status = 0;
 	elink_update_mng(params, vars->link_status);
@@ -12237,7 +12254,7 @@ static elink_status_t elink_8073_common_init_phy(struct bnx2x_softc *sc,
 		if (elink_populate_phy(sc, phy_index, shmem_base, shmem2_base,
 				       port_of_path, &phy[port]) !=
 		    ELINK_STATUS_OK) {
-			PMD_DRV_LOG(DEBUG, "populate_phy failed");
+			PMD_DRV_LOG(DEBUG, sc, "populate_phy failed");
 			return ELINK_STATUS_ERROR;
 		}
 		/* Disable attentions */
@@ -12277,7 +12294,7 @@ static elink_status_t elink_8073_common_init_phy(struct bnx2x_softc *sc,
 		else
 			port_of_path = 0;
 
-		PMD_DRV_LOG(DEBUG, "Loading spirom for phy address 0x%x",
+		PMD_DRV_LOG(DEBUG, sc, "Loading spirom for phy address 0x%x",
 			    phy_blk[port]->addr);
 		if (elink_8073_8727_external_rom_boot(sc, phy_blk[port],
 						      port_of_path))
@@ -12361,7 +12378,7 @@ static elink_status_t elink_8726_common_init_phy(struct bnx2x_softc *sc,
 		/* Extract the ext phy address for the port */
 		if (elink_populate_phy(sc, phy_index, shmem_base, shmem2_base,
 				       port, &phy) != ELINK_STATUS_OK) {
-			PMD_DRV_LOG(DEBUG, "populate phy failed");
+			PMD_DRV_LOG(DEBUG, sc, "populate phy failed");
 			return ELINK_STATUS_ERROR;
 		}
 
@@ -12481,7 +12498,7 @@ static elink_status_t elink_8727_common_init_phy(struct bnx2x_softc *sc,
 		if (elink_populate_phy(sc, phy_index, shmem_base, shmem2_base,
 				       port_of_path, &phy[port]) !=
 		    ELINK_STATUS_OK) {
-			PMD_DRV_LOG(DEBUG, "populate phy failed");
+			PMD_DRV_LOG(DEBUG, sc, "populate phy failed");
 			return ELINK_STATUS_ERROR;
 		}
 		/* disable attentions */
@@ -12512,7 +12529,7 @@ static elink_status_t elink_8727_common_init_phy(struct bnx2x_softc *sc,
 			port_of_path = port;
 		else
 			port_of_path = 0;
-		PMD_DRV_LOG(DEBUG, "Loading spirom for phy address 0x%x",
+		PMD_DRV_LOG(DEBUG, sc, "Loading spirom for phy address 0x%x",
 			    phy_blk[port]->addr);
 		if (elink_8073_8727_external_rom_boot(sc, phy_blk[port],
 						      port_of_path))
@@ -12539,7 +12556,8 @@ static elink_status_t elink_84833_common_init_phy(struct bnx2x_softc *sc,
 	DELAY(10);
 	elink_cb_gpio_mult_write(sc, reset_gpios,
 				 MISC_REGISTERS_GPIO_OUTPUT_HIGH);
-	PMD_DRV_LOG(DEBUG, "84833 reset pulse on pin values 0x%x", reset_gpios);
+	PMD_DRV_LOG(DEBUG, sc,
+		    "84833 reset pulse on pin values 0x%x", reset_gpios);
 	return ELINK_STATUS_OK;
 }
 
@@ -12587,7 +12605,7 @@ static elink_status_t elink_ext_phy_common_init(struct bnx2x_softc *sc,
 		rc = ELINK_STATUS_ERROR;
 		break;
 	default:
-		PMD_DRV_LOG(DEBUG,
+		PMD_DRV_LOG(DEBUG, sc,
 			    "ext_phy 0x%x common init not required",
 			    ext_phy_type);
 		break;
@@ -12613,7 +12631,7 @@ elink_status_t elink_common_init_phy(struct bnx2x_softc * sc,
 
 	elink_set_mdio_clk(sc, GRCBASE_EMAC0);
 	elink_set_mdio_clk(sc, GRCBASE_EMAC1);
-	PMD_DRV_LOG(DEBUG, "Begin common phy init");
+	PMD_DRV_LOG(DEBUG, sc, "Begin common phy init");
 	if (CHIP_IS_E3(sc)) {
 		/* Enable EPIO */
 		val = REG_RD(sc, MISC_REG_GEN_PURP_HWG);
@@ -12624,7 +12642,7 @@ elink_status_t elink_common_init_phy(struct bnx2x_softc * sc,
 			 offsetof(struct shmem_region,
 				  port_mb[PORT_0].ext_phy_fw_version));
 	if (phy_ver) {
-		PMD_DRV_LOG(DEBUG, "Not doing common init; phy ver is 0x%x",
+		PMD_DRV_LOG(DEBUG, sc, "Not doing common init; phy ver is 0x%x",
 			    phy_ver);
 		return ELINK_STATUS_OK;
 	}
@@ -12696,15 +12714,15 @@ static uint8_t elink_analyze_link_error(struct elink_params *params,
 	/* If values differ */
 	switch (phy_flag) {
 	case PHY_HALF_OPEN_CONN_FLAG:
-		PMD_DRV_LOG(DEBUG, "Analyze Remote Fault");
+		PMD_DRV_LOG(DEBUG, sc, "Analyze Remote Fault");
 		break;
 	case PHY_SFP_TX_FAULT_FLAG:
-		PMD_DRV_LOG(DEBUG, "Analyze TX Fault");
+		PMD_DRV_LOG(DEBUG, sc, "Analyze TX Fault");
 		break;
 	default:
-		PMD_DRV_LOG(DEBUG, "Analyze UNKNOWN");
+		PMD_DRV_LOG(DEBUG, sc, "Analyze UNKNOWN");
 	}
-	PMD_DRV_LOG(DEBUG, "Link changed:[%x %x]->%x", vars->link_up,
+	PMD_DRV_LOG(DEBUG, sc, "Link changed:[%x %x]->%x", vars->link_up,
 		    old_status, status);
 
 	/* a. Update shmem->link_status accordingly
@@ -12830,7 +12848,7 @@ static void elink_sfp_tx_fault_detection(struct elink_phy *phy,
 	    PORT_HW_CFG_E3_TX_FAULT_SHIFT;
 
 	if (elink_get_cfg_pin(sc, cfg_pin, &value)) {
-		PMD_DRV_LOG(DEBUG, "Failed to read pin 0x%02x", cfg_pin);
+		PMD_DRV_LOG(DEBUG, sc, "Failed to read pin 0x%02x", cfg_pin);
 		return;
 	}
 
@@ -12852,7 +12870,7 @@ static void elink_sfp_tx_fault_detection(struct elink_phy *phy,
 
 		/* If module is unapproved, led should be on regardless */
 		if (!(phy->flags & ELINK_FLAGS_SFP_NOT_APPROVED)) {
-			PMD_DRV_LOG(DEBUG, "Change TX_Fault LED: ->%x",
+			PMD_DRV_LOG(DEBUG, sc, "Change TX_Fault LED: ->%x",
 				    led_mode);
 			elink_set_e3_module_fault_led(params, led_mode);
 		}
@@ -12862,7 +12880,7 @@ static void elink_sfp_tx_fault_detection(struct elink_phy *phy,
 static void elink_kr2_recovery(struct elink_params *params,
 			       struct elink_vars *vars, struct elink_phy *phy)
 {
-	PMD_DRV_LOG(DEBUG, "KR2 recovery");
+	PMD_DRV_LOG(DEBUG, params->sc, "KR2 recovery");
 
 	elink_warpcore_enable_AN_KR2(phy, params, vars);
 	elink_warpcore_restart_AN_KR(phy, params);
@@ -12889,7 +12907,7 @@ static void elink_check_kr2_wa(struct elink_params *params,
 	if (!sigdet) {
 		if (!(vars->link_attr_sync & LINK_ATTR_SYNC_KR2_ENABLE)) {
 			elink_kr2_recovery(params, vars, phy);
-			PMD_DRV_LOG(DEBUG, "No sigdet");
+			PMD_DRV_LOG(DEBUG, sc, "No sigdet");
 		}
 		return;
 	}
@@ -12907,7 +12925,7 @@ static void elink_check_kr2_wa(struct elink_params *params,
 	if (base_page == 0) {
 		if (!(vars->link_attr_sync & LINK_ATTR_SYNC_KR2_ENABLE)) {
 			elink_kr2_recovery(params, vars, phy);
-			PMD_DRV_LOG(DEBUG, "No BP");
+			PMD_DRV_LOG(DEBUG, sc, "No BP");
 		}
 		return;
 	}
@@ -12923,7 +12941,7 @@ static void elink_check_kr2_wa(struct elink_params *params,
 	/* In case KR2 is already disabled, check if we need to re-enable it */
 	if (!(vars->link_attr_sync & LINK_ATTR_SYNC_KR2_ENABLE)) {
 		if (!not_kr2_device) {
-			PMD_DRV_LOG(DEBUG, "BP=0x%x, NP=0x%x", base_page,
+			PMD_DRV_LOG(DEBUG, sc, "BP=0x%x, NP=0x%x", base_page,
 				    next_page);
 			elink_kr2_recovery(params, vars, phy);
 		}
@@ -12932,7 +12950,8 @@ static void elink_check_kr2_wa(struct elink_params *params,
 	/* KR2 is enabled, but not KR2 device */
 	if (not_kr2_device) {
 		/* Disable KR2 on both lanes */
-		PMD_DRV_LOG(DEBUG, "BP=0x%x, NP=0x%x", base_page, next_page);
+		PMD_DRV_LOG(DEBUG, sc,
+			    "BP=0x%x, NP=0x%x", base_page, next_page);
 		elink_disable_kr2(params, vars, phy);
 		/* Restart AN on leading lane */
 		elink_warpcore_restart_AN_KR(phy, params);
@@ -12949,7 +12968,7 @@ void elink_period_func(struct elink_params *params, struct elink_vars *vars)
 			elink_set_aer_mmd(params, &params->phy[phy_idx]);
 			if (elink_check_half_open_conn(params, vars, 1) !=
 			    ELINK_STATUS_OK) {
-				PMD_DRV_LOG(DEBUG, "Fault detection failed");
+				PMD_DRV_LOG(DEBUG, sc, "Fault detection failed");
 			}
 			break;
 		}
@@ -12995,7 +13014,7 @@ uint8_t elink_fan_failure_det_req(struct bnx2x_softc *sc,
 		if (elink_populate_phy(sc, phy_index, shmem_base, shmem2_base,
 				       port, &phy)
 		    != ELINK_STATUS_OK) {
-			PMD_DRV_LOG(DEBUG, "populate phy failed");
+			PMD_DRV_LOG(DEBUG, sc, "populate phy failed");
 			return 0;
 		}
 		fan_failure_det_req |= (phy.flags &
@@ -13045,7 +13064,7 @@ void elink_init_mod_abs_int(struct bnx2x_softc *sc, struct elink_vars *vars,
 			if (elink_populate_phy(sc, phy_index, shmem_base,
 					       shmem2_base, port, &phy)
 			    != ELINK_STATUS_OK) {
-				PMD_DRV_LOG(DEBUG, "populate phy failed");
+				PMD_DRV_LOG(DEBUG, sc, "populate phy failed");
 				return;
 			}
 			if (phy.type == PORT_HW_CFG_XGXS_EXT_PHY_TYPE_BNX2X8726) {
@@ -13075,7 +13094,7 @@ void elink_init_mod_abs_int(struct bnx2x_softc *sc, struct elink_vars *vars,
 		     dev_info.port_hw_config[port].aeu_int_mask);
 	REG_WR(sc, sync_offset, vars->aeu_int_mask);
 
-	PMD_DRV_LOG(DEBUG, "Setting MOD_ABS (GPIO%d_P%d) AEU to 0x%x",
+	PMD_DRV_LOG(DEBUG, sc, "Setting MOD_ABS (GPIO%d_P%d) AEU to 0x%x",
 		    gpio_num, gpio_port, vars->aeu_int_mask);
 
 	if (port == 0)
diff --git a/drivers/net/bnxt/bnxt.h b/drivers/net/bnxt/bnxt.h
index b934605e..dc867b12 100644
--- a/drivers/net/bnxt/bnxt.h
+++ b/drivers/net/bnxt/bnxt.h
@@ -132,6 +132,7 @@ struct bnxt {
 	uint32_t		flags;
 #define BNXT_FLAG_REGISTERED	(1 << 0)
 #define BNXT_FLAG_VF		(1 << 1)
+#define BNXT_FLAG_DFLT_VNIC_SET	(1 << 12)
 #define BNXT_PF(bp)		(!((bp)->flags & BNXT_FLAG_VF))
 #define BNXT_VF(bp)		((bp)->flags & BNXT_FLAG_VF)
 #define BNXT_NPAR_ENABLED(bp)	((bp)->port_partition_type)
diff --git a/drivers/net/bnxt/bnxt_hwrm.c b/drivers/net/bnxt/bnxt_hwrm.c
index d65e28be..dd99c578 100644
--- a/drivers/net/bnxt/bnxt_hwrm.c
+++ b/drivers/net/bnxt/bnxt_hwrm.c
@@ -50,7 +50,7 @@
 #include "bnxt_vnic.h"
 #include "hsi_struct_def_dpdk.h"
 
-#define HWRM_CMD_TIMEOUT		2000
+#define HWRM_CMD_TIMEOUT		6000000
 
 /*
  * HWRM Functions (sent to HWRM)
@@ -97,7 +97,7 @@ static int bnxt_hwrm_send_message_locked(struct bnxt *bp, void *msg,
 			if (*valid == HWRM_RESP_VALID_KEY)
 				break;
 		}
-		rte_delay_us(600);
+		rte_delay_us(1);
 	}
 
 	if (i >= HWRM_CMD_TIMEOUT) {
@@ -232,6 +232,8 @@ int bnxt_hwrm_set_filter(struct bnxt *bp,
 	HWRM_PREP(req, CFA_L2_FILTER_ALLOC, -1, resp);
 
 	req.flags = rte_cpu_to_le_32(filter->flags);
+	req.flags |=
+	rte_cpu_to_le_32(HWRM_CFA_L2_FILTER_ALLOC_INPUT_FLAGS_OUTERMOST);
 
 	enables = filter->enables |
 	      HWRM_CFA_L2_FILTER_ALLOC_INPUT_ENABLES_DST_ID;
@@ -379,7 +381,6 @@ int bnxt_hwrm_ver_get(struct bnxt *bp)
 	int rc = 0;
 	struct hwrm_ver_get_input req = {.req_type = 0 };
 	struct hwrm_ver_get_output *resp = bp->hwrm_cmd_resp_addr;
-	uint32_t my_version;
 	uint32_t fw_version;
 	uint16_t max_resp_len;
 	char type[RTE_MEMZONE_NAMESIZE];
@@ -405,10 +406,6 @@ int bnxt_hwrm_ver_get(struct bnxt *bp)
 	RTE_LOG(INFO, PMD, "Driver HWRM version: %d.%d.%d\n",
 		HWRM_VERSION_MAJOR, HWRM_VERSION_MINOR, HWRM_VERSION_UPDATE);
 
-	my_version = HWRM_VERSION_MAJOR << 16;
-	my_version |= HWRM_VERSION_MINOR << 8;
-	my_version |= HWRM_VERSION_UPDATE;
-
 	fw_version = resp->hwrm_intf_maj << 16;
 	fw_version |= resp->hwrm_intf_min << 8;
 	fw_version |= resp->hwrm_intf_upd;
@@ -419,21 +416,6 @@ int bnxt_hwrm_ver_get(struct bnxt *bp)
 		goto error;
 	}
 
-	if (my_version != fw_version) {
-		RTE_LOG(INFO, PMD, "BNXT Driver/HWRM API mismatch.\n");
-		if (my_version < fw_version) {
-			RTE_LOG(INFO, PMD,
-				"Firmware API version is newer than driver.\n");
-			RTE_LOG(INFO, PMD,
-				"The driver may be missing features.\n");
-		} else {
-			RTE_LOG(INFO, PMD,
-				"Firmware API version is older than driver.\n");
-			RTE_LOG(INFO, PMD,
-				"Not all driver features may be functional.\n");
-		}
-	}
-
 	if (bp->max_req_len > resp->max_req_win_len) {
 		RTE_LOG(ERR, PMD, "Unsupported request length\n");
 		rc = -EINVAL;
@@ -898,8 +880,11 @@ int bnxt_hwrm_vnic_cfg(struct bnxt *bp, struct bnxt_vnic_info *vnic)
 	req.lb_rule = rte_cpu_to_le_16(0xffff);
 	req.mru = rte_cpu_to_le_16(bp->eth_dev->data->mtu + ETHER_HDR_LEN +
 				   ETHER_CRC_LEN + VLAN_TAG_SIZE);
-	if (vnic->func_default)
+	/* Configure default VNIC only once. */
+	if (vnic->func_default && !(bp->flags & BNXT_FLAG_DFLT_VNIC_SET)) {
 		req.flags = 1;
+		bp->flags |= BNXT_FLAG_DFLT_VNIC_SET;
+	}
 	if (vnic->vlan_strip)
 		req.flags |=
 		    rte_cpu_to_le_32(HWRM_VNIC_CFG_INPUT_FLAGS_VLAN_STRIP_MODE);
@@ -976,6 +961,10 @@ int bnxt_hwrm_vnic_free(struct bnxt *bp, struct bnxt_vnic_info *vnic)
 	HWRM_CHECK_RESULT;
 
 	vnic->fw_vnic_id = INVALID_HW_RING_ID;
+	/* Configure default VNIC again if necessary. */
+	if (vnic->func_default && (bp->flags & BNXT_FLAG_DFLT_VNIC_SET))
+		bp->flags &= ~BNXT_FLAG_DFLT_VNIC_SET;
+
 	return rc;
 }
 
diff --git a/drivers/net/bnxt/bnxt_txr.c b/drivers/net/bnxt/bnxt_txr.c
index ff24e232..f1e1616b 100644
--- a/drivers/net/bnxt/bnxt_txr.c
+++ b/drivers/net/bnxt/bnxt_txr.c
@@ -146,7 +146,7 @@ static uint16_t bnxt_start_xmit(struct rte_mbuf *tx_pkt,
 {
 	struct bnxt_tx_ring_info *txr = txq->tx_ring;
 	struct tx_bd_long *txbd;
-	struct tx_bd_long_hi *txbd1;
+	struct tx_bd_long_hi *txbd1 = NULL;
 	uint32_t vlan_tag_flags, cfa_action;
 	bool long_bd = false;
 	uint16_t last_prod = 0;
@@ -313,7 +313,8 @@ static uint16_t bnxt_start_xmit(struct rte_mbuf *tx_pkt,
 	}
 
 	txbd->flags_type |= TX_BD_LONG_FLAGS_PACKET_END;
-	txbd1->lflags = rte_cpu_to_le_32(txbd1->lflags);
+	if (txbd1)
+		txbd1->lflags = rte_cpu_to_le_32(txbd1->lflags);
 
 	txr->tx_prod = RING_NEXT(txr->tx_ring_struct, txr->tx_prod);
 
diff --git a/drivers/net/bonding/rte_eth_bond_pmd.c b/drivers/net/bonding/rte_eth_bond_pmd.c
index 6081918e..103f5585 100644
--- a/drivers/net/bonding/rte_eth_bond_pmd.c
+++ b/drivers/net/bonding/rte_eth_bond_pmd.c
@@ -1,7 +1,7 @@
 /*-
  *   BSD LICENSE
  *
- *   Copyright(c) 2010-2015 Intel Corporation. All rights reserved.
+ *   Copyright(c) 2010-2017 Intel Corporation. All rights reserved.
  *   All rights reserved.
  *
  *   Redistribution and use in source and binary forms, with or without
@@ -62,7 +62,8 @@ get_vlan_offset(struct ether_hdr *eth_hdr, uint16_t *proto)
 {
 	size_t vlan_offset = 0;
 
-	if (rte_cpu_to_be_16(ETHER_TYPE_VLAN) == *proto) {
+	if (rte_cpu_to_be_16(ETHER_TYPE_VLAN) == *proto ||
+		rte_cpu_to_be_16(ETHER_TYPE_QINQ) == *proto) {
 		struct vlan_hdr *vlan_hdr = (struct vlan_hdr *)(eth_hdr + 1);
 
 		vlan_offset = sizeof(struct vlan_hdr);
@@ -82,28 +83,34 @@ bond_ethdev_rx_burst(void *queue, struct rte_mbuf **bufs, uint16_t nb_pkts)
 {
 	struct bond_dev_private *internals;
 
-	uint16_t num_rx_slave = 0;
 	uint16_t num_rx_total = 0;
-
+	uint16_t slave_count;
+	uint16_t active_slave;
 	int i;
 
 	/* Cast to structure, containing bonded device's port id and queue id */
 	struct bond_rx_queue *bd_rx_q = (struct bond_rx_queue *)queue;
-
 	internals = bd_rx_q->dev_private;
+	slave_count = internals->active_slave_count;
+	active_slave = internals->active_slave;
 
+	for (i = 0; i < slave_count && nb_pkts; i++) {
+		uint16_t num_rx_slave;
 
-	for (i = 0; i < internals->active_slave_count && nb_pkts; i++) {
 		/* Offset of pointer to *bufs increases as packets are received
 		 * from other slaves */
-		num_rx_slave = rte_eth_rx_burst(internals->active_slaves[i],
-				bd_rx_q->queue_id, bufs + num_rx_total, nb_pkts);
-		if (num_rx_slave) {
-			num_rx_total += num_rx_slave;
-			nb_pkts -= num_rx_slave;
-		}
-	}
-
+		num_rx_slave =
+			rte_eth_rx_burst(internals->active_slaves[active_slave],
+					 bd_rx_q->queue_id,
+					 bufs + num_rx_total, nb_pkts);
+		num_rx_total += num_rx_slave;
+		nb_pkts -= num_rx_slave;
+		if (++active_slave == slave_count)
+			active_slave = 0;
+	}
+
+	if (++internals->active_slave == slave_count)
+		internals->active_slave = 0;
 	return num_rx_total;
 }
 
@@ -145,7 +152,7 @@ bond_ethdev_rx_burst_8023ad(void *queue, struct rte_mbuf **bufs,
 	const uint16_t ether_type_slow_be = rte_be_to_cpu_16(ETHER_TYPE_SLOW);
 	uint16_t num_rx_total = 0;	/* Total number of received packets */
 	uint8_t slaves[RTE_MAX_ETHPORTS];
-	uint8_t slave_count;
+	uint8_t slave_count, idx;
 
 	uint8_t collecting;  /* current slave collecting status */
 	const uint8_t promisc = internals->promiscuous_en;
@@ -159,12 +166,18 @@ bond_ethdev_rx_burst_8023ad(void *queue, struct rte_mbuf **bufs,
 	memcpy(slaves, internals->active_slaves,
 			sizeof(internals->active_slaves[0]) * slave_count);
 
+	idx = internals->active_slave;
+	if (idx >= slave_count) {
+		internals->active_slave = 0;
+		idx = 0;
+	}
 	for (i = 0; i < slave_count && num_rx_total < nb_pkts; i++) {
 		j = num_rx_total;
-		collecting = ACTOR_STATE(&mode_8023ad_ports[slaves[i]], COLLECTING);
+		collecting = ACTOR_STATE(&mode_8023ad_ports[slaves[idx]],
+					 COLLECTING);
 
 		/* Read packets from this slave */
-		num_rx_total += rte_eth_rx_burst(slaves[i], bd_rx_q->queue_id,
+		num_rx_total += rte_eth_rx_burst(slaves[idx], bd_rx_q->queue_id,
 				&bufs[num_rx_total], nb_pkts - num_rx_total);
 
 		for (k = j; k < 2 && k < num_rx_total; k++)
@@ -187,8 +200,8 @@ bond_ethdev_rx_burst_8023ad(void *queue, struct rte_mbuf **bufs,
 					!is_same_ether_addr(&bond_mac, &hdr->d_addr)))) {
 
 				if (hdr->ether_type == ether_type_slow_be) {
-					bond_mode_8023ad_handle_slow_pkt(internals, slaves[i],
-						bufs[j]);
+					bond_mode_8023ad_handle_slow_pkt(
+					    internals, slaves[idx], bufs[j]);
 				} else
 					rte_pktmbuf_free(bufs[j]);
 
@@ -201,8 +214,13 @@ bond_ethdev_rx_burst_8023ad(void *queue, struct rte_mbuf **bufs,
 			} else
 				j++;
 		}
+		if (unlikely(++idx == slave_count))
+			idx = 0;
 	}
 
+	if (++internals->active_slave == slave_count)
+		internals->active_slave = 0;
+
 	return num_rx_total;
 }
 
@@ -1324,6 +1342,9 @@ slave_configure(struct rte_eth_dev *bonded_eth_dev,
 	int errval;
 	uint16_t q_id;
 
+	struct bond_dev_private *internals = (struct bond_dev_private *)
+		bonded_eth_dev->data->dev_private;
+
 	/* Stop slave */
 	rte_eth_dev_stop(slave_eth_dev->data->port_id);
 
@@ -1333,12 +1354,11 @@ slave_configure(struct rte_eth_dev *bonded_eth_dev,
 
 	/* If RSS is enabled for bonding, try to enable it for slaves  */
 	if (bonded_eth_dev->data->dev_conf.rxmode.mq_mode & ETH_MQ_RX_RSS_FLAG) {
-		if (bonded_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key_len
-				!= 0) {
+		if (internals->rss_key_len != 0) {
 			slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key_len =
-					bonded_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key_len;
+					internals->rss_key_len;
 			slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key =
-					bonded_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key;
+					internals->rss_key;
 		} else {
 			slave_eth_dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key = NULL;
 		}
@@ -1649,12 +1669,20 @@ bond_ethdev_stop(struct rte_eth_dev *eth_dev)
 			tlb_last_obytets[internals->active_slaves[i]] = 0;
 	}
 
-	internals->link_status_polling_enabled = 0;
-	for (i = 0; i < internals->slave_count; i++)
-		internals->slaves[i].last_link_status = 0;
-
 	eth_dev->data->dev_link.link_status = ETH_LINK_DOWN;
 	eth_dev->data->dev_started = 0;
+
+	internals->link_status_polling_enabled = 0;
+	for (i = 0; i < internals->slave_count; i++) {
+		uint16_t slave_id = internals->slaves[i].port_id;
+		if (find_slave_by_id(internals->active_slaves,
+				internals->active_slave_count, slave_id) !=
+						internals->active_slave_count) {
+			internals->slaves[i].last_link_status = 0;
+			rte_eth_dev_stop(slave_id);
+			deactivate_slave(eth_dev, slave_id);
+		}
+	}
 }
 
 void
@@ -2371,16 +2399,30 @@ bond_ethdev_configure(struct rte_eth_dev *dev)
 
 	unsigned i, j;
 
-	/* If RSS is enabled, fill table and key with default values */
+	/*
+	 * If RSS is enabled, fill table with default values and
+	 * set key to the the value specified in port RSS configuration.
+	 * Fall back to default RSS key if the key is not specified
+	 */
 	if (dev->data->dev_conf.rxmode.mq_mode & ETH_MQ_RX_RSS) {
-		dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key = internals->rss_key;
-		dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key_len = 0;
-		memcpy(internals->rss_key, default_rss_key, 40);
+		if (dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key != NULL) {
+			internals->rss_key_len =
+				dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key_len;
+			memcpy(internals->rss_key,
+			       dev->data->dev_conf.rx_adv_conf.rss_conf.rss_key,
+			       internals->rss_key_len);
+		} else {
+			internals->rss_key_len = sizeof(default_rss_key);
+			memcpy(internals->rss_key, default_rss_key,
+			       internals->rss_key_len);
+		}
 
 		for (i = 0; i < RTE_DIM(internals->reta_conf); i++) {
 			internals->reta_conf[i].mask = ~0LL;
 			for (j = 0; j < RTE_RETA_GROUP_SIZE; j++)
-				internals->reta_conf[i].reta[j] = j % dev->data->nb_rx_queues;
+				internals->reta_conf[i].reta[j] =
+						(i * RTE_RETA_GROUP_SIZE + j) %
+						dev->data->nb_rx_queues;
 		}
 	}
 
diff --git a/drivers/net/bonding/rte_eth_bond_private.h b/drivers/net/bonding/rte_eth_bond_private.h
index d95d440b..8c963ddb 100644
--- a/drivers/net/bonding/rte_eth_bond_private.h
+++ b/drivers/net/bonding/rte_eth_bond_private.h
@@ -1,7 +1,7 @@
 /*-
  *   BSD LICENSE
  *
- *   Copyright(c) 2010-2015 Intel Corporation. All rights reserved.
+ *   Copyright(c) 2010-2017 Intel Corporation. All rights reserved.
  *   All rights reserved.
  *
  *   Redistribution and use in source and binary forms, with or without
@@ -144,6 +144,7 @@ struct bond_dev_private {
 	uint16_t nb_rx_queues;			/**< Total number of rx queues */
 	uint16_t nb_tx_queues;			/**< Total number of tx queues*/
 
+	uint8_t active_slave;		/**< Next active_slave to poll */
 	uint8_t active_slave_count;		/**< Number of active slaves */
 	uint8_t active_slaves[RTE_MAX_ETHPORTS];	/**< Active slave list */
 
diff --git a/drivers/net/e1000/base/e1000_i210.c b/drivers/net/e1000/base/e1000_i210.c
index 277331c4..c2abb43f 100644
--- a/drivers/net/e1000/base/e1000_i210.c
+++ b/drivers/net/e1000/base/e1000_i210.c
@@ -941,6 +941,7 @@ STATIC s32 e1000_pll_workaround_i210(struct e1000_hw *hw)
 	if (ret_val != E1000_SUCCESS)
 		nvm_word = E1000_INVM_DEFAULT_AL;
 	tmp_nvm = nvm_word | E1000_INVM_PLL_WO_VAL;
+	phy_word = E1000_PHY_PLL_UNCONF;
 	for (i = 0; i < E1000_MAX_PLL_TRIES; i++) {
 		/* check current state directly from internal PHY */
 		e1000_read_phy_reg_gs40g(hw, (E1000_PHY_PLL_FREQ_PAGE |
diff --git a/drivers/net/e1000/em_rxtx.c b/drivers/net/e1000/em_rxtx.c
index 41f51c0f..371bb620 100644
--- a/drivers/net/e1000/em_rxtx.c
+++ b/drivers/net/e1000/em_rxtx.c
@@ -1323,12 +1323,13 @@ eth_em_rx_queue_setup(struct rte_eth_dev *dev,
 	}
 
 	/*
-	 * EM devices don't support drop_en functionality
+	 * EM devices don't support drop_en functionality.
+	 * It's an optimization that does nothing on single-queue devices,
+	 * so just log the issue and carry on.
 	 */
 	if (rx_conf->rx_drop_en) {
-		PMD_INIT_LOG(ERR, "drop_en functionality not supported by "
+		PMD_INIT_LOG(NOTICE, "drop_en functionality not supported by "
 			     "device");
-		return -EINVAL;
 	}
 
 	/* Free memory prior to re-allocation if needed. */
diff --git a/drivers/net/e1000/igb_rxtx.c b/drivers/net/e1000/igb_rxtx.c
index 556d4605..4d112771 100644
--- a/drivers/net/e1000/igb_rxtx.c
+++ b/drivers/net/e1000/igb_rxtx.c
@@ -73,6 +73,10 @@
 
 /* Bit Mask to indicate what bits required for building TX context */
 #define IGB_TX_OFFLOAD_MASK (			 \
+		PKT_TX_OUTER_IPV6 |	 \
+		PKT_TX_OUTER_IPV4 |	 \
+		PKT_TX_IPV6 |		 \
+		PKT_TX_IPV4 |		 \
 		PKT_TX_VLAN_PKT |		 \
 		PKT_TX_IP_CKSUM |		 \
 		PKT_TX_L4_MASK |		 \
diff --git a/drivers/net/ena/ena_ethdev.c b/drivers/net/ena/ena_ethdev.c
index 1511c6a0..7de63e6c 100644
--- a/drivers/net/ena/ena_ethdev.c
+++ b/drivers/net/ena/ena_ethdev.c
@@ -1553,7 +1553,7 @@ static uint16_t eth_ena_recv_pkts(void *rx_queue, struct rte_mbuf **rx_pkts,
 
 		/* fill mbuf attributes if any */
 		ena_rx_mbuf_prepare(mbuf_head, &ena_rx_ctx);
-		mbuf_head->hash.rss = (uint32_t)rx_ring->id;
+		mbuf_head->hash.rss = ena_rx_ctx.hash;
 
 		/* pass to DPDK application head mbuf */
 		rx_pkts[recv_idx] = mbuf_head;
diff --git a/drivers/net/enic/Makefile b/drivers/net/enic/Makefile
index 3926b795..3ed1d90a 100644
--- a/drivers/net/enic/Makefile
+++ b/drivers/net/enic/Makefile
@@ -68,5 +68,6 @@ DEPDIRS-$(CONFIG_RTE_LIBRTE_ENIC_PMD) += lib/librte_eal lib/librte_ether
 DEPDIRS-$(CONFIG_RTE_LIBRTE_ENIC_PMD) += lib/librte_mempool lib/librte_mbuf
 DEPDIRS-$(CONFIG_RTE_LIBRTE_ENIC_PMD) += lib/librte_net
 DEPDIRS-$(CONFIG_RTE_LIBRTE_ENIC_PMD) += lib/librte_hash
+DEPDIRS-$(CONFIG_RTE_LIBRTE_ENIC_PMD) += lib/librte_kvargs
 
 include $(RTE_SDK)/mk/rte.lib.mk
diff --git a/drivers/net/enic/base/vnic_devcmd.h b/drivers/net/enic/base/vnic_devcmd.h
index 785fd6fd..a9496262 100644
--- a/drivers/net/enic/base/vnic_devcmd.h
+++ b/drivers/net/enic/base/vnic_devcmd.h
@@ -895,9 +895,9 @@ enum {
 };
 
 struct filter_tlv {
-	u_int32_t type;
-	u_int32_t length;
-	u_int32_t val[0];
+	uint32_t type;
+	uint32_t length;
+	uint32_t val[0];
 };
 
 /* Data for CMD_ADD_FILTER is 2 TLV and filter + action structs */
@@ -911,10 +911,10 @@ struct filter_tlv {
  * drivers should use this instead of "sizeof (struct filter_v2)" when
  * computing length for TLV.
  */
-static inline u_int32_t
+static inline uint32_t
 vnic_filter_size(struct filter_v2 *fp)
 {
-	u_int32_t size;
+	uint32_t size;
 
 	switch (fp->type) {
 	case FILTER_USNIC_ID:
diff --git a/drivers/net/enic/enic.h b/drivers/net/enic/enic.h
index 46f20b2d..4782faac 100644
--- a/drivers/net/enic/enic.h
+++ b/drivers/net/enic/enic.h
@@ -127,6 +127,7 @@ struct enic {
 	u8 hw_ip_checksum;
 	u16 max_mtu;
 	u16 adv_filters;
+	uint8_t ig_vlan_rewrite_mode; /* devargs ig-vlan-rewrite */
 
 	unsigned int flags;
 	unsigned int priv_flags;
diff --git a/drivers/net/enic/enic_ethdev.c b/drivers/net/enic/enic_ethdev.c
index 17479d4d..31614f3f 100644
--- a/drivers/net/enic/enic_ethdev.c
+++ b/drivers/net/enic/enic_ethdev.c
@@ -38,6 +38,7 @@
 #include <rte_dev.h>
 #include <rte_pci.h>
 #include <rte_ethdev.h>
+#include <rte_kvargs.h>
 #include <rte_string_fns.h>
 
 #include "vnic_intr.h"
@@ -64,6 +65,8 @@ static const struct rte_pci_id pci_id_enic_map[] = {
 	{.vendor_id = 0, /* sentinel */},
 };
 
+#define ENIC_DEVARG_IG_VLAN_REWRITE "ig-vlan-rewrite"
+
 static int
 enicpmd_fdir_ctrl_func(struct rte_eth_dev *eth_dev,
 			enum rte_filter_op filter_op, void *arg)
@@ -589,7 +592,64 @@ static const struct eth_dev_ops enicpmd_eth_dev_ops = {
 	.filter_ctrl          = enicpmd_dev_filter_ctrl,
 };
 
-struct enic *enicpmd_list_head = NULL;
+static int enic_parse_ig_vlan_rewrite(__rte_unused const char *key,
+				      const char *value,
+				      void *opaque)
+{
+	struct enic *enic;
+
+	enic = (struct enic *)opaque;
+	if (strcmp(value, "trunk") == 0) {
+		/* Trunk mode: always tag */
+		enic->ig_vlan_rewrite_mode = IG_VLAN_REWRITE_MODE_DEFAULT_TRUNK;
+	} else if (strcmp(value, "untag") == 0) {
+		/* Untag default VLAN mode: untag if VLAN = default VLAN */
+		enic->ig_vlan_rewrite_mode =
+			IG_VLAN_REWRITE_MODE_UNTAG_DEFAULT_VLAN;
+	} else if (strcmp(value, "priority") == 0) {
+		/*
+		 * Priority-tag default VLAN mode: priority tag (VLAN header
+		 * with ID=0) if VLAN = default
+		 */
+		enic->ig_vlan_rewrite_mode =
+			IG_VLAN_REWRITE_MODE_PRIORITY_TAG_DEFAULT_VLAN;
+	} else if (strcmp(value, "pass") == 0) {
+		/* Pass through mode: do not touch tags */
+		enic->ig_vlan_rewrite_mode = IG_VLAN_REWRITE_MODE_PASS_THRU;
+	} else {
+		dev_err(enic, "Invalid value for " ENIC_DEVARG_IG_VLAN_REWRITE
+			": expected=trunk|untag|priority|pass given=%s\n",
+			value);
+		return -EINVAL;
+	}
+	return 0;
+}
+
+static int enic_check_devargs(struct rte_eth_dev *dev)
+{
+	static const char *valid_keys[] = {
+		ENIC_DEVARG_IG_VLAN_REWRITE,
+		NULL};
+	struct enic *enic = pmd_priv(dev);
+	struct rte_kvargs *kvlist;
+
+	ENICPMD_FUNC_TRACE();
+
+	enic->ig_vlan_rewrite_mode = IG_VLAN_REWRITE_MODE_PASS_THRU;
+	if (!dev->pci_dev->device.devargs)
+		return 0;
+	kvlist = rte_kvargs_parse(dev->pci_dev->device.devargs->args, valid_keys);
+	if (!kvlist)
+		return -EINVAL;
+	if (rte_kvargs_process(kvlist, ENIC_DEVARG_IG_VLAN_REWRITE,
+			       enic_parse_ig_vlan_rewrite, enic) < 0) {
+		rte_kvargs_free(kvlist);
+		return -EINVAL;
+	}
+	rte_kvargs_free(kvlist);
+	return 0;
+}
+
 /* Initialize the driver
  * It returns 0 on success.
  */
@@ -598,6 +658,7 @@ static int eth_enicpmd_dev_init(struct rte_eth_dev *eth_dev)
 	struct rte_pci_device *pdev;
 	struct rte_pci_addr *addr;
 	struct enic *enic = pmd_priv(eth_dev);
+	int err;
 
 	ENICPMD_FUNC_TRACE();
 
@@ -615,6 +676,9 @@ static int eth_enicpmd_dev_init(struct rte_eth_dev *eth_dev)
 	snprintf(enic->bdf_name, ENICPMD_BDF_LENGTH, "%04x:%02x:%02x.%x",
 		addr->domain, addr->bus, addr->devid, addr->function);
 
+	err = enic_check_devargs(eth_dev);
+	if (err)
+		return err;
 	return enic_probe(enic);
 }
 
@@ -631,3 +695,5 @@ static struct eth_driver rte_enic_pmd = {
 
 RTE_PMD_REGISTER_PCI(net_enic, rte_enic_pmd.pci_drv);
 RTE_PMD_REGISTER_PCI_TABLE(net_enic, pci_id_enic_map);
+RTE_PMD_REGISTER_PARAM_STRING(net_enic,
+	ENIC_DEVARG_IG_VLAN_REWRITE "=trunk|untag|priority|pass");
diff --git a/drivers/net/enic/enic_main.c b/drivers/net/enic/enic_main.c
index 17606238..f687b3fc 100644
--- a/drivers/net/enic/enic_main.c
+++ b/drivers/net/enic/enic_main.c
@@ -1394,8 +1394,10 @@ int enic_probe(struct enic *enic)
 	}
 
 	/* Set ingress vlan rewrite mode before vnic initialization */
+	dev_debug(enic, "Set ig_vlan_rewrite_mode=%u\n",
+		  enic->ig_vlan_rewrite_mode);
 	err = vnic_dev_set_ig_vlan_rewrite_mode(enic->vdev,
-		IG_VLAN_REWRITE_MODE_PASS_THRU);
+		enic->ig_vlan_rewrite_mode);
 	if (err) {
 		dev_err(enic,
 			"Failed to set ingress vlan rewrite mode, aborting.\n");
diff --git a/drivers/net/enic/enic_rxtx.c b/drivers/net/enic/enic_rxtx.c
index 1934f8ba..0cfde468 100644
--- a/drivers/net/enic/enic_rxtx.c
+++ b/drivers/net/enic/enic_rxtx.c
@@ -189,10 +189,12 @@ enic_cq_rx_to_pkt_flags(struct cq_desc *cqd, struct rte_mbuf *mbuf)
 		pkt_flags |= PKT_RX_VLAN_PKT | PKT_RX_VLAN_STRIPPED;
 		mbuf->packet_type |= RTE_PTYPE_L2_ETHER;
 	} else {
-		if (vlan_tci != 0)
+		if (vlan_tci != 0) {
+			pkt_flags |= PKT_RX_VLAN_PKT;
 			mbuf->packet_type |= RTE_PTYPE_L2_ETHER_VLAN;
-		else
+		} else {
 			mbuf->packet_type |= RTE_PTYPE_L2_ETHER;
+		}
 	}
 	mbuf->vlan_tci = vlan_tci;
 
diff --git a/drivers/net/fm10k/fm10k_ethdev.c b/drivers/net/fm10k/fm10k_ethdev.c
index 0fac816f..f8f6d37d 100644
--- a/drivers/net/fm10k/fm10k_ethdev.c
+++ b/drivers/net/fm10k/fm10k_ethdev.c
@@ -482,11 +482,6 @@ fm10k_dev_configure(struct rte_eth_dev *dev)
 	return 0;
 }
 
-/* fls = find last set bit = 32 minus the number of leading zeros */
-#ifndef fls
-#define fls(x) (((x) == 0) ? 0 : (32 - __builtin_clz((x))))
-#endif
-
 static void
 fm10k_dev_vmdq_rx_configure(struct rte_eth_dev *dev)
 {
@@ -1059,8 +1054,8 @@ fm10k_dev_dglort_map_configure(struct rte_eth_dev *dev)
 
 	macvlan = FM10K_DEV_PRIVATE_TO_MACVLAN(dev->data->dev_private);
 	nb_queue_pools = macvlan->nb_queue_pools;
-	pool_len = nb_queue_pools ? fls(nb_queue_pools - 1) : 0;
-	rss_len = fls(dev->data->nb_rx_queues - 1) - pool_len;
+	pool_len = nb_queue_pools ? rte_fls_u32(nb_queue_pools - 1) : 0;
+	rss_len = rte_fls_u32(dev->data->nb_rx_queues - 1) - pool_len;
 
 	/* GLORT 0x0-0x3F are used by PF and VMDQ,  0x40-0x7F used by FD */
 	dglortdec = (rss_len << FM10K_DGLORTDEC_RSSLENGTH_SHIFT) | pool_len;
@@ -1071,7 +1066,7 @@ fm10k_dev_dglort_map_configure(struct rte_eth_dev *dev)
 	FM10K_WRITE_REG(hw, FM10K_DGLORTDEC(0), dglortdec);
 
 	/* Flow Director configurations, only queue number is valid. */
-	dglortdec = fls(dev->data->nb_rx_queues - 1);
+	dglortdec = rte_fls_u32(dev->data->nb_rx_queues - 1);
 	dglortmask = (GLORT_FD_MASK << FM10K_DGLORTMAP_MASK_SHIFT) |
 			(hw->mac.dglort_map + GLORT_FD_Q_BASE);
 	FM10K_WRITE_REG(hw, FM10K_DGLORTMAP(1), dglortmask);
diff --git a/drivers/net/i40e/base/i40e_adminq.c b/drivers/net/i40e/base/i40e_adminq.c
index e231582c..4d3f938e 100644
--- a/drivers/net/i40e/base/i40e_adminq.c
+++ b/drivers/net/i40e/base/i40e_adminq.c
@@ -126,6 +126,7 @@ enum i40e_status_code i40e_alloc_adminq_arq_ring(struct i40e_hw *hw)
  **/
 void i40e_free_adminq_asq(struct i40e_hw *hw)
 {
+	i40e_free_virt_mem(hw, &hw->aq.asq.cmd_buf);
 	i40e_free_dma_mem(hw, &hw->aq.asq.desc_buf);
 }
 
@@ -433,7 +434,7 @@ enum i40e_status_code i40e_init_asq(struct i40e_hw *hw)
 	/* initialize base registers */
 	ret_code = i40e_config_asq_regs(hw);
 	if (ret_code != I40E_SUCCESS)
-		goto init_adminq_free_rings;
+		goto init_config_regs;
 
 	/* success! */
 	hw->aq.asq.count = hw->aq.num_asq_entries;
@@ -441,6 +442,10 @@ enum i40e_status_code i40e_init_asq(struct i40e_hw *hw)
 
 init_adminq_free_rings:
 	i40e_free_adminq_asq(hw);
+	return ret_code;
+
+init_config_regs:
+	i40e_free_asq_bufs(hw);
 
 init_adminq_exit:
 	return ret_code;
diff --git a/drivers/net/i40e/base/i40e_common.c b/drivers/net/i40e/base/i40e_common.c
index de60e2a1..8ba75c73 100644
--- a/drivers/net/i40e/base/i40e_common.c
+++ b/drivers/net/i40e/base/i40e_common.c
@@ -1348,7 +1348,7 @@ enum i40e_status_code i40e_pf_reset(struct i40e_hw *hw)
 			I40E_GLGEN_RSTCTL_GRSTDEL_MASK) >>
 			I40E_GLGEN_RSTCTL_GRSTDEL_SHIFT;
 
-	grst_del = grst_del * 20;
+	grst_del = min(grst_del * 20, 160U);
 
 	for (cnt = 0; cnt < grst_del; cnt++) {
 		reg = rd32(hw, I40E_GLGEN_RSTAT);
@@ -3574,9 +3574,10 @@ STATIC void i40e_parse_discover_capabilities(struct i40e_hw *hw, void *buff,
 	u32 valid_functions, num_functions;
 	u32 number, logical_id, phys_id;
 	struct i40e_hw_capabilities *p;
+	enum i40e_status_code status;
+	u16 id, ocp_cfg_word0;
 	u8 major_rev;
 	u32 i = 0;
-	u16 id;
 
 	cap = (struct i40e_aqc_list_capabilities_element_resp *) buff;
 
@@ -3863,6 +3864,26 @@ STATIC void i40e_parse_discover_capabilities(struct i40e_hw *hw, void *buff,
 			hw->num_ports++;
 	}
 
+	/* OCP cards case: if a mezz is removed the ethernet port is at
+	 * disabled state in PRTGEN_CNF register. Additional NVM read is
+	 * needed in order to check if we are dealing with OCP card.
+	 * Those cards have 4 PFs at minimum, so using PRTGEN_CNF for counting
+	 * physical ports results in wrong partition id calculation and thus
+	 * not supporting WoL.
+	 */
+	if (hw->mac.type == I40E_MAC_X722) {
+		if (i40e_acquire_nvm(hw, I40E_RESOURCE_READ) == I40E_SUCCESS) {
+			status = i40e_aq_read_nvm(hw, I40E_SR_EMP_MODULE_PTR,
+						  2 * I40E_SR_OCP_CFG_WORD0,
+						  sizeof(ocp_cfg_word0),
+						  &ocp_cfg_word0, true, NULL);
+			if (status == I40E_SUCCESS &&
+			    (ocp_cfg_word0 & I40E_SR_OCP_ENABLED))
+				hw->num_ports = 4;
+			i40e_release_nvm(hw);
+		}
+	}
+
 	valid_functions = p->valid_functions;
 	num_functions = 0;
 	while (valid_functions) {
diff --git a/drivers/net/i40e/base/i40e_lan_hmc.c b/drivers/net/i40e/base/i40e_lan_hmc.c
index 22606484..739f3d5a 100644
--- a/drivers/net/i40e/base/i40e_lan_hmc.c
+++ b/drivers/net/i40e/base/i40e_lan_hmc.c
@@ -143,7 +143,7 @@ enum i40e_status_code i40e_init_lan_hmc(struct i40e_hw *hw, u32 txq_num,
 		ret_code = I40E_ERR_INVALID_HMC_OBJ_COUNT;
 		DEBUGOUT3("i40e_init_lan_hmc: Tx context: asks for 0x%x but max allowed is 0x%x, returns error %d\n",
 			  txq_num, obj->max_cnt, ret_code);
-		goto init_lan_hmc_out;
+		goto free_hmc_out;
 	}
 
 	/* aggregate values into the full LAN object for later */
@@ -166,7 +166,7 @@ enum i40e_status_code i40e_init_lan_hmc(struct i40e_hw *hw, u32 txq_num,
 		ret_code = I40E_ERR_INVALID_HMC_OBJ_COUNT;
 		DEBUGOUT3("i40e_init_lan_hmc: Rx context: asks for 0x%x but max allowed is 0x%x, returns error %d\n",
 			  rxq_num, obj->max_cnt, ret_code);
-		goto init_lan_hmc_out;
+		goto free_hmc_out;
 	}
 
 	/* aggregate values into the full LAN object for later */
@@ -189,7 +189,7 @@ enum i40e_status_code i40e_init_lan_hmc(struct i40e_hw *hw, u32 txq_num,
 		ret_code = I40E_ERR_INVALID_HMC_OBJ_COUNT;
 		DEBUGOUT3("i40e_init_lan_hmc: FCoE context: asks for 0x%x but max allowed is 0x%x, returns error %d\n",
 			  fcoe_cntx_num, obj->max_cnt, ret_code);
-		goto init_lan_hmc_out;
+		goto free_hmc_out;
 	}
 
 	/* aggregate values into the full LAN object for later */
@@ -212,7 +212,7 @@ enum i40e_status_code i40e_init_lan_hmc(struct i40e_hw *hw, u32 txq_num,
 		ret_code = I40E_ERR_INVALID_HMC_OBJ_COUNT;
 		DEBUGOUT3("i40e_init_lan_hmc: FCoE filter: asks for 0x%x but max allowed is 0x%x, returns error %d\n",
 			  fcoe_filt_num, obj->max_cnt, ret_code);
-		goto init_lan_hmc_out;
+		goto free_hmc_out;
 	}
 
 	/* aggregate values into the full LAN object for later */
@@ -233,7 +233,7 @@ enum i40e_status_code i40e_init_lan_hmc(struct i40e_hw *hw, u32 txq_num,
 					  (sizeof(struct i40e_hmc_sd_entry) *
 					  hw->hmc.sd_table.sd_cnt));
 		if (ret_code)
-			goto init_lan_hmc_out;
+			goto free_hmc_out;
 		hw->hmc.sd_table.sd_entry =
 			(struct i40e_hmc_sd_entry *)hw->hmc.sd_table.addr.va;
 	}
@@ -242,6 +242,11 @@ enum i40e_status_code i40e_init_lan_hmc(struct i40e_hw *hw, u32 txq_num,
 
 init_lan_hmc_out:
 	return ret_code;
+free_hmc_out:
+	if (hw->hmc.hmc_obj_virt_mem.va)
+		i40e_free_virt_mem(hw, &hw->hmc.hmc_obj_virt_mem);
+
+	return ret_code;
 }
 
 /**
diff --git a/drivers/net/i40e/base/i40e_type.h b/drivers/net/i40e/base/i40e_type.h
index d514abe3..aa45d10c 100644
--- a/drivers/net/i40e/base/i40e_type.h
+++ b/drivers/net/i40e/base/i40e_type.h
@@ -1519,6 +1519,8 @@ struct i40e_hw_port_stats {
 #define I40E_SR_PCIE_ALT_MODULE_MAX_SIZE	1024
 #define I40E_SR_CONTROL_WORD_1_SHIFT		0x06
 #define I40E_SR_CONTROL_WORD_1_MASK	(0x03 << I40E_SR_CONTROL_WORD_1_SHIFT)
+#define I40E_SR_OCP_CFG_WORD0			0x2B
+#define I40E_SR_OCP_ENABLED			BIT(15)
 
 /* Shadow RAM related */
 #define I40E_SR_SECTOR_SIZE_IN_WORDS	0x800
diff --git a/drivers/net/i40e/i40e_ethdev.c b/drivers/net/i40e/i40e_ethdev.c
index 30612963..62b36c9a 100644
--- a/drivers/net/i40e/i40e_ethdev.c
+++ b/drivers/net/i40e/i40e_ethdev.c
@@ -1081,9 +1081,6 @@ eth_i40e_dev_init(struct rte_eth_dev *dev)
 	/* Make sure all is clean before doing PF reset */
 	i40e_clear_hw(hw);
 
-	/* Initialize the hardware */
-	i40e_hw_init(dev);
-
 	/* Reset here to make sure all is clean for each PF */
 	ret = i40e_pf_reset(hw);
 	if (ret) {
@@ -1098,20 +1095,6 @@ eth_i40e_dev_init(struct rte_eth_dev *dev)
 		return ret;
 	}
 
-	i40e_config_automask(pf);
-
-	/*
-	 * To work around the NVM issue, initialize registers
-	 * for flexible payload and packet type of QinQ by
-	 * software. It should be removed once issues are fixed
-	 * in NVM.
-	 */
-	if (!pf->support_multi_driver)
-		i40e_GLQF_reg_init(hw);
-
-	/* Initialize the input set for filters (hash and fd) to default value */
-	i40e_filter_input_set_init(pf);
-
 	/* Initialize the parameters for adminq */
 	i40e_init_adminq_parameter(hw);
 	ret = i40e_init_adminq(hw);
@@ -1126,6 +1109,23 @@ eth_i40e_dev_init(struct rte_eth_dev *dev)
 		     ((hw->nvm.version >> 4) & 0xff),
 		     (hw->nvm.version & 0xf), hw->nvm.eetrack);
 
+	/* Initialize the hardware */
+	i40e_hw_init(dev);
+
+	i40e_config_automask(pf);
+
+	/*
+	 * To work around the NVM issue, initialize registers
+	 * for flexible payload and packet type of QinQ by
+	 * software. It should be removed once issues are fixed
+	 * in NVM.
+	 */
+	if (!pf->support_multi_driver)
+		i40e_GLQF_reg_init(hw);
+
+	/* Initialize the input set for filters (hash and fd) to default value */
+	i40e_filter_input_set_init(pf);
+
 	/* Need the special FW version to support floating VEB */
 	config_floating_veb(dev);
 	/* Clear PXE mode */
@@ -2085,6 +2085,10 @@ i40e_dev_promiscuous_disable(struct rte_eth_dev *dev)
 	if (status != I40E_SUCCESS)
 		PMD_DRV_LOG(ERR, "Failed to disable unicast promiscuous");
 
+	/* must remain in all_multicast mode */
+	if (dev->data->all_multicast == 1)
+		return;
+
 	status = i40e_aq_set_vsi_multicast_promiscuous(hw, vsi->seid,
 							false, NULL);
 	if (status != I40E_SUCCESS)
@@ -4589,7 +4593,7 @@ i40e_enable_pf_lb(struct i40e_pf *pf)
 	int ret;
 
 	/* Use the FW API if FW >= v5.0 */
-	if (hw->aq.fw_maj_ver < 5) {
+	if (hw->aq.fw_maj_ver < 5 && hw->mac.type != I40E_MAC_X722) {
 		PMD_INIT_LOG(ERR, "FW < v5.0, cannot enable loopback");
 		return;
 	}
@@ -4858,7 +4862,7 @@ i40e_vsi_setup(struct i40e_pf *pf,
 		ctxt.flags = I40E_AQ_VSI_TYPE_VF;
 
 		/* Use the VEB configuration if FW >= v5.0 */
-		if (hw->aq.fw_maj_ver >= 5) {
+		if (hw->aq.fw_maj_ver >= 5 || hw->mac.type == I40E_MAC_X722) {
 			/* Configure switch ID */
 			ctxt.info.valid_sections |=
 			rte_cpu_to_le_16(I40E_AQ_VSI_PROP_SWITCH_VALID);
@@ -10080,6 +10084,32 @@ i40e_dev_rx_queue_intr_disable(struct rte_eth_dev *dev, uint16_t queue_id)
 	return 0;
 }
 
+/**
+ * This function is used to check if the register is valid.
+ * Below is the valid registers list for X722 only:
+ * 0x2b800--0x2bb00
+ * 0x38700--0x38a00
+ * 0x3d800--0x3db00
+ * 0x208e00--0x209000
+ * 0x20be00--0x20c000
+ * 0x263c00--0x264000
+ * 0x265c00--0x266000
+ */
+static inline int i40e_valid_regs(enum i40e_mac_type type, uint32_t reg_offset)
+{
+	if ((type != I40E_MAC_X722) &&
+	    ((reg_offset >= 0x2b800 && reg_offset <= 0x2bb00) ||
+	     (reg_offset >= 0x38700 && reg_offset <= 0x38a00) ||
+	     (reg_offset >= 0x3d800 && reg_offset <= 0x3db00) ||
+	     (reg_offset >= 0x208e00 && reg_offset <= 0x209000) ||
+	     (reg_offset >= 0x20be00 && reg_offset <= 0x20c000) ||
+	     (reg_offset >= 0x263c00 && reg_offset <= 0x264000) ||
+	     (reg_offset >= 0x265c00 && reg_offset <= 0x266000)))
+		return 0;
+	else
+		return 1;
+}
+
 static int i40e_get_regs(struct rte_eth_dev *dev,
 			 struct rte_dev_reg_info *regs)
 {
@@ -10121,8 +10151,11 @@ static int i40e_get_regs(struct rte_eth_dev *dev,
 				reg_offset = arr_idx * reg_info->stride1 +
 					arr_idx2 * reg_info->stride2;
 				reg_offset += reg_info->base_addr;
-				ptr_data[reg_offset >> 2] =
-					I40E_READ_REG(hw, reg_offset);
+				if (!i40e_valid_regs(hw->mac.type, reg_offset))
+					ptr_data[reg_offset >> 2] = 0;
+				else
+					ptr_data[reg_offset >> 2] =
+						I40E_READ_REG(hw, reg_offset);
 			}
 	}
 
diff --git a/drivers/net/i40e/i40e_rxtx.c b/drivers/net/i40e/i40e_rxtx.c
index 777ffc21..2c56c1ac 100644
--- a/drivers/net/i40e/i40e_rxtx.c
+++ b/drivers/net/i40e/i40e_rxtx.c
@@ -74,6 +74,10 @@
 #define I40E_TXD_CMD (I40E_TX_DESC_CMD_EOP | I40E_TX_DESC_CMD_RS)
 
 #define I40E_TX_CKSUM_OFFLOAD_MASK (		 \
+		PKT_TX_OUTER_IPV4 |		 \
+		PKT_TX_OUTER_IPV6 |		 \
+		PKT_TX_IPV4 |			 \
+		PKT_TX_IPV6 |			 \
 		PKT_TX_IP_CKSUM |		 \
 		PKT_TX_L4_MASK |		 \
 		PKT_TX_TCP_SEG |		 \
diff --git a/drivers/net/ixgbe/base/ixgbe_common.c b/drivers/net/ixgbe/base/ixgbe_common.c
index e54fd306..ac4ef8ab 100644
--- a/drivers/net/ixgbe/base/ixgbe_common.c
+++ b/drivers/net/ixgbe/base/ixgbe_common.c
@@ -5095,10 +5095,10 @@ s32 ixgbe_setup_mac_link_multispeed_fiber(struct ixgbe_hw *hw,
 		ixgbe_flap_tx_laser(hw);
 
 		/* Wait for the controller to acquire link.  Per IEEE 802.3ap,
-		 * Section 73.10.2, we may have to wait up to 500ms if KR is
+		 * Section 73.10.2, we may have to wait up to 1000ms if KR is
 		 * attempted.  82599 uses the same timing for 10g SFI.
 		 */
-		for (i = 0; i < 5; i++) {
+		for (i = 0; i < 10; i++) {
 			/* Wait for the link partner to also set speed */
 			msec_delay(100);
 
diff --git a/drivers/net/ixgbe/ixgbe_ethdev.c b/drivers/net/ixgbe/ixgbe_ethdev.c
index 182a8c66..61c075b6 100644
--- a/drivers/net/ixgbe/ixgbe_ethdev.c
+++ b/drivers/net/ixgbe/ixgbe_ethdev.c
@@ -3227,13 +3227,8 @@ ixgbevf_dev_info_get(struct rte_eth_dev *dev,
 
 static int
 ixgbevf_check_link(struct ixgbe_hw *hw, ixgbe_link_speed *speed,
-		   int *link_up, int wait_to_complete)
+		   int *link_up, int wait_to_complete __rte_unused)
 {
-	/**
-	 * for a quick link status checking, wait_to_compelet == 0,
-	 * skip PF link status checking
-	 */
-	bool no_pflink_check = wait_to_complete == 0;
 	struct ixgbe_mbx_info *mbx = &hw->mbx;
 	struct ixgbe_mac_info *mac = &hw->mac;
 	uint32_t links_reg, in_msg;
@@ -3294,14 +3289,6 @@ ixgbevf_check_link(struct ixgbe_hw *hw, ixgbe_link_speed *speed,
 		*speed = IXGBE_LINK_SPEED_UNKNOWN;
 	}
 
-	if (no_pflink_check) {
-		if (*speed == IXGBE_LINK_SPEED_UNKNOWN)
-			mac->get_link_status = true;
-		else
-			mac->get_link_status = false;
-
-		goto out;
-	}
 	/* if the read failed it could just be a mailbox collision, best wait
 	 * until we are called again and don't report an error
 	 */
@@ -3311,7 +3298,7 @@ ixgbevf_check_link(struct ixgbe_hw *hw, ixgbe_link_speed *speed,
 	if (!(in_msg & IXGBE_VT_MSGTYPE_CTS)) {
 		/* msg is not CTS and is NACK we must have lost CTS status */
 		if (in_msg & IXGBE_VT_MSGTYPE_NACK)
-			ret_val = -1;
+			mac->get_link_status = false;
 		goto out;
 	}
 
diff --git a/drivers/net/ixgbe/ixgbe_rxtx.c b/drivers/net/ixgbe/ixgbe_rxtx.c
index 8b18b530..4b1a6f48 100644
--- a/drivers/net/ixgbe/ixgbe_rxtx.c
+++ b/drivers/net/ixgbe/ixgbe_rxtx.c
@@ -81,6 +81,10 @@
 
 /* Bit Mask to indicate what bits required for building TX context */
 #define IXGBE_TX_OFFLOAD_MASK (			 \
+		PKT_TX_OUTER_IPV6 |		 \
+		PKT_TX_OUTER_IPV4 |		 \
+		PKT_TX_IPV6 |			 \
+		PKT_TX_IPV4 |			 \
 		PKT_TX_VLAN_PKT |		 \
 		PKT_TX_IP_CKSUM |		 \
 		PKT_TX_L4_MASK |		 \
@@ -4996,6 +5000,7 @@ ixgbe_dev_tx_queue_start(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 
 	if (tx_queue_id < dev->data->nb_tx_queues) {
 		txq = dev->data->tx_queues[tx_queue_id];
+		IXGBE_WRITE_REG(hw, IXGBE_TDH(txq->reg_idx), 0);
 		txdctl = IXGBE_READ_REG(hw, IXGBE_TXDCTL(txq->reg_idx));
 		txdctl |= IXGBE_TXDCTL_ENABLE;
 		IXGBE_WRITE_REG(hw, IXGBE_TXDCTL(txq->reg_idx), txdctl);
@@ -5013,7 +5018,6 @@ ixgbe_dev_tx_queue_start(struct rte_eth_dev *dev, uint16_t tx_queue_id)
 					     "Tx Queue %d", tx_queue_id);
 		}
 		rte_wmb();
-		IXGBE_WRITE_REG(hw, IXGBE_TDH(txq->reg_idx), 0);
 		IXGBE_WRITE_REG(hw, IXGBE_TDT(txq->reg_idx), 0);
 		dev->data->tx_queue_state[tx_queue_id] = RTE_ETH_QUEUE_STATE_STARTED;
 	} else
diff --git a/drivers/net/mlx5/mlx5_utils.h b/drivers/net/mlx5/mlx5_utils.h
index f126979b..7412103d 100644
--- a/drivers/net/mlx5/mlx5_utils.h
+++ b/drivers/net/mlx5/mlx5_utils.h
@@ -43,6 +43,16 @@
 
 #include "mlx5_defs.h"
 
+/*
+ * Compilation workaround for PPC64 when AltiVec is fully enabled, e.g. std=c11.
+ * Otherwise there would be a type conflict between stdbool and altivec.
+ */
+#if defined(__PPC64__) && !defined(__APPLE_ALTIVEC__)
+#undef bool
+/* redefine as in stdbool.h */
+#define bool _Bool
+#endif
+
 /* Bit-field manipulation. */
 #define BITFIELD_DECLARE(bf, type, size) \
 	type bf[(((size_t)(size) / (sizeof(type) * CHAR_BIT)) + \
diff --git a/drivers/net/nfp/nfp_net.c b/drivers/net/nfp/nfp_net.c
index 0f0589e0..e5f6a883 100644
--- a/drivers/net/nfp/nfp_net.c
+++ b/drivers/net/nfp/nfp_net.c
@@ -1567,21 +1567,20 @@ nfp_net_rx_cksum(struct nfp_net_rxq *rxq, struct nfp_net_rx_desc *rxd,
 		return;
 
 	/* If IPv4 and IP checksum error, fail */
-	if ((rxd->rxd.flags & PCIE_DESC_RX_IP4_CSUM) &&
-	    !(rxd->rxd.flags & PCIE_DESC_RX_IP4_CSUM_OK))
+	if (unlikely((rxd->rxd.flags & PCIE_DESC_RX_IP4_CSUM) &&
+	    !(rxd->rxd.flags & PCIE_DESC_RX_IP4_CSUM_OK)))
 		mb->ol_flags |= PKT_RX_IP_CKSUM_BAD;
+	else
+		mb->ol_flags |= PKT_RX_IP_CKSUM_GOOD;
 
 	/* If neither UDP nor TCP return */
 	if (!(rxd->rxd.flags & PCIE_DESC_RX_TCP_CSUM) &&
 	    !(rxd->rxd.flags & PCIE_DESC_RX_UDP_CSUM))
 		return;
 
-	if ((rxd->rxd.flags & PCIE_DESC_RX_TCP_CSUM) &&
-	    !(rxd->rxd.flags & PCIE_DESC_RX_TCP_CSUM_OK))
-		mb->ol_flags |= PKT_RX_L4_CKSUM_BAD;
-
-	if ((rxd->rxd.flags & PCIE_DESC_RX_UDP_CSUM) &&
-	    !(rxd->rxd.flags & PCIE_DESC_RX_UDP_CSUM_OK))
+	if (likely(rxd->rxd.flags & PCIE_DESC_RX_L4_CSUM_OK))
+		mb->ol_flags |= PKT_RX_L4_CKSUM_GOOD;
+	else
 		mb->ol_flags |= PKT_RX_L4_CKSUM_BAD;
 }
 
@@ -1630,6 +1629,18 @@ nfp_net_set_hash(struct nfp_net_rxq *rxq, struct nfp_net_rx_desc *rxd,
 	case NFP_NET_RSS_IPV6_EX:
 		mbuf->packet_type |= RTE_PTYPE_INNER_L3_IPV6_EXT;
 		break;
+	case NFP_NET_RSS_IPV4_TCP:
+		mbuf->packet_type |= RTE_PTYPE_INNER_L3_IPV6_EXT;
+		break;
+	case NFP_NET_RSS_IPV6_TCP:
+		mbuf->packet_type |= RTE_PTYPE_INNER_L3_IPV6_EXT;
+		break;
+	case NFP_NET_RSS_IPV4_UDP:
+		mbuf->packet_type |= RTE_PTYPE_INNER_L3_IPV6_EXT;
+		break;
+	case NFP_NET_RSS_IPV6_UDP:
+		mbuf->packet_type |= RTE_PTYPE_INNER_L3_IPV6_EXT;
+		break;
 	default:
 		mbuf->packet_type |= RTE_PTYPE_INNER_L4_MASK;
 	}
@@ -2223,14 +2234,22 @@ nfp_net_rss_hash_update(struct rte_eth_dev *dev,
 	}
 
 	if (rss_hf & ETH_RSS_IPV4)
-		cfg_rss_ctrl |= NFP_NET_CFG_RSS_IPV4 |
-				NFP_NET_CFG_RSS_IPV4_TCP |
-				NFP_NET_CFG_RSS_IPV4_UDP;
+		cfg_rss_ctrl |= NFP_NET_CFG_RSS_IPV4;
+
+	if (rss_hf & ETH_RSS_NONFRAG_IPV4_TCP)
+		cfg_rss_ctrl |= NFP_NET_CFG_RSS_IPV4_TCP;
+
+	if (rss_hf & ETH_RSS_NONFRAG_IPV4_UDP)
+		cfg_rss_ctrl |= NFP_NET_CFG_RSS_IPV4_UDP;
 
 	if (rss_hf & ETH_RSS_IPV6)
-		cfg_rss_ctrl |= NFP_NET_CFG_RSS_IPV6 |
-				NFP_NET_CFG_RSS_IPV6_TCP |
-				NFP_NET_CFG_RSS_IPV6_UDP;
+		cfg_rss_ctrl |= NFP_NET_CFG_RSS_IPV6;
+
+	if (rss_hf & ETH_RSS_NONFRAG_IPV6_TCP)
+		cfg_rss_ctrl |= NFP_NET_CFG_RSS_IPV6_TCP;
+
+	if (rss_hf & ETH_RSS_NONFRAG_IPV6_UDP)
+		cfg_rss_ctrl |= NFP_NET_CFG_RSS_IPV6_UDP;
 
 	cfg_rss_ctrl |= NFP_NET_CFG_RSS_MASK;
 	cfg_rss_ctrl |= NFP_NET_CFG_RSS_TOEPLITZ;
@@ -2450,6 +2469,9 @@ nfp_net_init(struct rte_eth_dev *eth_dev)
 	ether_addr_copy((struct ether_addr *)hw->mac_addr,
 			&eth_dev->data->mac_addrs[0]);
 
+	if (!(hw->cap & NFP_NET_CFG_CTRL_LIVE_ADDR))
+		eth_dev->data->dev_flags |= RTE_ETH_DEV_NOLIVE_MAC_ADDR;
+
 	PMD_INIT_LOG(INFO, "port %d VendorID=0x%x DeviceID=0x%x "
 		     "mac=%02x:%02x:%02x:%02x:%02x:%02x",
 		     eth_dev->data->port_id, pci_dev->id.vendor_id,
diff --git a/drivers/net/nfp/nfp_net_pmd.h b/drivers/net/nfp/nfp_net_pmd.h
index c1809720..ce475e39 100644
--- a/drivers/net/nfp/nfp_net_pmd.h
+++ b/drivers/net/nfp/nfp_net_pmd.h
@@ -279,6 +279,8 @@ struct nfp_net_txq {
 #define PCIE_DESC_RX_UDP_CSUM_OK        (1 <<  1)
 #define PCIE_DESC_RX_VLAN               (1 <<  0)
 
+#define PCIE_DESC_RX_L4_CSUM_OK         (PCIE_DESC_RX_TCP_CSUM_OK | \
+					 PCIE_DESC_RX_UDP_CSUM_OK)
 struct nfp_net_rx_desc {
 	union {
 		/* Freelist descriptor */
diff --git a/drivers/net/thunderx/nicvf_rxtx.c b/drivers/net/thunderx/nicvf_rxtx.c
index 4b9b2932..ac30552b 100644
--- a/drivers/net/thunderx/nicvf_rxtx.c
+++ b/drivers/net/thunderx/nicvf_rxtx.c
@@ -89,6 +89,14 @@ fill_sq_desc_header(union sq_entry_t *entry, struct rte_mbuf *pkt)
 	entry->buff[0] = sqe.buff[0];
 }
 
+static inline void __hot
+fill_sq_desc_header_zero_w1(union sq_entry_t *entry,
+				struct rte_mbuf *pkt)
+{
+	fill_sq_desc_header(entry, pkt);
+	entry->buff[1] = 0ULL;
+}
+
 void __hot
 nicvf_single_pool_free_xmited_buffers(struct nicvf_txq *sq)
 {
@@ -232,7 +240,7 @@ nicvf_xmit_pkts_multiseg(void *tx_queue, struct rte_mbuf **tx_pkts,
 		used_bufs += nb_segs;
 
 		txbuffs[tail] = NULL;
-		fill_sq_desc_header(desc_ptr + tail, pkt);
+		fill_sq_desc_header_zero_w1(desc_ptr + tail, pkt);
 		tail = (tail + 1) & qlen_mask;
 
 		txbuffs[tail] = pkt;
diff --git a/drivers/net/vhost/rte_eth_vhost.c b/drivers/net/vhost/rte_eth_vhost.c
index 12922df6..5858e536 100644
--- a/drivers/net/vhost/rte_eth_vhost.c
+++ b/drivers/net/vhost/rte_eth_vhost.c
@@ -1248,4 +1248,6 @@ RTE_PMD_REGISTER_VDEV(net_vhost, pmd_vhost_drv);
 RTE_PMD_REGISTER_ALIAS(net_vhost, eth_vhost);
 RTE_PMD_REGISTER_PARAM_STRING(net_vhost,
 	"iface=<ifc> "
-	"queues=<int>");
+	"queues=<int> "
+	"client=<0|1> "
+	"dequeue-zero-copy=<0|1> ");
diff --git a/drivers/net/virtio/virtio_ethdev.c b/drivers/net/virtio/virtio_ethdev.c
index 5a27ab77..6f950f0f 100644
--- a/drivers/net/virtio/virtio_ethdev.c
+++ b/drivers/net/virtio/virtio_ethdev.c
@@ -1394,11 +1394,6 @@ eth_virtio_dev_init(struct rte_eth_dev *eth_dev)
 	if (ret < 0)
 		return ret;
 
-	/* Setup interrupt callback  */
-	if (eth_dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC)
-		rte_intr_callback_register(&pci_dev->intr_handle,
-			virtio_interrupt_handler, eth_dev);
-
 	return 0;
 }
 
@@ -1423,11 +1418,6 @@ eth_virtio_dev_uninit(struct rte_eth_dev *eth_dev)
 	rte_free(eth_dev->data->mac_addrs);
 	eth_dev->data->mac_addrs = NULL;
 
-	/* reset interrupt callback  */
-	if (eth_dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC)
-		rte_intr_callback_unregister(&pci_dev->intr_handle,
-						virtio_interrupt_handler,
-						eth_dev);
 	rte_eal_pci_unmap_device(pci_dev);
 
 	PMD_INIT_LOG(DEBUG, "dev_uninit completed");
@@ -1538,6 +1528,12 @@ virtio_dev_start(struct rte_eth_dev *dev)
 			return -ENOTSUP;
 		}
 
+		/* Setup interrupt callback  */
+		if (dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC)
+			rte_intr_callback_register(&dev->pci_dev->intr_handle,
+						   virtio_interrupt_handler,
+						   dev);
+
 		if (rte_intr_enable(&dev->pci_dev->intr_handle) < 0) {
 			PMD_DRV_LOG(ERR, "interrupt enable failed");
 			return -EIO;
@@ -1645,9 +1641,17 @@ virtio_dev_stop(struct rte_eth_dev *dev)
 
 	PMD_INIT_LOG(DEBUG, "stop");
 
-	if (dev->data->dev_conf.intr_conf.lsc)
+	if (dev->data->dev_conf.intr_conf.lsc) {
 		rte_intr_disable(&dev->pci_dev->intr_handle);
 
+		/* Reset interrupt callback  */
+		if (dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC) {
+			rte_intr_callback_unregister(&dev->pci_dev->intr_handle,
+						     virtio_interrupt_handler,
+						     dev);
+		}
+	}
+
 	hw->started = 0;
 	memset(&link, 0, sizeof(link));
 	virtio_dev_atomic_write_link_status(dev, &link);
diff --git a/drivers/net/virtio/virtio_ethdev.h b/drivers/net/virtio/virtio_ethdev.h
index c491ec1b..5122792a 100644
--- a/drivers/net/virtio/virtio_ethdev.h
+++ b/drivers/net/virtio/virtio_ethdev.h
@@ -74,7 +74,11 @@
 	(VIRTIO_PMD_DEFAULT_GUEST_FEATURES |	\
 	 1u << VIRTIO_NET_F_GUEST_CSUM	   |	\
 	 1u << VIRTIO_NET_F_GUEST_TSO4     |	\
-	 1u << VIRTIO_NET_F_GUEST_TSO6)
+	 1u << VIRTIO_NET_F_GUEST_TSO6     |	\
+	 1u << VIRTIO_NET_F_CSUM           |	\
+	 1u << VIRTIO_NET_F_HOST_TSO4      |	\
+	 1u << VIRTIO_NET_F_HOST_TSO6)
+
 /*
  * CQ function prototype
  */
diff --git a/drivers/net/virtio/virtio_user/virtio_user_dev.c b/drivers/net/virtio/virtio_user/virtio_user_dev.c
index 8bb155d8..3e6787a0 100644
--- a/drivers/net/virtio/virtio_user/virtio_user_dev.c
+++ b/drivers/net/virtio/virtio_user/virtio_user_dev.c
@@ -142,9 +142,6 @@ virtio_user_start_device(struct virtio_user_dev *dev)
 	uint64_t features;
 	int ret;
 
-	/* Do not check return as already done in init, or reset in stop */
-	vhost_user_sock(dev->vhostfd, VHOST_USER_SET_OWNER, NULL);
-
 	/* Step 0: tell vhost to create queues */
 	if (virtio_user_queue_setup(dev, virtio_user_create_queue) < 0)
 		goto error;
@@ -185,6 +182,7 @@ error:
 
 int virtio_user_stop_device(struct virtio_user_dev *dev)
 {
+	struct vhost_vring_state state;
 	uint32_t i;
 
 	for (i = 0; i < dev->max_queue_pairs * 2; ++i) {
@@ -195,6 +193,17 @@ int virtio_user_stop_device(struct virtio_user_dev *dev)
 	for (i = 0; i < dev->max_queue_pairs; ++i)
 		vhost_user_enable_queue_pair(dev->vhostfd, i, 0);
 
+	/* Stop the backend. */
+	for (i = 0; i < dev->max_queue_pairs * 2; ++i) {
+		state.index = i;
+		if (vhost_user_sock(dev->vhostfd, VHOST_USER_GET_VRING_BASE,
+					   &state) < 0) {
+			PMD_DRV_LOG(ERR, "get_vring_base failed, index=%u\n",
+				    i);
+			return -1;
+		}
+	}
+
 	return 0;
 }
 
diff --git a/drivers/net/virtio/virtio_user_ethdev.c b/drivers/net/virtio/virtio_user_ethdev.c
index b1bd6234..caa9be5a 100644
--- a/drivers/net/virtio/virtio_user_ethdev.c
+++ b/drivers/net/virtio/virtio_user_ethdev.c
@@ -369,7 +369,7 @@ virtio_user_pmd_probe(const char *name, const char *params)
 		}
 	} else {
 		PMD_INIT_LOG(ERR, "arg %s is mandatory for virtio_user\n",
-			  VIRTIO_USER_ARG_QUEUE_SIZE);
+			     VIRTIO_USER_ARG_PATH);
 		goto end;
 	}
 
diff --git a/examples/ipv4_multicast/main.c b/examples/ipv4_multicast/main.c
index b908b317..d2e1bfb9 100644
--- a/examples/ipv4_multicast/main.c
+++ b/examples/ipv4_multicast/main.c
@@ -301,8 +301,6 @@ mcast_out_pkt(struct rte_mbuf *pkt, int use_clone)
 	hdr->tx_offload = pkt->tx_offload;
 	hdr->hash = pkt->hash;
 
-	hdr->ol_flags = pkt->ol_flags;
-
 	__rte_mbuf_sanity_check(hdr, 1);
 	return hdr;
 }
diff --git a/examples/vhost/main.c b/examples/vhost/main.c
index fe232747..89d21fc0 100644
--- a/examples/vhost/main.c
+++ b/examples/vhost/main.c
@@ -87,9 +87,6 @@
 /* Max number of devices. Limited by vmdq. */
 #define MAX_DEVICES 64
 
-/* Size of buffers used for snprintfs. */
-#define MAX_PRINT_BUFF 6072
-
 /* Maximum long option length for option parsing. */
 #define MAX_LONG_OPT_SZ 64
 
diff --git a/lib/librte_acl/rte_acl.h b/lib/librte_acl/rte_acl.h
index caa91f7e..39686d51 100644
--- a/lib/librte_acl/rte_acl.h
+++ b/lib/librte_acl/rte_acl.h
@@ -117,7 +117,7 @@ enum {
 	RTE_ACL_TYPE_SHIFT = 29,
 	RTE_ACL_MAX_INDEX = RTE_LEN2MASK(RTE_ACL_TYPE_SHIFT, uint32_t),
 	RTE_ACL_MAX_PRIORITY = RTE_ACL_MAX_INDEX,
-	RTE_ACL_MIN_PRIORITY = 0,
+	RTE_ACL_MIN_PRIORITY = 1,
 };
 
 #define	RTE_ACL_INVALID_USERDATA	0
diff --git a/lib/librte_eal/common/eal_common_options.c b/lib/librte_eal/common/eal_common_options.c
index 6ca8af17..2dc86509 100644
--- a/lib/librte_eal/common/eal_common_options.c
+++ b/lib/librte_eal/common/eal_common_options.c
@@ -179,7 +179,7 @@ eal_plugin_add(const char *path)
 		return -1;
 	}
 	memset(solib, 0, sizeof(*solib));
-	strncpy(solib->name, path, PATH_MAX-1);
+	strlcpy(solib->name, path, PATH_MAX-1);
 	solib->name[PATH_MAX-1] = 0;
 	TAILQ_INSERT_TAIL(&solib_list, solib, next);
 
diff --git a/lib/librte_eal/common/include/rte_common.h b/lib/librte_eal/common/include/rte_common.h
index f5e2f886..f17926f3 100644
--- a/lib/librte_eal/common/include/rte_common.h
+++ b/lib/librte_eal/common/include/rte_common.h
@@ -200,16 +200,7 @@ rte_is_aligned(void *ptr, unsigned align)
 /**
  * Triggers an error at compilation time if the condition is true.
  */
-#ifndef __OPTIMIZE__
 #define RTE_BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
-#else
-extern int RTE_BUILD_BUG_ON_detected_error;
-#define RTE_BUILD_BUG_ON(condition) do {             \
-	((void)sizeof(char[1 - 2*!!(condition)]));   \
-	if (condition)                               \
-		RTE_BUILD_BUG_ON_detected_error = 1; \
-} while(0)
-#endif
 
 /*********** Macros to work with powers of 2 ********/
 
@@ -326,6 +317,23 @@ rte_bsf32(uint32_t v)
 	return (uint32_t)__builtin_ctz(v);
 }
 
+/**
+ * Return the last (most-significant) bit set.
+ *
+ * @note The last (most significant) bit is at position 32.
+ * @note rte_fls_u32(0) = 0, rte_fls_u32(1) = 1, rte_fls_u32(0x80000000) = 32
+ *
+ * @param x
+ *     The input parameter.
+ * @return
+ *     The last (most-significant) bit set, or 0 if the input is 0.
+ */
+static inline int
+rte_fls_u32(uint32_t x)
+{
+	return (x == 0) ? 0 : 32 - __builtin_clz(x);
+}
+
 #ifndef offsetof
 /** Return the offset of a field in a structure. */
 #define offsetof(TYPE, MEMBER)  __builtin_offsetof (TYPE, MEMBER)
diff --git a/lib/librte_eal/common/include/rte_pci.h b/lib/librte_eal/common/include/rte_pci.h
index 9ce88472..10fa8564 100644
--- a/lib/librte_eal/common/include/rte_pci.h
+++ b/lib/librte_eal/common/include/rte_pci.h
@@ -248,6 +248,8 @@ TAILQ_HEAD(mapped_pci_res_list, mapped_pci_resource);
 do {                                                               \
 	unsigned long val;                                      \
 	char *end;                                              \
+	if (*in == '\0')                                        \
+		return -EINVAL;                                 \
 	errno = 0;                                              \
 	val = strtoul((in), &end, 16);                          \
 	if (errno != 0 || end[0] != (dlm) || val > (lim))       \
diff --git a/lib/librte_eal/common/include/rte_version.h b/lib/librte_eal/common/include/rte_version.h
index 9148ef16..b509ec93 100644
--- a/lib/librte_eal/common/include/rte_version.h
+++ b/lib/librte_eal/common/include/rte_version.h
@@ -66,7 +66,7 @@ extern "C" {
 /**
  * Patch level number i.e. the z in yy.mm.z
  */
-#define RTE_VER_MINOR 8
+#define RTE_VER_MINOR 9
 
 /**
  * Extra string to be appended to version number
diff --git a/lib/librte_eal/linuxapp/eal/eal.c b/lib/librte_eal/linuxapp/eal/eal.c
index 59ed7882..bbd6284e 100644
--- a/lib/librte_eal/linuxapp/eal/eal.c
+++ b/lib/librte_eal/linuxapp/eal/eal.c
@@ -746,7 +746,8 @@ rte_eal_init(int argc, char **argv)
 	int i, fctret, ret;
 	pthread_t thread_id;
 	static rte_atomic32_t run_once = RTE_ATOMIC32_INIT(0);
-	const char *logid;
+	const char *p;
+	static char logid[PATH_MAX];
 	char cpuset[RTE_CPU_AFFINITY_STR_LEN];
 	char thread_name[RTE_MAX_THREAD_NAME_LEN];
 
@@ -756,9 +757,8 @@ rte_eal_init(int argc, char **argv)
 	if (!rte_atomic32_test_and_set(&run_once))
 		return -1;
 
-	logid = strrchr(argv[0], '/');
-	logid = strdup(logid ? logid + 1: argv[0]);
-
+	p = strrchr(argv[0], '/');
+	strlcpy(logid, p ? p + 1 : argv[0], sizeof(logid));
 	thread_id = pthread_self();
 
 	eal_log_level_parse(argc, argv);
diff --git a/lib/librte_eal/linuxapp/eal/eal_interrupts.c b/lib/librte_eal/linuxapp/eal/eal_interrupts.c
index 7f739140..cce69285 100644
--- a/lib/librte_eal/linuxapp/eal/eal_interrupts.c
+++ b/lib/librte_eal/linuxapp/eal/eal_interrupts.c
@@ -647,7 +647,7 @@ eal_intr_process_interrupts(struct epoll_event *events, int nfds)
 {
 	int n, bytes_read;
 	struct rte_intr_source *src;
-	struct rte_intr_callback *cb;
+	struct rte_intr_callback *cb, *next;
 	union rte_intr_read_buffer buf;
 	struct rte_intr_callback active_cb;
 
@@ -713,6 +713,23 @@ eal_intr_process_interrupts(struct epoll_event *events, int nfds)
 					"descriptor %d: %s\n",
 					events[n].data.fd,
 					strerror(errno));
+				/*
+				 * The device is unplugged or buggy, remove
+				 * it as an interrupt source and return to
+				 * force the wait list to be rebuilt.
+				 */
+				rte_spinlock_lock(&intr_lock);
+				TAILQ_REMOVE(&intr_sources, src, next);
+				rte_spinlock_unlock(&intr_lock);
+
+				for (cb = TAILQ_FIRST(&src->callbacks); cb;
+							cb = next) {
+					next = TAILQ_NEXT(cb, next);
+					TAILQ_REMOVE(&src->callbacks, cb, next);
+					free(cb);
+				}
+				free(src);
+				return -1;
 			} else if (bytes_read == 0)
 				RTE_LOG(ERR, EAL, "Read nothing from file "
 					"descriptor %d\n", events[n].data.fd);
diff --git a/lib/librte_eal/linuxapp/eal/eal_pci_uio.c b/lib/librte_eal/linuxapp/eal/eal_pci_uio.c
index 42280678..3ca217f4 100644
--- a/lib/librte_eal/linuxapp/eal/eal_pci_uio.c
+++ b/lib/librte_eal/linuxapp/eal/eal_pci_uio.c
@@ -327,7 +327,7 @@ pci_uio_map_resource_by_index(struct rte_pci_device *dev, int res_idx,
 			loc->function, res_idx);
 
 	/* allocate memory to keep path */
-	maps[map_idx].path = rte_malloc(NULL, strlen(devname) + 1, 0);
+	maps[map_idx].path = rte_malloc(NULL, sizeof(devname), 0);
 	if (maps[map_idx].path == NULL) {
 		RTE_LOG(ERR, EAL, "Cannot allocate memory for path: %s\n",
 				strerror(errno));
diff --git a/lib/librte_eal/linuxapp/eal/eal_vfio.h b/lib/librte_eal/linuxapp/eal/eal_vfio.h
index ac31a4fc..72f1f757 100644
--- a/lib/librte_eal/linuxapp/eal/eal_vfio.h
+++ b/lib/librte_eal/linuxapp/eal/eal_vfio.h
@@ -59,23 +59,46 @@
 #define VFIO_IOMMU_SPAPR_REGISTER_MEMORY _IO(VFIO_TYPE, VFIO_BASE + 17)
 #define VFIO_IOMMU_SPAPR_TCE_CREATE _IO(VFIO_TYPE, VFIO_BASE + 19)
 #define VFIO_IOMMU_SPAPR_TCE_REMOVE _IO(VFIO_TYPE, VFIO_BASE + 20)
+
 struct vfio_iommu_spapr_register_memory {
 	uint32_t argsz;
 	uint32_t flags;
 	uint64_t vaddr;
 	uint64_t size;
 };
+
 struct vfio_iommu_spapr_tce_create {
 	uint32_t argsz;
 	uint32_t page_shift;
 	uint64_t window_size;
 	uint32_t levels;
 };
+
 struct vfio_iommu_spapr_tce_remove {
 	uint32_t argsz;
 	uint64_t start_addr;
 };
-#else
+
+struct vfio_iommu_spapr_tce_ddw_info {
+	uint64_t pgsizes;
+	uint32_t max_dynamic_windows_supported;
+	uint32_t levels;
+};
+
+/* SPAPR_v2 is not present, but SPAPR might be */
+#ifndef VFIO_SPAPR_TCE_IOMMU
+#define VFIO_IOMMU_SPAPR_TCE_GET_INFO _IO(VFIO_TYPE, VFIO_BASE + 12)
+
+struct vfio_iommu_spapr_tce_info {
+	uint32_t argsz;
+	uint32_t flags;
+	uint32_t dma32_window_start;
+	uint32_t dma32_window_size;
+	struct vfio_iommu_spapr_tce_ddw_info ddw;
+};
+#endif /* VFIO_SPAPR_TCE_IOMMU */
+
+#else /* VFIO_SPAPR_TCE_v2_IOMMU */
 #define RTE_VFIO_SPAPR VFIO_SPAPR_TCE_v2_IOMMU
 #endif
 
diff --git a/lib/librte_eal/linuxapp/eal/include/exec-env/rte_kni_common.h b/lib/librte_eal/linuxapp/eal/include/exec-env/rte_kni_common.h
index 09713b0c..1dc161c2 100644
--- a/lib/librte_eal/linuxapp/eal/include/exec-env/rte_kni_common.h
+++ b/lib/librte_eal/linuxapp/eal/include/exec-env/rte_kni_common.h
@@ -61,6 +61,7 @@
 
 #ifdef __KERNEL__
 #include <linux/if.h>
+#include <asm/barrier.h>
 #define RTE_STD_C11
 #else
 #include <rte_common.h>
diff --git a/lib/librte_eal/linuxapp/igb_uio/igb_uio.c b/lib/librte_eal/linuxapp/igb_uio/igb_uio.c
index 9f00f07a..59d6a093 100644
--- a/lib/librte_eal/linuxapp/igb_uio/igb_uio.c
+++ b/lib/librte_eal/linuxapp/igb_uio/igb_uio.c
@@ -170,6 +170,33 @@ igbuio_pci_irqhandler(int irq, struct uio_info *info)
 	return IRQ_HANDLED;
 }
 
+/**
+ * This gets called while opening uio device file.
+ */
+static int
+igbuio_pci_open(struct uio_info *info, struct inode *inode)
+{
+	struct rte_uio_pci_dev *udev = info->priv;
+	struct pci_dev *dev = udev->pdev;
+
+	/* set bus master, which was cleared by the reset function */
+	pci_set_master(dev);
+
+	return 0;
+}
+
+static int
+igbuio_pci_release(struct uio_info *info, struct inode *inode)
+{
+	struct rte_uio_pci_dev *udev = info->priv;
+	struct pci_dev *dev = udev->pdev;
+
+	/* stop the device from further DMA */
+	pci_clear_master(dev);
+
+	return 0;
+}
+
 #ifdef CONFIG_XEN_DOM0
 static int
 igbuio_dom0_mmap_phys(struct uio_info *info, struct vm_area_struct *vma)
@@ -370,6 +397,8 @@ igbuio_pci_probe(struct pci_dev *dev, const struct pci_device_id *id)
 	udev->info.version = "0.1";
 	udev->info.handler = igbuio_pci_irqhandler;
 	udev->info.irqcontrol = igbuio_pci_irqcontrol;
+	udev->info.open = igbuio_pci_open;
+	udev->info.release = igbuio_pci_release;
 #ifdef CONFIG_XEN_DOM0
 	/* check if the driver run on Xen Dom0 */
 	if (xen_initial_domain())
@@ -460,6 +489,8 @@ igbuio_pci_remove(struct pci_dev *dev)
 {
 	struct rte_uio_pci_dev *udev = pci_get_drvdata(dev);
 
+	igbuio_pci_release(&udev->info, NULL);
+
 	sysfs_remove_group(&dev->dev.kobj, &dev_attr_grp);
 	uio_unregister_device(&udev->info);
 	igbuio_pci_release_iomem(&udev->info);
diff --git a/lib/librte_eal/linuxapp/kni/ethtool/igb/igb_ethtool.c b/lib/librte_eal/linuxapp/kni/ethtool/igb/igb_ethtool.c
index 1110bef8..272f3096 100644
--- a/lib/librte_eal/linuxapp/kni/ethtool/igb/igb_ethtool.c
+++ b/lib/librte_eal/linuxapp/kni/ethtool/igb/igb_ethtool.c
@@ -150,6 +150,7 @@ static const char igb_gstrings_test[][ETH_GSTRING_LEN] = {
 #define IGB_TEST_LEN (sizeof(igb_gstrings_test) / ETH_GSTRING_LEN)
 #endif /* ETHTOOL_TEST */
 
+#ifndef ETHTOOL_GLINKSETTINGS
 static int igb_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
 {
 	struct igb_adapter *adapter = netdev_priv(netdev);
@@ -274,7 +275,9 @@ static int igb_get_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
 #endif /* ETH_TP_MDI_X */
 	return 0;
 }
+#endif
 
+#ifndef ETHTOOL_SLINKSETTINGS
 static int igb_set_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
 {
 	struct igb_adapter *adapter = netdev_priv(netdev);
@@ -379,6 +382,7 @@ static int igb_set_settings(struct net_device *netdev, struct ethtool_cmd *ecmd)
 	clear_bit(__IGB_RESETTING, &adapter->state);
 	return 0;
 }
+#endif
 
 static u32 igb_get_link(struct net_device *netdev)
 {
@@ -2752,8 +2756,12 @@ static int igb_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
 #endif /* ETHTOOL_GRXRINGS */
 
 static const struct ethtool_ops igb_ethtool_ops = {
+#ifndef ETHTOOL_GLINKSETTINGS
 	.get_settings           = igb_get_settings,
+#endif
+#ifndef ETHTOOL_SLINKSETTINGS
 	.set_settings           = igb_set_settings,
+#endif
 	.get_drvinfo            = igb_get_drvinfo,
 	.get_regs_len           = igb_get_regs_len,
 	.get_regs               = igb_get_regs,
diff --git a/lib/librte_eal/linuxapp/kni/ethtool/igb/kcompat.h b/lib/librte_eal/linuxapp/kni/ethtool/igb/kcompat.h
index 9e4798ef..87d0096c 100644
--- a/lib/librte_eal/linuxapp/kni/ethtool/igb/kcompat.h
+++ b/lib/librte_eal/linuxapp/kni/ethtool/igb/kcompat.h
@@ -697,19 +697,22 @@ struct _kc_ethtool_pauseparam {
 #define SLE_VERSION(a,b,c) KERNEL_VERSION(a,b,c)
 #endif
 #ifdef CONFIG_SUSE_KERNEL
-#if ( LINUX_VERSION_CODE == KERNEL_VERSION(2,6,27) )
-/* SLES11 GA is 2.6.27 based */
-#define SLE_VERSION_CODE SLE_VERSION(11,0,0)
-#elif ( LINUX_VERSION_CODE == KERNEL_VERSION(2,6,32) )
-/* SLES11 SP1 is 2.6.32 based */
-#define SLE_VERSION_CODE SLE_VERSION(11,1,0)
+#if (LINUX_VERSION_CODE >= KERNEL_VERSION(4, 4, 57))
+/* SLES12SP3 is at least 4.4.57+ based */
+#define SLE_VERSION_CODE SLE_VERSION(12, 3, 0)
+#elif ( LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,28) )
+/* SLES12 is at least 3.12.28+ based */
+#define SLE_VERSION_CODE SLE_VERSION(12,0,0)
 #elif ((LINUX_VERSION_CODE >= KERNEL_VERSION(3,0,61)) && \
        (LINUX_VERSION_CODE < KERNEL_VERSION(3,1,0)))
 /* SLES11 SP3 is at least 3.0.61+ based */
 #define SLE_VERSION_CODE SLE_VERSION(11,3,0)
-#elif ( LINUX_VERSION_CODE >= KERNEL_VERSION(3,12,28) )
-/* SLES12 is at least 3.12.28+ based */
-#define SLE_VERSION_CODE SLE_VERSION(12,0,0)
+#elif ( LINUX_VERSION_CODE == KERNEL_VERSION(2,6,32) )
+/* SLES11 SP1 is 2.6.32 based */
+#define SLE_VERSION_CODE SLE_VERSION(11,1,0)
+#elif ( LINUX_VERSION_CODE == KERNEL_VERSION(2,6,27) )
+/* SLES11 GA is 2.6.27 based */
+#define SLE_VERSION_CODE SLE_VERSION(11,0,0)
 #endif /* LINUX_VERSION_CODE == KERNEL_VERSION(x,y,z) */
 #endif /* CONFIG_SUSE_KERNEL */
 #ifndef SLE_VERSION_CODE
@@ -3912,7 +3915,8 @@ skb_set_hash(struct sk_buff *skb, __u32 hash, __always_unused int type)
 #define HAVE_NDO_BRIDGE_GETLINK_NLFLAGS
 #endif /* >= 4.1.0 */
 
-#if ( LINUX_VERSION_CODE >= KERNEL_VERSION(4,2,0) )
+#if (( LINUX_VERSION_CODE >= KERNEL_VERSION(4,2,0) ) \
+    || ( RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(7,4) ))
 /* ndo_bridge_getlink adds new filter_mask and vlan_fill parameters */
 #define HAVE_NDO_BRIDGE_GETLINK_FILTER_MASK_VLAN_FILL
 #endif /* >= 4.2.0 */
@@ -3929,9 +3933,16 @@ skb_set_hash(struct sk_buff *skb, __u32 hash, __always_unused int type)
 #define vlan_tx_tag_present skb_vlan_tag_present
 #endif
 
-#if ( LINUX_VERSION_CODE >= KERNEL_VERSION(4,9,0) )
+#if ((LINUX_VERSION_CODE >= KERNEL_VERSION(4, 9, 0)) || \
+     (SLE_VERSION_CODE && SLE_VERSION_CODE >= SLE_VERSION(12, 3, 0)) || \
+     (RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(7, 4)))
 #define HAVE_VF_VLAN_PROTO
-#endif /* >= 4.9.0 */
+#if (RHEL_RELEASE_CODE >= RHEL_RELEASE_VERSION(7, 4))
+/* In RHEL/Centos 7.4, the "new" version of ndo_set_vf_vlan
+ * is in the struct net_device_ops_extended */
+#define ndo_set_vf_vlan extended.ndo_set_vf_vlan
+#endif
+#endif
 
 #if (defined(RHEL_RELEASE_CODE) && \
 	(RHEL_RELEASE_VERSION(7, 5) <= RHEL_RELEASE_CODE))
diff --git a/lib/librte_eal/linuxapp/kni/ethtool/ixgbe/ixgbe.h b/lib/librte_eal/linuxapp/kni/ethtool/ixgbe/ixgbe.h
index 59415469..cc3f8ea4 100644
--- a/lib/librte_eal/linuxapp/kni/ethtool/ixgbe/ixgbe.h
+++ b/lib/librte_eal/linuxapp/kni/ethtool/ixgbe/ixgbe.h
@@ -905,8 +905,10 @@ s32 ixgbe_dcb_hw_ets(struct ixgbe_hw *hw, struct ieee_ets *ets, int max_frame);
 #endif /* CONFIG_DCB */
 
 extern void ixgbe_clean_rx_ring(struct ixgbe_ring *rx_ring);
+#ifndef ETHTOOL_GLINKSETTINGS
 extern int ixgbe_get_settings(struct net_device *netdev,
 			      struct ethtool_cmd *ecmd);
+#endif
 extern int ixgbe_write_uc_addr_list(struct ixgbe_adapter *adapter,
 			    struct net_device *netdev, unsigned int vfn);
 extern void ixgbe_full_sync_mac_table(struct ixgbe_adapter *adapter);
diff --git a/lib/librte_eal/linuxapp/kni/ethtool/ixgbe/ixgbe_ethtool.c b/lib/librte_eal/linuxapp/kni/ethtool/ixgbe/ixgbe_ethtool.c
index bc3cb2f4..8e3f2587 100644
--- a/lib/librte_eal/linuxapp/kni/ethtool/ixgbe/ixgbe_ethtool.c
+++ b/lib/librte_eal/linuxapp/kni/ethtool/ixgbe/ixgbe_ethtool.c
@@ -173,6 +173,7 @@ static const char ixgbe_gstrings_test[][ETH_GSTRING_LEN] = {
 #define IXGBE_TEST_LEN	(sizeof(ixgbe_gstrings_test) / ETH_GSTRING_LEN)
 #endif /* ETHTOOL_TEST */
 
+#ifndef ETHTOOL_GLINKSETTINGS
 int ixgbe_get_settings(struct net_device *netdev,
 		       struct ethtool_cmd *ecmd)
 {
@@ -362,7 +363,9 @@ int ixgbe_get_settings(struct net_device *netdev,
 
 	return 0;
 }
+#endif
 
+#ifndef ETHTOOL_SLINKSETTINGS
 static int ixgbe_set_settings(struct net_device *netdev,
 			      struct ethtool_cmd *ecmd)
 {
@@ -406,6 +409,7 @@ static int ixgbe_set_settings(struct net_device *netdev,
 	}
 	return err;
 }
+#endif
 
 static void ixgbe_get_pauseparam(struct net_device *netdev,
 				 struct ethtool_pauseparam *pause)
@@ -2830,8 +2834,12 @@ static int ixgbe_set_rxnfc(struct net_device *dev, struct ethtool_rxnfc *cmd)
 #endif /* ETHTOOL_GRXRINGS */
 //static
 struct ethtool_ops ixgbe_ethtool_ops = {
+#ifndef ETHTOOL_GLINKSETTINGS
 	.get_settings		= ixgbe_get_settings,
+#endif
+#ifndef ETHTOOL_SLINKSETTINGS
 	.set_settings		= ixgbe_set_settings,
+#endif
 	.get_drvinfo		= ixgbe_get_drvinfo,
 	.get_regs_len		= ixgbe_get_regs_len,
 	.get_regs		= ixgbe_get_regs,
diff --git a/lib/librte_eal/linuxapp/kni/kni_ethtool.c b/lib/librte_eal/linuxapp/kni/kni_ethtool.c
index 0c88589c..8174e98d 100644
--- a/lib/librte_eal/linuxapp/kni/kni_ethtool.c
+++ b/lib/librte_eal/linuxapp/kni/kni_ethtool.c
@@ -46,6 +46,8 @@ kni_get_drvinfo(struct net_device *dev, struct ethtool_drvinfo *info)
 	priv->lad_dev->ethtool_ops->get_drvinfo(priv->lad_dev, info);
 }
 
+/* ETHTOOL_GLINKSETTINGS replaces ETHTOOL_GSET */
+#ifndef ETHTOOL_GLINKSETTINGS
 static int
 kni_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
 {
@@ -53,7 +55,10 @@ kni_get_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
 
 	return priv->lad_dev->ethtool_ops->get_settings(priv->lad_dev, ecmd);
 }
+#endif
 
+/* ETHTOOL_SLINKSETTINGS replaces ETHTOOL_SSET */
+#ifndef ETHTOOL_SLINKSETTINGS
 static int
 kni_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
 {
@@ -61,6 +66,7 @@ kni_set_settings(struct net_device *dev, struct ethtool_cmd *ecmd)
 
 	return priv->lad_dev->ethtool_ops->set_settings(priv->lad_dev, ecmd);
 }
+#endif
 
 static void
 kni_get_wol(struct net_device *dev, struct ethtool_wolinfo *wol)
@@ -209,8 +215,12 @@ kni_get_ethtool_stats(struct net_device *dev, struct ethtool_stats *stats,
 struct ethtool_ops kni_ethtool_ops = {
 	.begin			= kni_check_if_running,
 	.get_drvinfo		= kni_get_drvinfo,
+#ifndef ETHTOOL_GLINKSETTINGS
 	.get_settings		= kni_get_settings,
+#endif
+#ifndef ETHTOOL_SLINKSETTINGS
 	.set_settings		= kni_set_settings,
+#endif
 	.get_regs_len		= kni_get_regs_len,
 	.get_regs		= kni_get_regs,
 	.get_wol		= kni_get_wol,
diff --git a/lib/librte_eal/linuxapp/kni/kni_fifo.h b/lib/librte_eal/linuxapp/kni/kni_fifo.h
index 025ec1c9..208d34bf 100644
--- a/lib/librte_eal/linuxapp/kni/kni_fifo.h
+++ b/lib/librte_eal/linuxapp/kni/kni_fifo.h
@@ -27,6 +27,14 @@
 
 #include <exec-env/rte_kni_common.h>
 
+/* Skip some memory barriers on Linux < 3.14 */
+#ifndef smp_load_acquire
+#define smp_load_acquire(a) (*(a))
+#endif
+#ifndef smp_store_release
+#define smp_store_release(a, b) *(a) = (b)
+#endif
+
 /**
  * Adds num elements into the fifo. Return the number actually written
  */
@@ -35,7 +43,7 @@ kni_fifo_put(struct rte_kni_fifo *fifo, void **data, uint32_t num)
 {
 	uint32_t i = 0;
 	uint32_t fifo_write = fifo->write;
-	uint32_t fifo_read = fifo->read;
+	uint32_t fifo_read = smp_load_acquire(&fifo->read);
 	uint32_t new_write = fifo_write;
 
 	for (i = 0; i < num; i++) {
@@ -46,7 +54,7 @@ kni_fifo_put(struct rte_kni_fifo *fifo, void **data, uint32_t num)
 		fifo->buffer[fifo_write] = data[i];
 		fifo_write = new_write;
 	}
-	fifo->write = fifo_write;
+	smp_store_release(&fifo->write, fifo_write);
 
 	return i;
 }
@@ -59,7 +67,7 @@ kni_fifo_get(struct rte_kni_fifo *fifo, void **data, uint32_t num)
 {
 	uint32_t i = 0;
 	uint32_t new_read = fifo->read;
-	uint32_t fifo_write = fifo->write;
+	uint32_t fifo_write = smp_load_acquire(&fifo->write);
 
 	for (i = 0; i < num; i++) {
 		if (new_read == fifo_write)
@@ -68,7 +76,7 @@ kni_fifo_get(struct rte_kni_fifo *fifo, void **data, uint32_t num)
 		data[i] = fifo->buffer[new_read];
 		new_read = (new_read + 1) & (fifo->len - 1);
 	}
-	fifo->read = new_read;
+	smp_store_release(&fifo->read, new_read);
 
 	return i;
 }
@@ -79,7 +87,9 @@ kni_fifo_get(struct rte_kni_fifo *fifo, void **data, uint32_t num)
 static inline uint32_t
 kni_fifo_count(struct rte_kni_fifo *fifo)
 {
-	return (fifo->len + fifo->write - fifo->read) & (fifo->len - 1);
+	uint32_t fifo_write = smp_load_acquire(&fifo->write);
+	uint32_t fifo_read = smp_load_acquire(&fifo->read);
+	return (fifo->len + fifo_write - fifo_read) & (fifo->len - 1);
 }
 
 /**
@@ -88,7 +98,9 @@ kni_fifo_count(struct rte_kni_fifo *fifo)
 static inline uint32_t
 kni_fifo_free_count(struct rte_kni_fifo *fifo)
 {
-	return (fifo->read - fifo->write - 1) & (fifo->len - 1);
+	uint32_t fifo_write = smp_load_acquire(&fifo->write);
+	uint32_t fifo_read = smp_load_acquire(&fifo->read);
+	return (fifo_read - fifo_write - 1) & (fifo->len - 1);
 }
 
 #ifdef RTE_KNI_VHOST
diff --git a/lib/librte_ether/rte_ethdev.c b/lib/librte_ether/rte_ethdev.c
index 9b28e95a..4992b30f 100644
--- a/lib/librte_ether/rte_ethdev.c
+++ b/lib/librte_ether/rte_ethdev.c
@@ -601,6 +601,13 @@ rte_eth_dev_rx_queue_start(uint8_t port_id, uint16_t rx_queue_id)
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
 
 	dev = &rte_eth_devices[port_id];
+	if (!dev->data->dev_started) {
+		RTE_PMD_DEBUG_TRACE(
+		    "port %d must be started before start any queue\n",
+		    port_id);
+		return -EINVAL;
+	}
+
 	if (rx_queue_id >= dev->data->nb_rx_queues) {
 		RTE_PMD_DEBUG_TRACE("Invalid RX queue_id=%d\n", rx_queue_id);
 		return -EINVAL;
@@ -627,12 +634,6 @@ rte_eth_dev_rx_queue_stop(uint8_t port_id, uint16_t rx_queue_id)
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
 
 	dev = &rte_eth_devices[port_id];
-	if (!dev->data->dev_started) {
-		RTE_PMD_DEBUG_TRACE(
-		    "port %d must be started before start any queue\n", port_id);
-		return -EINVAL;
-	}
-
 	if (rx_queue_id >= dev->data->nb_rx_queues) {
 		RTE_PMD_DEBUG_TRACE("Invalid RX queue_id=%d\n", rx_queue_id);
 		return -EINVAL;
@@ -659,6 +660,13 @@ rte_eth_dev_tx_queue_start(uint8_t port_id, uint16_t tx_queue_id)
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
 
 	dev = &rte_eth_devices[port_id];
+	if (!dev->data->dev_started) {
+		RTE_PMD_DEBUG_TRACE(
+		    "port %d must be started before start any queue\n",
+		    port_id);
+		return -EINVAL;
+	}
+
 	if (tx_queue_id >= dev->data->nb_tx_queues) {
 		RTE_PMD_DEBUG_TRACE("Invalid TX queue_id=%d\n", tx_queue_id);
 		return -EINVAL;
@@ -685,12 +693,6 @@ rte_eth_dev_tx_queue_stop(uint8_t port_id, uint16_t tx_queue_id)
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
 
 	dev = &rte_eth_devices[port_id];
-	if (!dev->data->dev_started) {
-		RTE_PMD_DEBUG_TRACE(
-		    "port %d must be started before start any queue\n", port_id);
-		return -EINVAL;
-	}
-
 	if (tx_queue_id >= dev->data->nb_tx_queues) {
 		RTE_PMD_DEBUG_TRACE("Invalid TX queue_id=%d\n", tx_queue_id);
 		return -EINVAL;
@@ -795,7 +797,9 @@ rte_eth_dev_configure(uint8_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
 {
 	struct rte_eth_dev *dev;
 	struct rte_eth_dev_info dev_info;
+	struct rte_eth_conf orig_conf;
 	int diag;
+	int ret;
 
 	RTE_ETH_VALID_PORTID_OR_ERR_RET(port_id, -EINVAL);
 
@@ -824,6 +828,9 @@ rte_eth_dev_configure(uint8_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
 		return -EBUSY;
 	}
 
+	/* Store original config, as rollback required on failure */
+	memcpy(&orig_conf, &dev->data->dev_conf, sizeof(dev->data->dev_conf));
+
 	/* Copy the dev_conf parameter into the dev structure */
 	memcpy(&dev->data->dev_conf, dev_conf, sizeof(dev->data->dev_conf));
 
@@ -836,19 +843,22 @@ rte_eth_dev_configure(uint8_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
 
 	if (nb_rx_q == 0 && nb_tx_q == 0) {
 		RTE_PMD_DEBUG_TRACE("ethdev port_id=%d both rx and tx queue cannot be 0\n", port_id);
-		return -EINVAL;
+		ret = -EINVAL;
+		goto rollback;
 	}
 
 	if (nb_rx_q > dev_info.max_rx_queues) {
 		RTE_PMD_DEBUG_TRACE("ethdev port_id=%d nb_rx_queues=%d > %d\n",
 				port_id, nb_rx_q, dev_info.max_rx_queues);
-		return -EINVAL;
+		ret = -EINVAL;
+		goto rollback;
 	}
 
 	if (nb_tx_q > dev_info.max_tx_queues) {
 		RTE_PMD_DEBUG_TRACE("ethdev port_id=%d nb_tx_queues=%d > %d\n",
 				port_id, nb_tx_q, dev_info.max_tx_queues);
-		return -EINVAL;
+		ret = -EINVAL;
+		goto rollback;
 	}
 
 	/*
@@ -859,7 +869,8 @@ rte_eth_dev_configure(uint8_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
 		(!(dev->data->dev_flags & RTE_ETH_DEV_INTR_LSC))) {
 			RTE_PMD_DEBUG_TRACE("driver %s does not support lsc\n",
 					dev->data->drv_name);
-			return -EINVAL;
+			ret = -EINVAL;
+			goto rollback;
 	}
 
 	/*
@@ -874,14 +885,16 @@ rte_eth_dev_configure(uint8_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
 				port_id,
 				(unsigned)dev_conf->rxmode.max_rx_pkt_len,
 				(unsigned)dev_info.max_rx_pktlen);
-			return -EINVAL;
+			ret = -EINVAL;
+			goto rollback;
 		} else if (dev_conf->rxmode.max_rx_pkt_len < ETHER_MIN_LEN) {
 			RTE_PMD_DEBUG_TRACE("ethdev port_id=%d max_rx_pkt_len %u"
 				" < min valid value %u\n",
 				port_id,
 				(unsigned)dev_conf->rxmode.max_rx_pkt_len,
 				(unsigned)ETHER_MIN_LEN);
-			return -EINVAL;
+			ret = -EINVAL;
+			goto rollback;
 		}
 	} else {
 		if (dev_conf->rxmode.max_rx_pkt_len < ETHER_MIN_LEN ||
@@ -898,7 +911,8 @@ rte_eth_dev_configure(uint8_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
 	if (diag != 0) {
 		RTE_PMD_DEBUG_TRACE("port%d rte_eth_dev_rx_queue_config = %d\n",
 				port_id, diag);
-		return diag;
+		ret = diag;
+		goto rollback;
 	}
 
 	diag = rte_eth_dev_tx_queue_config(dev, nb_tx_q);
@@ -906,7 +920,8 @@ rte_eth_dev_configure(uint8_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
 		RTE_PMD_DEBUG_TRACE("port%d rte_eth_dev_tx_queue_config = %d\n",
 				port_id, diag);
 		rte_eth_dev_rx_queue_config(dev, 0);
-		return diag;
+		ret = diag;
+		goto rollback;
 	}
 
 	diag = (*dev->dev_ops->dev_configure)(dev);
@@ -915,10 +930,16 @@ rte_eth_dev_configure(uint8_t port_id, uint16_t nb_rx_q, uint16_t nb_tx_q,
 				port_id, diag);
 		rte_eth_dev_rx_queue_config(dev, 0);
 		rte_eth_dev_tx_queue_config(dev, 0);
-		return diag;
+		ret = diag;
+		goto rollback;
 	}
 
 	return 0;
+
+rollback:
+	memcpy(&dev->data->dev_conf, &orig_conf, sizeof(dev->data->dev_conf));
+
+	return ret;
 }
 
 static void
diff --git a/lib/librte_ether/rte_ethdev.h b/lib/librte_ether/rte_ethdev.h
index 981e0577..41839bbe 100644
--- a/lib/librte_ether/rte_ethdev.h
+++ b/lib/librte_ether/rte_ethdev.h
@@ -842,12 +842,6 @@ struct rte_eth_conf {
 };
 
 /**
- * A structure used to retrieve the contextual information of
- * an Ethernet device, such as the controlling driver of the device,
- * its PCI context, etc...
- */
-
-/**
  * RX offload capabilities of a device.
  */
 #define DEV_RX_OFFLOAD_VLAN_STRIP  0x00000001
@@ -878,6 +872,12 @@ struct rte_eth_conf {
 /**
  * Ethernet device information
  */
+
+/**
+ * A structure used to retrieve the contextual information of
+ * an Ethernet device, such as the controlling driver of the
+ * device, etc...
+ */
 struct rte_eth_dev_info {
 	struct rte_pci_device *pci_dev; /**< Device PCI information. */
 	const char *driver_name; /**< Device Driver name. */
diff --git a/lib/librte_hash/rte_cuckoo_hash.c b/lib/librte_hash/rte_cuckoo_hash.c
index 049ff988..2414c7f2 100644
--- a/lib/librte_hash/rte_cuckoo_hash.c
+++ b/lib/librte_hash/rte_cuckoo_hash.c
@@ -212,7 +212,9 @@ rte_hash_create(const struct rte_hash_parameters *params)
 		goto err_unlock;
 	}
 
-	const uint32_t key_entry_size = sizeof(struct rte_hash_key) + params->key_len;
+	const uint32_t key_entry_size =
+		RTE_ALIGN(sizeof(struct rte_hash_key) + params->key_len,
+			  KEY_ALIGNMENT);
 	const uint64_t key_tbl_size = (uint64_t) key_entry_size * num_key_slots;
 
 	k = rte_zmalloc_socket(NULL, key_tbl_size,
@@ -405,7 +407,7 @@ rte_hash_reset(struct rte_hash *h)
 
 	/* clear the free ring */
 	while (rte_ring_dequeue(h->free_slots, &ptr) == 0)
-		rte_pause();
+		continue;
 
 	/* Repopulate the free slots ring. Entry zero is reserved for key misses */
 	if (h->hw_trans_mem_support)
diff --git a/lib/librte_hash/rte_cuckoo_hash.h b/lib/librte_hash/rte_cuckoo_hash.h
index 1b8ffed8..dae3f4a3 100644
--- a/lib/librte_hash/rte_cuckoo_hash.h
+++ b/lib/librte_hash/rte_cuckoo_hash.h
@@ -161,7 +161,7 @@ struct rte_hash_key {
 	};
 	/* Variable key size */
 	char key[0];
-} __attribute__((aligned(KEY_ALIGNMENT)));
+};
 
 /* All different signature compare functions */
 enum rte_hash_sig_compare_function {
diff --git a/lib/librte_ip_frag/ip_frag_common.h b/lib/librte_ip_frag/ip_frag_common.h
index 835e4f93..5382a3e3 100644
--- a/lib/librte_ip_frag/ip_frag_common.h
+++ b/lib/librte_ip_frag/ip_frag_common.h
@@ -81,28 +81,23 @@ struct rte_mbuf *ipv6_frag_reassemble(struct ip_frag_pkt *fp);
 static inline int
 ip_frag_key_is_empty(const struct ip_frag_key * key)
 {
-	uint32_t i;
-	for (i = 0; i < RTE_MIN(key->key_len, RTE_DIM(key->src_dst)); i++)
-		if (key->src_dst[i] != 0)
-			return 0;
-	return 1;
+	return (key->key_len == 0);
 }
 
-/* empty the key */
+/* invalidate the key */
 static inline void
 ip_frag_key_invalidate(struct ip_frag_key * key)
 {
-	uint32_t i;
-	for (i = 0; i < key->key_len; i++)
-		key->src_dst[i] = 0;
+	key->key_len = 0;
 }
 
 /* compare two keys */
-static inline int
+static inline uint64_t
 ip_frag_key_cmp(const struct ip_frag_key * k1, const struct ip_frag_key * k2)
 {
-	uint32_t i, val;
-	val = k1->id ^ k2->id;
+	uint32_t i;
+	uint64_t val;
+	val = k1->id_key_len ^ k2->id_key_len;
 	for (i = 0; i < k1->key_len; i++)
 		val |= k1->src_dst[i] ^ k2->src_dst[i];
 	return val;
diff --git a/lib/librte_ip_frag/rte_ip_frag.h b/lib/librte_ip_frag/rte_ip_frag.h
index 6708906d..e13486ac 100644
--- a/lib/librte_ip_frag/rte_ip_frag.h
+++ b/lib/librte_ip_frag/rte_ip_frag.h
@@ -72,9 +72,17 @@ struct ip_frag {
 
 /** @internal <src addr, dst_addr, id> to uniquely indetify fragmented datagram. */
 struct ip_frag_key {
-	uint64_t src_dst[4];      /**< src address, first 8 bytes used for IPv4 */
-	uint32_t id;           /**< dst address */
-	uint32_t key_len;      /**< src/dst key length */
+	uint64_t src_dst[4];
+	/**< src and dst address, only first 8 bytes used for IPv4 */
+	RTE_STD_C11
+	union {
+		uint64_t id_key_len; /**< combined for easy fetch */
+		__extension__
+		struct {
+			uint32_t id;       /**< packet id */
+			uint32_t key_len;  /**< src/dst key length */
+		};
+	};
 };
 
 /**
diff --git a/lib/librte_ip_frag/rte_ipv4_reassembly.c b/lib/librte_ip_frag/rte_ipv4_reassembly.c
index 847ea0d6..ede2ae09 100644
--- a/lib/librte_ip_frag/rte_ipv4_reassembly.c
+++ b/lib/librte_ip_frag/rte_ipv4_reassembly.c
@@ -65,8 +65,11 @@ ipv4_frag_reassemble(struct ip_frag_pkt *fp)
 			/* previous fragment found. */
 			if(fp->frags[i].ofs + fp->frags[i].len == ofs) {
 
+				RTE_ASSERT(curr_idx != i);
+
 				/* adjust start of the last fragment data. */
-				rte_pktmbuf_adj(m, (uint16_t)(m->l2_len + m->l3_len));
+				rte_pktmbuf_adj(m,
+					(uint16_t)(m->l2_len + m->l3_len));
 				rte_pktmbuf_chain(fp->frags[i].mb, m);
 
 				/* this mbuf should not be accessed directly */
@@ -125,14 +128,14 @@ ipv4_frag_reassemble(struct ip_frag_pkt *fp)
  */
 struct rte_mbuf *
 rte_ipv4_frag_reassemble_packet(struct rte_ip_frag_tbl *tbl,
-		struct rte_ip_frag_death_row *dr, struct rte_mbuf *mb, uint64_t tms,
-		struct ipv4_hdr *ip_hdr)
+	struct rte_ip_frag_death_row *dr, struct rte_mbuf *mb, uint64_t tms,
+	struct ipv4_hdr *ip_hdr)
 {
 	struct ip_frag_pkt *fp;
 	struct ip_frag_key key;
 	const unaligned_uint64_t *psd;
-	uint16_t ip_len;
 	uint16_t flag_offset, ip_ofs, ip_flag;
+	int32_t ip_len;
 
 	flag_offset = rte_be_to_cpu_16(ip_hdr->fragment_offset);
 	ip_ofs = (uint16_t)(flag_offset & IPV4_HDR_OFFSET_MASK);
@@ -145,12 +148,11 @@ rte_ipv4_frag_reassemble_packet(struct rte_ip_frag_tbl *tbl,
 	key.key_len = IPV4_KEYLEN;
 
 	ip_ofs *= IPV4_HDR_OFFSET_UNITS;
-	ip_len = (uint16_t)(rte_be_to_cpu_16(ip_hdr->total_length) -
-		mb->l3_len);
+	ip_len = rte_be_to_cpu_16(ip_hdr->total_length) - mb->l3_len;
 
 	IP_FRAG_LOG(DEBUG, "%s:%d:\n"
 		"mbuf: %p, tms: %" PRIu64
-		", key: <%" PRIx64 ", %#x>, ofs: %u, len: %u, flags: %#x\n"
+		", key: <%" PRIx64 ", %#x>, ofs: %u, len: %d, flags: %#x\n"
 		"tbl: %p, max_cycles: %" PRIu64 ", entry_mask: %#x, "
 		"max_entries: %u, use_entries: %u\n\n",
 		__func__, __LINE__,
@@ -158,6 +160,12 @@ rte_ipv4_frag_reassemble_packet(struct rte_ip_frag_tbl *tbl,
 		tbl, tbl->max_cycles, tbl->entry_mask, tbl->max_entries,
 		tbl->use_entries);
 
+	/* check that fragment length is greater then zero. */
+	if (ip_len <= 0) {
+		IP_FRAG_MBUF2DR(dr, mb);
+		return NULL;
+	}
+
 	/* try to find/add entry into the fragment's table. */
 	if ((fp = ip_frag_find(tbl, dr, &key, tms)) == NULL) {
 		IP_FRAG_MBUF2DR(dr, mb);
diff --git a/lib/librte_ip_frag/rte_ipv6_reassembly.c b/lib/librte_ip_frag/rte_ipv6_reassembly.c
index d9b5d690..9f080d6e 100644
--- a/lib/librte_ip_frag/rte_ipv6_reassembly.c
+++ b/lib/librte_ip_frag/rte_ipv6_reassembly.c
@@ -88,8 +88,11 @@ ipv6_frag_reassemble(struct ip_frag_pkt *fp)
 			/* previous fragment found. */
 			if (fp->frags[i].ofs + fp->frags[i].len == ofs) {
 
+				RTE_ASSERT(curr_idx != i);
+
 				/* adjust start of the last fragment data. */
-				rte_pktmbuf_adj(m, (uint16_t)(m->l2_len + m->l3_len));
+				rte_pktmbuf_adj(m,
+					(uint16_t)(m->l2_len + m->l3_len));
 				rte_pktmbuf_chain(fp->frags[i].mb, m);
 
 				/* this mbuf should not be accessed directly */
@@ -164,12 +167,13 @@ ipv6_frag_reassemble(struct ip_frag_pkt *fp)
 #define FRAG_OFFSET(x) (rte_cpu_to_be_16(x) >> 3)
 struct rte_mbuf *
 rte_ipv6_frag_reassemble_packet(struct rte_ip_frag_tbl *tbl,
-		struct rte_ip_frag_death_row *dr, struct rte_mbuf *mb, uint64_t tms,
-		struct ipv6_hdr *ip_hdr, struct ipv6_extension_fragment *frag_hdr)
+	struct rte_ip_frag_death_row *dr, struct rte_mbuf *mb, uint64_t tms,
+	struct ipv6_hdr *ip_hdr, struct ipv6_extension_fragment *frag_hdr)
 {
 	struct ip_frag_pkt *fp;
 	struct ip_frag_key key;
-	uint16_t ip_len, ip_ofs;
+	uint16_t ip_ofs;
+	int32_t ip_len;
 
 	rte_memcpy(&key.src_dst[0], ip_hdr->src_addr, 16);
 	rte_memcpy(&key.src_dst[2], ip_hdr->dst_addr, 16);
@@ -180,15 +184,17 @@ rte_ipv6_frag_reassemble_packet(struct rte_ip_frag_tbl *tbl,
 	ip_ofs = FRAG_OFFSET(frag_hdr->frag_data) * 8;
 
 	/*
-	 * as per RFC2460, payload length contains all extension headers as well.
-	 * since we don't support anything but frag headers, this is what we remove
-	 * from the payload len.
+	 * as per RFC2460, payload length contains all extension headers
+	 * as well.
+	 * since we don't support anything but frag headers,
+	 * this is what we remove from the payload len.
 	 */
 	ip_len = rte_be_to_cpu_16(ip_hdr->payload_len) - sizeof(*frag_hdr);
 
 	IP_FRAG_LOG(DEBUG, "%s:%d:\n"
 		"mbuf: %p, tms: %" PRIu64
-		", key: <" IPv6_KEY_BYTES_FMT ", %#x>, ofs: %u, len: %u, flags: %#x\n"
+		", key: <" IPv6_KEY_BYTES_FMT ", %#x>, "
+		"ofs: %u, len: %d, flags: %#x\n"
 		"tbl: %p, max_cycles: %" PRIu64 ", entry_mask: %#x, "
 		"max_entries: %u, use_entries: %u\n\n",
 		__func__, __LINE__,
@@ -197,6 +203,12 @@ rte_ipv6_frag_reassemble_packet(struct rte_ip_frag_tbl *tbl,
 		tbl, tbl->max_cycles, tbl->entry_mask, tbl->max_entries,
 		tbl->use_entries);
 
+	/* check that fragment length is greater then zero. */
+	if (ip_len <= 0) {
+		IP_FRAG_MBUF2DR(dr, mb);
+		return NULL;
+	}
+
 	/* try to find/add entry into the fragment's table. */
 	fp = ip_frag_find(tbl, dr, &key, tms);
 	if (fp == NULL) {
diff --git a/lib/librte_kni/rte_kni.c b/lib/librte_kni/rte_kni.c
index 0c6641bf..12656a9d 100644
--- a/lib/librte_kni/rte_kni.c
+++ b/lib/librte_kni/rte_kni.c
@@ -532,7 +532,7 @@ int
 rte_kni_handle_request(struct rte_kni *kni)
 {
 	unsigned ret;
-	struct rte_kni_request *req;
+	struct rte_kni_request *req = NULL;
 
 	if (kni == NULL)
 		return -1;
diff --git a/lib/librte_kvargs/rte_kvargs.c b/lib/librte_kvargs/rte_kvargs.c
index 5504c6df..476b8c1d 100644
--- a/lib/librte_kvargs/rte_kvargs.c
+++ b/lib/librte_kvargs/rte_kvargs.c
@@ -160,6 +160,9 @@ rte_kvargs_process(const struct rte_kvargs *kvlist,
 	const struct rte_kvargs_pair *pair;
 	unsigned i;
 
+	if (kvlist == NULL)
+		return 0;
+
 	for (i = 0; i < kvlist->count; i++) {
 		pair = &kvlist->pairs[i];
 		if (key_match == NULL || strcmp(pair->key, key_match) == 0) {
diff --git a/lib/librte_kvargs/rte_kvargs.h b/lib/librte_kvargs/rte_kvargs.h
index ae9ae79f..83363a8d 100644
--- a/lib/librte_kvargs/rte_kvargs.h
+++ b/lib/librte_kvargs/rte_kvargs.h
@@ -106,7 +106,7 @@ struct rte_kvargs *rte_kvargs_parse(const char *args, const char *valid_keys[]);
  * rte_kvargs_parse().
  *
  * @param kvlist
- *   The rte_kvargs structure
+ *   The rte_kvargs structure. No error if NULL.
  */
 void rte_kvargs_free(struct rte_kvargs *kvlist);
 
@@ -115,11 +115,10 @@ void rte_kvargs_free(struct rte_kvargs *kvlist);
  *
  * For each key/value association that matches the given key, calls the
  * handler function with the for a given arg_name passing the value on the
- * dictionary for that key and a given extra argument. If *kvlist* is NULL
- * function does nothing.
+ * dictionary for that key and a given extra argument.
  *
  * @param kvlist
- *   The rte_kvargs structure
+ *   The rte_kvargs structure. No error if NULL.
  * @param key_match
  *   The key on which the handler should be called, or NULL to process handler
  *   on all associations
diff --git a/lib/librte_net/rte_gre.h b/lib/librte_net/rte_gre.h
index 46568ff5..8a3414cf 100644
--- a/lib/librte_net/rte_gre.h
+++ b/lib/librte_net/rte_gre.h
@@ -43,6 +43,7 @@ extern "C" {
 /**
  * GRE Header
  */
+__extension__
 struct gre_hdr {
 #if RTE_BYTE_ORDER == RTE_LITTLE_ENDIAN
 	uint16_t res2:4; /**< Reserved */
diff --git a/lib/librte_sched/rte_bitmap.h b/lib/librte_sched/rte_bitmap.h
index bbf4da94..6828a7c3 100644
--- a/lib/librte_sched/rte_bitmap.h
+++ b/lib/librte_sched/rte_bitmap.h
@@ -116,7 +116,7 @@ __rte_bitmap_index1_inc(struct rte_bitmap *bmp)
 static inline uint64_t
 __rte_bitmap_mask1_get(struct rte_bitmap *bmp)
 {
-	return (~1lu) << bmp->offset1;
+	return (~1llu) << bmp->offset1;
 }
 
 static inline void
@@ -345,7 +345,7 @@ rte_bitmap_get(struct rte_bitmap *bmp, uint32_t pos)
 	index2 = pos >> RTE_BITMAP_SLAB_BIT_SIZE_LOG2;
 	offset2 = pos & RTE_BITMAP_SLAB_BIT_MASK;
 	slab2 = bmp->array2 + index2;
-	return (*slab2) & (1lu << offset2);
+	return (*slab2) & (1llu << offset2);
 }
 
 /**
@@ -370,8 +370,8 @@ rte_bitmap_set(struct rte_bitmap *bmp, uint32_t pos)
 	slab2 = bmp->array2 + index2;
 	slab1 = bmp->array1 + index1;
 
-	*slab2 |= 1lu << offset2;
-	*slab1 |= 1lu << offset1;
+	*slab2 |= 1llu << offset2;
+	*slab1 |= 1llu << offset1;
 }
 
 /**
@@ -398,7 +398,7 @@ rte_bitmap_set_slab(struct rte_bitmap *bmp, uint32_t pos, uint64_t slab)
 	slab1 = bmp->array1 + index1;
 
 	*slab2 |= slab;
-	*slab1 |= 1lu << offset1;
+	*slab1 |= 1llu << offset1;
 }
 
 static inline uint64_t
@@ -436,7 +436,7 @@ rte_bitmap_clear(struct rte_bitmap *bmp, uint32_t pos)
 	slab2 = bmp->array2 + index2;
 
 	/* Return if array2 slab is not all-zeros */
-	*slab2 &= ~(1lu << offset2);
+	*slab2 &= ~(1llu << offset2);
 	if (*slab2){
 		return;
 	}
@@ -452,7 +452,7 @@ rte_bitmap_clear(struct rte_bitmap *bmp, uint32_t pos)
 	index1 = pos >> (RTE_BITMAP_SLAB_BIT_SIZE_LOG2 + RTE_BITMAP_CL_BIT_SIZE_LOG2);
 	offset1 = (pos >> RTE_BITMAP_CL_BIT_SIZE_LOG2) & RTE_BITMAP_SLAB_BIT_MASK;
 	slab1 = bmp->array1 + index1;
-	*slab1 &= ~(1lu << offset1);
+	*slab1 &= ~(1llu << offset1);
 
 	return;
 }
diff --git a/lib/librte_sched/rte_reciprocal.c b/lib/librte_sched/rte_reciprocal.c
index 652f0237..385109cd 100644
--- a/lib/librte_sched/rte_reciprocal.c
+++ b/lib/librte_sched/rte_reciprocal.c
@@ -38,28 +38,13 @@
 
 #include "rte_reciprocal.h"
 
-/* find largest set bit.
- * portable and slow but does not matter for this usage.
- */
-static inline int fls(uint32_t x)
-{
-	int b;
-
-	for (b = 31; b >= 0; --b) {
-		if (x & (1u << b))
-			return b + 1;
-	}
-
-	return 0;
-}
-
 struct rte_reciprocal rte_reciprocal_value(uint32_t d)
 {
 	struct rte_reciprocal R;
 	uint64_t m;
 	int l;
 
-	l = fls(d - 1);
+	l = rte_fls_u32(d - 1);
 	m = ((1ULL << 32) * ((1ULL << l) - d));
 	m /= d;
 
diff --git a/lib/librte_vhost/vhost_user.c b/lib/librte_vhost/vhost_user.c
index 04c92ceb..618d413f 100644
--- a/lib/librte_vhost/vhost_user.c
+++ b/lib/librte_vhost/vhost_user.c
@@ -741,7 +741,7 @@ vhost_user_set_vring_call(struct virtio_net *dev, struct VhostUserMsg *pmsg)
  *  In vhost-user, when we receive kick message, will test whether virtio
  *  device is ready for packet processing.
  */
-static void
+static int
 vhost_user_set_vring_kick(struct virtio_net *dev, struct VhostUserMsg *pmsg)
 {
 	struct vhost_vring_file file;
@@ -769,6 +769,8 @@ vhost_user_set_vring_kick(struct virtio_net *dev, struct VhostUserMsg *pmsg)
 		if (notify_ops->new_device(dev->vid) == 0)
 			dev->flags |= VIRTIO_DEV_RUNNING;
 	}
+
+	return 0;
 }
 
 static void
@@ -847,14 +849,19 @@ vhost_user_set_vring_enable(struct virtio_net *dev,
 	return 0;
 }
 
-static void
+static int
 vhost_user_set_protocol_features(struct virtio_net *dev,
 				 uint64_t protocol_features)
 {
-	if (protocol_features & ~VHOST_USER_PROTOCOL_FEATURES)
-		return;
+	if (protocol_features & ~VHOST_USER_PROTOCOL_FEATURES) {
+		RTE_LOG(ERR, VHOST_CONFIG,
+			"(%d) received invalid protocol features.\n",
+			dev->vid);
+		return -1;
+	}
 
 	dev->protocol_features = protocol_features;
+	return 0;
 }
 
 static int
@@ -949,7 +956,7 @@ read_vhost_message(int sockfd, struct VhostUserMsg *msg)
 	if (ret <= 0)
 		return ret;
 
-	if (msg && msg->size) {
+	if (msg->size) {
 		if (msg->size > sizeof(msg->payload)) {
 			RTE_LOG(ERR, VHOST_CONFIG,
 				"invalid msg size: %d\n", msg->size);
@@ -1080,6 +1087,7 @@ vhost_user_msg_handler(int vid, int fd)
 
 	}
 
+	ret = 0;
 	switch (msg.request) {
 	case VHOST_USER_GET_FEATURES:
 		msg.payload.u64 = vhost_user_get_features();
@@ -1087,7 +1095,7 @@ vhost_user_msg_handler(int vid, int fd)
 		send_vhost_message(fd, &msg);
 		break;
 	case VHOST_USER_SET_FEATURES:
-		vhost_user_set_features(dev, msg.payload.u64);
+		ret = vhost_user_set_features(dev, msg.payload.u64);
 		break;
 
 	case VHOST_USER_GET_PROTOCOL_FEATURES:
@@ -1096,14 +1104,14 @@ vhost_user_msg_handler(int vid, int fd)
 		send_vhost_message(fd, &msg);
 		break;
 	case VHOST_USER_SET_PROTOCOL_FEATURES:
-		vhost_user_set_protocol_features(dev, msg.payload.u64);
+		ret = vhost_user_set_protocol_features(dev, msg.payload.u64);
 		break;
 
 	case VHOST_USER_SET_OWNER:
-		vhost_user_set_owner();
+		ret = vhost_user_set_owner();
 		break;
 	case VHOST_USER_RESET_OWNER:
-		vhost_user_reset_owner(dev);
+		ret = vhost_user_reset_owner(dev);
 		break;
 
 	case VHOST_USER_SET_MEM_TABLE:
@@ -1111,10 +1119,14 @@ vhost_user_msg_handler(int vid, int fd)
 		break;
 
 	case VHOST_USER_SET_LOG_BASE:
-		vhost_user_set_log_base(dev, &msg);
-
-		/* it needs a reply */
-		msg.size = sizeof(msg.payload.u64);
+		ret = vhost_user_set_log_base(dev, &msg);
+		if (ret)
+			break;
+		/*
+		 * The spec is not clear about it (yet), but QEMU doesn't expect
+		 * any payload in the reply. But a reply is required.
+		 */
+		msg.size = 0;
 		send_vhost_message(fd, &msg);
 		break;
 	case VHOST_USER_SET_LOG_FD:
@@ -1123,23 +1135,25 @@ vhost_user_msg_handler(int vid, int fd)
 		break;
 
 	case VHOST_USER_SET_VRING_NUM:
-		vhost_user_set_vring_num(dev, &msg.payload.state);
+		ret = vhost_user_set_vring_num(dev, &msg.payload.state);
 		break;
 	case VHOST_USER_SET_VRING_ADDR:
-		vhost_user_set_vring_addr(&dev, &msg.payload.addr);
+		ret = vhost_user_set_vring_addr(&dev, &msg.payload.addr);
 		break;
 	case VHOST_USER_SET_VRING_BASE:
-		vhost_user_set_vring_base(dev, &msg.payload.state);
+		ret = vhost_user_set_vring_base(dev, &msg.payload.state);
 		break;
 
 	case VHOST_USER_GET_VRING_BASE:
 		ret = vhost_user_get_vring_base(dev, &msg.payload.state);
+		if (ret)
+			break;
 		msg.size = sizeof(msg.payload.state);
 		send_vhost_message(fd, &msg);
 		break;
 
 	case VHOST_USER_SET_VRING_KICK:
-		vhost_user_set_vring_kick(dev, &msg);
+		ret = vhost_user_set_vring_kick(dev, &msg);
 		break;
 	case VHOST_USER_SET_VRING_CALL:
 		vhost_user_set_vring_call(dev, &msg);
@@ -1158,10 +1172,10 @@ vhost_user_msg_handler(int vid, int fd)
 		break;
 
 	case VHOST_USER_SET_VRING_ENABLE:
-		vhost_user_set_vring_enable(dev, &msg.payload.state);
+		ret = vhost_user_set_vring_enable(dev, &msg.payload.state);
 		break;
 	case VHOST_USER_SEND_RARP:
-		vhost_user_send_rarp(dev, &msg);
+		ret = vhost_user_send_rarp(dev, &msg);
 		break;
 
 	default:
@@ -1172,5 +1186,11 @@ vhost_user_msg_handler(int vid, int fd)
 	if (unlock_required)
 		vhost_user_unlock_all_queue_pairs(dev);
 
+	if (ret) {
+		RTE_LOG(ERR, VHOST_CONFIG,
+			"vhost message handling failed.\n");
+		return -1;
+	}
+
 	return 0;
 }
diff --git a/lib/librte_vhost/virtio_net.c b/lib/librte_vhost/virtio_net.c
index cfd69cea..eaee1c78 100644
--- a/lib/librte_vhost/virtio_net.c
+++ b/lib/librte_vhost/virtio_net.c
@@ -272,7 +272,7 @@ flush_shadow_used_ring(struct virtio_net *dev, struct vhost_virtqueue *vq)
 
 static inline void __attribute__((always_inline))
 update_shadow_used_ring(struct vhost_virtqueue *vq,
-			 uint16_t desc_idx, uint16_t len)
+			 uint16_t desc_idx, uint32_t len)
 {
 	uint16_t i = vq->shadow_used_idx++;
 
@@ -610,7 +610,7 @@ static inline int __attribute__((always_inline))
 fill_vec_buf(struct virtio_net *dev, struct vhost_virtqueue *vq,
 			 uint32_t avail_idx, uint32_t *vec_idx,
 			 struct buf_vector *buf_vec, uint16_t *desc_chain_head,
-			 uint16_t *desc_chain_len)
+			 uint32_t *desc_chain_len)
 {
 	uint16_t idx = vq->avail->ring[avail_idx & (vq->size - 1)];
 	uint32_t vec_id = *vec_idx;
@@ -684,7 +684,7 @@ reserve_avail_buf_mergeable(struct virtio_net *dev, struct vhost_virtqueue *vq,
 	uint16_t tries = 0;
 
 	uint16_t head_idx = 0;
-	uint16_t len = 0;
+	uint32_t len = 0;
 
 	*num_buffers = 0;
 	cur_idx  = vq->last_avail_idx;
diff --git a/mk/rte.cpuflags.mk b/mk/rte.cpuflags.mk
index e634abc3..5cef63ab 100644
--- a/mk/rte.cpuflags.mk
+++ b/mk/rte.cpuflags.mk
@@ -70,8 +70,10 @@ CPUFLAGS += PCLMULQDQ
 endif
 
 ifneq ($(filter $(AUTO_CPUFLAGS),__AVX__),)
+ifeq ($(CONFIG_RTE_ENABLE_AVX),y)
 CPUFLAGS += AVX
 endif
+endif
 
 ifneq ($(filter $(AUTO_CPUFLAGS),__RDRND__),)
 CPUFLAGS += RDRAND
@@ -86,11 +88,20 @@ CPUFLAGS += F16C
 endif
 
 ifneq ($(filter $(AUTO_CPUFLAGS),__AVX2__),)
+ifeq ($(CONFIG_RTE_ENABLE_AVX),y)
 CPUFLAGS += AVX2
 endif
+endif
 
 ifneq ($(filter $(AUTO_CPUFLAGS),__AVX512F__),)
+ifeq ($(CONFIG_RTE_ENABLE_AVX512),y)
 CPUFLAGS += AVX512F
+else
+# disable AVX512F support of gcc as a workaround for Bug 97
+ifeq ($(CONFIG_RTE_TOOLCHAIN_GCC),y)
+MACHINE_CFLAGS += -mno-avx512f
+endif
+endif
 endif
 
 # IBM Power CPU flags
@@ -111,7 +122,7 @@ CPUFLAGS += VSX
 endif
 
 # ARM flags
-ifneq ($(filter $(AUTO_CPUFLAGS),__ARM_NEON),)
+ifneq ($(filter __ARM_NEON __aarch64__,$(AUTO_CPUFLAGS)),)
 CPUFLAGS += NEON
 endif
 
diff --git a/pkg/dpdk.spec b/pkg/dpdk.spec
index b33a1824..c2cd30ff 100644
--- a/pkg/dpdk.spec
+++ b/pkg/dpdk.spec
@@ -30,7 +30,7 @@
 # OF THE POSSIBILITY OF SUCH DAMAGE.
 
 Name: dpdk
-Version: 16.11.8
+Version: 16.11.9
 Release: 1
 Packager: packaging@6wind.com
 URL: http://dpdk.org
diff --git a/tools/dpdk-devbind.py b/tools/dpdk-devbind.py
index e7cfcd02..47597dee 100755
--- a/tools/dpdk-devbind.py
+++ b/tools/dpdk-devbind.py
@@ -609,6 +609,13 @@ def do_arg_actions():
 
 def main():
     '''program main function'''
+    # check if lspci is installed, suppress any output
+    with open(os.devnull, 'w') as devnull:
+        ret = subprocess.call(['which', 'lspci'],
+                              stdout=devnull, stderr=devnull)
+        if ret != 0:
+            print("'lspci' not found - please install 'pciutils'")
+            sys.exit(1)
     parse_args()
     check_modules()
     get_nic_details()
author	Luca Boccassi <luca.boccassi@gmail.com>	2019-03-20 14:45:09 +0000
committer	Luca Boccassi <luca.boccassi@gmail.com>	2019-03-20 14:45:37 +0000
commit	f7a9461e29147c47ce2bb81bd157ac1833cf5eb1 (patch)
tree	6f3b4f4850cf9f116acc1dda3f0515259673e13b
parent	8e6d9d118f6105a3627b64a7949e1fb0b145879e (diff)