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

Pull InfiniBand/RDMA changes for the 3.4 merge window from Roland Dreier:
 "Nothing big really stands out; by patch count lots of fixes to the
  mlx4 driver plus some cleanups and fixes to the core and other
  drivers."

* tag 'rdma-for-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/roland/infiniband: (28 commits)
  mlx4_core: Scale size of MTT table with system RAM
  mlx4_core: Allow dynamic MTU configuration for IB ports
  IB/mlx4: Fix info returned when querying IBoE ports
  IB/mlx4: Fix possible missed completion event
  mlx4_core: Report thermal error events
  mlx4_core: Fix one more static exported function
  IB: Change CQE "csum_ok" field to a bit flag
  RDMA/iwcm: Reject connect requests if cmid is not in LISTEN state
  RDMA/cxgb3: Don't pass irq flags to flush_qp()
  mlx4_core: Get rid of redundant ext_port_cap flags
  RDMA/ucma: Fix AB-BA deadlock
  IB/ehca: Fix ilog2() compile failure
  IB: Use central enum for speed instead of hard-coded values
  IB/iser: Post initial receive buffers before sending the final login request
  IB/iser: Free IB connection resources in the proper place
  IB/srp: Consolidate repetitive sysfs code
  IB/srp: Use pr_fmt() and pr_err()/pr_warn()
  IB/core: Fix SDR rates in sysfs
  mlx4: Enforce device max FMR maps in FMR alloc
  IB/mlx4: Set bad_wr for invalid send opcode
  ...

20 files changed, 230 insertions, 150 deletions

diff --git a/drivers/infiniband/hw/amso1100/c2_provider.c b/drivers/infiniband/hw/amso1100/c2_provider.c
index 12f923d64e42..07eb3a8067d8 100644
--- a/drivers/infiniband/hw/amso1100/c2_provider.c
+++ b/drivers/infiniband/hw/amso1100/c2_provider.c
@@ -94,7 +94,7 @@ static int c2_query_port(struct ib_device *ibdev,
         props->pkey_tbl_len = 1;
         props->qkey_viol_cntr = 0;
         props->active_width = 1;
-        props->active_speed = 1;
+        props->active_speed = IB_SPEED_SDR;
 
         return 0;
 }
