X-Git-Url: http://git.droids-corp.org/?a=blobdiff_plain;f=drivers%2Fnet%2Fhinic%2Fhinic_pmd_ethdev.c;h=803a39e2da7beefbfcfd1f2fa6eb91bc4ea34985;hb=6e77151286b2f551ae30aac0f251ed067f1ec011;hp=c50cdd9f81ae931a294229e564c7bb1e65c425ed;hpb=9039c8125730adfd46b8c891e7f205eb4ac43c67;p=dpdk.git

diff --git a/drivers/net/hinic/hinic_pmd_ethdev.c b/drivers/net/hinic/hinic_pmd_ethdev.c
index c50cdd9f81..803a39e2da 100644
--- a/drivers/net/hinic/hinic_pmd_ethdev.c
+++ b/drivers/net/hinic/hinic_pmd_ethdev.c
@@ -10,6 +10,7 @@
 #include <rte_memcpy.h>
 #include <rte_mempool.h>
 #include <rte_errno.h>
+#include <rte_ether.h>
 
 #include "base/hinic_compat.h"
 #include "base/hinic_pmd_hwdev.h"
@@ -20,6 +21,7 @@
 #include "base/hinic_pmd_cmdq.h"
 #include "base/hinic_pmd_niccfg.h"
 #include "base/hinic_pmd_nicio.h"
+#include "base/hinic_pmd_mbox.h"
 #include "hinic_pmd_ethdev.h"
 #include "hinic_pmd_tx.h"
 #include "hinic_pmd_rx.h"
@@ -29,21 +31,54 @@
 
 /* Hinic devices */
 #define HINIC_DEV_ID_PRD		0x1822
+#define HINIC_DEV_ID_VF			0x375E
+#define HINIC_DEV_ID_VF_HV		0x379E
+
+/* Mezz card for Blade Server */
 #define HINIC_DEV_ID_MEZZ_25GE		0x0210
 #define HINIC_DEV_ID_MEZZ_40GE		0x020D
 #define HINIC_DEV_ID_MEZZ_100GE		0x0205
 
+/* 2*25G and 2*100G card */
+#define HINIC_DEV_ID_1822_DUAL_25GE	0x0206
+#define HINIC_DEV_ID_1822_100GE		0x0200
+
 #define HINIC_SERVICE_MODE_NIC		2
 
-#define HINIC_INTR_CB_UNREG_MAX_RETRIES		10
+#define HINIC_INTR_CB_UNREG_MAX_RETRIES	10
 
 #define DEFAULT_BASE_COS		4
 #define NR_MAX_COS			8
 
 #define HINIC_MIN_RX_BUF_SIZE		1024
-#define HINIC_MAX_MAC_ADDRS		1
+#define HINIC_MAX_UC_MAC_ADDRS		128
+#define HINIC_MAX_MC_MAC_ADDRS		2048
+
+#define HINIC_DEFAULT_BURST_SIZE	32
+#define HINIC_DEFAULT_NB_QUEUES		1
+#define HINIC_DEFAULT_RING_SIZE		1024
+
+/*
+ * vlan_id is a 12 bit number.
+ * The VFTA array is actually a 4096 bit array, 128 of 32bit elements.
+ * 2^5 = 32. The val of lower 5 bits specifies the bit in the 32bit element.
+ * The higher 7 bit val specifies VFTA array index.
+ */
+#define HINIC_VFTA_BIT(vlan_id)    (1 << ((vlan_id) & 0x1F))
+#define HINIC_VFTA_IDX(vlan_id)    ((vlan_id) >> 5)
+
+#define HINIC_VLAN_FILTER_EN		(1U << 0)
 
-/** Driver-specific log messages type. */
+#define HINIC_MTU_TO_PKTLEN(mtu)	\
+	((mtu) + ETH_HLEN + ETH_CRC_LEN)
+
+#define HINIC_PKTLEN_TO_MTU(pktlen)	\
+	((pktlen) - (ETH_HLEN + ETH_CRC_LEN))
+
+/* lro numer limit for one packet */
+#define HINIC_LRO_WQE_NUM_DEFAULT	8
+
+/* Driver-specific log messages type */
 int hinic_logtype;
 
 struct hinic_xstats_name_off {
@@ -197,10 +232,16 @@ static const struct hinic_xstats_name_off hinic_txq_stats_strings[] = {
 
 static int hinic_xstats_calc_num(struct hinic_nic_dev *nic_dev)
 {
-	return (HINIC_VPORT_XSTATS_NUM +
-		HINIC_PHYPORT_XSTATS_NUM +
-		HINIC_RXQ_XSTATS_NUM * nic_dev->num_rq +
-		HINIC_TXQ_XSTATS_NUM * nic_dev->num_sq);
+	if (HINIC_IS_VF(nic_dev->hwdev)) {
+		return (HINIC_VPORT_XSTATS_NUM +
+			HINIC_RXQ_XSTATS_NUM * nic_dev->num_rq +
+			HINIC_TXQ_XSTATS_NUM * nic_dev->num_sq);
+	} else {
+		return (HINIC_VPORT_XSTATS_NUM +
+			HINIC_PHYPORT_XSTATS_NUM +
+			HINIC_RXQ_XSTATS_NUM * nic_dev->num_rq +
+			HINIC_TXQ_XSTATS_NUM * nic_dev->num_sq);
+	}
 }
 
 static const struct rte_eth_desc_lim hinic_rx_desc_lim = {
@@ -215,13 +256,14 @@ static const struct rte_eth_desc_lim hinic_tx_desc_lim = {
 	.nb_align = HINIC_TXD_ALIGN,
 };
 
+static int hinic_vlan_offload_set(struct rte_eth_dev *dev, int mask);
 
 /**
  * Interrupt handler triggered by NIC  for handling
  * specific event.
  *
  * @param: The address of parameter (struct rte_eth_dev *) regsitered before.
- **/
+ */
 static void hinic_dev_interrupt_handler(void *param)
 {
 	struct rte_eth_dev *dev = param;
@@ -276,6 +318,9 @@ static int hinic_dev_configure(struct rte_eth_dev *dev)
 		return -EINVAL;
 	}
 
+	if (dev->data->dev_conf.rxmode.mq_mode & ETH_MQ_RX_RSS_FLAG)
+		dev->data->dev_conf.rxmode.offloads |= DEV_RX_OFFLOAD_RSS_HASH;
+
 	/* mtu size is 256~9600 */
 	if (dev->data->dev_conf.rxmode.max_rx_pkt_len < HINIC_MIN_FRAME_SIZE ||
 	    dev->data->dev_conf.rxmode.max_rx_pkt_len >
@@ -298,6 +343,18 @@ static int hinic_dev_configure(struct rte_eth_dev *dev)
 		return err;
 	}
 
+	/* init vlan offoad */
+	err = hinic_vlan_offload_set(dev,
+				ETH_VLAN_STRIP_MASK | ETH_VLAN_FILTER_MASK);
+	if (err) {
+		PMD_DRV_LOG(ERR, "Initialize vlan filter and strip failed\n");
+		(void)hinic_config_mq_mode(dev, FALSE);
+		return err;
+	}
+
+	/*clear fdir filter flag in function table*/
+	hinic_free_fdir_filter(nic_dev);
+
 	return HINIC_OK;
 }
 
@@ -599,7 +656,7 @@ static void hinic_reset_tx_queue(struct rte_eth_dev *dev)
 		txq->wq->delta = txq->q_depth;
 		txq->wq->mask  = txq->q_depth - 1;
 
-		/*clear hardware ci*/
+		/* clear hardware ci */
 		ci_addr = (volatile u32 *)HINIC_CI_VADDR(nic_io->ci_vaddr_base,
 							q_id);
 		*ci_addr = 0;
@@ -673,14 +730,21 @@ hinic_dev_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *info)
 	info->max_tx_queues  = nic_dev->nic_cap.max_sqs;
 	info->min_rx_bufsize = HINIC_MIN_RX_BUF_SIZE;
 	info->max_rx_pktlen  = HINIC_MAX_JUMBO_FRAME_SIZE;
-	info->max_mac_addrs  = HINIC_MAX_MAC_ADDRS;
+	info->max_mac_addrs  = HINIC_MAX_UC_MAC_ADDRS;
+	info->min_mtu = HINIC_MIN_MTU_SIZE;
+	info->max_mtu = HINIC_MAX_MTU_SIZE;
 
 	hinic_get_speed_capa(dev, &info->speed_capa);
 	info->rx_queue_offload_capa = 0;
 	info->rx_offload_capa = DEV_RX_OFFLOAD_VLAN_STRIP |
 				DEV_RX_OFFLOAD_IPV4_CKSUM |
 				DEV_RX_OFFLOAD_UDP_CKSUM |
-				DEV_RX_OFFLOAD_TCP_CKSUM;
+				DEV_RX_OFFLOAD_TCP_CKSUM |
+				DEV_RX_OFFLOAD_VLAN_FILTER |
+				DEV_RX_OFFLOAD_SCATTER |
+				DEV_RX_OFFLOAD_JUMBO_FRAME |
+				DEV_RX_OFFLOAD_TCP_LRO |
+				DEV_RX_OFFLOAD_RSS_HASH;
 
 	info->tx_queue_offload_capa = 0;
 	info->tx_offload_capa = DEV_TX_OFFLOAD_VLAN_INSERT |
@@ -698,6 +762,35 @@ hinic_dev_infos_get(struct rte_eth_dev *dev, struct rte_eth_dev_info *info)
 	info->rx_desc_lim = hinic_rx_desc_lim;
 	info->tx_desc_lim = hinic_tx_desc_lim;
 
+	/* Driver-preferred Rx/Tx parameters */
+	info->default_rxportconf.burst_size = HINIC_DEFAULT_BURST_SIZE;
+	info->default_txportconf.burst_size = HINIC_DEFAULT_BURST_SIZE;
+	info->default_rxportconf.nb_queues = HINIC_DEFAULT_NB_QUEUES;
+	info->default_txportconf.nb_queues = HINIC_DEFAULT_NB_QUEUES;
+	info->default_rxportconf.ring_size = HINIC_DEFAULT_RING_SIZE;
+	info->default_txportconf.ring_size = HINIC_DEFAULT_RING_SIZE;
+
+	return 0;
+}
+
+static int hinic_fw_version_get(struct rte_eth_dev *dev, char *fw_version,
+				size_t fw_size)
+{
+	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+	char fw_ver[HINIC_MGMT_VERSION_MAX_LEN] = {0};
+	int err;
+
+	err = hinic_get_mgmt_version(nic_dev->hwdev, fw_ver);
+	if (err) {
+		PMD_DRV_LOG(ERR, "Failed to get fw version\n");
+		return -EINVAL;
+	}
+
+	if (fw_size < strlen(fw_ver) + 1)
+		return (strlen(fw_ver) + 1);
+
+	snprintf(fw_version, fw_size, "%s", fw_ver);
+
 	return 0;
 }
 
