7 files changed, 190 insertions, 42 deletions

diff --git a/drivers/infiniband/hw/mlx4/main.c b/drivers/infiniband/hw/mlx4/main.c
index 8b72cf392b34..0c3375524a64 100644
--- a/drivers/infiniband/hw/mlx4/main.c
+++ b/drivers/infiniband/hw/mlx4/main.c
@@ -1975,8 +1975,7 @@ static void mlx4_ib_alloc_eqs(struct mlx4_dev *dev, struct mlx4_ib_dev *ibdev)
             dev->caps.num_ports > dev->caps.comp_pool)
                 return;
 
-        eq_per_port = rounddown_pow_of_two(dev->caps.comp_pool/
-                                        dev->caps.num_ports);
+        eq_per_port = dev->caps.comp_pool / dev->caps.num_ports;
 
         /* Init eq table */
         added_eqs = 0;
diff --git a/drivers/net/ethernet/mellanox/mlx4/eq.c b/drivers/net/ethernet/mellanox/mlx4/eq.c
index 49290a405903..d68b264cee4d 100644
--- a/drivers/net/ethernet/mellanox/mlx4/eq.c
+++ b/drivers/net/ethernet/mellanox/mlx4/eq.c
@@ -1123,8 +1123,12 @@ int mlx4_init_eq_table(struct mlx4_dev *dev)
                 goto err_out_free;
         }
 
-        err = mlx4_bitmap_init(&priv->eq_table.bitmap, dev->caps.num_eqs,
-                               dev->caps.num_eqs - 1, dev->caps.reserved_eqs, 0);
+        err = mlx4_bitmap_init(&priv->eq_table.bitmap,
+                               roundup_pow_of_two(dev->caps.num_eqs),
+                               dev->caps.num_eqs - 1,
+                               dev->caps.reserved_eqs,
+                               roundup_pow_of_two(dev->caps.num_eqs) -
+                               dev->caps.num_eqs);
         if (err)
                 goto err_out_free;
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/fw.c b/drivers/net/ethernet/mellanox/mlx4/fw.c
index b3bbeb97da14..d2f594fadfbf 100644
--- a/drivers/net/ethernet/mellanox/mlx4/fw.c
+++ b/drivers/net/ethernet/mellanox/mlx4/fw.c
@@ -142,7 +142,8 @@ static void dump_dev_cap_flags2(struct mlx4_dev *dev, u64 flags)
                 [13] = "Large cache line (>64B) EQE stride support",
                 [14] = "Ethernet protocol control support",
                 [15] = "Ethernet Backplane autoneg support",
-                [16] = "CONFIG DEV support"
+                [16] = "CONFIG DEV support",
+                [17] = "Asymmetric EQs support"
         };
         int i;
 
@@ -200,7 +201,6 @@ int mlx4_QUERY_FUNC(struct mlx4_dev *dev, struct mlx4_func *func, int slave)
         outbox = mailbox->buf;
 
         in_modifier = slave;
