Merge tag 'rdma-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband

Pull infiniband/rdma updates from Roland Dreier:
 "Main set of InfiniBand/RDMA updates for 3.17 merge window:

   - MR reregistration support
   - MAD support for RMPP in userspace
   - iSER and SRP initiator updates
   - ocrdma hardware driver updates
   - other fixes..."

* tag 'rdma-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband: (52 commits)
  IB/srp: Fix return value check in srp_init_module()
  RDMA/ocrdma: report asic-id in query device
  RDMA/ocrdma: Update sli data structure for endianness
  RDMA/ocrdma: Obtain SL from device structure
  RDMA/uapi: Include socket.h in rdma_user_cm.h
  IB/srpt: Handle GID change events
  IB/mlx5: Use ARRAY_SIZE instead of sizeof/sizeof[0]
  IB/mlx4: Use ARRAY_SIZE instead of sizeof/sizeof[0]
  RDMA/amso1100: Check for integer overflow in c2_alloc_cq_buf()
  IPoIB: Remove unnecessary test for NULL before debugfs_remove()
  IB/mad: Add user space RMPP support
  IB/mad: add new ioctl to ABI to support new registration options
  IB/mad: Add dev_notice messages for various umad/mad registration failures
  IB/mad: Update module to [pr|dev]_* style print messages
  IB/ipoib: Avoid multicast join attempts with invalid P_key
  IB/umad: Update module to [pr|dev]_* style print messages
  IB/ipoib: Avoid flushing the workqueue from worker context
  IB/ipoib: Use P_Key change event instead of P_Key polling mechanism
  IB/ipath: Add P_Key change event support
  mlx4_core: Add support for secure-host and SMP firewall
  ...

10 files changed, 311 insertions, 6 deletions

diff --git a/drivers/net/ethernet/emulex/benet/be.h b/drivers/net/ethernet/emulex/benet/be.h
index 811f1351db7a..43e08d0bc3d3 100644
--- a/drivers/net/ethernet/emulex/benet/be.h
+++ b/drivers/net/ethernet/emulex/benet/be.h
@@ -897,5 +897,6 @@ void be_roce_dev_remove(struct be_adapter *);
  */
 void be_roce_dev_open(struct be_adapter *);
 void be_roce_dev_close(struct be_adapter *);
+void be_roce_dev_shutdown(struct be_adapter *);
 
 #endif                          /* BE_H */
diff --git a/drivers/net/ethernet/emulex/benet/be_main.c b/drivers/net/ethernet/emulex/benet/be_main.c
index db4ff14ff18f..9cdeda54674a 100644
--- a/drivers/net/ethernet/emulex/benet/be_main.c
+++ b/drivers/net/ethernet/emulex/benet/be_main.c
@@ -5014,6 +5014,7 @@ static void be_shutdown(struct pci_dev *pdev)
         if (!adapter)
                 return;
 
+        be_roce_dev_shutdown(adapter);
         cancel_delayed_work_sync(&adapter->work);
         cancel_delayed_work_sync(&adapter->func_recovery_work);
 
diff --git a/drivers/net/ethernet/emulex/benet/be_roce.c b/drivers/net/ethernet/emulex/benet/be_roce.c
index 5bf16603a3e9..ef4672dc7357 100644
--- a/drivers/net/ethernet/emulex/benet/be_roce.c
+++ b/drivers/net/ethernet/emulex/benet/be_roce.c
@@ -120,7 +120,8 @@ static void _be_roce_dev_open(struct be_adapter *adapter)
 {
         if (ocrdma_drv && adapter->ocrdma_dev &&
             ocrdma_drv->state_change_handler)
-                ocrdma_drv->state_change_handler(adapter->ocrdma_dev, 0);
+                ocrdma_drv->state_change_handler(adapter->ocrdma_dev,
+                                                 BE_DEV_UP);
 }
 
 void be_roce_dev_open(struct be_adapter *adapter)
@@ -136,7 +137,8 @@ static void _be_roce_dev_close(struct be_adapter *adapter)
 {
         if (ocrdma_drv && adapter->ocrdma_dev &&
             ocrdma_drv->state_change_handler)
-                ocrdma_drv->state_change_handler(adapter->ocrdma_dev, 1);
+                ocrdma_drv->state_change_handler(adapter->ocrdma_dev,
+                                                 BE_DEV_DOWN);
 }
 
 void be_roce_dev_close(struct be_adapter *adapter)