@@ -720,6 +813,7 @@ static int hinic_rxtx_configure(struct rte_eth_dev *dev)
 {
 	int err;
 	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+	bool lro_en;
 
 	/* rx configure, if rss enable, need to init default configuration */
 	err = hinic_rx_configure(dev);
@@ -736,6 +830,18 @@ static int hinic_rxtx_configure(struct rte_eth_dev *dev)
 		goto set_rx_mode_fail;
 	}
 
+	/* config lro */
+	lro_en = dev->data->dev_conf.rxmode.offloads & DEV_RX_OFFLOAD_TCP_LRO ?
+			true : false;
+
+	err = hinic_set_rx_lro(nic_dev->hwdev, lro_en, lro_en,
+				HINIC_LRO_WQE_NUM_DEFAULT);
+	if (err) {
+		PMD_DRV_LOG(ERR, "%s lro failed, err: %d",
+			lro_en ? "Enable" : "Disable", err);
+		goto set_rx_mode_fail;
+	}
+
 	return HINIC_OK;
 
 set_rx_mode_fail:
@@ -831,6 +937,66 @@ out:
 	return rc;
 }
 
+/**
+ * DPDK callback to bring the link UP.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ *
+ * @return
+ *   0 on success, negative errno value on failure.
+ */
+static int hinic_dev_set_link_up(struct rte_eth_dev *dev)
+{
+	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+	int ret;
+
+	ret = hinic_set_xsfp_tx_status(nic_dev->hwdev, true);
+	if (ret) {
+		PMD_DRV_LOG(ERR, "Enable port tx xsfp failed, dev_name: %s, port_id: %d",
+			    nic_dev->proc_dev_name, dev->data->port_id);
+		return ret;
+	}
+
+	/* link status follow phy port status, up will open pma */
+	ret = hinic_set_port_enable(nic_dev->hwdev, true);
+	if (ret)
+		PMD_DRV_LOG(ERR, "Set mac link up failed, dev_name: %s, port_id: %d",
+			    nic_dev->proc_dev_name, dev->data->port_id);
+
+	return ret;
+}
+
+/**
+ * DPDK callback to bring the link DOWN.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ *
+ * @return
+ *   0 on success, negative errno value on failure.
+ */
+static int hinic_dev_set_link_down(struct rte_eth_dev *dev)
+{
+	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+	int ret;
+
+	ret = hinic_set_xsfp_tx_status(nic_dev->hwdev, false);
+	if (ret) {
+		PMD_DRV_LOG(ERR, "Disable port tx xsfp failed, dev_name: %s, port_id: %d",
+			    nic_dev->proc_dev_name, dev->data->port_id);
+		return ret;
+	}
+
+	/* link status follow phy port status, up will close pma */
+	ret = hinic_set_port_enable(nic_dev->hwdev, false);
+	if (ret)
+		PMD_DRV_LOG(ERR, "Set mac link down failed, dev_name: %s, port_id: %d",
+			    nic_dev->proc_dev_name, dev->data->port_id);
+
+	return ret;
+}
+
 /**
  * DPDK callback to start the device.
  *
@@ -888,6 +1054,9 @@ static int hinic_dev_start(struct rte_eth_dev *dev)
 		goto cfg_rxtx_fail;
 	}
 
+	/* reactive pf status, so that uP report asyn event */
+	hinic_set_pf_status(nic_dev->hwdev->hwif, HINIC_PF_STATUS_ACTIVE_FLAG);
+
 	/* open virtual port and ready to start packet receiving */
 	rc = hinic_set_vport_enable(nic_dev->hwdev, true);
 	if (rc) {
@@ -915,6 +1084,8 @@ en_port_fail:
 	(void)hinic_set_vport_enable(nic_dev->hwdev, false);
 
 en_vport_fail:
+	hinic_set_pf_status(nic_dev->hwdev->hwif, HINIC_PF_STATUS_INIT);
+
 	/* Flush tx && rx chip resources in case of set vport fake fail */
 	(void)hinic_flush_qp_res(nic_dev->hwdev);
 	rte_delay_ms(100);
@@ -951,7 +1122,7 @@ static void hinic_rx_queue_release(void *queue)
 	nic_dev = rxq->nic_dev;
 
 	/* free rxq_pkt mbuf */
-	hinic_free_all_rx_skbs(rxq);
+	hinic_free_all_rx_mbufs(rxq);
 
 	/* free rxq_cqe, rxq_info */
 	hinic_free_rx_resources(rxq);
@@ -983,7 +1154,7 @@ static void hinic_tx_queue_release(void *queue)
 	nic_dev = txq->nic_dev;
 
 	/* free txq_pkt mbuf */
-	hinic_free_all_tx_skbs(txq);
+	hinic_free_all_tx_mbufs(txq);
 
 	/* free txq_info */
 	hinic_free_tx_resources(txq);
@@ -1062,6 +1233,8 @@ static void hinic_dev_stop(struct rte_eth_dev *dev)
 	/* clean root context */
 	hinic_free_qp_ctxts(nic_dev->hwdev);
 
+	hinic_free_fdir_filter(nic_dev);
+
 	/* free mbuf */
 	hinic_free_all_rx_mbuf(dev);
 	hinic_free_all_tx_mbuf(dev);
@@ -1203,14 +1376,17 @@ hinic_dev_stats_get(struct rte_eth_dev *dev, struct rte_eth_stats *stats)
  * @param dev
  *   Pointer to Ethernet device structure.
  */
-static void hinic_dev_stats_reset(struct rte_eth_dev *dev)
+static int hinic_dev_stats_reset(struct rte_eth_dev *dev)
 {
 	int qid;
 	struct hinic_rxq	*rxq = NULL;
 	struct hinic_txq	*txq = NULL;
 	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+	int ret;
 
-	hinic_clear_vport_stats(nic_dev->hwdev);
+	ret = hinic_clear_vport_stats(nic_dev->hwdev);
+	if (ret != 0)
+		return ret;
 
 	for (qid = 0; qid < nic_dev->num_rq; qid++) {
 		rxq = nic_dev->rxqs[qid];
@@ -1221,6 +1397,8 @@ static void hinic_dev_stats_reset(struct rte_eth_dev *dev)
 		txq = nic_dev->txqs[qid];
 		hinic_txq_stats_reset(txq);
 	}
+
+	return 0;
 }
 
 /**
@@ -1228,15 +1406,23 @@ static void hinic_dev_stats_reset(struct rte_eth_dev *dev)
  *
  * @param dev
  *   Pointer to Ethernet device structure.
- **/
-static void hinic_dev_xstats_reset(struct rte_eth_dev *dev)
+ */
+static int hinic_dev_xstats_reset(struct rte_eth_dev *dev)
 {
 	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+	int ret;
+
+	ret = hinic_dev_stats_reset(dev);
+	if (ret != 0)
+		return ret;
 
-	hinic_dev_stats_reset(dev);
+	if (hinic_func_type(nic_dev->hwdev) != TYPE_VF) {
+		ret = hinic_clear_phy_port_stats(nic_dev->hwdev);
+		if (ret != 0)
+			return ret;
+	}
 
-	if (hinic_func_type(nic_dev->hwdev) != TYPE_VF)
-		hinic_clear_phy_port_stats(nic_dev->hwdev);
+	return 0;
 }
 
 static void hinic_gen_random_mac_addr(struct rte_ether_addr *mac_addr)
@@ -1276,21 +1462,41 @@ static int hinic_init_mac_addr(struct rte_eth_dev *eth_dev)
 	if (rc)
 		return rc;
 
-	memmove(eth_dev->data->mac_addrs->addr_bytes,
-		addr_bytes, RTE_ETHER_ADDR_LEN);
-
-	if (rte_is_zero_ether_addr(eth_dev->data->mac_addrs))
-		hinic_gen_random_mac_addr(eth_dev->data->mac_addrs);
+	rte_ether_addr_copy((struct rte_ether_addr *)addr_bytes,
+		&eth_dev->data->mac_addrs[0]);
+	if (rte_is_zero_ether_addr(&eth_dev->data->mac_addrs[0]))
+		hinic_gen_random_mac_addr(&eth_dev->data->mac_addrs[0]);
 
 	func_id = hinic_global_func_id(nic_dev->hwdev);
-	rc = hinic_set_mac(nic_dev->hwdev, eth_dev->data->mac_addrs->addr_bytes,
-			   0, func_id);
+	rc = hinic_set_mac(nic_dev->hwdev,
+			eth_dev->data->mac_addrs[0].addr_bytes,
+			0, func_id);
 	if (rc && rc != HINIC_PF_SET_VF_ALREADY)
 		return rc;
 
+	rte_ether_addr_copy(&eth_dev->data->mac_addrs[0],
+			&nic_dev->default_addr);
+
 	return 0;
 }
 
