21 files changed, 3699 insertions, 108 deletions

diff --git a/drivers/net/ethernet/intel/ice/Makefile b/drivers/net/ethernet/intel/ice/Makefile
index 45125bd074d9..e5d6f684437e 100644
--- a/drivers/net/ethernet/intel/ice/Makefile
+++ b/drivers/net/ethernet/intel/ice/Makefile
@@ -16,3 +16,4 @@ ice-y := ice_main.o	\
          ice_lib.o      \
          ice_txrx.o     \
          ice_ethtool.o
+ice-$(CONFIG_PCI_IOV) += ice_virtchnl_pf.o ice_sriov.o
diff --git a/drivers/net/ethernet/intel/ice/ice.h b/drivers/net/ethernet/intel/ice/ice.h
index 0b269c470343..4c4b5717a627 100644
--- a/drivers/net/ethernet/intel/ice/ice.h
+++ b/drivers/net/ethernet/intel/ice/ice.h
@@ -28,6 +28,7 @@
 #include <linux/ip.h>
 #include <linux/ipv6.h>
 #include <linux/if_bridge.h>
+#include <linux/avf/virtchnl.h>
 #include <net/ipv6.h>
 #include "ice_devids.h"
 #include "ice_type.h"
@@ -35,6 +36,8 @@
 #include "ice_switch.h"
 #include "ice_common.h"
 #include "ice_sched.h"
+#include "ice_virtchnl_pf.h"
+#include "ice_sriov.h"
 
 extern const char ice_drv_ver[];
 #define ICE_BAR0                0
@@ -46,6 +49,7 @@ extern const char ice_drv_ver[];
 #define ICE_INT_NAME_STR_LEN    (IFNAMSIZ + 16)
 #define ICE_ETHTOOL_FWVER_LEN   32
 #define ICE_AQ_LEN              64
+#define ICE_MBXQ_LEN            64
 #define ICE_MIN_MSIX            2
 #define ICE_NO_VSI              0xffff
 #define ICE_MAX_VSI_ALLOC       130
@@ -63,6 +67,14 @@ extern const char ice_drv_ver[];
 #define ICE_RES_MISC_VEC_ID     (ICE_RES_VALID_BIT - 1)
 #define ICE_INVAL_Q_INDEX       0xffff
 #define ICE_INVAL_VFID          256
+#define ICE_MAX_VF_COUNT        256
+#define ICE_MAX_QS_PER_VF               256
+#define ICE_MIN_QS_PER_VF               1
+#define ICE_DFLT_QS_PER_VF              4
+#define ICE_MAX_BASE_QS_PER_VF          16
+#define ICE_MAX_INTR_PER_VF             65
+#define ICE_MIN_INTR_PER_VF             (ICE_MIN_QS_PER_VF + 1)
+#define ICE_DFLT_INTR_PER_VF            (ICE_DFLT_QS_PER_VF + 1)
 
 #define ICE_VSIQF_HKEY_ARRAY_SIZE       ((VSIQF_HKEY_MAX_INDEX + 1) *   4)
 