@@ -148,6 +150,18 @@ void be_roce_dev_close(struct be_adapter *adapter)
         }
 }
 
+void be_roce_dev_shutdown(struct be_adapter *adapter)
+{
+        if (be_roce_supported(adapter)) {
+                mutex_lock(&be_adapter_list_lock);
+                if (ocrdma_drv && adapter->ocrdma_dev &&
+                    ocrdma_drv->state_change_handler)
+                        ocrdma_drv->state_change_handler(adapter->ocrdma_dev,
+                                                         BE_DEV_SHUTDOWN);
+                mutex_unlock(&be_adapter_list_lock);
+        }
+}
+
 int be_roce_register_driver(struct ocrdma_driver *drv)
 {
         struct be_adapter *dev;
diff --git a/drivers/net/ethernet/emulex/benet/be_roce.h b/drivers/net/ethernet/emulex/benet/be_roce.h
index a3d9e96c18eb..e6f7eb1a7d87 100644
--- a/drivers/net/ethernet/emulex/benet/be_roce.h
+++ b/drivers/net/ethernet/emulex/benet/be_roce.h
@@ -62,7 +62,8 @@ struct ocrdma_driver {
 
 enum {
         BE_DEV_UP       = 0,
-        BE_DEV_DOWN     = 1
+        BE_DEV_DOWN     = 1,
+        BE_DEV_SHUTDOWN = 2
 };
 
 /* APIs for RoCE driver to register callback handlers,
diff --git a/drivers/net/ethernet/mellanox/mlx4/cmd.c b/drivers/net/ethernet/mellanox/mlx4/cmd.c
index 5d940a26055c..65a4a0f88ea0 100644
--- a/drivers/net/ethernet/mellanox/mlx4/cmd.c
+++ b/drivers/net/ethernet/mellanox/mlx4/cmd.c
@@ -1311,6 +1311,15 @@ static struct mlx4_cmd_info cmd_info[] = {
                 .wrapper = mlx4_MAD_IFC_wrapper
         },
         {
+                .opcode = MLX4_CMD_MAD_DEMUX,
+                .has_inbox = false,
+                .has_outbox = false,
+                .out_is_imm = false,
+                .encode_slave_id = false,
+                .verify = NULL,
+                .wrapper = mlx4_CMD_EPERM_wrapper
+        },
+        {
                 .opcode = MLX4_CMD_QUERY_IF_STAT,
                 .has_inbox = false,
                 .has_outbox = true,
diff --git a/drivers/net/ethernet/mellanox/mlx4/fw.c b/drivers/net/ethernet/mellanox/mlx4/fw.c
index 688e1eabab29..494753e44ae3 100644
--- a/drivers/net/ethernet/mellanox/mlx4/fw.c
+++ b/drivers/net/ethernet/mellanox/mlx4/fw.c
@@ -136,7 +136,8 @@ static void dump_dev_cap_flags2(struct mlx4_dev *dev, u64 flags)
                 [7] = "FSM (MAC anti-spoofing) support",
                 [8] = "Dynamic QP updates support",
                 [9] = "Device managed flow steering IPoIB support",
-                [10] = "TCP/IP offloads/flow-steering for VXLAN support"
+                [10] = "TCP/IP offloads/flow-steering for VXLAN support",
+                [11] = "MAD DEMUX (Secure-Host) support"
         };
         int i;
 
@@ -571,6 +572,7 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
 #define QUERY_DEV_CAP_MAX_ICM_SZ_OFFSET         0xa0
 #define QUERY_DEV_CAP_FW_REASSIGN_MAC           0x9d
 #define QUERY_DEV_CAP_VXLAN                     0x9e
+#define QUERY_DEV_CAP_MAD_DEMUX_OFFSET          0xb0
 
         dev_cap->flags2 = 0;
         mailbox = mlx4_alloc_cmd_mailbox(dev);
@@ -748,6 +750,11 @@ int mlx4_QUERY_DEV_CAP(struct mlx4_dev *dev, struct mlx4_dev_cap *dev_cap)
                 MLX4_GET(dev_cap->max_counters, outbox,
                          QUERY_DEV_CAP_MAX_COUNTERS_OFFSET);
 
+        MLX4_GET(field32, outbox,
+                 QUERY_DEV_CAP_MAD_DEMUX_OFFSET);
+        if (field32 & (1 << 0))
+                dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_MAD_DEMUX;
+
         MLX4_GET(field32, outbox, QUERY_DEV_CAP_EXT_2_FLAGS_OFFSET);
         if (field32 & (1 << 16))
                 dev_cap->flags2 |= MLX4_DEV_CAP_FLAG2_UPDATE_QP;
@@ -2016,3 +2023,85 @@ void mlx4_opreq_action(struct work_struct *work)
 out:
         mlx4_free_cmd_mailbox(dev, mailbox);
 }
+
+static int mlx4_check_smp_firewall_active(struct mlx4_dev *dev,
+                                          struct mlx4_cmd_mailbox *mailbox)
+{
+#define MLX4_CMD_MAD_DEMUX_SET_ATTR_OFFSET              0x10
+#define MLX4_CMD_MAD_DEMUX_GETRESP_ATTR_OFFSET          0x20
+#define MLX4_CMD_MAD_DEMUX_TRAP_ATTR_OFFSET             0x40
+#define MLX4_CMD_MAD_DEMUX_TRAP_REPRESS_ATTR_OFFSET     0x70
+
+        u32 set_attr_mask, getresp_attr_mask;
+        u32 trap_attr_mask, traprepress_attr_mask;
+
+        MLX4_GET(set_attr_mask, mailbox->buf,
+                 MLX4_CMD_MAD_DEMUX_SET_ATTR_OFFSET);
+        mlx4_dbg(dev, "SMP firewall set_attribute_mask = 0x%x\n",
+                 set_attr_mask);
+
+        MLX4_GET(getresp_attr_mask, mailbox->buf,
+                 MLX4_CMD_MAD_DEMUX_GETRESP_ATTR_OFFSET);
+        mlx4_dbg(dev, "SMP firewall getresp_attribute_mask = 0x%x\n",
+                 getresp_attr_mask);
+
+        MLX4_GET(trap_attr_mask, mailbox->buf,
+                 MLX4_CMD_MAD_DEMUX_TRAP_ATTR_OFFSET);
+        mlx4_dbg(dev, "SMP firewall trap_attribute_mask = 0x%x\n",
+                 trap_attr_mask);
+
+        MLX4_GET(traprepress_attr_mask, mailbox->buf,
+                 MLX4_CMD_MAD_DEMUX_TRAP_REPRESS_ATTR_OFFSET);
+        mlx4_dbg(dev, "SMP firewall traprepress_attribute_mask = 0x%x\n",
+                 traprepress_attr_mask);
+
+        if (set_attr_mask && getresp_attr_mask && trap_attr_mask &&
+            traprepress_attr_mask)
+                return 1;
+
+        return 0;
+}
+
+int mlx4_config_mad_demux(struct mlx4_dev *dev)
+{
+        struct mlx4_cmd_mailbox *mailbox;
+        int secure_host_active;
+        int err;
+
+        /* Check if mad_demux is supported */
+        if (!(dev->caps.flags2 & MLX4_DEV_CAP_FLAG2_MAD_DEMUX))
+                return 0;
+
+        mailbox = mlx4_alloc_cmd_mailbox(dev);
+        if (IS_ERR(mailbox)) {
+                mlx4_warn(dev, "Failed to allocate mailbox for cmd MAD_DEMUX");
+                return -ENOMEM;
+        }
+
+        /* Query mad_demux to find out which MADs are handled by internal sma */
+        err = mlx4_cmd_box(dev, 0, mailbox->dma, 0x01 /* subn mgmt class */,
+                           MLX4_CMD_MAD_DEMUX_QUERY_RESTR, MLX4_CMD_MAD_DEMUX,
+                           MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
+        if (err) {
+                mlx4_warn(dev, "MLX4_CMD_MAD_DEMUX: query restrictions failed (%d)\n",
+                          err);
+                goto out;
+        }
+
+        secure_host_active = mlx4_check_smp_firewall_active(dev, mailbox);
+
+        /* Config mad_demux to handle all MADs returned by the query above */
+        err = mlx4_cmd(dev, mailbox->dma, 0x01 /* subn mgmt class */,
+                       MLX4_CMD_MAD_DEMUX_CONFIG, MLX4_CMD_MAD_DEMUX,
+                       MLX4_CMD_TIME_CLASS_B, MLX4_CMD_NATIVE);
+        if (err) {
+                mlx4_warn(dev, "MLX4_CMD_MAD_DEMUX: configure failed (%d)\n", err);
+                goto out;
+        }
+
+        if (secure_host_active)
+                mlx4_warn(dev, "HCA operating in secure-host mode. SMP firewall activated.\n");
+out:
+        mlx4_free_cmd_mailbox(dev, mailbox);
+        return err;
+}
diff --git a/drivers/net/ethernet/mellanox/mlx4/main.c b/drivers/net/ethernet/mellanox/mlx4/main.c
index 80b8c5f30e4e..0158689906fd 100644
--- a/drivers/net/ethernet/mellanox/mlx4/main.c
+++ b/drivers/net/ethernet/mellanox/mlx4/main.c
@@ -1853,6 +1853,11 @@ static int mlx4_setup_hca(struct mlx4_dev *dev)
                         mlx4_err(dev, "Failed to initialize multicast group table, aborting\n");
                         goto err_mr_table_free;
                 }
+                err = mlx4_config_mad_demux(dev);
+                if (err) {
+                        mlx4_err(dev, "Failed in config_mad_demux, aborting\n");
+                        goto err_mcg_table_free;
+                }
         }
 
         err = mlx4_init_eq_table(dev);