-        mlx4_dbg(dev, "%s for VF %d\n", __func__, in_modifier);
 
         err = mlx4_cmd_box(dev, 0, mailbox->dma, in_modifier, 0,
                            MLX4_CMD_QUERY_FUNC,
@@ -243,6 +243,7 @@ int mlx4_QUERY_FUNC_CAP_wrapper(struct mlx4_dev *dev, int slave,
         u8      field, port;
         u32     size, proxy_qp, qkey;
         int     err = 0;
+        struct mlx4_func func;
 
 #define QUERY_FUNC_CAP_FLAGS_OFFSET             0x0
 #define QUERY_FUNC_CAP_NUM_PORTS_OFFSET         0x1
@@ -287,6 +288,7 @@ int mlx4_QUERY_FUNC_CAP_wrapper(struct mlx4_dev *dev, int slave,
 #define QUERY_FUNC_CAP_VF_ENABLE_QP0            0x08
 
 #define QUERY_FUNC_CAP_FLAGS0_FORCE_PHY_WQE_GID 0x80
+#define QUERY_FUNC_CAP_SUPPORTS_NON_POWER_OF_2_NUM_EQS (1 << 31)
 
         if (vhcr->op_modifier == 1) {
                 struct mlx4_active_ports actv_ports =
@@ -365,11 +367,24 @@ int mlx4_QUERY_FUNC_CAP_wrapper(struct mlx4_dev *dev, int slave,
                 size = dev->caps.num_cqs;
                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_CQ_QUOTA_OFFSET_DEP);
 
-                size = dev->caps.num_eqs;
-                MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MAX_EQ_OFFSET);
-
-                size = dev->caps.reserved_eqs;
-                MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_RESERVED_EQ_OFFSET);
+                if (!(dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_SYS_EQS) ||
+                    mlx4_QUERY_FUNC(dev, &func, slave)) {
+                        size = vhcr->in_modifier &
+                                QUERY_FUNC_CAP_SUPPORTS_NON_POWER_OF_2_NUM_EQS ?
+                                dev->caps.num_eqs :
+                                rounddown_pow_of_two(dev->caps.num_eqs);
+                        MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MAX_EQ_OFFSET);
+                        size = dev->caps.reserved_eqs;
+                        MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_RESERVED_EQ_OFFSET);
+                } else {
+                        size = vhcr->in_modifier &
+                                QUERY_FUNC_CAP_SUPPORTS_NON_POWER_OF_2_NUM_EQS ?
+                                func.max_eq :
+                                rounddown_pow_of_two(func.max_eq);
+                        MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MAX_EQ_OFFSET);
+                        size = func.rsvd_eqs;
+                        MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_RESERVED_EQ_OFFSET);
+                }
 
                 size = priv->mfunc.master.res_tracker.res_alloc[RES_MPT].quota[slave];
                 MLX4_PUT(outbox->buf, size, QUERY_FUNC_CAP_MPT_QUOTA_OFFSET);
@@ -399,14 +414,17 @@ int mlx4_QUERY_FUNC_CAP(struct mlx4_dev *dev, u8 gen_or_port,
         u8                      field, op_modifier;
         u32                     size, qkey;
         int                     err = 0, quotas = 0;
+        u32                     in_modifier;
 
         op_modifier = !!gen_or_port; /* 0 = general, 1 = logical port */
+        in_modifier = op_modifier ? gen_or_port :
+                QUERY_FUNC_CAP_SUPPORTS_NON_POWER_OF_2_NUM_EQS;
 
         mailbox = mlx4_alloc_cmd_mailbox(dev);
         if (IS_ERR(mailbox))
                 return PTR_ERR(mailbox);
 
-        err = mlx4_cmd_box(dev, 0, mailbox->dma, gen_or_port, op_modifier,
+        err = mlx4_cmd_box(dev, 0, mailbox->dma, in_modifier, op_modifier,
                            MLX4_CMD_QUERY_FUNC_CAP,
                            MLX4_CMD_TIME_CLASS_A, MLX4_CMD_WRAPPED);
         if (err)
@@ -578,6 +596,7 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
 #define QUERY_DEV_CAP_MAX_MRW_SZ_OFFSET         0x21
 #define QUERY_DEV_CAP_RSVD_MRW_OFFSET           0x22
 #define QUERY_DEV_CAP_MAX_MTT_SEG_OFFSET        0x23
+#define QUERY_DEV_CAP_NUM_SYS_EQ_OFFSET         0x26
 #define QUERY_DEV_CAP_MAX_AV_OFFSET             0x27
 #define QUERY_DEV_CAP_MAX_REQ_QP_OFFSET         0x29
 #define QUERY_DEV_CAP_MAX_RES_QP_OFFSET         0x2b
@@ -678,6 +697,8 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
         dev_cap->reserved_mrws = 1 << (field & 0xf);
         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_MTT_SEG_OFFSET);
         dev_cap->max_mtt_seg = 1 << (field & 0x3f);
+        MLX4_GET(size, outbox, QUERY_DEV_CAP_NUM_SYS_EQ_OFFSET);
+        dev_cap->num_sys_eqs = size & 0xfff;
         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_REQ_QP_OFFSET);
         dev_cap->max_requester_per_qp = 1 << (field & 0x3f);
         MLX4_GET(field, outbox, QUERY_DEV_CAP_MAX_RES_QP_OFFSET);