@@ -133,9 +145,21 @@ enum ice_state {
         __ICE_EMPR_RECV,                /* set by OICR handler */
         __ICE_SUSPENDED,                /* set on module remove path */
         __ICE_RESET_FAILED,             /* set by reset/rebuild */
+        /* When checking for the PF to be in a nominal operating state, the
+         * bits that are grouped at the beginning of the list need to be
+         * checked.  Bits occurring before __ICE_STATE_NOMINAL_CHECK_BITS will
+         * be checked.  If you need to add a bit into consideration for nominal
+         * operating state, it must be added before
+         * __ICE_STATE_NOMINAL_CHECK_BITS.  Do not move this entry's position
+         * without appropriate consideration.
+         */
+        __ICE_STATE_NOMINAL_CHECK_BITS,
         __ICE_ADMINQ_EVENT_PENDING,
+        __ICE_MAILBOXQ_EVENT_PENDING,
         __ICE_MDD_EVENT_PENDING,
+        __ICE_VFLR_EVENT_PENDING,
         __ICE_FLTR_OVERFLOW_PROMISC,
+        __ICE_VF_DIS,
         __ICE_CFG_BUSY,
         __ICE_SERVICE_SCHED,
         __ICE_SERVICE_DIS,
@@ -181,6 +205,8 @@ struct ice_vsi {
         /* Interrupt thresholds */
         u16 work_lmt;
 
+        s16 vf_id;                      /* VF ID for SR-IOV VSIs */
+
         /* RSS config */
         u16 rss_table_size;     /* HW RSS table size */
         u16 rss_size;           /* Allocated RSS queues */
@@ -240,6 +266,8 @@ enum ice_pf_flags {
         ICE_FLAG_MSIX_ENA,
         ICE_FLAG_FLTR_SYNC,
         ICE_FLAG_RSS_ENA,
+        ICE_FLAG_SRIOV_ENA,
+        ICE_FLAG_SRIOV_CAPABLE,
         ICE_PF_FLAGS_NBITS              /* must be last */
 };
 
@@ -255,6 +283,12 @@ struct ice_pf {
 
         struct ice_vsi **vsi;           /* VSIs created by the driver */
         struct ice_sw *first_sw;        /* first switch created by firmware */
+        /* Virtchnl/SR-IOV config info */
+        struct ice_vf *vf;
+        int num_alloc_vfs;              /* actual number of VFs allocated */
+        u16 num_vfs_supported;          /* num VFs supported for this PF */
+        u16 num_vf_qps;                 /* num queue pairs per VF */
+        u16 num_vf_msix;                /* num vectors per VF */
         DECLARE_BITMAP(state, __ICE_STATE_NBITS);
         DECLARE_BITMAP(avail_txqs, ICE_MAX_TXQS);
         DECLARE_BITMAP(avail_rxqs, ICE_MAX_RXQS);
diff --git a/drivers/net/ethernet/intel/ice/ice_adminq_cmd.h b/drivers/net/ethernet/intel/ice/ice_adminq_cmd.h
index c100b4bda195..6653555f55dd 100644
--- a/drivers/net/ethernet/intel/ice/ice_adminq_cmd.h
+++ b/drivers/net/ethernet/intel/ice/ice_adminq_cmd.h
@@ -87,6 +87,8 @@ struct ice_aqc_list_caps {
 /* Device/Function buffer entry, repeated per reported capability */
 struct ice_aqc_list_caps_elem {
         __le16 cap;
+#define ICE_AQC_CAPS_SRIOV                              0x0012
+#define ICE_AQC_CAPS_VF                                 0x0013
 #define ICE_AQC_CAPS_VSI                                0x0017
 #define ICE_AQC_CAPS_RSS                                0x0040
 #define ICE_AQC_CAPS_RXQS                               0x0041
@@ -1075,6 +1077,19 @@ struct ice_aqc_nvm {
         __le32 addr_low;
 };
 
+/**
+ * Send to PF command (indirect 0x0801) id is only used by PF
+ *
+ * Send to VF command (indirect 0x0802) id is only used by PF
+ *
+ */
+struct ice_aqc_pf_vf_msg {
+        __le32 id;
+        u32 reserved;
+        __le32 addr_high;
+        __le32 addr_low;
+};
+
 /* Get/Set RSS key (indirect 0x0B04/0x0B02) */
 struct ice_aqc_get_set_rss_key {
 #define ICE_AQC_GSET_RSS_KEY_VSI_VALID  BIT(15)
@@ -1332,6 +1347,7 @@ struct ice_aq_desc {
                 struct ice_aqc_query_txsched_res query_sched_res;
                 struct ice_aqc_add_move_delete_elem add_move_delete_elem;
                 struct ice_aqc_nvm nvm;
+                struct ice_aqc_pf_vf_msg virt;
                 struct ice_aqc_get_set_rss_lut get_set_rss_lut;
                 struct ice_aqc_get_set_rss_key get_set_rss_key;
                 struct ice_aqc_add_txqs add_txqs;
@@ -1429,6 +1445,10 @@ enum ice_adminq_opc {
         /* NVM commands */
         ice_aqc_opc_nvm_read                            = 0x0701,
 
+        /* PF/VF mailbox commands */
+        ice_mbx_opc_send_msg_to_pf                      = 0x0801,
+        ice_mbx_opc_send_msg_to_vf                      = 0x0802,
+
         /* RSS commands */
         ice_aqc_opc_set_rss_key                         = 0x0B02,
         ice_aqc_opc_set_rss_lut                         = 0x0B03,
diff --git a/drivers/net/ethernet/intel/ice/ice_common.c b/drivers/net/ethernet/intel/ice/ice_common.c
index 68fbbb92d504..c52f450f2c0d 100644
--- a/drivers/net/ethernet/intel/ice/ice_common.c
+++ b/drivers/net/ethernet/intel/ice/ice_common.c
@@ -1406,6 +1406,28 @@ ice_parse_caps(struct ice_hw *hw, void *buf, u32 cap_count,
                 u16 cap = le16_to_cpu(cap_resp->cap);
 
                 switch (cap) {
+                case ICE_AQC_CAPS_SRIOV:
+                        caps->sr_iov_1_1 = (number == 1);
+                        ice_debug(hw, ICE_DBG_INIT,
+                                  "HW caps: SR-IOV = %d\n", caps->sr_iov_1_1);
+                        break;
+                case ICE_AQC_CAPS_VF:
+                        if (dev_p) {
+                                dev_p->num_vfs_exposed = number;
+                                ice_debug(hw, ICE_DBG_INIT,
+                                          "HW caps: VFs exposed = %d\n",
+                                          dev_p->num_vfs_exposed);
+                        } else if (func_p) {
+                                func_p->num_allocd_vfs = number;
+                                func_p->vf_base_id = logical_id;
+                                ice_debug(hw, ICE_DBG_INIT,
+                                          "HW caps: VFs allocated = %d\n",
+                                          func_p->num_allocd_vfs);
+                                ice_debug(hw, ICE_DBG_INIT,
+                                          "HW caps: VF base_id = %d\n",
+                                          func_p->vf_base_id);
+                        }
+                        break;
                 case ICE_AQC_CAPS_VSI:
                         if (dev_p) {
                                 dev_p->num_vsi_allocd_to_host = number;
@@ -2265,6 +2287,8 @@ ice_aq_add_lan_txq(struct ice_hw *hw, u8 num_qgrps,
  * @num_qgrps: number of groups in the list
  * @qg_list: the list of groups to disable
  * @buf_size: the total size of the qg_list buffer in bytes
+ * @rst_src: if called due to reset, specifies the RST source
+ * @vmvf_num: the relative VM or VF number that is undergoing the reset
  * @cd: pointer to command details structure or NULL
  *
  * Disable LAN Tx queue (0x0C31)
@@ -2272,6 +2296,7 @@ ice_aq_add_lan_txq(struct ice_hw *hw, u8 num_qgrps,
 static enum ice_status
 ice_aq_dis_lan_txq(struct ice_hw *hw, u8 num_qgrps,
                    struct ice_aqc_dis_txq_item *qg_list, u16 buf_size,
+                   enum ice_disq_rst_src rst_src, u16 vmvf_num,
                    struct ice_sq_cd *cd)
 {
         struct ice_aqc_dis_txqs *cmd;
@@ -2281,14 +2306,45 @@ ice_aq_dis_lan_txq(struct ice_hw *hw, u8 num_qgrps,
         cmd = &desc.params.dis_txqs;
         ice_fill_dflt_direct_cmd_desc(&desc, ice_aqc_opc_dis_txqs);
 
-        if (!qg_list)
+        /* qg_list can be NULL only in VM/VF reset flow */
+        if (!qg_list && !rst_src)
                 return ICE_ERR_PARAM;
 
         if (num_qgrps > ICE_LAN_TXQ_MAX_QGRPS)
                 return ICE_ERR_PARAM;
-        desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);
+
         cmd->num_entries = num_qgrps;
 
+        cmd->vmvf_and_timeout = cpu_to_le16((5 << ICE_AQC_Q_DIS_TIMEOUT_S) &
+                                            ICE_AQC_Q_DIS_TIMEOUT_M);
+
+        switch (rst_src) {
+        case ICE_VM_RESET:
+                cmd->cmd_type = ICE_AQC_Q_DIS_CMD_VM_RESET;
+                cmd->vmvf_and_timeout |=
+                        cpu_to_le16(vmvf_num & ICE_AQC_Q_DIS_VMVF_NUM_M);
+                break;
+        case ICE_VF_RESET:
+                cmd->cmd_type = ICE_AQC_Q_DIS_CMD_VF_RESET;
+                /* In this case, FW expects vmvf_num to be absolute VF id */
+                cmd->vmvf_and_timeout |=
+                        cpu_to_le16((vmvf_num + hw->func_caps.vf_base_id) &
+                                    ICE_AQC_Q_DIS_VMVF_NUM_M);
+                break;
+        case ICE_NO_RESET:
+        default:
+                break;
+        }
+
+        /* If no queue group info, we are in a reset flow. Issue the AQ */
+        if (!qg_list)
+                goto do_aq;
+
+        /* set RD bit to indicate that command buffer is provided by the driver
+         * and it needs to be read by the firmware
+         */
+        desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);
+
         for (i = 0; i < num_qgrps; ++i) {
                 /* Calculate the size taken up by the queue IDs in this group */
                 sz += qg_list[i].num_qs * sizeof(qg_list[i].q_id);
@@ -2304,6 +2360,7 @@ ice_aq_dis_lan_txq(struct ice_hw *hw, u8 num_qgrps,
         if (buf_size != sz)
                 return ICE_ERR_PARAM;
 
+do_aq:
         return ice_aq_send_cmd(hw, &desc, qg_list, buf_size, cd);
 }
 
@@ -2610,13 +2667,16 @@ ena_txq_exit:
  * @num_queues: number of queues
  * @q_ids: pointer to the q_id array
  * @q_teids: pointer to queue node teids
+ * @rst_src: if called due to reset, specifies the RST source
+ * @vmvf_num: the relative VM or VF number that is undergoing the reset
  * @cd: pointer to command details structure or NULL
  *
  * This function removes queues and their corresponding nodes in SW DB
  */
 enum ice_status
 ice_dis_vsi_txq(struct ice_port_info *pi, u8 num_queues, u16 *q_ids,
-                u32 *q_teids, struct ice_sq_cd *cd)
+                u32 *q_teids, enum ice_disq_rst_src rst_src, u16 vmvf_num,
+                struct ice_sq_cd *cd)
 {
         enum ice_status status = ICE_ERR_DOES_NOT_EXIST;
         struct ice_aqc_dis_txq_item qg_list;
@@ -2625,6 +2685,15 @@ ice_dis_vsi_txq(struct ice_port_info *pi, u8 num_queues, u16 *q_ids,
         if (!pi || pi->port_state != ICE_SCHED_PORT_STATE_READY)
                 return ICE_ERR_CFG;
 
+        /* if queue is disabled already yet the disable queue command has to be
+         * sent to complete the VF reset, then call ice_aq_dis_lan_txq without
+         * any queue information
+         */
+
+        if (!num_queues && rst_src)
+                return ice_aq_dis_lan_txq(pi->hw, 0, NULL, 0, rst_src, vmvf_num,
+                                          NULL);
+
         mutex_lock(&pi->sched_lock);
 
         for (i = 0; i < num_queues; i++) {
@@ -2637,7 +2706,8 @@ ice_dis_vsi_txq(struct ice_port_info *pi, u8 num_queues, u16 *q_ids,
                 qg_list.num_qs = 1;
                 qg_list.q_id[0] = cpu_to_le16(q_ids[i]);
                 status = ice_aq_dis_lan_txq(pi->hw, 1, &qg_list,
-                                            sizeof(qg_list), cd);
+                                            sizeof(qg_list), rst_src, vmvf_num,
+                                            cd);
 
                 if (status)
                         break;
diff --git a/drivers/net/ethernet/intel/ice/ice_common.h b/drivers/net/ethernet/intel/ice/ice_common.h
index 7b2a5bb2e550..1900681289a4 100644
--- a/drivers/net/ethernet/intel/ice/ice_common.h
+++ b/drivers/net/ethernet/intel/ice/ice_common.h
@@ -7,6 +7,7 @@
 #include "ice.h"
 #include "ice_type.h"
 #include "ice_switch.h"
+#include <linux/avf/virtchnl.h>
 
 void ice_debug_cq(struct ice_hw *hw, u32 mask, void *desc, void *buf,
                   u16 buf_len);
@@ -89,7 +90,8 @@ ice_aq_set_event_mask(struct ice_hw *hw, u8 port_num, u16 mask,
                       struct ice_sq_cd *cd);
 enum ice_status
 ice_dis_vsi_txq(struct ice_port_info *pi, u8 num_queues, u16 *q_ids,
-                u32 *q_teids, struct ice_sq_cd *cmd_details);
+                u32 *q_teids, enum ice_disq_rst_src rst_src, u16 vmvf_num,
+                struct ice_sq_cd *cmd_details);
 enum ice_status
 ice_cfg_vsi_lan(struct ice_port_info *pi, u16 vsi_handle, u8 tc_bitmap,
                 u16 *max_lanqs);
diff --git a/drivers/net/ethernet/intel/ice/ice_controlq.c b/drivers/net/ethernet/intel/ice/ice_controlq.c
index b25ce4f587f5..84c967294eaf 100644
--- a/drivers/net/ethernet/intel/ice/ice_controlq.c
+++ b/drivers/net/ethernet/intel/ice/ice_controlq.c
@@ -33,6 +33,36 @@ static void ice_adminq_init_regs(struct ice_hw *hw)
 }
 
 /**
+ * ice_mailbox_init_regs - Initialize Mailbox registers
+ * @hw: pointer to the hardware structure
+ *
+ * This assumes the alloc_sq and alloc_rq functions have already been called
+ */
+static void ice_mailbox_init_regs(struct ice_hw *hw)
+{
+        struct ice_ctl_q_info *cq = &hw->mailboxq;
+
+        /* set head and tail registers in our local struct */
+        cq->sq.head = PF_MBX_ATQH;
+        cq->sq.tail = PF_MBX_ATQT;
+        cq->sq.len = PF_MBX_ATQLEN;
+        cq->sq.bah = PF_MBX_ATQBAH;
+        cq->sq.bal = PF_MBX_ATQBAL;
+        cq->sq.len_mask = PF_MBX_ATQLEN_ATQLEN_M;
+        cq->sq.len_ena_mask = PF_MBX_ATQLEN_ATQENABLE_M;
+        cq->sq.head_mask = PF_MBX_ATQH_ATQH_M;
+
+        cq->rq.head = PF_MBX_ARQH;
+        cq->rq.tail = PF_MBX_ARQT;
+        cq->rq.len = PF_MBX_ARQLEN;
+        cq->rq.bah = PF_MBX_ARQBAH;
+        cq->rq.bal = PF_MBX_ARQBAL;
+        cq->rq.len_mask = PF_MBX_ARQLEN_ARQLEN_M;
+        cq->rq.len_ena_mask = PF_MBX_ARQLEN_ARQENABLE_M;
+        cq->rq.head_mask = PF_MBX_ARQH_ARQH_M;
+}
+
+/**
  * ice_check_sq_alive
  * @hw: pointer to the hw struct
  * @cq: pointer to the specific Control queue
@@ -639,6 +669,10 @@ static enum ice_status ice_init_ctrlq(struct ice_hw *hw, enum ice_ctl_q q_type)
                 ice_adminq_init_regs(hw);
                 cq = &hw->adminq;
                 break;
+        case ICE_CTL_Q_MAILBOX:
+                ice_mailbox_init_regs(hw);
+                cq = &hw->mailboxq;
+                break;
         default:
                 return ICE_ERR_PARAM;
         }
@@ -696,7 +730,12 @@ enum ice_status ice_init_all_ctrlq(struct ice_hw *hw)
         if (ret_code)
                 return ret_code;
 
-        return ice_init_check_adminq(hw);
+        ret_code = ice_init_check_adminq(hw);
+        if (ret_code)
+                return ret_code;
+
+        /* Init Mailbox queue */
+        return ice_init_ctrlq(hw, ICE_CTL_Q_MAILBOX);
 }
 
 /**
@@ -714,6 +753,9 @@ static void ice_shutdown_ctrlq(struct ice_hw *hw, enum ice_ctl_q q_type)
                 if (ice_check_sq_alive(hw, cq))
                         ice_aq_q_shutdown(hw, true);
                 break;
+        case ICE_CTL_Q_MAILBOX:
+                cq = &hw->mailboxq;
+                break;
         default:
                 return;
         }
@@ -736,6 +778,8 @@ void ice_shutdown_all_ctrlq(struct ice_hw *hw)
 {
         /* Shutdown FW admin queue */
         ice_shutdown_ctrlq(hw, ICE_CTL_Q_ADMIN);
+        /* Shutdown PF-VF Mailbox */
+        ice_shutdown_ctrlq(hw, ICE_CTL_Q_MAILBOX);
 }
 
 /**
diff --git a/drivers/net/ethernet/intel/ice/ice_controlq.h b/drivers/net/ethernet/intel/ice/ice_controlq.h
index ea02b89243e2..437f832fd7c4 100644
--- a/drivers/net/ethernet/intel/ice/ice_controlq.h
+++ b/drivers/net/ethernet/intel/ice/ice_controlq.h
@@ -8,6 +8,7 @@
 
 /* Maximum buffer lengths for all control queue types */
 #define ICE_AQ_MAX_BUF_LEN 4096
+#define ICE_MBXQ_MAX_BUF_LEN 4096
 
 #define ICE_CTL_Q_DESC(R, i) \
         (&(((struct ice_aq_desc *)((R).desc_buf.va))[i]))
@@ -28,6 +29,7 @@
 enum ice_ctl_q {
         ICE_CTL_Q_UNKNOWN = 0,
         ICE_CTL_Q_ADMIN,
+        ICE_CTL_Q_MAILBOX,
 };
 
 /* Control Queue default settings */
diff --git a/drivers/net/ethernet/intel/ice/ice_hw_autogen.h b/drivers/net/ethernet/intel/ice/ice_hw_autogen.h
index 9a78d83eaa3e..a6679a9bfd3a 100644
--- a/drivers/net/ethernet/intel/ice/ice_hw_autogen.h
+++ b/drivers/net/ethernet/intel/ice/ice_hw_autogen.h
@@ -29,6 +29,22 @@
 #define PF_FW_ATQLEN_ATQCRIT_M                  BIT(30)
 #define PF_FW_ATQLEN_ATQENABLE_M                BIT(31)
 #define PF_FW_ATQT                              0x00080400
+#define PF_MBX_ARQBAH                           0x0022E400
+#define PF_MBX_ARQBAL                           0x0022E380
+#define PF_MBX_ARQH                             0x0022E500
+#define PF_MBX_ARQH_ARQH_M                      ICE_M(0x3FF, 0)
+#define PF_MBX_ARQLEN                           0x0022E480
+#define PF_MBX_ARQLEN_ARQLEN_M                  ICE_M(0x3FF, 0)
+#define PF_MBX_ARQLEN_ARQENABLE_M               BIT(31)
+#define PF_MBX_ARQT                             0x0022E580
+#define PF_MBX_ATQBAH                           0x0022E180
+#define PF_MBX_ATQBAL                           0x0022E100
+#define PF_MBX_ATQH                             0x0022E280
+#define PF_MBX_ATQH_ATQH_M                      ICE_M(0x3FF, 0)
+#define PF_MBX_ATQLEN                           0x0022E200
+#define PF_MBX_ATQLEN_ATQLEN_M                  ICE_M(0x3FF, 0)
+#define PF_MBX_ATQLEN_ATQENABLE_M               BIT(31)
+#define PF_MBX_ATQT                             0x0022E300
 #define GLFLXP_RXDID_FLAGS(_i, _j)              (0x0045D000 + ((_i) * 4 + (_j) * 256))
 #define GLFLXP_RXDID_FLAGS_FLEXIFLAG_4N_S       0
 #define GLFLXP_RXDID_FLAGS_FLEXIFLAG_4N_M       ICE_M(0x3F, 0)
@@ -74,10 +90,16 @@
 #define GLGEN_RTRIG_CORER_M                     BIT(0)
 #define GLGEN_RTRIG_GLOBR_M                     BIT(1)
 #define GLGEN_STAT                              0x000B612C
+#define GLGEN_VFLRSTAT(_i)                      (0x00093A04 + ((_i) * 4))
 #define PFGEN_CTRL                              0x00091000
 #define PFGEN_CTRL_PFSWR_M                      BIT(0)
 #define PFGEN_STATE                             0x00088000
 #define PRTGEN_STATUS                           0x000B8100
+#define VFGEN_RSTAT(_VF)                        (0x00074000 + ((_VF) * 4))
+#define VPGEN_VFRSTAT(_VF)                      (0x00090800 + ((_VF) * 4))
+#define VPGEN_VFRSTAT_VFRD_M                    BIT(0)
+#define VPGEN_VFRTRIG(_VF)                      (0x00090000 + ((_VF) * 4))
+#define VPGEN_VFRTRIG_VFSWR_M                   BIT(0)
 #define PFHMC_ERRORDATA                         0x00520500
 #define PFHMC_ERRORINFO                         0x00520400
 #define GLINT_DYN_CTL(_INT)                     (0x00160000 + ((_INT) * 4))
@@ -90,11 +112,23 @@
 #define GLINT_ITR(_i, _INT)                     (0x00154000 + ((_i) * 8192 + (_INT) * 4))
 #define GLINT_RATE(_INT)                        (0x0015A000 + ((_INT) * 4))
 #define GLINT_RATE_INTRL_ENA_M                  BIT(6)
+#define GLINT_VECT2FUNC(_INT)                   (0x00162000 + ((_INT) * 4))
+#define GLINT_VECT2FUNC_VF_NUM_S                0
+#define GLINT_VECT2FUNC_VF_NUM_M                ICE_M(0xFF, 0)
+#define GLINT_VECT2FUNC_PF_NUM_S                12
+#define GLINT_VECT2FUNC_PF_NUM_M                ICE_M(0x7, 12)
+#define GLINT_VECT2FUNC_IS_PF_S                 16
+#define GLINT_VECT2FUNC_IS_PF_M                 BIT(16)
 #define PFINT_FW_CTL                            0x0016C800
 #define PFINT_FW_CTL_MSIX_INDX_M                ICE_M(0x7FF, 0)
 #define PFINT_FW_CTL_ITR_INDX_S                 11
 #define PFINT_FW_CTL_ITR_INDX_M                 ICE_M(0x3, 11)
 #define PFINT_FW_CTL_CAUSE_ENA_M                BIT(30)
+#define PFINT_MBX_CTL                           0x0016B280
+#define PFINT_MBX_CTL_MSIX_INDX_M               ICE_M(0x7FF, 0)
+#define PFINT_MBX_CTL_ITR_INDX_S                11
+#define PFINT_MBX_CTL_ITR_INDX_M                ICE_M(0x3, 11)
+#define PFINT_MBX_CTL_CAUSE_ENA_M               BIT(30)
 #define PFINT_OICR                              0x0016CA00
 #define PFINT_OICR_ECC_ERR_M                    BIT(16)
 #define PFINT_OICR_MAL_DETECT_M                 BIT(19)
@@ -102,6 +136,7 @@
 #define PFINT_OICR_PCI_EXCEPTION_M              BIT(21)
 #define PFINT_OICR_HMC_ERR_M                    BIT(26)
 #define PFINT_OICR_PE_CRITERR_M                 BIT(28)
+#define PFINT_OICR_VFLR_M                       BIT(29)
 #define PFINT_OICR_CTL                          0x0016CA80
 #define PFINT_OICR_CTL_MSIX_INDX_M              ICE_M(0x7FF, 0)
 #define PFINT_OICR_CTL_ITR_INDX_S               11
@@ -116,6 +151,12 @@
 #define QINT_TQCTL_MSIX_INDX_S                  0
 #define QINT_TQCTL_ITR_INDX_S                   11
 #define QINT_TQCTL_CAUSE_ENA_M                  BIT(30)
+#define VPINT_ALLOC(_VF)                        (0x001D1000 + ((_VF) * 4))
+#define VPINT_ALLOC_FIRST_S                     0
+#define VPINT_ALLOC_FIRST_M                     ICE_M(0x7FF, 0)
+#define VPINT_ALLOC_LAST_S                      12
+#define VPINT_ALLOC_LAST_M                      ICE_M(0x7FF, 12)
+#define VPINT_ALLOC_VALID_M                     BIT(31)
 #define QRX_CONTEXT(_i, _QRX)                   (0x00280000 + ((_i) * 8192 + (_QRX) * 4))
 #define QRX_CTRL(_QRX)                          (0x00120000 + ((_QRX) * 4))
 #define QRX_CTRL_MAX_INDEX                      2047
@@ -128,6 +169,20 @@
 #define QRX_TAIL_MAX_INDEX                      2047
 #define QRX_TAIL_TAIL_S                         0
 #define QRX_TAIL_TAIL_M                         ICE_M(0x1FFF, 0)
+#define VPLAN_RX_QBASE(_VF)                     (0x00072000 + ((_VF) * 4))
+#define VPLAN_RX_QBASE_VFFIRSTQ_S               0
+#define VPLAN_RX_QBASE_VFFIRSTQ_M               ICE_M(0x7FF, 0)
+#define VPLAN_RX_QBASE_VFNUMQ_S                 16
+#define VPLAN_RX_QBASE_VFNUMQ_M                 ICE_M(0xFF, 16)
+#define VPLAN_RXQ_MAPENA(_VF)                   (0x00073000 + ((_VF) * 4))
+#define VPLAN_RXQ_MAPENA_RX_ENA_M               BIT(0)
+#define VPLAN_TX_QBASE(_VF)                     (0x001D1800 + ((_VF) * 4))
+#define VPLAN_TX_QBASE_VFFIRSTQ_S               0
+#define VPLAN_TX_QBASE_VFFIRSTQ_M               ICE_M(0x3FFF, 0)
+#define VPLAN_TX_QBASE_VFNUMQ_S                 16
+#define VPLAN_TX_QBASE_VFNUMQ_M                 ICE_M(0xFF, 16)
+#define VPLAN_TXQ_MAPENA(_VF)                   (0x00073800 + ((_VF) * 4))
+#define VPLAN_TXQ_MAPENA_TX_ENA_M               BIT(0)
 #define GL_MDET_RX                              0x00294C00
 #define GL_MDET_RX_QNUM_S                       0
 #define GL_MDET_RX_QNUM_M                       ICE_M(0x7FFF, 0)
@@ -164,6 +219,14 @@
 #define PF_MDET_TX_PQM_VALID_M                  BIT(0)
 #define PF_MDET_TX_TCLAN                        0x000FC000
 #define PF_MDET_TX_TCLAN_VALID_M                BIT(0)
+#define VP_MDET_RX(_VF)                         (0x00294400 + ((_VF) * 4))
+#define VP_MDET_RX_VALID_M                      BIT(0)
+#define VP_MDET_TX_PQM(_VF)                     (0x002D2000 + ((_VF) * 4))
+#define VP_MDET_TX_PQM_VALID_M                  BIT(0)
+#define VP_MDET_TX_TCLAN(_VF)                   (0x000FB800 + ((_VF) * 4))
+#define VP_MDET_TX_TCLAN_VALID_M                BIT(0)
+#define VP_MDET_TX_TDPU(_VF)                    (0x00040000 + ((_VF) * 4))
+#define VP_MDET_TX_TDPU_VALID_M                 BIT(0)
 #define GLNVM_FLA                               0x000B6108
 #define GLNVM_FLA_LOCKED_M                      BIT(6)
 #define GLNVM_GENS                              0x000B6100
@@ -175,6 +238,9 @@
 #define PF_FUNC_RID                             0x0009E880
 #define PF_FUNC_RID_FUNC_NUM_S                  0
 #define PF_FUNC_RID_FUNC_NUM_M                  ICE_M(0x7, 0)
+#define PF_PCI_CIAA                             0x0009E580
+#define PF_PCI_CIAA_VF_NUM_S                    12
+#define PF_PCI_CIAD                             0x0009E500
 #define GL_PWR_MODE_CTL                         0x000B820C
 #define GL_PWR_MODE_CTL_CAR_MAX_BW_S            30
 #define GL_PWR_MODE_CTL_CAR_MAX_BW_M            ICE_M(0x3, 30)
@@ -255,5 +321,8 @@
 #define GLV_UPTCH(_i)                           (0x0030A004 + ((_i) * 8))
 #define GLV_UPTCL(_i)                           (0x0030A000 + ((_i) * 8))
 #define VSIQF_HKEY_MAX_INDEX                    12
+#define VSIQF_HLUT_MAX_INDEX                    15
+#define VFINT_DYN_CTLN(_i)                      (0x00003800 + ((_i) * 4))
+#define VFINT_DYN_CTLN_CLEARPBA_M               BIT(1)
 
 #endif /* _ICE_HW_AUTOGEN_H_ */
diff --git a/drivers/net/ethernet/intel/ice/ice_lan_tx_rx.h b/drivers/net/ethernet/intel/ice/ice_lan_tx_rx.h
index 94504023d86e..7d2a66739e3f 100644
--- a/drivers/net/ethernet/intel/ice/ice_lan_tx_rx.h
+++ b/drivers/net/ethernet/intel/ice/ice_lan_tx_rx.h
@@ -418,6 +418,7 @@ struct ice_tlan_ctx {
         u8  pf_num;
         u16 vmvf_num;
         u8  vmvf_type;
+#define ICE_TLAN_CTX_VMVF_TYPE_VF       0
 #define ICE_TLAN_CTX_VMVF_TYPE_VMQ      1
 #define ICE_TLAN_CTX_VMVF_TYPE_PF       2
         u16 src_vsi;
@@ -473,4 +474,16 @@ static inline struct ice_rx_ptype_decoded ice_decode_rx_desc_ptype(u16 ptype)
 {
         return ice_ptype_lkup[ptype];
 }
+
+#define ICE_LINK_SPEED_UNKNOWN          0
+#define ICE_LINK_SPEED_10MBPS           10
+#define ICE_LINK_SPEED_100MBPS          100
+#define ICE_LINK_SPEED_1000MBPS         1000
+#define ICE_LINK_SPEED_2500MBPS         2500
+#define ICE_LINK_SPEED_5000MBPS         5000
+#define ICE_LINK_SPEED_10000MBPS        10000
+#define ICE_LINK_SPEED_20000MBPS        20000
+#define ICE_LINK_SPEED_25000MBPS        25000
+#define ICE_LINK_SPEED_40000MBPS        40000
+
 #endif /* _ICE_LAN_TX_RX_H_ */
diff --git a/drivers/net/ethernet/intel/ice/ice_lib.c b/drivers/net/ethernet/intel/ice/ice_lib.c
index acf3478a3f3b..49f1940772ed 100644
--- a/drivers/net/ethernet/intel/ice/ice_lib.c
+++ b/drivers/net/ethernet/intel/ice/ice_lib.c
@@ -68,18 +68,20 @@ static int ice_setup_rx_ctx(struct ice_ring *ring)
          /* Enable Flexible Descriptors in the queue context which
           * allows this driver to select a specific receive descriptor format
           */
-        regval = rd32(hw, QRXFLXP_CNTXT(pf_q));
-        regval |= (rxdid << QRXFLXP_CNTXT_RXDID_IDX_S) &
-                QRXFLXP_CNTXT_RXDID_IDX_M;
-
-        /* increasing context priority to pick up profile id;
-         * default is 0x01; setting to 0x03 to ensure profile
-         * is programming if prev context is of same priority
-         */
-        regval |= (0x03 << QRXFLXP_CNTXT_RXDID_PRIO_S) &
-                QRXFLXP_CNTXT_RXDID_PRIO_M;
+        if (vsi->type != ICE_VSI_VF) {
+                regval = rd32(hw, QRXFLXP_CNTXT(pf_q));
+                regval |= (rxdid << QRXFLXP_CNTXT_RXDID_IDX_S) &
+                        QRXFLXP_CNTXT_RXDID_IDX_M;
+
+                /* increasing context priority to pick up profile id;
+                 * default is 0x01; setting to 0x03 to ensure profile
+                 * is programming if prev context is of same priority
+                 */
+                regval |= (0x03 << QRXFLXP_CNTXT_RXDID_PRIO_S) &
+                        QRXFLXP_CNTXT_RXDID_PRIO_M;
 
-        wr32(hw, QRXFLXP_CNTXT(pf_q), regval);
+                wr32(hw, QRXFLXP_CNTXT(pf_q), regval);
+        }
 
         /* Absolute queue number out of 2K needs to be passed */
         err = ice_write_rxq_ctx(hw, &rlan_ctx, pf_q);
@@ -90,6 +92,9 @@ static int ice_setup_rx_ctx(struct ice_ring *ring)
                 return -EIO;
         }
 
+        if (vsi->type == ICE_VSI_VF)
+                return 0;
+
         /* init queue specific tail register */
         ring->tail = hw->hw_addr + QRX_TAIL(pf_q);
         writel(0, ring->tail);
@@ -132,6 +137,11 @@ ice_setup_tx_ctx(struct ice_ring *ring, struct ice_tlan_ctx *tlan_ctx, u16 pf_q)
         case ICE_VSI_PF:
                 tlan_ctx->vmvf_type = ICE_TLAN_CTX_VMVF_TYPE_PF;
                 break;
+        case ICE_VSI_VF:
+                /* Firmware expects vmvf_num to be absolute VF id */
+                tlan_ctx->vmvf_num = hw->func_caps.vf_base_id + vsi->vf_id;
+                tlan_ctx->vmvf_type = ICE_TLAN_CTX_VMVF_TYPE_VF;
+                break;
         default:
                 return;
         }
@@ -285,6 +295,16 @@ static void ice_vsi_set_num_qs(struct ice_vsi *vsi)
                 vsi->num_desc = ALIGN(ICE_DFLT_NUM_DESC, ICE_REQ_DESC_MULTIPLE);
                 vsi->num_q_vectors = max_t(int, pf->num_lan_rx, pf->num_lan_tx);
                 break;
+        case ICE_VSI_VF:
+                vsi->alloc_txq = pf->num_vf_qps;
+                vsi->alloc_rxq = pf->num_vf_qps;
+                /* pf->num_vf_msix includes (VF miscellaneous vector +
+                 * data queue interrupts). Since vsi->num_q_vectors is number
+                 * of queues vectors, subtract 1 from the original vector
+                 * count
+                 */
+                vsi->num_q_vectors = pf->num_vf_msix - 1;
+                break;
         default:
                 dev_warn(&vsi->back->pdev->dev, "Unknown VSI type %d\n",
                          vsi->type);
@@ -331,6 +351,8 @@ void ice_vsi_delete(struct ice_vsi *vsi)
         struct ice_vsi_ctx ctxt;
         enum ice_status status;
 
+        if (vsi->type == ICE_VSI_VF)
+                ctxt.vf_num = vsi->vf_id;
         ctxt.vsi_num = vsi->vsi_num;
 
         memcpy(&ctxt.info, &vsi->info, sizeof(struct ice_aqc_vsi_props));
@@ -466,6 +488,10 @@ static struct ice_vsi *ice_vsi_alloc(struct ice_pf *pf, enum ice_vsi_type type)
                 /* Setup default MSIX irq handler for VSI */
                 vsi->irq_handler = ice_msix_clean_rings;
                 break;
+        case ICE_VSI_VF:
+                if (ice_vsi_alloc_arrays(vsi, true))
+                        goto err_rings;
+                break;
         default:
                 dev_warn(&pf->pdev->dev, "Unknown VSI type %d\n", vsi->type);
                 goto unlock_pf;
@@ -685,6 +711,15 @@ static void ice_vsi_set_rss_params(struct ice_vsi *vsi)
                                       BIT(cap->rss_table_entry_width));
                 vsi->rss_lut_type = ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_PF;
                 break;
+        case ICE_VSI_VF:
+                /* VF VSI will gets a small RSS table
+                 * For VSI_LUT, LUT size should be set to 64 bytes
+                 */
+                vsi->rss_table_size = ICE_VSIQF_HLUT_ARRAY_SIZE;
+                vsi->rss_size = min_t(int, num_online_cpus(),
+                                      BIT(cap->rss_table_entry_width));
+                vsi->rss_lut_type = ICE_AQC_GSET_RSS_LUT_TABLE_TYPE_VSI;
+                break;
         default:
                 dev_warn(&pf->pdev->dev, "Unknown VSI type %d\n",
                          vsi->type);
@@ -773,17 +808,17 @@ static void ice_vsi_setup_q_map(struct ice_vsi *vsi, struct ice_vsi_ctx *ctxt)
          * Setup number and offset of Rx queues for all TCs for the VSI
          */
 
+        qcount = numq_tc;
         /* qcount will change if RSS is enabled */
         if (test_bit(ICE_FLAG_RSS_ENA, vsi->back->flags)) {
-                if (vsi->type == ICE_VSI_PF)
-                        max_rss = ICE_MAX_LG_RSS_QS;
-                else
-                        max_rss = ICE_MAX_SMALL_RSS_QS;
-
-                qcount = min_t(int, numq_tc, max_rss);
-                qcount = min_t(int, qcount, vsi->rss_size);
-        } else {
-                qcount = numq_tc;
+                if (vsi->type == ICE_VSI_PF || vsi->type == ICE_VSI_VF) {
+                        if (vsi->type == ICE_VSI_PF)
+                                max_rss = ICE_MAX_LG_RSS_QS;
+                        else
+                                max_rss = ICE_MAX_SMALL_RSS_QS;
+                        qcount = min_t(int, numq_tc, max_rss);
+                        qcount = min_t(int, qcount, vsi->rss_size);
+                }
         }
 
         /* find the (rounded up) power-of-2 of qcount */
@@ -813,6 +848,14 @@ static void ice_vsi_setup_q_map(struct ice_vsi *vsi, struct ice_vsi_ctx *ctxt)
         vsi->num_txq = qcount_tx;
         vsi->num_rxq = offset;
 
+        if (vsi->type == ICE_VSI_VF && vsi->num_txq != vsi->num_rxq) {
+                dev_dbg(&vsi->back->pdev->dev, "VF VSI should have same number of Tx and Rx queues. Hence making them equal\n");
+                /* since there is a chance that num_rxq could have been changed
+                 * in the above for loop, make num_txq equal to num_rxq.
+                 */
+                vsi->num_txq = vsi->num_rxq;
+        }
+
         /* Rx queue mapping */
         ctxt->info.mapping_flags |= cpu_to_le16(ICE_AQ_VSI_Q_MAP_CONTIG);
         /* q_mapping buffer holds the info for the first queue allocated for
@@ -838,6 +881,11 @@ static void ice_set_rss_vsi_ctx(struct ice_vsi_ctx *ctxt, struct ice_vsi *vsi)
                 lut_type = ICE_AQ_VSI_Q_OPT_RSS_LUT_PF;
                 hash_type = ICE_AQ_VSI_Q_OPT_RSS_TPLZ;
                 break;
+        case ICE_VSI_VF:
+                /* VF VSI will gets a small RSS table which is a VSI LUT type */
+                lut_type = ICE_AQ_VSI_Q_OPT_RSS_LUT_VSI;
+                hash_type = ICE_AQ_VSI_Q_OPT_RSS_TPLZ;
+                break;
         default:
                 dev_warn(&vsi->back->pdev->dev, "Unknown VSI type %d\n",
                          vsi->type);
@@ -868,6 +916,11 @@ static int ice_vsi_init(struct ice_vsi *vsi)
         case ICE_VSI_PF:
                 ctxt.flags = ICE_AQ_VSI_TYPE_PF;
                 break;
+        case ICE_VSI_VF:
+                ctxt.flags = ICE_AQ_VSI_TYPE_VF;
+                /* VF number here is the absolute VF number (0-255) */
+                ctxt.vf_num = vsi->vf_id + hw->func_caps.vf_base_id;
+                break;
         default:
                 return -ENODEV;
         }
@@ -961,6 +1014,8 @@ static int ice_vsi_alloc_q_vector(struct ice_vsi *vsi, int v_idx)
 
         q_vector->vsi = vsi;
         q_vector->v_idx = v_idx;
+        if (vsi->type == ICE_VSI_VF)
+                goto out;
         /* only set affinity_mask if the CPU is online */
         if (cpu_online(v_idx))
                 cpumask_set_cpu(v_idx, &q_vector->affinity_mask);
@@ -973,6 +1028,7 @@ static int ice_vsi_alloc_q_vector(struct ice_vsi *vsi, int v_idx)
                 netif_napi_add(vsi->netdev, &q_vector->napi, ice_napi_poll,
                                NAPI_POLL_WEIGHT);
 
+out:
         /* tie q_vector and VSI together */
         vsi->q_vectors[v_idx] = q_vector;
 
@@ -1067,6 +1123,13 @@ static int ice_vsi_setup_vector_base(struct ice_vsi *vsi)
                 vsi->hw_base_vector = ice_get_res(pf, pf->hw_irq_tracker,
                                                   num_q_vectors, vsi->idx);
                 break;
+        case ICE_VSI_VF:
+                /* take VF misc vector and data vectors into account */
+                num_q_vectors = pf->num_vf_msix;
+                /* For VF VSI, reserve slots only from HW interrupts */
+                vsi->hw_base_vector = ice_get_res(pf, pf->hw_irq_tracker,
+                                                  num_q_vectors, vsi->idx);
+                break;
         default:
                 dev_warn(&vsi->back->pdev->dev, "Unknown VSI type %d\n",
                          vsi->type);
@@ -1077,9 +1140,11 @@ static int ice_vsi_setup_vector_base(struct ice_vsi *vsi)
                 dev_err(&pf->pdev->dev,
                         "Failed to get tracking for %d HW vectors for VSI %d, err=%d\n",
                         num_q_vectors, vsi->vsi_num, vsi->hw_base_vector);
-                ice_free_res(vsi->back->sw_irq_tracker, vsi->sw_base_vector,
-                             vsi->idx);
-                pf->num_avail_sw_msix += num_q_vectors;
+                if (vsi->type != ICE_VSI_VF) {
+                        ice_free_res(vsi->back->sw_irq_tracker,
+                                     vsi->sw_base_vector, vsi->idx);
+                        pf->num_avail_sw_msix += num_q_vectors;
+                }
                 return -ENOENT;
         }
 
@@ -1139,7 +1204,6 @@ static int ice_vsi_alloc_rings(struct ice_vsi *vsi)
                 ring->vsi = vsi;
                 ring->dev = &pf->pdev->dev;
                 ring->count = vsi->num_desc;
-                ring->itr_setting = ICE_DFLT_TX_ITR;
                 vsi->tx_rings[i] = ring;
         }
 
@@ -1159,7 +1223,6 @@ static int ice_vsi_alloc_rings(struct ice_vsi *vsi)
                 ring->netdev = vsi->netdev;
                 ring->dev = &pf->pdev->dev;
                 ring->count = vsi->num_desc;
-                ring->itr_setting = ICE_DFLT_RX_ITR;
                 vsi->rx_rings[i] = ring;
         }
 
@@ -1196,6 +1259,7 @@ static void ice_vsi_map_rings_to_vectors(struct ice_vsi *vsi)
                 tx_rings_per_v = DIV_ROUND_UP(tx_rings_rem, q_vectors - v_id);
                 q_vector->num_ring_tx = tx_rings_per_v;
                 q_vector->tx.ring = NULL;
+                q_vector->tx.itr_idx = ICE_TX_ITR;
                 q_base = vsi->num_txq - tx_rings_rem;
 
                 for (q_id = q_base; q_id < (q_base + tx_rings_per_v); q_id++) {
@@ -1211,6 +1275,7 @@ static void ice_vsi_map_rings_to_vectors(struct ice_vsi *vsi)
                 rx_rings_per_v = DIV_ROUND_UP(rx_rings_rem, q_vectors - v_id);
                 q_vector->num_ring_rx = rx_rings_per_v;
                 q_vector->rx.ring = NULL;
+                q_vector->rx.itr_idx = ICE_RX_ITR;
                 q_base = vsi->num_rxq - rx_rings_rem;
 
                 for (q_id = q_base; q_id < (q_base + rx_rings_per_v); q_id++) {
@@ -1512,6 +1577,9 @@ int ice_vsi_cfg_rxqs(struct ice_vsi *vsi)
         int err = 0;
         u16 i;
 
+        if (vsi->type == ICE_VSI_VF)
+                goto setup_rings;
+
         if (vsi->netdev && vsi->netdev->mtu > ETH_DATA_LEN)
                 vsi->max_frame = vsi->netdev->mtu +
                         ETH_HLEN + ETH_FCS_LEN + VLAN_HLEN;
@@ -1519,6 +1587,7 @@ int ice_vsi_cfg_rxqs(struct ice_vsi *vsi)
                 vsi->max_frame = ICE_RXBUF_2048;
 
         vsi->rx_buf_len = ICE_RXBUF_2048;
+setup_rings:
         /* set up individual rings */
         for (i = 0; i < vsi->num_rxq && !err; i++)
                 err = ice_setup_rx_ctx(vsi->rx_rings[i]);
@@ -1615,6 +1684,37 @@ static u32 ice_intrl_usec_to_reg(u8 intrl, u8 gran)
 }
 
 /**
+ * ice_cfg_itr - configure the initial interrupt throttle values
+ * @hw: pointer to the HW structure
+ * @q_vector: interrupt vector that's being configured
+ * @vector: HW vector index to apply the interrupt throttling to
+ *
+ * Configure interrupt throttling values for the ring containers that are
+ * associated with the interrupt vector passed in.
+ */
+static void
+ice_cfg_itr(struct ice_hw *hw, struct ice_q_vector *q_vector, u16 vector)
+{
+        u8 itr_gran = hw->itr_gran;
+
+        if (q_vector->num_ring_rx) {
+                struct ice_ring_container *rc = &q_vector->rx;
+
+                rc->itr = ITR_TO_REG(ICE_DFLT_RX_ITR, itr_gran);
+                rc->latency_range = ICE_LOW_LATENCY;
+                wr32(hw, GLINT_ITR(rc->itr_idx, vector), rc->itr);
+        }
+
+        if (q_vector->num_ring_tx) {
+                struct ice_ring_container *rc = &q_vector->tx;
+
+                rc->itr = ITR_TO_REG(ICE_DFLT_TX_ITR, itr_gran);
+                rc->latency_range = ICE_LOW_LATENCY;
+                wr32(hw, GLINT_ITR(rc->itr_idx, vector), rc->itr);
+        }
+}
+
+/**
  * ice_vsi_cfg_msix - MSIX mode Interrupt Config in the HW
  * @vsi: the VSI being configured
  */
@@ -1624,31 +1724,13 @@ void ice_vsi_cfg_msix(struct ice_vsi *vsi)
         u16 vector = vsi->hw_base_vector;
         struct ice_hw *hw = &pf->hw;
         u32 txq = 0, rxq = 0;
-        int i, q, itr;
-        u8 itr_gran;
+        int i, q;
 
         for (i = 0; i < vsi->num_q_vectors; i++, vector++) {
                 struct ice_q_vector *q_vector = vsi->q_vectors[i];
 
-                itr_gran = hw->itr_gran;
-
-                q_vector->intrl = ICE_DFLT_INTRL;
-
-                if (q_vector->num_ring_rx) {
-                        q_vector->rx.itr =
-                                ITR_TO_REG(vsi->rx_rings[rxq]->itr_setting,
-                                           itr_gran);
-                        q_vector->rx.latency_range = ICE_LOW_LATENCY;
-                }
+                ice_cfg_itr(hw, q_vector, vector);
 
-                if (q_vector->num_ring_tx) {
-                        q_vector->tx.itr =
-                                ITR_TO_REG(vsi->tx_rings[txq]->itr_setting,
-                                           itr_gran);
-                        q_vector->tx.latency_range = ICE_LOW_LATENCY;
-                }
-                wr32(hw, GLINT_ITR(ICE_RX_ITR, vector), q_vector->rx.itr);
-                wr32(hw, GLINT_ITR(ICE_TX_ITR, vector), q_vector->tx.itr);
                 wr32(hw, GLINT_RATE(vector),
                      ice_intrl_usec_to_reg(q_vector->intrl, hw->intrl_gran));
 
@@ -1664,23 +1746,33 @@ void ice_vsi_cfg_msix(struct ice_vsi *vsi)
                  * tracked for this PF.
                  */
                 for (q = 0; q < q_vector->num_ring_tx; q++) {
+                        int itr_idx = q_vector->tx.itr_idx;
                         u32 val;
 
-                        itr = ICE_ITR_NONE;
-                        val = QINT_TQCTL_CAUSE_ENA_M |
-                              (itr << QINT_TQCTL_ITR_INDX_S)  |
-                              (vector << QINT_TQCTL_MSIX_INDX_S);
+                        if (vsi->type == ICE_VSI_VF)
+                                val = QINT_TQCTL_CAUSE_ENA_M |
+                                      (itr_idx << QINT_TQCTL_ITR_INDX_S)  |
+                                      ((i + 1) << QINT_TQCTL_MSIX_INDX_S);
+                        else
+                                val = QINT_TQCTL_CAUSE_ENA_M |
+                                      (itr_idx << QINT_TQCTL_ITR_INDX_S)  |
+                                      (vector << QINT_TQCTL_MSIX_INDX_S);
                         wr32(hw, QINT_TQCTL(vsi->txq_map[txq]), val);
                         txq++;
                 }
 
                 for (q = 0; q < q_vector->num_ring_rx; q++) {
+                        int itr_idx = q_vector->rx.itr_idx;
                         u32 val;
 
-                        itr = ICE_ITR_NONE;
-                        val = QINT_RQCTL_CAUSE_ENA_M |
-                              (itr << QINT_RQCTL_ITR_INDX_S)  |
-                              (vector << QINT_RQCTL_MSIX_INDX_S);
+                        if (vsi->type == ICE_VSI_VF)
+                                val = QINT_RQCTL_CAUSE_ENA_M |
+                                      (itr_idx << QINT_RQCTL_ITR_INDX_S)  |
+                                      ((i + 1) << QINT_RQCTL_MSIX_INDX_S);
+                        else
+                                val = QINT_RQCTL_CAUSE_ENA_M |
+                                      (itr_idx << QINT_RQCTL_ITR_INDX_S)  |
+                                      (vector << QINT_RQCTL_MSIX_INDX_S);
                         wr32(hw, QINT_RQCTL(vsi->rxq_map[rxq]), val);
                         rxq++;
                 }
@@ -1784,8 +1876,11 @@ int ice_vsi_stop_rx_rings(struct ice_vsi *vsi)
 /**
  * ice_vsi_stop_tx_rings - Disable Tx rings
  * @vsi: the VSI being configured
+ * @rst_src: reset source
+ * @rel_vmvf_num: Relative id of VF/VM
  */
-int ice_vsi_stop_tx_rings(struct ice_vsi *vsi)
+int ice_vsi_stop_tx_rings(struct ice_vsi *vsi, enum ice_disq_rst_src rst_src,
+                          u16 rel_vmvf_num)
 {
         struct ice_pf *pf = vsi->back;
         struct ice_hw *hw = &pf->hw;
@@ -1837,7 +1932,7 @@ int ice_vsi_stop_tx_rings(struct ice_vsi *vsi)
                      GLINT_DYN_CTL_SWINT_TRIG_M | GLINT_DYN_CTL_INTENA_MSK_M);
         }
         status = ice_dis_vsi_txq(vsi->port_info, vsi->num_txq, q_ids, q_teids,
-                                 NULL);
+                                 rst_src, rel_vmvf_num, NULL);
         /* if the disable queue command was exercised during an active reset
          * flow, ICE_ERR_RESET_ONGOING is returned. This is not an error as
          * the reset operation disables queues at the hardware level anyway.
@@ -1934,7 +2029,7 @@ err_out:
  */
 struct ice_vsi *
 ice_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi,
-              enum ice_vsi_type type, u16 __always_unused vf_id)
+              enum ice_vsi_type type, u16 vf_id)
 {
         u16 max_txqs[ICE_MAX_TRAFFIC_CLASS] = { 0 };
         struct device *dev = &pf->pdev->dev;
@@ -1949,6 +2044,8 @@ ice_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi,
 
         vsi->port_info = pi;
         vsi->vsw = pf->first_sw;
+        if (vsi->type == ICE_VSI_VF)
+                vsi->vf_id = vf_id;
 
         if (ice_vsi_get_qs(vsi)) {
                 dev_err(dev, "Failed to allocate queues. vsi->idx = %d\n",
@@ -1987,6 +2084,34 @@ ice_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi,
                 if (test_bit(ICE_FLAG_RSS_ENA, pf->flags))
                         ice_vsi_cfg_rss_lut_key(vsi);
                 break;
+        case ICE_VSI_VF:
+                /* VF driver will take care of creating netdev for this type and
+                 * map queues to vectors through Virtchnl, PF driver only
+                 * creates a VSI and corresponding structures for bookkeeping
+                 * purpose
+                 */
+                ret = ice_vsi_alloc_q_vectors(vsi);
+                if (ret)
+                        goto unroll_vsi_init;
+
+                ret = ice_vsi_alloc_rings(vsi);
+                if (ret)
+                        goto unroll_alloc_q_vector;
+
+                /* Setup Vector base only during VF init phase or when VF asks
+                 * for more vectors than assigned number. In all other cases,
+                 * assign hw_base_vector to the value given earlier.
+                 */
+                if (test_bit(ICE_VF_STATE_CFG_INTR, pf->vf[vf_id].vf_states)) {
+                        ret = ice_vsi_setup_vector_base(vsi);
+                        if (ret)
+                                goto unroll_vector_base;
+                } else {
+                        vsi->hw_base_vector = pf->vf[vf_id].first_vector_idx;
+                }
+                pf->q_left_tx -= vsi->alloc_txq;
+                pf->q_left_rx -= vsi->alloc_rxq;
+                break;
         default:
                 /* if VSI type is not recognized, clean up the resources and
                  * exit
@@ -2045,8 +2170,8 @@ static void ice_vsi_release_msix(struct ice_vsi *vsi)
         for (i = 0; i < vsi->num_q_vectors; i++, vector++) {
                 struct ice_q_vector *q_vector = vsi->q_vectors[i];
 
-                wr32(hw, GLINT_ITR(ICE_RX_ITR, vector), 0);
-                wr32(hw, GLINT_ITR(ICE_TX_ITR, vector), 0);
+                wr32(hw, GLINT_ITR(ICE_IDX_ITR0, vector), 0);
+                wr32(hw, GLINT_ITR(ICE_IDX_ITR1, vector), 0);
                 for (q = 0; q < q_vector->num_ring_tx; q++) {
                         wr32(hw, QINT_TQCTL(vsi->txq_map[txq]), 0);
                         txq++;
@@ -2077,6 +2202,8 @@ void ice_vsi_free_irq(struct ice_vsi *vsi)
                         return;
 
                 ice_vsi_release_msix(vsi);
+                if (vsi->type == ICE_VSI_VF)
+                        return;
 
                 vsi->irqs_ready = false;
                 for (i = 0; i < vsi->num_q_vectors; i++) {
@@ -2317,10 +2444,12 @@ void ice_vsi_dis_irq(struct ice_vsi *vsi)
 int ice_vsi_release(struct ice_vsi *vsi)
 {
         struct ice_pf *pf;
+        struct ice_vf *vf;
 
         if (!vsi->back)
                 return -ENODEV;
         pf = vsi->back;
+        vf = &pf->vf[vsi->vf_id];
         /* do not unregister and free netdevs while driver is in the reset
          * recovery pending state. Since reset/rebuild happens through PF
          * service task workqueue, its not a good idea to unregister netdev
@@ -2342,10 +2471,23 @@ int ice_vsi_release(struct ice_vsi *vsi)
         ice_vsi_close(vsi);
 
         /* reclaim interrupt vectors back to PF */
-        ice_free_res(vsi->back->sw_irq_tracker, vsi->sw_base_vector, vsi->idx);
-        pf->num_avail_sw_msix += vsi->num_q_vectors;
-        ice_free_res(vsi->back->hw_irq_tracker, vsi->hw_base_vector, vsi->idx);
-        pf->num_avail_hw_msix += vsi->num_q_vectors;
+        if (vsi->type != ICE_VSI_VF) {
+                /* reclaim SW interrupts back to the common pool */
+                ice_free_res(vsi->back->sw_irq_tracker, vsi->sw_base_vector,
+                             vsi->idx);
+                pf->num_avail_sw_msix += vsi->num_q_vectors;
+                /* reclaim HW interrupts back to the common pool */
+                ice_free_res(vsi->back->hw_irq_tracker, vsi->hw_base_vector,
+                             vsi->idx);
+                pf->num_avail_hw_msix += vsi->num_q_vectors;
+        } else if (test_bit(ICE_VF_STATE_CFG_INTR, vf->vf_states)) {
+                /* Reclaim VF resources back only while freeing all VFs or
+                 * vector reassignment is requested
+                 */
+                ice_free_res(vsi->back->hw_irq_tracker, vf->first_vector_idx,
+                             vsi->idx);
+                pf->num_avail_hw_msix += pf->num_vf_msix;
+        }
 
         ice_remove_vsi_fltr(&pf->hw, vsi->idx);
         ice_vsi_delete(vsi);
@@ -2414,6 +2556,22 @@ int ice_vsi_rebuild(struct ice_vsi *vsi)
 
                 ice_vsi_map_rings_to_vectors(vsi);
                 break;
+        case ICE_VSI_VF:
+                ret = ice_vsi_alloc_q_vectors(vsi);
+                if (ret)
+                        goto err_rings;
+
+                ret = ice_vsi_setup_vector_base(vsi);
+                if (ret)
+                        goto err_vectors;
+
+                ret = ice_vsi_alloc_rings(vsi);
+                if (ret)
+                        goto err_vectors;
+
+                vsi->back->q_left_tx -= vsi->alloc_txq;
+                vsi->back->q_left_rx -= vsi->alloc_rxq;
+                break;
         default:
                 break;
         }
diff --git a/drivers/net/ethernet/intel/ice/ice_lib.h b/drivers/net/ethernet/intel/ice/ice_lib.h
index 2617afe01c82..677db40338f5 100644
--- a/drivers/net/ethernet/intel/ice/ice_lib.h
+++ b/drivers/net/ethernet/intel/ice/ice_lib.h
@@ -31,7 +31,8 @@ int ice_vsi_start_rx_rings(struct ice_vsi *vsi);
 
 int ice_vsi_stop_rx_rings(struct ice_vsi *vsi);
 
-int ice_vsi_stop_tx_rings(struct ice_vsi *vsi);
+int ice_vsi_stop_tx_rings(struct ice_vsi *vsi, enum ice_disq_rst_src rst_src,
+                          u16 rel_vmvf_num);
 
 int ice_cfg_vlan_pruning(struct ice_vsi *vsi, bool ena);
 
diff --git a/drivers/net/ethernet/intel/ice/ice_main.c b/drivers/net/ethernet/intel/ice/ice_main.c
index 46ccf265c218..8f61b375e768 100644
--- a/drivers/net/ethernet/intel/ice/ice_main.c
+++ b/drivers/net/ethernet/intel/ice/ice_main.c
@@ -8,7 +8,7 @@
 #include "ice.h"
 #include "ice_lib.h"
 
-#define DRV_VERSION     "0.7.1-k"
+#define DRV_VERSION     "0.7.2-k"
 #define DRV_SUMMARY     "Intel(R) Ethernet Connection E800 Series Linux Driver"
 const char ice_drv_ver[] = DRV_VERSION;
 static const char ice_driver_string[] = DRV_SUMMARY;
@@ -342,6 +342,10 @@ ice_prepare_for_reset(struct ice_pf *pf)
 {
         struct ice_hw *hw = &pf->hw;
 
+        /* Notify VFs of impending reset */
+        if (ice_check_sq_alive(hw, &hw->mailboxq))
+                ice_vc_notify_reset(pf);
+
         /* disable the VSIs and their queues that are not already DOWN */
         ice_pf_dis_all_vsi(pf);
 
@@ -661,6 +665,8 @@ ice_link_event(struct ice_pf *pf, struct ice_port_info *pi)
                 }
         }
 
+        ice_vc_notify_link_state(pf);
+
         return 0;
 }
 
@@ -711,6 +717,10 @@ static int __ice_clean_ctrlq(struct ice_pf *pf, enum ice_ctl_q q_type)
                 cq = &hw->adminq;
                 qtype = "Admin";
                 break;
+        case ICE_CTL_Q_MAILBOX:
+                cq = &hw->mailboxq;
+                qtype = "Mailbox";
+                break;
         default:
                 dev_warn(&pf->pdev->dev, "Unknown control queue type 0x%x\n",
                          q_type);
@@ -792,6 +802,9 @@ static int __ice_clean_ctrlq(struct ice_pf *pf, enum ice_ctl_q q_type)
                                 dev_err(&pf->pdev->dev,
                                         "Could not handle link event\n");
                         break;
+                case ice_mbx_opc_send_msg_to_pf:
+                        ice_vc_process_vf_msg(pf, &event);
+                        break;
                 case ice_aqc_opc_fw_logging:
                         ice_output_fw_log(hw, &event.desc, event.msg_buf);
                         break;
@@ -851,6 +864,28 @@ static void ice_clean_adminq_subtask(struct ice_pf *pf)
 }
 
 /**
+ * ice_clean_mailboxq_subtask - clean the MailboxQ rings
+ * @pf: board private structure
+ */
+static void ice_clean_mailboxq_subtask(struct ice_pf *pf)
+{
+        struct ice_hw *hw = &pf->hw;
+
+        if (!test_bit(__ICE_MAILBOXQ_EVENT_PENDING, pf->state))
+                return;
+
+        if (__ice_clean_ctrlq(pf, ICE_CTL_Q_MAILBOX))
+                return;
+
+        clear_bit(__ICE_MAILBOXQ_EVENT_PENDING, pf->state);
+
+        if (ice_ctrlq_pending(hw, &hw->mailboxq))
+                __ice_clean_ctrlq(pf, ICE_CTL_Q_MAILBOX);
+
+        ice_flush(hw);
+}
+
+/**
  * ice_service_task_schedule - schedule the service task to wake up
  * @pf: board private structure
  *
@@ -916,6 +951,7 @@ static void ice_handle_mdd_event(struct ice_pf *pf)
         struct ice_hw *hw = &pf->hw;
         bool mdd_detected = false;
         u32 reg;
+        int i;
 
         if (!test_bit(__ICE_MDD_EVENT_PENDING, pf->state))
                 return;
@@ -1005,6 +1041,51 @@ static void ice_handle_mdd_event(struct ice_pf *pf)
                 }
         }
 
+        /* see if one of the VFs needs to be reset */
+        for (i = 0; i < pf->num_alloc_vfs && mdd_detected; i++) {
+                struct ice_vf *vf = &pf->vf[i];
+
+                reg = rd32(hw, VP_MDET_TX_PQM(i));
+                if (reg & VP_MDET_TX_PQM_VALID_M) {
+                        wr32(hw, VP_MDET_TX_PQM(i), 0xFFFF);
+                        vf->num_mdd_events++;
+                        dev_info(&pf->pdev->dev, "TX driver issue detected on VF %d\n",
+                                 i);
+                }
+
+                reg = rd32(hw, VP_MDET_TX_TCLAN(i));
+                if (reg & VP_MDET_TX_TCLAN_VALID_M) {
+                        wr32(hw, VP_MDET_TX_TCLAN(i), 0xFFFF);
+                        vf->num_mdd_events++;
+                        dev_info(&pf->pdev->dev, "TX driver issue detected on VF %d\n",
+                                 i);
+                }
+
+                reg = rd32(hw, VP_MDET_TX_TDPU(i));
+                if (reg & VP_MDET_TX_TDPU_VALID_M) {
+                        wr32(hw, VP_MDET_TX_TDPU(i), 0xFFFF);
+                        vf->num_mdd_events++;
+                        dev_info(&pf->pdev->dev, "TX driver issue detected on VF %d\n",
+                                 i);
+                }
+
+                reg = rd32(hw, VP_MDET_RX(i));
+                if (reg & VP_MDET_RX_VALID_M) {
+                        wr32(hw, VP_MDET_RX(i), 0xFFFF);
+                        vf->num_mdd_events++;
+                        dev_info(&pf->pdev->dev, "RX driver issue detected on VF %d\n",
+                                 i);
+                }
+
+                if (vf->num_mdd_events > ICE_DFLT_NUM_MDD_EVENTS_ALLOWED) {
+                        dev_info(&pf->pdev->dev,
+                                 "Too many MDD events on VF %d, disabled\n", i);
+                        dev_info(&pf->pdev->dev,
+                                 "Use PF Control I/F to re-enable the VF\n");
+                        set_bit(ICE_VF_STATE_DIS, vf->vf_states);
+                }
+        }
+
         /* re-enable MDD interrupt cause */
         clear_bit(__ICE_MDD_EVENT_PENDING, pf->state);
         reg = rd32(hw, PFINT_OICR_ENA);
@@ -1038,8 +1119,10 @@ static void ice_service_task(struct work_struct *work)
         ice_check_for_hang_subtask(pf);
         ice_sync_fltr_subtask(pf);
         ice_handle_mdd_event(pf);
+        ice_process_vflr_event(pf);
         ice_watchdog_subtask(pf);
         ice_clean_adminq_subtask(pf);
+        ice_clean_mailboxq_subtask(pf);
 
         /* Clear __ICE_SERVICE_SCHED flag to allow scheduling next event */
         ice_service_task_complete(pf);
@@ -1050,6 +1133,8 @@ static void ice_service_task(struct work_struct *work)
          */
         if (time_after(jiffies, (start_time + pf->serv_tmr_period)) ||
             test_bit(__ICE_MDD_EVENT_PENDING, pf->state) ||
+            test_bit(__ICE_VFLR_EVENT_PENDING, pf->state) ||
+            test_bit(__ICE_MAILBOXQ_EVENT_PENDING, pf->state) ||
             test_bit(__ICE_ADMINQ_EVENT_PENDING, pf->state))
                 mod_timer(&pf->serv_tmr, jiffies);
 }
@@ -1064,6 +1149,10 @@ static void ice_set_ctrlq_len(struct ice_hw *hw)
         hw->adminq.num_sq_entries = ICE_AQ_LEN;
         hw->adminq.rq_buf_size = ICE_AQ_MAX_BUF_LEN;
         hw->adminq.sq_buf_size = ICE_AQ_MAX_BUF_LEN;
+        hw->mailboxq.num_rq_entries = ICE_MBXQ_LEN;
+        hw->mailboxq.num_sq_entries = ICE_MBXQ_LEN;
+        hw->mailboxq.rq_buf_size = ICE_MBXQ_MAX_BUF_LEN;
+        hw->mailboxq.sq_buf_size = ICE_MBXQ_MAX_BUF_LEN;
 }
 
 /**
@@ -1197,6 +1286,7 @@ static void ice_ena_misc_vector(struct ice_pf *pf)
                PFINT_OICR_MAL_DETECT_M |
                PFINT_OICR_GRST_M |
                PFINT_OICR_PCI_EXCEPTION_M |
+               PFINT_OICR_VFLR_M |
                PFINT_OICR_HMC_ERR_M |
                PFINT_OICR_PE_CRITERR_M);
 
@@ -1220,6 +1310,7 @@ static irqreturn_t ice_misc_intr(int __always_unused irq, void *data)
         u32 oicr, ena_mask;
 
         set_bit(__ICE_ADMINQ_EVENT_PENDING, pf->state);
+        set_bit(__ICE_MAILBOXQ_EVENT_PENDING, pf->state);
 
         oicr = rd32(hw, PFINT_OICR);
         ena_mask = rd32(hw, PFINT_OICR_ENA);
@@ -1228,6 +1319,10 @@ static irqreturn_t ice_misc_intr(int __always_unused irq, void *data)
                 ena_mask &= ~PFINT_OICR_MAL_DETECT_M;
                 set_bit(__ICE_MDD_EVENT_PENDING, pf->state);
         }
+        if (oicr & PFINT_OICR_VFLR_M) {
+                ena_mask &= ~PFINT_OICR_VFLR_M;
+                set_bit(__ICE_VFLR_EVENT_PENDING, pf->state);
+        }
 
         if (oicr & PFINT_OICR_GRST_M) {
                 u32 reset;
@@ -1406,6 +1501,11 @@ skip_req_irq:
                PFINT_FW_CTL_CAUSE_ENA_M);
         wr32(hw, PFINT_FW_CTL, val);
 
+        /* This enables Mailbox queue Interrupt causes */
+        val = ((pf->hw_oicr_idx & PFINT_MBX_CTL_MSIX_INDX_M) |
+               PFINT_MBX_CTL_CAUSE_ENA_M);
+        wr32(hw, PFINT_MBX_CTL, val);
+
         itr_gran = hw->itr_gran;
 
         wr32(hw, GLINT_ITR(ICE_RX_ITR, pf->hw_oicr_idx),
@@ -1775,6 +1875,15 @@ static void ice_init_pf(struct ice_pf *pf)
 {
         bitmap_zero(pf->flags, ICE_PF_FLAGS_NBITS);
         set_bit(ICE_FLAG_MSIX_ENA, pf->flags);
+#ifdef CONFIG_PCI_IOV
+        if (pf->hw.func_caps.common_cap.sr_iov_1_1) {
+                struct ice_hw *hw = &pf->hw;
+
+                set_bit(ICE_FLAG_SRIOV_CAPABLE, pf->flags);
+                pf->num_vfs_supported = min_t(int, hw->func_caps.num_allocd_vfs,
+                                              ICE_MAX_VF_COUNT);
+        }
+#endif /* CONFIG_PCI_IOV */
 
         mutex_init(&pf->sw_mutex);
         mutex_init(&pf->avail_q_mutex);
@@ -2138,6 +2247,8 @@ static void ice_remove(struct pci_dev *pdev)
         set_bit(__ICE_DOWN, pf->state);
         ice_service_task_stop(pf);
 
+        if (test_bit(ICE_FLAG_SRIOV_ENA, pf->flags))
+                ice_free_vfs(pf);
         ice_vsi_release_all(pf);
         ice_free_irq_msix_misc(pf);
         ice_for_each_vsi(pf, i) {
@@ -2173,6 +2284,7 @@ static struct pci_driver ice_driver = {
         .id_table = ice_pci_tbl,
         .probe = ice_probe,
         .remove = ice_remove,
+        .sriov_configure = ice_sriov_configure,
 };
 
 /**
@@ -2908,7 +3020,7 @@ int ice_down(struct ice_vsi *vsi)
         }
 
         ice_vsi_dis_irq(vsi);
-        tx_err = ice_vsi_stop_tx_rings(vsi);
+        tx_err = ice_vsi_stop_tx_rings(vsi, ICE_NO_RESET, 0);
         if (tx_err)
                 netdev_err(vsi->netdev,
                            "Failed stop Tx rings, VSI %d error %d\n",
@@ -3102,13 +3214,14 @@ static void ice_dis_vsi(struct ice_vsi *vsi)
 
         set_bit(__ICE_NEEDS_RESTART, vsi->state);
 
-        if (vsi->netdev && netif_running(vsi->netdev) &&
-            vsi->type == ICE_VSI_PF) {
-                rtnl_lock();
-                vsi->netdev->netdev_ops->ndo_stop(vsi->netdev);
-                rtnl_unlock();
-        } else {
-                ice_vsi_close(vsi);
+        if (vsi->type == ICE_VSI_PF && vsi->netdev) {
+                if (netif_running(vsi->netdev)) {
+                        rtnl_lock();
+                        vsi->netdev->netdev_ops->ndo_stop(vsi->netdev);
+                        rtnl_unlock();
+                } else {
+                        ice_vsi_close(vsi);
+                }
         }
 }
 
@@ -3120,12 +3233,16 @@ static int ice_ena_vsi(struct ice_vsi *vsi)
 {
         int err = 0;
 
-        if (test_and_clear_bit(__ICE_NEEDS_RESTART, vsi->state))
-                if (vsi->netdev && netif_running(vsi->netdev)) {
+        if (test_and_clear_bit(__ICE_NEEDS_RESTART, vsi->state) &&
+            vsi->netdev) {
+                if (netif_running(vsi->netdev)) {
                         rtnl_lock();
                         err = vsi->netdev->netdev_ops->ndo_open(vsi->netdev);
                         rtnl_unlock();
+                } else {
+                        err = ice_vsi_open(vsi);
                 }
+        }
 
         return err;
 }
@@ -3174,6 +3291,10 @@ static int ice_vsi_rebuild_all(struct ice_pf *pf)
                 if (!pf->vsi[i])
                         continue;
 
+                /* VF VSI rebuild isn't supported yet */
+                if (pf->vsi[i]->type == ICE_VSI_VF)
+                        continue;
+
                 err = ice_vsi_rebuild(pf->vsi[i]);
                 if (err) {
                         dev_err(&pf->pdev->dev,
@@ -3310,6 +3431,7 @@ static void ice_rebuild(struct ice_pf *pf)
                 goto err_vsi_rebuild;
         }
 
+        ice_reset_all_vfs(pf, true);
         /* if we get here, reset flow is successful */
         clear_bit(__ICE_RESET_FAILED, pf->state);
         return;
@@ -3818,6 +3940,12 @@ static const struct net_device_ops ice_netdev_ops = {
         .ndo_validate_addr = eth_validate_addr,
         .ndo_change_mtu = ice_change_mtu,
         .ndo_get_stats64 = ice_get_stats64,
+        .ndo_set_vf_spoofchk = ice_set_vf_spoofchk,
+        .ndo_set_vf_mac = ice_set_vf_mac,
+        .ndo_get_vf_config = ice_get_vf_cfg,
+        .ndo_set_vf_trust = ice_set_vf_trust,
+        .ndo_set_vf_vlan = ice_set_vf_port_vlan,
+        .ndo_set_vf_link_state = ice_set_vf_link_state,
         .ndo_vlan_rx_add_vid = ice_vlan_rx_add_vid,
         .ndo_vlan_rx_kill_vid = ice_vlan_rx_kill_vid,
         .ndo_set_features = ice_set_features,
diff --git a/drivers/net/ethernet/intel/ice/ice_sriov.c b/drivers/net/ethernet/intel/ice/ice_sriov.c
new file mode 100644
index 000000000000..027eba4e13f8
--- /dev/null
+++ b/drivers/net/ethernet/intel/ice/ice_sriov.c
@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2018, Intel Corporation. */
+
+#include "ice_common.h"
+#include "ice_adminq_cmd.h"
+#include "ice_sriov.h"
+
+/**
+ * ice_aq_send_msg_to_vf
+ * @hw: pointer to the hardware structure
+ * @vfid: VF ID to send msg
+ * @v_opcode: opcodes for VF-PF communication
+ * @v_retval: return error code
+ * @msg: pointer to the msg buffer
+ * @msglen: msg length
+ * @cd: pointer to command details
+ *
+ * Send message to VF driver (0x0802) using mailbox
+ * queue and asynchronously sending message via
+ * ice_sq_send_cmd() function
+ */
+enum ice_status
+ice_aq_send_msg_to_vf(struct ice_hw *hw, u16 vfid, u32 v_opcode, u32 v_retval,
+                      u8 *msg, u16 msglen, struct ice_sq_cd *cd)
+{
+        struct ice_aqc_pf_vf_msg *cmd;
+        struct ice_aq_desc desc;
+
+        ice_fill_dflt_direct_cmd_desc(&desc, ice_mbx_opc_send_msg_to_vf);
+
+        cmd = &desc.params.virt;
+        cmd->id = cpu_to_le32(vfid);
+
+        desc.cookie_high = cpu_to_le32(v_opcode);
+        desc.cookie_low = cpu_to_le32(v_retval);
+
+        if (msglen)
+                desc.flags |= cpu_to_le16(ICE_AQ_FLAG_RD);
+
+        return ice_sq_send_cmd(hw, &hw->mailboxq, &desc, msg, msglen, cd);
+}
+
+/**
+ * ice_conv_link_speed_to_virtchnl
+ * @adv_link_support: determines the format of the returned link speed
+ * @link_speed: variable containing the link_speed to be converted
+ *
+ * Convert link speed supported by HW to link speed supported by virtchnl.
+ * If adv_link_support is true, then return link speed in Mbps.  Else return
+ * link speed as a VIRTCHNL_LINK_SPEED_* casted to a u32. Note that the caller
+ * needs to cast back to an enum virtchnl_link_speed in the case where
+ * adv_link_support is false, but when adv_link_support is true the caller can
+ * expect the speed in Mbps.
+ */
+u32 ice_conv_link_speed_to_virtchnl(bool adv_link_support, u16 link_speed)
+{
+        u32 speed;
+
+        if (adv_link_support)
+                switch (link_speed) {
+                case ICE_AQ_LINK_SPEED_10MB:
+                        speed = ICE_LINK_SPEED_10MBPS;
+                        break;
+                case ICE_AQ_LINK_SPEED_100MB:
+                        speed = ICE_LINK_SPEED_100MBPS;
+                        break;
+                case ICE_AQ_LINK_SPEED_1000MB:
+                        speed = ICE_LINK_SPEED_1000MBPS;
+                        break;
+                case ICE_AQ_LINK_SPEED_2500MB:
+                        speed = ICE_LINK_SPEED_2500MBPS;
+                        break;
+                case ICE_AQ_LINK_SPEED_5GB:
+                        speed = ICE_LINK_SPEED_5000MBPS;
+                        break;
+                case ICE_AQ_LINK_SPEED_10GB:
+                        speed = ICE_LINK_SPEED_10000MBPS;
+                        break;
+                case ICE_AQ_LINK_SPEED_20GB:
+                        speed = ICE_LINK_SPEED_20000MBPS;
+                        break;
+                case ICE_AQ_LINK_SPEED_25GB:
+                        speed = ICE_LINK_SPEED_25000MBPS;
+                        break;
+                case ICE_AQ_LINK_SPEED_40GB:
+                        speed = ICE_LINK_SPEED_40000MBPS;
+                        break;
+                default:
+                        speed = ICE_LINK_SPEED_UNKNOWN;
+                        break;
+                }
+        else
+                /* Virtchnl speeds are not defined for every speed supported in
+                 * the hardware. To maintain compatibility with older AVF
+                 * drivers, while reporting the speed the new speed values are
+                 * resolved to the closest known virtchnl speeds
+                 */
+                switch (link_speed) {
+                case ICE_AQ_LINK_SPEED_10MB:
+                case ICE_AQ_LINK_SPEED_100MB:
+                        speed = (u32)VIRTCHNL_LINK_SPEED_100MB;
+                        break;
+                case ICE_AQ_LINK_SPEED_1000MB:
+                case ICE_AQ_LINK_SPEED_2500MB:
+                case ICE_AQ_LINK_SPEED_5GB:
+                        speed = (u32)VIRTCHNL_LINK_SPEED_1GB;
+                        break;
+                case ICE_AQ_LINK_SPEED_10GB:
+                        speed = (u32)VIRTCHNL_LINK_SPEED_10GB;
+                        break;
+                case ICE_AQ_LINK_SPEED_20GB:
+                        speed = (u32)VIRTCHNL_LINK_SPEED_20GB;
+                        break;
+                case ICE_AQ_LINK_SPEED_25GB:
+                        speed = (u32)VIRTCHNL_LINK_SPEED_25GB;
+                        break;
+                case ICE_AQ_LINK_SPEED_40GB:
+                        /* fall through */
+                        speed = (u32)VIRTCHNL_LINK_SPEED_40GB;
+                        break;
+                default:
+                        speed = (u32)VIRTCHNL_LINK_SPEED_UNKNOWN;
+                        break;
+                }
+
+        return speed;
+}
diff --git a/drivers/net/ethernet/intel/ice/ice_sriov.h b/drivers/net/ethernet/intel/ice/ice_sriov.h
new file mode 100644
index 000000000000..3d78a0795138
--- /dev/null
+++ b/drivers/net/ethernet/intel/ice/ice_sriov.h
@@ -0,0 +1,34 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* Copyright (c) 2018, Intel Corporation. */
+
+#ifndef _ICE_SRIOV_H_
+#define _ICE_SRIOV_H_
+
+#include "ice_common.h"
+
+#ifdef CONFIG_PCI_IOV
+enum ice_status
+ice_aq_send_msg_to_vf(struct ice_hw *hw, u16 vfid, u32 v_opcode, u32 v_retval,
+                      u8 *msg, u16 msglen, struct ice_sq_cd *cd);
+
+u32 ice_conv_link_speed_to_virtchnl(bool adv_link_support, u16 link_speed);
+#else /* CONFIG_PCI_IOV */
+static inline enum ice_status
+ice_aq_send_msg_to_vf(struct ice_hw __always_unused *hw,
+                      u16 __always_unused vfid, u32 __always_unused v_opcode,
+                      u32 __always_unused v_retval, u8 __always_unused *msg,
+                      u16 __always_unused msglen,
+                      struct ice_sq_cd __always_unused *cd)
+{
+        return 0;
+}
+
+static inline u32
+ice_conv_link_speed_to_virtchnl(bool __always_unused adv_link_support,
+                                u16 __always_unused link_speed)
+{
+        return 0;
+}
+
+#endif /* CONFIG_PCI_IOV */
+#endif /* _ICE_SRIOV_H_ */
diff --git a/drivers/net/ethernet/intel/ice/ice_status.h b/drivers/net/ethernet/intel/ice/ice_status.h
index d2dae913d81e..f49f299ddf2c 100644
--- a/drivers/net/ethernet/intel/ice/ice_status.h
+++ b/drivers/net/ethernet/intel/ice/ice_status.h
@@ -6,6 +6,9 @@
 
 /* Error Codes */
 enum ice_status {
+        ICE_SUCCESS                             = 0,
+
+        /* Generic codes : Range -1..-49 */
         ICE_ERR_PARAM                           = -1,
         ICE_ERR_NOT_IMPL                        = -2,
         ICE_ERR_NOT_READY                       = -3,
diff --git a/drivers/net/ethernet/intel/ice/ice_switch.c b/drivers/net/ethernet/intel/ice/ice_switch.c
index e949224b5282..33403f39f1b3 100644
--- a/drivers/net/ethernet/intel/ice/ice_switch.c
+++ b/drivers/net/ethernet/intel/ice/ice_switch.c
@@ -187,6 +187,7 @@ ice_aq_add_vsi(struct ice_hw *hw, struct ice_vsi_ctx *vsi_ctx,
         if (!vsi_ctx->alloc_from_pool)
                 cmd->vsi_num = cpu_to_le16(vsi_ctx->vsi_num |
                                            ICE_AQ_VSI_IS_VALID);
+        cmd->vf_id = vsi_ctx->vf_num;
 
         cmd->vsi_flags = cpu_to_le16(vsi_ctx->flags);
 
@@ -655,6 +656,7 @@ ice_fill_sw_rule(struct ice_hw *hw, struct ice_fltr_info *f_info,
         u8 *eth_hdr;
         u32 act = 0;
         __be16 *off;
+        u8 q_rgn;
 
         if (opc == ice_aqc_opc_remove_sw_rules) {
                 s_rule->pdata.lkup_tx_rx.act = 0;
@@ -693,14 +695,19 @@ ice_fill_sw_rule(struct ice_hw *hw, struct ice_fltr_info *f_info,
                 act |= (f_info->fwd_id.q_id << ICE_SINGLE_ACT_Q_INDEX_S) &
                         ICE_SINGLE_ACT_Q_INDEX_M;
                 break;
+        case ICE_DROP_PACKET:
+                act |= ICE_SINGLE_ACT_VSI_FORWARDING | ICE_SINGLE_ACT_DROP |
+                        ICE_SINGLE_ACT_VALID_BIT;
+                break;
         case ICE_FWD_TO_QGRP:
+                q_rgn = f_info->qgrp_size > 0 ?
+                        (u8)ilog2(f_info->qgrp_size) : 0;
                 act |= ICE_SINGLE_ACT_TO_Q;
-                act |= (f_info->qgrp_size << ICE_SINGLE_ACT_Q_REGION_S) &
+                act |= (f_info->fwd_id.q_id << ICE_SINGLE_ACT_Q_INDEX_S) &
+                        ICE_SINGLE_ACT_Q_INDEX_M;
+                act |= (q_rgn << ICE_SINGLE_ACT_Q_REGION_S) &
                         ICE_SINGLE_ACT_Q_REGION_M;
                 break;
-        case ICE_DROP_PACKET:
-                act |= ICE_SINGLE_ACT_VSI_FORWARDING | ICE_SINGLE_ACT_DROP;
-                break;
         default:
                 return;
         }
@@ -1415,8 +1422,8 @@ ice_rem_update_vsi_list(struct ice_hw *hw, u16 vsi_handle,
         fm_list->vsi_count--;
         clear_bit(vsi_handle, fm_list->vsi_list_info->vsi_map);
 
-        if ((fm_list->vsi_count == 1 && lkup_type != ICE_SW_LKUP_VLAN) ||
-            (fm_list->vsi_count == 0 && lkup_type == ICE_SW_LKUP_VLAN)) {
+        if (fm_list->vsi_count == 1 && lkup_type != ICE_SW_LKUP_VLAN) {
+                struct ice_fltr_info tmp_fltr_info = fm_list->fltr_info;
                 struct ice_vsi_list_map_info *vsi_list_info =
                         fm_list->vsi_list_info;
                 u16 rem_vsi_handle;
@@ -1425,6 +1432,8 @@ ice_rem_update_vsi_list(struct ice_hw *hw, u16 vsi_handle,
                                                 ICE_MAX_VSI);
                 if (!ice_is_vsi_valid(hw, rem_vsi_handle))
                         return ICE_ERR_OUT_OF_RANGE;
+
+                /* Make sure VSI list is empty before removing it below */
                 status = ice_update_vsi_list_rule(hw, &rem_vsi_handle, 1,
                                                   vsi_list_id, true,
                                                   ice_aqc_opc_update_sw_rules,
@@ -1432,16 +1441,34 @@ ice_rem_update_vsi_list(struct ice_hw *hw, u16 vsi_handle,
                 if (status)
                         return status;
 
+                tmp_fltr_info.fltr_act = ICE_FWD_TO_VSI;
+                tmp_fltr_info.fwd_id.hw_vsi_id =
+                        ice_get_hw_vsi_num(hw, rem_vsi_handle);
+                tmp_fltr_info.vsi_handle = rem_vsi_handle;
+                status = ice_update_pkt_fwd_rule(hw, &tmp_fltr_info);
+                if (status) {
+                        ice_debug(hw, ICE_DBG_SW,
+                                  "Failed to update pkt fwd rule to FWD_TO_VSI on HW VSI %d, error %d\n",
+                                  tmp_fltr_info.fwd_id.hw_vsi_id, status);
+                        return status;
+                }
+
+                fm_list->fltr_info = tmp_fltr_info;
+        }
+
+        if ((fm_list->vsi_count == 1 && lkup_type != ICE_SW_LKUP_VLAN) ||
+            (fm_list->vsi_count == 0 && lkup_type == ICE_SW_LKUP_VLAN)) {
+                struct ice_vsi_list_map_info *vsi_list_info =
+                        fm_list->vsi_list_info;
+
                 /* Remove the VSI list since it is no longer used */
                 status = ice_remove_vsi_list_rule(hw, vsi_list_id, lkup_type);
-                if (status)
+                if (status) {
+                        ice_debug(hw, ICE_DBG_SW,
+                                  "Failed to remove VSI list %d, error %d\n",
+                                  vsi_list_id, status);
                         return status;
-
-                /* Change the list entry action from VSI_LIST to VSI */
-                fm_list->fltr_info.fltr_act = ICE_FWD_TO_VSI;
-                fm_list->fltr_info.fwd_id.hw_vsi_id =
-                        ice_get_hw_vsi_num(hw, rem_vsi_handle);
-                fm_list->fltr_info.vsi_handle = rem_vsi_handle;
+                }
 
                 list_del(&vsi_list_info->list_entry);
                 devm_kfree(ice_hw_to_dev(hw), vsi_list_info);
@@ -1983,12 +2010,12 @@ out:
 enum ice_status
 ice_remove_mac(struct ice_hw *hw, struct list_head *m_list)
 {
-        struct ice_fltr_list_entry *list_itr;
+        struct ice_fltr_list_entry *list_itr, *tmp;
 
         if (!m_list)
                 return ICE_ERR_PARAM;
 
-        list_for_each_entry(list_itr, m_list, list_entry) {
+        list_for_each_entry_safe(list_itr, tmp, m_list, list_entry) {
                 enum ice_sw_lkup_type l_type = list_itr->fltr_info.lkup_type;
 
                 if (l_type != ICE_SW_LKUP_MAC)
@@ -2010,12 +2037,12 @@ ice_remove_mac(struct ice_hw *hw, struct list_head *m_list)
 enum ice_status
 ice_remove_vlan(struct ice_hw *hw, struct list_head *v_list)
 {
-        struct ice_fltr_list_entry *v_list_itr;
+        struct ice_fltr_list_entry *v_list_itr, *tmp;
 
         if (!v_list || !hw)
                 return ICE_ERR_PARAM;
 
-        list_for_each_entry(v_list_itr, v_list, list_entry) {
+        list_for_each_entry_safe(v_list_itr, tmp, v_list, list_entry) {
                 enum ice_sw_lkup_type l_type = v_list_itr->fltr_info.lkup_type;
 
                 if (l_type != ICE_SW_LKUP_VLAN)
@@ -2115,7 +2142,7 @@ ice_add_to_vsi_fltr_list(struct ice_hw *hw, u16 vsi_handle,
                 struct ice_fltr_info *fi;
 
                 fi = &fm_entry->fltr_info;
-                if (!ice_vsi_uses_fltr(fm_entry, vsi_handle))
+                if (!fi || !ice_vsi_uses_fltr(fm_entry, vsi_handle))
                         continue;
 
                 status = ice_add_entry_to_vsi_fltr_list(hw, vsi_handle,
@@ -2232,7 +2259,8 @@ ice_replay_vsi_fltr(struct ice_hw *hw, u16 vsi_handle, u8 recp_id,
                                 goto end;
                         continue;
                 }
-                if (!test_bit(vsi_handle, itr->vsi_list_info->vsi_map))
+                if (!itr->vsi_list_info ||
+                    !test_bit(vsi_handle, itr->vsi_list_info->vsi_map))
                         continue;
                 /* Clearing it so that the logic can add it back */
                 clear_bit(vsi_handle, itr->vsi_list_info->vsi_map);
diff --git a/drivers/net/ethernet/intel/ice/ice_switch.h b/drivers/net/ethernet/intel/ice/ice_switch.h
index 7706e9b6003c..b88d96a1ef69 100644
--- a/drivers/net/ethernet/intel/ice/ice_switch.h
+++ b/drivers/net/ethernet/intel/ice/ice_switch.h
@@ -19,6 +19,7 @@ struct ice_vsi_ctx {
         struct ice_aqc_vsi_props info;
         struct ice_sched_vsi_info sched;
         u8 alloc_from_pool;
+        u8 vf_num;
 };
 
 enum ice_sw_fwd_act_type {
diff --git a/drivers/net/ethernet/intel/ice/ice_txrx.h b/drivers/net/ethernet/intel/ice/ice_txrx.h
index a9b92974e041..1d0f58bd389b 100644
--- a/drivers/net/ethernet/intel/ice/ice_txrx.h
+++ b/drivers/net/ethernet/intel/ice/ice_txrx.h
@@ -105,8 +105,9 @@ enum ice_rx_dtype {
 #define ICE_TX_ITR      ICE_IDX_ITR1
 #define ICE_ITR_DYNAMIC 0x8000  /* use top bit as a flag */
 #define ICE_ITR_8K      125
-#define ICE_DFLT_TX_ITR ICE_ITR_8K
-#define ICE_DFLT_RX_ITR ICE_ITR_8K
+#define ICE_ITR_20K     50
+#define ICE_DFLT_TX_ITR ICE_ITR_20K
+#define ICE_DFLT_RX_ITR ICE_ITR_20K
 /* apply ITR granularity translation to program the register. itr_gran is either
  * 2 or 4 usecs so we need to divide by 2 first then shift by that value
  */
@@ -135,13 +136,6 @@ struct ice_ring {
         u16 q_index;                    /* Queue number of ring */
         u32 txq_teid;                   /* Added Tx queue TEID */
 
-        /* high bit set means dynamic, use accessor routines to read/write.
-         * hardware supports 4us/2us resolution for the ITR registers.
-         * these values always store the USER setting, and must be converted
-         * before programming to a register.
-         */
-        u16 itr_setting;
-
         u16 count;                      /* Number of descriptors */
         u16 reg_idx;                    /* HW register index of the ring */
 
@@ -178,6 +172,7 @@ struct ice_ring_container {
         unsigned int total_bytes;       /* total bytes processed this int */
         unsigned int total_pkts;        /* total packets processed this int */
         enum ice_latency_range latency_range;
+        int itr_idx;    /* index in the interrupt vector */
         u16 itr;
 };
 
diff --git a/drivers/net/ethernet/intel/ice/ice_type.h b/drivers/net/ethernet/intel/ice/ice_type.h
index f5c8de0ed0eb..12f9432abf11 100644
--- a/drivers/net/ethernet/intel/ice/ice_type.h
+++ b/drivers/net/ethernet/intel/ice/ice_type.h
@@ -84,6 +84,7 @@ enum ice_media_type {
 
 enum ice_vsi_type {
         ICE_VSI_PF = 0,
+        ICE_VSI_VF,
 };
 
 struct ice_link_status {
@@ -103,6 +104,15 @@ struct ice_link_status {
         u8 module_type[ICE_MODULE_TYPE_TOTAL_BYTE];
 };
 
+/* Different reset sources for which a disable queue AQ call has to be made in
+ * order to clean the TX scheduler as a part of the reset
+ */
+enum ice_disq_rst_src {
+        ICE_NO_RESET = 0,
+        ICE_VM_RESET,
+        ICE_VF_RESET,
+};
+
 /* PHY info such as phy_type, etc... */
 struct ice_phy_info {
         struct ice_link_status link_info;
@@ -127,6 +137,9 @@ struct ice_hw_common_caps {
         /* Max MTU for function or device */
         u16 max_mtu;
 
+        /* Virtualization support */
+        u8 sr_iov_1_1;                  /* SR-IOV enabled */
+
         /* RSS related capabilities */
         u16 rss_table_size;             /* 512 for PFs and 64 for VFs */
         u8 rss_table_entry_width;       /* RSS Entry width in bits */
@@ -135,12 +148,15 @@ struct ice_hw_common_caps {
 /* Function specific capabilities */
 struct ice_hw_func_caps {
         struct ice_hw_common_caps common_cap;
+        u32 num_allocd_vfs;             /* Number of allocated VFs */
+        u32 vf_base_id;                 /* Logical ID of the first VF */
         u32 guaranteed_num_vsi;
 };
 
 /* Device wide capabilities */
 struct ice_hw_dev_caps {
         struct ice_hw_common_caps common_cap;
+        u32 num_vfs_exposed;            /* Total number of VFs exposed */
         u32 num_vsi_allocd_to_host;     /* Excluding EMP VSI */
 };
 
@@ -321,6 +337,7 @@ struct ice_hw {
 
         /* Control Queue info */
         struct ice_ctl_q_info adminq;
+        struct ice_ctl_q_info mailboxq;
 
         u8 api_branch;          /* API branch version */
         u8 api_maj_ver;         /* API major version */
@@ -426,4 +443,7 @@ struct ice_hw_port_stats {
 #define ICE_SR_SECTOR_SIZE_IN_WORDS     0x800
 #define ICE_SR_WORDS_IN_1KB             512
 
+/* Hash redirection LUT for VSI - maximum array size */
+#define ICE_VSIQF_HLUT_ARRAY_SIZE       ((VSIQF_HLUT_MAX_INDEX + 1) * 4)
+
 #endif /* _ICE_TYPE_H_ */
diff --git a/drivers/net/ethernet/intel/ice/ice_virtchnl_pf.c b/drivers/net/ethernet/intel/ice/ice_virtchnl_pf.c
new file mode 100644
index 000000000000..c25e486706f3
--- /dev/null
+++ b/drivers/net/ethernet/intel/ice/ice_virtchnl_pf.c
@@ -0,0 +1,2668 @@
+// SPDX-License-Identifier: GPL-2.0
+/* Copyright (c) 2018, Intel Corporation. */
+
+#include "ice.h"
+#include "ice_lib.h"
+
+/**
+ * ice_vc_vf_broadcast - Broadcast a message to all VFs on PF
+ * @pf: pointer to the PF structure
+ * @v_opcode: operation code
+ * @v_retval: return value
+ * @msg: pointer to the msg buffer
+ * @msglen: msg length
+ */
+static void
+ice_vc_vf_broadcast(struct ice_pf *pf, enum virtchnl_ops v_opcode,
+                    enum ice_status v_retval, u8 *msg, u16 msglen)
+{
+        struct ice_hw *hw = &pf->hw;
+        struct ice_vf *vf = pf->vf;
+        int i;
+
+        for (i = 0; i < pf->num_alloc_vfs; i++, vf++) {
+                /* Not all vfs are enabled so skip the ones that are not */
+                if (!test_bit(ICE_VF_STATE_INIT, vf->vf_states) &&
+                    !test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states))
+                        continue;
+
+                /* Ignore return value on purpose - a given VF may fail, but
+                 * we need to keep going and send to all of them
+                 */
+                ice_aq_send_msg_to_vf(hw, vf->vf_id, v_opcode, v_retval, msg,
+                                      msglen, NULL);
+        }
+}
+
+/**
+ * ice_set_pfe_link - Set the link speed/status of the virtchnl_pf_event
+ * @vf: pointer to the VF structure
+ * @pfe: pointer to the virtchnl_pf_event to set link speed/status for
+ * @ice_link_speed: link speed specified by ICE_AQ_LINK_SPEED_*
+ * @link_up: whether or not to set the link up/down
+ */
+static void
+ice_set_pfe_link(struct ice_vf *vf, struct virtchnl_pf_event *pfe,
+                 int ice_link_speed, bool link_up)
+{
+        if (vf->driver_caps & VIRTCHNL_VF_CAP_ADV_LINK_SPEED) {
+                pfe->event_data.link_event_adv.link_status = link_up;
+                /* Speed in Mbps */
+                pfe->event_data.link_event_adv.link_speed =
+                        ice_conv_link_speed_to_virtchnl(true, ice_link_speed);
+        } else {
+                pfe->event_data.link_event.link_status = link_up;
+                /* Legacy method for virtchnl link speeds */
+                pfe->event_data.link_event.link_speed =
+                        (enum virtchnl_link_speed)
+                        ice_conv_link_speed_to_virtchnl(false, ice_link_speed);
+        }
+}
+
+/**
+ * ice_set_pfe_link_forced - Force the virtchnl_pf_event link speed/status
+ * @vf: pointer to the VF structure
+ * @pfe: pointer to the virtchnl_pf_event to set link speed/status for
+ * @link_up: whether or not to set the link up/down
+ */
+static void
+ice_set_pfe_link_forced(struct ice_vf *vf, struct virtchnl_pf_event *pfe,
+                        bool link_up)
+{
+        u16 link_speed;
+
+        if (link_up)
+                link_speed = ICE_AQ_LINK_SPEED_40GB;
+        else
+                link_speed = ICE_AQ_LINK_SPEED_UNKNOWN;
+
+        ice_set_pfe_link(vf, pfe, link_speed, link_up);
+}
+
+/**
+ * ice_vc_notify_vf_link_state - Inform a VF of link status
+ * @vf: pointer to the VF structure
+ *
+ * send a link status message to a single VF
+ */
+static void ice_vc_notify_vf_link_state(struct ice_vf *vf)
+{
+        struct virtchnl_pf_event pfe = { 0 };
+        struct ice_link_status *ls;
+        struct ice_pf *pf = vf->pf;
+        struct ice_hw *hw;
+
+        hw = &pf->hw;
+        ls = &hw->port_info->phy.link_info;
+
+        pfe.event = VIRTCHNL_EVENT_LINK_CHANGE;
+        pfe.severity = PF_EVENT_SEVERITY_INFO;
+
+        if (vf->link_forced)
+                ice_set_pfe_link_forced(vf, &pfe, vf->link_up);
+        else
+                ice_set_pfe_link(vf, &pfe, ls->link_speed, ls->link_info &
+                                 ICE_AQ_LINK_UP);
+
+        ice_aq_send_msg_to_vf(hw, vf->vf_id, VIRTCHNL_OP_EVENT, 0, (u8 *)&pfe,
+                              sizeof(pfe), NULL);
+}
+
+/**
+ * ice_get_vf_vector - get VF interrupt vector register offset
+ * @vf_msix: number of MSIx vector per VF on a PF
+ * @vf_id: VF identifier
+ * @i: index of MSIx vector
+ */
+static u32 ice_get_vf_vector(int vf_msix, int vf_id, int i)
+{
+        return ((i == 0) ? VFINT_DYN_CTLN(vf_id) :
+                 VFINT_DYN_CTLN(((vf_msix - 1) * (vf_id)) + (i - 1)));
+}
+
+/**
+ * ice_free_vf_res - Free a VF's resources
+ * @vf: pointer to the VF info
+ */
+static void ice_free_vf_res(struct ice_vf *vf)
+{
+        struct ice_pf *pf = vf->pf;
+        int i, pf_vf_msix;
+
+        /* First, disable VF's configuration API to prevent OS from
+         * accessing the VF's VSI after it's freed or invalidated.
+         */
+        clear_bit(ICE_VF_STATE_INIT, vf->vf_states);
+
+        /* free vsi & disconnect it from the parent uplink */
+        if (vf->lan_vsi_idx) {
+                ice_vsi_release(pf->vsi[vf->lan_vsi_idx]);
+                vf->lan_vsi_idx = 0;
+                vf->lan_vsi_num = 0;
+                vf->num_mac = 0;
+        }
+
+        pf_vf_msix = pf->num_vf_msix;
+        /* Disable interrupts so that VF starts in a known state */
+        for (i = 0; i < pf_vf_msix; i++) {
+                u32 reg_idx;
+
+                reg_idx = ice_get_vf_vector(pf_vf_msix, vf->vf_id, i);
+                wr32(&pf->hw, reg_idx, VFINT_DYN_CTLN_CLEARPBA_M);
+                ice_flush(&pf->hw);
+        }
+        /* reset some of the state variables keeping track of the resources */
+        clear_bit(ICE_VF_STATE_MC_PROMISC, vf->vf_states);
+        clear_bit(ICE_VF_STATE_UC_PROMISC, vf->vf_states);
+}
+
+/***********************enable_vf routines*****************************/
+
+/**
+ * ice_dis_vf_mappings
+ * @vf: pointer to the VF structure
+ */
+static void ice_dis_vf_mappings(struct ice_vf *vf)
+{
+        struct ice_pf *pf = vf->pf;
+        struct ice_vsi *vsi;
+        int first, last, v;
+        struct ice_hw *hw;
+
+        hw = &pf->hw;
+        vsi = pf->vsi[vf->lan_vsi_idx];
+
+        wr32(hw, VPINT_ALLOC(vf->vf_id), 0);
+
+        first = vf->first_vector_idx;
+        last = first + pf->num_vf_msix - 1;
+        for (v = first; v <= last; v++) {
+                u32 reg;
+
+                reg = (((1 << GLINT_VECT2FUNC_IS_PF_S) &
+                        GLINT_VECT2FUNC_IS_PF_M) |
+                       ((hw->pf_id << GLINT_VECT2FUNC_PF_NUM_S) &
+                        GLINT_VECT2FUNC_PF_NUM_M));
+                wr32(hw, GLINT_VECT2FUNC(v), reg);
+        }
+
+        if (vsi->tx_mapping_mode == ICE_VSI_MAP_CONTIG)
+                wr32(hw, VPLAN_TX_QBASE(vf->vf_id), 0);
+        else
+                dev_err(&pf->pdev->dev,
+                        "Scattered mode for VF Tx queues is not yet implemented\n");
+
+        if (vsi->rx_mapping_mode == ICE_VSI_MAP_CONTIG)
+                wr32(hw, VPLAN_RX_QBASE(vf->vf_id), 0);
+        else
+                dev_err(&pf->pdev->dev,
+                        "Scattered mode for VF Rx queues is not yet implemented\n");
+}
+
+/**
+ * ice_free_vfs - Free all VFs
+ * @pf: pointer to the PF structure
+ */
+void ice_free_vfs(struct ice_pf *pf)
+{
+        struct ice_hw *hw = &pf->hw;
+        int tmp, i;
+
+        if (!pf->vf)
+                return;
+
+        while (test_and_set_bit(__ICE_VF_DIS, pf->state))
+                usleep_range(1000, 2000);
+
+        /* Avoid wait time by stopping all VFs at the same time */
+        for (i = 0; i < pf->num_alloc_vfs; i++) {
+                if (!test_bit(ICE_VF_STATE_ENA, pf->vf[i].vf_states))
+                        continue;
+
+                /* stop rings without wait time */
+                ice_vsi_stop_tx_rings(pf->vsi[pf->vf[i].lan_vsi_idx],
+                                      ICE_NO_RESET, i);
+                ice_vsi_stop_rx_rings(pf->vsi[pf->vf[i].lan_vsi_idx]);
+
+                clear_bit(ICE_VF_STATE_ENA, pf->vf[i].vf_states);
+        }
+
+        /* Disable IOV before freeing resources. This lets any VF drivers
+         * running in the host get themselves cleaned up before we yank
+         * the carpet out from underneath their feet.
+         */
+        if (!pci_vfs_assigned(pf->pdev))
+                pci_disable_sriov(pf->pdev);
+        else
+                dev_warn(&pf->pdev->dev, "VFs are assigned - not disabling SR-IOV\n");
+
+        tmp = pf->num_alloc_vfs;
+        pf->num_vf_qps = 0;
+        pf->num_alloc_vfs = 0;
+        for (i = 0; i < tmp; i++) {
+                if (test_bit(ICE_VF_STATE_INIT, pf->vf[i].vf_states)) {
+                        /* disable VF qp mappings */
+                        ice_dis_vf_mappings(&pf->vf[i]);
+
+                        /* Set this state so that assigned VF vectors can be
+                         * reclaimed by PF for reuse in ice_vsi_release(). No
+                         * need to clear this bit since pf->vf array is being
+                         * freed anyways after this for loop
+                         */
+                        set_bit(ICE_VF_STATE_CFG_INTR, pf->vf[i].vf_states);
+                        ice_free_vf_res(&pf->vf[i]);
+                }
+        }
+
+        devm_kfree(&pf->pdev->dev, pf->vf);
+        pf->vf = NULL;
+
+        /* This check is for when the driver is unloaded while VFs are
+         * assigned. Setting the number of VFs to 0 through sysfs is caught
+         * before this function ever gets called.
+         */
+        if (!pci_vfs_assigned(pf->pdev)) {
+                int vf_id;
+
+                /* Acknowledge VFLR for all VFs. Without this, VFs will fail to
+                 * work correctly when SR-IOV gets re-enabled.
+                 */
+                for (vf_id = 0; vf_id < tmp; vf_id++) {
+                        u32 reg_idx, bit_idx;
+
+                        reg_idx = (hw->func_caps.vf_base_id + vf_id) / 32;
+                        bit_idx = (hw->func_caps.vf_base_id + vf_id) % 32;
+                        wr32(hw, GLGEN_VFLRSTAT(reg_idx), BIT(bit_idx));
+                }
+        }
+        clear_bit(__ICE_VF_DIS, pf->state);
+        clear_bit(ICE_FLAG_SRIOV_ENA, pf->flags);
+}
+
+/**
+ * ice_trigger_vf_reset - Reset a VF on HW
+ * @vf: pointer to the VF structure
+ * @is_vflr: true if VFLR was issued, false if not
+ *
+ * Trigger hardware to start a reset for a particular VF. Expects the caller
+ * to wait the proper amount of time to allow hardware to reset the VF before
+ * it cleans up and restores VF functionality.
+ */
+static void ice_trigger_vf_reset(struct ice_vf *vf, bool is_vflr)
+{
+        struct ice_pf *pf = vf->pf;
+        u32 reg, reg_idx, bit_idx;
+        struct ice_hw *hw;
+        int vf_abs_id, i;
+
+        hw = &pf->hw;
+        vf_abs_id = vf->vf_id + hw->func_caps.vf_base_id;
+
+        /* Inform VF that it is no longer active, as a warning */
+        clear_bit(ICE_VF_STATE_ACTIVE, vf->vf_states);
+
+        /* Disable VF's configuration API during reset. The flag is re-enabled
+         * in ice_alloc_vf_res(), when it's safe again to access VF's VSI.
+         * It's normally disabled in ice_free_vf_res(), but it's safer
+         * to do it earlier to give some time to finish to any VF config
+         * functions that may still be running at this point.
+         */
+        clear_bit(ICE_VF_STATE_INIT, vf->vf_states);
+
+        /* In the case of a VFLR, the HW has already reset the VF and we
+         * just need to clean up, so don't hit the VFRTRIG register.
+         */
+        if (!is_vflr) {
+                /* reset VF using VPGEN_VFRTRIG reg */
+                reg = rd32(hw, VPGEN_VFRTRIG(vf->vf_id));
+                reg |= VPGEN_VFRTRIG_VFSWR_M;
+                wr32(hw, VPGEN_VFRTRIG(vf->vf_id), reg);
+        }
+        /* clear the VFLR bit in GLGEN_VFLRSTAT */
+        reg_idx = (vf_abs_id) / 32;
+        bit_idx = (vf_abs_id) % 32;
+        wr32(hw, GLGEN_VFLRSTAT(reg_idx), BIT(bit_idx));
+        ice_flush(hw);
+
+        wr32(hw, PF_PCI_CIAA,
+             VF_DEVICE_STATUS | (vf_abs_id << PF_PCI_CIAA_VF_NUM_S));
+        for (i = 0; i < 100; i++) {
+                reg = rd32(hw, PF_PCI_CIAD);
+                if ((reg & VF_TRANS_PENDING_M) != 0)
+                        dev_err(&pf->pdev->dev,
+                                "VF %d PCI transactions stuck\n", vf->vf_id);
+                udelay(1);
+        }
+}
+
+/**
+ * ice_vsi_set_pvid - Set port VLAN id for the VSI
+ * @vsi: the VSI being changed
+ * @vid: the VLAN id to set as a PVID
+ */
+static int ice_vsi_set_pvid(struct ice_vsi *vsi, u16 vid)
+{
+        struct device *dev = &vsi->back->pdev->dev;
+        struct ice_hw *hw = &vsi->back->hw;
+        struct ice_vsi_ctx ctxt = { 0 };
+        enum ice_status status;
+
+        ctxt.info.vlan_flags = ICE_AQ_VSI_VLAN_MODE_TAGGED |
+                               ICE_AQ_VSI_PVLAN_INSERT_PVID |
+                               ICE_AQ_VSI_VLAN_EMOD_STR;
+        ctxt.info.pvid = cpu_to_le16(vid);
+        ctxt.info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_VLAN_VALID);
+
+        status = ice_update_vsi(hw, vsi->idx, &ctxt, NULL);
+        if (status) {
+                dev_info(dev, "update VSI for VLAN insert failed, err %d aq_err %d\n",
+                         status, hw->adminq.sq_last_status);
+                return -EIO;
+        }
+
+        vsi->info.pvid = ctxt.info.pvid;
+        vsi->info.vlan_flags = ctxt.info.vlan_flags;
+        return 0;
+}
+
+/**
+ * ice_vsi_kill_pvid - Remove port VLAN id from the VSI
+ * @vsi: the VSI being changed
+ */
+static int ice_vsi_kill_pvid(struct ice_vsi *vsi)
+{
+        struct ice_pf *pf = vsi->back;
+
+        if (ice_vsi_manage_vlan_stripping(vsi, false)) {
+                dev_err(&pf->pdev->dev, "Error removing Port VLAN on VSI %i\n",
+                        vsi->vsi_num);
+                return -ENODEV;
+        }
+
+        vsi->info.pvid = 0;
+        return 0;
+}
+
+/**
+ * ice_vf_vsi_setup - Set up a VF VSI
+ * @pf: board private structure
+ * @pi: pointer to the port_info instance
+ * @vf_id: defines VF id to which this VSI connects.
+ *
+ * Returns pointer to the successfully allocated VSI struct on success,
+ * otherwise returns NULL on failure.
+ */
+static struct ice_vsi *
+ice_vf_vsi_setup(struct ice_pf *pf, struct ice_port_info *pi, u16 vf_id)
+{
+        return ice_vsi_setup(pf, pi, ICE_VSI_VF, vf_id);
+}
+
+/**
+ * ice_alloc_vsi_res - Setup VF VSI and its resources
+ * @vf: pointer to the VF structure
+ *
+ * Returns 0 on success, negative value on failure
+ */
+static int ice_alloc_vsi_res(struct ice_vf *vf)
+{
+        struct ice_pf *pf = vf->pf;
+        LIST_HEAD(tmp_add_list);
+        u8 broadcast[ETH_ALEN];
+        struct ice_vsi *vsi;
+        int status = 0;
+
+        vsi = ice_vf_vsi_setup(pf, pf->hw.port_info, vf->vf_id);
+
+        if (!vsi) {
+                dev_err(&pf->pdev->dev, "Failed to create VF VSI\n");
+                return -ENOMEM;
+        }
+
+        vf->lan_vsi_idx = vsi->idx;
+        vf->lan_vsi_num = vsi->vsi_num;
+
+        /* first vector index is the VFs OICR index */
+        vf->first_vector_idx = vsi->hw_base_vector;
+        /* Since hw_base_vector holds the vector where data queue interrupts
+         * starts, increment by 1 since VFs allocated vectors include OICR intr
+         * as well.
+         */
+        vsi->hw_base_vector += 1;
+
+        /* Check if port VLAN exist before, and restore it accordingly */
+        if (vf->port_vlan_id)
+                ice_vsi_set_pvid(vsi, vf->port_vlan_id);
+
+        eth_broadcast_addr(broadcast);
+
+        status = ice_add_mac_to_list(vsi, &tmp_add_list, broadcast);
+        if (status)
+                goto ice_alloc_vsi_res_exit;
+
+        if (is_valid_ether_addr(vf->dflt_lan_addr.addr)) {
+                status = ice_add_mac_to_list(vsi, &tmp_add_list,
+                                             vf->dflt_lan_addr.addr);
+                if (status)
+                        goto ice_alloc_vsi_res_exit;
+        }
+
+        status = ice_add_mac(&pf->hw, &tmp_add_list);
+        if (status)
+                dev_err(&pf->pdev->dev, "could not add mac filters\n");
+
+        /* Clear this bit after VF initialization since we shouldn't reclaim
+         * and reassign interrupts for synchronous or asynchronous VFR events.
+         * We don't want to reconfigure interrupts since AVF driver doesn't
+         * expect vector assignment to be changed unless there is a request for
+         * more vectors.
+         */
+        clear_bit(ICE_VF_STATE_CFG_INTR, vf->vf_states);
+ice_alloc_vsi_res_exit:
+        ice_free_fltr_list(&pf->pdev->dev, &tmp_add_list);
+        return status;
+}
+
+/**
+ * ice_alloc_vf_res - Allocate VF resources
+ * @vf: pointer to the VF structure
+ */
+static int ice_alloc_vf_res(struct ice_vf *vf)
+{
+        int status;
+
+        /* setup VF VSI and necessary resources */
+        status = ice_alloc_vsi_res(vf);
+        if (status)
+                goto ice_alloc_vf_res_exit;
+
+        if (vf->trusted)
+                set_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
+        else
+                clear_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
+
+        /* VF is now completely initialized */
+        set_bit(ICE_VF_STATE_INIT, vf->vf_states);
+
+        return status;
+
+ice_alloc_vf_res_exit:
+        ice_free_vf_res(vf);
+        return status;
+}
+
+/**
+ * ice_ena_vf_mappings
+ * @vf: pointer to the VF structure
+ *
+ * Enable VF vectors and queues allocation by writing the details into
+ * respective registers.
+ */
+static void ice_ena_vf_mappings(struct ice_vf *vf)
+{
+        struct ice_pf *pf = vf->pf;
+        struct ice_vsi *vsi;
+        int first, last, v;
+        struct ice_hw *hw;
+        int abs_vf_id;
+        u32 reg;
+
+        hw = &pf->hw;
+        vsi = pf->vsi[vf->lan_vsi_idx];
+        first = vf->first_vector_idx;
+        last = (first + pf->num_vf_msix) - 1;
+        abs_vf_id = vf->vf_id + hw->func_caps.vf_base_id;
+
+        /* VF Vector allocation */
+        reg = (((first << VPINT_ALLOC_FIRST_S) & VPINT_ALLOC_FIRST_M) |
+               ((last << VPINT_ALLOC_LAST_S) & VPINT_ALLOC_LAST_M) |
+               VPINT_ALLOC_VALID_M);
+        wr32(hw, VPINT_ALLOC(vf->vf_id), reg);
+
+        /* map the interrupts to its functions */
+        for (v = first; v <= last; v++) {
+                reg = (((abs_vf_id << GLINT_VECT2FUNC_VF_NUM_S) &
+                        GLINT_VECT2FUNC_VF_NUM_M) |
+                       ((hw->pf_id << GLINT_VECT2FUNC_PF_NUM_S) &
+                        GLINT_VECT2FUNC_PF_NUM_M));
+                wr32(hw, GLINT_VECT2FUNC(v), reg);
+        }
+
+        /* VF Tx queues allocation */
+        if (vsi->tx_mapping_mode == ICE_VSI_MAP_CONTIG) {
+                wr32(hw, VPLAN_TXQ_MAPENA(vf->vf_id),
+                     VPLAN_TXQ_MAPENA_TX_ENA_M);
+                /* set the VF PF Tx queue range
+                 * VFNUMQ value should be set to (number of queues - 1). A value
+                 * of 0 means 1 queue and a value of 255 means 256 queues
+                 */
+                reg = (((vsi->txq_map[0] << VPLAN_TX_QBASE_VFFIRSTQ_S) &
+                        VPLAN_TX_QBASE_VFFIRSTQ_M) |
+                       (((vsi->alloc_txq - 1) << VPLAN_TX_QBASE_VFNUMQ_S) &
+                        VPLAN_TX_QBASE_VFNUMQ_M));
+                wr32(hw, VPLAN_TX_QBASE(vf->vf_id), reg);
+        } else {
+                dev_err(&pf->pdev->dev,
+                        "Scattered mode for VF Tx queues is not yet implemented\n");
+        }
+
+        /* VF Rx queues allocation */
+        if (vsi->rx_mapping_mode == ICE_VSI_MAP_CONTIG) {
+                wr32(hw, VPLAN_RXQ_MAPENA(vf->vf_id),
+                     VPLAN_RXQ_MAPENA_RX_ENA_M);
+                /* set the VF PF Rx queue range
+                 * VFNUMQ value should be set to (number of queues - 1). A value
+                 * of 0 means 1 queue and a value of 255 means 256 queues
+                 */
+                reg = (((vsi->rxq_map[0] << VPLAN_RX_QBASE_VFFIRSTQ_S) &
+                        VPLAN_RX_QBASE_VFFIRSTQ_M) |
+                       (((vsi->alloc_txq - 1) << VPLAN_RX_QBASE_VFNUMQ_S) &
+                        VPLAN_RX_QBASE_VFNUMQ_M));
+                wr32(hw, VPLAN_RX_QBASE(vf->vf_id), reg);
+        } else {
+                dev_err(&pf->pdev->dev,
+                        "Scattered mode for VF Rx queues is not yet implemented\n");
+        }
+}
+
+/**
+ * ice_determine_res
+ * @pf: pointer to the PF structure
+ * @avail_res: available resources in the PF structure
+ * @max_res: maximum resources that can be given per VF
+ * @min_res: minimum resources that can be given per VF
+ *
+ * Returns non-zero value if resources (queues/vectors) are available or
+ * returns zero if PF cannot accommodate for all num_alloc_vfs.
+ */
+static int
+ice_determine_res(struct ice_pf *pf, u16 avail_res, u16 max_res, u16 min_res)
+{
+        bool checked_min_res = false;
+        int res;
+
+        /* start by checking if PF can assign max number of resources for
+         * all num_alloc_vfs.
+         * if yes, return number per VF
+         * If no, divide by 2 and roundup, check again
+         * repeat the loop till we reach a point where even minimum resources
+         * are not available, in that case return 0
+         */
+        res = max_res;
+        while ((res >= min_res) && !checked_min_res) {
+                int num_all_res;
+
+                num_all_res = pf->num_alloc_vfs * res;
+                if (num_all_res <= avail_res)
+                        return res;
+
+                if (res == min_res)
+                        checked_min_res = true;
+
+                res = DIV_ROUND_UP(res, 2);
+        }
+        return 0;
+}
+
+/**
+ * ice_check_avail_res - check if vectors and queues are available
+ * @pf: pointer to the PF structure
+ *
+ * This function is where we calculate actual number of resources for VF VSIs,
+ * we don't reserve ahead of time during probe. Returns success if vectors and
+ * queues resources are available, otherwise returns error code
+ */
+static int ice_check_avail_res(struct ice_pf *pf)
+{
+        u16 num_msix, num_txq, num_rxq;
+
+        if (!pf->num_alloc_vfs)
+                return -EINVAL;
+
+        /* Grab from HW interrupts common pool
+         * Note: By the time the user decides it needs more vectors in a VF
+         * its already too late since one must decide this prior to creating the
+         * VF interface. So the best we can do is take a guess as to what the
+         * user might want.
+         *
+         * We have two policies for vector allocation:
+         * 1. if num_alloc_vfs is from 1 to 16, then we consider this as small
+         * number of NFV VFs used for NFV appliances, since this is a special
+         * case, we try to assign maximum vectors per VF (65) as much as
+         * possible, based on determine_resources algorithm.
+         * 2. if num_alloc_vfs is from 17 to 256, then its large number of
+         * regular VFs which are not used for any special purpose. Hence try to
+         * grab default interrupt vectors (5 as supported by AVF driver).
+         */
+        if (pf->num_alloc_vfs <= 16) {
+                num_msix = ice_determine_res(pf, pf->num_avail_hw_msix,
+                                             ICE_MAX_INTR_PER_VF,
+                                             ICE_MIN_INTR_PER_VF);
+        } else if (pf->num_alloc_vfs <= ICE_MAX_VF_COUNT) {
+                num_msix = ice_determine_res(pf, pf->num_avail_hw_msix,
+                                             ICE_DFLT_INTR_PER_VF,
+                                             ICE_MIN_INTR_PER_VF);
+        } else {
+                dev_err(&pf->pdev->dev,
+                        "Number of VFs %d exceeds max VF count %d\n",
+                        pf->num_alloc_vfs, ICE_MAX_VF_COUNT);
+                return -EIO;
+        }
+
+        if (!num_msix)
+                return -EIO;
+
+        /* Grab from the common pool
+         * start by requesting Default queues (4 as supported by AVF driver),
+         * Note that, the main difference between queues and vectors is, latter
+         * can only be reserved at init time but queues can be requested by VF
+         * at runtime through Virtchnl, that is the reason we start by reserving
+         * few queues.
+         */
+        num_txq = ice_determine_res(pf, pf->q_left_tx, ICE_DFLT_QS_PER_VF,
+                                    ICE_MIN_QS_PER_VF);
+
+        num_rxq = ice_determine_res(pf, pf->q_left_rx, ICE_DFLT_QS_PER_VF,
+                                    ICE_MIN_QS_PER_VF);
+
+        if (!num_txq || !num_rxq)
+                return -EIO;
+
+        /* since AVF driver works with only queue pairs which means, it expects
+         * to have equal number of Rx and Tx queues, so take the minimum of
+         * available Tx or Rx queues
+         */
+        pf->num_vf_qps = min_t(int, num_txq, num_rxq);
+        pf->num_vf_msix = num_msix;
+
+        return 0;
+}
+
+/**
+ * ice_cleanup_and_realloc_vf - Clean up VF and reallocate resources after reset
+ * @vf: pointer to the VF structure
+ *
+ * Cleanup a VF after the hardware reset is finished. Expects the caller to
+ * have verified whether the reset is finished properly, and ensure the
+ * minimum amount of wait time has passed. Reallocate VF resources back to make
+ * VF state active
+ */
+static void ice_cleanup_and_realloc_vf(struct ice_vf *vf)
+{
+        struct ice_pf *pf = vf->pf;
+        struct ice_hw *hw;
+        u32 reg;
+
+        hw = &pf->hw;
+
+        /* PF software completes the flow by notifying VF that reset flow is
+         * completed. This is done by enabling hardware by clearing the reset
+         * bit in the VPGEN_VFRTRIG reg and setting VFR_STATE in the VFGEN_RSTAT
+         * register to VFR completed (done at the end of this function)
+         * By doing this we allow HW to access VF memory at any point. If we
+         * did it any sooner, HW could access memory while it was being freed
+         * in ice_free_vf_res(), causing an IOMMU fault.
+         *
+         * On the other hand, this needs to be done ASAP, because the VF driver
+         * is waiting for this to happen and may report a timeout. It's
+         * harmless, but it gets logged into Guest OS kernel log, so best avoid
+         * it.
+         */
+        reg = rd32(hw, VPGEN_VFRTRIG(vf->vf_id));
+        reg &= ~VPGEN_VFRTRIG_VFSWR_M;
+        wr32(hw, VPGEN_VFRTRIG(vf->vf_id), reg);
+
+        /* reallocate VF resources to finish resetting the VSI state */
+        if (!ice_alloc_vf_res(vf)) {
+                ice_ena_vf_mappings(vf);
+                set_bit(ICE_VF_STATE_ACTIVE, vf->vf_states);
+                clear_bit(ICE_VF_STATE_DIS, vf->vf_states);
+                vf->num_vlan = 0;
+        }
+
+        /* Tell the VF driver the reset is done. This needs to be done only
+         * after VF has been fully initialized, because the VF driver may
+         * request resources immediately after setting this flag.
+         */
+        wr32(hw, VFGEN_RSTAT(vf->vf_id), VIRTCHNL_VFR_VFACTIVE);
+}
+
+/**
+ * ice_reset_all_vfs - reset all allocated VFs in one go
+ * @pf: pointer to the PF structure
+ * @is_vflr: true if VFLR was issued, false if not
+ *
+ * First, tell the hardware to reset each VF, then do all the waiting in one
+ * chunk, and finally finish restoring each VF after the wait. This is useful
+ * during PF routines which need to reset all VFs, as otherwise it must perform
+ * these resets in a serialized fashion.
+ *
+ * Returns true if any VFs were reset, and false otherwise.
+ */
+bool ice_reset_all_vfs(struct ice_pf *pf, bool is_vflr)
+{
+        struct ice_hw *hw = &pf->hw;
+        int v, i;
+
+        /* If we don't have any VFs, then there is nothing to reset */
+        if (!pf->num_alloc_vfs)
+                return false;
+
+        /* If VFs have been disabled, there is no need to reset */
+        if (test_and_set_bit(__ICE_VF_DIS, pf->state))
+                return false;
+
+        /* Begin reset on all VFs at once */
+        for (v = 0; v < pf->num_alloc_vfs; v++)
+                ice_trigger_vf_reset(&pf->vf[v], is_vflr);
+
+        /* Call Disable LAN Tx queue AQ call with VFR bit set and 0
+         * queues to inform Firmware about VF reset.
+         */
+        for (v = 0; v < pf->num_alloc_vfs; v++)
+                ice_dis_vsi_txq(pf->vsi[0]->port_info, 0, NULL, NULL,
+                                ICE_VF_RESET, v, NULL);
+
+        /* HW requires some time to make sure it can flush the FIFO for a VF
+         * when it resets it. Poll the VPGEN_VFRSTAT register for each VF in
+         * sequence to make sure that it has completed. We'll keep track of
+         * the VFs using a simple iterator that increments once that VF has
+         * finished resetting.
+         */
+        for (i = 0, v = 0; i < 10 && v < pf->num_alloc_vfs; i++) {
+                usleep_range(10000, 20000);
+
+                /* Check each VF in sequence */
+                while (v < pf->num_alloc_vfs) {
+                        struct ice_vf *vf = &pf->vf[v];
+                        u32 reg;
+
+                        reg = rd32(hw, VPGEN_VFRSTAT(vf->vf_id));
+                        if (!(reg & VPGEN_VFRSTAT_VFRD_M))
+                                break;
+
+                        /* If the current VF has finished resetting, move on
+                         * to the next VF in sequence.
+                         */
+                        v++;
+                }
+        }
+
+        /* Display a warning if at least one VF didn't manage to reset in
+         * time, but continue on with the operation.
+         */
+        if (v < pf->num_alloc_vfs)
+                dev_warn(&pf->pdev->dev, "VF reset check timeout\n");
+        usleep_range(10000, 20000);
+
+        /* free VF resources to begin resetting the VSI state */
+        for (v = 0; v < pf->num_alloc_vfs; v++)
+                ice_free_vf_res(&pf->vf[v]);
+
+        if (ice_check_avail_res(pf)) {
+                dev_err(&pf->pdev->dev,
+                        "Cannot allocate VF resources, try with fewer number of VFs\n");
+                return false;
+        }
+
+        /* Finish the reset on each VF */
+        for (v = 0; v < pf->num_alloc_vfs; v++)
+                ice_cleanup_and_realloc_vf(&pf->vf[v]);
+
+        ice_flush(hw);
+        clear_bit(__ICE_VF_DIS, pf->state);
+
+        return true;
+}
+
+/**
+ * ice_reset_vf - Reset a particular VF
+ * @vf: pointer to the VF structure
+ * @is_vflr: true if VFLR was issued, false if not
+ *
+ * Returns true if the VF is reset, false otherwise.
+ */
+static bool ice_reset_vf(struct ice_vf *vf, bool is_vflr)
+{
+        struct ice_pf *pf = vf->pf;
+        struct ice_hw *hw = &pf->hw;
+        bool rsd = false;
+        u32 reg;
+        int i;
+
+        /* If the VFs have been disabled, this means something else is
+         * resetting the VF, so we shouldn't continue.
+         */
+        if (test_and_set_bit(__ICE_VF_DIS, pf->state))
+                return false;
+
+        ice_trigger_vf_reset(vf, is_vflr);
+
+        if (test_bit(ICE_VF_STATE_ENA, vf->vf_states)) {
+                ice_vsi_stop_tx_rings(pf->vsi[vf->lan_vsi_idx], ICE_VF_RESET,
+                                      vf->vf_id);
+                ice_vsi_stop_rx_rings(pf->vsi[vf->lan_vsi_idx]);
+                clear_bit(ICE_VF_STATE_ENA, vf->vf_states);
+        } else {
+                /* Call Disable LAN Tx queue AQ call even when queues are not
+                 * enabled. This is needed for successful completiom of VFR
+                 */
+                ice_dis_vsi_txq(pf->vsi[vf->lan_vsi_idx]->port_info, 0,
+                                NULL, NULL, ICE_VF_RESET, vf->vf_id, NULL);
+        }
+
+        /* poll VPGEN_VFRSTAT reg to make sure
+         * that reset is complete
+         */
+        for (i = 0; i < 10; i++) {
+                /* VF reset requires driver to first reset the VF and then
+                 * poll the status register to make sure that the reset
+                 * completed successfully.
+                 */
+                usleep_range(10000, 20000);
+                reg = rd32(hw, VPGEN_VFRSTAT(vf->vf_id));
+                if (reg & VPGEN_VFRSTAT_VFRD_M) {
+                        rsd = true;
+                        break;
+                }
+        }
+
+        /* Display a warning if VF didn't manage to reset in time, but need to
+         * continue on with the operation.
+         */
+        if (!rsd)
+                dev_warn(&pf->pdev->dev, "VF reset check timeout on VF %d\n",
+                         vf->vf_id);
+
+        usleep_range(10000, 20000);
+
+        /* free VF resources to begin resetting the VSI state */
+        ice_free_vf_res(vf);
+
+        ice_cleanup_and_realloc_vf(vf);
+
+        ice_flush(hw);
+        clear_bit(__ICE_VF_DIS, pf->state);
+
+        return true;
+}
+
+/**
+ * ice_vc_notify_link_state - Inform all VFs on a PF of link status
+ * @pf: pointer to the PF structure
+ */
+void ice_vc_notify_link_state(struct ice_pf *pf)
+{
+        int i;
+
+        for (i = 0; i < pf->num_alloc_vfs; i++)
+                ice_vc_notify_vf_link_state(&pf->vf[i]);
+}
+
+/**
+ * ice_vc_notify_reset - Send pending reset message to all VFs
+ * @pf: pointer to the PF structure
+ *
+ * indicate a pending reset to all VFs on a given PF
+ */
+void ice_vc_notify_reset(struct ice_pf *pf)
+{
+        struct virtchnl_pf_event pfe;
+
+        if (!pf->num_alloc_vfs)
+                return;
+
+        pfe.event = VIRTCHNL_EVENT_RESET_IMPENDING;
+        pfe.severity = PF_EVENT_SEVERITY_CERTAIN_DOOM;
+        ice_vc_vf_broadcast(pf, VIRTCHNL_OP_EVENT, ICE_SUCCESS,
+                            (u8 *)&pfe, sizeof(struct virtchnl_pf_event));
+}
+
+/**
+ * ice_vc_notify_vf_reset - Notify VF of a reset event
+ * @vf: pointer to the VF structure
+ */
+static void ice_vc_notify_vf_reset(struct ice_vf *vf)
+{
+        struct virtchnl_pf_event pfe;
+
+        /* validate the request */
+        if (!vf || vf->vf_id >= vf->pf->num_alloc_vfs)
+                return;
+
+        /* verify if the VF is in either init or active before proceeding */
+        if (!test_bit(ICE_VF_STATE_INIT, vf->vf_states) &&
+            !test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states))
+                return;
+
+        pfe.event = VIRTCHNL_EVENT_RESET_IMPENDING;
+        pfe.severity = PF_EVENT_SEVERITY_CERTAIN_DOOM;
+        ice_aq_send_msg_to_vf(&vf->pf->hw, vf->vf_id, VIRTCHNL_OP_EVENT, 0,
+                              (u8 *)&pfe, sizeof(pfe), NULL);
+}
+
+/**
+ * ice_alloc_vfs - Allocate and set up VFs resources
+ * @pf: pointer to the PF structure
+ * @num_alloc_vfs: number of VFs to allocate
+ */
+static int ice_alloc_vfs(struct ice_pf *pf, u16 num_alloc_vfs)
+{
+        struct ice_hw *hw = &pf->hw;
+        struct ice_vf *vfs;
+        int i, ret;
+
+        /* Disable global interrupt 0 so we don't try to handle the VFLR. */
+        wr32(hw, GLINT_DYN_CTL(pf->hw_oicr_idx),
+             ICE_ITR_NONE << GLINT_DYN_CTL_ITR_INDX_S);
+
+        ice_flush(hw);
+
+        ret = pci_enable_sriov(pf->pdev, num_alloc_vfs);
+        if (ret) {
+                pf->num_alloc_vfs = 0;
+                goto err_unroll_intr;
+        }
+        /* allocate memory */
+        vfs = devm_kcalloc(&pf->pdev->dev, num_alloc_vfs, sizeof(*vfs),
+                           GFP_KERNEL);
+        if (!vfs) {
+                ret = -ENOMEM;
+                goto err_unroll_sriov;
+        }
+        pf->vf = vfs;
+
+        /* apply default profile */
+        for (i = 0; i < num_alloc_vfs; i++) {
+                vfs[i].pf = pf;
+                vfs[i].vf_sw_id = pf->first_sw;
+                vfs[i].vf_id = i;
+
+                /* assign default capabilities */
+                set_bit(ICE_VIRTCHNL_VF_CAP_L2, &vfs[i].vf_caps);
+                vfs[i].spoofchk = true;
+
+                /* Set this state so that PF driver does VF vector assignment */
+                set_bit(ICE_VF_STATE_CFG_INTR, vfs[i].vf_states);
+        }
+        pf->num_alloc_vfs = num_alloc_vfs;
+
+        /* VF resources get allocated during reset */
+        if (!ice_reset_all_vfs(pf, false))
+                goto err_unroll_sriov;
+
+        goto err_unroll_intr;
+
+err_unroll_sriov:
+        pci_disable_sriov(pf->pdev);
+err_unroll_intr:
+        /* rearm interrupts here */
+        ice_irq_dynamic_ena(hw, NULL, NULL);
+        return ret;
+}
+
+/**
+ * ice_pf_state_is_nominal - checks the pf for nominal state
+ * @pf: pointer to pf to check
+ *
+ * Check the PF's state for a collection of bits that would indicate
+ * the PF is in a state that would inhibit normal operation for
+ * driver functionality.
+ *
+ * Returns true if PF is in a nominal state.
+ * Returns false otherwise
+ */
+static bool ice_pf_state_is_nominal(struct ice_pf *pf)
+{
+        DECLARE_BITMAP(check_bits, __ICE_STATE_NBITS) = { 0 };
+
+        if (!pf)
+                return false;
+
+        bitmap_set(check_bits, 0, __ICE_STATE_NOMINAL_CHECK_BITS);
+        if (bitmap_intersects(pf->state, check_bits, __ICE_STATE_NBITS))
+                return false;
+
+        return true;
+}
+
+/**
+ * ice_pci_sriov_ena - Enable or change number of VFs
+ * @pf: pointer to the PF structure
+ * @num_vfs: number of VFs to allocate
+ */
+static int ice_pci_sriov_ena(struct ice_pf *pf, int num_vfs)
+{
+        int pre_existing_vfs = pci_num_vf(pf->pdev);
+        struct device *dev = &pf->pdev->dev;
+        int err;
+
+        if (!ice_pf_state_is_nominal(pf)) {
+                dev_err(dev, "Cannot enable SR-IOV, device not ready\n");
+                return -EBUSY;
+        }
+
+        if (!test_bit(ICE_FLAG_SRIOV_CAPABLE, pf->flags)) {
+                dev_err(dev, "This device is not capable of SR-IOV\n");
+                return -ENODEV;
+        }
+
+        if (pre_existing_vfs && pre_existing_vfs != num_vfs)
+                ice_free_vfs(pf);
+        else if (pre_existing_vfs && pre_existing_vfs == num_vfs)
+                return num_vfs;
+
+        if (num_vfs > pf->num_vfs_supported) {
+                dev_err(dev, "Can't enable %d VFs, max VFs supported is %d\n",
+                        num_vfs, pf->num_vfs_supported);
+                return -ENOTSUPP;
+        }
+
+        dev_info(dev, "Allocating %d VFs\n", num_vfs);
+        err = ice_alloc_vfs(pf, num_vfs);
+        if (err) {
+                dev_err(dev, "Failed to enable SR-IOV: %d\n", err);
+                return err;
+        }
+
+        set_bit(ICE_FLAG_SRIOV_ENA, pf->flags);
+        return num_vfs;
+}
+
+/**
+ * ice_sriov_configure - Enable or change number of VFs via sysfs
+ * @pdev: pointer to a pci_dev structure
+ * @num_vfs: number of VFs to allocate
+ *
+ * This function is called when the user updates the number of VFs in sysfs.
+ */
+int ice_sriov_configure(struct pci_dev *pdev, int num_vfs)
+{
+        struct ice_pf *pf = pci_get_drvdata(pdev);
+
+        if (num_vfs)
+                return ice_pci_sriov_ena(pf, num_vfs);
+
+        if (!pci_vfs_assigned(pdev)) {
+                ice_free_vfs(pf);
+        } else {
+                dev_err(&pf->pdev->dev,
+                        "can't free VFs because some are assigned to VMs.\n");
+                return -EBUSY;
+        }
+
+        return 0;
+}
+
+/**
+ * ice_process_vflr_event - Free VF resources via IRQ calls
+ * @pf: pointer to the PF structure
+ *
+ * called from the VLFR IRQ handler to
+ * free up VF resources and state variables
+ */
+void ice_process_vflr_event(struct ice_pf *pf)
+{
+        struct ice_hw *hw = &pf->hw;
+        int vf_id;
+        u32 reg;
+
+        if (!test_bit(__ICE_VFLR_EVENT_PENDING, pf->state) ||
+            !pf->num_alloc_vfs)
+                return;
+
+        /* Re-enable the VFLR interrupt cause here, before looking for which
+         * VF got reset. Otherwise, if another VF gets a reset while the
+         * first one is being processed, that interrupt will be lost, and
+         * that VF will be stuck in reset forever.
+         */
+        reg = rd32(hw, PFINT_OICR_ENA);
+        reg |= PFINT_OICR_VFLR_M;
+        wr32(hw, PFINT_OICR_ENA, reg);
+        ice_flush(hw);
+
+        clear_bit(__ICE_VFLR_EVENT_PENDING, pf->state);
+        for (vf_id = 0; vf_id < pf->num_alloc_vfs; vf_id++) {
+                struct ice_vf *vf = &pf->vf[vf_id];
+                u32 reg_idx, bit_idx;
+
+                reg_idx = (hw->func_caps.vf_base_id + vf_id) / 32;
+                bit_idx = (hw->func_caps.vf_base_id + vf_id) % 32;
+                /* read GLGEN_VFLRSTAT register to find out the flr VFs */
+                reg = rd32(hw, GLGEN_VFLRSTAT(reg_idx));
+                if (reg & BIT(bit_idx))
+                        /* GLGEN_VFLRSTAT bit will be cleared in ice_reset_vf */
+                        ice_reset_vf(vf, true);
+        }
+}
+
+/**
+ * ice_vc_dis_vf - Disable a given VF via SW reset
+ * @vf: pointer to the VF info
+ *
+ * Disable the VF through a SW reset
+ */
+static void ice_vc_dis_vf(struct ice_vf *vf)
+{
+        ice_vc_notify_vf_reset(vf);
+        ice_reset_vf(vf, false);
+}
+
+/**
+ * ice_vc_send_msg_to_vf - Send message to VF
+ * @vf: pointer to the VF info
+ * @v_opcode: virtual channel opcode
+ * @v_retval: virtual channel return value
+ * @msg: pointer to the msg buffer
+ * @msglen: msg length
+ *
+ * send msg to VF
+ */
+static int ice_vc_send_msg_to_vf(struct ice_vf *vf, u32 v_opcode,
+                                 enum ice_status v_retval, u8 *msg, u16 msglen)
+{
+        enum ice_status aq_ret;
+        struct ice_pf *pf;
+
+        /* validate the request */
+        if (!vf || vf->vf_id >= vf->pf->num_alloc_vfs)
+                return -EINVAL;
+
+        pf = vf->pf;
+
+        /* single place to detect unsuccessful return values */
+        if (v_retval) {
+                vf->num_inval_msgs++;
+                dev_info(&pf->pdev->dev, "VF %d failed opcode %d, retval: %d\n",
+                         vf->vf_id, v_opcode, v_retval);
+                if (vf->num_inval_msgs > ICE_DFLT_NUM_INVAL_MSGS_ALLOWED) {
+                        dev_err(&pf->pdev->dev,
+                                "Number of invalid messages exceeded for VF %d\n",
+                                vf->vf_id);
+                        dev_err(&pf->pdev->dev, "Use PF Control I/F to enable the VF\n");
+                        set_bit(ICE_VF_STATE_DIS, vf->vf_states);
+                        return -EIO;
+                }
+        } else {
+                vf->num_valid_msgs++;
+                /* reset the invalid counter, if a valid message is received. */
+                vf->num_inval_msgs = 0;
+        }
+
+        aq_ret = ice_aq_send_msg_to_vf(&pf->hw, vf->vf_id, v_opcode, v_retval,
+                                       msg, msglen, NULL);
+        if (aq_ret) {
+                dev_info(&pf->pdev->dev,
+                         "Unable to send the message to VF %d aq_err %d\n",
+                         vf->vf_id, pf->hw.mailboxq.sq_last_status);
+                return -EIO;
+        }
+
+        return 0;
+}
+
+/**
+ * ice_vc_get_ver_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ *
+ * called from the VF to request the API version used by the PF
+ */
+static int ice_vc_get_ver_msg(struct ice_vf *vf, u8 *msg)
+{
+        struct virtchnl_version_info info = {
+                VIRTCHNL_VERSION_MAJOR, VIRTCHNL_VERSION_MINOR
+        };
+
+        vf->vf_ver = *(struct virtchnl_version_info *)msg;
+        /* VFs running the 1.0 API expect to get 1.0 back or they will cry. */
+        if (VF_IS_V10(&vf->vf_ver))
+                info.minor = VIRTCHNL_VERSION_MINOR_NO_VF_CAPS;
+
+        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_VERSION, ICE_SUCCESS,
+                                     (u8 *)&info,
+                                     sizeof(struct virtchnl_version_info));
+}
+
+/**
+ * ice_vc_get_vf_res_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ *
+ * called from the VF to request its resources
+ */
+static int ice_vc_get_vf_res_msg(struct ice_vf *vf, u8 *msg)
+{
+        struct virtchnl_vf_resource *vfres = NULL;
+        enum ice_status aq_ret = 0;
+        struct ice_pf *pf = vf->pf;
+        struct ice_vsi *vsi;
+        int len = 0;
+        int ret;
+
+        if (!test_bit(ICE_VF_STATE_INIT, vf->vf_states)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto err;
+        }
+
+        len = sizeof(struct virtchnl_vf_resource);
+
+        vfres = devm_kzalloc(&pf->pdev->dev, len, GFP_KERNEL);
+        if (!vfres) {
+                aq_ret = ICE_ERR_NO_MEMORY;
+                len = 0;
+                goto err;
+        }
+        if (VF_IS_V11(&vf->vf_ver))
+                vf->driver_caps = *(u32 *)msg;
+        else
+                vf->driver_caps = VIRTCHNL_VF_OFFLOAD_L2 |
+                                  VIRTCHNL_VF_OFFLOAD_RSS_REG |
+                                  VIRTCHNL_VF_OFFLOAD_VLAN;
+
+        vfres->vf_cap_flags = VIRTCHNL_VF_OFFLOAD_L2;
+        vsi = pf->vsi[vf->lan_vsi_idx];
+        if (!vsi->info.pvid)
+                vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_VLAN;
+
+        if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RSS_PF) {
+                vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RSS_PF;
+        } else {
+                if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RSS_AQ)
+                        vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RSS_AQ;
+                else
+                        vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RSS_REG;
+        }
+
+        if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2)
+                vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RSS_PCTYPE_V2;
+
+        if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_ENCAP)
+                vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_ENCAP;
+
+        if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM)
+                vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_ENCAP_CSUM;
+
+        if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_RX_POLLING)
+                vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_RX_POLLING;
+
+        if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_WB_ON_ITR)
+                vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_WB_ON_ITR;
+
+        if (vf->driver_caps & VIRTCHNL_VF_OFFLOAD_REQ_QUEUES)
+                vfres->vf_cap_flags |= VIRTCHNL_VF_OFFLOAD_REQ_QUEUES;
+
+        if (vf->driver_caps & VIRTCHNL_VF_CAP_ADV_LINK_SPEED)
+                vfres->vf_cap_flags |= VIRTCHNL_VF_CAP_ADV_LINK_SPEED;
+
+        vfres->num_vsis = 1;
+        /* Tx and Rx queue are equal for VF */
+        vfres->num_queue_pairs = vsi->num_txq;
+        vfres->max_vectors = pf->num_vf_msix;
+        vfres->rss_key_size = ICE_VSIQF_HKEY_ARRAY_SIZE;
+        vfres->rss_lut_size = ICE_VSIQF_HLUT_ARRAY_SIZE;
+
+        vfres->vsi_res[0].vsi_id = vf->lan_vsi_num;
+        vfres->vsi_res[0].vsi_type = VIRTCHNL_VSI_SRIOV;
+        vfres->vsi_res[0].num_queue_pairs = vsi->num_txq;
+        ether_addr_copy(vfres->vsi_res[0].default_mac_addr,
+                        vf->dflt_lan_addr.addr);
+
+        set_bit(ICE_VF_STATE_ACTIVE, vf->vf_states);
+
+err:
+        /* send the response back to the VF */
+        ret = ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_VF_RESOURCES, aq_ret,
+                                    (u8 *)vfres, len);
+
+        devm_kfree(&pf->pdev->dev, vfres);
+        return ret;
+}
+
+/**
+ * ice_vc_reset_vf_msg
+ * @vf: pointer to the VF info
+ *
+ * called from the VF to reset itself,
+ * unlike other virtchnl messages, PF driver
+ * doesn't send the response back to the VF
+ */
+static void ice_vc_reset_vf_msg(struct ice_vf *vf)
+{
+        if (test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states))
+                ice_reset_vf(vf, false);
+}
+
+/**
+ * ice_find_vsi_from_id
+ * @pf: the pf structure to search for the VSI
+ * @id: id of the VSI it is searching for
+ *
+ * searches for the VSI with the given id
+ */
+static struct ice_vsi *ice_find_vsi_from_id(struct ice_pf *pf, u16 id)
+{
+        int i;
+
+        for (i = 0; i < pf->num_alloc_vsi; i++)
+                if (pf->vsi[i] && pf->vsi[i]->vsi_num == id)
+                        return pf->vsi[i];
+
+        return NULL;
+}
+
+/**
+ * ice_vc_isvalid_vsi_id
+ * @vf: pointer to the VF info
+ * @vsi_id: VF relative VSI id
+ *
+ * check for the valid VSI id
+ */
+static bool ice_vc_isvalid_vsi_id(struct ice_vf *vf, u16 vsi_id)
+{
+        struct ice_pf *pf = vf->pf;
+        struct ice_vsi *vsi;
+
+        vsi = ice_find_vsi_from_id(pf, vsi_id);
+
+        return (vsi && (vsi->vf_id == vf->vf_id));
+}
+
+/**
+ * ice_vc_isvalid_q_id
+ * @vf: pointer to the VF info
+ * @vsi_id: VSI id
+ * @qid: VSI relative queue id
+ *
+ * check for the valid queue id
+ */
+static bool ice_vc_isvalid_q_id(struct ice_vf *vf, u16 vsi_id, u8 qid)
+{
+        struct ice_vsi *vsi = ice_find_vsi_from_id(vf->pf, vsi_id);
+        /* allocated Tx and Rx queues should be always equal for VF VSI */
+        return (vsi && (qid < vsi->alloc_txq));
+}
+
+/**
+ * ice_vc_config_rss_key
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ *
+ * Configure the VF's RSS key
+ */
+static int ice_vc_config_rss_key(struct ice_vf *vf, u8 *msg)
+{
+        struct virtchnl_rss_key *vrk =
+                (struct virtchnl_rss_key *)msg;
+        struct ice_vsi *vsi = NULL;
+        enum ice_status aq_ret;
+        int ret;
+
+        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (!ice_vc_isvalid_vsi_id(vf, vrk->vsi_id)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        vsi = ice_find_vsi_from_id(vf->pf, vrk->vsi_id);
+        if (!vsi) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (vrk->key_len != ICE_VSIQF_HKEY_ARRAY_SIZE) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (!test_bit(ICE_FLAG_RSS_ENA, vf->pf->flags)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        ret = ice_set_rss(vsi, vrk->key, NULL, 0);
+        aq_ret = ret ? ICE_ERR_PARAM : ICE_SUCCESS;
+error_param:
+        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_CONFIG_RSS_KEY, aq_ret,
+                                     NULL, 0);
+}
+
+/**
+ * ice_vc_config_rss_lut
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ *
+ * Configure the VF's RSS LUT
+ */
+static int ice_vc_config_rss_lut(struct ice_vf *vf, u8 *msg)
+{
+        struct virtchnl_rss_lut *vrl = (struct virtchnl_rss_lut *)msg;
+        struct ice_vsi *vsi = NULL;
+        enum ice_status aq_ret;
+        int ret;
+
+        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (!ice_vc_isvalid_vsi_id(vf, vrl->vsi_id)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        vsi = ice_find_vsi_from_id(vf->pf, vrl->vsi_id);
+        if (!vsi) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (vrl->lut_entries != ICE_VSIQF_HLUT_ARRAY_SIZE) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (!test_bit(ICE_FLAG_RSS_ENA, vf->pf->flags)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        ret = ice_set_rss(vsi, NULL, vrl->lut, ICE_VSIQF_HLUT_ARRAY_SIZE);
+        aq_ret = ret ? ICE_ERR_PARAM : ICE_SUCCESS;
+error_param:
+        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_CONFIG_RSS_LUT, aq_ret,
+                                     NULL, 0);
+}
+
+/**
+ * ice_vc_get_stats_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ *
+ * called from the VF to get VSI stats
+ */
+static int ice_vc_get_stats_msg(struct ice_vf *vf, u8 *msg)
+{
+        struct virtchnl_queue_select *vqs =
+                (struct virtchnl_queue_select *)msg;
+        enum ice_status aq_ret = 0;
+        struct ice_eth_stats stats;
+        struct ice_vsi *vsi;
+
+        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (!ice_vc_isvalid_vsi_id(vf, vqs->vsi_id)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        vsi = ice_find_vsi_from_id(vf->pf, vqs->vsi_id);
+        if (!vsi) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        memset(&stats, 0, sizeof(struct ice_eth_stats));
+        ice_update_eth_stats(vsi);
+
+        stats = vsi->eth_stats;
+
+error_param:
+        /* send the response to the VF */
+        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_GET_STATS, aq_ret,
+                                     (u8 *)&stats, sizeof(stats));
+}
+
+/**
+ * ice_vc_ena_qs_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ *
+ * called from the VF to enable all or specific queue(s)
+ */
+static int ice_vc_ena_qs_msg(struct ice_vf *vf, u8 *msg)
+{
+        struct virtchnl_queue_select *vqs =
+            (struct virtchnl_queue_select *)msg;
+        enum ice_status aq_ret = 0;
+        struct ice_vsi *vsi;
+
+        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (!ice_vc_isvalid_vsi_id(vf, vqs->vsi_id)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (!vqs->rx_queues && !vqs->tx_queues) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        vsi = ice_find_vsi_from_id(vf->pf, vqs->vsi_id);
+        if (!vsi) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        /* Enable only Rx rings, Tx rings were enabled by the FW when the
+         * Tx queue group list was configured and the context bits were
+         * programmed using ice_vsi_cfg_txqs
+         */
+        if (ice_vsi_start_rx_rings(vsi))
+                aq_ret = ICE_ERR_PARAM;
+
+        /* Set flag to indicate that queues are enabled */
+        if (!aq_ret)
+                set_bit(ICE_VF_STATE_ENA, vf->vf_states);
+
+error_param:
+        /* send the response to the VF */
+        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_ENABLE_QUEUES, aq_ret,
+                                     NULL, 0);
+}
+
+/**
+ * ice_vc_dis_qs_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ *
+ * called from the VF to disable all or specific
+ * queue(s)
+ */
+static int ice_vc_dis_qs_msg(struct ice_vf *vf, u8 *msg)
+{
+        struct virtchnl_queue_select *vqs =
+            (struct virtchnl_queue_select *)msg;
+        enum ice_status aq_ret = 0;
+        struct ice_vsi *vsi;
+
+        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states) &&
+            !test_bit(ICE_VF_STATE_ENA, vf->vf_states)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (!ice_vc_isvalid_vsi_id(vf, vqs->vsi_id)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (!vqs->rx_queues && !vqs->tx_queues) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        vsi = ice_find_vsi_from_id(vf->pf, vqs->vsi_id);
+        if (!vsi) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (ice_vsi_stop_tx_rings(vsi, ICE_NO_RESET, vf->vf_id)) {
+                dev_err(&vsi->back->pdev->dev,
+                        "Failed to stop tx rings on VSI %d\n",
+                        vsi->vsi_num);
+                aq_ret = ICE_ERR_PARAM;
+        }
+
+        if (ice_vsi_stop_rx_rings(vsi)) {
+                dev_err(&vsi->back->pdev->dev,
+                        "Failed to stop rx rings on VSI %d\n",
+                        vsi->vsi_num);
+                aq_ret = ICE_ERR_PARAM;
+        }
+
+        /* Clear enabled queues flag */
+        if (!aq_ret)
+                clear_bit(ICE_VF_STATE_ENA, vf->vf_states);
+
+error_param:
+        /* send the response to the VF */
+        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_DISABLE_QUEUES, aq_ret,
+                                     NULL, 0);
+}
+
+/**
+ * ice_vc_cfg_irq_map_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ *
+ * called from the VF to configure the IRQ to queue map
+ */
+static int ice_vc_cfg_irq_map_msg(struct ice_vf *vf, u8 *msg)
+{
+        struct virtchnl_irq_map_info *irqmap_info =
+            (struct virtchnl_irq_map_info *)msg;
+        u16 vsi_id, vsi_q_id, vector_id;
+        struct virtchnl_vector_map *map;
+        struct ice_vsi *vsi = NULL;
+        struct ice_pf *pf = vf->pf;
+        enum ice_status aq_ret = 0;
+        unsigned long qmap;
+        int i;
+
+        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        for (i = 0; i < irqmap_info->num_vectors; i++) {
+                map = &irqmap_info->vecmap[i];
+
+                vector_id = map->vector_id;
+                vsi_id = map->vsi_id;
+                /* validate msg params */
+                if (!(vector_id < pf->hw.func_caps.common_cap
+                    .num_msix_vectors) || !ice_vc_isvalid_vsi_id(vf, vsi_id)) {
+                        aq_ret = ICE_ERR_PARAM;
+                        goto error_param;
+                }
+
+                vsi = ice_find_vsi_from_id(vf->pf, vsi_id);
+                if (!vsi) {
+                        aq_ret = ICE_ERR_PARAM;
+                        goto error_param;
+                }
+
+                /* lookout for the invalid queue index */
+                qmap = map->rxq_map;
+                for_each_set_bit(vsi_q_id, &qmap, ICE_MAX_BASE_QS_PER_VF) {
+                        struct ice_q_vector *q_vector;
+
+                        if (!ice_vc_isvalid_q_id(vf, vsi_id, vsi_q_id)) {
+                                aq_ret = ICE_ERR_PARAM;
+                                goto error_param;
+                        }
+                        q_vector = vsi->q_vectors[i];
+                        q_vector->num_ring_rx++;
+                        q_vector->rx.itr_idx = map->rxitr_idx;
+                        vsi->rx_rings[vsi_q_id]->q_vector = q_vector;
+                }
+
+                qmap = map->txq_map;
+                for_each_set_bit(vsi_q_id, &qmap, ICE_MAX_BASE_QS_PER_VF) {
+                        struct ice_q_vector *q_vector;
+
+                        if (!ice_vc_isvalid_q_id(vf, vsi_id, vsi_q_id)) {
+                                aq_ret = ICE_ERR_PARAM;
+                                goto error_param;
+                        }
+                        q_vector = vsi->q_vectors[i];
+                        q_vector->num_ring_tx++;
+                        q_vector->tx.itr_idx = map->txitr_idx;
+                        vsi->tx_rings[vsi_q_id]->q_vector = q_vector;
+                }
+        }
+
+        if (vsi)
+                ice_vsi_cfg_msix(vsi);
+error_param:
+        /* send the response to the VF */
+        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_CONFIG_IRQ_MAP, aq_ret,
+                                     NULL, 0);
+}
+
+/**
+ * ice_vc_cfg_qs_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ *
+ * called from the VF to configure the Rx/Tx queues
+ */
+static int ice_vc_cfg_qs_msg(struct ice_vf *vf, u8 *msg)
+{
+        struct virtchnl_vsi_queue_config_info *qci =
+            (struct virtchnl_vsi_queue_config_info *)msg;
+        struct virtchnl_queue_pair_info *qpi;
+        enum ice_status aq_ret = 0;
+        struct ice_vsi *vsi;
+        int i;
+
+        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (!ice_vc_isvalid_vsi_id(vf, qci->vsi_id)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        vsi = ice_find_vsi_from_id(vf->pf, qci->vsi_id);
+        if (!vsi) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        for (i = 0; i < qci->num_queue_pairs; i++) {
+                qpi = &qci->qpair[i];
+                if (qpi->txq.vsi_id != qci->vsi_id ||
+                    qpi->rxq.vsi_id != qci->vsi_id ||
+                    qpi->rxq.queue_id != qpi->txq.queue_id ||
+                    !ice_vc_isvalid_q_id(vf, qci->vsi_id, qpi->txq.queue_id)) {
+                        aq_ret = ICE_ERR_PARAM;
+                        goto error_param;
+                }
+                /* copy Tx queue info from VF into VSI */
+                vsi->tx_rings[i]->dma = qpi->txq.dma_ring_addr;
+                vsi->tx_rings[i]->count = qpi->txq.ring_len;
+                /* copy Rx queue info from VF into vsi */
+                vsi->rx_rings[i]->dma = qpi->rxq.dma_ring_addr;
+                vsi->rx_rings[i]->count = qpi->rxq.ring_len;
+                if (qpi->rxq.databuffer_size > ((16 * 1024) - 128)) {
+                        aq_ret = ICE_ERR_PARAM;
+                        goto error_param;
+                }
+                vsi->rx_buf_len = qpi->rxq.databuffer_size;
+                if (qpi->rxq.max_pkt_size >= (16 * 1024) ||
+                    qpi->rxq.max_pkt_size < 64) {
+                        aq_ret = ICE_ERR_PARAM;
+                        goto error_param;
+                }
+                vsi->max_frame = qpi->rxq.max_pkt_size;
+        }
+
+        /* VF can request to configure less than allocated queues
+         * or default allocated queues. So update the VSI with new number
+         */
+        vsi->num_txq = qci->num_queue_pairs;
+        vsi->num_rxq = qci->num_queue_pairs;
+
+        if (!ice_vsi_cfg_txqs(vsi) && !ice_vsi_cfg_rxqs(vsi))
+                aq_ret = 0;
+        else
+                aq_ret = ICE_ERR_PARAM;
+
+error_param:
+        /* send the response to the VF */
+        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_CONFIG_VSI_QUEUES, aq_ret,
+                                     NULL, 0);
+}
+
+/**
+ * ice_is_vf_trusted
+ * @vf: pointer to the VF info
+ */
+static bool ice_is_vf_trusted(struct ice_vf *vf)
+{
+        return test_bit(ICE_VIRTCHNL_VF_CAP_PRIVILEGE, &vf->vf_caps);
+}
+
+/**
+ * ice_can_vf_change_mac
+ * @vf: pointer to the VF info
+ *
+ * Return true if the VF is allowed to change its MAC filters, false otherwise
+ */
+static bool ice_can_vf_change_mac(struct ice_vf *vf)
+{
+        /* If the VF MAC address has been set administratively (via the
+         * ndo_set_vf_mac command), then deny permission to the VF to
+         * add/delete unicast MAC addresses, unless the VF is trusted
+         */
+        if (vf->pf_set_mac && !ice_is_vf_trusted(vf))
+                return false;
+
+        return true;
+}
+
+/**
+ * ice_vc_handle_mac_addr_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ * @set: true if mac filters are being set, false otherwise
+ *
+ * add guest mac address filter
+ */
+static int
+ice_vc_handle_mac_addr_msg(struct ice_vf *vf, u8 *msg, bool set)
+{
+        struct virtchnl_ether_addr_list *al =
+            (struct virtchnl_ether_addr_list *)msg;
+        struct ice_pf *pf = vf->pf;
+        enum virtchnl_ops vc_op;
+        enum ice_status ret;
+        LIST_HEAD(mac_list);
+        struct ice_vsi *vsi;
+        int mac_count = 0;
+        int i;
+
+        if (set)
+                vc_op = VIRTCHNL_OP_ADD_ETH_ADDR;
+        else
+                vc_op = VIRTCHNL_OP_DEL_ETH_ADDR;
+
+        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states) ||
+            !ice_vc_isvalid_vsi_id(vf, al->vsi_id)) {
+                ret = ICE_ERR_PARAM;
+                goto handle_mac_exit;
+        }
+
+        if (set && !ice_is_vf_trusted(vf) &&
+            (vf->num_mac + al->num_elements) > ICE_MAX_MACADDR_PER_VF) {
+                dev_err(&pf->pdev->dev,
+                        "Can't add more MAC addresses, because VF is not trusted, switch the VF to trusted mode in order to add more functionalities\n");
+                ret = ICE_ERR_PARAM;
+                goto handle_mac_exit;
+        }
+
+        vsi = pf->vsi[vf->lan_vsi_idx];
+
+        for (i = 0; i < al->num_elements; i++) {
+                u8 *maddr = al->list[i].addr;
+
+                if (ether_addr_equal(maddr, vf->dflt_lan_addr.addr) ||
+                    is_broadcast_ether_addr(maddr)) {
+                        if (set) {
+                                /* VF is trying to add filters that the PF
+                                 * already added. Just continue.
+                                 */
+                                dev_info(&pf->pdev->dev,
+                                         "mac %pM already set for VF %d\n",
+                                         maddr, vf->vf_id);
+                                continue;
+                        } else {
+                                /* VF can't remove dflt_lan_addr/bcast mac */
+                                dev_err(&pf->pdev->dev,
+                                        "can't remove mac %pM for VF %d\n",
+                                        maddr, vf->vf_id);
+                                ret = ICE_ERR_PARAM;
+                                goto handle_mac_exit;
+                        }
+                }
+
+                /* check for the invalid cases and bail if necessary */
+                if (is_zero_ether_addr(maddr)) {
+                        dev_err(&pf->pdev->dev,
+                                "invalid mac %pM provided for VF %d\n",
+                                maddr, vf->vf_id);
+                        ret = ICE_ERR_PARAM;
+                        goto handle_mac_exit;
+                }
+
+                if (is_unicast_ether_addr(maddr) &&
+                    !ice_can_vf_change_mac(vf)) {
+                        dev_err(&pf->pdev->dev,
+                                "can't change unicast mac for untrusted VF %d\n",
+                                vf->vf_id);
+                        ret = ICE_ERR_PARAM;
+                        goto handle_mac_exit;
+                }
+
+                /* get here if maddr is multicast or if VF can change mac */
+                if (ice_add_mac_to_list(vsi, &mac_list, al->list[i].addr)) {
+                        ret = ICE_ERR_NO_MEMORY;
+                        goto handle_mac_exit;
+                }
+                mac_count++;
+        }
+
+        /* program the updated filter list */
+        if (set)
+                ret = ice_add_mac(&pf->hw, &mac_list);
+        else
+                ret = ice_remove_mac(&pf->hw, &mac_list);
+
+        if (ret) {
+                dev_err(&pf->pdev->dev,
+                        "can't update mac filters for VF %d, error %d\n",
+                        vf->vf_id, ret);
+        } else {
+                if (set)
+                        vf->num_mac += mac_count;
+                else
+                        vf->num_mac -= mac_count;
+        }
+
+handle_mac_exit:
+        ice_free_fltr_list(&pf->pdev->dev, &mac_list);
+        /* send the response to the VF */
+        return ice_vc_send_msg_to_vf(vf, vc_op, ret, NULL, 0);
+}
+
+/**
+ * ice_vc_add_mac_addr_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ *
+ * add guest MAC address filter
+ */
+static int ice_vc_add_mac_addr_msg(struct ice_vf *vf, u8 *msg)
+{
+        return ice_vc_handle_mac_addr_msg(vf, msg, true);
+}
+
+/**
+ * ice_vc_del_mac_addr_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ *
+ * remove guest MAC address filter
+ */
+static int ice_vc_del_mac_addr_msg(struct ice_vf *vf, u8 *msg)
+{
+        return ice_vc_handle_mac_addr_msg(vf, msg, false);
+}
+
+/**
+ * ice_vc_request_qs_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ *
+ * VFs get a default number of queues but can use this message to request a
+ * different number.  If the request is successful, PF will reset the VF and
+ * return 0. If unsuccessful, PF will send message informing VF of number of
+ * available queue pairs via virtchnl message response to VF.
+ */
+static int ice_vc_request_qs_msg(struct ice_vf *vf, u8 *msg)
+{
+        struct virtchnl_vf_res_request *vfres =
+                (struct virtchnl_vf_res_request *)msg;
+        int req_queues = vfres->num_queue_pairs;
+        enum ice_status aq_ret = 0;
+        struct ice_pf *pf = vf->pf;
+        int tx_rx_queue_left;
+        int cur_queues;
+
+        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        cur_queues = pf->num_vf_qps;
+        tx_rx_queue_left = min_t(int, pf->q_left_tx, pf->q_left_rx);
+        if (req_queues <= 0) {
+                dev_err(&pf->pdev->dev,
+                        "VF %d tried to request %d queues.  Ignoring.\n",
+                        vf->vf_id, req_queues);
+        } else if (req_queues > ICE_MAX_QS_PER_VF) {
+                dev_err(&pf->pdev->dev,
+                        "VF %d tried to request more than %d queues.\n",
+                        vf->vf_id, ICE_MAX_QS_PER_VF);
+                vfres->num_queue_pairs = ICE_MAX_QS_PER_VF;
+        } else if (req_queues - cur_queues > tx_rx_queue_left) {
+                dev_warn(&pf->pdev->dev,
+                         "VF %d requested %d more queues, but only %d left.\n",
+                         vf->vf_id, req_queues - cur_queues, tx_rx_queue_left);
+                vfres->num_queue_pairs = tx_rx_queue_left + cur_queues;
+        } else {
+                /* request is successful, then reset VF */
+                vf->num_req_qs = req_queues;
+                ice_vc_dis_vf(vf);
+                dev_info(&pf->pdev->dev,
+                         "VF %d granted request of %d queues.\n",
+                         vf->vf_id, req_queues);
+                return 0;
+        }
+
+error_param:
+        /* send the response to the VF */
+        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_REQUEST_QUEUES,
+                                     aq_ret, (u8 *)vfres, sizeof(*vfres));
+}
+
+/**
+ * ice_set_vf_port_vlan
+ * @netdev: network interface device structure
+ * @vf_id: VF identifier
+ * @vlan_id: VLAN id being set
+ * @qos: priority setting
+ * @vlan_proto: VLAN protocol
+ *
+ * program VF Port VLAN id and/or qos
+ */
+int
+ice_set_vf_port_vlan(struct net_device *netdev, int vf_id, u16 vlan_id, u8 qos,
+                     __be16 vlan_proto)
+{
+        u16 vlanprio = vlan_id | (qos << ICE_VLAN_PRIORITY_S);
+        struct ice_netdev_priv *np = netdev_priv(netdev);
+        struct ice_pf *pf = np->vsi->back;
+        struct ice_vsi *vsi;
+        struct ice_vf *vf;
+        int ret = 0;
+
+        /* validate the request */
+        if (vf_id >= pf->num_alloc_vfs) {
+                dev_err(&pf->pdev->dev, "invalid VF id: %d\n", vf_id);
+                return -EINVAL;
+        }
+
+        if (vlan_id > ICE_MAX_VLANID || qos > 7) {
+                dev_err(&pf->pdev->dev, "Invalid VF Parameters\n");
+                return -EINVAL;
+        }
+
+        if (vlan_proto != htons(ETH_P_8021Q)) {
+                dev_err(&pf->pdev->dev, "VF VLAN protocol is not supported\n");
+                return -EPROTONOSUPPORT;
+        }
+
+        vf = &pf->vf[vf_id];
+        vsi = pf->vsi[vf->lan_vsi_idx];
+        if (!test_bit(ICE_VF_STATE_INIT, vf->vf_states)) {
+                dev_err(&pf->pdev->dev, "VF %d in reset. Try again.\n", vf_id);
+                return -EBUSY;
+        }
+
+        if (le16_to_cpu(vsi->info.pvid) == vlanprio) {
+                /* duplicate request, so just return success */
+                dev_info(&pf->pdev->dev,
+                         "Duplicate pvid %d request\n", vlanprio);
+                return ret;
+        }
+
+        /* If pvid, then remove all filters on the old VLAN */
+        if (vsi->info.pvid)
+                ice_vsi_kill_vlan(vsi, (le16_to_cpu(vsi->info.pvid) &
+                                  VLAN_VID_MASK));
+
+        if (vlan_id || qos) {
+                ret = ice_vsi_set_pvid(vsi, vlanprio);
+                if (ret)
+                        goto error_set_pvid;
+        } else {
+                ice_vsi_kill_pvid(vsi);
+        }
+
+        if (vlan_id) {
+                dev_info(&pf->pdev->dev, "Setting VLAN %d, QOS 0x%x on VF %d\n",
+                         vlan_id, qos, vf_id);
+
+                /* add new VLAN filter for each MAC */
+                ret = ice_vsi_add_vlan(vsi, vlan_id);
+                if (ret)
+                        goto error_set_pvid;
+        }
+
+        /* The Port VLAN needs to be saved across resets the same as the
+         * default LAN MAC address.
+         */
+        vf->port_vlan_id = le16_to_cpu(vsi->info.pvid);
+
+error_set_pvid:
+        return ret;
+}
+
+/**
+ * ice_vc_process_vlan_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ * @add_v: Add VLAN if true, otherwise delete VLAN
+ *
+ * Process virtchnl op to add or remove programmed guest VLAN id
+ */
+static int ice_vc_process_vlan_msg(struct ice_vf *vf, u8 *msg, bool add_v)
+{
+        struct virtchnl_vlan_filter_list *vfl =
+            (struct virtchnl_vlan_filter_list *)msg;
+        enum ice_status aq_ret = 0;
+        struct ice_pf *pf = vf->pf;
+        struct ice_vsi *vsi;
+        int i;
+
+        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (!ice_vc_isvalid_vsi_id(vf, vfl->vsi_id)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (add_v && !ice_is_vf_trusted(vf) &&
+            vf->num_vlan >= ICE_MAX_VLAN_PER_VF) {
+                dev_info(&pf->pdev->dev,
+                         "VF is not trusted, switch the VF to trusted mode, in order to add more VLAN addresses\n");
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        for (i = 0; i < vfl->num_elements; i++) {
+                if (vfl->vlan_id[i] > ICE_MAX_VLANID) {
+                        aq_ret = ICE_ERR_PARAM;
+                        dev_err(&pf->pdev->dev,
+                                "invalid VF VLAN id %d\n", vfl->vlan_id[i]);
+                        goto error_param;
+                }
+        }
+
+        vsi = ice_find_vsi_from_id(vf->pf, vfl->vsi_id);
+        if (!vsi) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (vsi->info.pvid) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (ice_vsi_manage_vlan_stripping(vsi, add_v)) {
+                dev_err(&pf->pdev->dev,
+                        "%sable VLAN stripping failed for VSI %i\n",
+                         add_v ? "en" : "dis", vsi->vsi_num);
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        if (add_v) {
+                for (i = 0; i < vfl->num_elements; i++) {
+                        u16 vid = vfl->vlan_id[i];
+
+                        if (!ice_vsi_add_vlan(vsi, vid)) {
+                                vf->num_vlan++;
+                                set_bit(vid, vsi->active_vlans);
+
+                                /* Enable VLAN pruning when VLAN 0 is added */
+                                if (unlikely(!vid))
+                                        if (ice_cfg_vlan_pruning(vsi, true))
+                                                aq_ret = ICE_ERR_PARAM;
+                        } else {
+                                aq_ret = ICE_ERR_PARAM;
+                        }
+                }
+        } else {
+                for (i = 0; i < vfl->num_elements; i++) {
+                        u16 vid = vfl->vlan_id[i];
+
+                        /* Make sure ice_vsi_kill_vlan is successful before
+                         * updating VLAN information
+                         */
+                        if (!ice_vsi_kill_vlan(vsi, vid)) {
+                                vf->num_vlan--;
+                                clear_bit(vid, vsi->active_vlans);
+
+                                /* Disable VLAN pruning when removing VLAN 0 */
+                                if (unlikely(!vid))
+                                        ice_cfg_vlan_pruning(vsi, false);
+                        }
+                }
+        }
+
+error_param:
+        /* send the response to the VF */
+        if (add_v)
+                return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_ADD_VLAN, aq_ret,
+                                             NULL, 0);
+        else
+                return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_DEL_VLAN, aq_ret,
+                                             NULL, 0);
+}
+
+/**
+ * ice_vc_add_vlan_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ *
+ * Add and program guest VLAN id
+ */
+static int ice_vc_add_vlan_msg(struct ice_vf *vf, u8 *msg)
+{
+        return ice_vc_process_vlan_msg(vf, msg, true);
+}
+
+/**
+ * ice_vc_remove_vlan_msg
+ * @vf: pointer to the VF info
+ * @msg: pointer to the msg buffer
+ *
+ * remove programmed guest VLAN id
+ */
+static int ice_vc_remove_vlan_msg(struct ice_vf *vf, u8 *msg)
+{
+        return ice_vc_process_vlan_msg(vf, msg, false);
+}
+
+/**
+ * ice_vc_ena_vlan_stripping
+ * @vf: pointer to the VF info
+ *
+ * Enable VLAN header stripping for a given VF
+ */
+static int ice_vc_ena_vlan_stripping(struct ice_vf *vf)
+{
+        enum ice_status aq_ret = 0;
+        struct ice_pf *pf = vf->pf;
+        struct ice_vsi *vsi;
+
+        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        vsi = pf->vsi[vf->lan_vsi_idx];
+        if (ice_vsi_manage_vlan_stripping(vsi, true))
+                aq_ret = ICE_ERR_AQ_ERROR;
+
+error_param:
+        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_ENABLE_VLAN_STRIPPING,
+                                     aq_ret, NULL, 0);
+}
+
+/**
+ * ice_vc_dis_vlan_stripping
+ * @vf: pointer to the VF info
+ *
+ * Disable VLAN header stripping for a given VF
+ */
+static int ice_vc_dis_vlan_stripping(struct ice_vf *vf)
+{
+        enum ice_status aq_ret = 0;
+        struct ice_pf *pf = vf->pf;
+        struct ice_vsi *vsi;
+
+        if (!test_bit(ICE_VF_STATE_ACTIVE, vf->vf_states)) {
+                aq_ret = ICE_ERR_PARAM;
+                goto error_param;
+        }
+
+        vsi = pf->vsi[vf->lan_vsi_idx];
+        if (ice_vsi_manage_vlan_stripping(vsi, false))
+                aq_ret = ICE_ERR_AQ_ERROR;
+
+error_param:
+        return ice_vc_send_msg_to_vf(vf, VIRTCHNL_OP_DISABLE_VLAN_STRIPPING,
+                                     aq_ret, NULL, 0);
+}
+
+/**
+ * ice_vc_process_vf_msg - Process request from VF
+ * @pf: pointer to the PF structure
+ * @event: pointer to the AQ event
+ *
+ * called from the common asq/arq handler to
+ * process request from VF
+ */
+void ice_vc_process_vf_msg(struct ice_pf *pf, struct ice_rq_event_info *event)
+{
+        u32 v_opcode = le32_to_cpu(event->desc.cookie_high);
+        s16 vf_id = le16_to_cpu(event->desc.retval);
+        u16 msglen = event->msg_len;
+        u8 *msg = event->msg_buf;
+        struct ice_vf *vf = NULL;
+        int err = 0;
+
+        if (vf_id >= pf->num_alloc_vfs) {
+                err = -EINVAL;
+                goto error_handler;
+        }
+
+        vf = &pf->vf[vf_id];
+
+        /* Check if VF is disabled. */
+        if (test_bit(ICE_VF_STATE_DIS, vf->vf_states)) {
+                err = -EPERM;
+                goto error_handler;
+        }
+
+        /* Perform basic checks on the msg */
+        err = virtchnl_vc_validate_vf_msg(&vf->vf_ver, v_opcode, msg, msglen);
+        if (err) {
+                if (err == VIRTCHNL_ERR_PARAM)
+                        err = -EPERM;
+                else
+                        err = -EINVAL;
+                goto error_handler;
+        }
+
+        /* Perform additional checks specific to RSS and Virtchnl */
+        if (v_opcode == VIRTCHNL_OP_CONFIG_RSS_KEY) {
+                struct virtchnl_rss_key *vrk = (struct virtchnl_rss_key *)msg;
+
+                if (vrk->key_len != ICE_VSIQF_HKEY_ARRAY_SIZE)
+                        err = -EINVAL;
+        } else if (v_opcode == VIRTCHNL_OP_CONFIG_RSS_LUT) {
+                struct virtchnl_rss_lut *vrl = (struct virtchnl_rss_lut *)msg;
+
+                if (vrl->lut_entries != ICE_VSIQF_HLUT_ARRAY_SIZE)
+                        err = -EINVAL;
+        }
+
+error_handler:
+        if (err) {
+                ice_vc_send_msg_to_vf(vf, v_opcode, ICE_ERR_PARAM, NULL, 0);
+                dev_err(&pf->pdev->dev, "Invalid message from VF %d, opcode %d, len %d, error %d\n",
+                        vf_id, v_opcode, msglen, err);
+                return;
+        }
+
+        switch (v_opcode) {
+        case VIRTCHNL_OP_VERSION:
+                err = ice_vc_get_ver_msg(vf, msg);
+                break;
+        case VIRTCHNL_OP_GET_VF_RESOURCES:
+                err = ice_vc_get_vf_res_msg(vf, msg);
+                break;
+        case VIRTCHNL_OP_RESET_VF:
+                ice_vc_reset_vf_msg(vf);
+                break;
+        case VIRTCHNL_OP_ADD_ETH_ADDR:
+                err = ice_vc_add_mac_addr_msg(vf, msg);
+                break;
+        case VIRTCHNL_OP_DEL_ETH_ADDR:
+                err = ice_vc_del_mac_addr_msg(vf, msg);
+                break;
+        case VIRTCHNL_OP_CONFIG_VSI_QUEUES:
+                err = ice_vc_cfg_qs_msg(vf, msg);
+                break;
+        case VIRTCHNL_OP_ENABLE_QUEUES:
+                err = ice_vc_ena_qs_msg(vf, msg);
+                ice_vc_notify_vf_link_state(vf);
+                break;
+        case VIRTCHNL_OP_DISABLE_QUEUES:
+                err = ice_vc_dis_qs_msg(vf, msg);
+                break;
+        case VIRTCHNL_OP_REQUEST_QUEUES:
+                err = ice_vc_request_qs_msg(vf, msg);
+                break;
+        case VIRTCHNL_OP_CONFIG_IRQ_MAP:
+                err = ice_vc_cfg_irq_map_msg(vf, msg);
+                break;
+        case VIRTCHNL_OP_CONFIG_RSS_KEY:
+                err = ice_vc_config_rss_key(vf, msg);
+                break;
+        case VIRTCHNL_OP_CONFIG_RSS_LUT:
+                err = ice_vc_config_rss_lut(vf, msg);
+                break;
+        case VIRTCHNL_OP_GET_STATS:
+                err = ice_vc_get_stats_msg(vf, msg);
+                break;
+        case VIRTCHNL_OP_ADD_VLAN:
+                err = ice_vc_add_vlan_msg(vf, msg);
+                break;
+        case VIRTCHNL_OP_DEL_VLAN:
+                err = ice_vc_remove_vlan_msg(vf, msg);
+                break;
+        case VIRTCHNL_OP_ENABLE_VLAN_STRIPPING:
+                err = ice_vc_ena_vlan_stripping(vf);
+                break;
+        case VIRTCHNL_OP_DISABLE_VLAN_STRIPPING:
+                err = ice_vc_dis_vlan_stripping(vf);
+                break;
+        case VIRTCHNL_OP_UNKNOWN:
+        default:
+                dev_err(&pf->pdev->dev, "Unsupported opcode %d from VF %d\n",
+                        v_opcode, vf_id);
+                err = ice_vc_send_msg_to_vf(vf, v_opcode, ICE_ERR_NOT_IMPL,
+                                            NULL, 0);
+                break;
+        }
+        if (err) {
+                /* Helper function cares less about error return values here
+                 * as it is busy with pending work.
+                 */
+                dev_info(&pf->pdev->dev,
+                         "PF failed to honor VF %d, opcode %d\n, error %d\n",
+                         vf_id, v_opcode, err);
+        }
+}
+
+/**
+ * ice_get_vf_cfg
+ * @netdev: network interface device structure
+ * @vf_id: VF identifier
+ * @ivi: VF configuration structure
+ *
+ * return VF configuration
+ */
+int ice_get_vf_cfg(struct net_device *netdev, int vf_id,
+                   struct ifla_vf_info *ivi)
+{
+        struct ice_netdev_priv *np = netdev_priv(netdev);
+        struct ice_vsi *vsi = np->vsi;
+        struct ice_pf *pf = vsi->back;
+        struct ice_vf *vf;
+
+        /* validate the request */
+        if (vf_id >= pf->num_alloc_vfs) {
+                netdev_err(netdev, "invalid VF id: %d\n", vf_id);
+                return -EINVAL;
+        }
+
+        vf = &pf->vf[vf_id];
+        vsi = pf->vsi[vf->lan_vsi_idx];
+
+        if (!test_bit(ICE_VF_STATE_INIT, vf->vf_states)) {
+                netdev_err(netdev, "VF %d in reset. Try again.\n", vf_id);
+                return -EBUSY;
+        }
+
+        ivi->vf = vf_id;
+        ether_addr_copy(ivi->mac, vf->dflt_lan_addr.addr);
+
+        /* VF configuration for VLAN and applicable QoS */
+        ivi->vlan = le16_to_cpu(vsi->info.pvid) & ICE_VLAN_M;
+        ivi->qos = (le16_to_cpu(vsi->info.pvid) & ICE_PRIORITY_M) >>
+                    ICE_VLAN_PRIORITY_S;
+
+        ivi->trusted = vf->trusted;
+        ivi->spoofchk = vf->spoofchk;
+        if (!vf->link_forced)
+                ivi->linkstate = IFLA_VF_LINK_STATE_AUTO;
+        else if (vf->link_up)
+                ivi->linkstate = IFLA_VF_LINK_STATE_ENABLE;
+        else
+                ivi->linkstate = IFLA_VF_LINK_STATE_DISABLE;
+        ivi->max_tx_rate = vf->tx_rate;
+        ivi->min_tx_rate = 0;
+        return 0;
+}
+
+/**
+ * ice_set_vf_spoofchk
+ * @netdev: network interface device structure
+ * @vf_id: VF identifier
+ * @ena: flag to enable or disable feature
+ *
+ * Enable or disable VF spoof checking
+ */
+int ice_set_vf_spoofchk(struct net_device *netdev, int vf_id, bool ena)
+{
+        struct ice_netdev_priv *np = netdev_priv(netdev);
+        struct ice_vsi_ctx ctx = { 0 };
+        struct ice_vsi *vsi = np->vsi;
+        struct ice_pf *pf = vsi->back;
+        struct ice_vf *vf;
+        int status;
+
+        /* validate the request */
+        if (vf_id >= pf->num_alloc_vfs) {
+                netdev_err(netdev, "invalid VF id: %d\n", vf_id);
+                return -EINVAL;
+        }
+
+        vf = &pf->vf[vf_id];
+        if (!test_bit(ICE_VF_STATE_INIT, vf->vf_states)) {
+                netdev_err(netdev, "VF %d in reset. Try again.\n", vf_id);
+                return -EBUSY;
+        }
+
+        if (ena == vf->spoofchk) {
+                dev_dbg(&pf->pdev->dev, "VF spoofchk already %s\n",
+                        ena ? "ON" : "OFF");
+                return 0;
+        }
+
+        ctx.info.valid_sections = cpu_to_le16(ICE_AQ_VSI_PROP_SECURITY_VALID);
+
+        if (ena) {
+                ctx.info.sec_flags |= ICE_AQ_VSI_SEC_FLAG_ENA_MAC_ANTI_SPOOF;
+                ctx.info.sw_flags2 |= ICE_AQ_VSI_SW_FLAG_RX_PRUNE_EN_M;
+        }
+
+        status = ice_update_vsi(&pf->hw, vsi->idx, &ctx, NULL);
+        if (status) {
+                dev_dbg(&pf->pdev->dev,
+                        "Error %d, failed to update VSI* parameters\n", status);
+                return -EIO;
+        }
+
+        vf->spoofchk = ena;
+        vsi->info.sec_flags = ctx.info.sec_flags;
+        vsi->info.sw_flags2 = ctx.info.sw_flags2;
+
+        return status;
+}
+
+/**
+ * ice_set_vf_mac
+ * @netdev: network interface device structure
+ * @vf_id: VF identifier
+ * @mac: mac address
+ *
+ * program VF mac address
+ */
+int ice_set_vf_mac(struct net_device *netdev, int vf_id, u8 *mac)
+{
+        struct ice_netdev_priv *np = netdev_priv(netdev);
+        struct ice_vsi *vsi = np->vsi;
+        struct ice_pf *pf = vsi->back;
+        struct ice_vf *vf;
+        int ret = 0;
+
+        /* validate the request */
+        if (vf_id >= pf->num_alloc_vfs) {
+                netdev_err(netdev, "invalid VF id: %d\n", vf_id);
+                return -EINVAL;
+        }
+
+        vf = &pf->vf[vf_id];
+        if (!test_bit(ICE_VF_STATE_INIT, vf->vf_states)) {
+                netdev_err(netdev, "VF %d in reset. Try again.\n", vf_id);
+                return -EBUSY;
+        }
+
+        if (is_zero_ether_addr(mac) || is_multicast_ether_addr(mac)) {
+                netdev_err(netdev, "%pM not a valid unicast address\n", mac);
+                return -EINVAL;
+        }
+
+        /* copy mac into dflt_lan_addr and trigger a VF reset. The reset
+         * flow will use the updated dflt_lan_addr and add a MAC filter
+         * using ice_add_mac. Also set pf_set_mac to indicate that the PF has
+         * set the MAC address for this VF.
+         */
+        ether_addr_copy(vf->dflt_lan_addr.addr, mac);
+        vf->pf_set_mac = true;
+        netdev_info(netdev,
+                    "mac on VF %d set to %pM\n. VF driver will be reinitialized\n",
+                    vf_id, mac);
+
+        ice_vc_dis_vf(vf);
+        return ret;
+}
+
+/**
+ * ice_set_vf_trust
+ * @netdev: network interface device structure
+ * @vf_id: VF identifier
+ * @trusted: Boolean value to enable/disable trusted VF
+ *
+ * Enable or disable a given VF as trusted
+ */
+int ice_set_vf_trust(struct net_device *netdev, int vf_id, bool trusted)
+{
+        struct ice_netdev_priv *np = netdev_priv(netdev);
+        struct ice_vsi *vsi = np->vsi;
+        struct ice_pf *pf = vsi->back;
+        struct ice_vf *vf;
+
+        /* validate the request */
+        if (vf_id >= pf->num_alloc_vfs) {
+                dev_err(&pf->pdev->dev, "invalid VF id: %d\n", vf_id);
+                return -EINVAL;
+        }
+
+        vf = &pf->vf[vf_id];
+        if (!test_bit(ICE_VF_STATE_INIT, vf->vf_states)) {
+                dev_err(&pf->pdev->dev, "VF %d in reset. Try again.\n", vf_id);
+                return -EBUSY;
+        }
+
+        /* Check if already trusted */
+        if (trusted == vf->trusted)
+                return 0;
+
+        vf->trusted = trusted;
+        ice_vc_dis_vf(vf);
+        dev_info(&pf->pdev->dev, "VF %u is now %strusted\n",
+                 vf_id, trusted ? "" : "un");
+
+        return 0;
+}
+
+/**
+ * ice_set_vf_link_state
+ * @netdev: network interface device structure
+ * @vf_id: VF identifier
+ * @link_state: required link state
+ *
+ * Set VF's link state, irrespective of physical link state status
+ */
+int ice_set_vf_link_state(struct net_device *netdev, int vf_id, int link_state)
+{
+        struct ice_netdev_priv *np = netdev_priv(netdev);
+        struct ice_pf *pf = np->vsi->back;
+        struct virtchnl_pf_event pfe = { 0 };
+        struct ice_link_status *ls;
+        struct ice_vf *vf;
+        struct ice_hw *hw;
+
+        if (vf_id >= pf->num_alloc_vfs) {
+                dev_err(&pf->pdev->dev, "Invalid VF Identifier %d\n", vf_id);
+                return -EINVAL;
+        }
+
+        vf = &pf->vf[vf_id];
+        hw = &pf->hw;
+        ls = &pf->hw.port_info->phy.link_info;
+
+        if (!test_bit(ICE_VF_STATE_INIT, vf->vf_states)) {
+                dev_err(&pf->pdev->dev, "vf %d in reset. Try again.\n", vf_id);
+                return -EBUSY;
+        }
+
+        pfe.event = VIRTCHNL_EVENT_LINK_CHANGE;
+        pfe.severity = PF_EVENT_SEVERITY_INFO;
+
+        switch (link_state) {
+        case IFLA_VF_LINK_STATE_AUTO:
+                vf->link_forced = false;
+                vf->link_up = ls->link_info & ICE_AQ_LINK_UP;
+                break;
+        case IFLA_VF_LINK_STATE_ENABLE:
+                vf->link_forced = true;
+                vf->link_up = true;
+                break;
+        case IFLA_VF_LINK_STATE_DISABLE:
+                vf->link_forced = true;
+                vf->link_up = false;
+                break;
+        default:
+                return -EINVAL;
+        }
+
+        if (vf->link_forced)
+                ice_set_pfe_link_forced(vf, &pfe, vf->link_up);
+        else
+                ice_set_pfe_link(vf, &pfe, ls->link_speed, vf->link_up);
+
+        /* Notify the VF of its new link state */
+        ice_aq_send_msg_to_vf(hw, vf->vf_id, VIRTCHNL_OP_EVENT, 0, (u8 *)&pfe,
+                              sizeof(pfe), NULL);
+
+        return 0;
+}
diff --git a/drivers/net/ethernet/intel/ice/ice_virtchnl_pf.h b/drivers/net/ethernet/intel/ice/ice_virtchnl_pf.h
new file mode 100644
index 000000000000..10131e0180f9
--- /dev/null
+++ b/drivers/net/ethernet/intel/ice/ice_virtchnl_pf.h
@@ -0,0 +1,173 @@
+/* SPDX-License-Identifier: GPL-2.0 */
+/* Copyright (c) 2018, Intel Corporation. */
+
+#ifndef _ICE_VIRTCHNL_PF_H_
+#define _ICE_VIRTCHNL_PF_H_
+#include "ice.h"
+
+#define ICE_MAX_VLANID                  4095
+#define ICE_VLAN_PRIORITY_S             12
+#define ICE_VLAN_M                      0xFFF
+#define ICE_PRIORITY_M                  0x7000
+
+/* Restrict number of MAC Addr and VLAN that non-trusted VF can programmed */
+#define ICE_MAX_VLAN_PER_VF             8
+#define ICE_MAX_MACADDR_PER_VF          12
+
+/* Malicious Driver Detection */
+#define ICE_DFLT_NUM_MDD_EVENTS_ALLOWED         3
+#define ICE_DFLT_NUM_INVAL_MSGS_ALLOWED         10
+
+/* Static VF transaction/status register def */
+#define VF_DEVICE_STATUS                0xAA
+#define VF_TRANS_PENDING_M              0x20
+
+/* Specific VF states */
+enum ice_vf_states {
+        ICE_VF_STATE_INIT = 0,
+        ICE_VF_STATE_ACTIVE,
+        ICE_VF_STATE_ENA,
+        ICE_VF_STATE_DIS,
+        ICE_VF_STATE_MC_PROMISC,
+        ICE_VF_STATE_UC_PROMISC,
+        /* state to indicate if PF needs to do vector assignment for VF.
+         * This needs to be set during first time VF initialization or later
+         * when VF asks for more Vectors through virtchnl OP.
+         */
+        ICE_VF_STATE_CFG_INTR,
+        ICE_VF_STATES_NBITS
+};
+
+/* VF capabilities */
+enum ice_virtchnl_cap {
+        ICE_VIRTCHNL_VF_CAP_L2 = 0,
+        ICE_VIRTCHNL_VF_CAP_PRIVILEGE,
+};
+
+/* VF information structure */
+struct ice_vf {
+        struct ice_pf *pf;
+
+        s16 vf_id;                      /* VF id in the PF space */
+        u32 driver_caps;                /* reported by VF driver */
+        int first_vector_idx;           /* first vector index of this VF */
+        struct ice_sw *vf_sw_id;        /* switch id the VF VSIs connect to */
+        struct virtchnl_version_info vf_ver;
+        struct virtchnl_ether_addr dflt_lan_addr;
+        u16 port_vlan_id;
+        u8 pf_set_mac;                  /* VF MAC address set by VMM admin */
+        u8 trusted;
+        u16 lan_vsi_idx;                /* index into PF struct */
+        u16 lan_vsi_num;                /* ID as used by firmware */
+        u64 num_mdd_events;             /* number of mdd events detected */
+        u64 num_inval_msgs;             /* number of continuous invalid msgs */
+        u64 num_valid_msgs;             /* number of valid msgs detected */
+        unsigned long vf_caps;          /* vf's adv. capabilities */
+        DECLARE_BITMAP(vf_states, ICE_VF_STATES_NBITS); /* VF runtime states */
+        unsigned int tx_rate;           /* Tx bandwidth limit in Mbps */
+        u8 link_forced;
+        u8 link_up;                     /* only valid if VF link is forced */
+        u8 spoofchk;
+        u16 num_mac;
+        u16 num_vlan;
+        u8 num_req_qs;          /* num of queue pairs requested by VF */
+};
+
+#ifdef CONFIG_PCI_IOV
+void ice_process_vflr_event(struct ice_pf *pf);
+int ice_sriov_configure(struct pci_dev *pdev, int num_vfs);
+int ice_set_vf_mac(struct net_device *netdev, int vf_id, u8 *mac);
+int ice_get_vf_cfg(struct net_device *netdev, int vf_id,
+                   struct ifla_vf_info *ivi);
+
+void ice_free_vfs(struct ice_pf *pf);
+void ice_vc_process_vf_msg(struct ice_pf *pf, struct ice_rq_event_info *event);
+void ice_vc_notify_link_state(struct ice_pf *pf);
+void ice_vc_notify_reset(struct ice_pf *pf);
+bool ice_reset_all_vfs(struct ice_pf *pf, bool is_vflr);
+
+int ice_set_vf_port_vlan(struct net_device *netdev, int vf_id,
+                         u16 vlan_id, u8 qos, __be16 vlan_proto);
+
+int ice_set_vf_bw(struct net_device *netdev, int vf_id, int min_tx_rate,
+                  int max_tx_rate);
+
+int ice_set_vf_trust(struct net_device *netdev, int vf_id, bool trusted);
+
+int ice_set_vf_link_state(struct net_device *netdev, int vf_id, int link_state);
+
+int ice_set_vf_spoofchk(struct net_device *netdev, int vf_id, bool ena);
+#else /* CONFIG_PCI_IOV */
+#define ice_process_vflr_event(pf) do {} while (0)
+#define ice_free_vfs(pf) do {} while (0)
+#define ice_vc_process_vf_msg(pf, event) do {} while (0)
+#define ice_vc_notify_link_state(pf) do {} while (0)
+#define ice_vc_notify_reset(pf) do {} while (0)
+
+static inline bool
+ice_reset_all_vfs(struct ice_pf __always_unused *pf,
+                  bool __always_unused is_vflr)
+{
+        return true;
+}
+
+static inline int
+ice_sriov_configure(struct pci_dev __always_unused *pdev,
+                    int __always_unused num_vfs)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int
+ice_set_vf_mac(struct net_device __always_unused *netdev,
+               int __always_unused vf_id, u8 __always_unused *mac)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int
+ice_get_vf_cfg(struct net_device __always_unused *netdev,
+               int __always_unused vf_id,
+               struct ifla_vf_info __always_unused *ivi)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int
+ice_set_vf_trust(struct net_device __always_unused *netdev,
+                 int __always_unused vf_id, bool __always_unused trusted)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int
+ice_set_vf_port_vlan(struct net_device __always_unused *netdev,
+                     int __always_unused vf_id, u16 __always_unused vid,
+                     u8 __always_unused qos, __be16 __always_unused v_proto)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int
+ice_set_vf_spoofchk(struct net_device __always_unused *netdev,
+                    int __always_unused vf_id, bool __always_unused ena)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int
+ice_set_vf_link_state(struct net_device __always_unused *netdev,
+                      int __always_unused vf_id, int __always_unused link_state)
+{
+        return -EOPNOTSUPP;
+}
+
+static inline int
+ice_set_vf_bw(struct net_device __always_unused *netdev,
+              int __always_unused vf_id, int __always_unused min_tx_rate,
+              int __always_unused max_tx_rate)
+{
+        return -EOPNOTSUPP;
+}
+#endif /* CONFIG_PCI_IOV */
+#endif /* _ICE_VIRTCHNL_PF_H_ */