Merge branch 'mpi-master' into wip-k-fmlpwip-k-fmlp

Conflicts:
	litmus/sched_cedf.c

27 files changed, 768 insertions, 261 deletions

diff --git a/drivers/infiniband/hw/qib/Kconfig b/drivers/infiniband/hw/qib/Kconfig
index 7c03a70c55a2..8349f9c5064c 100644
--- a/drivers/infiniband/hw/qib/Kconfig
+++ b/drivers/infiniband/hw/qib/Kconfig
@@ -1,6 +1,6 @@
 config INFINIBAND_QIB
         tristate "QLogic PCIe HCA support"
-        depends on 64BIT && NET
+        depends on 64BIT
         ---help---
         This is a low-level driver for QLogic PCIe QLE InfiniBand host
         channel adapters.  This driver does not support the QLogic
diff --git a/drivers/infiniband/hw/qib/qib.h b/drivers/infiniband/hw/qib/qib.h
index 61de0654820e..769a1d9da4b7 100644
--- a/drivers/infiniband/hw/qib/qib.h
+++ b/drivers/infiniband/hw/qib/qib.h
@@ -653,7 +653,7 @@ struct diag_observer_list_elt;
 
 /* device data struct now contains only "general per-device" info.
  * fields related to a physical IB port are in a qib_pportdata struct,
- * described above) while fields only used by a particualr chip-type are in
+ * described above) while fields only used by a particular chip-type are in
  * a qib_chipdata struct, whose contents are opaque to this file.
  */
 struct qib_devdata {
@@ -766,7 +766,7 @@ struct qib_devdata {
         void (*f_sdma_hw_start_up)(struct qib_pportdata *);
         void (*f_sdma_init_early)(struct qib_pportdata *);
         void (*f_set_cntr_sample)(struct qib_pportdata *, u32, u32);
-        void (*f_update_usrhead)(struct qib_ctxtdata *, u64, u32, u32);
+        void (*f_update_usrhead)(struct qib_ctxtdata *, u64, u32, u32, u32);
         u32 (*f_hdrqempty)(struct qib_ctxtdata *);
         u64 (*f_portcntr)(struct qib_pportdata *, u32);
         u32 (*f_read_cntrs)(struct qib_devdata *, loff_t, char **,
@@ -1406,7 +1406,7 @@ extern struct mutex qib_mutex;
  */
 #define qib_early_err(dev, fmt, ...) \
         do { \
-                dev_info(dev, KERN_ERR QIB_DRV_NAME ": " fmt, ##__VA_ARGS__); \
+                dev_err(dev, fmt, ##__VA_ARGS__); \
         } while (0)
 
 #define qib_dev_err(dd, fmt, ...) \
diff --git a/drivers/infiniband/hw/qib/qib_cq.c b/drivers/infiniband/hw/qib/qib_cq.c
index a86cbf880f98..5246aa486bbe 100644
--- a/drivers/infiniband/hw/qib/qib_cq.c
+++ b/drivers/infiniband/hw/qib/qib_cq.c
@@ -100,7 +100,8 @@ void qib_cq_enter(struct qib_cq *cq, struct ib_wc *entry, int solicited)
         wc->head = next;
 
         if (cq->notify == IB_CQ_NEXT_COMP ||
-            (cq->notify == IB_CQ_SOLICITED && solicited)) {
+            (cq->notify == IB_CQ_SOLICITED &&
+             (solicited || entry->status != IB_WC_SUCCESS))) {
                 cq->notify = IB_CQ_NONE;
                 cq->triggered++;
                 /*
diff --git a/drivers/infiniband/hw/qib/qib_diag.c b/drivers/infiniband/hw/qib/qib_diag.c
index 05dcf0d9a7d3..204c4dd9dce0 100644
--- a/drivers/infiniband/hw/qib/qib_diag.c
+++ b/drivers/infiniband/hw/qib/qib_diag.c
@@ -136,7 +136,8 @@ static const struct file_operations diag_file_ops = {
         .write = qib_diag_write,
         .read = qib_diag_read,
         .open = qib_diag_open,
-        .release = qib_diag_release
+        .release = qib_diag_release,
+        .llseek = default_llseek,
 };
 
 static atomic_t diagpkt_count = ATOMIC_INIT(0);
@@ -149,6 +150,7 @@ static ssize_t qib_diagpkt_write(struct file *fp, const char __user *data,
 static const struct file_operations diagpkt_file_ops = {
         .owner = THIS_MODULE,
         .write = qib_diagpkt_write,
+        .llseek = noop_llseek,
 };
 
 int qib_diag_add(struct qib_devdata *dd)
diff --git a/drivers/infiniband/hw/qib/qib_driver.c b/drivers/infiniband/hw/qib/qib_driver.c
index 9cd193603fb1..23e584f4c36c 100644
--- a/drivers/infiniband/hw/qib/qib_driver.c
+++ b/drivers/infiniband/hw/qib/qib_driver.c
@@ -71,6 +71,11 @@ MODULE_DESCRIPTION("QLogic IB driver");
  */
 #define QIB_PIO_MAXIBHDR 128
 
+/*
+ * QIB_MAX_PKT_RCV is the max # if packets processed per receive interrupt.
+ */
+#define QIB_MAX_PKT_RECV 64
+
 struct qlogic_ib_stats qib_stats;
 
 const char *qib_get_unit_name(int unit)
@@ -284,14 +289,147 @@ static inline void *qib_get_egrbuf(const struct qib_ctxtdata *rcd, u32 etail)
  * Returns 1 if error was a CRC, else 0.
  * Needed for some chip's synthesized error counters.
  */
-static u32 qib_rcv_hdrerr(struct qib_pportdata *ppd, u32 ctxt,
-                          u32 eflags, u32 l, u32 etail, __le32 *rhf_addr,
-                          struct qib_message_header *hdr)
+static u32 qib_rcv_hdrerr(struct qib_ctxtdata *rcd, struct qib_pportdata *ppd,
+                          u32 ctxt, u32 eflags, u32 l, u32 etail,
+                          __le32 *rhf_addr, struct qib_message_header *rhdr)
 {
         u32 ret = 0;
 
         if (eflags & (QLOGIC_IB_RHF_H_ICRCERR | QLOGIC_IB_RHF_H_VCRCERR))
                 ret = 1;
+        else if (eflags == QLOGIC_IB_RHF_H_TIDERR) {
+                /* For TIDERR and RC QPs premptively schedule a NAK */
+                struct qib_ib_header *hdr = (struct qib_ib_header *) rhdr;
+                struct qib_other_headers *ohdr = NULL;
+                struct qib_ibport *ibp = &ppd->ibport_data;
+                struct qib_qp *qp = NULL;
+                u32 tlen = qib_hdrget_length_in_bytes(rhf_addr);
+                u16 lid  = be16_to_cpu(hdr->lrh[1]);
+                int lnh = be16_to_cpu(hdr->lrh[0]) & 3;
+                u32 qp_num;
+                u32 opcode;
+                u32 psn;
+                int diff;
+                unsigned long flags;
+
+                /* Sanity check packet */
+                if (tlen < 24)
+                        goto drop;
+
+                if (lid < QIB_MULTICAST_LID_BASE) {
+                        lid &= ~((1 << ppd->lmc) - 1);
+                        if (unlikely(lid != ppd->lid))
+                                goto drop;
+                }
+
+                /* Check for GRH */
+                if (lnh == QIB_LRH_BTH)
+                        ohdr = &hdr->u.oth;
+                else if (lnh == QIB_LRH_GRH) {
+                        u32 vtf;
+
+                        ohdr = &hdr->u.l.oth;
+                        if (hdr->u.l.grh.next_hdr != IB_GRH_NEXT_HDR)
+                                goto drop;
+                        vtf = be32_to_cpu(hdr->u.l.grh.version_tclass_flow);
+                        if ((vtf >> IB_GRH_VERSION_SHIFT) != IB_GRH_VERSION)
+                                goto drop;
+                } else
+                        goto drop;
+
+                /* Get opcode and PSN from packet */
+                opcode = be32_to_cpu(ohdr->bth[0]);
+                opcode >>= 24;
+                psn = be32_to_cpu(ohdr->bth[2]);
+
+                /* Get the destination QP number. */
+                qp_num = be32_to_cpu(ohdr->bth[1]) & QIB_QPN_MASK;
+                if (qp_num != QIB_MULTICAST_QPN) {
+                        int ruc_res;
+                        qp = qib_lookup_qpn(ibp, qp_num);
+                        if (!qp)
+                                goto drop;
+
+                        /*
+                         * Handle only RC QPs - for other QP types drop error
+                         * packet.
+                         */
+                        spin_lock(&qp->r_lock);
+
+                        /* Check for valid receive state. */
+                        if (!(ib_qib_state_ops[qp->state] &
+                              QIB_PROCESS_RECV_OK)) {
+                                ibp->n_pkt_drops++;
+                                goto unlock;
+                        }
+
+                        switch (qp->ibqp.qp_type) {
+                        case IB_QPT_RC:
+                                spin_lock_irqsave(&qp->s_lock, flags);
+                                ruc_res =
+                                        qib_ruc_check_hdr(
+                                                ibp, hdr,
+                                                lnh == QIB_LRH_GRH,
+                                                qp,
+                                                be32_to_cpu(ohdr->bth[0]));
+                                if (ruc_res) {
+                                        spin_unlock_irqrestore(&qp->s_lock,
+                                                               flags);
+                                        goto unlock;
+                                }
+                                spin_unlock_irqrestore(&qp->s_lock, flags);
+
+                                /* Only deal with RDMA Writes for now */
+                                if (opcode <
+                                    IB_OPCODE_RC_RDMA_READ_RESPONSE_FIRST) {
+                                        diff = qib_cmp24(psn, qp->r_psn);
+                                        if (!qp->r_nak_state && diff >= 0) {
+                                                ibp->n_rc_seqnak++;
+                                                qp->r_nak_state =
+                                                        IB_NAK_PSN_ERROR;
+                                                /* Use the expected PSN. */
+                                                qp->r_ack_psn = qp->r_psn;
+                                                /*
+                                                 * Wait to send the sequence
+                                                 * NAK until all packets
+                                                 * in the receive queue have
+                                                 * been processed.
+                                                 * Otherwise, we end up
+                                                 * propagating congestion.
+                                                 */
+                                                if (list_empty(&qp->rspwait)) {
+                                                        qp->r_flags |=
+                                                                QIB_R_RSP_NAK;
+                                                        atomic_inc(
+                                                                &qp->refcount);
+                                                        list_add_tail(
+                                                         &qp->rspwait,
+                                                         &rcd->qp_wait_list);
+                                                }
+                                        } /* Out of sequence NAK */
+                                } /* QP Request NAKs */
+                                break;
+                        case IB_QPT_SMI:
+                        case IB_QPT_GSI:
+                        case IB_QPT_UD:
+                        case IB_QPT_UC:
+                        default:
+                                /* For now don't handle any other QP types */
+                                break;
+                        }
+
+unlock:
+                        spin_unlock(&qp->r_lock);
+                        /*
+                         * Notify qib_destroy_qp() if it is waiting
+                         * for us to finish.
+                         */
+                        if (atomic_dec_and_test(&qp->refcount))
+                                wake_up(&qp->wait);
+                } /* Unicast QP */
+        } /* Valid packet with TIDErr */
+
+drop:
         return ret;
 }
 
@@ -335,7 +473,7 @@ u32 qib_kreceive(struct qib_ctxtdata *rcd, u32 *llic, u32 *npkts)
                 smp_rmb();  /* prevent speculative reads of dma'ed hdrq */
         }
 
-        for (last = 0, i = 1; !last && i <= 64; i += !last) {
+        for (last = 0, i = 1; !last; i += !last) {
                 hdr = dd->f_get_msgheader(dd, rhf_addr);
                 eflags = qib_hdrget_err_flags(rhf_addr);
                 etype = qib_hdrget_rcv_type(rhf_addr);
@@ -371,7 +509,7 @@ u32 qib_kreceive(struct qib_ctxtdata *rcd, u32 *llic, u32 *npkts)
                  * packets; only qibhdrerr should be set.
                  */
                 if (unlikely(eflags))
-                        crcs += qib_rcv_hdrerr(ppd, rcd->ctxt, eflags, l,
+                        crcs += qib_rcv_hdrerr(rcd, ppd, rcd->ctxt, eflags, l,
                                                etail, rhf_addr, hdr);
                 else if (etype == RCVHQ_RCV_TYPE_NON_KD) {
                         qib_ib_rcv(rcd, hdr, ebuf, tlen);
@@ -384,6 +522,9 @@ move_along:
                 l += rsize;
                 if (l >= maxcnt)
                         l = 0;
+                if (i == QIB_MAX_PKT_RECV)
+                        last = 1;
+
                 rhf_addr = (__le32 *) rcd->rcvhdrq + l + dd->rhf_offset;
                 if (dd->flags & QIB_NODMA_RTAIL) {
                         u32 seq = qib_hdrget_seq(rhf_addr);
@@ -402,7 +543,7 @@ move_along:
                  */
                 lval = l;
                 if (!last && !(i & 0xf)) {
-                        dd->f_update_usrhead(rcd, lval, updegr, etail);
+                        dd->f_update_usrhead(rcd, lval, updegr, etail, i);
                         updegr = 0;
                 }
         }
@@ -444,7 +585,7 @@ bail:
          * if no packets were processed.
          */
         lval = (u64)rcd->head | dd->rhdrhead_intr_off;
-        dd->f_update_usrhead(rcd, lval, updegr, etail);
+        dd->f_update_usrhead(rcd, lval, updegr, etail, i);
         return crcs;
 }
 
diff --git a/drivers/infiniband/hw/qib/qib_file_ops.c b/drivers/infiniband/hw/qib/qib_file_ops.c
index 6b11645edf35..406fca50d036 100644
--- a/drivers/infiniband/hw/qib/qib_file_ops.c
+++ b/drivers/infiniband/hw/qib/qib_file_ops.c
@@ -63,7 +63,8 @@ static const struct file_operations qib_file_ops = {
         .open = qib_open,
         .release = qib_close,
         .poll = qib_poll,
-        .mmap = qib_mmapf
+        .mmap = qib_mmapf,
+        .llseek = noop_llseek,
 };
 
 /*
@@ -1378,17 +1379,17 @@ static int get_a_ctxt(struct file *fp, const struct qib_user_info *uinfo,
                 /* find device (with ACTIVE ports) with fewest ctxts in use */
                 for (ndev = 0; ndev < devmax; ndev++) {
                         struct qib_devdata *dd = qib_lookup(ndev);
-                        unsigned cused = 0, cfree = 0;
+                        unsigned cused = 0, cfree = 0, pusable = 0;
                         if (!dd)
                                 continue;
                         if (port && port <= dd->num_pports &&
                             usable(dd->pport + port - 1))
-                                dusable = 1;
+                                pusable = 1;
                         else
                                 for (i = 0; i < dd->num_pports; i++)
                                         if (usable(dd->pport + i))
-                                                dusable++;
-                        if (!dusable)
+                                                pusable++;
+                        if (!pusable)
                                 continue;
                         for (ctxt = dd->first_user_ctxt; ctxt < dd->cfgctxts;
                              ctxt++)
@@ -1396,7 +1397,7 @@ static int get_a_ctxt(struct file *fp, const struct qib_user_info *uinfo,
                                         cused++;
                                 else
                                         cfree++;
-                        if (cfree && cused < inuse) {
+                        if (pusable && cfree && cused < inuse) {
                                 udd = dd;
                                 inuse = cused;
                         }
@@ -1538,7 +1539,7 @@ done_chk_sdma:
 
                 /*
                  * If process has NOT already set it's affinity, select and
-                 * reserve a processor for it, as a rendevous for all
+                 * reserve a processor for it, as a rendezvous for all
                  * users of the driver.  If they don't actually later
                  * set affinity to this cpu, or set it to some other cpu,
                  * it just means that sooner or later we don't recommend
@@ -1656,7 +1657,7 @@ static int qib_do_user_init(struct file *fp,
          * 0 to 1.  So for those chips, we turn it off and then back on.
          * This will (very briefly) affect any other open ctxts, but the
          * duration is very short, and therefore isn't an issue.  We
-         * explictly set the in-memory tail copy to 0 beforehand, so we
+         * explicitly set the in-memory tail copy to 0 beforehand, so we
          * don't have to wait to be sure the DMA update has happened
          * (chip resets head/tail to 0 on transition to enable).
          */
@@ -1722,7 +1723,7 @@ static int qib_close(struct inode *in, struct file *fp)
 
         mutex_lock(&qib_mutex);
 
-        fd = (struct qib_filedata *) fp->private_data;
+        fd = fp->private_data;
         fp->private_data = NULL;
         rcd = fd->rcd;
         if (!rcd) {
@@ -1808,7 +1809,7 @@ static int qib_ctxt_info(struct file *fp, struct qib_ctxt_info __user *uinfo)
         struct qib_ctxtdata *rcd = ctxt_fp(fp);
         struct qib_filedata *fd;
 
-        fd = (struct qib_filedata *) fp->private_data;
+        fd = fp->private_data;
 
         info.num_active = qib_count_active_units();
         info.unit = rcd->dd->unit;
diff --git a/drivers/infiniband/hw/qib/qib_fs.c b/drivers/infiniband/hw/qib/qib_fs.c
index 9f989c0ba9d3..df7fa251dcdc 100644
--- a/drivers/infiniband/hw/qib/qib_fs.c
+++ b/drivers/infiniband/hw/qib/qib_fs.c
@@ -58,6 +58,7 @@ static int qibfs_mknod(struct inode *dir, struct dentry *dentry,
                 goto bail;
         }
 
+        inode->i_ino = get_next_ino();
         inode->i_mode = mode;
         inode->i_uid = 0;
         inode->i_gid = 0;
@@ -367,6 +368,7 @@ bail:
 static const struct file_operations flash_ops = {
         .read = flash_read,
         .write = flash_write,
+        .llseek = default_llseek,
 };
 
 static int add_cntr_files(struct super_block *sb, struct qib_devdata *dd)
@@ -451,17 +453,14 @@ static int remove_file(struct dentry *parent, char *name)
                 goto bail;
         }
 
-        spin_lock(&dcache_lock);
         spin_lock(&tmp->d_lock);
         if (!(d_unhashed(tmp) && tmp->d_inode)) {
-                dget_locked(tmp);
+                dget_dlock(tmp);
                 __d_drop(tmp);
                 spin_unlock(&tmp->d_lock);
-                spin_unlock(&dcache_lock);
                 simple_unlink(parent->d_inode, tmp);
         } else {
                 spin_unlock(&tmp->d_lock);
-                spin_unlock(&dcache_lock);
         }
 
         ret = 0;
@@ -553,13 +552,13 @@ bail:
         return ret;
 }
 
-static int qibfs_get_sb(struct file_system_type *fs_type, int flags,
-                        const char *dev_name, void *data, struct vfsmount *mnt)
+static struct dentry *qibfs_mount(struct file_system_type *fs_type, int flags,
+                        const char *dev_name, void *data)
 {
-        int ret = get_sb_single(fs_type, flags, data,
-                                qibfs_fill_super, mnt);
-        if (ret >= 0)
-                qib_super = mnt->mnt_sb;
+        struct dentry *ret;
+        ret = mount_single(fs_type, flags, data, qibfs_fill_super);
+        if (!IS_ERR(ret))
+                qib_super = ret->d_sb;
         return ret;
 }
 
@@ -601,7 +600,7 @@ int qibfs_remove(struct qib_devdata *dd)
 static struct file_system_type qibfs_fs_type = {
         .owner =        THIS_MODULE,
         .name =         "ipathfs",
-        .get_sb =       qibfs_get_sb,
+        .mount =        qibfs_mount,
         .kill_sb =      qibfs_kill_super,
 };
 
diff --git a/drivers/infiniband/hw/qib/qib_iba6120.c b/drivers/infiniband/hw/qib/qib_iba6120.c
index a5e29dbb9537..d8ca0a0b970d 100644
--- a/drivers/infiniband/hw/qib/qib_iba6120.c
+++ b/drivers/infiniband/hw/qib/qib_iba6120.c
@@ -1799,7 +1799,7 @@ static int qib_6120_setup_reset(struct qib_devdata *dd)
         /*
          * Keep chip from being accessed until we are ready.  Use
          * writeq() directly, to allow the write even though QIB_PRESENT
-         * isnt' set.
+         * isn't set.
          */
         dd->flags &= ~(QIB_INITTED | QIB_PRESENT);
         dd->int_counter = 0; /* so we check interrupts work again */
@@ -2074,7 +2074,7 @@ static void qib_6120_config_ctxts(struct qib_devdata *dd)
 }
 
 static void qib_update_6120_usrhead(struct qib_ctxtdata *rcd, u64 hd,
-                                    u32 updegr, u32 egrhd)
+                                    u32 updegr, u32 egrhd, u32 npkts)
 {
         qib_write_ureg(rcd->dd, ur_rcvhdrhead, hd, rcd->ctxt);
         if (updegr)
@@ -2171,7 +2171,7 @@ static void rcvctrl_6120_mod(struct qib_pportdata *ppd, unsigned int op,
                  * Init the context registers also; if we were
                  * disabled, tail and head should both be zero
                  * already from the enable, but since we don't
-                 * know, we have to do it explictly.
+                 * know, we have to do it explicitly.
                  */
                 val = qib_read_ureg32(dd, ur_rcvegrindextail, ctxt);
                 qib_write_ureg(dd, ur_rcvegrindexhead, val, ctxt);
diff --git a/drivers/infiniband/hw/qib/qib_iba7220.c b/drivers/infiniband/hw/qib/qib_iba7220.c
index 6fd8d74e7392..c765a2eb04cf 100644
--- a/drivers/infiniband/hw/qib/qib_iba7220.c
+++ b/drivers/infiniband/hw/qib/qib_iba7220.c
@@ -1692,8 +1692,7 @@ static void qib_7220_quiet_serdes(struct qib_pportdata *ppd)
         ppd->lflags &= ~QIBL_IB_AUTONEG_INPROG;
         spin_unlock_irqrestore(&ppd->lflags_lock, flags);
         wake_up(&ppd->cpspec->autoneg_wait);
-        cancel_delayed_work(&ppd->cpspec->autoneg_work);
-        flush_scheduled_work();
+        cancel_delayed_work_sync(&ppd->cpspec->autoneg_work);
 
         shutdown_7220_relock_poll(ppd->dd);
         val = qib_read_kreg64(ppd->dd, kr_xgxs_cfg);
@@ -2112,7 +2111,7 @@ static int qib_setup_7220_reset(struct qib_devdata *dd)
         /*
          * Keep chip from being accessed until we are ready.  Use
          * writeq() directly, to allow the write even though QIB_PRESENT
-         * isnt' set.
+         * isn't set.
          */
         dd->flags &= ~(QIB_INITTED | QIB_PRESENT);
         dd->int_counter = 0; /* so we check interrupts work again */
@@ -2297,7 +2296,7 @@ static void qib_7220_config_ctxts(struct qib_devdata *dd)
         nchipctxts = qib_read_kreg32(dd, kr_portcnt);
         dd->cspec->numctxts = nchipctxts;
         if (qib_n_krcv_queues > 1) {
-                dd->qpn_mask = 0x3f;
+                dd->qpn_mask = 0x3e;
                 dd->first_user_ctxt = qib_n_krcv_queues * dd->num_pports;
                 if (dd->first_user_ctxt > nchipctxts)
                         dd->first_user_ctxt = nchipctxts;
@@ -2480,7 +2479,7 @@ static int qib_7220_set_ib_cfg(struct qib_pportdata *ppd, int which, u32 val)
                  * we command the link down.  As with width, only write the
                  * actual register if the link is currently down, otherwise
                  * takes effect on next link change.  Since setting is being
-                 * explictly requested (via MAD or sysfs), clear autoneg
+                 * explicitly requested (via MAD or sysfs), clear autoneg
                  * failure status if speed autoneg is enabled.
                  */
                 ppd->link_speed_enabled = val;
@@ -2703,7 +2702,7 @@ static int qib_7220_set_loopback(struct qib_pportdata *ppd, const char *what)
 }
 
 static void qib_update_7220_usrhead(struct qib_ctxtdata *rcd, u64 hd,
-                                    u32 updegr, u32 egrhd)
+                                    u32 updegr, u32 egrhd, u32 npkts)
 {
         qib_write_ureg(rcd->dd, ur_rcvhdrhead, hd, rcd->ctxt);
         if (updegr)
@@ -2779,7 +2778,7 @@ static void rcvctrl_7220_mod(struct qib_pportdata *ppd, unsigned int op,
                  * Init the context registers also; if we were
                  * disabled, tail and head should both be zero
                  * already from the enable, but since we don't
-                 * know, we have to do it explictly.
+                 * know, we have to do it explicitly.
                  */
                 val = qib_read_ureg32(dd, ur_rcvegrindextail, ctxt);
                 qib_write_ureg(dd, ur_rcvegrindexhead, val, ctxt);
@@ -3515,8 +3514,8 @@ static void try_7220_autoneg(struct qib_pportdata *ppd)
 
         toggle_7220_rclkrls(ppd->dd);
         /* 2 msec is minimum length of a poll cycle */
-        schedule_delayed_work(&ppd->cpspec->autoneg_work,
-                              msecs_to_jiffies(2));
+        queue_delayed_work(ib_wq, &ppd->cpspec->autoneg_work,
+                           msecs_to_jiffies(2));
 }
 
 /*
diff --git a/drivers/infiniband/hw/qib/qib_iba7322.c b/drivers/infiniband/hw/qib/qib_iba7322.c
index 584d443b5335..8ec5237031a0 100644
--- a/drivers/infiniband/hw/qib/qib_iba7322.c
+++ b/drivers/infiniband/hw/qib/qib_iba7322.c
@@ -71,6 +71,9 @@ static void qib_7322_mini_pcs_reset(struct qib_pportdata *);
 
 static u32 ahb_mod(struct qib_devdata *, int, int, int, u32, u32);
 static void ibsd_wr_allchans(struct qib_pportdata *, int, unsigned, unsigned);
+static void serdes_7322_los_enable(struct qib_pportdata *, int);
+static int serdes_7322_init_old(struct qib_pportdata *);
+static int serdes_7322_init_new(struct qib_pportdata *);
 
 #define BMASK(msb, lsb) (((1 << ((msb) + 1 - (lsb))) - 1) << (lsb))
 
@@ -111,6 +114,21 @@ static ushort qib_singleport;
 module_param_named(singleport, qib_singleport, ushort, S_IRUGO);
 MODULE_PARM_DESC(singleport, "Use only IB port 1; more per-port buffer space");
 
+/*
+ * Receive header queue sizes
+ */
+static unsigned qib_rcvhdrcnt;
+module_param_named(rcvhdrcnt, qib_rcvhdrcnt, uint, S_IRUGO);
+MODULE_PARM_DESC(rcvhdrcnt, "receive header count");
+
+static unsigned qib_rcvhdrsize;
+module_param_named(rcvhdrsize, qib_rcvhdrsize, uint, S_IRUGO);
+MODULE_PARM_DESC(rcvhdrsize, "receive header size in 32-bit words");
+
+static unsigned qib_rcvhdrentsize;
+module_param_named(rcvhdrentsize, qib_rcvhdrentsize, uint, S_IRUGO);
+MODULE_PARM_DESC(rcvhdrentsize, "receive header entry size in 32-bit words");
+
 #define MAX_ATTEN_LEN 64 /* plenty for any real system */
 /* for read back, default index is ~5m copper cable */
 static char txselect_list[MAX_ATTEN_LEN] = "10";
@@ -314,7 +332,7 @@ MODULE_PARM_DESC(txselect, \
 #define krp_serdesctrl KREG_IBPORT_IDX(IBSerdesCtrl)
 
 /*
- * Per-context kernel registers.  Acess only with qib_read_kreg_ctxt()
+ * Per-context kernel registers.  Access only with qib_read_kreg_ctxt()
  * or qib_write_kreg_ctxt()
  */
 #define krc_rcvhdraddr KREG_IDX(RcvHdrAddr0)
@@ -451,6 +469,8 @@ static u8 ib_rate_to_delay[IB_RATE_120_GBPS + 1] = {
 #define IB_7322_LT_STATE_RECOVERIDLE     0x0f
 #define IB_7322_LT_STATE_CFGENH          0x10
 #define IB_7322_LT_STATE_CFGTEST         0x11
+#define IB_7322_LT_STATE_CFGWAITRMTTEST  0x12
+#define IB_7322_LT_STATE_CFGWAITENH      0x13
 
 /* link state machine states from IBC */
 #define IB_7322_L_STATE_DOWN             0x0
@@ -480,8 +500,10 @@ static const u8 qib_7322_physportstate[0x20] = {
                 IB_PHYSPORTSTATE_LINK_ERR_RECOVER,
         [IB_7322_LT_STATE_CFGENH] = IB_PHYSPORTSTATE_CFG_ENH,
         [IB_7322_LT_STATE_CFGTEST] = IB_PHYSPORTSTATE_CFG_TRAIN,
-        [0x12] = IB_PHYSPORTSTATE_CFG_TRAIN,
-        [0x13] = IB_PHYSPORTSTATE_CFG_WAIT_ENH,
+        [IB_7322_LT_STATE_CFGWAITRMTTEST] =
+                IB_PHYSPORTSTATE_CFG_TRAIN,
+        [IB_7322_LT_STATE_CFGWAITENH] =
+                IB_PHYSPORTSTATE_CFG_WAIT_ENH,
         [0x14] = IB_PHYSPORTSTATE_CFG_TRAIN,
         [0x15] = IB_PHYSPORTSTATE_CFG_TRAIN,
         [0x16] = IB_PHYSPORTSTATE_CFG_TRAIN,
@@ -544,6 +566,7 @@ static void write_tx_serdes_param(struct qib_pportdata *, struct txdds_ent *);
 
 #define TXDDS_TABLE_SZ 16 /* number of entries per speed in onchip table */
 #define TXDDS_EXTRA_SZ 13 /* number of extra tx settings entries */
+#define TXDDS_MFG_SZ 2    /* number of mfg tx settings entries */
 #define SERDES_CHANS 4 /* yes, it's obvious, but one less magic number */
 
 #define H1_FORCE_VAL 8
@@ -1673,10 +1696,14 @@ static void handle_serdes_issues(struct qib_pportdata *ppd, u64 ibcst)
                 break;
         }
 
-        if (ibclt == IB_7322_LT_STATE_CFGTEST &&
+        if (((ibclt >= IB_7322_LT_STATE_CFGTEST &&
+              ibclt <= IB_7322_LT_STATE_CFGWAITENH) ||
+             ibclt == IB_7322_LT_STATE_LINKUP) &&
             (ibcst & SYM_MASK(IBCStatusA_0, LinkSpeedQDR))) {
                 force_h1(ppd);
                 ppd->cpspec->qdr_reforce = 1;
+                if (!ppd->dd->cspec->r1)
+                        serdes_7322_los_enable(ppd, 0);
         } else if (ppd->cpspec->qdr_reforce &&
                 (ibcst & SYM_MASK(IBCStatusA_0, LinkSpeedQDR)) &&
                  (ibclt == IB_7322_LT_STATE_CFGENH ||
@@ -1692,18 +1719,37 @@ static void handle_serdes_issues(struct qib_pportdata *ppd, u64 ibcst)
               ibclt <= IB_7322_LT_STATE_SLEEPQUIET)))
                 adj_tx_serdes(ppd);
 
-        if (!ppd->cpspec->qdr_dfe_on && ibclt != IB_7322_LT_STATE_LINKUP &&
-            ibclt <= IB_7322_LT_STATE_SLEEPQUIET) {
-                ppd->cpspec->qdr_dfe_on = 1;
-                ppd->cpspec->qdr_dfe_time = 0;
-                /* On link down, reenable QDR adaptation */
-                qib_write_kreg_port(ppd, krp_static_adapt_dis(2),
-                        ppd->dd->cspec->r1 ?
-                                    QDR_STATIC_ADAPT_DOWN_R1 :
-                                    QDR_STATIC_ADAPT_DOWN);
+        if (ibclt != IB_7322_LT_STATE_LINKUP) {
+                u8 ltstate = qib_7322_phys_portstate(ibcst);
+                u8 pibclt = (u8)SYM_FIELD(ppd->lastibcstat, IBCStatusA_0,
+                                          LinkTrainingState);
+                if (!ppd->dd->cspec->r1 &&
+                    pibclt == IB_7322_LT_STATE_LINKUP &&
+                    ltstate != IB_PHYSPORTSTATE_LINK_ERR_RECOVER &&
+                    ltstate != IB_PHYSPORTSTATE_RECOVERY_RETRAIN &&
+                    ltstate != IB_PHYSPORTSTATE_RECOVERY_WAITRMT &&
+                    ltstate != IB_PHYSPORTSTATE_RECOVERY_IDLE)
+                        /* If the link went down (but no into recovery,
+                         * turn LOS back on */
+                        serdes_7322_los_enable(ppd, 1);
+                if (!ppd->cpspec->qdr_dfe_on &&
+                    ibclt <= IB_7322_LT_STATE_SLEEPQUIET) {
+                        ppd->cpspec->qdr_dfe_on = 1;
+                        ppd->cpspec->qdr_dfe_time = 0;
+                        /* On link down, reenable QDR adaptation */
+                        qib_write_kreg_port(ppd, krp_static_adapt_dis(2),
+                                            ppd->dd->cspec->r1 ?
+                                            QDR_STATIC_ADAPT_DOWN_R1 :
+                                            QDR_STATIC_ADAPT_DOWN);
+                        printk(KERN_INFO QIB_DRV_NAME
+                                " IB%u:%u re-enabled QDR adaptation "
+                                "ibclt %x\n", ppd->dd->unit, ppd->port, ibclt);
+                }
         }
 }
 
+static int qib_7322_set_ib_cfg(struct qib_pportdata *, int, u32);
+
 /*
  * This is per-pport error handling.
  * will likely get it's own MSIx interrupt (one for each port,
@@ -2323,6 +2369,11 @@ static int qib_7322_bringup_serdes(struct qib_pportdata *ppd)
         qib_write_kreg_port(ppd, krp_rcvctrl, ppd->p_rcvctrl);
         spin_unlock_irqrestore(&dd->cspec->rcvmod_lock, flags);
 
+        /* Hold the link state machine for mezz boards */
+        if (IS_QMH(dd) || IS_QME(dd))
+                qib_set_ib_7322_lstate(ppd, 0,
+                                       QLOGIC_IB_IBCC_LINKINITCMD_DISABLE);
+
         /* Also enable IBSTATUSCHG interrupt.  */
         val = qib_read_kreg_port(ppd, krp_errmask);
         qib_write_kreg_port(ppd, krp_errmask,
@@ -2348,10 +2399,9 @@ static void qib_7322_mini_quiet_serdes(struct qib_pportdata *ppd)
         ppd->lflags &= ~QIBL_IB_AUTONEG_INPROG;
         spin_unlock_irqrestore(&ppd->lflags_lock, flags);
         wake_up(&ppd->cpspec->autoneg_wait);
-        cancel_delayed_work(&ppd->cpspec->autoneg_work);
+        cancel_delayed_work_sync(&ppd->cpspec->autoneg_work);
         if (ppd->dd->cspec->r1)
-                cancel_delayed_work(&ppd->cpspec->ipg_work);
-        flush_scheduled_work();
+                cancel_delayed_work_sync(&ppd->cpspec->ipg_work);
 
         ppd->cpspec->chase_end = 0;
         if (ppd->cpspec->chase_timer.data) /* if initted */
@@ -2648,7 +2698,7 @@ static noinline void unknown_7322_gpio_intr(struct qib_devdata *dd)
                         if (!(pins & mask)) {
                                 ++handled;
                                 qd->t_insert = get_jiffies_64();
-                                schedule_work(&qd->work);
+                                queue_work(ib_wq, &qd->work);
                         }
                 }
         }
@@ -2785,7 +2835,6 @@ static irqreturn_t qib_7322intr(int irq, void *data)
                                 ctxtrbits &= ~rmask;
                                 if (dd->rcd[i]) {
                                         qib_kreceive(dd->rcd[i], NULL, &npkts);
-                                        adjust_rcv_timeout(dd->rcd[i], npkts);
                                 }
                         }
                         rmask <<= 1;
@@ -2835,7 +2884,6 @@ static irqreturn_t qib_7322pintr(int irq, void *data)
                        (1ULL << QIB_I_RCVURG_LSB)) << rcd->ctxt);
 
         qib_kreceive(rcd, NULL, &npkts);
-        adjust_rcv_timeout(rcd, npkts);
 
         return IRQ_HANDLED;
 }
@@ -3157,6 +3205,10 @@ static unsigned qib_7322_boardname(struct qib_devdata *dd)
         case BOARD_QME7342:
                 n = "InfiniPath_QME7342";
                 break;
+        case 8:
+                n = "InfiniPath_QME7362";
+                dd->flags |= QIB_HAS_QSFP;
+                break;
         case 15:
                 n = "InfiniPath_QLE7342_TEST";
                 dd->flags |= QIB_HAS_QSFP;
@@ -3253,7 +3305,7 @@ static int qib_do_7322_reset(struct qib_devdata *dd)
         /*
          * Keep chip from being accessed until we are ready.  Use
          * writeq() directly, to allow the write even though QIB_PRESENT
-         * isnt' set.
+         * isn't set.
          */
         dd->flags &= ~(QIB_INITTED | QIB_PRESENT | QIB_BADINTR);
         dd->flags |= QIB_DOING_RESET;
@@ -3475,11 +3527,6 @@ static void qib_7322_config_ctxts(struct qib_devdata *dd)
         nchipctxts = qib_read_kreg32(dd, kr_contextcnt);
         dd->cspec->numctxts = nchipctxts;
         if (qib_n_krcv_queues > 1 && dd->num_pports) {
-                /*
-                 * Set the mask for which bits from the QPN are used
-                 * to select a context number.
-                 */
-                dd->qpn_mask = 0x3f;
                 dd->first_user_ctxt = NUM_IB_PORTS +
                         (qib_n_krcv_queues - 1) * dd->num_pports;
                 if (dd->first_user_ctxt > nchipctxts)
@@ -3530,8 +3577,11 @@ static void qib_7322_config_ctxts(struct qib_devdata *dd)
 
         /* kr_rcvegrcnt changes based on the number of contexts enabled */
         dd->cspec->rcvegrcnt = qib_read_kreg32(dd, kr_rcvegrcnt);
-        dd->rcvhdrcnt = max(dd->cspec->rcvegrcnt,
-                                dd->num_pports > 1 ? 1024U : 2048U);
+        if (qib_rcvhdrcnt)
+                dd->rcvhdrcnt = max(dd->cspec->rcvegrcnt, qib_rcvhdrcnt);
+        else
+                dd->rcvhdrcnt = max(dd->cspec->rcvegrcnt,
+                                    dd->num_pports > 1 ? 1024U : 2048U);
 }
 
 static int qib_7322_get_ib_cfg(struct qib_pportdata *ppd, int which)
@@ -3683,7 +3733,7 @@ static int qib_7322_set_ib_cfg(struct qib_pportdata *ppd, int which, u32 val)
                 /*
                  * As with width, only write the actual register if the
                  * link is currently down, otherwise takes effect on next
-                 * link change.  Since setting is being explictly requested
+                 * link change.  Since setting is being explicitly requested
                  * (via MAD or sysfs), clear autoneg failure status if speed
                  * autoneg is enabled.
                  */
@@ -4002,8 +4052,14 @@ static int qib_7322_set_ib_table(struct qib_pportdata *ppd, int which, void *t)
 }
 
 static void qib_update_7322_usrhead(struct qib_ctxtdata *rcd, u64 hd,
-                                    u32 updegr, u32 egrhd)
+                                    u32 updegr, u32 egrhd, u32 npkts)
 {
+        /*
+         * Need to write timeout register before updating rcvhdrhead to ensure
+         * that the timer is enabled on reception of a packet.
+         */
+        if (hd >> IBA7322_HDRHEAD_PKTINT_SHIFT)
+                adjust_rcv_timeout(rcd, npkts);
         qib_write_ureg(rcd->dd, ur_rcvhdrhead, hd, rcd->ctxt);
         qib_write_ureg(rcd->dd, ur_rcvhdrhead, hd, rcd->ctxt);
         if (updegr)
@@ -4113,7 +4169,7 @@ static void rcvctrl_7322_mod(struct qib_pportdata *ppd, unsigned int op,
                  * Init the context registers also; if we were
                  * disabled, tail and head should both be zero
                  * already from the enable, but since we don't
-                 * know, we have to do it explictly.
+                 * know, we have to do it explicitly.
                  */
                 val = qib_read_ureg32(dd, ur_rcvegrindextail, ctxt);
                 qib_write_ureg(dd, ur_rcvegrindexhead, val, ctxt);
@@ -4926,8 +4982,8 @@ static void try_7322_autoneg(struct qib_pportdata *ppd)
         set_7322_ibspeed_fast(ppd, QIB_IB_DDR);
         qib_7322_mini_pcs_reset(ppd);
         /* 2 msec is minimum length of a poll cycle */
-        schedule_delayed_work(&ppd->cpspec->autoneg_work,
-                              msecs_to_jiffies(2));
+        queue_delayed_work(ib_wq, &ppd->cpspec->autoneg_work,
+                           msecs_to_jiffies(2));
 }
 
 /*
@@ -5057,7 +5113,8 @@ static void try_7322_ipg(struct qib_pportdata *ppd)
                 ib_free_send_mad(send_buf);
 retry:
         delay = 2 << ppd->cpspec->ipg_tries;
-        schedule_delayed_work(&ppd->cpspec->ipg_work, msecs_to_jiffies(delay));
+        queue_delayed_work(ib_wq, &ppd->cpspec->ipg_work,
+                           msecs_to_jiffies(delay));
 }
 
 /*
@@ -5522,7 +5579,7 @@ static void qsfp_7322_event(struct work_struct *work)
                 u64 now = get_jiffies_64();
                 if (time_after64(now, pwrup))
                         break;
-                msleep(1);
+                msleep(20);
         }
         ret = qib_refresh_qsfp_cache(ppd, &qd->cache);
         /*
@@ -5531,9 +5588,16 @@ static void qsfp_7322_event(struct work_struct *work)
          * even on failure to read cable information.  We don't
          * get here for QME, so IS_QME check not needed here.
          */
-        le2 = (!ret && qd->cache.atten[1] >= qib_long_atten &&
-               !ppd->dd->cspec->r1 && QSFP_IS_CU(qd->cache.tech)) ?
-                LE2_5m : LE2_DEFAULT;
+        if (!ret && !ppd->dd->cspec->r1) {
+                if (QSFP_IS_ACTIVE_FAR(qd->cache.tech))
+                        le2 = LE2_QME;
+                else if (qd->cache.atten[1] >= qib_long_atten &&
+                         QSFP_IS_CU(qd->cache.tech))
+                        le2 = LE2_5m;
+                else
+                        le2 = LE2_DEFAULT;
+        } else
+                le2 = LE2_DEFAULT;
         ibsd_wr_allchans(ppd, 13, (le2 << 7), BMASK(9, 7));
         init_txdds_table(ppd, 0);
 }
@@ -5579,6 +5643,7 @@ static void set_no_qsfp_atten(struct qib_devdata *dd, int change)
         u32 pidx, unit, port, deflt, h1;
         unsigned long val;
         int any = 0, seth1;
+        int txdds_size;
 
         str = txselect_list;
 
@@ -5587,6 +5652,10 @@ static void set_no_qsfp_atten(struct qib_devdata *dd, int change)
         for (pidx = 0; pidx < dd->num_pports; ++pidx)
                 dd->pport[pidx].cpspec->no_eep = deflt;
 
+        txdds_size = TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ;
+        if (IS_QME(dd) || IS_QMH(dd))
+                txdds_size += TXDDS_MFG_SZ;
+
         while (*nxt && nxt[1]) {
                 str = ++nxt;
                 unit = simple_strtoul(str, &nxt, 0);
@@ -5609,7 +5678,7 @@ static void set_no_qsfp_atten(struct qib_devdata *dd, int change)
                                 ;
                         continue;
                 }
-                if (val >= TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ)
+                if (val >= txdds_size)
                         continue;
                 seth1 = 0;
                 h1 = 0; /* gcc thinks it might be used uninitted */
@@ -5633,6 +5702,11 @@ static void set_no_qsfp_atten(struct qib_devdata *dd, int change)
                                 ppd->cpspec->h1_val = h1;
                         /* now change the IBC and serdes, overriding generic */
                         init_txdds_table(ppd, 1);
+                        /* Re-enable the physical state machine on mezz boards
+                         * now that the correct settings have been set. */
+                        if (IS_QMH(dd) || IS_QME(dd))
+                                qib_set_ib_7322_lstate(ppd, 0,
+                                            QLOGIC_IB_IBCC_LINKINITCMD_SLEEP);
                         any++;
                 }
                 if (*nxt == '\n')
@@ -5661,10 +5735,11 @@ static int setup_txselect(const char *str, struct kernel_param *kp)
                 return -ENOSPC;
         }
         val = simple_strtoul(str, &n, 0);
-        if (n == str || val >= (TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ)) {
+        if (n == str || val >= (TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ +
+                                TXDDS_MFG_SZ)) {
                 printk(KERN_INFO QIB_DRV_NAME
                        "txselect_values must start with a number < %d\n",
-                        TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ);
+                        TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ + TXDDS_MFG_SZ);
                 return -EINVAL;
         }
         strcpy(txselect_list, str);
@@ -5810,7 +5885,8 @@ static void write_7322_initregs(struct qib_devdata *dd)
                 unsigned n, regno;
                 unsigned long flags;
 
-                if (!dd->qpn_mask || !dd->pport[pidx].link_speed_supported)
+                if (dd->n_krcv_queues < 2 ||
+                        !dd->pport[pidx].link_speed_supported)
                         continue;
 
                 ppd = &dd->pport[pidx];
@@ -6097,8 +6173,10 @@ static int qib_init_7322_variables(struct qib_devdata *dd)
                 ppd++;
         }
 
-        dd->rcvhdrentsize = QIB_RCVHDR_ENTSIZE;
-        dd->rcvhdrsize = QIB_DFLT_RCVHDRSIZE;
+        dd->rcvhdrentsize = qib_rcvhdrentsize ?
+                qib_rcvhdrentsize : QIB_RCVHDR_ENTSIZE;
+        dd->rcvhdrsize = qib_rcvhdrsize ?
+                qib_rcvhdrsize : QIB_DFLT_RCVHDRSIZE;
         dd->rhf_offset = dd->rcvhdrentsize - sizeof(u64) / sizeof(u32);
 
         /* we always allocate at least 2048 bytes for eager buffers */
@@ -6495,7 +6573,7 @@ static void qib_7322_txchk_change(struct qib_devdata *dd, u32 start,
                 /* make sure we see an updated copy next time around */
                 sendctrl_7322_mod(dd->pport, QIB_SENDCTRL_AVAIL_BLIP);
                 sleeps++;
-                msleep(1);
+                msleep(20);
         }
 
         switch (which) {
@@ -6993,6 +7071,12 @@ static const struct txdds_ent txdds_extra_qdr[TXDDS_EXTRA_SZ] = {
         {  0, 1,  0, 12 },      /* QMH7342 backplane settings */
 };
 
+static const struct txdds_ent txdds_extra_mfg[TXDDS_MFG_SZ] = {
+        /* amp, pre, main, post */
+        { 0, 0, 0, 0 },         /* QME7342 mfg settings */
+        { 0, 0, 0, 6 },         /* QME7342 P2 mfg settings */
+};
+
 static const struct txdds_ent *get_atten_table(const struct txdds_ent *txdds,
                                                unsigned atten)
 {
@@ -7066,6 +7150,16 @@ static void find_best_ent(struct qib_pportdata *ppd,
                 *sdr_dds = &txdds_extra_sdr[idx];
                 *ddr_dds = &txdds_extra_ddr[idx];
                 *qdr_dds = &txdds_extra_qdr[idx];
+        } else if ((IS_QME(ppd->dd) || IS_QMH(ppd->dd)) &&
+                   ppd->cpspec->no_eep < (TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ +
+                                          TXDDS_MFG_SZ)) {
+                idx = ppd->cpspec->no_eep - (TXDDS_TABLE_SZ + TXDDS_EXTRA_SZ);
+                printk(KERN_INFO QIB_DRV_NAME
+                        " IB%u:%u use idx %u into txdds_mfg\n",
+                        ppd->dd->unit, ppd->port, idx);
+                *sdr_dds = &txdds_extra_mfg[idx];
+                *ddr_dds = &txdds_extra_mfg[idx];
+                *qdr_dds = &txdds_extra_mfg[idx];
         } else {
                 /* this shouldn't happen, it's range checked */
                 *sdr_dds = txdds_sdr + qib_long_atten;
@@ -7210,9 +7304,35 @@ static void ibsd_wr_allchans(struct qib_pportdata *ppd, int addr, unsigned data,
         }
 }
 
+static void serdes_7322_los_enable(struct qib_pportdata *ppd, int enable)
+{
+        u64 data = qib_read_kreg_port(ppd, krp_serdesctrl);
+        u8 state = SYM_FIELD(data, IBSerdesCtrl_0, RXLOSEN);
+
+        if (enable && !state) {
+                printk(KERN_INFO QIB_DRV_NAME " IB%u:%u Turning LOS on\n",
+                        ppd->dd->unit, ppd->port);
+                data |= SYM_MASK(IBSerdesCtrl_0, RXLOSEN);
+        } else if (!enable && state) {
+                printk(KERN_INFO QIB_DRV_NAME " IB%u:%u Turning LOS off\n",
+                        ppd->dd->unit, ppd->port);
+                data &= ~SYM_MASK(IBSerdesCtrl_0, RXLOSEN);
+        }
+        qib_write_kreg_port(ppd, krp_serdesctrl, data);
+}
+
 static int serdes_7322_init(struct qib_pportdata *ppd)
 {
-        u64 data;
+        int ret = 0;
+        if (ppd->dd->cspec->r1)
+                ret = serdes_7322_init_old(ppd);
+        else
+                ret = serdes_7322_init_new(ppd);
+        return ret;
+}
+
+static int serdes_7322_init_old(struct qib_pportdata *ppd)
+{
         u32 le_val;
 
         /*
@@ -7270,11 +7390,7 @@ static int serdes_7322_init(struct qib_pportdata *ppd)
         ibsd_wr_allchans(ppd, 20, (2 << 10), BMASK(12, 10)); /* DDR */
         ibsd_wr_allchans(ppd, 20, (4 << 13), BMASK(15, 13)); /* SDR */
 
-        data = qib_read_kreg_port(ppd, krp_serdesctrl);
-        /* Turn off IB latency mode */
-        data &= ~SYM_MASK(IBSerdesCtrl_0, IB_LAT_MODE);
-        qib_write_kreg_port(ppd, krp_serdesctrl, data |
-                SYM_MASK(IBSerdesCtrl_0, RXLOSEN));
+        serdes_7322_los_enable(ppd, 1);
 
         /* rxbistena; set 0 to avoid effects of it switch later */
         ibsd_wr_allchans(ppd, 9, 0 << 15, 1 << 15);
@@ -7314,6 +7430,206 @@ static int serdes_7322_init(struct qib_pportdata *ppd)
         return 0;
 }
 
+static int serdes_7322_init_new(struct qib_pportdata *ppd)
+{
+        u64 tstart;
+        u32 le_val, rxcaldone;
+        int chan, chan_done = (1 << SERDES_CHANS) - 1;
+
+        /*
+         * Initialize the Tx DDS tables.  Also done every QSFP event,
+         * for adapters with QSFP
+         */
+        init_txdds_table(ppd, 0);
+
+        /* Clear cmode-override, may be set from older driver */
+        ahb_mod(ppd->dd, IBSD(ppd->hw_pidx), 5, 10, 0 << 14, 1 << 14);
+
+        /* ensure no tx overrides from earlier driver loads */
+        qib_write_kreg_port(ppd, krp_tx_deemph_override,
+                SYM_MASK(IBSD_TX_DEEMPHASIS_OVERRIDE_0,
+                reset_tx_deemphasis_override));
+
+        /* START OF LSI SUGGESTED SERDES BRINGUP */
+        /* Reset - Calibration Setup */
+        /*       Stop DFE adaptaion */
+        ibsd_wr_allchans(ppd, 1, 0, BMASK(9, 1));
+        /*       Disable LE1 */
+        ibsd_wr_allchans(ppd, 13, 0, BMASK(5, 5));
+        /*       Disable autoadapt for LE1 */
+        ibsd_wr_allchans(ppd, 1, 0, BMASK(15, 15));
+        /*       Disable LE2 */
+        ibsd_wr_allchans(ppd, 13, 0, BMASK(6, 6));
+        /*       Disable VGA */
+        ibsd_wr_allchans(ppd, 5, 0, BMASK(0, 0));
+        /*       Disable AFE Offset Cancel */
+        ibsd_wr_allchans(ppd, 12, 0, BMASK(12, 12));
+        /*       Disable Timing Loop */
+        ibsd_wr_allchans(ppd, 2, 0, BMASK(3, 3));
+        /*       Disable Frequency Loop */
+        ibsd_wr_allchans(ppd, 2, 0, BMASK(4, 4));
+        /*       Disable Baseline Wander Correction */
+        ibsd_wr_allchans(ppd, 13, 0, BMASK(13, 13));
+        /*       Disable RX Calibration */
+        ibsd_wr_allchans(ppd, 4, 0, BMASK(10, 10));
+        /*       Disable RX Offset Calibration */
+        ibsd_wr_allchans(ppd, 12, 0, BMASK(4, 4));
+        /*       Select BB CDR */
+        ibsd_wr_allchans(ppd, 2, (1 << 15), BMASK(15, 15));
+        /*       CDR Step Size */
+        ibsd_wr_allchans(ppd, 5, 0, BMASK(9, 8));
+        /*       Enable phase Calibration */
+        ibsd_wr_allchans(ppd, 12, (1 << 5), BMASK(5, 5));
+        /*       DFE Bandwidth [2:14-12] */
+        ibsd_wr_allchans(ppd, 2, (4 << 12), BMASK(14, 12));
+        /*       DFE Config (4 taps only) */
+        ibsd_wr_allchans(ppd, 16, 0, BMASK(1, 0));
+        /*       Gain Loop Bandwidth */
+        if (!ppd->dd->cspec->r1) {
+                ibsd_wr_allchans(ppd, 12, 1 << 12, BMASK(12, 12));
+                ibsd_wr_allchans(ppd, 12, 2 << 8, BMASK(11, 8));
+        } else {
+                ibsd_wr_allchans(ppd, 19, (3 << 11), BMASK(13, 11));
+        }
+        /*       Baseline Wander Correction Gain [13:4-0] (leave as default) */
+        /*       Baseline Wander Correction Gain [3:7-5] (leave as default) */
+        /*       Data Rate Select [5:7-6] (leave as default) */
+        /*       RX Parallel Word Width [3:10-8] (leave as default) */
+
+        /* RX REST */
+        /*       Single- or Multi-channel reset */
+        /*       RX Analog reset */
+        /*       RX Digital reset */
+        ibsd_wr_allchans(ppd, 0, 0, BMASK(15, 13));
+        msleep(20);
+        /*       RX Analog reset */
+        ibsd_wr_allchans(ppd, 0, (1 << 14), BMASK(14, 14));
+        msleep(20);
+        /*       RX Digital reset */
+        ibsd_wr_allchans(ppd, 0, (1 << 13), BMASK(13, 13));
+        msleep(20);
+
+        /* setup LoS params; these are subsystem, so chan == 5 */
+        /* LoS filter threshold_count on, ch 0-3, set to 8 */
+        ahb_mod(ppd->dd, IBSD(ppd->hw_pidx), 5, 5, 8 << 11, BMASK(14, 11));
+        ahb_mod(ppd->dd, IBSD(ppd->hw_pidx), 5, 7, 8 << 4, BMASK(7, 4));
+        ahb_mod(ppd->dd, IBSD(ppd->hw_pidx), 5, 8, 8 << 11, BMASK(14, 11));
+        ahb_mod(ppd->dd, IBSD(ppd->hw_pidx), 5, 10, 8 << 4, BMASK(7, 4));
+
+        /* LoS filter threshold_count off, ch 0-3, set to 4 */
+        ahb_mod(ppd->dd, IBSD(ppd->hw_pidx), 5, 6, 4 << 0, BMASK(3, 0));
+        ahb_mod(ppd->dd, IBSD(ppd->hw_pidx), 5, 7, 4 << 8, BMASK(11, 8));
+        ahb_mod(ppd->dd, IBSD(ppd->hw_pidx), 5, 9, 4 << 0, BMASK(3, 0));
+        ahb_mod(ppd->dd, IBSD(ppd->hw_pidx), 5, 10, 4 << 8, BMASK(11, 8));
+
+        /* LoS filter select enabled */
+        ahb_mod(ppd->dd, IBSD(ppd->hw_pidx), 5, 9, 1 << 15, 1 << 15);
+
+        /* LoS target data:  SDR=4, DDR=2, QDR=1 */
+        ibsd_wr_allchans(ppd, 14, (1 << 3), BMASK(5, 3)); /* QDR */
+        ibsd_wr_allchans(ppd, 20, (2 << 10), BMASK(12, 10)); /* DDR */
+        ibsd_wr_allchans(ppd, 20, (4 << 13), BMASK(15, 13)); /* SDR */
+
+        /* Turn on LOS on initial SERDES init */
+        serdes_7322_los_enable(ppd, 1);
+        /* FLoop LOS gate: PPM filter  enabled */
+        ibsd_wr_allchans(ppd, 38, 0 << 10, 1 << 10);
+
+        /* RX LATCH CALIBRATION */
+        /*       Enable Eyefinder Phase Calibration latch */
+        ibsd_wr_allchans(ppd, 15, 1, BMASK(0, 0));
+        /*       Enable RX Offset Calibration latch */
+        ibsd_wr_allchans(ppd, 12, (1 << 4), BMASK(4, 4));
+        msleep(20);
+        /*       Start Calibration */
+        ibsd_wr_allchans(ppd, 4, (1 << 10), BMASK(10, 10));
+        tstart = get_jiffies_64();
+        while (chan_done &&
+               !time_after64(get_jiffies_64(),
+                        tstart + msecs_to_jiffies(500))) {
+                msleep(20);
+                for (chan = 0; chan < SERDES_CHANS; ++chan) {
+                        rxcaldone = ahb_mod(ppd->dd, IBSD(ppd->hw_pidx),
+                                            (chan + (chan >> 1)),
+                                            25, 0, 0);
+                        if ((~rxcaldone & (u32)BMASK(9, 9)) == 0 &&
+                            (~chan_done & (1 << chan)) == 0)
+                                chan_done &= ~(1 << chan);
+                }
+        }
+        if (chan_done) {
+                printk(KERN_INFO QIB_DRV_NAME
+                         " Serdes %d calibration not done after .5 sec: 0x%x\n",
+                         IBSD(ppd->hw_pidx), chan_done);
+        } else {
+                for (chan = 0; chan < SERDES_CHANS; ++chan) {
+                        rxcaldone = ahb_mod(ppd->dd, IBSD(ppd->hw_pidx),
+                                            (chan + (chan >> 1)),
+                                            25, 0, 0);
+                        if ((~rxcaldone & (u32)BMASK(10, 10)) == 0)
+                                printk(KERN_INFO QIB_DRV_NAME
+                                         " Serdes %d chan %d calibration "
+                                         "failed\n", IBSD(ppd->hw_pidx), chan);
+                }
+        }
+
+        /*       Turn off Calibration */
+        ibsd_wr_allchans(ppd, 4, 0, BMASK(10, 10));
+        msleep(20);
+
+        /* BRING RX UP */
+        /*       Set LE2 value (May be overridden in qsfp_7322_event) */
+        le_val = IS_QME(ppd->dd) ? LE2_QME : LE2_DEFAULT;
+        ibsd_wr_allchans(ppd, 13, (le_val << 7), BMASK(9, 7));
+        /*       Set LE2 Loop bandwidth */
+        ibsd_wr_allchans(ppd, 3, (7 << 5), BMASK(7, 5));
+        /*       Enable LE2 */
+        ibsd_wr_allchans(ppd, 13, (1 << 6), BMASK(6, 6));
+        msleep(20);
+        /*       Enable H0 only */
+        ibsd_wr_allchans(ppd, 1, 1, BMASK(9, 1));
+        /* gain hi stop 32 (22) (6:1) lo stop 7 (10:7) target 22 (13) (15:11) */
+        le_val = (ppd->dd->cspec->r1 || IS_QME(ppd->dd)) ? 0xb6c0 : 0x6bac;
+        ibsd_wr_allchans(ppd, 21, le_val, 0xfffe);
+        /*       Enable VGA */
+        ibsd_wr_allchans(ppd, 5, 0, BMASK(0, 0));
+        msleep(20);
+        /*       Set Frequency Loop Bandwidth */
+        ibsd_wr_allchans(ppd, 2, (7 << 5), BMASK(8, 5));
+        /*       Enable Frequency Loop */
+        ibsd_wr_allchans(ppd, 2, (1 << 4), BMASK(4, 4));
+        /*       Set Timing Loop Bandwidth */
+        ibsd_wr_allchans(ppd, 2, 0, BMASK(11, 9));
+        /*       Enable Timing Loop */
+        ibsd_wr_allchans(ppd, 2, (1 << 3), BMASK(3, 3));
+        msleep(50);
+        /*       Enable DFE
+         *       Set receive adaptation mode.  SDR and DDR adaptation are
+         *       always on, and QDR is initially enabled; later disabled.
+         */
+        qib_write_kreg_port(ppd, krp_static_adapt_dis(0), 0ULL);
+        qib_write_kreg_port(ppd, krp_static_adapt_dis(1), 0ULL);
+        qib_write_kreg_port(ppd, krp_static_adapt_dis(2),
+                            ppd->dd->cspec->r1 ?
+                            QDR_STATIC_ADAPT_DOWN_R1 : QDR_STATIC_ADAPT_DOWN);
+        ppd->cpspec->qdr_dfe_on = 1;
+        /*       Disable LE1  */
+        ibsd_wr_allchans(ppd, 13, (0 << 5), (1 << 5));
+        /*       Disable auto adapt for LE1 */
+        ibsd_wr_allchans(ppd, 1, (0 << 15), BMASK(15, 15));
+        msleep(20);
+        /*       Enable AFE Offset Cancel */
+        ibsd_wr_allchans(ppd, 12, (1 << 12), BMASK(12, 12));
+        /*       Enable Baseline Wander Correction */
+        ibsd_wr_allchans(ppd, 12, (1 << 13), BMASK(13, 13));
+        /* Termination: rxtermctrl_r2d addr 11 bits [12:11] = 1 */
+        ibsd_wr_allchans(ppd, 11, (1 << 11), BMASK(12, 11));
+        /* VGA output common mode */
+        ibsd_wr_allchans(ppd, 12, (3 << 2), BMASK(3, 2));
+
+        return 0;
+}
+
 /* start adjust QMH serdes parameters */
 
 static void set_man_code(struct qib_pportdata *ppd, int chan, int code)
diff --git a/drivers/infiniband/hw/qib/qib_init.c b/drivers/infiniband/hw/qib/qib_init.c
index f1d16d3a01f6..a01f3fce8eb3 100644
--- a/drivers/infiniband/hw/qib/qib_init.c
+++ b/drivers/infiniband/hw/qib/qib_init.c
@@ -80,7 +80,6 @@ unsigned qib_wc_pat = 1; /* default (1) is to use PAT, not MTRR */
 module_param_named(wc_pat, qib_wc_pat, uint, S_IRUGO);
 MODULE_PARM_DESC(wc_pat, "enable write-combining via PAT mechanism");
 
-struct workqueue_struct *qib_wq;
 struct workqueue_struct *qib_cq_wq;
 
 static void verify_interrupt(unsigned long);
@@ -92,9 +91,11 @@ unsigned long *qib_cpulist;
 /* set number of contexts we'll actually use */
 void qib_set_ctxtcnt(struct qib_devdata *dd)
 {
-        if (!qib_cfgctxts)
+        if (!qib_cfgctxts) {
                 dd->cfgctxts = dd->first_user_ctxt + num_online_cpus();
-        else if (qib_cfgctxts < dd->num_pports)
+                if (dd->cfgctxts > dd->ctxtcnt)
+                        dd->cfgctxts = dd->ctxtcnt;
+        } else if (qib_cfgctxts < dd->num_pports)
                 dd->cfgctxts = dd->ctxtcnt;
         else if (qib_cfgctxts <= dd->ctxtcnt)
                 dd->cfgctxts = qib_cfgctxts;
@@ -268,23 +269,20 @@ static void init_shadow_tids(struct qib_devdata *dd)
         struct page **pages;
         dma_addr_t *addrs;
 
-        pages = vmalloc(dd->cfgctxts * dd->rcvtidcnt * sizeof(struct page *));
+        pages = vzalloc(dd->cfgctxts * dd->rcvtidcnt * sizeof(struct page *));
         if (!pages) {
                 qib_dev_err(dd, "failed to allocate shadow page * "
                             "array, no expected sends!\n");
                 goto bail;
         }
 
-        addrs = vmalloc(dd->cfgctxts * dd->rcvtidcnt * sizeof(dma_addr_t));
+        addrs = vzalloc(dd->cfgctxts * dd->rcvtidcnt * sizeof(dma_addr_t));
         if (!addrs) {
                 qib_dev_err(dd, "failed to allocate shadow dma handle "
                             "array, no expected sends!\n");
                 goto bail_free;
         }
 
-        memset(pages, 0, dd->cfgctxts * dd->rcvtidcnt * sizeof(struct page *));
-        memset(addrs, 0, dd->cfgctxts * dd->rcvtidcnt * sizeof(dma_addr_t));
-
         dd->pageshadow = pages;
         dd->physshadow = addrs;
         return;
@@ -348,7 +346,7 @@ done:
  * @dd: the qlogic_ib device
  *
  * sanity check at least some of the values after reset, and
- * ensure no receive or transmit (explictly, in case reset
+ * ensure no receive or transmit (explicitly, in case reset
  * failed
  */
 static int init_after_reset(struct qib_devdata *dd)
@@ -1045,24 +1043,10 @@ static int __init qlogic_ib_init(void)
         if (ret)
                 goto bail;
 
-        /*
-         * We create our own workqueue mainly because we want to be
-         * able to flush it when devices are being removed.  We can't
-         * use schedule_work()/flush_scheduled_work() because both
-         * unregister_netdev() and linkwatch_event take the rtnl lock,
-         * so flush_scheduled_work() can deadlock during device
-         * removal.
-         */
-        qib_wq = create_workqueue("qib");
-        if (!qib_wq) {
-                ret = -ENOMEM;
-                goto bail_dev;
-        }
-
         qib_cq_wq = create_singlethread_workqueue("qib_cq");
         if (!qib_cq_wq) {
                 ret = -ENOMEM;
-                goto bail_wq;
+                goto bail_dev;
         }
 
         /*
@@ -1092,8 +1076,6 @@ bail_unit:
         idr_destroy(&qib_unit_table);
 bail_cq_wq:
         destroy_workqueue(qib_cq_wq);
-bail_wq:
-        destroy_workqueue(qib_wq);
 bail_dev:
         qib_dev_cleanup();
 bail:
@@ -1117,7 +1099,6 @@ static void __exit qlogic_ib_cleanup(void)
 
         pci_unregister_driver(&qib_driver);
 
-        destroy_workqueue(qib_wq);
         destroy_workqueue(qib_cq_wq);
 
         qib_cpulist_count = 0;
@@ -1243,6 +1224,7 @@ static int __devinit qib_init_one(struct pci_dev *pdev,
                 qib_early_err(&pdev->dev, "QLogic PCIE device 0x%x cannot "
                       "work if CONFIG_PCI_MSI is not enabled\n",
                       ent->device);
+                dd = ERR_PTR(-ENODEV);
 #endif
                 break;
 
@@ -1289,7 +1271,7 @@ static int __devinit qib_init_one(struct pci_dev *pdev,
 
         if (qib_mini_init || initfail || ret) {
                 qib_stop_timers(dd);
-                flush_scheduled_work();
+                flush_workqueue(ib_wq);
                 for (pidx = 0; pidx < dd->num_pports; ++pidx)
                         dd->f_quiet_serdes(dd->pport + pidx);
                 if (qib_mini_init)
@@ -1338,8 +1320,8 @@ static void __devexit qib_remove_one(struct pci_dev *pdev)
 
         qib_stop_timers(dd);
 
-        /* wait until all of our (qsfp) schedule_work() calls complete */
-        flush_scheduled_work();
+        /* wait until all of our (qsfp) queue_work() calls complete */
+        flush_workqueue(ib_wq);
 
         ret = qibfs_remove(dd);
         if (ret)
diff --git a/drivers/infiniband/hw/qib/qib_intr.c b/drivers/infiniband/hw/qib/qib_intr.c
index 54a40828a106..6ae57d23004a 100644
--- a/drivers/infiniband/hw/qib/qib_intr.c
+++ b/drivers/infiniband/hw/qib/qib_intr.c
@@ -96,8 +96,12 @@ void qib_handle_e_ibstatuschanged(struct qib_pportdata *ppd, u64 ibcs)
          * states, or if it transitions from any of the up (INIT or better)
          * states into any of the down states (except link recovery), then
          * call the chip-specific code to take appropriate actions.
+         *
+         * ppd->lflags could be 0 if this is the first time the interrupt
+         * handlers has been called but the link is already up.
          */
-        if (lstate >= IB_PORT_INIT && (ppd->lflags & QIBL_LINKDOWN) &&
+        if (lstate >= IB_PORT_INIT &&
+            (!ppd->lflags || (ppd->lflags & QIBL_LINKDOWN)) &&
             ltstate == IB_PHYSPORTSTATE_LINKUP) {
                 /* transitioned to UP */
                 if (dd->f_ib_updown(ppd, 1, ibcs))
@@ -131,7 +135,8 @@ void qib_handle_e_ibstatuschanged(struct qib_pportdata *ppd, u64 ibcs)
                         /* start a 75msec timer to clear symbol errors */
                         mod_timer(&ppd->symerr_clear_timer,
                                   msecs_to_jiffies(75));
-                } else if (ltstate == IB_PHYSPORTSTATE_LINKUP) {
+                } else if (ltstate == IB_PHYSPORTSTATE_LINKUP &&
+                           !(ppd->lflags & QIBL_LINKACTIVE)) {
                         /* active, but not active defered */
                         qib_hol_up(ppd); /* useful only for 6120 now */
                         *ppd->statusp |=
diff --git a/drivers/infiniband/hw/qib/qib_keys.c b/drivers/infiniband/hw/qib/qib_keys.c
index 4b80eb153d57..8fd19a47df0c 100644
--- a/drivers/infiniband/hw/qib/qib_keys.c
+++ b/drivers/infiniband/hw/qib/qib_keys.c
@@ -136,7 +136,6 @@ int qib_lkey_ok(struct qib_lkey_table *rkt, struct qib_pd *pd,
         struct qib_mregion *mr;
         unsigned n, m;
         size_t off;
-        int ret = 0;
         unsigned long flags;
 
         /*
@@ -152,6 +151,8 @@ int qib_lkey_ok(struct qib_lkey_table *rkt, struct qib_pd *pd,
                 if (!dev->dma_mr)
                         goto bail;
                 atomic_inc(&dev->dma_mr->refcount);
+                spin_unlock_irqrestore(&rkt->lock, flags);
+
                 isge->mr = dev->dma_mr;
                 isge->vaddr = (void *) sge->addr;
                 isge->length = sge->length;
@@ -170,19 +171,34 @@ int qib_lkey_ok(struct qib_lkey_table *rkt, struct qib_pd *pd,
                      off + sge->length > mr->length ||
                      (mr->access_flags & acc) != acc))
                 goto bail;
+        atomic_inc(&mr->refcount);
+        spin_unlock_irqrestore(&rkt->lock, flags);
 
         off += mr->offset;
-        m = 0;
-        n = 0;
-        while (off >= mr->map[m]->segs[n].length) {
-                off -= mr->map[m]->segs[n].length;
-                n++;
-                if (n >= QIB_SEGSZ) {
-                        m++;
-                        n = 0;
+        if (mr->page_shift) {
+                /*
+                page sizes are uniform power of 2 so no loop is necessary
+                entries_spanned_by_off is the number of times the loop below
+                would have executed.
+                */
+                size_t entries_spanned_by_off;
+
+                entries_spanned_by_off = off >> mr->page_shift;
+                off -= (entries_spanned_by_off << mr->page_shift);
+                m = entries_spanned_by_off/QIB_SEGSZ;
+                n = entries_spanned_by_off%QIB_SEGSZ;
+        } else {
+                m = 0;
+                n = 0;
+                while (off >= mr->map[m]->segs[n].length) {
+                        off -= mr->map[m]->segs[n].length;
+                        n++;
+                        if (n >= QIB_SEGSZ) {
+                                m++;
+                                n = 0;
+                        }
                 }
         }
-        atomic_inc(&mr->refcount);
         isge->mr = mr;
         isge->vaddr = mr->map[m]->segs[n].vaddr + off;
         isge->length = mr->map[m]->segs[n].length - off;
@@ -190,10 +206,10 @@ int qib_lkey_ok(struct qib_lkey_table *rkt, struct qib_pd *pd,
         isge->m = m;
         isge->n = n;
 ok:
-        ret = 1;
+        return 1;
 bail:
         spin_unlock_irqrestore(&rkt->lock, flags);
-        return ret;
+        return 0;
 }
 
 /**
@@ -214,7 +230,6 @@ int qib_rkey_ok(struct qib_qp *qp, struct qib_sge *sge,
         struct qib_mregion *mr;
         unsigned n, m;
         size_t off;
-        int ret = 0;
         unsigned long flags;
 
         /*
@@ -231,6 +246,8 @@ int qib_rkey_ok(struct qib_qp *qp, struct qib_sge *sge,
                 if (!dev->dma_mr)
                         goto bail;
                 atomic_inc(&dev->dma_mr->refcount);
+                spin_unlock_irqrestore(&rkt->lock, flags);
+
                 sge->mr = dev->dma_mr;
                 sge->vaddr = (void *) vaddr;
                 sge->length = len;
@@ -248,19 +265,34 @@ int qib_rkey_ok(struct qib_qp *qp, struct qib_sge *sge,
         if (unlikely(vaddr < mr->iova || off + len > mr->length ||
                      (mr->access_flags & acc) == 0))
                 goto bail;
+        atomic_inc(&mr->refcount);
+        spin_unlock_irqrestore(&rkt->lock, flags);
 
         off += mr->offset;
-        m = 0;
-        n = 0;
-        while (off >= mr->map[m]->segs[n].length) {
-                off -= mr->map[m]->segs[n].length;
-                n++;
-                if (n >= QIB_SEGSZ) {
-                        m++;
-                        n = 0;
+        if (mr->page_shift) {
+                /*
+                page sizes are uniform power of 2 so no loop is necessary
+                entries_spanned_by_off is the number of times the loop below
+                would have executed.
+                */
+                size_t entries_spanned_by_off;
+
+                entries_spanned_by_off = off >> mr->page_shift;
+                off -= (entries_spanned_by_off << mr->page_shift);
+                m = entries_spanned_by_off/QIB_SEGSZ;
+                n = entries_spanned_by_off%QIB_SEGSZ;
+        } else {
+                m = 0;
+                n = 0;
+                while (off >= mr->map[m]->segs[n].length) {
+                        off -= mr->map[m]->segs[n].length;
+                        n++;
+                        if (n >= QIB_SEGSZ) {
+                                m++;
+                                n = 0;
+                        }
                 }
         }
-        atomic_inc(&mr->refcount);
         sge->mr = mr;
         sge->vaddr = mr->map[m]->segs[n].vaddr + off;
         sge->length = mr->map[m]->segs[n].length - off;
@@ -268,10 +300,10 @@ int qib_rkey_ok(struct qib_qp *qp, struct qib_sge *sge,
         sge->m = m;
         sge->n = n;
 ok:
-        ret = 1;
+        return 1;
 bail:
         spin_unlock_irqrestore(&rkt->lock, flags);
-        return ret;
+        return 0;
 }
 
 /*
diff --git a/drivers/infiniband/hw/qib/qib_mad.c b/drivers/infiniband/hw/qib/qib_mad.c
index 94b0d1f3a8f0..8fd3df5bf04d 100644
--- a/drivers/infiniband/hw/qib/qib_mad.c
+++ b/drivers/infiniband/hw/qib/qib_mad.c
@@ -464,8 +464,9 @@ static int subn_get_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
         memset(smp->data, 0, sizeof(smp->data));
 
         /* Only return the mkey if the protection field allows it. */
-        if (smp->method == IB_MGMT_METHOD_SET || ibp->mkey == smp->mkey ||
-            ibp->mkeyprot == 0)
+        if (!(smp->method == IB_MGMT_METHOD_GET &&
+              ibp->mkey != smp->mkey &&
+              ibp->mkeyprot == 1))
                 pip->mkey = ibp->mkey;
         pip->gid_prefix = ibp->gid_prefix;
         lid = ppd->lid;
@@ -668,8 +669,8 @@ static int subn_set_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
         lid = be16_to_cpu(pip->lid);
         /* Must be a valid unicast LID address. */
         if (lid == 0 || lid >= QIB_MULTICAST_LID_BASE)
-                goto err;
-        if (ppd->lid != lid || ppd->lmc != (pip->mkeyprot_resv_lmc & 7)) {
+                smp->status |= IB_SMP_INVALID_FIELD;
+        else if (ppd->lid != lid || ppd->lmc != (pip->mkeyprot_resv_lmc & 7)) {
                 if (ppd->lid != lid)
                         qib_set_uevent_bits(ppd, _QIB_EVENT_LID_CHANGE_BIT);
                 if (ppd->lmc != (pip->mkeyprot_resv_lmc & 7))
@@ -683,8 +684,8 @@ static int subn_set_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
         msl = pip->neighbormtu_mastersmsl & 0xF;
         /* Must be a valid unicast LID address. */
         if (smlid == 0 || smlid >= QIB_MULTICAST_LID_BASE)
-                goto err;
-        if (smlid != ibp->sm_lid || msl != ibp->sm_sl) {
+                smp->status |= IB_SMP_INVALID_FIELD;
+        else if (smlid != ibp->sm_lid || msl != ibp->sm_sl) {
                 spin_lock_irqsave(&ibp->lock, flags);
                 if (ibp->sm_ah) {
                         if (smlid != ibp->sm_lid)
@@ -705,10 +706,11 @@ static int subn_set_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
         lwe = pip->link_width_enabled;
         if (lwe) {
                 if (lwe == 0xFF)
-                        lwe = ppd->link_width_supported;
+                        set_link_width_enabled(ppd, ppd->link_width_supported);
                 else if (lwe >= 16 || (lwe & ~ppd->link_width_supported))
-                        goto err;
-                set_link_width_enabled(ppd, lwe);
+                        smp->status |= IB_SMP_INVALID_FIELD;
+                else if (lwe != ppd->link_width_enabled)
+                        set_link_width_enabled(ppd, lwe);
         }
 
         lse = pip->linkspeedactive_enabled & 0xF;
@@ -719,10 +721,12 @@ static int subn_set_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
                  * speeds.
                  */
                 if (lse == 15)
-                        lse = ppd->link_speed_supported;
+                        set_link_speed_enabled(ppd,
+                                               ppd->link_speed_supported);
                 else if (lse >= 8 || (lse & ~ppd->link_speed_supported))
-                        goto err;
-                set_link_speed_enabled(ppd, lse);
+                        smp->status |= IB_SMP_INVALID_FIELD;
+                else if (lse != ppd->link_speed_enabled)
+                        set_link_speed_enabled(ppd, lse);
         }
 
         /* Set link down default state. */
@@ -738,7 +742,7 @@ static int subn_set_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
                                         IB_LINKINITCMD_POLL);
                 break;
         default:
-                goto err;
+                smp->status |= IB_SMP_INVALID_FIELD;
         }
 
         ibp->mkeyprot = pip->mkeyprot_resv_lmc >> 6;
@@ -748,15 +752,17 @@ static int subn_set_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
 
         mtu = ib_mtu_enum_to_int((pip->neighbormtu_mastersmsl >> 4) & 0xF);
         if (mtu == -1)
-                goto err;
-        qib_set_mtu(ppd, mtu);
+                smp->status |= IB_SMP_INVALID_FIELD;
+        else
+                qib_set_mtu(ppd, mtu);
 
         /* Set operational VLs */
         vls = (pip->operationalvl_pei_peo_fpi_fpo >> 4) & 0xF;
         if (vls) {
                 if (vls > ppd->vls_supported)
-                        goto err;
-                (void) dd->f_set_ib_cfg(ppd, QIB_IB_CFG_OP_VLS, vls);
+                        smp->status |= IB_SMP_INVALID_FIELD;
+                else
+                        (void) dd->f_set_ib_cfg(ppd, QIB_IB_CFG_OP_VLS, vls);
         }
 
         if (pip->mkey_violations == 0)
@@ -770,10 +776,10 @@ static int subn_set_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
 
         ore = pip->localphyerrors_overrunerrors;
         if (set_phyerrthreshold(ppd, (ore >> 4) & 0xF))
-                goto err;
+                smp->status |= IB_SMP_INVALID_FIELD;
 
         if (set_overrunthreshold(ppd, (ore & 0xF)))
-                goto err;
+                smp->status |= IB_SMP_INVALID_FIELD;
 
         ibp->subnet_timeout = pip->clientrereg_resv_subnetto & 0x1F;
 
@@ -792,7 +798,7 @@ static int subn_set_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
         state = pip->linkspeed_portstate & 0xF;
         lstate = (pip->portphysstate_linkdown >> 4) & 0xF;
         if (lstate && !(state == IB_PORT_DOWN || state == IB_PORT_NOP))
-                goto err;
+                smp->status |= IB_SMP_INVALID_FIELD;
 
         /*
          * Only state changes of DOWN, ARM, and ACTIVE are valid
@@ -812,8 +818,10 @@ static int subn_set_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
                         lstate = QIB_IB_LINKDOWN;
                 else if (lstate == 3)
                         lstate = QIB_IB_LINKDOWN_DISABLE;
-                else
-                        goto err;
+                else {
+                        smp->status |= IB_SMP_INVALID_FIELD;
+                        break;
+                }
                 spin_lock_irqsave(&ppd->lflags_lock, flags);
                 ppd->lflags &= ~QIBL_LINKV;
                 spin_unlock_irqrestore(&ppd->lflags_lock, flags);
@@ -835,8 +843,7 @@ static int subn_set_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
                 qib_set_linkstate(ppd, QIB_IB_LINKACTIVE);
                 break;
         default:
-                /* XXX We have already partially updated our state! */
-                goto err;
+                smp->status |= IB_SMP_INVALID_FIELD;
         }
 
         ret = subn_get_portinfo(smp, ibdev, port);
@@ -844,7 +851,7 @@ static int subn_set_portinfo(struct ib_smp *smp, struct ib_device *ibdev,
         if (clientrereg)
                 pip->clientrereg_resv_subnetto |= 0x80;
 
-        goto done;
+        goto get_only;
 
 err:
         smp->status |= IB_SMP_INVALID_FIELD;
diff --git a/drivers/infiniband/hw/qib/qib_mad.h b/drivers/infiniband/hw/qib/qib_mad.h
index 147aff9117d7..7840ab593bcf 100644
--- a/drivers/infiniband/hw/qib/qib_mad.h
+++ b/drivers/infiniband/hw/qib/qib_mad.h
@@ -73,7 +73,7 @@ struct ib_mad_notice_attr {
 
                 struct {
                         __be16  reserved;
-                        __be16  lid;            /* LID where change occured */
+                        __be16  lid;            /* LID where change occurred */
                         u8      reserved2;
                         u8      local_changes;  /* low bit - local changes */
                         __be32  new_cap_mask;   /* new capability mask */
diff --git a/drivers/infiniband/hw/qib/qib_mr.c b/drivers/infiniband/hw/qib/qib_mr.c
index 5f95f0f6385d..08944e2ee334 100644
--- a/drivers/infiniband/hw/qib/qib_mr.c
+++ b/drivers/infiniband/hw/qib/qib_mr.c
@@ -39,7 +39,6 @@
 /* Fast memory region */
 struct qib_fmr {
         struct ib_fmr ibfmr;
-        u8 page_shift;
         struct qib_mregion mr;        /* must be last */
 };
 
@@ -107,6 +106,7 @@ static struct qib_mr *alloc_mr(int count, struct qib_lkey_table *lk_table)
                         goto bail;
         }
         mr->mr.mapsz = m;
+        mr->mr.page_shift = 0;
         mr->mr.max_segs = count;
 
         /*
@@ -231,6 +231,8 @@ struct ib_mr *qib_reg_user_mr(struct ib_pd *pd, u64 start, u64 length,
         mr->mr.access_flags = mr_access_flags;
         mr->umem = umem;
 
+        if (is_power_of_2(umem->page_size))
+                mr->mr.page_shift = ilog2(umem->page_size);
         m = 0;
         n = 0;
         list_for_each_entry(chunk, &umem->chunk_list, list) {
@@ -390,7 +392,7 @@ struct ib_fmr *qib_alloc_fmr(struct ib_pd *pd, int mr_access_flags,
         fmr->mr.offset = 0;
         fmr->mr.access_flags = mr_access_flags;
         fmr->mr.max_segs = fmr_attr->max_pages;
-        fmr->page_shift = fmr_attr->page_shift;
+        fmr->mr.page_shift = fmr_attr->page_shift;
 
         atomic_set(&fmr->mr.refcount, 0);
         ret = &fmr->ibfmr;
@@ -437,7 +439,7 @@ int qib_map_phys_fmr(struct ib_fmr *ibfmr, u64 *page_list,
         spin_lock_irqsave(&rkt->lock, flags);
         fmr->mr.user_base = iova;
         fmr->mr.iova = iova;
-        ps = 1 << fmr->page_shift;
+        ps = 1 << fmr->mr.page_shift;
         fmr->mr.length = list_len * ps;
         m = 0;
         n = 0;
diff --git a/drivers/infiniband/hw/qib/qib_pcie.c b/drivers/infiniband/hw/qib/qib_pcie.c
index 7fa6e5592630..891cc2ff5f00 100644
--- a/drivers/infiniband/hw/qib/qib_pcie.c
+++ b/drivers/infiniband/hw/qib/qib_pcie.c
@@ -103,16 +103,20 @@ int qib_pcie_init(struct pci_dev *pdev, const struct pci_device_id *ent)
                 ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
         } else
                 ret = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(64));
-        if (ret)
+        if (ret) {
                 qib_early_err(&pdev->dev,
                               "Unable to set DMA consistent mask: %d\n", ret);
+                goto bail;
+        }
 
         pci_set_master(pdev);
         ret = pci_enable_pcie_error_reporting(pdev);
-        if (ret)
+        if (ret) {
                 qib_early_err(&pdev->dev,
                               "Unable to enable pcie error reporting: %d\n",
                               ret);
+                ret = 0;
+        }
         goto done;
 
 bail:
@@ -522,11 +526,8 @@ static int qib_tune_pcie_coalesce(struct qib_devdata *dd)
          */
         devid = parent->device;
         if (devid >= 0x25e2 && devid <= 0x25fa) {
-                u8 rev;
-
                 /* 5000 P/V/X/Z */
-                pci_read_config_byte(parent, PCI_REVISION_ID, &rev);
-                if (rev <= 0xb2)
+                if (parent->revision <= 0xb2)
                         bits = 1U << 10;
                 else
                         bits = 7U << 10;
diff --git a/drivers/infiniband/hw/qib/qib_qp.c b/drivers/infiniband/hw/qib/qib_qp.c
index 6c39851d2ded..e16751f8639e 100644
--- a/drivers/infiniband/hw/qib/qib_qp.c
+++ b/drivers/infiniband/hw/qib/qib_qp.c
@@ -48,13 +48,12 @@ static inline unsigned mk_qpn(struct qib_qpn_table *qpt,
 
 static inline unsigned find_next_offset(struct qib_qpn_table *qpt,
                                         struct qpn_map *map, unsigned off,
-                                        unsigned r)
+                                        unsigned n)
 {
         if (qpt->mask) {
                 off++;
-                if ((off & qpt->mask) >> 1 != r)
-                        off = ((off & qpt->mask) ?
-                                (off | qpt->mask) + 1 : off) | (r << 1);
+                if (((off & qpt->mask) >> 1) >= n)
+                        off = (off | qpt->mask) + 2;
         } else
                 off = find_next_zero_bit(map->page, BITS_PER_PAGE, off);
         return off;
@@ -123,7 +122,6 @@ static int alloc_qpn(struct qib_devdata *dd, struct qib_qpn_table *qpt,
         u32 i, offset, max_scan, qpn;
         struct qpn_map *map;
         u32 ret;
-        int r;
 
         if (type == IB_QPT_SMI || type == IB_QPT_GSI) {
                 unsigned n;
@@ -139,15 +137,11 @@ static int alloc_qpn(struct qib_devdata *dd, struct qib_qpn_table *qpt,
                 goto bail;
         }
 
-        r = smp_processor_id();
-        if (r >= dd->n_krcv_queues)
-                r %= dd->n_krcv_queues;
-        qpn = qpt->last + 1;
+        qpn = qpt->last + 2;
         if (qpn >= QPN_MAX)
                 qpn = 2;
-        if (qpt->mask && ((qpn & qpt->mask) >> 1) != r)
-                qpn = ((qpn & qpt->mask) ? (qpn | qpt->mask) + 1 : qpn) |
-                        (r << 1);
+        if (qpt->mask && ((qpn & qpt->mask) >> 1) >= dd->n_krcv_queues)
+                qpn = (qpn | qpt->mask) + 2;
         offset = qpn & BITS_PER_PAGE_MASK;
         map = &qpt->map[qpn / BITS_PER_PAGE];
         max_scan = qpt->nmaps - !offset;
@@ -163,7 +157,8 @@ static int alloc_qpn(struct qib_devdata *dd, struct qib_qpn_table *qpt,
                                 ret = qpn;
                                 goto bail;
                         }
-                        offset = find_next_offset(qpt, map, offset, r);
+                        offset = find_next_offset(qpt, map, offset,
+                                dd->n_krcv_queues);
                         qpn = mk_qpn(qpt, map, offset);
                         /*
                          * This test differs from alloc_pidmap().
@@ -183,13 +178,13 @@ static int alloc_qpn(struct qib_devdata *dd, struct qib_qpn_table *qpt,
                         if (qpt->nmaps == QPNMAP_ENTRIES)
                                 break;
                         map = &qpt->map[qpt->nmaps++];
-                        offset = qpt->mask ? (r << 1) : 0;
+                        offset = 0;
                 } else if (map < &qpt->map[qpt->nmaps]) {
                         ++map;
-                        offset = qpt->mask ? (r << 1) : 0;
+                        offset = 0;
                 } else {
                         map = &qpt->map[0];
-                        offset = qpt->mask ? (r << 1) : 2;
+                        offset = 2;
                 }
                 qpn = mk_qpn(qpt, map, offset);
         }
@@ -468,6 +463,10 @@ int qib_error_qp(struct qib_qp *qp, enum ib_wc_status err)
                 qp->s_flags &= ~(QIB_S_TIMER | QIB_S_WAIT_RNR);
                 del_timer(&qp->s_timer);
         }
+
+        if (qp->s_flags & QIB_S_ANY_WAIT_SEND)
+                qp->s_flags &= ~QIB_S_ANY_WAIT_SEND;
+
         spin_lock(&dev->pending_lock);
         if (!list_empty(&qp->iowait) && !(qp->s_flags & QIB_S_BUSY)) {
                 qp->s_flags &= ~QIB_S_ANY_WAIT_IO;
@@ -1061,7 +1060,6 @@ struct ib_qp *qib_create_qp(struct ib_pd *ibpd,
                 }
                 qp->ibqp.qp_num = err;
                 qp->port_num = init_attr->port_num;
-                qp->processor_id = smp_processor_id();
                 qib_reset_qp(qp, init_attr->qp_type);
                 break;
 
diff --git a/drivers/infiniband/hw/qib/qib_qsfp.c b/drivers/infiniband/hw/qib/qib_qsfp.c
index 35b3604b691d..3374a52232c1 100644
--- a/drivers/infiniband/hw/qib/qib_qsfp.c
+++ b/drivers/infiniband/hw/qib/qib_qsfp.c
@@ -485,7 +485,7 @@ void qib_qsfp_init(struct qib_qsfp_data *qd,
                 goto bail;
         /* We see a module, but it may be unwise to look yet. Just schedule */
         qd->t_insert = get_jiffies_64();
-        schedule_work(&qd->work);
+        queue_work(ib_wq, &qd->work);
 bail:
         return;
 }
@@ -493,10 +493,9 @@ bail:
 void qib_qsfp_deinit(struct qib_qsfp_data *qd)
 {
         /*
-         * There is nothing to do here for now.  our
-         * work is scheduled with schedule_work(), and
-         * flush_scheduled_work() from remove_one will
-         * block until all work ssetup with schedule_work()
+         * There is nothing to do here for now.  our work is scheduled
+         * with queue_work(), and flush_workqueue() from remove_one
+         * will block until all work setup with queue_work()
          * completes.
          */
 }
diff --git a/drivers/infiniband/hw/qib/qib_qsfp.h b/drivers/infiniband/hw/qib/qib_qsfp.h
index 19b527bafd57..c109bbdc90ac 100644
--- a/drivers/infiniband/hw/qib/qib_qsfp.h
+++ b/drivers/infiniband/hw/qib/qib_qsfp.h
@@ -79,6 +79,8 @@
 extern const char *const qib_qsfp_devtech[16];
 /* Active Equalization includes fiber, copper full EQ, and copper near Eq */
 #define QSFP_IS_ACTIVE(tech) ((0xA2FF >> ((tech) >> 4)) & 1)
+/* Active Equalization includes fiber, copper full EQ, and copper far Eq */
+#define QSFP_IS_ACTIVE_FAR(tech) ((0x32FF >> ((tech) >> 4)) & 1)
 /* Attenuation should be valid for copper other than full/near Eq */
 #define QSFP_HAS_ATTEN(tech) ((0x4D00 >> ((tech) >> 4)) & 1)
 /* Length is only valid if technology is "copper" */
diff --git a/drivers/infiniband/hw/qib/qib_rc.c b/drivers/infiniband/hw/qib/qib_rc.c
index a0931119bd78..eca0c41f1226 100644
--- a/drivers/infiniband/hw/qib/qib_rc.c
+++ b/drivers/infiniband/hw/qib/qib_rc.c
@@ -1005,7 +1005,8 @@ void qib_rc_send_complete(struct qib_qp *qp, struct qib_ib_header *hdr)
          * there are still requests that haven't been acked.
          */
         if ((psn & IB_BTH_REQ_ACK) && qp->s_acked != qp->s_tail &&
-            !(qp->s_flags & (QIB_S_TIMER | QIB_S_WAIT_RNR | QIB_S_WAIT_PSN)))
+            !(qp->s_flags & (QIB_S_TIMER | QIB_S_WAIT_RNR | QIB_S_WAIT_PSN)) &&
+            (ib_qib_state_ops[qp->state] & QIB_PROCESS_RECV_OK))
                 start_timer(qp);
 
         while (qp->s_last != qp->s_acked) {
@@ -1407,6 +1408,7 @@ static void qib_rc_rcv_resp(struct qib_ibport *ibp,
                             struct qib_ctxtdata *rcd)
 {
         struct qib_swqe *wqe;
+        struct qib_pportdata *ppd = ppd_from_ibp(ibp);
         enum ib_wc_status status;
         unsigned long flags;
         int diff;
@@ -1414,7 +1416,32 @@ static void qib_rc_rcv_resp(struct qib_ibport *ibp,
         u32 aeth;
         u64 val;
 
+        if (opcode != OP(RDMA_READ_RESPONSE_MIDDLE)) {
+                /*
+                 * If ACK'd PSN on SDMA busy list try to make progress to
+                 * reclaim SDMA credits.
+                 */
+                if ((qib_cmp24(psn, qp->s_sending_psn) >= 0) &&
+                    (qib_cmp24(qp->s_sending_psn, qp->s_sending_hpsn) <= 0)) {
+
+                        /*
+                         * If send tasklet not running attempt to progress
+                         * SDMA queue.
+                         */
+                        if (!(qp->s_flags & QIB_S_BUSY)) {
+                                /* Acquire SDMA Lock */
+                                spin_lock_irqsave(&ppd->sdma_lock, flags);
+                                /* Invoke sdma make progress */
+                                qib_sdma_make_progress(ppd);
+                                /* Release SDMA Lock */
+                                spin_unlock_irqrestore(&ppd->sdma_lock, flags);
+                        }
+                }
+        }
+
         spin_lock_irqsave(&qp->s_lock, flags);
+        if (!(ib_qib_state_ops[qp->state] & QIB_PROCESS_RECV_OK))
+                goto ack_done;
 
         /* Ignore invalid responses. */
         if (qib_cmp24(psn, qp->s_next_psn) >= 0)
@@ -2068,7 +2095,10 @@ send_last:
                         goto nack_op_err;
                 if (!ret)
                         goto rnr_nak;
-                goto send_last_imm;
+                wc.ex.imm_data = ohdr->u.rc.imm_data;
+                hdrsize += 4;
+                wc.wc_flags = IB_WC_WITH_IMM;
+                goto send_last;
 
         case OP(RDMA_READ_REQUEST): {
                 struct qib_ack_entry *e;
diff --git a/drivers/infiniband/hw/qib/qib_twsi.c b/drivers/infiniband/hw/qib/qib_twsi.c
index 6f31ca5039db..ddde72e11edb 100644
--- a/drivers/infiniband/hw/qib/qib_twsi.c
+++ b/drivers/infiniband/hw/qib/qib_twsi.c
@@ -41,7 +41,7 @@
  * QLogic_IB "Two Wire Serial Interface" driver.
  * Originally written for a not-quite-i2c serial eeprom, which is
  * still used on some supported boards. Later boards have added a
- * variety of other uses, most board-specific, so teh bit-boffing
+ * variety of other uses, most board-specific, so the bit-boffing
  * part has been split off to this file, while the other parts
  * have been moved to chip-specific files.
  *
diff --git a/drivers/infiniband/hw/qib/qib_uc.c b/drivers/infiniband/hw/qib/qib_uc.c
index b9c8b6346c1b..32ccf3c824ca 100644
--- a/drivers/infiniband/hw/qib/qib_uc.c
+++ b/drivers/infiniband/hw/qib/qib_uc.c
@@ -457,8 +457,10 @@ rdma_first:
                 }
                 if (opcode == OP(RDMA_WRITE_ONLY))
                         goto rdma_last;
-                else if (opcode == OP(RDMA_WRITE_ONLY_WITH_IMMEDIATE))
+                else if (opcode == OP(RDMA_WRITE_ONLY_WITH_IMMEDIATE)) {
+                        wc.ex.imm_data = ohdr->u.rc.imm_data;
                         goto rdma_last_imm;
+                }
                 /* FALLTHROUGH */
         case OP(RDMA_WRITE_MIDDLE):
                 /* Check for invalid length PMTU or posted rwqe len. */
@@ -471,8 +473,8 @@ rdma_first:
                 break;
 
         case OP(RDMA_WRITE_LAST_WITH_IMMEDIATE):
-rdma_last_imm:
                 wc.ex.imm_data = ohdr->u.imm_data;
+rdma_last_imm:
                 hdrsize += 4;
                 wc.wc_flags = IB_WC_WITH_IMM;
 
diff --git a/drivers/infiniband/hw/qib/qib_ud.c b/drivers/infiniband/hw/qib/qib_ud.c
index e1b3da2a1f85..828609fa4d28 100644
--- a/drivers/infiniband/hw/qib/qib_ud.c
+++ b/drivers/infiniband/hw/qib/qib_ud.c
@@ -116,7 +116,7 @@ static void qib_ud_loopback(struct qib_qp *sqp, struct qib_swqe *swqe)
         }
 
         /*
-         * A GRH is expected to preceed the data even if not
+         * A GRH is expected to precede the data even if not
          * present on the wire.
          */
         length = swqe->length;
@@ -445,13 +445,14 @@ void qib_ud_rcv(struct qib_ibport *ibp, struct qib_ib_header *hdr,
         qkey = be32_to_cpu(ohdr->u.ud.deth[0]);
         src_qp = be32_to_cpu(ohdr->u.ud.deth[1]) & QIB_QPN_MASK;
 
-        /* Get the number of bytes the message was padded by. */
+        /*
+         * Get the number of bytes the message was padded by
+         * and drop incomplete packets.
+         */
         pad = (be32_to_cpu(ohdr->bth[0]) >> 20) & 3;
-        if (unlikely(tlen < (hdrsize + pad + 4))) {
-                /* Drop incomplete packets. */
-                ibp->n_pkt_drops++;
-                goto bail;
-        }
+        if (unlikely(tlen < (hdrsize + pad + 4)))
+                goto drop;
+
         tlen -= hdrsize + pad + 4;
 
         /*
@@ -460,10 +461,8 @@ void qib_ud_rcv(struct qib_ibport *ibp, struct qib_ib_header *hdr,
          */
         if (qp->ibqp.qp_num) {
                 if (unlikely(hdr->lrh[1] == IB_LID_PERMISSIVE ||
-                             hdr->lrh[3] == IB_LID_PERMISSIVE)) {
-                        ibp->n_pkt_drops++;
-                        goto bail;
-                }
+                             hdr->lrh[3] == IB_LID_PERMISSIVE))
+                        goto drop;
                 if (qp->ibqp.qp_num > 1) {
                         u16 pkey1, pkey2;
 
@@ -476,7 +475,7 @@ void qib_ud_rcv(struct qib_ibport *ibp, struct qib_ib_header *hdr,
                                                 0xF,
                                               src_qp, qp->ibqp.qp_num,
                                               hdr->lrh[3], hdr->lrh[1]);
-                                goto bail;
+                                return;
                         }
                 }
                 if (unlikely(qkey != qp->qkey)) {
@@ -484,30 +483,24 @@ void qib_ud_rcv(struct qib_ibport *ibp, struct qib_ib_header *hdr,
                                       (be16_to_cpu(hdr->lrh[0]) >> 4) & 0xF,
                                       src_qp, qp->ibqp.qp_num,
                                       hdr->lrh[3], hdr->lrh[1]);
-                        goto bail;
+                        return;
                 }
                 /* Drop invalid MAD packets (see 13.5.3.1). */
                 if (unlikely(qp->ibqp.qp_num == 1 &&
                              (tlen != 256 ||
-                              (be16_to_cpu(hdr->lrh[0]) >> 12) == 15))) {
-                        ibp->n_pkt_drops++;
-                        goto bail;
-                }
+                              (be16_to_cpu(hdr->lrh[0]) >> 12) == 15)))
+                        goto drop;
         } else {
                 struct ib_smp *smp;
 
                 /* Drop invalid MAD packets (see 13.5.3.1). */
-                if (tlen != 256 || (be16_to_cpu(hdr->lrh[0]) >> 12) != 15) {
-                        ibp->n_pkt_drops++;
-                        goto bail;
-                }
+                if (tlen != 256 || (be16_to_cpu(hdr->lrh[0]) >> 12) != 15)
+                        goto drop;
                 smp = (struct ib_smp *) data;
                 if ((hdr->lrh[1] == IB_LID_PERMISSIVE ||
                      hdr->lrh[3] == IB_LID_PERMISSIVE) &&
-                    smp->mgmt_class != IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE) {
-                        ibp->n_pkt_drops++;
-                        goto bail;
-                }
+                    smp->mgmt_class != IB_MGMT_CLASS_SUBN_DIRECTED_ROUTE)
+                        goto drop;
         }
 
         /*
@@ -519,17 +512,15 @@ void qib_ud_rcv(struct qib_ibport *ibp, struct qib_ib_header *hdr,
             opcode == IB_OPCODE_UD_SEND_ONLY_WITH_IMMEDIATE) {
                 wc.ex.imm_data = ohdr->u.ud.imm_data;
                 wc.wc_flags = IB_WC_WITH_IMM;
-                hdrsize += sizeof(u32);
+                tlen -= sizeof(u32);
         } else if (opcode == IB_OPCODE_UD_SEND_ONLY) {
                 wc.ex.imm_data = 0;
                 wc.wc_flags = 0;
-        } else {
-                ibp->n_pkt_drops++;
-                goto bail;
-        }
+        } else
+                goto drop;
 
         /*
-         * A GRH is expected to preceed the data even if not
+         * A GRH is expected to precede the data even if not
          * present on the wire.
          */
         wc.byte_len = tlen + sizeof(struct ib_grh);
@@ -556,8 +547,7 @@ void qib_ud_rcv(struct qib_ibport *ibp, struct qib_ib_header *hdr,
         /* Silently drop packets which are too big. */
         if (unlikely(wc.byte_len > qp->r_len)) {
                 qp->r_flags |= QIB_R_REUSE_SGE;
-                ibp->n_pkt_drops++;
-                return;
+                goto drop;
         }
         if (has_grh) {
                 qib_copy_sge(&qp->r_sge, &hdr->u.l.grh,
@@ -594,5 +584,8 @@ void qib_ud_rcv(struct qib_ibport *ibp, struct qib_ib_header *hdr,
         qib_cq_enter(to_icq(qp->ibqp.recv_cq), &wc,
                      (ohdr->bth[0] &
                         cpu_to_be32(IB_BTH_SOLICITED)) != 0);
-bail:;
+        return;
+
+drop:
+        ibp->n_pkt_drops++;
 }
diff --git a/drivers/infiniband/hw/qib/qib_user_pages.c b/drivers/infiniband/hw/qib/qib_user_pages.c
index d7a26c1d4f37..7689e49c13c9 100644
--- a/drivers/infiniband/hw/qib/qib_user_pages.c
+++ b/drivers/infiniband/hw/qib/qib_user_pages.c
@@ -51,8 +51,8 @@ static void __qib_release_user_pages(struct page **p, size_t num_pages,
 /*
  * Call with current->mm->mmap_sem held.
  */
-static int __get_user_pages(unsigned long start_page, size_t num_pages,
-                            struct page **p, struct vm_area_struct **vma)
+static int __qib_get_user_pages(unsigned long start_page, size_t num_pages,
+                                struct page **p, struct vm_area_struct **vma)
 {
         unsigned long lock_limit;
         size_t got;
@@ -136,7 +136,7 @@ int qib_get_user_pages(unsigned long start_page, size_t num_pages,
 
         down_write(&current->mm->mmap_sem);
 
-        ret = __get_user_pages(start_page, num_pages, p, NULL);
+        ret = __qib_get_user_pages(start_page, num_pages, p, NULL);
 
         up_write(&current->mm->mmap_sem);
 
diff --git a/drivers/infiniband/hw/qib/qib_user_sdma.c b/drivers/infiniband/hw/qib/qib_user_sdma.c
index 4c19e06b5e85..82442085cbe6 100644
--- a/drivers/infiniband/hw/qib/qib_user_sdma.c
+++ b/drivers/infiniband/hw/qib/qib_user_sdma.c
@@ -239,7 +239,7 @@ static int qib_user_sdma_num_pages(const struct iovec *iov)
 }
 
 /*
- * Truncate length to page boundry.
+ * Truncate length to page boundary.
  */
 static int qib_user_sdma_page_length(unsigned long addr, unsigned long len)
 {
@@ -382,6 +382,7 @@ static void qib_user_sdma_free_pkt_list(struct device *dev,
 
                 kmem_cache_free(pq->pkt_slab, pkt);
         }
+        INIT_LIST_HEAD(list);
 }
 
 /*
diff --git a/drivers/infiniband/hw/qib/qib_verbs.h b/drivers/infiniband/hw/qib/qib_verbs.h
index bd57c1273225..95e5b47223b3 100644
--- a/drivers/infiniband/hw/qib/qib_verbs.h
+++ b/drivers/infiniband/hw/qib/qib_verbs.h
@@ -301,6 +301,7 @@ struct qib_mregion {
         int access_flags;
         u32 max_segs;           /* number of qib_segs in all the arrays */
         u32 mapsz;              /* size of the map array */
+        u8  page_shift;         /* 0 - non unform/non powerof2 sizes */
         atomic_t refcount;
         struct qib_segarray *map[0];    /* the segments */
 };
@@ -435,7 +436,6 @@ struct qib_qp {
         spinlock_t r_lock;      /* used for APM */
         spinlock_t s_lock;
         atomic_t s_dma_busy;
-        unsigned processor_id;  /* Processor ID QP is bound to */
         u32 s_flags;
         u32 s_cur_size;         /* size of send packet in bytes */
         u32 s_len;              /* total length of s_sge */
@@ -805,7 +805,6 @@ static inline int qib_send_ok(struct qib_qp *qp)
                  !(qp->s_flags & QIB_S_ANY_WAIT_SEND));
 }
 
-extern struct workqueue_struct *qib_wq;
 extern struct workqueue_struct *qib_cq_wq;
 
 /*
@@ -813,13 +812,8 @@ extern struct workqueue_struct *qib_cq_wq;
  */
 static inline void qib_schedule_send(struct qib_qp *qp)
 {
-        if (qib_send_ok(qp)) {
-                if (qp->processor_id == smp_processor_id())
-                        queue_work(qib_wq, &qp->s_work);
-                else
-                        queue_work_on(qp->processor_id,
-                                      qib_wq, &qp->s_work);
-        }
+        if (qib_send_ok(qp))
+                queue_work(ib_wq, &qp->s_work);
 }
 
 static inline int qib_pkey_ok(u16 pkey1, u16 pkey2)