diff --git a/drivers/infiniband/hw/cxgb3/iwch_provider.c b/drivers/infiniband/hw/cxgb3/iwch_provider.c
index 37c224fc3ad9..0bdf09aa6f42 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_provider.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_provider.c
@@ -1227,7 +1227,7 @@ static int iwch_query_port(struct ib_device *ibdev,
         props->gid_tbl_len = 1;
         props->pkey_tbl_len = 1;
         props->active_width = 2;
-        props->active_speed = 2;
+        props->active_speed = IB_SPEED_DDR;
         props->max_msg_sz = -1;
 
         return 0;
diff --git a/drivers/infiniband/hw/cxgb3/iwch_qp.c b/drivers/infiniband/hw/cxgb3/iwch_qp.c
index bea5839d89ee..6de8463f453b 100644
--- a/drivers/infiniband/hw/cxgb3/iwch_qp.c
+++ b/drivers/infiniband/hw/cxgb3/iwch_qp.c
@@ -803,7 +803,7 @@ int iwch_post_terminate(struct iwch_qp *qhp, struct respQ_msg_t *rsp_msg)
  * Assumes qhp lock is held.
  */
 static void __flush_qp(struct iwch_qp *qhp, struct iwch_cq *rchp,
-                                struct iwch_cq *schp, unsigned long *flag)
+                                struct iwch_cq *schp)
 {
         int count;
         int flushed;
@@ -812,44 +812,44 @@ static void __flush_qp(struct iwch_qp *qhp, struct iwch_cq *rchp,
         PDBG("%s qhp %p rchp %p schp %p\n", __func__, qhp, rchp, schp);
         /* take a ref on the qhp since we must release the lock */
         atomic_inc(&qhp->refcnt);
-        spin_unlock_irqrestore(&qhp->lock, *flag);
+        spin_unlock(&qhp->lock);
 
         /* locking hierarchy: cq lock first, then qp lock. */
-        spin_lock_irqsave(&rchp->lock, *flag);
+        spin_lock(&rchp->lock);
         spin_lock(&qhp->lock);
         cxio_flush_hw_cq(&rchp->cq);
         cxio_count_rcqes(&rchp->cq, &qhp->wq, &count);
         flushed = cxio_flush_rq(&qhp->wq, &rchp->cq, count);
         spin_unlock(&qhp->lock);
-        spin_unlock_irqrestore(&rchp->lock, *flag);
+        spin_unlock(&rchp->lock);
         if (flushed) {
-                spin_lock_irqsave(&rchp->comp_handler_lock, *flag);
+                spin_lock(&rchp->comp_handler_lock);
                 (*rchp->ibcq.comp_handler)(&rchp->ibcq, rchp->ibcq.cq_context);
-                spin_unlock_irqrestore(&rchp->comp_handler_lock, *flag);
+                spin_unlock(&rchp->comp_handler_lock);
         }
 
         /* locking hierarchy: cq lock first, then qp lock. */
-        spin_lock_irqsave(&schp->lock, *flag);
+        spin_lock(&schp->lock);
         spin_lock(&qhp->lock);
         cxio_flush_hw_cq(&schp->cq);
         cxio_count_scqes(&schp->cq, &qhp->wq, &count);
         flushed = cxio_flush_sq(&qhp->wq, &schp->cq, count);
         spin_unlock(&qhp->lock);
-        spin_unlock_irqrestore(&schp->lock, *flag);
+        spin_unlock(&schp->lock);
         if (flushed) {
-                spin_lock_irqsave(&schp->comp_handler_lock, *flag);
+                spin_lock(&schp->comp_handler_lock);
                 (*schp->ibcq.comp_handler)(&schp->ibcq, schp->ibcq.cq_context);
-                spin_unlock_irqrestore(&schp->comp_handler_lock, *flag);
+                spin_unlock(&schp->comp_handler_lock);
         }
 
         /* deref */
         if (atomic_dec_and_test(&qhp->refcnt))
                 wake_up(&qhp->wait);
 
-        spin_lock_irqsave(&qhp->lock, *flag);
+        spin_lock(&qhp->lock);
 }
 
-static void flush_qp(struct iwch_qp *qhp, unsigned long *flag)
+static void flush_qp(struct iwch_qp *qhp)
 {
         struct iwch_cq *rchp, *schp;
 
@@ -859,19 +859,19 @@ static void flush_qp(struct iwch_qp *qhp, unsigned long *flag)
         if (qhp->ibqp.uobject) {
                 cxio_set_wq_in_error(&qhp->wq);
                 cxio_set_cq_in_error(&rchp->cq);
-                spin_lock_irqsave(&rchp->comp_handler_lock, *flag);
+                spin_lock(&rchp->comp_handler_lock);
                 (*rchp->ibcq.comp_handler)(&rchp->ibcq, rchp->ibcq.cq_context);
-                spin_unlock_irqrestore(&rchp->comp_handler_lock, *flag);
+                spin_unlock(&rchp->comp_handler_lock);
                 if (schp != rchp) {
                         cxio_set_cq_in_error(&schp->cq);
-                        spin_lock_irqsave(&schp->comp_handler_lock, *flag);
+                        spin_lock(&schp->comp_handler_lock);
                         (*schp->ibcq.comp_handler)(&schp->ibcq,
                                                    schp->ibcq.cq_context);
-                        spin_unlock_irqrestore(&schp->comp_handler_lock, *flag);
+                        spin_unlock(&schp->comp_handler_lock);
                 }
                 return;
         }
-        __flush_qp(qhp, rchp, schp, flag);
+        __flush_qp(qhp, rchp, schp);
 }
 
 
@@ -1030,7 +1030,7 @@ int iwch_modify_qp(struct iwch_dev *rhp, struct iwch_qp *qhp,
                         break;
                 case IWCH_QP_STATE_ERROR:
                         qhp->attr.state = IWCH_QP_STATE_ERROR;
-                        flush_qp(qhp, &flag);
+                        flush_qp(qhp);
                         break;
                 default:
                         ret = -EINVAL;
@@ -1078,7 +1078,7 @@ int iwch_modify_qp(struct iwch_dev *rhp, struct iwch_qp *qhp,
                 }
                 switch (attrs->next_state) {
                         case IWCH_QP_STATE_IDLE:
-                                flush_qp(qhp, &flag);
+                                flush_qp(qhp);
                                 qhp->attr.state = IWCH_QP_STATE_IDLE;
                                 qhp->attr.llp_stream_handle = NULL;
                                 put_ep(&qhp->ep->com);
@@ -1132,7 +1132,7 @@ err:
         free=1;
         wake_up(&qhp->wait);
         BUG_ON(!ep);
-        flush_qp(qhp, &flag);
+        flush_qp(qhp);
 out:
         spin_unlock_irqrestore(&qhp->lock, flag);
 
diff --git a/drivers/infiniband/hw/cxgb4/cm.c b/drivers/infiniband/hw/cxgb4/cm.c
index 0cf61554f176..92b4c2b0308b 100644
--- a/drivers/infiniband/hw/cxgb4/cm.c
+++ b/drivers/infiniband/hw/cxgb4/cm.c
@@ -1114,7 +1114,7 @@ static void process_mpa_reply(struct c4iw_ep *ep, struct sk_buff *skb)
          * generated when moving QP to RTS state.
          * A TERM message will be sent after QP has moved to RTS state
          */
-        if ((ep->mpa_attr.version == 2) &&
+        if ((ep->mpa_attr.version == 2) && peer2peer &&
                         (ep->mpa_attr.p2p_type != p2p_type)) {
                 ep->mpa_attr.p2p_type = FW_RI_INIT_P2PTYPE_DISABLED;
                 rtr_mismatch = 1;
diff --git a/drivers/infiniband/hw/cxgb4/provider.c b/drivers/infiniband/hw/cxgb4/provider.c
index 247fe706e7fa..be1c18f44400 100644
--- a/drivers/infiniband/hw/cxgb4/provider.c
+++ b/drivers/infiniband/hw/cxgb4/provider.c
@@ -329,7 +329,7 @@ static int c4iw_query_port(struct ib_device *ibdev, u8 port,
         props->gid_tbl_len = 1;
         props->pkey_tbl_len = 1;
         props->active_width = 2;
-        props->active_speed = 2;
+        props->active_speed = IB_SPEED_DDR;
         props->max_msg_sz = -1;
 
         return 0;
diff --git a/drivers/infiniband/hw/ehca/ehca_hca.c b/drivers/infiniband/hw/ehca/ehca_hca.c
index 73edc3668663..9ed4d2588304 100644
--- a/drivers/infiniband/hw/ehca/ehca_hca.c
+++ b/drivers/infiniband/hw/ehca/ehca_hca.c
@@ -233,7 +233,7 @@ int ehca_query_port(struct ib_device *ibdev,
                 props->phys_state      = 5;
                 props->state           = rblock->state;
                 props->active_width    = IB_WIDTH_12X;
-                props->active_speed    = 0x1;
+                props->active_speed    = IB_SPEED_SDR;
         }
 
 query_port1:
diff --git a/drivers/infiniband/hw/ehca/ehca_irq.c b/drivers/infiniband/hw/ehca/ehca_irq.c
index e571e60ecb88..53589000fd07 100644
--- a/drivers/infiniband/hw/ehca/ehca_irq.c
+++ b/drivers/infiniband/hw/ehca/ehca_irq.c
@@ -786,7 +786,8 @@ static struct task_struct *create_comp_task(struct ehca_comp_pool *pool,
         spin_lock_init(&cct->task_lock);
         INIT_LIST_HEAD(&cct->cq_list);
         init_waitqueue_head(&cct->wait_queue);
-        cct->task = kthread_create(comp_task, cct, "ehca_comp/%d", cpu);
+        cct->task = kthread_create_on_node(comp_task, cct, cpu_to_node(cpu),
+                                           "ehca_comp/%d", cpu);
 
         return cct->task;
 }
diff --git a/drivers/infiniband/hw/ehca/ehca_mrmw.c b/drivers/infiniband/hw/ehca/ehca_mrmw.c
index 43cae84005f0..b781b2cb0624 100644
--- a/drivers/infiniband/hw/ehca/ehca_mrmw.c
+++ b/drivers/infiniband/hw/ehca/ehca_mrmw.c
@@ -112,7 +112,7 @@ static u32 ehca_encode_hwpage_size(u32 pgsize)
 
 static u64 ehca_get_max_hwpage_size(struct ehca_shca *shca)
 {
-        return 1UL << ilog2(shca->hca_cap_mr_pgsize);
+        return rounddown_pow_of_two(shca->hca_cap_mr_pgsize);
 }
 
 static struct ehca_mr *ehca_mr_new(void)
diff --git a/drivers/infiniband/hw/mlx4/cq.c b/drivers/infiniband/hw/mlx4/cq.c
index 5ecf38d97269..77c8cb4c5073 100644
--- a/drivers/infiniband/hw/mlx4/cq.c
+++ b/drivers/infiniband/hw/mlx4/cq.c
@@ -720,7 +720,8 @@ repoll:
                 wc->dlid_path_bits = (g_mlpath_rqpn >> 24) & 0x7f;
                 wc->wc_flags      |= g_mlpath_rqpn & 0x80000000 ? IB_WC_GRH : 0;
                 wc->pkey_index     = be32_to_cpu(cqe->immed_rss_invalid) & 0x7f;
-                wc->csum_ok        = mlx4_ib_ipoib_csum_ok(cqe->status, cqe->checksum);
+                wc->wc_flags      |= mlx4_ib_ipoib_csum_ok(cqe->status,
+                                        cqe->checksum) ? IB_WC_IP_CSUM_OK : 0;
                 if (rdma_port_get_link_layer(wc->qp->device,
                                 (*cur_qp)->port) == IB_LINK_LAYER_ETHERNET)
                         wc->sl  = be16_to_cpu(cqe->sl_vid) >> 13;
@@ -747,8 +748,7 @@ int mlx4_ib_poll_cq(struct ib_cq *ibcq, int num_entries, struct ib_wc *wc)
                         break;
         }
 
-        if (npolled)
-                mlx4_cq_set_ci(&cq->mcq);
+        mlx4_cq_set_ci(&cq->mcq);
 
         spin_unlock_irqrestore(&cq->lock, flags);
 
diff --git a/drivers/infiniband/hw/mlx4/main.c b/drivers/infiniband/hw/mlx4/main.c
index 7b445df6a667..75d305629300 100644
--- a/drivers/infiniband/hw/mlx4/main.c
+++ b/drivers/infiniband/hw/mlx4/main.c
@@ -163,7 +163,7 @@ static int mlx4_ib_query_device(struct ib_device *ibdev,
         props->max_mcast_qp_attach = dev->dev->caps.num_qp_per_mgm;
         props->max_total_mcast_qp_attach = props->max_mcast_qp_attach *
                                            props->max_mcast_grp;
-        props->max_map_per_fmr = (1 << (32 - ilog2(dev->dev->caps.num_mpts))) - 1;
+        props->max_map_per_fmr = dev->dev->caps.max_fmr_maps;
 
 out:
         kfree(in_mad);
@@ -182,12 +182,27 @@ mlx4_ib_port_link_layer(struct ib_device *device, u8 port_num)
 }
 
 static int ib_link_query_port(struct ib_device *ibdev, u8 port,
-                              struct ib_port_attr *props,
-                              struct ib_smp *in_mad,
-                              struct ib_smp *out_mad)
+                              struct ib_port_attr *props)
 {
+        struct ib_smp *in_mad  = NULL;
+        struct ib_smp *out_mad = NULL;
         int ext_active_speed;
-        int err;
+        int err = -ENOMEM;
+
+        in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
+        out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
+        if (!in_mad || !out_mad)
+                goto out;
+
+        init_query_mad(in_mad);
+        in_mad->attr_id  = IB_SMP_ATTR_PORT_INFO;
+        in_mad->attr_mod = cpu_to_be32(port);
+
+        err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL,
+                                in_mad, out_mad);
+        if (err)
+                goto out;
+
 
         props->lid              = be16_to_cpup((__be16 *) (out_mad->data + 16));
         props->lmc              = out_mad->data[34] & 0x7;
@@ -215,34 +230,33 @@ static int ib_link_query_port(struct ib_device *ibdev, u8 port,
 
                 switch (ext_active_speed) {
                 case 1:
-                        props->active_speed = 16; /* FDR */
+                        props->active_speed = IB_SPEED_FDR;
                         break;
                 case 2:
-                        props->active_speed = 32; /* EDR */
+                        props->active_speed = IB_SPEED_EDR;
                         break;
                 }
         }
 
         /* If reported active speed is QDR, check if is FDR-10 */
-        if (props->active_speed == 4) {
-                if (to_mdev(ibdev)->dev->caps.ext_port_cap[port] &
-                    MLX_EXT_PORT_CAP_FLAG_EXTENDED_PORT_INFO) {
-                        init_query_mad(in_mad);
-                        in_mad->attr_id = MLX4_ATTR_EXTENDED_PORT_INFO;
-                        in_mad->attr_mod = cpu_to_be32(port);
-
-                        err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port,
-                                           NULL, NULL, in_mad, out_mad);
-                        if (err)
-                                return err;
+        if (props->active_speed == IB_SPEED_QDR) {
+                init_query_mad(in_mad);
+                in_mad->attr_id = MLX4_ATTR_EXTENDED_PORT_INFO;
+                in_mad->attr_mod = cpu_to_be32(port);
 
-                        /* Checking LinkSpeedActive for FDR-10 */
-                        if (out_mad->data[15] & 0x1)
-                                props->active_speed = 8;
-                }
-        }
+                err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port,
+                                   NULL, NULL, in_mad, out_mad);
+                if (err)
+                        return err;
 
-        return 0;
+                /* Checking LinkSpeedActive for FDR-10 */
+                if (out_mad->data[15] & 0x1)
+                        props->active_speed = IB_SPEED_FDR10;
+        }
+out:
+        kfree(in_mad);
+        kfree(out_mad);
+        return err;
 }
 
 static u8 state_to_phys_state(enum ib_port_state state)
@@ -251,32 +265,42 @@ static u8 state_to_phys_state(enum ib_port_state state)
 }
 
 static int eth_link_query_port(struct ib_device *ibdev, u8 port,
-                               struct ib_port_attr *props,
-                               struct ib_smp *out_mad)
+                               struct ib_port_attr *props)
 {
-        struct mlx4_ib_iboe *iboe = &to_mdev(ibdev)->iboe;
+
+        struct mlx4_ib_dev *mdev = to_mdev(ibdev);
+        struct mlx4_ib_iboe *iboe = &mdev->iboe;
         struct net_device *ndev;
         enum ib_mtu tmp;
+        struct mlx4_cmd_mailbox *mailbox;
+        int err = 0;
+
+        mailbox = mlx4_alloc_cmd_mailbox(mdev->dev);
+        if (IS_ERR(mailbox))
+                return PTR_ERR(mailbox);
+
+        err = mlx4_cmd_box(mdev->dev, 0, mailbox->dma, port, 0,
+                           MLX4_CMD_QUERY_PORT, MLX4_CMD_TIME_CLASS_B,
+                           MLX4_CMD_WRAPPED);
+        if (err)
+                goto out;
 
-        props->active_width     = IB_WIDTH_1X;
-        props->active_speed     = 4;
+        props->active_width     =  (((u8 *)mailbox->buf)[5] == 0x40) ?
+                                                IB_WIDTH_4X : IB_WIDTH_1X;
+        props->active_speed     = IB_SPEED_QDR;
         props->port_cap_flags   = IB_PORT_CM_SUP;
-        props->gid_tbl_len      = to_mdev(ibdev)->dev->caps.gid_table_len[port];
-        props->max_msg_sz       = to_mdev(ibdev)->dev->caps.max_msg_sz;
+        props->gid_tbl_len      = mdev->dev->caps.gid_table_len[port];
+        props->max_msg_sz       = mdev->dev->caps.max_msg_sz;
         props->pkey_tbl_len     = 1;
-        props->bad_pkey_cntr    = be16_to_cpup((__be16 *) (out_mad->data + 46));
-        props->qkey_viol_cntr   = be16_to_cpup((__be16 *) (out_mad->data + 48));
         props->max_mtu          = IB_MTU_4096;
-        props->subnet_timeout   = 0;
-        props->max_vl_num       = out_mad->data[37] >> 4;
-        props->init_type_reply  = 0;
+        props->max_vl_num       = 2;
         props->state            = IB_PORT_DOWN;
         props->phys_state       = state_to_phys_state(props->state);
         props->active_mtu       = IB_MTU_256;
         spin_lock(&iboe->lock);
         ndev = iboe->netdevs[port - 1];
         if (!ndev)
-                goto out;
+                goto out_unlock;
 
         tmp = iboe_get_mtu(ndev->mtu);
         props->active_mtu = tmp ? min(props->max_mtu, tmp) : IB_MTU_256;
@@ -284,41 +308,23 @@ static int eth_link_query_port(struct ib_device *ibdev, u8 port,
         props->state            = (netif_running(ndev) && netif_carrier_ok(ndev)) ?
                                         IB_PORT_ACTIVE : IB_PORT_DOWN;
         props->phys_state       = state_to_phys_state(props->state);
-
-out:
+out_unlock:
         spin_unlock(&iboe->lock);
-        return 0;
+out:
+        mlx4_free_cmd_mailbox(mdev->dev, mailbox);
+        return err;
 }
 
 static int mlx4_ib_query_port(struct ib_device *ibdev, u8 port,
                               struct ib_port_attr *props)
 {
-        struct ib_smp *in_mad  = NULL;
-        struct ib_smp *out_mad = NULL;
-        int err = -ENOMEM;
-
-        in_mad  = kzalloc(sizeof *in_mad, GFP_KERNEL);
-        out_mad = kmalloc(sizeof *out_mad, GFP_KERNEL);
-        if (!in_mad || !out_mad)
-                goto out;
+        int err;
 
         memset(props, 0, sizeof *props);
 
-        init_query_mad(in_mad);
-        in_mad->attr_id  = IB_SMP_ATTR_PORT_INFO;
-        in_mad->attr_mod = cpu_to_be32(port);
-
-        err = mlx4_MAD_IFC(to_mdev(ibdev), 1, 1, port, NULL, NULL, in_mad, out_mad);
-        if (err)
-                goto out;
-
         err = mlx4_ib_port_link_layer(ibdev, port) == IB_LINK_LAYER_INFINIBAND ?
-                ib_link_query_port(ibdev, port, props, in_mad, out_mad) :
-                eth_link_query_port(ibdev, port, props, out_mad);
-
-out:
-        kfree(in_mad);
-        kfree(out_mad);
+                ib_link_query_port(ibdev, port, props) :
+                                eth_link_query_port(ibdev, port, props);
 
         return err;
 }
diff --git a/drivers/infiniband/hw/mlx4/qp.c b/drivers/infiniband/hw/mlx4/qp.c
index aa2aefa4236c..3a7848966627 100644
--- a/drivers/infiniband/hw/mlx4/qp.c
+++ b/drivers/infiniband/hw/mlx4/qp.c
@@ -1884,6 +1884,7 @@ int mlx4_ib_post_send(struct ib_qp *ibqp, struct ib_send_wr *wr,
                 wmb();
 
                 if (wr->opcode < 0 || wr->opcode >= ARRAY_SIZE(mlx4_ib_opcode)) {
+                        *bad_wr = wr;
                         err = -EINVAL;
                         goto out;
                 }
diff --git a/drivers/infiniband/hw/mthca/mthca_cq.c b/drivers/infiniband/hw/mthca/mthca_cq.c
index 53157b86a1ba..40ba83338155 100644
--- a/drivers/infiniband/hw/mthca/mthca_cq.c
+++ b/drivers/infiniband/hw/mthca/mthca_cq.c
@@ -643,7 +643,8 @@ static inline int mthca_poll_one(struct mthca_dev *dev,
                 entry->wc_flags   |= cqe->g_mlpath & 0x80 ? IB_WC_GRH : 0;
                 checksum = (be32_to_cpu(cqe->rqpn) >> 24) |
                                 ((be32_to_cpu(cqe->my_ee) >> 16) & 0xff00);
-                entry->csum_ok = (cqe->sl_ipok & 1 && checksum == 0xffff);
+                entry->wc_flags   |=  (cqe->sl_ipok & 1 && checksum == 0xffff) ?
+                                                        IB_WC_IP_CSUM_OK : 0;
         }
 
         entry->status = IB_WC_SUCCESS;
diff --git a/drivers/infiniband/hw/nes/nes_cm.c b/drivers/infiniband/hw/nes/nes_cm.c
index c5e4cb2d3223..71edfbbcce1c 100644
--- a/drivers/infiniband/hw/nes/nes_cm.c
+++ b/drivers/infiniband/hw/nes/nes_cm.c
@@ -338,18 +338,21 @@ static int parse_mpa(struct nes_cm_node *cm_node, u8 *buffer, u32 *type,
         case IETF_MPA_V2: {
                 u16 ird_size;
                 u16 ord_size;
+                u16 rtr_ctrl_ird;
+                u16 rtr_ctrl_ord;
+
                 mpa_v2_frame = (struct ietf_mpa_v2 *)buffer;
                 mpa_hdr_len += IETF_RTR_MSG_SIZE;
                 cm_node->mpa_frame_size -= IETF_RTR_MSG_SIZE;
                 rtr_msg = &mpa_v2_frame->rtr_msg;
 
                 /* parse rtr message */
-                rtr_msg->ctrl_ird = ntohs(rtr_msg->ctrl_ird);
-                rtr_msg->ctrl_ord = ntohs(rtr_msg->ctrl_ord);
-                ird_size = rtr_msg->ctrl_ird & IETF_NO_IRD_ORD;
-                ord_size = rtr_msg->ctrl_ord & IETF_NO_IRD_ORD;
+                rtr_ctrl_ird = ntohs(rtr_msg->ctrl_ird);
+                rtr_ctrl_ord = ntohs(rtr_msg->ctrl_ord);
+                ird_size = rtr_ctrl_ird & IETF_NO_IRD_ORD;
+                ord_size = rtr_ctrl_ord & IETF_NO_IRD_ORD;
 
-                if (!(rtr_msg->ctrl_ird & IETF_PEER_TO_PEER)) {
+                if (!(rtr_ctrl_ird & IETF_PEER_TO_PEER)) {
                         /* send reset */
                         return -EINVAL;
                 }
@@ -370,9 +373,9 @@ static int parse_mpa(struct nes_cm_node *cm_node, u8 *buffer, u32 *type,
                         }
                 }
 
-                if (rtr_msg->ctrl_ord & IETF_RDMA0_READ) {
+                if (rtr_ctrl_ord & IETF_RDMA0_READ) {
                         cm_node->send_rdma0_op = SEND_RDMA_READ_ZERO;
-                } else if (rtr_msg->ctrl_ord & IETF_RDMA0_WRITE) {
+                } else if (rtr_ctrl_ord & IETF_RDMA0_WRITE) {
                         cm_node->send_rdma0_op = SEND_RDMA_WRITE_ZERO;
                 } else {        /* Not supported RDMA0 operation */
                         return -EINVAL;
@@ -543,6 +546,8 @@ static void build_mpa_v2(struct nes_cm_node *cm_node,
 {
         struct ietf_mpa_v2 *mpa_frame = (struct ietf_mpa_v2 *)start_addr;
         struct ietf_rtr_msg *rtr_msg = &mpa_frame->rtr_msg;
+        u16 ctrl_ird;
+        u16 ctrl_ord;
 
         /* initialize the upper 5 bytes of the frame */
         build_mpa_v1(cm_node, start_addr, mpa_key);
@@ -550,31 +555,31 @@ static void build_mpa_v2(struct nes_cm_node *cm_node,
         mpa_frame->priv_data_len += htons(IETF_RTR_MSG_SIZE);
 
         /* initialize RTR msg */
-        rtr_msg->ctrl_ird = (cm_node->ird_size > IETF_NO_IRD_ORD) ?
+        ctrl_ird = (cm_node->ird_size > IETF_NO_IRD_ORD) ?
                             IETF_NO_IRD_ORD : cm_node->ird_size;
-        rtr_msg->ctrl_ord = (cm_node->ord_size > IETF_NO_IRD_ORD) ?
+        ctrl_ord = (cm_node->ord_size > IETF_NO_IRD_ORD) ?
                             IETF_NO_IRD_ORD : cm_node->ord_size;
 
-        rtr_msg->ctrl_ird |= IETF_PEER_TO_PEER;
-        rtr_msg->ctrl_ird |= IETF_FLPDU_ZERO_LEN;
+        ctrl_ird |= IETF_PEER_TO_PEER;
+        ctrl_ird |= IETF_FLPDU_ZERO_LEN;
 
         switch (mpa_key) {
         case MPA_KEY_REQUEST:
-                rtr_msg->ctrl_ord |= IETF_RDMA0_WRITE;
-                rtr_msg->ctrl_ord |= IETF_RDMA0_READ;
+                ctrl_ord |= IETF_RDMA0_WRITE;
+                ctrl_ord |= IETF_RDMA0_READ;
                 break;
         case MPA_KEY_REPLY:
                 switch (cm_node->send_rdma0_op) {
                 case SEND_RDMA_WRITE_ZERO:
-                        rtr_msg->ctrl_ord |= IETF_RDMA0_WRITE;
+                        ctrl_ord |= IETF_RDMA0_WRITE;
                         break;
                 case SEND_RDMA_READ_ZERO:
-                        rtr_msg->ctrl_ord |= IETF_RDMA0_READ;
+                        ctrl_ord |= IETF_RDMA0_READ;
                         break;
                 }
         }
-        rtr_msg->ctrl_ird = htons(rtr_msg->ctrl_ird);
-        rtr_msg->ctrl_ord = htons(rtr_msg->ctrl_ord);
+        rtr_msg->ctrl_ird = htons(ctrl_ird);
+        rtr_msg->ctrl_ord = htons(ctrl_ord);
 }
 
 /**
diff --git a/drivers/infiniband/hw/nes/nes_verbs.c b/drivers/infiniband/hw/nes/nes_verbs.c
index 0927b5cc65d3..8b8812de4b5c 100644
--- a/drivers/infiniband/hw/nes/nes_verbs.c
+++ b/drivers/infiniband/hw/nes/nes_verbs.c
@@ -597,7 +597,7 @@ static int nes_query_port(struct ib_device *ibdev, u8 port, struct ib_port_attr
         props->pkey_tbl_len = 1;
         props->qkey_viol_cntr = 0;
         props->active_width = IB_WIDTH_4X;
-        props->active_speed = 1;
+        props->active_speed = IB_SPEED_SDR;
         props->max_msg_sz = 0x80000000;
 
         return 0;
diff --git a/drivers/infiniband/hw/qib/qib.h b/drivers/infiniband/hw/qib/qib.h
index b881bdc401f5..6b811e3e8bd1 100644
--- a/drivers/infiniband/hw/qib/qib.h
+++ b/drivers/infiniband/hw/qib/qib.h
@@ -427,6 +427,14 @@ struct qib_verbs_txreq {
 /* how often we check for packet activity for "power on hours (in seconds) */
 #define ACTIVITY_TIMER 5
 
+#define MAX_NAME_SIZE 64
+struct qib_msix_entry {
+        struct msix_entry msix;
+        void *arg;
+        char name[MAX_NAME_SIZE];
+        cpumask_var_t mask;
+};
+
 /* Below is an opaque struct. Each chip (device) can maintain
  * private data needed for its operation, but not germane to the
  * rest of the driver.  For convenience, we define another that
@@ -1355,7 +1363,7 @@ int qib_pcie_init(struct pci_dev *, const struct pci_device_id *);
 int qib_pcie_ddinit(struct qib_devdata *, struct pci_dev *,
                     const struct pci_device_id *);
 void qib_pcie_ddcleanup(struct qib_devdata *);
-int qib_pcie_params(struct qib_devdata *, u32, u32 *, struct msix_entry *);
+int qib_pcie_params(struct qib_devdata *, u32, u32 *, struct qib_msix_entry *);
 int qib_reinit_intr(struct qib_devdata *);
 void qib_enable_intx(struct pci_dev *);
 void qib_nomsi(struct qib_devdata *);
diff --git a/drivers/infiniband/hw/qib/qib_iba7322.c b/drivers/infiniband/hw/qib/qib_iba7322.c
index 41e92089e41b..060b96064469 100644
--- a/drivers/infiniband/hw/qib/qib_iba7322.c
+++ b/drivers/infiniband/hw/qib/qib_iba7322.c
@@ -541,8 +541,7 @@ struct qib_chip_specific {
         u32 lastbuf_for_pio;
         u32 stay_in_freeze;
         u32 recovery_ports_initted;
-        struct msix_entry *msix_entries;
-        void  **msix_arg;
+        struct qib_msix_entry *msix_entries;
         unsigned long *sendchkenable;
         unsigned long *sendgrhchk;
         unsigned long *sendibchk;
@@ -639,24 +638,24 @@ static struct {
         int lsb;
         int port; /* 0 if not port-specific, else port # */
 } irq_table[] = {
-        { QIB_DRV_NAME, qib_7322intr, -1, 0 },
-        { QIB_DRV_NAME " (buf avail)", qib_7322bufavail,
+        { "", qib_7322intr, -1, 0 },
+        { " (buf avail)", qib_7322bufavail,
                 SYM_LSB(IntStatus, SendBufAvail), 0 },
-        { QIB_DRV_NAME " (sdma 0)", sdma_intr,
+        { " (sdma 0)", sdma_intr,
                 SYM_LSB(IntStatus, SDmaInt_0), 1 },
-        { QIB_DRV_NAME " (sdma 1)", sdma_intr,
+        { " (sdma 1)", sdma_intr,
                 SYM_LSB(IntStatus, SDmaInt_1), 2 },
-        { QIB_DRV_NAME " (sdmaI 0)", sdma_idle_intr,
+        { " (sdmaI 0)", sdma_idle_intr,
                 SYM_LSB(IntStatus, SDmaIdleInt_0), 1 },
-        { QIB_DRV_NAME " (sdmaI 1)", sdma_idle_intr,
+        { " (sdmaI 1)", sdma_idle_intr,
                 SYM_LSB(IntStatus, SDmaIdleInt_1), 2 },
-        { QIB_DRV_NAME " (sdmaP 0)", sdma_progress_intr,
+        { " (sdmaP 0)", sdma_progress_intr,
                 SYM_LSB(IntStatus, SDmaProgressInt_0), 1 },
-        { QIB_DRV_NAME " (sdmaP 1)", sdma_progress_intr,
+        { " (sdmaP 1)", sdma_progress_intr,
                 SYM_LSB(IntStatus, SDmaProgressInt_1), 2 },
-        { QIB_DRV_NAME " (sdmaC 0)", sdma_cleanup_intr,
+        { " (sdmaC 0)", sdma_cleanup_intr,
                 SYM_LSB(IntStatus, SDmaCleanupDone_0), 1 },
-        { QIB_DRV_NAME " (sdmaC 1)", sdma_cleanup_intr,
+        { " (sdmaC 1)", sdma_cleanup_intr,
                 SYM_LSB(IntStatus, SDmaCleanupDone_1), 2 },
 };
 
@@ -2567,9 +2566,13 @@ static void qib_7322_nomsix(struct qib_devdata *dd)
                 int i;
 
                 dd->cspec->num_msix_entries = 0;
-                for (i = 0; i < n; i++)
-                        free_irq(dd->cspec->msix_entries[i].vector,
-                                 dd->cspec->msix_arg[i]);
+                for (i = 0; i < n; i++) {
+                        irq_set_affinity_hint(
+                          dd->cspec->msix_entries[i].msix.vector, NULL);
+                        free_cpumask_var(dd->cspec->msix_entries[i].mask);
+                        free_irq(dd->cspec->msix_entries[i].msix.vector,
+                           dd->cspec->msix_entries[i].arg);
+                }
                 qib_nomsix(dd);
         }
         /* make sure no MSIx interrupts are left pending */
@@ -2597,7 +2600,6 @@ static void qib_setup_7322_cleanup(struct qib_devdata *dd)
         kfree(dd->cspec->sendgrhchk);
         kfree(dd->cspec->sendibchk);
         kfree(dd->cspec->msix_entries);
-        kfree(dd->cspec->msix_arg);
         for (i = 0; i < dd->num_pports; i++) {
                 unsigned long flags;
                 u32 mask = QSFP_GPIO_MOD_PRS_N |
@@ -3070,6 +3072,8 @@ static void qib_setup_7322_interrupt(struct qib_devdata *dd, int clearpend)
         int ret, i, msixnum;
         u64 redirect[6];
         u64 mask;
+        const struct cpumask *local_mask;
+        int firstcpu, secondcpu = 0, currrcvcpu = 0;
 
         if (!dd->num_pports)
                 return;
@@ -3118,13 +3122,28 @@ try_intx:
         memset(redirect, 0, sizeof redirect);
         mask = ~0ULL;
         msixnum = 0;
+        local_mask = cpumask_of_pcibus(dd->pcidev->bus);
+        firstcpu = cpumask_first(local_mask);
+        if (firstcpu >= nr_cpu_ids ||
+                        cpumask_weight(local_mask) == num_online_cpus()) {
+                local_mask = topology_core_cpumask(0);
+                firstcpu = cpumask_first(local_mask);
+        }
+        if (firstcpu < nr_cpu_ids) {
+                secondcpu = cpumask_next(firstcpu, local_mask);
+                if (secondcpu >= nr_cpu_ids)
+                        secondcpu = firstcpu;
+                currrcvcpu = secondcpu;
+        }
         for (i = 0; msixnum < dd->cspec->num_msix_entries; i++) {
                 irq_handler_t handler;
-                const char *name;
                 void *arg;
                 u64 val;
                 int lsb, reg, sh;
 
+                dd->cspec->msix_entries[msixnum].
+                        name[sizeof(dd->cspec->msix_entries[msixnum].name) - 1]
+                        = '\0';
                 if (i < ARRAY_SIZE(irq_table)) {
                         if (irq_table[i].port) {
                                 /* skip if for a non-configured port */
@@ -3135,7 +3154,11 @@ try_intx:
                                 arg = dd;
                         lsb = irq_table[i].lsb;
                         handler = irq_table[i].handler;
-                        name = irq_table[i].name;
+                        snprintf(dd->cspec->msix_entries[msixnum].name,
+                                sizeof(dd->cspec->msix_entries[msixnum].name)
+                                 - 1,
+                                QIB_DRV_NAME "%d%s", dd->unit,
+                                irq_table[i].name);
                 } else {
                         unsigned ctxt;
 
@@ -3148,23 +3171,28 @@ try_intx:
                                 continue;
                         lsb = QIB_I_RCVAVAIL_LSB + ctxt;
                         handler = qib_7322pintr;
-                        name = QIB_DRV_NAME " (kctx)";
+                        snprintf(dd->cspec->msix_entries[msixnum].name,
+                                sizeof(dd->cspec->msix_entries[msixnum].name)
+                                 - 1,
+                                QIB_DRV_NAME "%d (kctx)", dd->unit);
                 }
-                ret = request_irq(dd->cspec->msix_entries[msixnum].vector,
-                                  handler, 0, name, arg);
+                ret = request_irq(
+                        dd->cspec->msix_entries[msixnum].msix.vector,
+                        handler, 0, dd->cspec->msix_entries[msixnum].name,
+                        arg);
                 if (ret) {
                         /*
                          * Shouldn't happen since the enable said we could
                          * have as many as we are trying to setup here.
                          */
                         qib_dev_err(dd, "Couldn't setup MSIx "
-                                    "interrupt (vec=%d, irq=%d): %d\n", msixnum,
-                                    dd->cspec->msix_entries[msixnum].vector,
-                                    ret);
+                                "interrupt (vec=%d, irq=%d): %d\n", msixnum,
+                                dd->cspec->msix_entries[msixnum].msix.vector,
+                                ret);
                         qib_7322_nomsix(dd);
                         goto try_intx;
                 }
-                dd->cspec->msix_arg[msixnum] = arg;
+                dd->cspec->msix_entries[msixnum].arg = arg;
                 if (lsb >= 0) {
                         reg = lsb / IBA7322_REDIRECT_VEC_PER_REG;
                         sh = (lsb % IBA7322_REDIRECT_VEC_PER_REG) *
@@ -3174,6 +3202,25 @@ try_intx:
                 }
                 val = qib_read_kreg64(dd, 2 * msixnum + 1 +
                         (QIB_7322_MsixTable_OFFS / sizeof(u64)));
+                if (firstcpu < nr_cpu_ids &&
+                        zalloc_cpumask_var(
+                                &dd->cspec->msix_entries[msixnum].mask,
+                                GFP_KERNEL)) {
+                        if (handler == qib_7322pintr) {
+                                cpumask_set_cpu(currrcvcpu,
+                                        dd->cspec->msix_entries[msixnum].mask);
+                                currrcvcpu = cpumask_next(currrcvcpu,
+                                        local_mask);
+                                if (currrcvcpu >= nr_cpu_ids)
+                                        currrcvcpu = secondcpu;
+                        } else {
+                                cpumask_set_cpu(firstcpu,
+                                        dd->cspec->msix_entries[msixnum].mask);
+                        }
+                        irq_set_affinity_hint(
+                                dd->cspec->msix_entries[msixnum].msix.vector,
+                                dd->cspec->msix_entries[msixnum].mask);
+                }
                 msixnum++;
         }
         /* Initialize the vector mapping */
@@ -3365,7 +3412,7 @@ static int qib_do_7322_reset(struct qib_devdata *dd)
         if (msix_entries) {
                 /* restore the MSIx vector address and data if saved above */
                 for (i = 0; i < msix_entries; i++) {
-                        dd->cspec->msix_entries[i].entry = i;
+                        dd->cspec->msix_entries[i].msix.entry = i;
                         if (!msix_vecsave || !msix_vecsave[2 * i])
                                 continue;
                         qib_write_kreg(dd, 2 * i +
@@ -6865,15 +6912,13 @@ struct qib_devdata *qib_init_iba7322_funcs(struct pci_dev *pdev,
 
         tabsize = actual_cnt;
         dd->cspec->msix_entries = kmalloc(tabsize *
-                        sizeof(struct msix_entry), GFP_KERNEL);
-        dd->cspec->msix_arg = kmalloc(tabsize *
-                        sizeof(void *), GFP_KERNEL);
-        if (!dd->cspec->msix_entries || !dd->cspec->msix_arg) {
+                        sizeof(struct qib_msix_entry), GFP_KERNEL);
+        if (!dd->cspec->msix_entries) {
                 qib_dev_err(dd, "No memory for MSIx table\n");
                 tabsize = 0;
         }
         for (i = 0; i < tabsize; i++)
-                dd->cspec->msix_entries[i].entry = i;
+                dd->cspec->msix_entries[i].msix.entry = i;
 
         if (qib_pcie_params(dd, 8, &tabsize, dd->cspec->msix_entries))
                 qib_dev_err(dd, "Failed to setup PCIe or interrupts; "
diff --git a/drivers/infiniband/hw/qib/qib_mad.c b/drivers/infiniband/hw/qib/qib_mad.c
index 3b3745f261f0..c4ff788823b5 100644
--- a/drivers/infiniband/hw/qib/qib_mad.c
+++ b/drivers/infiniband/hw/qib/qib_mad.c
@@ -433,7 +433,6 @@ static int subn_get_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
         struct qib_pportdata *ppd;
         struct qib_ibport *ibp;
         struct ib_port_info *pip = (struct ib_port_info *)smp->data;
-        u16 lid;
         u8 mtu;
         int ret;
         u32 state;
@@ -469,8 +468,7 @@ static int subn_get_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
               ibp->mkeyprot == 1))
                 pip->mkey = ibp->mkey;
         pip->gid_prefix = ibp->gid_prefix;
-        lid = ppd->lid;
-        pip->lid = lid ? cpu_to_be16(lid) : IB_LID_PERMISSIVE;
+        pip->lid = cpu_to_be16(ppd->lid);
         pip->sm_lid = cpu_to_be16(ibp->sm_lid);
         pip->cap_mask = cpu_to_be32(ibp->port_cap_flags);
         /* pip->diag_code; */
diff --git a/drivers/infiniband/hw/qib/qib_pcie.c b/drivers/infiniband/hw/qib/qib_pcie.c
index 0fde788e1100..790646ef5106 100644
--- a/drivers/infiniband/hw/qib/qib_pcie.c
+++ b/drivers/infiniband/hw/qib/qib_pcie.c
@@ -194,11 +194,24 @@ void qib_pcie_ddcleanup(struct qib_devdata *dd)
 }
 
 static void qib_msix_setup(struct qib_devdata *dd, int pos, u32 *msixcnt,
-                           struct msix_entry *msix_entry)
+                           struct qib_msix_entry *qib_msix_entry)
 {
         int ret;
         u32 tabsize = 0;
         u16 msix_flags;
+        struct msix_entry *msix_entry;
+        int i;
+
+        /* We can't pass qib_msix_entry array to qib_msix_setup
+         * so use a dummy msix_entry array and copy the allocated
+         * irq back to the qib_msix_entry array. */
+        msix_entry = kmalloc(*msixcnt * sizeof(*msix_entry), GFP_KERNEL);
+        if (!msix_entry) {
+                ret = -ENOMEM;
+                goto do_intx;
+        }
+        for (i = 0; i < *msixcnt; i++)
+                msix_entry[i] = qib_msix_entry[i].msix;
 
         pci_read_config_word(dd->pcidev, pos + PCI_MSIX_FLAGS, &msix_flags);
         tabsize = 1 + (msix_flags & PCI_MSIX_FLAGS_QSIZE);
@@ -209,11 +222,15 @@ static void qib_msix_setup(struct qib_devdata *dd, int pos, u32 *msixcnt,
                 tabsize = ret;
                 ret = pci_enable_msix(dd->pcidev, msix_entry, tabsize);
         }
+do_intx:
         if (ret) {
                 qib_dev_err(dd, "pci_enable_msix %d vectors failed: %d, "
                             "falling back to INTx\n", tabsize, ret);
                 tabsize = 0;
         }
+        for (i = 0; i < tabsize; i++)
+                qib_msix_entry[i].msix = msix_entry[i];
+        kfree(msix_entry);
         *msixcnt = tabsize;
 
         if (ret)
@@ -251,7 +268,7 @@ static int qib_msi_setup(struct qib_devdata *dd, int pos)
 }
 
 int qib_pcie_params(struct qib_devdata *dd, u32 minw, u32 *nent,
-                    struct msix_entry *entry)
+                    struct qib_msix_entry *entry)
 {
         u16 linkstat, speed;
         int pos = 0, pose, ret = 1;
diff --git a/drivers/infiniband/hw/qib/qib_rc.c b/drivers/infiniband/hw/qib/qib_rc.c
index 894afac26f3b..765b4cbaa020 100644
--- a/drivers/infiniband/hw/qib/qib_rc.c
+++ b/drivers/infiniband/hw/qib/qib_rc.c
@@ -2048,7 +2048,6 @@ send_last:
                 wc.pkey_index = 0;
                 wc.dlid_path_bits = 0;
                 wc.port_num = 0;
-                wc.csum_ok = 0;
                 /* Signal completion event if the solicited bit is set. */
                 qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc,
                              (ohdr->bth[0] &
diff --git a/drivers/infiniband/hw/qib/qib_uc.c b/drivers/infiniband/hw/qib/qib_uc.c
index 847e7afdfd94..7ce2ac2ed219 100644
--- a/drivers/infiniband/hw/qib/qib_uc.c
+++ b/drivers/infiniband/hw/qib/qib_uc.c
@@ -422,7 +422,6 @@ last_imm:
                 wc.pkey_index = 0;
                 wc.dlid_path_bits = 0;
                 wc.port_num = 0;
-                wc.csum_ok = 0;
                 /* Signal completion event if the solicited bit is set. */
                 qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc,
                              (ohdr->bth[0] &