@@ -905,8 +926,11 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
          * we can't use any EQs whose doorbell falls on that page,
          * even if the EQ itself isn't reserved.
          */
-        dev_cap->reserved_eqs = max(dev_cap->reserved_uars * 4,
-                                    dev_cap->reserved_eqs);
+        if (dev_cap->num_sys_eqs == 0)
+                dev_cap->reserved_eqs = max(dev_cap->reserved_uars * 4,
+                                            dev_cap->reserved_eqs);
+        else
+                dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_SYS_EQS;
 
         mlx4_dbg(dev, "Max ICM size %lld MB\n",
                  (unsigned long long) dev_cap->max_icm_sz >> 20);
@@ -916,8 +940,9 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
                  dev_cap->max_srqs, dev_cap->reserved_srqs, dev_cap->srq_entry_sz);
         mlx4_dbg(dev, "Max CQs: %d, reserved CQs: %d, entry size: %d\n",
                  dev_cap->max_cqs, dev_cap->reserved_cqs, dev_cap->cqc_entry_sz);
-        mlx4_dbg(dev, "Max EQs: %d, reserved EQs: %d, entry size: %d\n",
-                 dev_cap->max_eqs, dev_cap->reserved_eqs, dev_cap->eqc_entry_sz);
+        mlx4_dbg(dev, "Num sys EQs: %d, max EQs: %d, reserved EQs: %d, entry size: %d\n",
+                 dev_cap->num_sys_eqs, dev_cap->max_eqs, dev_cap->reserved_eqs,
+                 dev_cap->eqc_entry_sz);
         mlx4_dbg(dev, "reserved MPTs: %d, reserved MTTs: %d\n",
                  dev_cap->reserved_mrws, dev_cap->reserved_mtts);
         mlx4_dbg(dev, "Max PDs: %d, reserved PDs: %d, reserved UARs: %d\n",
@@ -1463,6 +1488,7 @@ int mlx4_INIT_HCA(struct mlx4_dev *dev, struct mlx4_init_hca_param *param)
 #define  INIT_HCA_AUXC_BASE_OFFSET       (INIT_HCA_QPC_OFFSET + 0x50)
 #define  INIT_HCA_EQC_BASE_OFFSET        (INIT_HCA_QPC_OFFSET + 0x60)
 #define  INIT_HCA_LOG_EQ_OFFSET          (INIT_HCA_QPC_OFFSET + 0x67)
+#define INIT_HCA_NUM_SYS_EQS_OFFSET     (INIT_HCA_QPC_OFFSET + 0x6a)
 #define  INIT_HCA_RDMARC_BASE_OFFSET     (INIT_HCA_QPC_OFFSET + 0x70)
 #define  INIT_HCA_LOG_RD_OFFSET          (INIT_HCA_QPC_OFFSET + 0x77)
 #define INIT_HCA_MCAST_OFFSET            0x0c0
@@ -1566,6 +1592,7 @@ int mlx4_INIT_HCA(struct mlx4_dev *dev, struct mlx4_init_hca_param *param)
         MLX4_PUT(inbox, param->auxc_base,     INIT_HCA_AUXC_BASE_OFFSET);
         MLX4_PUT(inbox, param->eqc_base,      INIT_HCA_EQC_BASE_OFFSET);
         MLX4_PUT(inbox, param->log_num_eqs,   INIT_HCA_LOG_EQ_OFFSET);
+        MLX4_PUT(inbox, param->num_sys_eqs,   INIT_HCA_NUM_SYS_EQS_OFFSET);
         MLX4_PUT(inbox, param->rdmarc_base,   INIT_HCA_RDMARC_BASE_OFFSET);
         MLX4_PUT(inbox, param->log_rd_per_qp, INIT_HCA_LOG_RD_OFFSET);
 
@@ -1676,6 +1703,7 @@ int mlx4_QUERY_HCA(struct mlx4_dev *dev,
         MLX4_GET(param->auxc_base,     outbox, INIT_HCA_AUXC_BASE_OFFSET);
         MLX4_GET(param->eqc_base,      outbox, INIT_HCA_EQC_BASE_OFFSET);
         MLX4_GET(param->log_num_eqs,   outbox, INIT_HCA_LOG_EQ_OFFSET);
+        MLX4_GET(param->num_sys_eqs,   outbox, INIT_HCA_NUM_SYS_EQS_OFFSET);
         MLX4_GET(param->rdmarc_base,   outbox, INIT_HCA_RDMARC_BASE_OFFSET);
         MLX4_GET(param->log_rd_per_qp, outbox, INIT_HCA_LOG_RD_OFFSET);
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/fw.h b/drivers/net/ethernet/mellanox/mlx4/fw.h
index 48c11b5e73e7..475215ee370f 100644
--- a/drivers/net/ethernet/mellanox/mlx4/fw.h
+++ b/drivers/net/ethernet/mellanox/mlx4/fw.h
@@ -56,6 +56,7 @@ struct mlx4_dev_cap {
         int max_mpts;
         int reserved_eqs;
         int max_eqs;
+        int num_sys_eqs;
         int reserved_mtts;
         int max_mrw_sz;
         int reserved_mrws;
@@ -180,6 +181,7 @@ struct mlx4_init_hca_param {
         u8  log_num_srqs;
         u8  log_num_cqs;
         u8  log_num_eqs;
+        u16 num_sys_eqs;
         u8  log_rd_per_qp;
         u8  log_mc_table_sz;
         u8  log_mpt_sz;
diff --git a/drivers/net/ethernet/mellanox/mlx4/main.c b/drivers/net/ethernet/mellanox/mlx4/main.c
index 43047b2a2aac..ebb279060a25 100644
--- a/drivers/net/ethernet/mellanox/mlx4/main.c
+++ b/drivers/net/ethernet/mellanox/mlx4/main.c
@@ -197,6 +197,29 @@ static void mlx4_set_port_mask(struct mlx4_dev *dev)
                 dev->caps.port_mask[i] = dev->caps.port_type[i];
 }
 
+enum {
+        MLX4_QUERY_FUNC_NUM_SYS_EQS = 1 << 0,
+};
+
+static int mlx4_query_func(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
+{
+        int err = 0;
+        struct mlx4_func func;
+
+        if (dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_SYS_EQS) {
+                err = mlx4_QUERY_FUNC(dev, &func, 0);
+                if (err) {
+                        mlx4_err(dev, "QUERY_DEV_CAP command failed, aborting.\n");
+                        return err;
+                }
+                dev_cap->max_eqs = func.max_eq;
+                dev_cap->reserved_eqs = func.rsvd_eqs;
+                dev_cap->reserved_uars = func.rsvd_uars;
+                err |= MLX4_QUERY_FUNC_NUM_SYS_EQS;
+        }
+        return err;
+}
+
 static void mlx4_enable_cqe_eqe_stride(struct mlx4_dev *dev)
 {
         struct mlx4_caps *dev_cap = &dev->caps;
@@ -261,7 +284,10 @@ static int mlx4_dev_cap(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
         }
 
         dev->caps.num_ports          = dev_cap->num_ports;
-        dev->phys_caps.num_phys_eqs  = MLX4_MAX_EQ_NUM;
+        dev->caps.num_sys_eqs = dev_cap->num_sys_eqs;
+        dev->phys_caps.num_phys_eqs = dev_cap->flags2 & MLX4_DEV_CAP_FLAG2_SYS_EQS ?
+                                      dev->caps.num_sys_eqs :
+                                      MLX4_MAX_EQ_NUM;
         for (i = 1; i <= dev->caps.num_ports; ++i) {
                 dev->caps.vl_cap[i]         = dev_cap->max_vl[i];
                 dev->caps.ib_mtu_cap[i]     = dev_cap->ib_mtu[i];
@@ -1130,8 +1156,7 @@ static int mlx4_init_cmpt_table(struct mlx4_dev *dev, u64 cmpt_base,
         if (err)
                 goto err_srq;
 
-        num_eqs = (mlx4_is_master(dev)) ? dev->phys_caps.num_phys_eqs :
-                  dev->caps.num_eqs;
+        num_eqs = dev->phys_caps.num_phys_eqs;
         err = mlx4_init_icm_table(dev, &priv->eq_table.cmpt_table,
                                   cmpt_base +
                                   ((u64) (MLX4_CMPT_TYPE_EQ *
@@ -1193,8 +1218,7 @@ static int mlx4_init_icm(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap,
         }
 
 
-        num_eqs = (mlx4_is_master(dev)) ? dev->phys_caps.num_phys_eqs :
-                   dev->caps.num_eqs;
+        num_eqs = dev->phys_caps.num_phys_eqs;
         err = mlx4_init_icm_table(dev, &priv->eq_table.table,
                                   init_hca->eqc_base, dev_cap->eqc_entry_sz,
                                   num_eqs, num_eqs, 0, 0);
@@ -1719,6 +1743,19 @@ static int mlx4_init_hca(struct mlx4_dev *dev)
                         mlx4_err(dev, "INIT_HCA command failed, aborting\n");
                         goto err_free_icm;
                 }
+
+                if (dev_cap.flags2 & MLX4_DEV_CAP_FLAG2_SYS_EQS) {
+                        err = mlx4_query_func(dev, &dev_cap);
+                        if (err < 0) {
+                                mlx4_err(dev, "QUERY_FUNC command failed, aborting.\n");
+                                goto err_stop_fw;
+                        } else if (err & MLX4_QUERY_FUNC_NUM_SYS_EQS) {
+                                dev->caps.num_eqs = dev_cap.max_eqs;
+                                dev->caps.reserved_eqs = dev_cap.reserved_eqs;
+                                dev->caps.reserved_uars = dev_cap.reserved_uars;
+                        }
+                }
+
                 /*
                  * If TS is supported by FW
                  * read HCA frequency by QUERY_HCA command
@@ -2085,12 +2122,11 @@ static void mlx4_enable_msi_x(struct mlx4_dev *dev)
 {
         struct mlx4_priv *priv = mlx4_priv(dev);
         struct msix_entry *entries;
-        int nreq = min_t(int, dev->caps.num_ports *
-                         min_t(int, num_online_cpus() + 1,
-                               MAX_MSIX_P_PORT) + MSIX_LEGACY_SZ, MAX_MSIX);
         int i;
 
         if (msi_x) {
+                int nreq = dev->caps.num_ports * num_online_cpus() + MSIX_LEGACY_SZ;
+
                 nreq = min_t(int, dev->caps.num_eqs - dev->caps.reserved_eqs,
                              nreq);
 
@@ -2345,6 +2381,7 @@ static int mlx4_load_one(struct pci_dev *pdev, int pci_dev_data,
         int err;
         int port;
         int i;
+        struct mlx4_dev_cap *dev_cap = NULL;
         int existing_vfs = 0;
 
         dev = &priv->dev;
@@ -2381,15 +2418,6 @@ static int mlx4_load_one(struct pci_dev *pdev, int pci_dev_data,
                         }
                 }
 
-                if (total_vfs) {
-                        existing_vfs = pci_num_vf(pdev);
-                        dev->flags = MLX4_FLAG_MASTER;
-                        dev->flags = mlx4_enable_sriov(dev, pdev, total_vfs,
-                                                       existing_vfs);
-                        if (!SRIOV_VALID_STATE(dev->flags))
-                                goto err_sriov;
-                }
-
                 atomic_set(&priv->opreq_count, 0);
                 INIT_WORK(&priv->opreq_task, mlx4_opreq_action);
 
@@ -2403,6 +2431,12 @@ static int mlx4_load_one(struct pci_dev *pdev, int pci_dev_data,
                         mlx4_err(dev, "Failed to reset HCA, aborting\n");
                         goto err_sriov;
                 }
+
+                if (total_vfs) {
+                        existing_vfs = pci_num_vf(pdev);
+                        dev->flags = MLX4_FLAG_MASTER;
+                        dev->num_vfs = total_vfs;
+                }
         }
 
 slave_start:
@@ -2416,9 +2450,10 @@ slave_start:
          * before posting commands. Also, init num_slaves before calling
          * mlx4_init_hca */
         if (mlx4_is_mfunc(dev)) {
-                if (mlx4_is_master(dev))
+                if (mlx4_is_master(dev)) {
                         dev->num_slaves = MLX4_MAX_NUM_SLAVES;
-                else {
+
+                } else {
                         dev->num_slaves = 0;
                         err = mlx4_multi_func_init(dev);
                         if (err) {
@@ -2434,6 +2469,52 @@ slave_start:
                 goto err_mfunc;
         }
 
+        if (mlx4_is_master(dev)) {
+                if (!dev_cap) {
+                        dev_cap = kzalloc(sizeof(*dev_cap), GFP_KERNEL);
+
+                        if (!dev_cap) {
+                                err = -ENOMEM;
+                                goto err_fw;
+                        }
+
+                        err = mlx4_QUERY_DEV_CAP(dev, dev_cap);
+                        if (err) {
+                                mlx4_err(dev, "QUERY_DEV_CAP command failed, aborting.\n");
+                                goto err_fw;
+                        }
+
+                        if (!(dev_cap->flags2 & MLX4_DEV_CAP_FLAG2_SYS_EQS)) {
+                                u64 dev_flags = mlx4_enable_sriov(dev, pdev, total_vfs,
+                                                                  existing_vfs);
+
+                                mlx4_cmd_cleanup(dev, MLX4_CMD_CLEANUP_ALL);
+                                dev->flags = dev_flags;
+                                if (!SRIOV_VALID_STATE(dev->flags)) {
+                                        mlx4_err(dev, "Invalid SRIOV state\n");
+                                        goto err_sriov;
+                                }
+                                err = mlx4_reset(dev);
+                                if (err) {
+                                        mlx4_err(dev, "Failed to reset HCA, aborting.\n");
+                                        goto err_sriov;
+                                }
+                                goto slave_start;
+                        }
+                } else {
+                        /* Legacy mode FW requires SRIOV to be enabled before
+                         * doing QUERY_DEV_CAP, since max_eq's value is different if
+                         * SRIOV is enabled.
+                         */
+                        memset(dev_cap, 0, sizeof(*dev_cap));
+                        err = mlx4_QUERY_DEV_CAP(dev, dev_cap);
+                        if (err) {
+                                mlx4_err(dev, "QUERY_DEV_CAP command failed, aborting.\n");
+                                goto err_fw;
+                        }
+                }
+        }
+
         err = mlx4_init_hca(dev);
         if (err) {
                 if (err == -EACCES) {
@@ -2457,6 +2538,30 @@ slave_start:
                         goto err_fw;
         }
 
+        if (mlx4_is_master(dev) && (dev_cap->flags2 & MLX4_DEV_CAP_FLAG2_SYS_EQS)) {
+                u64 dev_flags = mlx4_enable_sriov(dev, pdev, total_vfs, existing_vfs);
+
+                if ((dev->flags ^ dev_flags) & (MLX4_FLAG_MASTER | MLX4_FLAG_SLAVE)) {
+                        mlx4_cmd_cleanup(dev, MLX4_CMD_CLEANUP_VHCR);
+                        dev->flags = dev_flags;
+                        err = mlx4_cmd_init(dev);
+                        if (err) {
+                                /* Only VHCR is cleaned up, so could still
+                                 * send FW commands
+                                 */
+                                mlx4_err(dev, "Failed to init VHCR command interface, aborting\n");
+                                goto err_close;
+                        }
+                } else {
+                        dev->flags = dev_flags;
+                }
+
+                if (!SRIOV_VALID_STATE(dev->flags)) {
+                        mlx4_err(dev, "Invalid SRIOV state\n");
+                        goto err_close;
+                }
+        }
+
         /* check if the device is functioning at its maximum possible speed.
          * No return code for this call, just warn the user in case of PCI
          * express device capabilities are under-satisfied by the bus.
@@ -2631,6 +2736,7 @@ err_sriov:
         if (!mlx4_is_slave(dev))
                 mlx4_free_ownership(dev);
 
+        kfree(dev_cap);
         return err;
 }
 
diff --git a/drivers/net/ethernet/mellanox/mlx4/profile.c b/drivers/net/ethernet/mellanox/mlx4/profile.c
index 14089d9e1667..2bf437aafc53 100644
--- a/drivers/net/ethernet/mellanox/mlx4/profile.c
+++ b/drivers/net/ethernet/mellanox/mlx4/profile.c
@@ -126,8 +126,7 @@ u64 mlx4_make_profile(struct mlx4_dev *dev,
         profile[MLX4_RES_AUXC].num    = request->num_qp;
         profile[MLX4_RES_SRQ].num     = request->num_srq;
         profile[MLX4_RES_CQ].num      = request->num_cq;
-        profile[MLX4_RES_EQ].num      = mlx4_is_mfunc(dev) ?
-                                        dev->phys_caps.num_phys_eqs :
+        profile[MLX4_RES_EQ].num = mlx4_is_mfunc(dev) ? dev->phys_caps.num_phys_eqs :
                                         min_t(unsigned, dev_cap->max_eqs, MAX_MSIX);
         profile[MLX4_RES_DMPT].num    = request->num_mpt;
         profile[MLX4_RES_CMPT].num    = MLX4_NUM_CMPTS;
@@ -216,10 +215,18 @@ u64 mlx4_make_profile(struct mlx4_dev *dev,
                         init_hca->log_num_cqs = profile[i].log_num;
                         break;
                 case MLX4_RES_EQ:
-                        dev->caps.num_eqs     = roundup_pow_of_two(min_t(unsigned, dev_cap->max_eqs,
-                                                                         MAX_MSIX));
-                        init_hca->eqc_base    = profile[i].start;
-                        init_hca->log_num_eqs = ilog2(dev->caps.num_eqs);
+                        if (dev_cap->flags2 & MLX4_DEV_CAP_FLAG2_SYS_EQS) {
+                                init_hca->log_num_eqs = 0x1f;
+                                init_hca->eqc_base    = profile[i].start;
+                                init_hca->num_sys_eqs = dev_cap->num_sys_eqs;
+                        } else {
+                                dev->caps.num_eqs     = roundup_pow_of_two(
+                                                                min_t(unsigned,
+                                                                      dev_cap->max_eqs,
+                                                                      MAX_MSIX));
+                                init_hca->eqc_base    = profile[i].start;
+                                init_hca->log_num_eqs = ilog2(dev->caps.num_eqs);
+                        }
                         break;
                 case MLX4_RES_DMPT:
                         dev->caps.num_mpts      = profile[i].num;
diff --git a/include/linux/mlx4/device.h b/include/linux/mlx4/device.h
index 3d9bff00f24a..1c560eb870ad 100644
--- a/include/linux/mlx4/device.h
+++ b/include/linux/mlx4/device.h
@@ -189,7 +189,8 @@ enum {
         MLX4_DEV_CAP_FLAG2_EQE_STRIDE           = 1LL <<  13,
         MLX4_DEV_CAP_FLAG2_ETH_PROT_CTRL        = 1LL <<  14,
         MLX4_DEV_CAP_FLAG2_ETH_BACKPL_AN_REP    = 1LL <<  15,
-        MLX4_DEV_CAP_FLAG2_CONFIG_DEV           = 1LL <<  16
+        MLX4_DEV_CAP_FLAG2_CONFIG_DEV           = 1LL <<  16,
+        MLX4_DEV_CAP_FLAG2_SYS_EQS              = 1LL <<  17
 };
 
 enum {
@@ -443,6 +444,7 @@ struct mlx4_caps {
         int                     num_cqs;
         int                     max_cqes;
         int                     reserved_cqs;
+        int                     num_sys_eqs;
         int                     num_eqs;
         int                     reserved_eqs;
         int                     num_comp_vectors;