+static void hinic_delete_mc_addr_list(struct hinic_nic_dev *nic_dev)
+{
+	u16 func_id;
+	u32 i;
+
+	func_id = hinic_global_func_id(nic_dev->hwdev);
+
+	for (i = 0; i < HINIC_MAX_MC_MAC_ADDRS; i++) {
+		if (rte_is_zero_ether_addr(&nic_dev->mc_list[i]))
+			break;
+
+		hinic_del_mac(nic_dev->hwdev, nic_dev->mc_list[i].addr_bytes,
+			      0, func_id);
+		memset(&nic_dev->mc_list[i], 0, sizeof(struct rte_ether_addr));
+	}
+}
+
 /**
  * Deinit mac_vlan table in NIC.
  *
@@ -1305,19 +1511,285 @@ static void hinic_deinit_mac_addr(struct rte_eth_dev *eth_dev)
 {
 	struct hinic_nic_dev *nic_dev =
 				HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(eth_dev);
-	int rc;
 	u16 func_id = 0;
+	int rc;
+	int i;
 
-	if (rte_is_zero_ether_addr(eth_dev->data->mac_addrs))
-		return;
+	func_id = hinic_global_func_id(nic_dev->hwdev);
+
+	for (i = 0; i < HINIC_MAX_UC_MAC_ADDRS; i++) {
+		if (rte_is_zero_ether_addr(&eth_dev->data->mac_addrs[i]))
+			continue;
+
+		rc = hinic_del_mac(nic_dev->hwdev,
+				   eth_dev->data->mac_addrs[i].addr_bytes,
+				   0, func_id);
+		if (rc && rc != HINIC_PF_SET_VF_ALREADY)
+			PMD_DRV_LOG(ERR, "Delete mac table failed, dev_name: %s",
+				    eth_dev->data->name);
+
+		memset(&eth_dev->data->mac_addrs[i], 0,
+		       sizeof(struct rte_ether_addr));
+	}
+
+	/* delete multicast mac addrs */
+	hinic_delete_mc_addr_list(nic_dev);
+}
+
+static int hinic_dev_set_mtu(struct rte_eth_dev *dev, uint16_t mtu)
+{
+	int ret = 0;
+	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+
+	PMD_DRV_LOG(INFO, "Set port mtu, port_id: %d, mtu: %d, max_pkt_len: %d",
+			dev->data->port_id, mtu, HINIC_MTU_TO_PKTLEN(mtu));
+
+	if (mtu < HINIC_MIN_MTU_SIZE || mtu > HINIC_MAX_MTU_SIZE) {
+		PMD_DRV_LOG(ERR, "Invalid mtu: %d, must between %d and %d",
+				mtu, HINIC_MIN_MTU_SIZE, HINIC_MAX_MTU_SIZE);
+		return -EINVAL;
+	}
+
+	ret = hinic_set_port_mtu(nic_dev->hwdev, mtu);
+	if (ret) {
+		PMD_DRV_LOG(ERR, "Set port mtu failed, ret: %d", ret);
+		return ret;
+	}
+
+	/* update max frame size */
+	dev->data->dev_conf.rxmode.max_rx_pkt_len = HINIC_MTU_TO_PKTLEN(mtu);
+	nic_dev->mtu_size = mtu;
+
+	return ret;
+}
+
+static void hinic_store_vlan_filter(struct hinic_nic_dev *nic_dev,
+					u16 vlan_id, bool on)
+{
+	u32 vid_idx, vid_bit;
+
+	vid_idx = HINIC_VFTA_IDX(vlan_id);
+	vid_bit = HINIC_VFTA_BIT(vlan_id);
+
+	if (on)
+		nic_dev->vfta[vid_idx] |= vid_bit;
+	else
+		nic_dev->vfta[vid_idx] &= ~vid_bit;
+}
+
+static bool hinic_find_vlan_filter(struct hinic_nic_dev *nic_dev,
+				uint16_t vlan_id)
+{
+	u32 vid_idx, vid_bit;
+
+	vid_idx = HINIC_VFTA_IDX(vlan_id);
+	vid_bit = HINIC_VFTA_BIT(vlan_id);
+
+	return (nic_dev->vfta[vid_idx] & vid_bit) ? TRUE : FALSE;
+}
+
+/**
+ * DPDK callback to set vlan filter.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ * @param vlan_id
+ *   vlan id is used to filter vlan packets
+ * @param enable
+ *   enable disable or enable vlan filter function
+ */
+static int hinic_vlan_filter_set(struct rte_eth_dev *dev,
+				uint16_t vlan_id, int enable)
+{
+	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+	int err = 0;
+	u16 func_id;
+
+	if (vlan_id > RTE_ETHER_MAX_VLAN_ID)
+		return -EINVAL;
 
 	func_id = hinic_global_func_id(nic_dev->hwdev);
-	rc = hinic_del_mac(nic_dev->hwdev,
-			   eth_dev->data->mac_addrs->addr_bytes,
-			   0, func_id);
-	if (rc && rc != HINIC_PF_SET_VF_ALREADY)
-		PMD_DRV_LOG(ERR, "Delete mac table failed, dev_name: %s",
-			    eth_dev->data->name);
+
+	if (enable) {
+		/* If vlanid is already set, just return */
+		if (hinic_find_vlan_filter(nic_dev, vlan_id)) {
+			PMD_DRV_LOG(INFO, "Vlan %u has been added, device: %s",
+				  vlan_id, nic_dev->proc_dev_name);
+			return 0;
+		}
+
+		err = hinic_add_remove_vlan(nic_dev->hwdev, vlan_id,
+					    func_id, TRUE);
+	} else {
+		/* If vlanid can't be found, just return */
+		if (!hinic_find_vlan_filter(nic_dev, vlan_id)) {
+			PMD_DRV_LOG(INFO, "Vlan %u is not in the vlan filter list, device: %s",
+				  vlan_id, nic_dev->proc_dev_name);
+			return 0;
+		}
+
+		err = hinic_add_remove_vlan(nic_dev->hwdev, vlan_id,
+					    func_id, FALSE);
+	}
+
+	if (err) {
+		PMD_DRV_LOG(ERR, "%s vlan failed, func_id: %d, vlan_id: %d, err: %d",
+		      enable ? "Add" : "Remove", func_id, vlan_id, err);
+		return err;
+	}
+
+	hinic_store_vlan_filter(nic_dev, vlan_id, enable);
+
+	PMD_DRV_LOG(INFO, "%s vlan %u succeed, device: %s",
+		  enable ? "Add" : "Remove", vlan_id, nic_dev->proc_dev_name);
+	return 0;
+}
+
+/**
+ * DPDK callback to enable or disable vlan offload.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ * @param mask
+ *   Definitions used for VLAN setting
+ */
+static int hinic_vlan_offload_set(struct rte_eth_dev *dev, int mask)
+{
+	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+	struct rte_eth_rxmode *rxmode = &dev->data->dev_conf.rxmode;
+	bool on;
+	int err;
+
+	/* Enable or disable VLAN filter */
+	if (mask & ETH_VLAN_FILTER_MASK) {
+		on = (rxmode->offloads & DEV_RX_OFFLOAD_VLAN_FILTER) ?
+			TRUE : FALSE;
+		err = hinic_config_vlan_filter(nic_dev->hwdev, on);
+		if (err == HINIC_MGMT_CMD_UNSUPPORTED) {
+			PMD_DRV_LOG(WARNING,
+				"Current matching version does not support vlan filter configuration, device: %s, port_id: %d",
+				  nic_dev->proc_dev_name, dev->data->port_id);
+		} else if (err) {
+			PMD_DRV_LOG(ERR, "Failed to %s vlan filter, device: %s, port_id: %d, err: %d",
+				  on ? "enable" : "disable",
+				  nic_dev->proc_dev_name,
+				  dev->data->port_id, err);
+			return err;
+		}
+
+		PMD_DRV_LOG(INFO, "%s vlan filter succeed, device: %s, port_id: %d",
+			  on ? "Enable" : "Disable",
+			  nic_dev->proc_dev_name, dev->data->port_id);
+	}
+
+	/* Enable or disable VLAN stripping */
+	if (mask & ETH_VLAN_STRIP_MASK) {
+		on = (rxmode->offloads & DEV_RX_OFFLOAD_VLAN_STRIP) ?
+			TRUE : FALSE;
+		err = hinic_set_rx_vlan_offload(nic_dev->hwdev, on);
+		if (err) {
+			PMD_DRV_LOG(ERR, "Failed to %s vlan strip, device: %s, port_id: %d, err: %d",
+				  on ? "enable" : "disable",
+				  nic_dev->proc_dev_name,
+				  dev->data->port_id, err);
+			return err;
+		}
+
+		PMD_DRV_LOG(INFO, "%s vlan strip succeed, device: %s, port_id: %d",
+			  on ? "Enable" : "Disable",
+			  nic_dev->proc_dev_name, dev->data->port_id);
+	}
+
+	if (mask & ETH_VLAN_EXTEND_MASK) {
+		PMD_DRV_LOG(ERR, "Don't support vlan qinq, device: %s, port_id: %d",
+			  nic_dev->proc_dev_name, dev->data->port_id);
+		return -ENOTSUP;
+	}
+
+	return 0;
+}
+
+static void hinic_remove_all_vlanid(struct rte_eth_dev *eth_dev)
+{
+	struct hinic_nic_dev *nic_dev =
+		HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(eth_dev);
+	u16 func_id;
+	int i;
+
+	func_id = hinic_global_func_id(nic_dev->hwdev);
+	for (i = 0; i <= RTE_ETHER_MAX_VLAN_ID; i++) {
+		/* If can't find it, continue */
+		if (!hinic_find_vlan_filter(nic_dev, i))
+			continue;
+
+		(void)hinic_add_remove_vlan(nic_dev->hwdev, i, func_id, FALSE);
+		hinic_store_vlan_filter(nic_dev, i, false);
+	}
+}
+
+static int hinic_set_dev_allmulticast(struct hinic_nic_dev *nic_dev,
+				bool enable)
+{
+	u32 rx_mode_ctrl = nic_dev->rx_mode_status;
+
+	if (enable)
+		rx_mode_ctrl |= HINIC_RX_MODE_MC_ALL;
+	else
+		rx_mode_ctrl &= (~HINIC_RX_MODE_MC_ALL);
+
+	return hinic_config_rx_mode(nic_dev, rx_mode_ctrl);
+}
+
+/**
+ * DPDK callback to enable allmulticast mode.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ *
+ * @return
+ *   0 on success,
+ *   negative error value otherwise.
+ */
+static int hinic_dev_allmulticast_enable(struct rte_eth_dev *dev)
+{
+	int ret = HINIC_OK;
+	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+
+	ret = hinic_set_dev_allmulticast(nic_dev, true);
+	if (ret) {
+		PMD_DRV_LOG(ERR, "Enable allmulticast failed, error: %d", ret);
+		return ret;
+	}
+
+	PMD_DRV_LOG(INFO, "Enable allmulticast succeed, nic_dev: %s, port_id: %d",
+		nic_dev->proc_dev_name, dev->data->port_id);
+	return 0;
+}
+
+/**
+ * DPDK callback to disable allmulticast mode.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ *
+ * @return
+ *   0 on success,
+ *   negative error value otherwise.
+ */
+static int hinic_dev_allmulticast_disable(struct rte_eth_dev *dev)
+{
+	int ret = HINIC_OK;
+	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+
+	ret = hinic_set_dev_allmulticast(nic_dev, false);
+	if (ret) {
+		PMD_DRV_LOG(ERR, "Disable allmulticast failed, error: %d", ret);
+		return ret;
+	}
+
+	PMD_DRV_LOG(INFO, "Disable allmulticast succeed, nic_dev: %s, port_id: %d",
+		nic_dev->proc_dev_name, dev->data->port_id);
+	return 0;
 }
 
 /**
@@ -1684,6 +2156,9 @@ static int hinic_dev_xstats_get(struct rte_eth_dev *dev,
 		count++;
 	}
 
+	if (HINIC_IS_VF(nic_dev->hwdev))
+		return count;
+
 	/* Get stats from hinic_phy_port_stats */
 	err = hinic_get_phy_port_stats(nic_dev->hwdev, &port_stats);
 	if (err)