diff --git a/drivers/net/ethernet/mellanox/mlx4/mlx4.h b/drivers/net/ethernet/mellanox/mlx4/mlx4.h
index 13fbcd03c3e4..b508c7887ef8 100644
--- a/drivers/net/ethernet/mellanox/mlx4/mlx4.h
+++ b/drivers/net/ethernet/mellanox/mlx4/mlx4.h
@@ -274,6 +274,8 @@ struct mlx4_icm_table {
 #define MLX4_MPT_FLAG_PHYSICAL      (1 <<  9)
 #define MLX4_MPT_FLAG_REGION        (1 <<  8)
 
+#define MLX4_MPT_PD_MASK            (0x1FFFFUL)
+#define MLX4_MPT_PD_VF_MASK         (0xFE0000UL)
 #define MLX4_MPT_PD_FLAG_FAST_REG   (1 << 27)
 #define MLX4_MPT_PD_FLAG_RAE        (1 << 28)
 #define MLX4_MPT_PD_FLAG_EN_INV     (3 << 24)
@@ -1306,5 +1308,6 @@ void mlx4_init_quotas(struct mlx4_dev *dev);
 int mlx4_get_slave_num_gids(struct mlx4_dev *dev, int slave, int port);
 /* Returns the VF index of slave */
 int mlx4_get_vf_indx(struct mlx4_dev *dev, int slave);
+int mlx4_config_mad_demux(struct mlx4_dev *dev);
 
 #endif /* MLX4_H */
diff --git a/drivers/net/ethernet/mellanox/mlx4/mr.c b/drivers/net/ethernet/mellanox/mlx4/mr.c
index 2839abb878a6..7d717eccb7b0 100644
--- a/drivers/net/ethernet/mellanox/mlx4/mr.c
+++ b/drivers/net/ethernet/mellanox/mlx4/mr.c
@@ -298,6 +298,131 @@ static int mlx4_HW2SW_MPT(struct mlx4_dev *dev, struct mlx4_cmd_mailbox *mailbox
                             MLX4_CMD_TIME_CLASS_B, MLX4_CMD_WRAPPED);
 }
 
