New upstream version 18.02upstream/18.02

Change-Id: I89ed24cb2a49b78fe5be6970b99dd46c1499fcc3
Signed-off-by: Luca Boccassi <luca.boccassi@gmail.com>

1 files changed, 476 insertions, 150 deletions

diff --git a/drivers/net/bnxt/bnxt_ethdev.c b/drivers/net/bnxt/bnxt_ethdev.c
index 3b6813cb..21c46f83 100644
--- a/drivers/net/bnxt/bnxt_ethdev.c
+++ b/drivers/net/bnxt/bnxt_ethdev.c
@@ -35,7 +35,7 @@
 #include <stdbool.h>
 
 #include <rte_dev.h>
-#include <rte_ethdev.h>
+#include <rte_ethdev_driver.h>
 #include <rte_ethdev_pci.h>
 #include <rte_malloc.h>
 #include <rte_cycles.h>
@@ -58,6 +58,7 @@
 #define DRV_MODULE_NAME		"bnxt"
 static const char bnxt_version[] =
 	"Broadcom Cumulus driver " DRV_MODULE_NAME "\n";
+int bnxt_logtype_driver;
 
 #define PCI_VENDOR_ID_BROADCOM 0x14E4
 
@@ -201,7 +202,7 @@ alloc_mem_err:
 
 static int bnxt_init_chip(struct bnxt *bp)
 {
-	unsigned int i, rss_idx, fw_idx;
+	unsigned int i;
 	struct rte_eth_link new;
 	struct rte_pci_device *pci_dev = RTE_ETH_DEV_TO_PCI(bp->eth_dev);
 	struct rte_intr_handle *intr_handle = &pci_dev->intr_handle;
@@ -223,25 +224,25 @@ static int bnxt_init_chip(struct bnxt *bp)
 
 	rc = bnxt_alloc_all_hwrm_stat_ctxs(bp);
 	if (rc) {
-		RTE_LOG(ERR, PMD, "HWRM stat ctx alloc failure rc: %x\n", rc);
+		PMD_DRV_LOG(ERR, "HWRM stat ctx alloc failure rc: %x\n", rc);
 		goto err_out;
 	}
 
 	rc = bnxt_alloc_hwrm_rings(bp);
 	if (rc) {
-		RTE_LOG(ERR, PMD, "HWRM ring alloc failure rc: %x\n", rc);
+		PMD_DRV_LOG(ERR, "HWRM ring alloc failure rc: %x\n", rc);
 		goto err_out;
 	}
 
 	rc = bnxt_alloc_all_hwrm_ring_grps(bp);
 	if (rc) {
-		RTE_LOG(ERR, PMD, "HWRM ring grp alloc failure: %x\n", rc);
+		PMD_DRV_LOG(ERR, "HWRM ring grp alloc failure: %x\n", rc);
 		goto err_out;
 	}
 
 	rc = bnxt_mq_rx_configure(bp);
 	if (rc) {
-		RTE_LOG(ERR, PMD, "MQ mode configure failure rc: %x\n", rc);
+		PMD_DRV_LOG(ERR, "MQ mode configure failure rc: %x\n", rc);
 		goto err_out;
 	}
 
@@ -251,14 +252,14 @@ static int bnxt_init_chip(struct bnxt *bp)
 
 		rc = bnxt_hwrm_vnic_alloc(bp, vnic);
 		if (rc) {
-			RTE_LOG(ERR, PMD, "HWRM vnic %d alloc failure rc: %x\n",
+			PMD_DRV_LOG(ERR, "HWRM vnic %d alloc failure rc: %x\n",
 				i, rc);
 			goto err_out;
 		}
 
 		rc = bnxt_hwrm_vnic_ctx_alloc(bp, vnic);
 		if (rc) {
-			RTE_LOG(ERR, PMD,
+			PMD_DRV_LOG(ERR,
 				"HWRM vnic %d ctx alloc failure rc: %x\n",
 				i, rc);
 			goto err_out;
@@ -266,39 +267,24 @@ static int bnxt_init_chip(struct bnxt *bp)
 
 		rc = bnxt_hwrm_vnic_cfg(bp, vnic);
 		if (rc) {
-			RTE_LOG(ERR, PMD, "HWRM vnic %d cfg failure rc: %x\n",
+			PMD_DRV_LOG(ERR, "HWRM vnic %d cfg failure rc: %x\n",
 				i, rc);
 			goto err_out;
 		}
 
 		rc = bnxt_set_hwrm_vnic_filters(bp, vnic);
 		if (rc) {
-			RTE_LOG(ERR, PMD,
+			PMD_DRV_LOG(ERR,
 				"HWRM vnic %d filter failure rc: %x\n",
 				i, rc);
 			goto err_out;
 		}
-		if (vnic->rss_table && vnic->hash_type) {
-			/*
-			 * Fill the RSS hash & redirection table with
-			 * ring group ids for all VNICs
-			 */
-			for (rss_idx = 0, fw_idx = 0;
-			     rss_idx < HW_HASH_INDEX_SIZE;
-			     rss_idx++, fw_idx++) {
-				if (vnic->fw_grp_ids[fw_idx] ==
-				    INVALID_HW_RING_ID)
-					fw_idx = 0;
-				vnic->rss_table[rss_idx] =
-						vnic->fw_grp_ids[fw_idx];
-			}
-			rc = bnxt_hwrm_vnic_rss_cfg(bp, vnic);
-			if (rc) {
-				RTE_LOG(ERR, PMD,
-					"HWRM vnic %d set RSS failure rc: %x\n",
-					i, rc);
-				goto err_out;
-			}
+
+		rc = bnxt_vnic_rss_configure(bp, vnic);
+		if (rc) {
+			PMD_DRV_LOG(ERR,
+				    "HWRM vnic set RSS failure rc: %x\n", rc);
+			goto err_out;
 		}
 
 		bnxt_hwrm_vnic_plcmode_cfg(bp, vnic);
@@ -310,7 +296,7 @@ static int bnxt_init_chip(struct bnxt *bp)
 	}
 	rc = bnxt_hwrm_cfa_l2_set_rx_mask(bp, &bp->vnic_info[0], 0, NULL);
 	if (rc) {
-		RTE_LOG(ERR, PMD,
+		PMD_DRV_LOG(ERR,
 			"HWRM cfa l2 rx mask failure rc: %x\n", rc);
 		goto err_out;
 	}
@@ -320,10 +306,9 @@ static int bnxt_init_chip(struct bnxt *bp)
 	     !RTE_ETH_DEV_SRIOV(bp->eth_dev).active) &&
 	    bp->eth_dev->data->dev_conf.intr_conf.rxq != 0) {
 		intr_vector = bp->eth_dev->data->nb_rx_queues;
-		RTE_LOG(INFO, PMD, "%s(): intr_vector = %d\n", __func__,
-			intr_vector);
+		PMD_DRV_LOG(DEBUG, "intr_vector = %d\n", intr_vector);
 		if (intr_vector > bp->rx_cp_nr_rings) {
-			RTE_LOG(ERR, PMD, "At most %d intr queues supported",
+			PMD_DRV_LOG(ERR, "At most %d intr queues supported",
 					bp->rx_cp_nr_rings);
 			return -ENOTSUP;
 		}
@@ -337,13 +322,13 @@ static int bnxt_init_chip(struct bnxt *bp)
 				    bp->eth_dev->data->nb_rx_queues *
 				    sizeof(int), 0);
 		if (intr_handle->intr_vec == NULL) {
-			RTE_LOG(ERR, PMD, "Failed to allocate %d rx_queues"
+			PMD_DRV_LOG(ERR, "Failed to allocate %d rx_queues"
 				" intr_vec", bp->eth_dev->data->nb_rx_queues);
 			return -ENOMEM;
 		}
-		RTE_LOG(DEBUG, PMD, "%s(): intr_handle->intr_vec = %p "
+		PMD_DRV_LOG(DEBUG, "intr_handle->intr_vec = %p "
 			"intr_handle->nb_efd = %d intr_handle->max_intr = %d\n",
-			 __func__, intr_handle->intr_vec, intr_handle->nb_efd,
+			 intr_handle->intr_vec, intr_handle->nb_efd,
 			intr_handle->max_intr);
 	}
 
@@ -359,14 +344,14 @@ static int bnxt_init_chip(struct bnxt *bp)
 
 	rc = bnxt_get_hwrm_link_config(bp, &new);
 	if (rc) {
-		RTE_LOG(ERR, PMD, "HWRM Get link config failure rc: %x\n", rc);
+		PMD_DRV_LOG(ERR, "HWRM Get link config failure rc: %x\n", rc);
 		goto err_out;
 	}
 
 	if (!bp->link_info.link_up) {
 		rc = bnxt_set_hwrm_link_config(bp, true);
 		if (rc) {
-			RTE_LOG(ERR, PMD,
+			PMD_DRV_LOG(ERR,
 				"HWRM link config failure rc: %x\n", rc);
 			goto err_out;
 		}
@@ -378,6 +363,10 @@ static int bnxt_init_chip(struct bnxt *bp)
 err_out:
 	bnxt_free_all_hwrm_resources(bp);
 
+	/* Some of the error status returned by FW may not be from errno.h */
+	if (rc > 0)
+		rc = -EIO;
+
 	return rc;
 }
 
@@ -393,7 +382,10 @@ static int bnxt_init_nic(struct bnxt *bp)
 {
 	int rc;
 
-	bnxt_init_ring_grps(bp);
+	rc = bnxt_init_ring_grps(bp);
+	if (rc)
+		return rc;
+
 	bnxt_init_vnics(bp);
 	bnxt_init_filters(bp);
 
@@ -523,6 +515,26 @@ static int bnxt_dev_configure_op(struct rte_eth_dev *eth_dev)
 	bp->tx_queues = (void *)eth_dev->data->tx_queues;
 
 	/* Inherit new configurations */
+	if (eth_dev->data->nb_rx_queues > bp->max_rx_rings ||
+	    eth_dev->data->nb_tx_queues > bp->max_tx_rings ||
+	    eth_dev->data->nb_rx_queues + eth_dev->data->nb_tx_queues + 1 >
+	    bp->max_cp_rings ||
+	    eth_dev->data->nb_rx_queues + eth_dev->data->nb_tx_queues >
+	    bp->max_stat_ctx ||
+	    (uint32_t)(eth_dev->data->nb_rx_queues + 1) > bp->max_ring_grps) {
+		PMD_DRV_LOG(ERR,
+			"Insufficient resources to support requested config\n");
+		PMD_DRV_LOG(ERR,
+			"Num Queues Requested: Tx %d, Rx %d\n",
+			eth_dev->data->nb_tx_queues,
+			eth_dev->data->nb_rx_queues);
+		PMD_DRV_LOG(ERR,
+			"Res available: TxQ %d, RxQ %d, CQ %d Stat %d, Grp %d\n",
+			bp->max_tx_rings, bp->max_rx_rings, bp->max_cp_rings,
+			bp->max_stat_ctx, bp->max_ring_grps);
+		return -ENOSPC;
+	}
+
 	bp->rx_nr_rings = eth_dev->data->nb_rx_queues;
 	bp->tx_nr_rings = eth_dev->data->nb_tx_queues;
 	bp->rx_cp_nr_rings = bp->rx_nr_rings;
@@ -540,13 +552,13 @@ static void bnxt_print_link_info(struct rte_eth_dev *eth_dev)
 	struct rte_eth_link *link = &eth_dev->data->dev_link;
 
 	if (link->link_status)
-		RTE_LOG(INFO, PMD, "Port %d Link Up - speed %u Mbps - %s\n",
+		PMD_DRV_LOG(INFO, "Port %d Link Up - speed %u Mbps - %s\n",
 			eth_dev->data->port_id,
 			(uint32_t)link->link_speed,
 			(link->link_duplex == ETH_LINK_FULL_DUPLEX) ?
 			("full-duplex") : ("half-duplex\n"));
 	else
-		RTE_LOG(INFO, PMD, "Port %d Link Down\n",
+		PMD_DRV_LOG(INFO, "Port %d Link Down\n",
 			eth_dev->data->port_id);
 }
 
@@ -563,7 +575,7 @@ static int bnxt_dev_start_op(struct rte_eth_dev *eth_dev)
 	int rc;
 
 	if (bp->rx_cp_nr_rings > RTE_ETHDEV_QUEUE_STAT_CNTRS) {
-		RTE_LOG(ERR, PMD,
+		PMD_DRV_LOG(ERR,
 			"RxQ cnt %d > CONFIG_RTE_ETHDEV_QUEUE_STAT_CNTRS %d\n",
 			bp->rx_cp_nr_rings, RTE_ETHDEV_QUEUE_STAT_CNTRS);
 	}
@@ -583,6 +595,7 @@ static int bnxt_dev_start_op(struct rte_eth_dev *eth_dev)
 	if (rc)
 		goto error;
 
+	bp->flags |= BNXT_FLAG_INIT_DONE;
 	return 0;
 
 error:
@@ -628,6 +641,7 @@ static void bnxt_dev_stop_op(struct rte_eth_dev *eth_dev)
 	}
 	bnxt_set_hwrm_link_config(bp, false);
 	bnxt_hwrm_port_clr_stats(bp);
+	bp->flags &= ~BNXT_FLAG_INIT_DONE;
 	bnxt_shutdown_nic(bp);
 	bp->dev_stopped = 1;
 }
@@ -700,25 +714,25 @@ static int bnxt_mac_addr_add_op(struct rte_eth_dev *eth_dev,
 	struct bnxt_filter_info *filter;
 
 	if (BNXT_VF(bp)) {
-		RTE_LOG(ERR, PMD, "Cannot add MAC address to a VF interface\n");
+		PMD_DRV_LOG(ERR, "Cannot add MAC address to a VF interface\n");
 		return -ENOTSUP;
 	}
 
 	if (!vnic) {
-		RTE_LOG(ERR, PMD, "VNIC not found for pool %d!\n", pool);
+		PMD_DRV_LOG(ERR, "VNIC not found for pool %d!\n", pool);
 		return -EINVAL;
 	}
 	/* Attach requested MAC address to the new l2_filter */
 	STAILQ_FOREACH(filter, &vnic->filter, next) {
 		if (filter->mac_index == index) {
-			RTE_LOG(ERR, PMD,
+			PMD_DRV_LOG(ERR,
 				"MAC addr already existed for pool %d\n", pool);
-			return -EINVAL;
+			return 0;
 		}
 	}
 	filter = bnxt_alloc_filter(bp);
 	if (!filter) {
-		RTE_LOG(ERR, PMD, "L2 filter alloc failed\n");
+		PMD_DRV_LOG(ERR, "L2 filter alloc failed\n");
 		return -ENODEV;
 	}
 	STAILQ_INSERT_TAIL(&vnic->filter, filter, next);
@@ -741,7 +755,7 @@ int bnxt_link_update_op(struct rte_eth_dev *eth_dev, int wait_to_complete)
 		if (rc) {
 			new.link_speed = ETH_LINK_SPEED_100M;
 			new.link_duplex = ETH_LINK_FULL_DUPLEX;
-			RTE_LOG(ERR, PMD,
+			PMD_DRV_LOG(ERR,
 				"Failed to retrieve link rc = 0x%x!\n", rc);
 			goto out;
 		}
@@ -832,7 +846,7 @@ static int bnxt_reta_update_op(struct rte_eth_dev *eth_dev,
 		return -EINVAL;
 
 	if (reta_size != HW_HASH_INDEX_SIZE) {
-		RTE_LOG(ERR, PMD, "The configured hash table lookup size "
+		PMD_DRV_LOG(ERR, "The configured hash table lookup size "
 			"(%d) must equal the size supported by the hardware "
 			"(%d)\n", reta_size, HW_HASH_INDEX_SIZE);
 		return -EINVAL;
@@ -864,12 +878,12 @@ static int bnxt_reta_query_op(struct rte_eth_dev *eth_dev,
 		return -EINVAL;
 
 	if (reta_size != HW_HASH_INDEX_SIZE) {
-		RTE_LOG(ERR, PMD, "The configured hash table lookup size "
+		PMD_DRV_LOG(ERR, "The configured hash table lookup size "
 			"(%d) must equal the size supported by the hardware "
 			"(%d)\n", reta_size, HW_HASH_INDEX_SIZE);
 		return -EINVAL;
 	}
-	/* EW - need to revisit here copying from u64 to u16 */
+	/* EW - need to revisit here copying from uint64_t to uint16_t */
 	memcpy(reta_conf, vnic->rss_table, reta_size);
 
 	if (rte_intr_allow_others(intr_handle)) {
@@ -895,7 +909,7 @@ static int bnxt_rss_hash_update_op(struct rte_eth_dev *eth_dev,
 	 */
 	if (dev_conf->rxmode.mq_mode & ETH_MQ_RX_RSS_FLAG) {
 		if (!rss_conf->rss_hf)
-			RTE_LOG(ERR, PMD, "Hash type NONE\n");
+			PMD_DRV_LOG(ERR, "Hash type NONE\n");
 	} else {
 		if (rss_conf->rss_hf & BNXT_ETH_RSS_SUPPORT)
 			return -EINVAL;
@@ -984,7 +998,7 @@ static int bnxt_rss_hash_conf_get_op(struct rte_eth_dev *eth_dev,
 				~HWRM_VNIC_RSS_CFG_INPUT_HASH_TYPE_UDP_IPV6;
 		}
 		if (hash_types) {
-			RTE_LOG(ERR, PMD,
+			PMD_DRV_LOG(ERR,
 				"Unknwon RSS config from firmware (%08x), RSS disabled",
 				vnic->hash_type);
 			return -ENOTSUP;
@@ -1032,8 +1046,8 @@ static int bnxt_flow_ctrl_set_op(struct rte_eth_dev *dev,
 {
 	struct bnxt *bp = (struct bnxt *)dev->data->dev_private;
 
-	if (BNXT_NPAR_PF(bp) || BNXT_VF(bp)) {
-		RTE_LOG(ERR, PMD, "Flow Control Settings cannot be modified\n");
+	if (!BNXT_SINGLE_PF(bp) || BNXT_VF(bp)) {
+		PMD_DRV_LOG(ERR, "Flow Control Settings cannot be modified\n");
 		return -ENOTSUP;
 	}
 
@@ -1093,10 +1107,10 @@ bnxt_udp_tunnel_port_add_op(struct rte_eth_dev *eth_dev,
 	switch (udp_tunnel->prot_type) {
 	case RTE_TUNNEL_TYPE_VXLAN:
 		if (bp->vxlan_port_cnt) {
-			RTE_LOG(ERR, PMD, "Tunnel Port %d already programmed\n",
+			PMD_DRV_LOG(ERR, "Tunnel Port %d already programmed\n",
 				udp_tunnel->udp_port);
 			if (bp->vxlan_port != udp_tunnel->udp_port) {
-				RTE_LOG(ERR, PMD, "Only one port allowed\n");
+				PMD_DRV_LOG(ERR, "Only one port allowed\n");
 				return -ENOSPC;
 			}
 			bp->vxlan_port_cnt++;
@@ -1108,10 +1122,10 @@ bnxt_udp_tunnel_port_add_op(struct rte_eth_dev *eth_dev,
 		break;
 	case RTE_TUNNEL_TYPE_GENEVE:
 		if (bp->geneve_port_cnt) {
-			RTE_LOG(ERR, PMD, "Tunnel Port %d already programmed\n",
+			PMD_DRV_LOG(ERR, "Tunnel Port %d already programmed\n",
 				udp_tunnel->udp_port);
 			if (bp->geneve_port != udp_tunnel->udp_port) {
-				RTE_LOG(ERR, PMD, "Only one port allowed\n");
+				PMD_DRV_LOG(ERR, "Only one port allowed\n");
 				return -ENOSPC;
 			}
 			bp->geneve_port_cnt++;
@@ -1122,7 +1136,7 @@ bnxt_udp_tunnel_port_add_op(struct rte_eth_dev *eth_dev,
 		bp->geneve_port_cnt++;
 		break;
 	default:
-		RTE_LOG(ERR, PMD, "Tunnel type is not supported\n");
+		PMD_DRV_LOG(ERR, "Tunnel type is not supported\n");
 		return -ENOTSUP;
 	}
 	rc = bnxt_hwrm_tunnel_dst_port_alloc(bp, udp_tunnel->udp_port,
@@ -1142,11 +1156,11 @@ bnxt_udp_tunnel_port_del_op(struct rte_eth_dev *eth_dev,
 	switch (udp_tunnel->prot_type) {
 	case RTE_TUNNEL_TYPE_VXLAN:
 		if (!bp->vxlan_port_cnt) {
-			RTE_LOG(ERR, PMD, "No Tunnel port configured yet\n");
+			PMD_DRV_LOG(ERR, "No Tunnel port configured yet\n");
 			return -EINVAL;
 		}
 		if (bp->vxlan_port != udp_tunnel->udp_port) {
-			RTE_LOG(ERR, PMD, "Req Port: %d. Configured port: %d\n",
+			PMD_DRV_LOG(ERR, "Req Port: %d. Configured port: %d\n",
 				udp_tunnel->udp_port, bp->vxlan_port);
 			return -EINVAL;
 		}
@@ -1159,11 +1173,11 @@ bnxt_udp_tunnel_port_del_op(struct rte_eth_dev *eth_dev,
 		break;
 	case RTE_TUNNEL_TYPE_GENEVE:
 		if (!bp->geneve_port_cnt) {
-			RTE_LOG(ERR, PMD, "No Tunnel port configured yet\n");
+			PMD_DRV_LOG(ERR, "No Tunnel port configured yet\n");
 			return -EINVAL;
 		}
 		if (bp->geneve_port != udp_tunnel->udp_port) {
-			RTE_LOG(ERR, PMD, "Req Port: %d. Configured port: %d\n",
+			PMD_DRV_LOG(ERR, "Req Port: %d. Configured port: %d\n",
 				udp_tunnel->udp_port, bp->geneve_port);
 			return -EINVAL;
 		}
@@ -1175,7 +1189,7 @@ bnxt_udp_tunnel_port_del_op(struct rte_eth_dev *eth_dev,
 		port = bp->geneve_fw_dst_port_id;
 		break;
 	default:
-		RTE_LOG(ERR, PMD, "Tunnel type is not supported\n");
+		PMD_DRV_LOG(ERR, "Tunnel type is not supported\n");
 		return -ENOTSUP;
 	}
 
@@ -1232,7 +1246,7 @@ static int bnxt_del_vlan_filter(struct bnxt *bp, uint16_t vlan_id)
 
 					new_filter = bnxt_alloc_filter(bp);
 					if (!new_filter) {
-						RTE_LOG(ERR, PMD,
+						PMD_DRV_LOG(ERR,
 							"MAC/VLAN filter alloc failed\n");
 						rc = -ENOMEM;
 						goto exit;
@@ -1250,7 +1264,7 @@ static int bnxt_del_vlan_filter(struct bnxt *bp, uint16_t vlan_id)
 							new_filter);
 					if (rc)
 						goto exit;
-					RTE_LOG(INFO, PMD,
+					PMD_DRV_LOG(INFO,
 						"Del Vlan filter for %d\n",
 						vlan_id);
 				}
@@ -1305,7 +1319,7 @@ static int bnxt_add_vlan_filter(struct bnxt *bp, uint16_t vlan_id)
 				}
 				new_filter = bnxt_alloc_filter(bp);
 				if (!new_filter) {
-					RTE_LOG(ERR, PMD,
+					PMD_DRV_LOG(ERR,
 						"MAC/VLAN filter alloc failed\n");
 					rc = -ENOMEM;
 					goto exit;
@@ -1325,7 +1339,7 @@ static int bnxt_add_vlan_filter(struct bnxt *bp, uint16_t vlan_id)
 							     new_filter);
 				if (rc)
 					goto exit;
-				RTE_LOG(INFO, PMD,
+				PMD_DRV_LOG(INFO,
 					"Added Vlan filter for %d\n", vlan_id);
 cont:
 				filter = temp_filter;
@@ -1360,7 +1374,7 @@ bnxt_vlan_offload_set_op(struct rte_eth_dev *dev, int mask)
 			for (i = 0; i < 4095; i++)
 				bnxt_del_vlan_filter(bp, i);
 		}
-		RTE_LOG(INFO, PMD, "VLAN Filtering: %d\n",
+		PMD_DRV_LOG(DEBUG, "VLAN Filtering: %d\n",
 			dev->data->dev_conf.rxmode.hw_vlan_filter);
 	}
 
@@ -1374,12 +1388,12 @@ bnxt_vlan_offload_set_op(struct rte_eth_dev *dev, int mask)
 				vnic->vlan_strip = false;
 			bnxt_hwrm_vnic_cfg(bp, vnic);
 		}
-		RTE_LOG(INFO, PMD, "VLAN Strip Offload: %d\n",
+		PMD_DRV_LOG(DEBUG, "VLAN Strip Offload: %d\n",
 			dev->data->dev_conf.rxmode.hw_vlan_strip);
 	}
 
 	if (mask & ETH_VLAN_EXTEND_MASK)
-		RTE_LOG(ERR, PMD, "Extend VLAN Not supported\n");
+		PMD_DRV_LOG(ERR, "Extend VLAN Not supported\n");
 
 	return 0;
 }
@@ -1397,7 +1411,6 @@ bnxt_set_default_mac_addr_op(struct rte_eth_dev *dev, struct ether_addr *addr)
 		return;
 
 	memcpy(bp->mac_addr, addr, sizeof(bp->mac_addr));
-	memcpy(&dev->data->mac_addrs[0], bp->mac_addr, ETHER_ADDR_LEN);
 
 	STAILQ_FOREACH(filter, &vnic->filter, next) {
 		/* Default Filter is at Index 0 */
@@ -1416,7 +1429,7 @@ bnxt_set_default_mac_addr_op(struct rte_eth_dev *dev, struct ether_addr *addr)
 		if (rc)
 			break;
 		filter->mac_index = 0;
-		RTE_LOG(DEBUG, PMD, "Set MAC addr\n");
+		PMD_DRV_LOG(DEBUG, "Set MAC addr\n");
 	}
 }
 
@@ -1519,7 +1532,7 @@ static int bnxt_mtu_set_op(struct rte_eth_dev *eth_dev, uint16_t new_mtu)
 		      ETHER_HDR_LEN - ETHER_CRC_LEN - VLAN_TAG_SIZE * 2;
 
 	if (new_mtu < ETHER_MIN_MTU || new_mtu > max_dev_mtu) {
-		RTE_LOG(ERR, PMD, "MTU requested must be within (%d, %d)\n",
+		PMD_DRV_LOG(ERR, "MTU requested must be within (%d, %d)\n",
 			ETHER_MIN_MTU, max_dev_mtu);
 		return -EINVAL;
 	}
@@ -1537,7 +1550,7 @@ static int bnxt_mtu_set_op(struct rte_eth_dev *eth_dev, uint16_t new_mtu)
 		new_mtu + ETHER_HDR_LEN + ETHER_CRC_LEN + VLAN_TAG_SIZE * 2;
 
 	eth_dev->data->mtu = new_mtu;
-	RTE_LOG(INFO, PMD, "New MTU is %d\n", eth_dev->data->mtu);
+	PMD_DRV_LOG(INFO, "New MTU is %d\n", eth_dev->data->mtu);
 
 	for (i = 0; i < bp->nr_vnics; i++) {
 		struct bnxt_vnic_info *vnic = &bp->vnic_info[i];
@@ -1563,8 +1576,8 @@ bnxt_vlan_pvid_set_op(struct rte_eth_dev *dev, uint16_t pvid, int on)
 	uint16_t vlan = bp->vlan;
 	int rc;
 
-	if (BNXT_NPAR_PF(bp) || BNXT_VF(bp)) {
-		RTE_LOG(ERR, PMD,
+	if (!BNXT_SINGLE_PF(bp) || BNXT_VF(bp)) {
+		PMD_DRV_LOG(ERR,
 			"PVID cannot be modified for this function\n");
 		return -ENOTSUP;
 	}
@@ -1723,15 +1736,15 @@ bnxt_match_and_validate_ether_filter(struct bnxt *bp,
 	int match = 0;
 	*ret = 0;
 
-	if (efilter->ether_type != ETHER_TYPE_IPv4 &&
-		efilter->ether_type != ETHER_TYPE_IPv6) {
-		RTE_LOG(ERR, PMD, "unsupported ether_type(0x%04x) in"
+	if (efilter->ether_type == ETHER_TYPE_IPv4 ||
+		efilter->ether_type == ETHER_TYPE_IPv6) {
+		PMD_DRV_LOG(ERR, "invalid ether_type(0x%04x) in"
 			" ethertype filter.", efilter->ether_type);
 		*ret = -EINVAL;
 		goto exit;
 	}
 	if (efilter->queue >= bp->rx_nr_rings) {
-		RTE_LOG(ERR, PMD, "Invalid queue %d\n", efilter->queue);
+		PMD_DRV_LOG(ERR, "Invalid queue %d\n", efilter->queue);
 		*ret = -EINVAL;
 		goto exit;
 	}
@@ -1739,7 +1752,7 @@ bnxt_match_and_validate_ether_filter(struct bnxt *bp,
 	vnic0 = STAILQ_FIRST(&bp->ff_pool[0]);
 	vnic = STAILQ_FIRST(&bp->ff_pool[efilter->queue]);
 	if (vnic == NULL) {
-		RTE_LOG(ERR, PMD, "Invalid queue %d\n", efilter->queue);
+		PMD_DRV_LOG(ERR, "Invalid queue %d\n", efilter->queue);
 		*ret = -EINVAL;
 		goto exit;
 	}
@@ -1790,7 +1803,7 @@ bnxt_ethertype_filter(struct rte_eth_dev *dev,
 		return 0;
 
 	if (arg == NULL) {
-		RTE_LOG(ERR, PMD, "arg shouldn't be NULL for operation %u.",
+		PMD_DRV_LOG(ERR, "arg shouldn't be NULL for operation %u.",
 			    filter_op);
 		return -EINVAL;
 	}
@@ -1807,7 +1820,7 @@ bnxt_ethertype_filter(struct rte_eth_dev *dev,
 
 		bfilter = bnxt_get_unused_filter(bp);
 		if (bfilter == NULL) {
-			RTE_LOG(ERR, PMD,
+			PMD_DRV_LOG(ERR,
 				"Not enough resources for a new filter.\n");
 			return -ENOMEM;
 		}
@@ -1851,11 +1864,11 @@ bnxt_ethertype_filter(struct rte_eth_dev *dev,
 				      next);
 			bnxt_free_filter(bp, filter1);
 		} else if (ret == 0) {
-			RTE_LOG(ERR, PMD, "No matching filter found\n");
+			PMD_DRV_LOG(ERR, "No matching filter found\n");
 		}
 		break;
 	default:
-		RTE_LOG(ERR, PMD, "unsupported operation %u.", filter_op);
+		PMD_DRV_LOG(ERR, "unsupported operation %u.", filter_op);
 		ret = -EINVAL;
 		goto error;
 	}
@@ -1874,7 +1887,7 @@ parse_ntuple_filter(struct bnxt *bp,
 	uint32_t en = 0;
 
 	if (nfilter->queue >= bp->rx_nr_rings) {
-		RTE_LOG(ERR, PMD, "Invalid queue %d\n", nfilter->queue);
+		PMD_DRV_LOG(ERR, "Invalid queue %d\n", nfilter->queue);
 		return -EINVAL;
 	}
 
@@ -1886,7 +1899,7 @@ parse_ntuple_filter(struct bnxt *bp,
 			NTUPLE_FLTR_ALLOC_INPUT_EN_DST_PORT_MASK;
 		break;
 	default:
-		RTE_LOG(ERR, PMD, "invalid dst_port mask.");
+		PMD_DRV_LOG(ERR, "invalid dst_port mask.");
 		return -EINVAL;
 	}
 
@@ -1904,7 +1917,7 @@ parse_ntuple_filter(struct bnxt *bp,
 		en |= NTUPLE_FLTR_ALLOC_IN_EN_IP_PROTO;
 		break;
 	default:
-		RTE_LOG(ERR, PMD, "invalid protocol mask.");
+		PMD_DRV_LOG(ERR, "invalid protocol mask.");
 		return -EINVAL;
 	}
 
@@ -1916,7 +1929,7 @@ parse_ntuple_filter(struct bnxt *bp,
 			NTUPLE_FLTR_ALLOC_INPUT_EN_DST_IPADDR_MASK;
 		break;
 	default:
-		RTE_LOG(ERR, PMD, "invalid dst_ip mask.");
+		PMD_DRV_LOG(ERR, "invalid dst_ip mask.");
 		return -EINVAL;
 	}
 
@@ -1928,7 +1941,7 @@ parse_ntuple_filter(struct bnxt *bp,
 			NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_IPADDR_MASK;
 		break;
 	default:
-		RTE_LOG(ERR, PMD, "invalid src_ip mask.");
+		PMD_DRV_LOG(ERR, "invalid src_ip mask.");
 		return -EINVAL;
 	}
 
@@ -1940,7 +1953,7 @@ parse_ntuple_filter(struct bnxt *bp,
 			NTUPLE_FLTR_ALLOC_INPUT_EN_SRC_PORT_MASK;
 		break;
 	default:
-		RTE_LOG(ERR, PMD, "invalid src_port mask.");
+		PMD_DRV_LOG(ERR, "invalid src_port mask.");
 		return -EINVAL;
 	}
 
@@ -1953,7 +1966,8 @@ parse_ntuple_filter(struct bnxt *bp,
 
 static struct bnxt_filter_info*
 bnxt_match_ntuple_filter(struct bnxt *bp,
-			 struct bnxt_filter_info *bfilter)
+			 struct bnxt_filter_info *bfilter,
+			 struct bnxt_vnic_info **mvnic)
 {
 	struct bnxt_filter_info *mfilter = NULL;
 	int i;
@@ -1972,8 +1986,11 @@ bnxt_match_ntuple_filter(struct bnxt *bp,
 			    bfilter->dst_port == mfilter->dst_port &&
 			    bfilter->dst_port_mask == mfilter->dst_port_mask &&
 			    bfilter->flags == mfilter->flags &&
-			    bfilter->enables == mfilter->enables)
+			    bfilter->enables == mfilter->enables) {
+				if (mvnic)
+					*mvnic = vnic;
 				return mfilter;
+			}
 		}
 	}
 	return NULL;
@@ -1985,22 +2002,22 @@ bnxt_cfg_ntuple_filter(struct bnxt *bp,
 		       enum rte_filter_op filter_op)
 {
 	struct bnxt_filter_info *bfilter, *mfilter, *filter1;
-	struct bnxt_vnic_info *vnic, *vnic0;
+	struct bnxt_vnic_info *vnic, *vnic0, *mvnic;
 	int ret;
 
 	if (nfilter->flags != RTE_5TUPLE_FLAGS) {
-		RTE_LOG(ERR, PMD, "only 5tuple is supported.");
+		PMD_DRV_LOG(ERR, "only 5tuple is supported.");
 		return -EINVAL;
 	}
 
 	if (nfilter->flags & RTE_NTUPLE_FLAGS_TCP_FLAG) {
-		RTE_LOG(ERR, PMD, "Ntuple filter: TCP flags not supported\n");
+		PMD_DRV_LOG(ERR, "Ntuple filter: TCP flags not supported\n");
 		return -EINVAL;
 	}
 
 	bfilter = bnxt_get_unused_filter(bp);
 	if (bfilter == NULL) {
-		RTE_LOG(ERR, PMD,
+		PMD_DRV_LOG(ERR,
 			"Not enough resources for a new filter.\n");
 		return -ENOMEM;
 	}
@@ -2023,15 +2040,25 @@ bnxt_cfg_ntuple_filter(struct bnxt *bp,
 	bfilter->ethertype = 0x800;
 	bfilter->enables |= NTUPLE_FLTR_ALLOC_INPUT_EN_ETHERTYPE;
 
-	mfilter = bnxt_match_ntuple_filter(bp, bfilter);
+	mfilter = bnxt_match_ntuple_filter(bp, bfilter, &mvnic);
 
-	if (mfilter != NULL && filter_op == RTE_ETH_FILTER_ADD) {
-		RTE_LOG(ERR, PMD, "filter exists.");
+	if (mfilter != NULL && filter_op == RTE_ETH_FILTER_ADD &&
+	    bfilter->dst_id == mfilter->dst_id) {
+		PMD_DRV_LOG(ERR, "filter exists.\n");
 		ret = -EEXIST;
 		goto free_filter;
+	} else if (mfilter != NULL && filter_op == RTE_ETH_FILTER_ADD &&
+		   bfilter->dst_id != mfilter->dst_id) {
+		mfilter->dst_id = vnic->fw_vnic_id;
+		ret = bnxt_hwrm_set_ntuple_filter(bp, mfilter->dst_id, mfilter);
+		STAILQ_REMOVE(&mvnic->filter, mfilter, bnxt_filter_info, next);
+		STAILQ_INSERT_TAIL(&vnic->filter, mfilter, next);
+		PMD_DRV_LOG(ERR, "filter with matching pattern exists.\n");
+		PMD_DRV_LOG(ERR, " Updated it to the new destination queue\n");
+		goto free_filter;
 	}
 	if (mfilter == NULL && filter_op == RTE_ETH_FILTER_DELETE) {
-		RTE_LOG(ERR, PMD, "filter doesn't exist.");
+		PMD_DRV_LOG(ERR, "filter doesn't exist.");
 		ret = -ENOENT;
 		goto free_filter;
 	}
@@ -2050,11 +2077,11 @@ bnxt_cfg_ntuple_filter(struct bnxt *bp,
 		}
 		ret = bnxt_hwrm_clear_ntuple_filter(bp, mfilter);
 
-		STAILQ_REMOVE(&vnic->filter, mfilter, bnxt_filter_info,
-			      next);
+		STAILQ_REMOVE(&vnic->filter, mfilter, bnxt_filter_info, next);
 		bnxt_free_filter(bp, mfilter);
-		bfilter->fw_l2_filter_id = -1;
+		mfilter->fw_l2_filter_id = -1;
 		bnxt_free_filter(bp, bfilter);
+		bfilter->fw_l2_filter_id = -1;
 	}
 
 	return 0;
@@ -2076,7 +2103,7 @@ bnxt_ntuple_filter(struct rte_eth_dev *dev,
 		return 0;
 
 	if (arg == NULL) {
-		RTE_LOG(ERR, PMD, "arg shouldn't be NULL for operation %u.",
+		PMD_DRV_LOG(ERR, "arg shouldn't be NULL for operation %u.",
 			    filter_op);
 		return -EINVAL;
 	}
@@ -2093,7 +2120,7 @@ bnxt_ntuple_filter(struct rte_eth_dev *dev,
 			filter_op);
 		break;
 	default:
-		RTE_LOG(ERR, PMD, "unsupported operation %u.", filter_op);
+		PMD_DRV_LOG(ERR, "unsupported operation %u.", filter_op);
 		ret = -EINVAL;
 		break;
 	}
@@ -2295,7 +2322,7 @@ bnxt_parse_fdir_filter(struct bnxt *bp,
 	vnic0 = STAILQ_FIRST(&bp->ff_pool[0]);
 	vnic = STAILQ_FIRST(&bp->ff_pool[fdir->action.rx_queue]);
 	if (vnic == NULL) {
-		RTE_LOG(ERR, PMD, "Invalid queue %d\n", fdir->action.rx_queue);
+		PMD_DRV_LOG(ERR, "Invalid queue %d\n", fdir->action.rx_queue);
 		return -EINVAL;
 	}
 
@@ -2399,7 +2426,7 @@ bnxt_fdir_filter(struct rte_eth_dev *dev,
 		/* FALLTHROUGH */
 		filter = bnxt_get_unused_filter(bp);
 		if (filter == NULL) {
-			RTE_LOG(ERR, PMD,
+			PMD_DRV_LOG(ERR,
 				"Not enough resources for a new flow.\n");
 			return -ENOMEM;
 		}
@@ -2411,12 +2438,12 @@ bnxt_fdir_filter(struct rte_eth_dev *dev,
 
 		match = bnxt_match_fdir(bp, filter);
 		if (match != NULL && filter_op == RTE_ETH_FILTER_ADD) {
-			RTE_LOG(ERR, PMD, "Flow already exists.\n");
+			PMD_DRV_LOG(ERR, "Flow already exists.\n");
 			ret = -EEXIST;
 			goto free_filter;
 		}
 		if (match == NULL && filter_op == RTE_ETH_FILTER_DELETE) {
-			RTE_LOG(ERR, PMD, "Flow does not exist.\n");
+			PMD_DRV_LOG(ERR, "Flow does not exist.\n");
 			ret = -ENOENT;
 			goto free_filter;
 		}
@@ -2463,10 +2490,10 @@ bnxt_fdir_filter(struct rte_eth_dev *dev,
 	case RTE_ETH_FILTER_STATS:
 	case RTE_ETH_FILTER_INFO:
 		/* FALLTHROUGH */
-		RTE_LOG(ERR, PMD, "operation %u not implemented", filter_op);
+		PMD_DRV_LOG(ERR, "operation %u not implemented", filter_op);
 		break;
 	default:
-		RTE_LOG(ERR, PMD, "unknown operation %u", filter_op);
+		PMD_DRV_LOG(ERR, "unknown operation %u", filter_op);
 		ret = -EINVAL;
 		break;
 	}
@@ -2487,7 +2514,7 @@ bnxt_filter_ctrl_op(struct rte_eth_dev *dev __rte_unused,
 
 	switch (filter_type) {
 	case RTE_ETH_FILTER_TUNNEL:
-		RTE_LOG(ERR, PMD,
+		PMD_DRV_LOG(ERR,
 			"filter type: %d: To be implemented\n", filter_type);
 		break;
 	case RTE_ETH_FILTER_FDIR:
@@ -2505,7 +2532,7 @@ bnxt_filter_ctrl_op(struct rte_eth_dev *dev __rte_unused,
 		*(const void **)arg = &bnxt_flow_ops;
 		break;
 	default:
-		RTE_LOG(ERR, PMD,
+		PMD_DRV_LOG(ERR,
 			"Filter type (%d) not supported", filter_type);
 		ret = -EINVAL;
 		break;
@@ -2536,7 +2563,260 @@ bnxt_dev_supported_ptypes_get_op(struct rte_eth_dev *dev)
 	return NULL;
 }
 
+static int bnxt_map_regs(struct bnxt *bp, uint32_t *reg_arr, int count,
+			 int reg_win)
+{
+	uint32_t reg_base = *reg_arr & 0xfffff000;
+	uint32_t win_off;
+	int i;
+
+	for (i = 0; i < count; i++) {
+		if ((reg_arr[i] & 0xfffff000) != reg_base)
+			return -ERANGE;
+	}
+	win_off = BNXT_GRCPF_REG_WINDOW_BASE_OUT + (reg_win - 1) * 4;
+	rte_cpu_to_le_32(rte_write32(reg_base, (uint8_t *)bp->bar0 + win_off));
+	return 0;
+}
+
+static int bnxt_map_ptp_regs(struct bnxt *bp)
+{
+	struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
+	uint32_t *reg_arr;
+	int rc, i;
+
+	reg_arr = ptp->rx_regs;
+	rc = bnxt_map_regs(bp, reg_arr, BNXT_PTP_RX_REGS, 5);
+	if (rc)
+		return rc;
+
+	reg_arr = ptp->tx_regs;
+	rc = bnxt_map_regs(bp, reg_arr, BNXT_PTP_TX_REGS, 6);
+	if (rc)
+		return rc;
+
+	for (i = 0; i < BNXT_PTP_RX_REGS; i++)
+		ptp->rx_mapped_regs[i] = 0x5000 + (ptp->rx_regs[i] & 0xfff);
+
+	for (i = 0; i < BNXT_PTP_TX_REGS; i++)
+		ptp->tx_mapped_regs[i] = 0x6000 + (ptp->tx_regs[i] & 0xfff);
 
+	return 0;
+}
+
+static void bnxt_unmap_ptp_regs(struct bnxt *bp)
+{
+	rte_cpu_to_le_32(rte_write32(0, (uint8_t *)bp->bar0 +
+			 BNXT_GRCPF_REG_WINDOW_BASE_OUT + 16));
+	rte_cpu_to_le_32(rte_write32(0, (uint8_t *)bp->bar0 +
+			 BNXT_GRCPF_REG_WINDOW_BASE_OUT + 20));
+}
+
+static uint64_t bnxt_cc_read(struct bnxt *bp)
+{
+	uint64_t ns;
+
+	ns = rte_le_to_cpu_32(rte_read32((uint8_t *)bp->bar0 +
+			      BNXT_GRCPF_REG_SYNC_TIME));
+	ns |= (uint64_t)(rte_le_to_cpu_32(rte_read32((uint8_t *)bp->bar0 +
+					  BNXT_GRCPF_REG_SYNC_TIME + 4))) << 32;
+	return ns;
+}
+
+static int bnxt_get_tx_ts(struct bnxt *bp, uint64_t *ts)
+{
+	struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
+	uint32_t fifo;
+
+	fifo = rte_le_to_cpu_32(rte_read32((uint8_t *)bp->bar0 +
+				ptp->tx_mapped_regs[BNXT_PTP_TX_FIFO]));
+	if (fifo & BNXT_PTP_TX_FIFO_EMPTY)
+		return -EAGAIN;
+
+	fifo = rte_le_to_cpu_32(rte_read32((uint8_t *)bp->bar0 +
+				ptp->tx_mapped_regs[BNXT_PTP_TX_FIFO]));
+	*ts = rte_le_to_cpu_32(rte_read32((uint8_t *)bp->bar0 +
+				ptp->tx_mapped_regs[BNXT_PTP_TX_TS_L]));
+	*ts |= (uint64_t)rte_le_to_cpu_32(rte_read32((uint8_t *)bp->bar0 +
+				ptp->tx_mapped_regs[BNXT_PTP_TX_TS_H])) << 32;
+
+	return 0;
+}
+
+static int bnxt_get_rx_ts(struct bnxt *bp, uint64_t *ts)
+{
+	struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
+	struct bnxt_pf_info *pf = &bp->pf;
+	uint16_t port_id;
+	uint32_t fifo;
+
+	if (!ptp)
+		return -ENODEV;
+
+	fifo = rte_le_to_cpu_32(rte_read32((uint8_t *)bp->bar0 +
+				ptp->rx_mapped_regs[BNXT_PTP_RX_FIFO]));
+	if (!(fifo & BNXT_PTP_RX_FIFO_PENDING))
+		return -EAGAIN;
+
+	port_id = pf->port_id;
+	rte_cpu_to_le_32(rte_write32(1 << port_id, (uint8_t *)bp->bar0 +
+	       ptp->rx_mapped_regs[BNXT_PTP_RX_FIFO_ADV]));
+
+	fifo = rte_le_to_cpu_32(rte_read32((uint8_t *)bp->bar0 +
+				   ptp->rx_mapped_regs[BNXT_PTP_RX_FIFO]));
+	if (fifo & BNXT_PTP_RX_FIFO_PENDING) {
+/*		bnxt_clr_rx_ts(bp);	  TBD  */
+		return -EBUSY;
+	}
+
+	*ts = rte_le_to_cpu_32(rte_read32((uint8_t *)bp->bar0 +
+				ptp->rx_mapped_regs[BNXT_PTP_RX_TS_L]));
+	*ts |= (uint64_t)rte_le_to_cpu_32(rte_read32((uint8_t *)bp->bar0 +
+				ptp->rx_mapped_regs[BNXT_PTP_RX_TS_H])) << 32;
+
+	return 0;
+}
+
+static int
+bnxt_timesync_write_time(struct rte_eth_dev *dev, const struct timespec *ts)
+{
+	uint64_t ns;
+	struct bnxt *bp = (struct bnxt *)dev->data->dev_private;
+	struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
+
+	if (!ptp)
+		return 0;
+
+	ns = rte_timespec_to_ns(ts);
+	/* Set the timecounters to a new value. */
+	ptp->tc.nsec = ns;
+
+	return 0;
+}
+
+static int
+bnxt_timesync_read_time(struct rte_eth_dev *dev, struct timespec *ts)
+{
+	uint64_t ns, systime_cycles;
+	struct bnxt *bp = (struct bnxt *)dev->data->dev_private;
+	struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
+
+	if (!ptp)
+		return 0;
+
+	systime_cycles = bnxt_cc_read(bp);
+	ns = rte_timecounter_update(&ptp->tc, systime_cycles);
+	*ts = rte_ns_to_timespec(ns);
+
+	return 0;
+}
+static int
+bnxt_timesync_enable(struct rte_eth_dev *dev)
+{
+	struct bnxt *bp = (struct bnxt *)dev->data->dev_private;
+	struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
+	uint32_t shift = 0;
+
+	if (!ptp)
+		return 0;
+
+	ptp->rx_filter = 1;
+	ptp->tx_tstamp_en = 1;
+	ptp->rxctl = BNXT_PTP_MSG_EVENTS;
+
+	if (!bnxt_hwrm_ptp_cfg(bp))
+		bnxt_map_ptp_regs(bp);
+
+	memset(&ptp->tc, 0, sizeof(struct rte_timecounter));
+	memset(&ptp->rx_tstamp_tc, 0, sizeof(struct rte_timecounter));
+	memset(&ptp->tx_tstamp_tc, 0, sizeof(struct rte_timecounter));
+
+	ptp->tc.cc_mask = BNXT_CYCLECOUNTER_MASK;
+	ptp->tc.cc_shift = shift;
+	ptp->tc.nsec_mask = (1ULL << shift) - 1;
+
+	ptp->rx_tstamp_tc.cc_mask = BNXT_CYCLECOUNTER_MASK;
+	ptp->rx_tstamp_tc.cc_shift = shift;
+	ptp->rx_tstamp_tc.nsec_mask = (1ULL << shift) - 1;
+
+	ptp->tx_tstamp_tc.cc_mask = BNXT_CYCLECOUNTER_MASK;
+	ptp->tx_tstamp_tc.cc_shift = shift;
+	ptp->tx_tstamp_tc.nsec_mask = (1ULL << shift) - 1;
+
+	return 0;
+}
+
+static int
+bnxt_timesync_disable(struct rte_eth_dev *dev)
+{
+	struct bnxt *bp = (struct bnxt *)dev->data->dev_private;
+	struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
+
+	if (!ptp)
+		return 0;
+
+	ptp->rx_filter = 0;
+	ptp->tx_tstamp_en = 0;
+	ptp->rxctl = 0;
+
+	bnxt_hwrm_ptp_cfg(bp);
+
+	bnxt_unmap_ptp_regs(bp);
+
+	return 0;
+}
+
+static int
+bnxt_timesync_read_rx_timestamp(struct rte_eth_dev *dev,
+				 struct timespec *timestamp,
+				 uint32_t flags __rte_unused)
+{
+	struct bnxt *bp = (struct bnxt *)dev->data->dev_private;
+	struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
+	uint64_t rx_tstamp_cycles = 0;
+	uint64_t ns;
+
+	if (!ptp)
+		return 0;
+
+	bnxt_get_rx_ts(bp, &rx_tstamp_cycles);
+	ns = rte_timecounter_update(&ptp->rx_tstamp_tc, rx_tstamp_cycles);
+	*timestamp = rte_ns_to_timespec(ns);
+	return  0;
+}
+
+static int
+bnxt_timesync_read_tx_timestamp(struct rte_eth_dev *dev,
+				 struct timespec *timestamp)
+{
+	struct bnxt *bp = (struct bnxt *)dev->data->dev_private;
+	struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
+	uint64_t tx_tstamp_cycles = 0;
+	uint64_t ns;
+
+	if (!ptp)
+		return 0;
+
+	bnxt_get_tx_ts(bp, &tx_tstamp_cycles);
+	ns = rte_timecounter_update(&ptp->tx_tstamp_tc, tx_tstamp_cycles);
+	*timestamp = rte_ns_to_timespec(ns);
+
+	return 0;
+}
+
+static int
+bnxt_timesync_adjust_time(struct rte_eth_dev *dev, int64_t delta)
+{
+	struct bnxt *bp = (struct bnxt *)dev->data->dev_private;
+	struct bnxt_ptp_cfg *ptp = bp->ptp_cfg;
+
+	if (!ptp)
+		return 0;
+
+	ptp->tc.nsec += delta;
+
+	return 0;
+}
 
 static int
 bnxt_get_eeprom_length_op(struct rte_eth_dev *dev)
@@ -2546,8 +2826,8 @@ bnxt_get_eeprom_length_op(struct rte_eth_dev *dev)
 	uint32_t dir_entries;
 	uint32_t entry_length;
 
-	RTE_LOG(INFO, PMD, "%s(): %04x:%02x:%02x:%02x\n",
-		__func__, bp->pdev->addr.domain, bp->pdev->addr.bus,
+	PMD_DRV_LOG(INFO, "%04x:%02x:%02x:%02x\n",
+		bp->pdev->addr.domain, bp->pdev->addr.bus,
 		bp->pdev->addr.devid, bp->pdev->addr.function);
 
 	rc = bnxt_hwrm_nvm_get_dir_info(bp, &dir_entries, &entry_length);
@@ -2565,8 +2845,8 @@ bnxt_get_eeprom_op(struct rte_eth_dev *dev,
 	uint32_t index;
 	uint32_t offset;
 
-	RTE_LOG(INFO, PMD, "%s(): %04x:%02x:%02x:%02x in_eeprom->offset = %d "
-		"len = %d\n", __func__, bp->pdev->addr.domain,
+	PMD_DRV_LOG(INFO, "%04x:%02x:%02x:%02x in_eeprom->offset = %d "
+		"len = %d\n", bp->pdev->addr.domain,
 		bp->pdev->addr.bus, bp->pdev->addr.devid,
 		bp->pdev->addr.function, in_eeprom->offset, in_eeprom->length);
 
@@ -2634,13 +2914,13 @@ bnxt_set_eeprom_op(struct rte_eth_dev *dev,
 	uint8_t index, dir_op;
 	uint16_t type, ext, ordinal, attr;
 
-	RTE_LOG(INFO, PMD, "%s(): %04x:%02x:%02x:%02x in_eeprom->offset = %d "
-		"len = %d\n", __func__, bp->pdev->addr.domain,
+	PMD_DRV_LOG(INFO, "%04x:%02x:%02x:%02x in_eeprom->offset = %d "
+		"len = %d\n", bp->pdev->addr.domain,
 		bp->pdev->addr.bus, bp->pdev->addr.devid,
 		bp->pdev->addr.function, in_eeprom->offset, in_eeprom->length);
 
 	if (!BNXT_PF(bp)) {
-		RTE_LOG(ERR, PMD, "NVM write not supported from a VF\n");
+		PMD_DRV_LOG(ERR, "NVM write not supported from a VF\n");
 		return -EINVAL;
 	}
 
@@ -2727,11 +3007,22 @@ static const struct eth_dev_ops bnxt_dev_ops = {
 	.rx_queue_count = bnxt_rx_queue_count_op,
 	.rx_descriptor_status = bnxt_rx_descriptor_status_op,
 	.tx_descriptor_status = bnxt_tx_descriptor_status_op,
+	.rx_queue_start = bnxt_rx_queue_start,
+	.rx_queue_stop = bnxt_rx_queue_stop,
+	.tx_queue_start = bnxt_tx_queue_start,
+	.tx_queue_stop = bnxt_tx_queue_stop,
 	.filter_ctrl = bnxt_filter_ctrl_op,
 	.dev_supported_ptypes_get = bnxt_dev_supported_ptypes_get_op,
 	.get_eeprom_length    = bnxt_get_eeprom_length_op,
 	.get_eeprom           = bnxt_get_eeprom_op,
 	.set_eeprom           = bnxt_set_eeprom_op,
+	.timesync_enable      = bnxt_timesync_enable,
+	.timesync_disable     = bnxt_timesync_disable,
+	.timesync_read_time   = bnxt_timesync_read_time,
+	.timesync_write_time   = bnxt_timesync_write_time,
+	.timesync_adjust_time = bnxt_timesync_adjust_time,
+	.timesync_read_rx_timestamp = bnxt_timesync_read_rx_timestamp,
+	.timesync_read_tx_timestamp = bnxt_timesync_read_tx_timestamp,
 };
 
 static bool bnxt_vf_pciid(uint16_t id)
@@ -2754,7 +3045,7 @@ static int bnxt_init_board(struct rte_eth_dev *eth_dev)
 
 	/* enable device (incl. PCI PM wakeup), and bus-mastering */
 	if (!pci_dev->mem_resource[0].addr) {
-		RTE_LOG(ERR, PMD,
+		PMD_DRV_LOG(ERR,
 			"Cannot find PCI device base address, aborting\n");
 		rc = -ENODEV;
 		goto init_err_disable;
@@ -2765,7 +3056,7 @@ static int bnxt_init_board(struct rte_eth_dev *eth_dev)
 
 	bp->bar0 = (void *)pci_dev->mem_resource[0].addr;
 	if (!bp->bar0) {
-		RTE_LOG(ERR, PMD, "Cannot map device registers, aborting\n");
+		PMD_DRV_LOG(ERR, "Cannot map device registers, aborting\n");
 		rc = -ENOMEM;
 		goto init_err_release;
 	}
@@ -2801,7 +3092,7 @@ bnxt_dev_init(struct rte_eth_dev *eth_dev)
 	int rc;
 
 	if (version_printed++ == 0)
-		RTE_LOG(INFO, PMD, "%s\n", bnxt_version);
+		PMD_DRV_LOG(INFO, "%s\n", bnxt_version);
 
 	rte_eth_copy_pci_info(eth_dev, pci_dev);
 
@@ -2818,7 +3109,7 @@ bnxt_dev_init(struct rte_eth_dev *eth_dev)
 
 	rc = bnxt_init_board(eth_dev);
 	if (rc) {
-		RTE_LOG(ERR, PMD,
+		PMD_DRV_LOG(ERR,
 			"Board initialization failed rc: %x\n", rc);
 		goto error;
 	}
@@ -2849,13 +3140,13 @@ skip_init:
 		memset(mz->addr, 0, mz->len);
 		mz_phys_addr = mz->iova;
 		if ((unsigned long)mz->addr == mz_phys_addr) {
-			RTE_LOG(WARNING, PMD,
+			PMD_DRV_LOG(WARNING,
 				"Memzone physical address same as virtual.\n");
-			RTE_LOG(WARNING, PMD,
+			PMD_DRV_LOG(WARNING,
 				"Using rte_mem_virt2iova()\n");
 			mz_phys_addr = rte_mem_virt2iova(mz->addr);
 			if (mz_phys_addr == 0) {
-				RTE_LOG(ERR, PMD,
+				PMD_DRV_LOG(ERR,
 				"unable to map address to physical memory\n");
 				return -ENOMEM;
 			}
@@ -2884,13 +3175,13 @@ skip_init:
 		memset(mz->addr, 0, mz->len);
 		mz_phys_addr = mz->iova;
 		if ((unsigned long)mz->addr == mz_phys_addr) {
-			RTE_LOG(WARNING, PMD,
+			PMD_DRV_LOG(WARNING,
 				"Memzone physical address same as virtual.\n");
-			RTE_LOG(WARNING, PMD,
+			PMD_DRV_LOG(WARNING,
 				"Using rte_mem_virt2iova()\n");
 			mz_phys_addr = rte_mem_virt2iova(mz->addr);
 			if (mz_phys_addr == 0) {
-				RTE_LOG(ERR, PMD,
+				PMD_DRV_LOG(ERR,
 				"unable to map address to physical memory\n");
 				return -ENOMEM;
 			}
@@ -2905,45 +3196,71 @@ skip_init:
 
 	rc = bnxt_alloc_hwrm_resources(bp);
 	if (rc) {
-		RTE_LOG(ERR, PMD,
+		PMD_DRV_LOG(ERR,
 			"hwrm resource allocation failure rc: %x\n", rc);
 		goto error_free;
 	}
 	rc = bnxt_hwrm_ver_get(bp);
 	if (rc)
 		goto error_free;
-	bnxt_hwrm_queue_qportcfg(bp);
+	rc = bnxt_hwrm_queue_qportcfg(bp);
+	if (rc) {
+		PMD_DRV_LOG(ERR, "hwrm queue qportcfg failed\n");
+		goto error_free;
+	}
 
-	bnxt_hwrm_func_qcfg(bp);
+	rc = bnxt_hwrm_func_qcfg(bp);
+	if (rc) {
+		PMD_DRV_LOG(ERR, "hwrm func qcfg failed\n");
+		goto error_free;
+	}
 
 	/* Get the MAX capabilities for this function */
 	rc = bnxt_hwrm_func_qcaps(bp);
 	if (rc) {
-		RTE_LOG(ERR, PMD, "hwrm query capability failure rc: %x\n", rc);
+		PMD_DRV_LOG(ERR, "hwrm query capability failure rc: %x\n", rc);
 		goto error_free;
 	}
 	if (bp->max_tx_rings == 0) {
-		RTE_LOG(ERR, PMD, "No TX rings available!\n");
+		PMD_DRV_LOG(ERR, "No TX rings available!\n");
 		rc = -EBUSY;
 		goto error_free;
 	}
 	eth_dev->data->mac_addrs = rte_zmalloc("bnxt_mac_addr_tbl",
 					ETHER_ADDR_LEN * bp->max_l2_ctx, 0);
 	if (eth_dev->data->mac_addrs == NULL) {
-		RTE_LOG(ERR, PMD,
+		PMD_DRV_LOG(ERR,
 			"Failed to alloc %u bytes needed to store MAC addr tbl",
 			ETHER_ADDR_LEN * bp->max_l2_ctx);
 		rc = -ENOMEM;
 		goto error_free;
 	}
+
+	if (check_zero_bytes(bp->dflt_mac_addr, ETHER_ADDR_LEN)) {
+		PMD_DRV_LOG(ERR,
+			    "Invalid MAC addr %02X:%02X:%02X:%02X:%02X:%02X\n",
+			    bp->dflt_mac_addr[0], bp->dflt_mac_addr[1],
+			    bp->dflt_mac_addr[2], bp->dflt_mac_addr[3],
+			    bp->dflt_mac_addr[4], bp->dflt_mac_addr[5]);
+		rc = -EINVAL;
+		goto error_free;
+	}
 	/* Copy the permanent MAC from the qcap response address now. */
 	memcpy(bp->mac_addr, bp->dflt_mac_addr, sizeof(bp->mac_addr));
 	memcpy(&eth_dev->data->mac_addrs[0], bp->mac_addr, ETHER_ADDR_LEN);
+
+	if (bp->max_ring_grps < bp->rx_cp_nr_rings) {
+		/* 1 ring is for default completion ring */
+		PMD_DRV_LOG(ERR, "Insufficient resource: Ring Group\n");
+		rc = -ENOSPC;
+		goto error_free;
+	}
+
 	bp->grp_info = rte_zmalloc("bnxt_grp_info",
 				sizeof(*bp->grp_info) * bp->max_ring_grps, 0);
 	if (!bp->grp_info) {
-		RTE_LOG(ERR, PMD,
-			"Failed to alloc %zu bytes needed to store group info table\n",
+		PMD_DRV_LOG(ERR,
+			"Failed to alloc %zu bytes to store group info table\n",
 			sizeof(*bp->grp_info) * bp->max_ring_grps);
 		rc = -ENOMEM;
 		goto error_free;
@@ -2955,7 +3272,7 @@ skip_init:
 	    ((bp->fw_ver >= ((20 << 24) | (8 << 16))))) {
 		memset(bp->pf.vf_req_fwd, 0xff, sizeof(bp->pf.vf_req_fwd));
 	} else {
-		RTE_LOG(WARNING, PMD,
+		PMD_DRV_LOG(WARNING,
 			"Firmware too old for VF mailbox functionality\n");
 		memset(bp->pf.vf_req_fwd, 0, sizeof(bp->pf.vf_req_fwd));
 	}
@@ -2975,21 +3292,21 @@ skip_init:
 	ALLOW_FUNC(HWRM_VNIC_TPA_CFG);
 	rc = bnxt_hwrm_func_driver_register(bp);
 	if (rc) {
-		RTE_LOG(ERR, PMD,
+		PMD_DRV_LOG(ERR,
 			"Failed to register driver");
 		rc = -EBUSY;
 		goto error_free;
 	}
 
-	RTE_LOG(INFO, PMD,
+	PMD_DRV_LOG(INFO,
 		DRV_MODULE_NAME " found at mem %" PRIx64 ", node addr %pM\n",
 		pci_dev->mem_resource[0].phys_addr,
 		pci_dev->mem_resource[0].addr);
 
 	rc = bnxt_hwrm_func_reset(bp);
 	if (rc) {
-		RTE_LOG(ERR, PMD, "hwrm chip reset failure rc: %x\n", rc);
-		rc = -1;
+		PMD_DRV_LOG(ERR, "hwrm chip reset failure rc: %x\n", rc);
+		rc = -EIO;
 		goto error_free;
 	}
 
@@ -3000,13 +3317,13 @@ skip_init:
 		if (bp->pdev->max_vfs) {
 			rc = bnxt_hwrm_allocate_vfs(bp, bp->pdev->max_vfs);
 			if (rc) {
-				RTE_LOG(ERR, PMD, "Failed to allocate VFs\n");
+				PMD_DRV_LOG(ERR, "Failed to allocate VFs\n");
 				goto error_free;
 			}
 		} else {
 			rc = bnxt_hwrm_allocate_pf_only(bp);
 			if (rc) {
-				RTE_LOG(ERR, PMD,
+				PMD_DRV_LOG(ERR,
 					"Failed to allocate PF resources\n");
 				goto error_free;
 			}
@@ -3115,6 +3432,15 @@ bool is_bnxt_supported(struct rte_eth_dev *dev)
 	return is_device_supported(dev, &bnxt_rte_pmd);
 }
 
+RTE_INIT(bnxt_init_log);
+static void
+bnxt_init_log(void)
+{
+	bnxt_logtype_driver = rte_log_register("pmd.bnxt.driver");
+	if (bnxt_logtype_driver >= 0)
+		rte_log_set_level(bnxt_logtype_driver, RTE_LOG_NOTICE);
+}
+
 RTE_PMD_REGISTER_PCI(net_bnxt, bnxt_rte_pmd);
 RTE_PMD_REGISTER_PCI_TABLE(net_bnxt, bnxt_pci_id_map);
 RTE_PMD_REGISTER_KMOD_DEP(net_bnxt, "* igb_uio | uio_pci_generic | vfio-pci");