@@ -1699,6 +2174,23 @@ static int hinic_dev_xstats_get(struct rte_eth_dev *dev,
 	return count;
 }
 
+static void hinic_rxq_info_get(struct rte_eth_dev *dev, uint16_t queue_id,
+				struct rte_eth_rxq_info *qinfo)
+{
+	struct hinic_rxq  *rxq = dev->data->rx_queues[queue_id];
+
+	qinfo->mp = rxq->mb_pool;
+	qinfo->nb_desc = rxq->q_depth;
+}
+
+static void hinic_txq_info_get(struct rte_eth_dev *dev, uint16_t queue_id,
+				struct rte_eth_txq_info *qinfo)
+{
+	struct hinic_txq  *txq = dev->data->tx_queues[queue_id];
+
+	qinfo->nb_desc = txq->q_depth;
+}
+
 /**
  * DPDK callback to retrieve names of extended device statistics
  *
@@ -1752,6 +2244,9 @@ static int hinic_dev_xstats_get_names(struct rte_eth_dev *dev,
 		count++;
 	}
 
+	if (HINIC_IS_VF(nic_dev->hwdev))
+		return count;
+
 	/* get phy port stats */
 	for (i = 0; i < HINIC_PHYPORT_XSTATS_NUM; i++) {
 		snprintf(xstats_names[count].name,
@@ -1763,10 +2258,213 @@ static int hinic_dev_xstats_get_names(struct rte_eth_dev *dev,
 
 	return count;
 }
-
-static int hinic_set_default_pause_feature(struct hinic_nic_dev *nic_dev)
+/**
+ *  DPDK callback to set mac address
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ * @param addr
+ *   Pointer to mac address
+ * @return
+ *   0 on success, negative error value otherwise.
+ */
+static int hinic_set_mac_addr(struct rte_eth_dev *dev,
+			      struct rte_ether_addr *addr)
 {
-	struct nic_pause_config pause_config = {0};
+	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+	u16 func_id;
+	int err;
+
+	func_id = hinic_global_func_id(nic_dev->hwdev);
+	err = hinic_update_mac(nic_dev->hwdev, nic_dev->default_addr.addr_bytes,
+			       addr->addr_bytes, 0, func_id);
+	if (err)
+		return err;
+
+	rte_ether_addr_copy(addr, &nic_dev->default_addr);
+
+	PMD_DRV_LOG(INFO, "Set new mac address %02x:%02x:%02x:%02x:%02x:%02x\n",
+		    addr->addr_bytes[0], addr->addr_bytes[1],
+		    addr->addr_bytes[2], addr->addr_bytes[3],
+		    addr->addr_bytes[4], addr->addr_bytes[5]);
+
+	return 0;
+}
+
+/**
+ * DPDK callback to remove a MAC address.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ * @param index
+ *   MAC address index.
+ */
+static void hinic_mac_addr_remove(struct rte_eth_dev *dev, uint32_t index)
+{
+	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+	u16 func_id;
+	int ret;
+
+	if (index >= HINIC_MAX_UC_MAC_ADDRS) {
+		PMD_DRV_LOG(INFO, "Remove mac index(%u) is out of range",
+			    index);
+		return;
+	}
+
+	func_id = hinic_global_func_id(nic_dev->hwdev);
+	ret = hinic_del_mac(nic_dev->hwdev,
+			    dev->data->mac_addrs[index].addr_bytes, 0, func_id);
+	if (ret)
+		return;
+
+	memset(&dev->data->mac_addrs[index], 0, sizeof(struct rte_ether_addr));
+}
+
+/**
+ * DPDK callback to add a MAC address.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ * @param mac_addr
+ *   MAC address to register.
+ * @param index
+ *   MAC address index.
+ * @param vmdq
+ *   VMDq pool index to associate address with (ignored).
+ *
+ * @return
+ *   0 on success, a negative errno value otherwise and rte_errno is set.
+ */
+
+static int hinic_mac_addr_add(struct rte_eth_dev *dev,
+			      struct rte_ether_addr *mac_addr, uint32_t index,
+			      __rte_unused uint32_t vmdq)
+{
+	struct hinic_nic_dev  *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+	unsigned int i;
+	u16 func_id;
+	int ret;
+
+	if (index >= HINIC_MAX_UC_MAC_ADDRS) {
+		PMD_DRV_LOG(INFO, "Add mac index(%u) is out of range,", index);
+		return -EINVAL;
+	}
+
+	/* First, make sure this address isn't already configured. */
+	for (i = 0; (i != HINIC_MAX_UC_MAC_ADDRS); ++i) {
+		/* Skip this index, it's going to be reconfigured. */
+		if (i == index)
+			continue;
+
+		if (memcmp(&dev->data->mac_addrs[i],
+			mac_addr, sizeof(*mac_addr)))
+			continue;
+
+		PMD_DRV_LOG(INFO, "MAC address already configured");
+		return -EADDRINUSE;
+	}
+
+	func_id = hinic_global_func_id(nic_dev->hwdev);
+	ret = hinic_set_mac(nic_dev->hwdev, mac_addr->addr_bytes, 0, func_id);
+	if (ret)
+		return ret;
+
+	dev->data->mac_addrs[index] = *mac_addr;
+	return 0;
+}
+
+/**
+ *  DPDK callback to set multicast mac address
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ * @param mc_addr_set
+ *   Pointer to multicast mac address
+ * @param nb_mc_addr
+ *   mc addr count
+ * @return
+ *   0 on success, negative error value otherwise.
+ */
+static int hinic_set_mc_addr_list(struct rte_eth_dev *dev,
+				  struct rte_ether_addr *mc_addr_set,
+				  uint32_t nb_mc_addr)
+{
+	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+	u16 func_id;
+	int ret;
+	u32 i;
+
+	func_id = hinic_global_func_id(nic_dev->hwdev);
+
+	/* delete old multi_cast addrs firstly */
+	hinic_delete_mc_addr_list(nic_dev);
+
+	if (nb_mc_addr > HINIC_MAX_MC_MAC_ADDRS)
+		goto allmulti;
+
+	for (i = 0; i < nb_mc_addr; i++) {
+		ret = hinic_set_mac(nic_dev->hwdev, mc_addr_set[i].addr_bytes,
+				    0, func_id);
+		/* if add mc addr failed, set all multi_cast */
+		if (ret) {
+			hinic_delete_mc_addr_list(nic_dev);
+			goto allmulti;
+		}
+
+		rte_ether_addr_copy(&mc_addr_set[i], &nic_dev->mc_list[i]);
+	}
+
+	return 0;
+
+allmulti:
+	hinic_dev_allmulticast_enable(dev);
+
+	return 0;
+}
+
+/**
+ * DPDK callback to manage filter operations
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ * @param filter_type
+ *   Filter type.
+ * @param filter_op
+ *   Operation to perform.
+ * @param arg
+ *   Pointer to operation-specific structure.
+ *
+ * @return
+ *   0 on success, negative errno value on failure.
+ */
+static int hinic_dev_filter_ctrl(struct rte_eth_dev *dev,
+		     enum rte_filter_type filter_type,
+		     enum rte_filter_op filter_op,
+		     void *arg)
+{
+	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+	int func_id = hinic_global_func_id(nic_dev->hwdev);
+
+	switch (filter_type) {
+	case RTE_ETH_FILTER_GENERIC:
+		if (filter_op != RTE_ETH_FILTER_GET)
+			return -EINVAL;
+		*(const void **)arg = &hinic_flow_ops;
+		break;
+	default:
+		PMD_DRV_LOG(INFO, "Filter type (%d) not supported",
+			filter_type);
+		return -EINVAL;
+	}
+
+	PMD_DRV_LOG(INFO, "Set filter_ctrl succeed, func_id: 0x%x, filter_type: 0x%x,"
+			"filter_op: 0x%x.", func_id, filter_type, filter_op);
+	return 0;
+}
+
+static int hinic_set_default_pause_feature(struct hinic_nic_dev *nic_dev)
+{
+	struct nic_pause_config pause_config = {0};
 
 	pause_config.auto_neg = 0;
 	pause_config.rx_pause = HINIC_DEFAUT_PAUSE_CONFIG;
@@ -1792,26 +2490,42 @@ static int hinic_set_default_dcb_feature(struct hinic_nic_dev *nic_dev)
 					up_pgid, up_bw, up_strict);
 }
 
-static void hinic_init_default_cos(struct hinic_nic_dev *nic_dev)
+static int hinic_init_default_cos(struct hinic_nic_dev *nic_dev)
 {
-	nic_dev->default_cos =
-			(hinic_global_func_id(nic_dev->hwdev) +
-			 DEFAULT_BASE_COS) % NR_MAX_COS;
+	u8 cos_id = 0;
+	int err;
+
+	if (!HINIC_IS_VF(nic_dev->hwdev)) {
+		nic_dev->default_cos =
+				(hinic_global_func_id(nic_dev->hwdev) +
+						DEFAULT_BASE_COS) % NR_MAX_COS;
+	} else {
+		err = hinic_vf_get_default_cos(nic_dev->hwdev, &cos_id);
+		if (err) {
+			PMD_DRV_LOG(ERR, "Get VF default cos failed, err: %d",
+					err);
+			return HINIC_ERROR;
+		}
+
+		nic_dev->default_cos = cos_id;
+	}
+
+	return 0;
 }
 
 static int hinic_set_default_hw_feature(struct hinic_nic_dev *nic_dev)
 {
 	int err;
 
-	hinic_init_default_cos(nic_dev);
-
-	/* Restore DCB configure to default status */
-	err = hinic_set_default_dcb_feature(nic_dev);
+	err = hinic_init_default_cos(nic_dev);
 	if (err)
 		return err;
 
-	/* disable LRO */
-	err = hinic_set_rx_lro(nic_dev->hwdev, 0, 0, (u8)0);
+	if (hinic_func_type(nic_dev->hwdev) == TYPE_VF)
+		return 0;
+
+	/* Restore DCB configure to default status */
+	err = hinic_set_default_dcb_feature(nic_dev);
 	if (err)
 		return err;
 
@@ -1839,6 +2553,9 @@ static int32_t hinic_card_workmode_check(struct hinic_nic_dev *nic_dev)
 	struct hinic_board_info info = { 0 };
 	int rc;
 
+	if (hinic_func_type(nic_dev->hwdev) == TYPE_VF)
+		return 0;
+
 	rc = hinic_get_board_info(nic_dev->hwdev, &info);
 	if (rc)
 		return rc;
@@ -1854,7 +2571,7 @@ static int hinic_copy_mempool_init(struct hinic_nic_dev *nic_dev)
 		nic_dev->cpy_mpool =
 		rte_pktmbuf_pool_create(nic_dev->proc_dev_name,
 					HINIC_COPY_MEMPOOL_DEPTH,
-					RTE_CACHE_LINE_SIZE, 0,
+					0, 0,
 					HINIC_COPY_MBUF_SIZE,
 					rte_socket_id());
 		if (!nic_dev->cpy_mpool) {
@@ -1965,6 +2682,14 @@ static int hinic_nic_dev_create(struct rte_eth_dev *eth_dev)
 		goto init_pf_to_mgmt_fail;
 	}
 
+	/* init mailbox */
+	rc = hinic_comm_func_to_func_init(nic_dev->hwdev);
+	if (rc) {
+		PMD_DRV_LOG(ERR, "Initialize func_to_func failed, dev_name: %s",
+			    eth_dev->data->name);
+		goto init_func_to_func_fail;
+	}
+
 	rc = hinic_card_workmode_check(nic_dev);
 	if (rc) {
 		PMD_DRV_LOG(ERR, "Check card workmode failed, dev_name: %s",
@@ -2064,6 +2789,9 @@ init_resources_state_fail:
 init_cmdq_fail:
 l2nic_reset_fail:
 workmode_check_fail:
+	hinic_comm_func_to_func_free(nic_dev->hwdev);
+
+init_func_to_func_fail:
 	hinic_comm_pf_to_mgmt_free(nic_dev->hwdev);
 
 init_pf_to_mgmt_fail:
@@ -2097,6 +2825,7 @@ static void hinic_nic_dev_destroy(struct rte_eth_dev *eth_dev)
 	hinic_deinit_nicio(nic_dev->hwdev);
 	hinic_deactivate_hwdev_state(nic_dev->hwdev);
 	hinic_comm_cmdqs_free(nic_dev->hwdev);
+	hinic_comm_func_to_func_free(nic_dev->hwdev);
 	hinic_comm_pf_to_mgmt_free(nic_dev->hwdev);
 	hinic_comm_aeqs_free(nic_dev->hwdev);
 	free_cfg_mgmt(nic_dev->hwdev);
@@ -2106,25 +2835,139 @@ static void hinic_nic_dev_destroy(struct rte_eth_dev *eth_dev)
 	nic_dev->hwdev = NULL;
 }
 
+/**
+ * DPDK callback to close the device.
+ *
+ * @param dev
+ *   Pointer to Ethernet device structure.
+ */
+static void hinic_dev_close(struct rte_eth_dev *dev)
+{
+	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
+
+	if (hinic_test_and_set_bit(HINIC_DEV_CLOSE, &nic_dev->dev_status)) {
+		PMD_DRV_LOG(WARNING, "Device %s already closed",
+			    dev->data->name);
+		return;
+	}
+
+	/* stop device first */
+	hinic_dev_stop(dev);
+
+	/* rx_cqe, rx_info */
+	hinic_free_all_rx_resources(dev);
+
+	/* tx_info */
+	hinic_free_all_tx_resources(dev);
+
+	/* free wq, pi_dma_addr */
+	hinic_free_all_rq(nic_dev);
+
+	/* free wq, db_addr */
+	hinic_free_all_sq(nic_dev);
+
+	/* deinit mac vlan tbl */
+	hinic_deinit_mac_addr(dev);
+	hinic_remove_all_vlanid(dev);
+
+	/* disable hardware and uio interrupt */
+	hinic_disable_interrupt(dev);
+
+	/* deinit nic hardware device */
+	hinic_nic_dev_destroy(dev);
+}
+
+static const struct eth_dev_ops hinic_pmd_ops = {
+	.dev_configure                 = hinic_dev_configure,
+	.dev_infos_get                 = hinic_dev_infos_get,
+	.fw_version_get                = hinic_fw_version_get,
+	.rx_queue_setup                = hinic_rx_queue_setup,
+	.tx_queue_setup                = hinic_tx_queue_setup,
+	.dev_start                     = hinic_dev_start,
+	.dev_set_link_up               = hinic_dev_set_link_up,
+	.dev_set_link_down             = hinic_dev_set_link_down,
+	.link_update                   = hinic_link_update,
+	.rx_queue_release              = hinic_rx_queue_release,
+	.tx_queue_release              = hinic_tx_queue_release,
+	.dev_stop                      = hinic_dev_stop,
+	.dev_close                     = hinic_dev_close,
+	.mtu_set                       = hinic_dev_set_mtu,
+	.vlan_filter_set               = hinic_vlan_filter_set,
+	.vlan_offload_set              = hinic_vlan_offload_set,
+	.allmulticast_enable           = hinic_dev_allmulticast_enable,
+	.allmulticast_disable          = hinic_dev_allmulticast_disable,
+	.promiscuous_enable            = hinic_dev_promiscuous_enable,
+	.promiscuous_disable           = hinic_dev_promiscuous_disable,
+	.rss_hash_update               = hinic_rss_hash_update,
+	.rss_hash_conf_get             = hinic_rss_conf_get,
+	.reta_update                   = hinic_rss_indirtbl_update,
+	.reta_query                    = hinic_rss_indirtbl_query,
+	.stats_get                     = hinic_dev_stats_get,
+	.stats_reset                   = hinic_dev_stats_reset,
+	.xstats_get                    = hinic_dev_xstats_get,
+	.xstats_reset                  = hinic_dev_xstats_reset,
+	.xstats_get_names              = hinic_dev_xstats_get_names,
+	.rxq_info_get                  = hinic_rxq_info_get,
+	.txq_info_get                  = hinic_txq_info_get,
+	.mac_addr_set                  = hinic_set_mac_addr,
+	.mac_addr_remove               = hinic_mac_addr_remove,
+	.mac_addr_add                  = hinic_mac_addr_add,
+	.set_mc_addr_list              = hinic_set_mc_addr_list,
+	.filter_ctrl                   = hinic_dev_filter_ctrl,
+};
+
+static const struct eth_dev_ops hinic_pmd_vf_ops = {
+	.dev_configure                 = hinic_dev_configure,
+	.dev_infos_get                 = hinic_dev_infos_get,
+	.fw_version_get                = hinic_fw_version_get,
+	.rx_queue_setup                = hinic_rx_queue_setup,
+	.tx_queue_setup                = hinic_tx_queue_setup,
+	.dev_start                     = hinic_dev_start,
+	.link_update                   = hinic_link_update,
+	.rx_queue_release              = hinic_rx_queue_release,
+	.tx_queue_release              = hinic_tx_queue_release,
+	.dev_stop                      = hinic_dev_stop,
+	.dev_close                     = hinic_dev_close,
+	.mtu_set                       = hinic_dev_set_mtu,
+	.vlan_filter_set               = hinic_vlan_filter_set,
+	.vlan_offload_set              = hinic_vlan_offload_set,
+	.allmulticast_enable           = hinic_dev_allmulticast_enable,
+	.allmulticast_disable          = hinic_dev_allmulticast_disable,
+	.rss_hash_update               = hinic_rss_hash_update,
+	.rss_hash_conf_get             = hinic_rss_conf_get,
+	.reta_update                   = hinic_rss_indirtbl_update,
+	.reta_query                    = hinic_rss_indirtbl_query,
+	.stats_get                     = hinic_dev_stats_get,
+	.stats_reset                   = hinic_dev_stats_reset,
+	.xstats_get                    = hinic_dev_xstats_get,
+	.xstats_reset                  = hinic_dev_xstats_reset,
+	.xstats_get_names              = hinic_dev_xstats_get_names,
+	.rxq_info_get                  = hinic_rxq_info_get,
+	.txq_info_get                  = hinic_txq_info_get,
+	.mac_addr_set                  = hinic_set_mac_addr,
+	.mac_addr_remove               = hinic_mac_addr_remove,
+	.mac_addr_add                  = hinic_mac_addr_add,
+	.set_mc_addr_list              = hinic_set_mc_addr_list,
+	.filter_ctrl                   = hinic_dev_filter_ctrl,
+};
+
 static int hinic_func_init(struct rte_eth_dev *eth_dev)
 {
 	struct rte_pci_device *pci_dev;
 	struct rte_ether_addr *eth_addr;
 	struct hinic_nic_dev *nic_dev;
+	struct hinic_filter_info *filter_info;
+	u32 mac_size;
 	int rc;
 
 	pci_dev = RTE_ETH_DEV_TO_PCI(eth_dev);
 
 	/* EAL is SECONDARY and eth_dev is already created */
 	if (rte_eal_process_type() != RTE_PROC_PRIMARY) {
-		rc = rte_intr_callback_register(&pci_dev->intr_handle,
-						hinic_dev_interrupt_handler,
-						(void *)eth_dev);
-		if (rc)
-			PMD_DRV_LOG(ERR, "Initialize %s failed in secondary process",
-				    eth_dev->data->name);
+		PMD_DRV_LOG(INFO, "Initialize %s in secondary process",
+			    eth_dev->data->name);
 
-		return rc;
+		return 0;
 	}
 
 	nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(eth_dev);
@@ -2137,7 +2980,8 @@ static int hinic_func_init(struct rte_eth_dev *eth_dev)
 		 pci_dev->addr.devid, pci_dev->addr.function);
 
 	/* alloc mac_addrs */
-	eth_addr = rte_zmalloc("hinic_mac", sizeof(*eth_addr), 0);
+	mac_size = HINIC_MAX_UC_MAC_ADDRS * sizeof(struct rte_ether_addr);
+	eth_addr = rte_zmalloc("hinic_mac", mac_size, 0);
 	if (!eth_addr) {
 		PMD_DRV_LOG(ERR, "Allocate ethernet addresses' memory failed, dev_name: %s",
 			    eth_dev->data->name);
@@ -2146,6 +2990,15 @@ static int hinic_func_init(struct rte_eth_dev *eth_dev)
 	}
 	eth_dev->data->mac_addrs = eth_addr;
 
+	mac_size = HINIC_MAX_MC_MAC_ADDRS * sizeof(struct rte_ether_addr);
+	nic_dev->mc_list = rte_zmalloc("hinic_mc", mac_size, 0);
+	if (!nic_dev->mc_list) {
+		PMD_DRV_LOG(ERR, "Allocate mcast address' memory failed, dev_name: %s",
+			    eth_dev->data->name);
+		rc = -ENOMEM;
+		goto mc_addr_fail;
+	}
+
 	/*
 	 * Pass the information to the rte_eth_dev_close() that it should also
 	 * release the private port resources.
@@ -2160,6 +3013,11 @@ static int hinic_func_init(struct rte_eth_dev *eth_dev)
 		goto create_nic_dev_fail;
 	}
 
+	if (HINIC_IS_VF(nic_dev->hwdev))
+		eth_dev->dev_ops = &hinic_pmd_vf_ops;
+	else
+		eth_dev->dev_ops = &hinic_pmd_ops;
+
 	rc = hinic_init_mac_addr(eth_dev);
 	if (rc) {
 		PMD_DRV_LOG(ERR, "Initialize mac table failed, dev_name: %s",
@@ -2186,6 +3044,16 @@ static int hinic_func_init(struct rte_eth_dev *eth_dev)
 	}
 	hinic_set_bit(HINIC_DEV_INTR_EN, &nic_dev->dev_status);
 
+	/* initialize filter info */
+	filter_info = &nic_dev->filter;
+	memset(filter_info, 0, sizeof(struct hinic_filter_info));
+	/* initialize 5tuple filter list */
+	TAILQ_INIT(&filter_info->fivetuple_list);
+	TAILQ_INIT(&nic_dev->filter_ntuple_list);
+	TAILQ_INIT(&nic_dev->filter_ethertype_list);
+	TAILQ_INIT(&nic_dev->filter_fdir_rule_list);
+	TAILQ_INIT(&nic_dev->hinic_flow_list);
+
 	hinic_set_bit(HINIC_DEV_INIT, &nic_dev->dev_status);
 	PMD_DRV_LOG(INFO, "Initialize %s in primary successfully",
 		    eth_dev->data->name);
@@ -2201,9 +3069,14 @@ reg_intr_cb_fail:
 	hinic_deinit_mac_addr(eth_dev);
 
 init_mac_fail:
+	eth_dev->dev_ops = NULL;
 	hinic_nic_dev_destroy(eth_dev);
 
 create_nic_dev_fail:
+	rte_free(nic_dev->mc_list);
+	nic_dev->mc_list = NULL;
+
+mc_addr_fail:
 	rte_free(eth_addr);
 	eth_dev->data->mac_addrs = NULL;
 
@@ -2213,71 +3086,6 @@ eth_addr_fail:
 	return rc;
 }
 
-/**
- * DPDK callback to close the device.
- *
- * @param dev
- *   Pointer to Ethernet device structure.
- */
-static void hinic_dev_close(struct rte_eth_dev *dev)
-{
-	struct hinic_nic_dev *nic_dev = HINIC_ETH_DEV_TO_PRIVATE_NIC_DEV(dev);
-
-	if (hinic_test_and_set_bit(HINIC_DEV_CLOSE, &nic_dev->dev_status)) {
-		PMD_DRV_LOG(WARNING, "Device %s already closed",
-			    dev->data->name);
-		return;
-	}
-
-	/* stop device first */
-	hinic_dev_stop(dev);
-
-	/* rx_cqe, rx_info */
-	hinic_free_all_rx_resources(dev);
-
-	/* tx_info */
-	hinic_free_all_tx_resources(dev);
-
-	/* free wq, pi_dma_addr */
-	hinic_free_all_rq(nic_dev);
-
-	/* free wq, db_addr */
-	hinic_free_all_sq(nic_dev);
-
-	/* deinit mac vlan tbl */
-	hinic_deinit_mac_addr(dev);
-
-	/* disable hardware and uio interrupt */
-	hinic_disable_interrupt(dev);
-
-	/* deinit nic hardware device */
-	hinic_nic_dev_destroy(dev);
-}
-
-static const struct eth_dev_ops hinic_pmd_ops = {
-	.dev_configure                 = hinic_dev_configure,
-	.dev_infos_get                 = hinic_dev_infos_get,
-	.rx_queue_setup                = hinic_rx_queue_setup,
-	.tx_queue_setup                = hinic_tx_queue_setup,
-	.dev_start                     = hinic_dev_start,
-	.link_update                   = hinic_link_update,
-	.rx_queue_release              = hinic_rx_queue_release,
-	.tx_queue_release              = hinic_tx_queue_release,
-	.dev_stop                      = hinic_dev_stop,
-	.dev_close                     = hinic_dev_close,
-	.promiscuous_enable            = hinic_dev_promiscuous_enable,
-	.promiscuous_disable           = hinic_dev_promiscuous_disable,
-	.rss_hash_update               = hinic_rss_hash_update,
-	.rss_hash_conf_get             = hinic_rss_conf_get,
-	.reta_update                   = hinic_rss_indirtbl_update,
-	.reta_query                    = hinic_rss_indirtbl_query,
-	.stats_get                     = hinic_dev_stats_get,
-	.stats_reset                   = hinic_dev_stats_reset,
-	.xstats_get                    = hinic_dev_xstats_get,
-	.xstats_reset                  = hinic_dev_xstats_reset,
-	.xstats_get_names              = hinic_dev_xstats_get_names,
-};
-
 static int hinic_dev_init(struct rte_eth_dev *eth_dev)
 {
 	struct rte_pci_device *pci_dev;
@@ -2290,8 +3098,7 @@ static int hinic_dev_init(struct rte_eth_dev *eth_dev)
 		    (rte_eal_process_type() == RTE_PROC_PRIMARY) ?
 		    "primary" : "secondary");
 
-	/* rte_eth_dev ops, rx_burst and tx_burst */
-	eth_dev->dev_ops = &hinic_pmd_ops;
+	/* rte_eth_dev rx_burst and tx_burst */
 	eth_dev->rx_pkt_burst = hinic_recv_pkts;
 	eth_dev->tx_pkt_burst = hinic_xmit_pkts;
 
@@ -2314,6 +3121,8 @@ static int hinic_dev_uninit(struct rte_eth_dev *dev)
 	dev->rx_pkt_burst = NULL;
 	dev->tx_pkt_burst = NULL;
 
+	rte_free(nic_dev->mc_list);
+
 	rte_free(dev->data->mac_addrs);
 	dev->data->mac_addrs = NULL;
 
@@ -2325,6 +3134,10 @@ static struct rte_pci_id pci_id_hinic_map[] = {
 	{ RTE_PCI_DEVICE(HINIC_HUAWEI_VENDOR_ID, HINIC_DEV_ID_MEZZ_25GE) },
 	{ RTE_PCI_DEVICE(HINIC_HUAWEI_VENDOR_ID, HINIC_DEV_ID_MEZZ_40GE) },
 	{ RTE_PCI_DEVICE(HINIC_HUAWEI_VENDOR_ID, HINIC_DEV_ID_MEZZ_100GE) },
+	{ RTE_PCI_DEVICE(HINIC_HUAWEI_VENDOR_ID, HINIC_DEV_ID_VF) },
+	{ RTE_PCI_DEVICE(HINIC_HUAWEI_VENDOR_ID, HINIC_DEV_ID_VF_HV) },
+	{ RTE_PCI_DEVICE(HINIC_HUAWEI_VENDOR_ID, HINIC_DEV_ID_1822_DUAL_25GE) },
+	{ RTE_PCI_DEVICE(HINIC_HUAWEI_VENDOR_ID, HINIC_DEV_ID_1822_100GE) },
 	{.vendor_id = 0},
 };