+int mlx4_mr_hw_get_mpt(struct mlx4_dev *dev, struct mlx4_mr *mmr,
+                       struct mlx4_mpt_entry ***mpt_entry)
+{
+        int err;
+        int key = key_to_hw_index(mmr->key) & (dev->caps.num_mpts - 1);
+        struct mlx4_cmd_mailbox *mailbox = NULL;
+
+        /* Make sure that at this point we have single-threaded access only */
+
+        if (mmr->enabled != MLX4_MPT_EN_HW)
+                return -EINVAL;
+
+        err = mlx4_HW2SW_MPT(dev, NULL, key);
+
+        if (err) {
+                mlx4_warn(dev, "HW2SW_MPT failed (%d).", err);
+                mlx4_warn(dev, "Most likely the MR has MWs bound to it.\n");
+                return err;
+        }
+
+        mmr->enabled = MLX4_MPT_EN_SW;
+
+        if (!mlx4_is_mfunc(dev)) {
+                **mpt_entry = mlx4_table_find(
+                                &mlx4_priv(dev)->mr_table.dmpt_table,
+                                key, NULL);
+        } else {
+                mailbox = mlx4_alloc_cmd_mailbox(dev);
+                if (IS_ERR_OR_NULL(mailbox))
+                        return PTR_ERR(mailbox);
+
+                err = mlx4_cmd_box(dev, 0, mailbox->dma, key,
+                                   0, MLX4_CMD_QUERY_MPT,
+                                   MLX4_CMD_TIME_CLASS_B,
+                                   MLX4_CMD_WRAPPED);
+
+                if (err)
+                        goto free_mailbox;
+
+                *mpt_entry = (struct mlx4_mpt_entry **)&mailbox->buf;
+        }
+
+        if (!(*mpt_entry) || !(**mpt_entry)) {
+                err = -ENOMEM;
+                goto free_mailbox;
+        }
+
+        return 0;
+
+free_mailbox:
+        mlx4_free_cmd_mailbox(dev, mailbox);
+        return err;
+}
+EXPORT_SYMBOL_GPL(mlx4_mr_hw_get_mpt);
+
+int mlx4_mr_hw_write_mpt(struct mlx4_dev *dev, struct mlx4_mr *mmr,
+                         struct mlx4_mpt_entry **mpt_entry)
+{
+        int err;
+
+        if (!mlx4_is_mfunc(dev)) {
+                /* Make sure any changes to this entry are flushed */
+                wmb();
+
+                *(u8 *)(*mpt_entry) = MLX4_MPT_STATUS_HW;
+
+                /* Make sure the new status is written */
+                wmb();
+
+                err = mlx4_SYNC_TPT(dev);
+        } else {
+                int key = key_to_hw_index(mmr->key) & (dev->caps.num_mpts - 1);
+
+                struct mlx4_cmd_mailbox *mailbox =
+                        container_of((void *)mpt_entry, struct mlx4_cmd_mailbox,
+                                     buf);
+
+                err = mlx4_SW2HW_MPT(dev, mailbox, key);
+        }
+
+        mmr->pd = be32_to_cpu((*mpt_entry)->pd_flags) & MLX4_MPT_PD_MASK;
+        if (!err)
+                mmr->enabled = MLX4_MPT_EN_HW;
+        return err;
+}
+EXPORT_SYMBOL_GPL(mlx4_mr_hw_write_mpt);
+
+void mlx4_mr_hw_put_mpt(struct mlx4_dev *dev,
+                        struct mlx4_mpt_entry **mpt_entry)
+{
+        if (mlx4_is_mfunc(dev)) {
+                struct mlx4_cmd_mailbox *mailbox =
+                        container_of((void *)mpt_entry, struct mlx4_cmd_mailbox,
+                                     buf);
+                mlx4_free_cmd_mailbox(dev, mailbox);
+        }
+}
+EXPORT_SYMBOL_GPL(mlx4_mr_hw_put_mpt);
+
+int mlx4_mr_hw_change_pd(struct mlx4_dev *dev, struct mlx4_mpt_entry *mpt_entry,
+                         u32 pdn)
+{
+        u32 pd_flags = be32_to_cpu(mpt_entry->pd_flags);
+        /* The wrapper function will put the slave's id here */
+        if (mlx4_is_mfunc(dev))
+                pd_flags &= ~MLX4_MPT_PD_VF_MASK;
+        mpt_entry->pd_flags = cpu_to_be32((pd_flags &  ~MLX4_MPT_PD_MASK) |
+                                          (pdn & MLX4_MPT_PD_MASK)
+                                          | MLX4_MPT_PD_FLAG_EN_INV);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(mlx4_mr_hw_change_pd);
+
+int mlx4_mr_hw_change_access(struct mlx4_dev *dev,
+                             struct mlx4_mpt_entry *mpt_entry,
+                             u32 access)
+{
+        u32 flags = (be32_to_cpu(mpt_entry->flags) & ~MLX4_PERM_MASK) |
+                    (access & MLX4_PERM_MASK);
+
+        mpt_entry->flags = cpu_to_be32(flags);
+        return 0;
+}
+EXPORT_SYMBOL_GPL(mlx4_mr_hw_change_access);
+
 static int mlx4_mr_alloc_reserved(struct mlx4_dev *dev, u32 mridx, u32 pd,
                            u64 iova, u64 size, u32 access, int npages,
                            int page_shift, struct mlx4_mr *mr)
@@ -463,6 +588,41 @@ int mlx4_mr_free(struct mlx4_dev *dev, struct mlx4_mr *mr)
 }
 EXPORT_SYMBOL_GPL(mlx4_mr_free);
 
