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

* 'for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband:
  mlx4_core: Increase command timeout for INIT_HCA to 10 seconds
  IPoIB/cm: Use common CQ for CM send completions
  IB/uverbs: Fix checking of userspace object ownership
  IB/mlx4: Sanity check userspace send queue sizes
  IPoIB: Rewrite "if (!likely(...))" as "if (unlikely(!(...)))"
  IB/ehca: Enable large page MRs by default
  IB/ehca: Change meaning of hca_cap_mr_pgsize
  IB/ehca: Fix ehca_encode_hwpage_size() and alloc_fmr()
  IB/ehca: Fix masking error in {,re}reg_phys_mr()
  IB/ehca: Supply QP token for SRQ base QPs
  IPoIB: Use round_jiffies() for ah_reap_task
  RDMA/cma: Fix deadlock destroying listen requests
  RDMA/cma: Add locking around QP accesses
  IB/mthca: Avoid alignment traps when writing doorbells
  mlx4_core: Kill mlx4_write64_raw()

11 files changed, 107 insertions, 135 deletions

diff --git a/drivers/infiniband/hw/ehca/ehca_classes.h b/drivers/infiniband/hw/ehca/ehca_classes.h
index 3f2d68cff76..2d660ae189e 100644
--- a/drivers/infiniband/hw/ehca/ehca_classes.h
+++ b/drivers/infiniband/hw/ehca/ehca_classes.h
@@ -323,7 +323,6 @@ extern int ehca_static_rate;
 extern int ehca_port_act_time;
 extern int ehca_use_hp_mr;
 extern int ehca_scaling_code;
-extern int ehca_mr_largepage;
 
 struct ipzu_queue_resp {
         u32 qe_size;      /* queue entry size */
diff --git a/drivers/infiniband/hw/ehca/ehca_hca.c b/drivers/infiniband/hw/ehca/ehca_hca.c
index 4aa3ffa6a19..15806d14046 100644
--- a/drivers/infiniband/hw/ehca/ehca_hca.c
+++ b/drivers/infiniband/hw/ehca/ehca_hca.c
@@ -77,6 +77,7 @@ int ehca_query_device(struct ib_device *ibdev, struct ib_device_attr *props)
         }
 
         memset(props, 0, sizeof(struct ib_device_attr));
+        props->page_size_cap   = shca->hca_cap_mr_pgsize;
         props->fw_ver          = rblock->hw_ver;
         props->max_mr_size     = rblock->max_mr_size;
         props->vendor_id       = rblock->vendor_id >> 8;
diff --git a/drivers/infiniband/hw/ehca/ehca_main.c b/drivers/infiniband/hw/ehca/ehca_main.c
index 7a7dab890f6..c6cd38c5321 100644
--- a/drivers/infiniband/hw/ehca/ehca_main.c
+++ b/drivers/infiniband/hw/ehca/ehca_main.c
@@ -65,7 +65,7 @@ int ehca_port_act_time = 30;
 int ehca_poll_all_eqs  = 1;
 int ehca_static_rate   = -1;
 int ehca_scaling_code  = 0;
-int ehca_mr_largepage  = 0;
+int ehca_mr_largepage  = 1;
 
 module_param_named(open_aqp1,     ehca_open_aqp1,     int, S_IRUGO);
 module_param_named(debug_level,   ehca_debug_level,   int, S_IRUGO);
@@ -260,13 +260,20 @@ static struct cap_descr {
         { HCA_CAP_MINI_QP, "HCA_CAP_MINI_QP" },
 };
 