+void mlx4_mr_rereg_mem_cleanup(struct mlx4_dev *dev, struct mlx4_mr *mr)
+{
+        mlx4_mtt_cleanup(dev, &mr->mtt);
+}
+EXPORT_SYMBOL_GPL(mlx4_mr_rereg_mem_cleanup);
+
+int mlx4_mr_rereg_mem_write(struct mlx4_dev *dev, struct mlx4_mr *mr,
+                            u64 iova, u64 size, int npages,
+                            int page_shift, struct mlx4_mpt_entry *mpt_entry)
+{
+        int err;
+
+        mpt_entry->start       = cpu_to_be64(mr->iova);
+        mpt_entry->length      = cpu_to_be64(mr->size);
+        mpt_entry->entity_size = cpu_to_be32(mr->mtt.page_shift);
+
+        err = mlx4_mtt_init(dev, npages, page_shift, &mr->mtt);
+        if (err)
+                return err;
+
+        if (mr->mtt.order < 0) {
+                mpt_entry->flags |= cpu_to_be32(MLX4_MPT_FLAG_PHYSICAL);
+                mpt_entry->mtt_addr = 0;
+        } else {
+                mpt_entry->mtt_addr = cpu_to_be64(mlx4_mtt_addr(dev,
+                                                  &mr->mtt));
+                if (mr->mtt.page_shift == 0)
+                        mpt_entry->mtt_sz    = cpu_to_be32(1 << mr->mtt.order);
+        }
+        mr->enabled = MLX4_MPT_EN_SW;
+
+        return 0;
+}
+EXPORT_SYMBOL_GPL(mlx4_mr_rereg_mem_write);
+
 int mlx4_mr_enable(struct mlx4_dev *dev, struct mlx4_mr *mr)
 {
         struct mlx4_cmd_mailbox *mailbox;
diff --git a/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c b/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
index 0efc1368e5a8..1089367fed22 100644
--- a/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
+++ b/drivers/net/ethernet/mellanox/mlx4/resource_tracker.c
@@ -2613,12 +2613,34 @@ int mlx4_QUERY_MPT_wrapper(struct mlx4_dev *dev, int slave,
         if (err)
                 return err;
 
-        if (mpt->com.from_state != RES_MPT_HW) {
+        if (mpt->com.from_state == RES_MPT_MAPPED) {
+                /* In order to allow rereg in SRIOV, we need to alter the MPT entry. To do
+                 * that, the VF must read the MPT. But since the MPT entry memory is not
+                 * in the VF's virtual memory space, it must use QUERY_MPT to obtain the
+                 * entry contents. To guarantee that the MPT cannot be changed, the driver
+                 * must perform HW2SW_MPT before this query and return the MPT entry to HW
+                 * ownership fofollowing the change. The change here allows the VF to
+                 * perform QUERY_MPT also when the entry is in SW ownership.
+                 */
+                struct mlx4_mpt_entry *mpt_entry = mlx4_table_find(
+                                        &mlx4_priv(dev)->mr_table.dmpt_table,
+                                        mpt->key, NULL);
+
+                if (NULL == mpt_entry || NULL == outbox->buf) {
+                        err = -EINVAL;
+                        goto out;
+                }
+
+                memcpy(outbox->buf, mpt_entry, sizeof(*mpt_entry));
+
+                err = 0;
+        } else if (mpt->com.from_state == RES_MPT_HW) {
+                err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
+        } else {
                 err = -EBUSY;
                 goto out;
         }
 
-        err = mlx4_DMA_wrapper(dev, slave, vhcr, inbox, outbox, cmd);
 
 out:
         put_res(dev, slave, id, RES_MPT);