-int ehca_sense_attributes(struct ehca_shca *shca)
+static int ehca_sense_attributes(struct ehca_shca *shca)
 {
         int i, ret = 0;
         u64 h_ret;
         struct hipz_query_hca *rblock;
         struct hipz_query_port *port;
 
+        static const u32 pgsize_map[] = {
+                HCA_CAP_MR_PGSIZE_4K,  0x1000,
+                HCA_CAP_MR_PGSIZE_64K, 0x10000,
+                HCA_CAP_MR_PGSIZE_1M,  0x100000,
+                HCA_CAP_MR_PGSIZE_16M, 0x1000000,
+        };
+
         rblock = ehca_alloc_fw_ctrlblock(GFP_KERNEL);
         if (!rblock) {
                 ehca_gen_err("Cannot allocate rblock memory.");
@@ -329,8 +336,15 @@ int ehca_sense_attributes(struct ehca_shca *shca)
                 if (EHCA_BMASK_GET(hca_cap_descr[i].mask, shca->hca_cap))
                         ehca_gen_dbg("   %s", hca_cap_descr[i].descr);
 
-        shca->hca_cap_mr_pgsize = rblock->memory_page_size_supported;
+        /* translate supported MR page sizes; always support 4K */
+        shca->hca_cap_mr_pgsize = EHCA_PAGESIZE;
+        if (ehca_mr_largepage) { /* support extra sizes only if enabled */
+                for (i = 0; i < ARRAY_SIZE(pgsize_map); i += 2)
+                        if (rblock->memory_page_size_supported & pgsize_map[i])
+                                shca->hca_cap_mr_pgsize |= pgsize_map[i + 1];
+        }
 
+        /* query max MTU from first port -- it's the same for all ports */
         port = (struct hipz_query_port *)rblock;
         h_ret = hipz_h_query_port(shca->ipz_hca_handle, 1, port);
         if (h_ret != H_SUCCESS) {
diff --git a/drivers/infiniband/hw/ehca/ehca_mrmw.c b/drivers/infiniband/hw/ehca/ehca_mrmw.c
index ead7230d773..e239bbf54da 100644
--- a/drivers/infiniband/hw/ehca/ehca_mrmw.c
+++ b/drivers/infiniband/hw/ehca/ehca_mrmw.c
@@ -72,24 +72,14 @@ enum ehca_mr_pgsize {
 
 static u32 ehca_encode_hwpage_size(u32 pgsize)
 {
-        u32 idx = 0;
-        pgsize >>= 12;
-        /*
-         * map mr page size into hw code:
-         * 0, 1, 2, 3 for 4K, 64K, 1M, 64M
-         */
-        while (!(pgsize & 1)) {
-                idx++;
-                pgsize >>= 4;
-        }
-        return idx;
+        int log = ilog2(pgsize);
+        WARN_ON(log < 12 || log > 24 || log & 3);
+        return (log - 12) / 4;
 }
 
 static u64 ehca_get_max_hwpage_size(struct ehca_shca *shca)
 {
-        if (shca->hca_cap_mr_pgsize & HCA_CAP_MR_PGSIZE_16M)
-                return EHCA_MR_PGSIZE16M;
-        return EHCA_MR_PGSIZE4K;
+        return 1UL << ilog2(shca->hca_cap_mr_pgsize);
 }
 
 static struct ehca_mr *ehca_mr_new(void)
@@ -259,7 +249,7 @@ struct ib_mr *ehca_reg_phys_mr(struct ib_pd *pd,
                 pginfo.u.phy.num_phys_buf = num_phys_buf;
                 pginfo.u.phy.phys_buf_array = phys_buf_array;
                 pginfo.next_hwpage =
-                        ((u64)iova_start & ~(hw_pgsize - 1)) / hw_pgsize;
+                        ((u64)iova_start & ~PAGE_MASK) / hw_pgsize;
 
                 ret = ehca_reg_mr(shca, e_mr, iova_start, size, mr_access_flags,
                                   e_pd, &pginfo, &e_mr->ib.ib_mr.lkey,
@@ -296,7 +286,7 @@ struct ib_mr *ehca_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
                 container_of(pd->device, struct ehca_shca, ib_device);
         struct ehca_pd *e_pd = container_of(pd, struct ehca_pd, ib_pd);
         struct ehca_mr_pginfo pginfo;
-        int ret;
+        int ret, page_shift;
         u32 num_kpages;
         u32 num_hwpages;
         u64 hwpage_size;
@@ -351,19 +341,20 @@ struct ib_mr *ehca_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
         /* determine number of MR pages */
         num_kpages = NUM_CHUNKS((virt % PAGE_SIZE) + length, PAGE_SIZE);
         /* select proper hw_pgsize */
-        if (ehca_mr_largepage &&
-            (shca->hca_cap_mr_pgsize & HCA_CAP_MR_PGSIZE_16M)) {
-                int page_shift = PAGE_SHIFT;
-                if (e_mr->umem->hugetlb) {
-                        /* determine page_shift, clamp between 4K and 16M */
-                        page_shift = (fls64(length - 1) + 3) & ~3;
-                        page_shift = min(max(page_shift, EHCA_MR_PGSHIFT4K),
-                                         EHCA_MR_PGSHIFT16M);
-                }
-                hwpage_size = 1UL << page_shift;
-        } else
-                hwpage_size = EHCA_MR_PGSIZE4K; /* ehca1 only supports 4k */
-        ehca_dbg(pd->device, "hwpage_size=%lx", hwpage_size);
+        page_shift = PAGE_SHIFT;
+        if (e_mr->umem->hugetlb) {
+                /* determine page_shift, clamp between 4K and 16M */
+                page_shift = (fls64(length - 1) + 3) & ~3;
+                page_shift = min(max(page_shift, EHCA_MR_PGSHIFT4K),
+                                 EHCA_MR_PGSHIFT16M);
+        }
+        hwpage_size = 1UL << page_shift;
+
+        /* now that we have the desired page size, shift until it's
+         * supported, too. 4K is always supported, so this terminates.
+         */
+        while (!(hwpage_size & shca->hca_cap_mr_pgsize))
+                hwpage_size >>= 4;
 
 reg_user_mr_fallback:
         num_hwpages = NUM_CHUNKS((virt % hwpage_size) + length, hwpage_size);
@@ -547,7 +538,7 @@ int ehca_rereg_phys_mr(struct ib_mr *mr,
                 pginfo.u.phy.num_phys_buf = num_phys_buf;
                 pginfo.u.phy.phys_buf_array = phys_buf_array;
                 pginfo.next_hwpage =
-                        ((u64)iova_start & ~(hw_pgsize - 1)) / hw_pgsize;
+                        ((u64)iova_start & ~PAGE_MASK) / hw_pgsize;
         }
         if (mr_rereg_mask & IB_MR_REREG_ACCESS)
                 new_acl = mr_access_flags;
@@ -809,8 +800,9 @@ struct ib_fmr *ehca_alloc_fmr(struct ib_pd *pd,
                 ib_fmr = ERR_PTR(-EINVAL);
                 goto alloc_fmr_exit0;
         }
-        hw_pgsize = ehca_get_max_hwpage_size(shca);
-        if ((1 << fmr_attr->page_shift) != hw_pgsize) {
+
+        hw_pgsize = 1 << fmr_attr->page_shift;
+        if (!(hw_pgsize & shca->hca_cap_mr_pgsize)) {
                 ehca_err(pd->device, "unsupported fmr_attr->page_shift=%x",
                          fmr_attr->page_shift);
                 ib_fmr = ERR_PTR(-EINVAL);
@@ -826,6 +818,7 @@ struct ib_fmr *ehca_alloc_fmr(struct ib_pd *pd,
 
         /* register MR on HCA */
         memset(&pginfo, 0, sizeof(pginfo));
+        pginfo.hwpage_size = hw_pgsize;
         /*
          * pginfo.num_hwpages==0, ie register_rpages() will not be called
          * but deferred to map_phys_fmr()
diff --git a/drivers/infiniband/hw/ehca/ehca_qp.c b/drivers/infiniband/hw/ehca/ehca_qp.c
index e2bd62be11e..de182648b28 100644
--- a/drivers/infiniband/hw/ehca/ehca_qp.c
+++ b/drivers/infiniband/hw/ehca/ehca_qp.c
@@ -451,7 +451,6 @@ static struct ehca_qp *internal_create_qp(
                 has_srq = 1;
                 parms.ext_type = EQPT_SRQBASE;
                 parms.srq_qpn = my_srq->real_qp_num;
-                parms.srq_token = my_srq->token;
         }
 
         if (is_llqp && has_srq) {
@@ -583,6 +582,9 @@ static struct ehca_qp *internal_create_qp(
                 goto create_qp_exit1;
         }
 
+        if (has_srq)
+                parms.srq_token = my_qp->token;
+
         parms.servicetype = ibqptype2servicetype(qp_type);
         if (parms.servicetype < 0) {
                 ret = -EINVAL;
diff --git a/drivers/infiniband/hw/mlx4/qp.c b/drivers/infiniband/hw/mlx4/qp.c
index 31a480e5b0d..6b3322486b5 100644
--- a/drivers/infiniband/hw/mlx4/qp.c
+++ b/drivers/infiniband/hw/mlx4/qp.c
@@ -63,6 +63,10 @@ struct mlx4_ib_sqp {
         u8                      header_buf[MLX4_IB_UD_HEADER_SIZE];
 };
 
+enum {
+        MLX4_IB_MIN_SQ_STRIDE = 6
+};
+
 static const __be32 mlx4_ib_opcode[] = {
         [IB_WR_SEND]                    = __constant_cpu_to_be32(MLX4_OPCODE_SEND),
         [IB_WR_SEND_WITH_IMM]           = __constant_cpu_to_be32(MLX4_OPCODE_SEND_IMM),
@@ -285,9 +289,17 @@ static int set_kernel_sq_size(struct mlx4_ib_dev *dev, struct ib_qp_cap *cap,
         return 0;
 }
 
-static int set_user_sq_size(struct mlx4_ib_qp *qp,
+static int set_user_sq_size(struct mlx4_ib_dev *dev,
+                            struct mlx4_ib_qp *qp,
                             struct mlx4_ib_create_qp *ucmd)
 {
+        /* Sanity check SQ size before proceeding */
+        if ((1 << ucmd->log_sq_bb_count) > dev->dev->caps.max_wqes       ||
+            ucmd->log_sq_stride >
+                ilog2(roundup_pow_of_two(dev->dev->caps.max_sq_desc_sz)) ||
+            ucmd->log_sq_stride < MLX4_IB_MIN_SQ_STRIDE)
+                return -EINVAL;
+
         qp->sq.wqe_cnt   = 1 << ucmd->log_sq_bb_count;
         qp->sq.wqe_shift = ucmd->log_sq_stride;
 
@@ -330,7 +342,7 @@ static int create_qp_common(struct mlx4_ib_dev *dev, struct ib_pd *pd,
 
                 qp->sq_no_prefetch = ucmd.sq_no_prefetch;
 
-                err = set_user_sq_size(qp, &ucmd);
+                err = set_user_sq_size(dev, qp, &ucmd);
                 if (err)
                         goto err;
 
diff --git a/drivers/infiniband/hw/mthca/mthca_cq.c b/drivers/infiniband/hw/mthca/mthca_cq.c
index be6e1e03bda..6bd9f139334 100644
--- a/drivers/infiniband/hw/mthca/mthca_cq.c
+++ b/drivers/infiniband/hw/mthca/mthca_cq.c
@@ -204,16 +204,11 @@ static void dump_cqe(struct mthca_dev *dev, void *cqe_ptr)
 static inline void update_cons_index(struct mthca_dev *dev, struct mthca_cq *cq,
                                      int incr)
 {
-        __be32 doorbell[2];
-
         if (mthca_is_memfree(dev)) {
                 *cq->set_ci_db = cpu_to_be32(cq->cons_index);
                 wmb();
         } else {
-                doorbell[0] = cpu_to_be32(MTHCA_TAVOR_CQ_DB_INC_CI | cq->cqn);
-                doorbell[1] = cpu_to_be32(incr - 1);
-
-                mthca_write64(doorbell,
+                mthca_write64(MTHCA_TAVOR_CQ_DB_INC_CI | cq->cqn, incr - 1,
                               dev->kar + MTHCA_CQ_DOORBELL,
                               MTHCA_GET_DOORBELL_LOCK(&dev->doorbell_lock));
                 /*
@@ -731,17 +726,12 @@ repoll:
 
 int mthca_tavor_arm_cq(struct ib_cq *cq, enum ib_cq_notify_flags flags)
 {
-        __be32 doorbell[2];
+        u32 dbhi = ((flags & IB_CQ_SOLICITED_MASK) == IB_CQ_SOLICITED ?
+                    MTHCA_TAVOR_CQ_DB_REQ_NOT_SOL :
+                    MTHCA_TAVOR_CQ_DB_REQ_NOT) |
+                to_mcq(cq)->cqn;
 
-        doorbell[0] = cpu_to_be32(((flags & IB_CQ_SOLICITED_MASK) ==
-                                   IB_CQ_SOLICITED ?
-                                   MTHCA_TAVOR_CQ_DB_REQ_NOT_SOL :
-                                   MTHCA_TAVOR_CQ_DB_REQ_NOT)      |
-                                  to_mcq(cq)->cqn);
-        doorbell[1] = (__force __be32) 0xffffffff;
-
-        mthca_write64(doorbell,
-                      to_mdev(cq->device)->kar + MTHCA_CQ_DOORBELL,
+        mthca_write64(dbhi, 0xffffffff, to_mdev(cq->device)->kar + MTHCA_CQ_DOORBELL,
                       MTHCA_GET_DOORBELL_LOCK(&to_mdev(cq->device)->doorbell_lock));
 
         return 0;
@@ -750,19 +740,16 @@ int mthca_tavor_arm_cq(struct ib_cq *cq, enum ib_cq_notify_flags flags)
 int mthca_arbel_arm_cq(struct ib_cq *ibcq, enum ib_cq_notify_flags flags)
 {
         struct mthca_cq *cq = to_mcq(ibcq);
-        __be32 doorbell[2];
-        u32 sn;
-        __be32 ci;
-
-        sn = cq->arm_sn & 3;
-        ci = cpu_to_be32(cq->cons_index);
+        __be32 db_rec[2];
+        u32 dbhi;
+        u32 sn = cq->arm_sn & 3;
 
-        doorbell[0] = ci;
-        doorbell[1] = cpu_to_be32((cq->cqn << 8) | (2 << 5) | (sn << 3) |
-                                  ((flags & IB_CQ_SOLICITED_MASK) ==
-                                   IB_CQ_SOLICITED ? 1 : 2));
+        db_rec[0] = cpu_to_be32(cq->cons_index);
+        db_rec[1] = cpu_to_be32((cq->cqn << 8) | (2 << 5) | (sn << 3) |
+                                ((flags & IB_CQ_SOLICITED_MASK) ==
+                                 IB_CQ_SOLICITED ? 1 : 2));
 
-        mthca_write_db_rec(doorbell, cq->arm_db);
+        mthca_write_db_rec(db_rec, cq->arm_db);
 
         /*
          * Make sure that the doorbell record in host memory is
@@ -770,14 +757,12 @@ int mthca_arbel_arm_cq(struct ib_cq *ibcq, enum ib_cq_notify_flags flags)
          */
         wmb();
 
-        doorbell[0] = cpu_to_be32((sn << 28)                       |
-                                  ((flags & IB_CQ_SOLICITED_MASK) == IB_CQ_SOLICITED ?
-                                   MTHCA_ARBEL_CQ_DB_REQ_NOT_SOL :
-                                   MTHCA_ARBEL_CQ_DB_REQ_NOT)      |
-                                  cq->cqn);
-        doorbell[1] = ci;
+        dbhi = (sn << 28) |
+                ((flags & IB_CQ_SOLICITED_MASK) == IB_CQ_SOLICITED ?
+                 MTHCA_ARBEL_CQ_DB_REQ_NOT_SOL :
+                 MTHCA_ARBEL_CQ_DB_REQ_NOT) | cq->cqn;
 
-        mthca_write64(doorbell,
+        mthca_write64(dbhi, cq->cons_index,
                       to_mdev(ibcq->device)->kar + MTHCA_CQ_DOORBELL,
                       MTHCA_GET_DOORBELL_LOCK(&to_mdev(ibcq->device)->doorbell_lock));
 
diff --git a/drivers/infiniband/hw/mthca/mthca_doorbell.h b/drivers/infiniband/hw/mthca/mthca_doorbell.h
index dd9a44d170c..b374dc395be 100644
--- a/drivers/infiniband/hw/mthca/mthca_doorbell.h
+++ b/drivers/infiniband/hw/mthca/mthca_doorbell.h
@@ -58,10 +58,10 @@ static inline void mthca_write64_raw(__be64 val, void __iomem *dest)
         __raw_writeq((__force u64) val, dest);
 }
 
-static inline void mthca_write64(__be32 val[2], void __iomem *dest,
+static inline void mthca_write64(u32 hi, u32 lo, void __iomem *dest,
                                  spinlock_t *doorbell_lock)
 {
-        __raw_writeq(*(u64 *) val, dest);
+        __raw_writeq((__force u64) cpu_to_be64((u64) hi << 32 | lo), dest);
 }
 
 static inline void mthca_write_db_rec(__be32 val[2], __be32 *db)
@@ -87,14 +87,17 @@ static inline void mthca_write64_raw(__be64 val, void __iomem *dest)
         __raw_writel(((__force u32 *) &val)[1], dest + 4);
 }
 
-static inline void mthca_write64(__be32 val[2], void __iomem *dest,
+static inline void mthca_write64(u32 hi, u32 lo, void __iomem *dest,
                                  spinlock_t *doorbell_lock)
 {
         unsigned long flags;
 
+        hi = (__force u32) cpu_to_be32(hi);
+        lo = (__force u32) cpu_to_be32(lo);
+
         spin_lock_irqsave(doorbell_lock, flags);
-        __raw_writel((__force u32) val[0], dest);
-        __raw_writel((__force u32) val[1], dest + 4);
+        __raw_writel(hi, dest);
+        __raw_writel(lo, dest + 4);
         spin_unlock_irqrestore(doorbell_lock, flags);
 }
 
diff --git a/drivers/infiniband/hw/mthca/mthca_eq.c b/drivers/infiniband/hw/mthca/mthca_eq.c
index 8592b26dc4e..b29de51b7f3 100644
--- a/drivers/infiniband/hw/mthca/mthca_eq.c
+++ b/drivers/infiniband/hw/mthca/mthca_eq.c
@@ -173,11 +173,6 @@ static inline u64 async_mask(struct mthca_dev *dev)
 
 static inline void tavor_set_eq_ci(struct mthca_dev *dev, struct mthca_eq *eq, u32 ci)
 {
-        __be32 doorbell[2];
-
-        doorbell[0] = cpu_to_be32(MTHCA_EQ_DB_SET_CI | eq->eqn);
-        doorbell[1] = cpu_to_be32(ci & (eq->nent - 1));
-
         /*
          * This barrier makes sure that all updates to ownership bits
          * done by set_eqe_hw() hit memory before the consumer index
@@ -187,7 +182,7 @@ static inline void tavor_set_eq_ci(struct mthca_dev *dev, struct mthca_eq *eq, u
          * having set_eqe_hw() overwrite the owner field.
          */
         wmb();
-        mthca_write64(doorbell,
+        mthca_write64(MTHCA_EQ_DB_SET_CI | eq->eqn, ci & (eq->nent - 1),
                       dev->kar + MTHCA_EQ_DOORBELL,
                       MTHCA_GET_DOORBELL_LOCK(&dev->doorbell_lock));
 }
@@ -212,12 +207,7 @@ static inline void set_eq_ci(struct mthca_dev *dev, struct mthca_eq *eq, u32 ci)
 
 static inline void tavor_eq_req_not(struct mthca_dev *dev, int eqn)
 {
-        __be32 doorbell[2];
-
-        doorbell[0] = cpu_to_be32(MTHCA_EQ_DB_REQ_NOT | eqn);
-        doorbell[1] = 0;
-
-        mthca_write64(doorbell,
+        mthca_write64(MTHCA_EQ_DB_REQ_NOT | eqn, 0,
                       dev->kar + MTHCA_EQ_DOORBELL,
                       MTHCA_GET_DOORBELL_LOCK(&dev->doorbell_lock));
 }
@@ -230,12 +220,7 @@ static inline void arbel_eq_req_not(struct mthca_dev *dev, u32 eqn_mask)
 static inline void disarm_cq(struct mthca_dev *dev, int eqn, int cqn)
 {
         if (!mthca_is_memfree(dev)) {
-                __be32 doorbell[2];
-
-                doorbell[0] = cpu_to_be32(MTHCA_EQ_DB_DISARM_CQ | eqn);
-                doorbell[1] = cpu_to_be32(cqn);
-
-                mthca_write64(doorbell,
+                mthca_write64(MTHCA_EQ_DB_DISARM_CQ | eqn, cqn,
                               dev->kar + MTHCA_EQ_DOORBELL,
                               MTHCA_GET_DOORBELL_LOCK(&dev->doorbell_lock));
         }
diff --git a/drivers/infiniband/hw/mthca/mthca_qp.c b/drivers/infiniband/hw/mthca/mthca_qp.c
index df01b2026a6..0e5461c6573 100644
--- a/drivers/infiniband/hw/mthca/mthca_qp.c
+++ b/drivers/infiniband/hw/mthca/mthca_qp.c
@@ -1799,15 +1799,11 @@ int mthca_tavor_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
 
 out:
         if (likely(nreq)) {
-                __be32 doorbell[2];
-
-                doorbell[0] = cpu_to_be32(((qp->sq.next_ind << qp->sq.wqe_shift) +
-                                           qp->send_wqe_offset) | f0 | op0);
-                doorbell[1] = cpu_to_be32((qp->qpn << 8) | size0);
-
                 wmb();
 
-                mthca_write64(doorbell,
+                mthca_write64(((qp->sq.next_ind << qp->sq.wqe_shift) +
+                               qp->send_wqe_offset) | f0 | op0,
+                              (qp->qpn << 8) | size0,
                               dev->kar + MTHCA_SEND_DOORBELL,
                               MTHCA_GET_DOORBELL_LOCK(&dev->doorbell_lock));
                 /*
@@ -1829,7 +1825,6 @@ int mthca_tavor_post_receive(struct ib_qp *ibqp, struct ib_recv_wr *wr,
 {
         struct mthca_dev *dev = to_mdev(ibqp->device);
         struct mthca_qp *qp = to_mqp(ibqp);
-        __be32 doorbell[2];
         unsigned long flags;
         int err = 0;
         int nreq;
@@ -1907,13 +1902,10 @@ int mthca_tavor_post_receive(struct ib_qp *ibqp, struct ib_recv_wr *wr,
                 if (unlikely(nreq == MTHCA_TAVOR_MAX_WQES_PER_RECV_DB)) {
                         nreq = 0;
 
-                        doorbell[0] = cpu_to_be32((qp->rq.next_ind << qp->rq.wqe_shift) | size0);
-                        doorbell[1] = cpu_to_be32(qp->qpn << 8);
-
                         wmb();
 
-                        mthca_write64(doorbell,
-                                      dev->kar + MTHCA_RECEIVE_DOORBELL,
+                        mthca_write64((qp->rq.next_ind << qp->rq.wqe_shift) | size0,
+                                      qp->qpn << 8, dev->kar + MTHCA_RECEIVE_DOORBELL,
                                       MTHCA_GET_DOORBELL_LOCK(&dev->doorbell_lock));
 
                         qp->rq.next_ind = ind;
@@ -1923,13 +1915,10 @@ int mthca_tavor_post_receive(struct ib_qp *ibqp, struct ib_recv_wr *wr,
 
 out:
         if (likely(nreq)) {
-                doorbell[0] = cpu_to_be32((qp->rq.next_ind << qp->rq.wqe_shift) | size0);
-                doorbell[1] = cpu_to_be32((qp->qpn << 8) | nreq);
-
                 wmb();
 
-                mthca_write64(doorbell,
-                              dev->kar + MTHCA_RECEIVE_DOORBELL,
+                mthca_write64((qp->rq.next_ind << qp->rq.wqe_shift) | size0,
+                              qp->qpn << 8 | nreq, dev->kar + MTHCA_RECEIVE_DOORBELL,
                               MTHCA_GET_DOORBELL_LOCK(&dev->doorbell_lock));
         }
 
@@ -1951,7 +1940,7 @@ int mthca_arbel_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
 {
         struct mthca_dev *dev = to_mdev(ibqp->device);
         struct mthca_qp *qp = to_mqp(ibqp);
-        __be32 doorbell[2];
+        u32 dbhi;
         void *wqe;
         void *prev_wqe;
         unsigned long flags;
@@ -1981,10 +1970,8 @@ int mthca_arbel_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                 if (unlikely(nreq == MTHCA_ARBEL_MAX_WQES_PER_SEND_DB)) {
                         nreq = 0;
 
-                        doorbell[0] = cpu_to_be32((MTHCA_ARBEL_MAX_WQES_PER_SEND_DB << 24) |
-                                                  ((qp->sq.head & 0xffff) << 8) |
-                                                  f0 | op0);
-                        doorbell[1] = cpu_to_be32((qp->qpn << 8) | size0);
+                        dbhi = (MTHCA_ARBEL_MAX_WQES_PER_SEND_DB << 24) |
+                                ((qp->sq.head & 0xffff) << 8) | f0 | op0;
 
                         qp->sq.head += MTHCA_ARBEL_MAX_WQES_PER_SEND_DB;
 
@@ -2000,7 +1987,8 @@ int mthca_arbel_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                          * write MMIO send doorbell.
                          */
                         wmb();
-                        mthca_write64(doorbell,
+
+                        mthca_write64(dbhi, (qp->qpn << 8) | size0,
                                       dev->kar + MTHCA_SEND_DOORBELL,
                                       MTHCA_GET_DOORBELL_LOCK(&dev->doorbell_lock));
                 }
@@ -2154,10 +2142,7 @@ int mthca_arbel_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
 
 out:
         if (likely(nreq)) {
-                doorbell[0] = cpu_to_be32((nreq << 24)                  |
-                                          ((qp->sq.head & 0xffff) << 8) |
-                                          f0 | op0);
-                doorbell[1] = cpu_to_be32((qp->qpn << 8) | size0);
+                dbhi = (nreq << 24) | ((qp->sq.head & 0xffff) << 8) | f0 | op0;
 
                 qp->sq.head += nreq;
 
@@ -2173,8 +2158,8 @@ out:
                  * write MMIO send doorbell.
                  */
                 wmb();
-                mthca_write64(doorbell,
-                              dev->kar + MTHCA_SEND_DOORBELL,
+
+                mthca_write64(dbhi, (qp->qpn << 8) | size0, dev->kar + MTHCA_SEND_DOORBELL,
                               MTHCA_GET_DOORBELL_LOCK(&dev->doorbell_lock));
         }
 
diff --git a/drivers/infiniband/hw/mthca/mthca_srq.c b/drivers/infiniband/hw/mthca/mthca_srq.c
index 3f58c11a62b..553d681f681 100644
--- a/drivers/infiniband/hw/mthca/mthca_srq.c
+++ b/drivers/infiniband/hw/mthca/mthca_srq.c
@@ -491,7 +491,6 @@ int mthca_tavor_post_srq_recv(struct ib_srq *ibsrq, struct ib_recv_wr *wr,
 {
         struct mthca_dev *dev = to_mdev(ibsrq->device);
         struct mthca_srq *srq = to_msrq(ibsrq);
-        __be32 doorbell[2];
         unsigned long flags;
         int err = 0;
         int first_ind;
@@ -563,16 +562,13 @@ int mthca_tavor_post_srq_recv(struct ib_srq *ibsrq, struct ib_recv_wr *wr,
                 if (unlikely(nreq == MTHCA_TAVOR_MAX_WQES_PER_RECV_DB)) {
                         nreq = 0;
 
-                        doorbell[0] = cpu_to_be32(first_ind << srq->wqe_shift);
-                        doorbell[1] = cpu_to_be32(srq->srqn << 8);
-
                         /*
                          * Make sure that descriptors are written
                          * before doorbell is rung.
                          */
                         wmb();
 
-                        mthca_write64(doorbell,
+                        mthca_write64(first_ind << srq->wqe_shift, srq->srqn << 8,
                                       dev->kar + MTHCA_RECEIVE_DOORBELL,
                                       MTHCA_GET_DOORBELL_LOCK(&dev->doorbell_lock));
 
@@ -581,16 +577,13 @@ int mthca_tavor_post_srq_recv(struct ib_srq *ibsrq, struct ib_recv_wr *wr,
         }
 
         if (likely(nreq)) {
-                doorbell[0] = cpu_to_be32(first_ind << srq->wqe_shift);
-                doorbell[1] = cpu_to_be32((srq->srqn << 8) | nreq);
-
                 /*
                  * Make sure that descriptors are written before
                  * doorbell is rung.
                  */
                 wmb();
 
-                mthca_write64(doorbell,
+                mthca_write64(first_ind << srq->wqe_shift, (srq->srqn << 8) | nreq,
                               dev->kar + MTHCA_RECEIVE_DOORBELL,
                               MTHCA_GET_DOORBELL_LOCK(&dev->doorbell_lock));
         }