Merge ../linux-2.6

21 files changed, 348 insertions, 313 deletions

diff --git a/drivers/infiniband/hw/ipath/ipath_debug.h b/drivers/infiniband/hw/ipath/ipath_debug.h
index 593e28969c69..46762387f5f8 100644
--- a/drivers/infiniband/hw/ipath/ipath_debug.h
+++ b/drivers/infiniband/hw/ipath/ipath_debug.h
@@ -60,11 +60,11 @@
 #define __IPATH_KERNEL_SEND 0x2000      /* use kernel mode send */
 #define __IPATH_EPKTDBG     0x4000      /* print ethernet packet data */
 #define __IPATH_SMADBG      0x8000      /* sma packet debug */
-#define __IPATH_IPATHDBG    0x10000     /* Ethernet (IPATH) general debug on */
-#define __IPATH_IPATHWARN   0x20000     /* Ethernet (IPATH) warnings on */
-#define __IPATH_IPATHERR    0x40000     /* Ethernet (IPATH) errors on */
-#define __IPATH_IPATHPD     0x80000     /* Ethernet (IPATH) packet dump on */
-#define __IPATH_IPATHTABLE  0x100000    /* Ethernet (IPATH) table dump on */
+#define __IPATH_IPATHDBG    0x10000     /* Ethernet (IPATH) gen debug */
+#define __IPATH_IPATHWARN   0x20000     /* Ethernet (IPATH) warnings */
+#define __IPATH_IPATHERR    0x40000     /* Ethernet (IPATH) errors */
+#define __IPATH_IPATHPD     0x80000     /* Ethernet (IPATH) packet dump */
+#define __IPATH_IPATHTABLE  0x100000    /* Ethernet (IPATH) table dump */
 
 #else                           /* _IPATH_DEBUGGING */
 
@@ -79,11 +79,12 @@
 #define __IPATH_TRSAMPLE  0x0   /* generate trace buffer sample entries */
 #define __IPATH_VERBDBG   0x0   /* very verbose debug */
 #define __IPATH_PKTDBG    0x0   /* print packet data */
-#define __IPATH_PROCDBG   0x0   /* print process startup (init)/exit messages */
+#define __IPATH_PROCDBG   0x0   /* process startup (init)/exit messages */
 /* print mmap/nopage stuff, not using VDBG any more */
 #define __IPATH_MMDBG     0x0
 #define __IPATH_EPKTDBG   0x0   /* print ethernet packet data */
-#define __IPATH_SMADBG    0x0   /* print process startup (init)/exit messages */#define __IPATH_IPATHDBG  0x0   /* Ethernet (IPATH) table dump on */
+#define __IPATH_SMADBG    0x0   /* process startup (init)/exit messages */
+#define __IPATH_IPATHDBG  0x0   /* Ethernet (IPATH) table dump on */
 #define __IPATH_IPATHWARN 0x0   /* Ethernet (IPATH) warnings on   */
 #define __IPATH_IPATHERR  0x0   /* Ethernet (IPATH) errors on   */
 #define __IPATH_IPATHPD   0x0   /* Ethernet (IPATH) packet dump on   */
diff --git a/drivers/infiniband/hw/ipath/ipath_diag.c b/drivers/infiniband/hw/ipath/ipath_diag.c
index cd533cf951c2..28ddceb260e8 100644
--- a/drivers/infiniband/hw/ipath/ipath_diag.c
+++ b/drivers/infiniband/hw/ipath/ipath_diag.c
@@ -277,13 +277,14 @@ static int ipath_diag_open(struct inode *in, struct file *fp)
 
 bail:
         spin_unlock_irqrestore(&ipath_devs_lock, flags);
-        mutex_unlock(&ipath_mutex);
 
         /* Only expose a way to reset the device if we
            make it into diag mode. */
         if (ret == 0)
                 ipath_expose_reset(&dd->pcidev->dev);
 
+        mutex_unlock(&ipath_mutex);
+
         return ret;
 }
 
@@ -365,15 +366,3 @@ static ssize_t ipath_diag_write(struct file *fp, const char __user *data,
 bail:
         return ret;
 }
-
-void ipath_diag_bringup_link(struct ipath_devdata *dd)
-{
-        if (diag_set_link || (dd->ipath_flags & IPATH_LINKACTIVE))
-                return;
-
-        diag_set_link = 1;
-        ipath_cdbg(VERBOSE, "Trying to set to set link active for "
-                   "diag pkt\n");
-        ipath_layer_set_linkstate(dd, IPATH_IB_LINKARM);
-        ipath_layer_set_linkstate(dd, IPATH_IB_LINKACTIVE);
-}
diff --git a/drivers/infiniband/hw/ipath/ipath_driver.c b/drivers/infiniband/hw/ipath/ipath_driver.c
index 58a94efb0070..dddcdae736ac 100644
--- a/drivers/infiniband/hw/ipath/ipath_driver.c
+++ b/drivers/infiniband/hw/ipath/ipath_driver.c
@@ -116,10 +116,9 @@ static int __devinit ipath_init_one(struct pci_dev *,
 #define PCI_DEVICE_ID_INFINIPATH_PE800 0x10
 
 static const struct pci_device_id ipath_pci_tbl[] = {
-        {PCI_DEVICE(PCI_VENDOR_ID_PATHSCALE,
-                    PCI_DEVICE_ID_INFINIPATH_HT)},
-        {PCI_DEVICE(PCI_VENDOR_ID_PATHSCALE,
-                    PCI_DEVICE_ID_INFINIPATH_PE800)},
+        { PCI_DEVICE(PCI_VENDOR_ID_PATHSCALE, PCI_DEVICE_ID_INFINIPATH_HT) },
+        { PCI_DEVICE(PCI_VENDOR_ID_PATHSCALE, PCI_DEVICE_ID_INFINIPATH_PE800) },
+        { 0, }
 };
 
 MODULE_DEVICE_TABLE(pci, ipath_pci_tbl);
@@ -418,9 +417,19 @@ static int __devinit ipath_init_one(struct pci_dev *pdev,
 
         ret = pci_set_dma_mask(pdev, DMA_64BIT_MASK);
         if (ret) {
-                dev_info(&pdev->dev, "pci_set_dma_mask unit %u "
-                         "fails: %d\n", dd->ipath_unit, ret);
-                goto bail_regions;
+                /*
+                 * if the 64 bit setup fails, try 32 bit.  Some systems
+                 * do not setup 64 bit maps on systems with 2GB or less
+                 * memory installed.
+                 */
+                ret = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
+                if (ret) {
+                        dev_info(&pdev->dev, "pci_set_dma_mask unit %u "
+                                 "fails: %d\n", dd->ipath_unit, ret);
+                        goto bail_regions;
+                }
+                else
+                        ipath_dbg("No 64bit DMA mask, used 32 bit mask\n");
         }
 
         pci_set_master(pdev);
@@ -1729,7 +1738,7 @@ void ipath_free_pddata(struct ipath_devdata *dd, u32 port, int freehdrq)
         }
 }
 
-int __init infinipath_init(void)
+static int __init infinipath_init(void)
 {
         int ret;
 
@@ -1896,19 +1905,19 @@ static void __exit infinipath_cleanup(void)
                         } else
                                 ipath_dbg("irq is 0, not doing free_irq "
                                           "for unit %u\n", dd->ipath_unit);
-                        dd->pcidev = NULL;
-                }
 
-                /*
-                 * we check for NULL here, because it's outside the kregbase
-                 * check, and we need to call it after the free_irq.  Thus
-                 * it's possible that the function pointers were never
-                 * initialized.
-                 */
-                if (dd->ipath_f_cleanup)
-                        /* clean up chip-specific stuff */
-                        dd->ipath_f_cleanup(dd);
+                        /*
+                         * we check for NULL here, because it's outside
+                         * the kregbase check, and we need to call it
+                         * after the free_irq.  Thus it's possible that
+                         * the function pointers were never initialized.
+                         */
+                        if (dd->ipath_f_cleanup)
+                                /* clean up chip-specific stuff */
+                                dd->ipath_f_cleanup(dd);
 
+                        dd->pcidev = NULL;
+                }
                 spin_lock_irqsave(&ipath_devs_lock, flags);
         }
 
@@ -1949,7 +1958,7 @@ int ipath_reset_device(int unit)
         }
 
         if (dd->ipath_pd)
-                for (i = 1; i < dd->ipath_portcnt; i++) {
+                for (i = 1; i < dd->ipath_cfgports; i++) {
                         if (dd->ipath_pd[i] && dd->ipath_pd[i]->port_cnt) {
                                 ipath_dbg("unit %u port %d is in use "
                                           "(PID %u cmd %s), can't reset\n",
diff --git a/drivers/infiniband/hw/ipath/ipath_eeprom.c b/drivers/infiniband/hw/ipath/ipath_eeprom.c
index f11a900e8cd7..a2f1ceafcca9 100644
--- a/drivers/infiniband/hw/ipath/ipath_eeprom.c
+++ b/drivers/infiniband/hw/ipath/ipath_eeprom.c
@@ -505,11 +505,10 @@ static u8 flash_csum(struct ipath_flash *ifp, int adjust)
  * ipath_get_guid - get the GUID from the i2c device
  * @dd: the infinipath device
  *
- * When we add the multi-chip support, we will probably have to add
- * the ability to use the number of guids field, and get the guid from
- * the first chip's flash, to use for all of them.
+ * We have the capability to use the ipath_nguid field, and get
+ * the guid from the first chip's flash, to use for all of them.
  */
-void ipath_get_guid(struct ipath_devdata *dd)
+void ipath_get_eeprom_info(struct ipath_devdata *dd)
 {
         void *buf;
         struct ipath_flash *ifp;
diff --git a/drivers/infiniband/hw/ipath/ipath_file_ops.c b/drivers/infiniband/hw/ipath/ipath_file_ops.c
index c347191f02bf..ada267e41f6c 100644
--- a/drivers/infiniband/hw/ipath/ipath_file_ops.c
+++ b/drivers/infiniband/hw/ipath/ipath_file_ops.c
@@ -139,7 +139,7 @@ static int ipath_get_base_info(struct ipath_portdata *pd,
         kinfo->spi_piosize = dd->ipath_ibmaxlen;
         kinfo->spi_mtu = dd->ipath_ibmaxlen;    /* maxlen, not ibmtu */
         kinfo->spi_port = pd->port_port;
-        kinfo->spi_sw_version = IPATH_USER_SWVERSION;
+        kinfo->spi_sw_version = IPATH_KERN_SWVERSION;
         kinfo->spi_hw_version = dd->ipath_revision;
 
         if (copy_to_user(ubase, kinfo, sizeof(*kinfo)))
@@ -1224,6 +1224,10 @@ static unsigned int ipath_poll(struct file *fp,
 
         if (tail == head) {
                 set_bit(IPATH_PORT_WAITING_RCV, &pd->port_flag);
+                if(dd->ipath_rhdrhead_intr_off) /* arm rcv interrupt */
+                        (void)ipath_write_ureg(dd, ur_rcvhdrhead,
+                                               dd->ipath_rhdrhead_intr_off
+                                               | head, pd->port_port);
                 poll_wait(fp, &pd->port_wait, pt);
 
                 if (test_bit(IPATH_PORT_WAITING_RCV, &pd->port_flag)) {
diff --git a/drivers/infiniband/hw/ipath/ipath_ht400.c b/drivers/infiniband/hw/ipath/ipath_ht400.c
index 4652435998f3..fac0a2b74de2 100644
--- a/drivers/infiniband/hw/ipath/ipath_ht400.c
+++ b/drivers/infiniband/hw/ipath/ipath_ht400.c
@@ -607,7 +607,12 @@ static int ipath_ht_boardname(struct ipath_devdata *dd, char *name,
         case 4:         /* Ponderosa is one of the bringup boards */
                 n = "Ponderosa";
                 break;
-        case 5:         /* HT-460 original production board */
+        case 5:
+                /*
+                 * HT-460 original production board; two production levels, with
+                 * different serial number ranges.   See ipath_ht_early_init() for
+                 * case where we enable IPATH_GPIO_INTR for later serial # range.
+                 */
                 n = "InfiniPath_HT-460";
                 break;
         case 6:
@@ -642,7 +647,7 @@ static int ipath_ht_boardname(struct ipath_devdata *dd, char *name,
         if (n)
                 snprintf(name, namelen, "%s", n);
 
-        if (dd->ipath_majrev != 3 || dd->ipath_minrev != 2) {
+        if (dd->ipath_majrev != 3 || (dd->ipath_minrev < 2 || dd->ipath_minrev > 3)) {
                 /*
                  * This version of the driver only supports the HT-400
                  * Rev 3.2
@@ -1520,6 +1525,18 @@ static int ipath_ht_early_init(struct ipath_devdata *dd)
          */
         ipath_write_kreg(dd, dd->ipath_kregs->kr_sendctrl,
                          INFINIPATH_S_ABORT);
+
+        ipath_get_eeprom_info(dd);
+        if(dd->ipath_boardrev == 5 && dd->ipath_serial[0] == '1' &&
+                dd->ipath_serial[1] == '2' && dd->ipath_serial[2] == '8') {
+                /*
+                 * Later production HT-460 has same changes as HT-465, so
+                 * can use GPIO interrupts.  They have serial #'s starting
+                 * with 128, rather than 112.
+                 */
+                dd->ipath_flags |= IPATH_GPIO_INTR;
+                dd->ipath_flags &= ~IPATH_POLL_RX_INTR;
+        }
         return 0;
 }
 
diff --git a/drivers/infiniband/hw/ipath/ipath_init_chip.c b/drivers/infiniband/hw/ipath/ipath_init_chip.c
index 2823ff9c0c62..dc83250d26a6 100644
--- a/drivers/infiniband/hw/ipath/ipath_init_chip.c
+++ b/drivers/infiniband/hw/ipath/ipath_init_chip.c
@@ -53,13 +53,19 @@ MODULE_PARM_DESC(cfgports, "Set max number of ports to use");
 
 /*
  * Number of buffers reserved for driver (layered drivers and SMA
- * send).  Reserved at end of buffer list.
+ * send).  Reserved at end of buffer list.   Initialized based on
+ * number of PIO buffers if not set via module interface.
+ * The problem with this is that it's global, but we'll use different
+ * numbers for different chip types.  So the default value is not
+ * very useful.  I've redefined it for the 1.3 release so that it's
+ * zero unless set by the user to something else, in which case we
+ * try to respect it.
  */
-static ushort ipath_kpiobufs = 32;
+static ushort ipath_kpiobufs;
 
 static int ipath_set_kpiobufs(const char *val, struct kernel_param *kp);
 
-module_param_call(kpiobufs, ipath_set_kpiobufs, param_get_uint,
+module_param_call(kpiobufs, ipath_set_kpiobufs, param_get_ushort,
                   &ipath_kpiobufs, S_IWUSR | S_IRUGO);
 MODULE_PARM_DESC(kpiobufs, "Set number of PIO buffers for driver");
 
@@ -531,8 +537,11 @@ static int init_housekeeping(struct ipath_devdata *dd,
          * Don't clear ipath_flags as 8bit mode was set before
          * entering this func. However, we do set the linkstate to
          * unknown, so we can watch for a transition.
+         * PRESENT is set because we want register reads to work,
+         * and the kernel infrastructure saw it in config space;
+         * We clear it if we have failures.
          */
-        dd->ipath_flags |= IPATH_LINKUNK;
+        dd->ipath_flags |= IPATH_LINKUNK | IPATH_PRESENT;
         dd->ipath_flags &= ~(IPATH_LINKACTIVE | IPATH_LINKARMED |
                              IPATH_LINKDOWN | IPATH_LINKINIT);
 
@@ -560,6 +569,7 @@ static int init_housekeeping(struct ipath_devdata *dd,
             || (dd->ipath_uregbase & 0xffffffff) == 0xffffffff) {
                 ipath_dev_err(dd, "Register read failures from chip, "
                               "giving up initialization\n");
+                dd->ipath_flags &= ~IPATH_PRESENT;
                 ret = -ENODEV;
                 goto done;
         }
@@ -682,16 +692,14 @@ int ipath_init_chip(struct ipath_devdata *dd, int reinit)
          */
         dd->ipath_pioavregs = ALIGN(val, sizeof(u64) * BITS_PER_BYTE / 2)
                 / (sizeof(u64) * BITS_PER_BYTE / 2);
-        if (!ipath_kpiobufs)    /* have to have at least 1, for SMA */
-                kpiobufs = ipath_kpiobufs = 1;
-        else if ((dd->ipath_piobcnt2k + dd->ipath_piobcnt4k) <
-                 (dd->ipath_cfgports * IPATH_MIN_USER_PORT_BUFCNT)) {
-                dev_info(&dd->pcidev->dev, "Too few PIO buffers (%u) "
-                         "for %u ports to have %u each!\n",
-                         dd->ipath_piobcnt2k + dd->ipath_piobcnt4k,
-                         dd->ipath_cfgports, IPATH_MIN_USER_PORT_BUFCNT);
-                kpiobufs = 1;   /* reserve just the minimum for SMA/ether */
-        } else
+        if (ipath_kpiobufs == 0) {
+                /* not set by user, or set explictly to default  */
+                if ((dd->ipath_piobcnt2k + dd->ipath_piobcnt4k) > 128)
+                        kpiobufs = 32;
+                else
+                        kpiobufs = 16;
+        }
+        else
                 kpiobufs = ipath_kpiobufs;
 
         if (kpiobufs >
@@ -871,7 +879,6 @@ int ipath_init_chip(struct ipath_devdata *dd, int reinit)
 
 done:
         if (!ret) {
-                ipath_get_guid(dd);
                 *dd->ipath_statusp |= IPATH_STATUS_CHIP_PRESENT;
                 if (!dd->ipath_f_intrsetup(dd)) {
                         /* now we can enable all interrupts from the chip */
diff --git a/drivers/infiniband/hw/ipath/ipath_intr.c b/drivers/infiniband/hw/ipath/ipath_intr.c
index 60f5f4108069..3e72a1fe3d73 100644
--- a/drivers/infiniband/hw/ipath/ipath_intr.c
+++ b/drivers/infiniband/hw/ipath/ipath_intr.c
@@ -172,8 +172,8 @@ static void handle_e_ibstatuschanged(struct ipath_devdata *dd,
                                    "was %s\n", dd->ipath_unit,
                                    ib_linkstate(lstate),
                                    ib_linkstate((unsigned)
-                                                dd->ipath_lastibcstat
-                                                & IPATH_IBSTATE_MASK));
+                                                dd->ipath_lastibcstat
+                                                & IPATH_IBSTATE_MASK));
         }
         else {
                 lstate = dd->ipath_lastibcstat & IPATH_IBSTATE_MASK;
@@ -665,14 +665,14 @@ static void handle_layer_pioavail(struct ipath_devdata *dd)
 
         ret = __ipath_layer_intr(dd, IPATH_LAYER_INT_SEND_CONTINUE);
         if (ret > 0)
-                goto clear;
+                goto set;
 
         ret = __ipath_verbs_piobufavail(dd);
         if (ret > 0)
-                goto clear;
+                goto set;
 
         return;
-clear:
+set:
         set_bit(IPATH_S_PIOINTBUFAVAIL, &dd->ipath_sendctrl);
         ipath_write_kreg(dd, dd->ipath_kregs->kr_sendctrl,
                          dd->ipath_sendctrl);
@@ -719,11 +719,24 @@ static void handle_rcv(struct ipath_devdata *dd, u32 istat)
 irqreturn_t ipath_intr(int irq, void *data, struct pt_regs *regs)
 {
         struct ipath_devdata *dd = data;
-        u32 istat = ipath_read_kreg32(dd, dd->ipath_kregs->kr_intstatus);
+        u32 istat;
         ipath_err_t estat = 0;
         static unsigned unexpected = 0;
         irqreturn_t ret;
 
+        if(!(dd->ipath_flags & IPATH_PRESENT)) {
+                /* this is mostly so we don't try to touch the chip while
+                 * it is being reset */
+                /*
+                 * This return value is perhaps odd, but we do not want the
+                 * interrupt core code to remove our interrupt handler
+                 * because we don't appear to be handling an interrupt
+                 * during a chip reset.
+                 */
+                return IRQ_HANDLED;
+        }
+
+        istat = ipath_read_kreg32(dd, dd->ipath_kregs->kr_intstatus);
         if (unlikely(!istat)) {
                 ipath_stats.sps_nullintr++;
                 ret = IRQ_NONE; /* not our interrupt, or already handled */
diff --git a/drivers/infiniband/hw/ipath/ipath_kernel.h b/drivers/infiniband/hw/ipath/ipath_kernel.h
index 159d0aed31a5..5d92d57b6f54 100644
--- a/drivers/infiniband/hw/ipath/ipath_kernel.h
+++ b/drivers/infiniband/hw/ipath/ipath_kernel.h
@@ -528,7 +528,6 @@ extern spinlock_t ipath_devs_lock;
 extern struct ipath_devdata *ipath_lookup(int unit);
 
 extern u16 ipath_layer_rcv_opcode;
-extern int ipath_verbs_registered;
 extern int __ipath_layer_intr(struct ipath_devdata *, u32);
 extern int ipath_layer_intr(struct ipath_devdata *, u32);
 extern int __ipath_layer_rcv(struct ipath_devdata *, void *,
@@ -651,7 +650,7 @@ u32 __iomem *ipath_getpiobuf(struct ipath_devdata *, u32 *);
 void ipath_init_pe800_funcs(struct ipath_devdata *);
 /* init HT-400-specific func */
 void ipath_init_ht400_funcs(struct ipath_devdata *);
-void ipath_get_guid(struct ipath_devdata *);
+void ipath_get_eeprom_info(struct ipath_devdata *);
 u64 ipath_snap_cntr(struct ipath_devdata *, ipath_creg);
 
 /*
@@ -732,7 +731,7 @@ u64 ipath_read_kreg64_port(const struct ipath_devdata *, ipath_kreg,
 static inline u32 ipath_read_ureg32(const struct ipath_devdata *dd,
                                     ipath_ureg regno, int port)
 {
-        if (!dd->ipath_kregbase)
+        if (!dd->ipath_kregbase || !(dd->ipath_flags & IPATH_PRESENT))
                 return 0;
 
         return readl(regno + (u64 __iomem *)
@@ -763,7 +762,7 @@ static inline void ipath_write_ureg(const struct ipath_devdata *dd,
 static inline u32 ipath_read_kreg32(const struct ipath_devdata *dd,
                                     ipath_kreg regno)
 {
-        if (!dd->ipath_kregbase)
+        if (!dd->ipath_kregbase || !(dd->ipath_flags & IPATH_PRESENT))
                 return -1;
         return readl((u32 __iomem *) & dd->ipath_kregbase[regno]);
 }
@@ -771,7 +770,7 @@ static inline u32 ipath_read_kreg32(const struct ipath_devdata *dd,
 static inline u64 ipath_read_kreg64(const struct ipath_devdata *dd,
                                     ipath_kreg regno)
 {
-        if (!dd->ipath_kregbase)
+        if (!dd->ipath_kregbase || !(dd->ipath_flags & IPATH_PRESENT))
                 return -1;
 
         return readq(&dd->ipath_kregbase[regno]);
@@ -787,7 +786,7 @@ static inline void ipath_write_kreg(const struct ipath_devdata *dd,
 static inline u64 ipath_read_creg(const struct ipath_devdata *dd,
                                   ipath_sreg regno)
 {
-        if (!dd->ipath_kregbase)
+        if (!dd->ipath_kregbase || !(dd->ipath_flags & IPATH_PRESENT))
                 return 0;
 
         return readq(regno + (u64 __iomem *)
@@ -798,7 +797,7 @@ static inline u64 ipath_read_creg(const struct ipath_devdata *dd,
 static inline u32 ipath_read_creg32(const struct ipath_devdata *dd,
                                          ipath_sreg regno)
 {
-        if (!dd->ipath_kregbase)
+        if (!dd->ipath_kregbase || !(dd->ipath_flags & IPATH_PRESENT))
                 return 0;
         return readl(regno + (u64 __iomem *)
                      (dd->ipath_cregbase +
diff --git a/drivers/infiniband/hw/ipath/ipath_keys.c b/drivers/infiniband/hw/ipath/ipath_keys.c
index aa33b0e9f2f6..5ae8761f9dd2 100644
--- a/drivers/infiniband/hw/ipath/ipath_keys.c
+++ b/drivers/infiniband/hw/ipath/ipath_keys.c
@@ -136,9 +136,7 @@ int ipath_lkey_ok(struct ipath_lkey_table *rkt, struct ipath_sge *isge,
                 ret = 1;
                 goto bail;
         }
-        spin_lock(&rkt->lock);
         mr = rkt->table[(sge->lkey >> (32 - ib_ipath_lkey_table_size))];
-        spin_unlock(&rkt->lock);
         if (unlikely(mr == NULL || mr->lkey != sge->lkey)) {
                 ret = 0;
                 goto bail;
@@ -184,8 +182,6 @@ bail:
  * @acc: access flags
  *
  * Return 1 if successful, otherwise 0.
- *
- * The QP r_rq.lock should be held.
  */
 int ipath_rkey_ok(struct ipath_ibdev *dev, struct ipath_sge_state *ss,
                   u32 len, u64 vaddr, u32 rkey, int acc)
@@ -196,9 +192,7 @@ int ipath_rkey_ok(struct ipath_ibdev *dev, struct ipath_sge_state *ss,
         size_t off;
         int ret;
 
-        spin_lock(&rkt->lock);
         mr = rkt->table[(rkey >> (32 - ib_ipath_lkey_table_size))];
-        spin_unlock(&rkt->lock);
         if (unlikely(mr == NULL || mr->lkey != rkey)) {
                 ret = 0;
                 goto bail;
diff --git a/drivers/infiniband/hw/ipath/ipath_layer.c b/drivers/infiniband/hw/ipath/ipath_layer.c
index 2cabf6340572..9ec4ac77b87f 100644
--- a/drivers/infiniband/hw/ipath/ipath_layer.c
+++ b/drivers/infiniband/hw/ipath/ipath_layer.c
@@ -46,13 +46,15 @@
 /* Acquire before ipath_devs_lock. */
 static DEFINE_MUTEX(ipath_layer_mutex);
 
+static int ipath_verbs_registered;
+
 u16 ipath_layer_rcv_opcode;
+
 static int (*layer_intr)(void *, u32);
 static int (*layer_rcv)(void *, void *, struct sk_buff *);
 static int (*layer_rcv_lid)(void *, void *);
 static int (*verbs_piobufavail)(void *);
 static void (*verbs_rcv)(void *, void *, void *, u32);
-int ipath_verbs_registered;
 
 static void *(*layer_add_one)(int, struct ipath_devdata *);
 static void (*layer_remove_one)(void *);
@@ -586,6 +588,8 @@ void ipath_verbs_unregister(void)
         verbs_rcv = NULL;
         verbs_timer_cb = NULL;
 
+        ipath_verbs_registered = 0;
+
         mutex_unlock(&ipath_layer_mutex);
 }
 
@@ -868,12 +872,13 @@ static void copy_io(u32 __iomem *piobuf, struct ipath_sge_state *ss,
                 update_sge(ss, len);
                 length -= len;
         }
+        /* Update address before sending packet. */
+        update_sge(ss, length);
         /* must flush early everything before trigger word */
         ipath_flush_wc();
         __raw_writel(last, piobuf);
         /* be sure trigger word is written */
         ipath_flush_wc();
-        update_sge(ss, length);
 }
 
 /**
@@ -939,17 +944,18 @@ int ipath_verbs_send(struct ipath_devdata *dd, u32 hdrwords,
         if (likely(ss->num_sge == 1 && len <= ss->sge.length &&
                    !((unsigned long)ss->sge.vaddr & (sizeof(u32) - 1)))) {
                 u32 w;
+                u32 *addr = (u32 *) ss->sge.vaddr;
 
+                /* Update address before sending packet. */
+                update_sge(ss, len);
                 /* Need to round up for the last dword in the packet. */
                 w = (len + 3) >> 2;
-                __iowrite32_copy(piobuf, ss->sge.vaddr, w - 1);
+                __iowrite32_copy(piobuf, addr, w - 1);
                 /* must flush early everything before trigger word */
                 ipath_flush_wc();
-                __raw_writel(((u32 *) ss->sge.vaddr)[w - 1],
-                             piobuf + w - 1);
+                __raw_writel(addr[w - 1], piobuf + w - 1);
                 /* be sure trigger word is written */
                 ipath_flush_wc();
-                update_sge(ss, len);
                 ret = 0;
                 goto bail;
         }
diff --git a/drivers/infiniband/hw/ipath/ipath_pe800.c b/drivers/infiniband/hw/ipath/ipath_pe800.c
index e693a7a82667..02e8c75b24f6 100644
--- a/drivers/infiniband/hw/ipath/ipath_pe800.c
+++ b/drivers/infiniband/hw/ipath/ipath_pe800.c
@@ -305,8 +305,8 @@ static const struct ipath_cregs ipath_pe_cregs = {
  * we'll print them and continue.  We reuse the same message buffer as
  * ipath_handle_errors() to avoid excessive stack usage.
  */
-void ipath_pe_handle_hwerrors(struct ipath_devdata *dd, char *msg,
-        size_t msgl)
+static void ipath_pe_handle_hwerrors(struct ipath_devdata *dd, char *msg,
+                                     size_t msgl)
 {
         ipath_err_t hwerrs;
         u32 bits, ctrl;
@@ -552,7 +552,7 @@ static int ipath_pe_boardname(struct ipath_devdata *dd, char *name,
  * freeze mode), and enable hardware errors as errors (along with
  * everything else) in errormask
  */
-void ipath_pe_init_hwerrors(struct ipath_devdata *dd)
+static void ipath_pe_init_hwerrors(struct ipath_devdata *dd)
 {
         ipath_err_t val;
         u64 extsval;
@@ -577,7 +577,7 @@ void ipath_pe_init_hwerrors(struct ipath_devdata *dd)
  * ipath_pe_bringup_serdes - bring up the serdes
  * @dd: the infinipath device
  */
-int ipath_pe_bringup_serdes(struct ipath_devdata *dd)
+static int ipath_pe_bringup_serdes(struct ipath_devdata *dd)
 {
         u64 val, tmp, config1;
         int ret = 0, change = 0;
@@ -694,7 +694,7 @@ int ipath_pe_bringup_serdes(struct ipath_devdata *dd)
  * @dd: the infinipath device
  * Called when driver is being unloaded
  */
-void ipath_pe_quiet_serdes(struct ipath_devdata *dd)
+static void ipath_pe_quiet_serdes(struct ipath_devdata *dd)
 {
         u64 val = ipath_read_kreg64(dd, dd->ipath_kregs->kr_serdesconfig0);
 
@@ -972,6 +972,8 @@ static int ipath_setup_pe_reset(struct ipath_devdata *dd)
         /* Use ERROR so it shows up in logs, etc. */
         ipath_dev_err(dd, "Resetting PE-800 unit %u\n",
                       dd->ipath_unit);
+        /* keep chip from being accessed in a few places */
+        dd->ipath_flags &= ~(IPATH_INITTED|IPATH_PRESENT);
         val = dd->ipath_control | INFINIPATH_C_RESET;
         ipath_write_kreg(dd, dd->ipath_kregs->kr_control, val);
         mb();
@@ -997,6 +999,8 @@ static int ipath_setup_pe_reset(struct ipath_devdata *dd)
                 if ((r = pci_enable_device(dd->pcidev)))
                         ipath_dev_err(dd, "pci_enable_device failed after "
                                       "reset: %d\n", r);
+                /* whether it worked or not, mark as present, again */
+                dd->ipath_flags |= IPATH_PRESENT;
                 val = ipath_read_kreg64(dd, dd->ipath_kregs->kr_revision);
                 if (val == dd->ipath_revision) {
                         ipath_cdbg(VERBOSE, "Got matching revision "
@@ -1176,6 +1180,8 @@ static int ipath_pe_early_init(struct ipath_devdata *dd)
          */
         dd->ipath_rhdrhead_intr_off = 1ULL<<32;
 
+        ipath_get_eeprom_info(dd);
+
         return 0;
 }
 
diff --git a/drivers/infiniband/hw/ipath/ipath_qp.c b/drivers/infiniband/hw/ipath/ipath_qp.c
index 6058d70d7577..9f8855d970c8 100644
--- a/drivers/infiniband/hw/ipath/ipath_qp.c
+++ b/drivers/infiniband/hw/ipath/ipath_qp.c
@@ -188,8 +188,8 @@ static void free_qpn(struct ipath_qp_table *qpt, u32 qpn)
  * Allocate the next available QPN and put the QP into the hash table.
  * The hash table holds a reference to the QP.
  */
-int ipath_alloc_qpn(struct ipath_qp_table *qpt, struct ipath_qp *qp,
-                    enum ib_qp_type type)
+static int ipath_alloc_qpn(struct ipath_qp_table *qpt, struct ipath_qp *qp,
+                           enum ib_qp_type type)
 {
         unsigned long flags;
         u32 qpn;
@@ -232,7 +232,7 @@ bail:
  * Remove the QP from the table so it can't be found asynchronously by
  * the receive interrupt routine.
  */
-void ipath_free_qp(struct ipath_qp_table *qpt, struct ipath_qp *qp)
+static void ipath_free_qp(struct ipath_qp_table *qpt, struct ipath_qp *qp)
 {
         struct ipath_qp *q, **qpp;
         unsigned long flags;
@@ -358,6 +358,65 @@ static void ipath_reset_qp(struct ipath_qp *qp)
 }
 
 /**
+ * ipath_error_qp - put a QP into an error state
+ * @qp: the QP to put into an error state
+ *
+ * Flushes both send and receive work queues.
+ * QP r_rq.lock and s_lock should be held.
+ */
+
+static void ipath_error_qp(struct ipath_qp *qp)
+{
+        struct ipath_ibdev *dev = to_idev(qp->ibqp.device);
+        struct ib_wc wc;
+
+        _VERBS_INFO("QP%d/%d in error state\n",
+                    qp->ibqp.qp_num, qp->remote_qpn);
+
+        spin_lock(&dev->pending_lock);
+        /* XXX What if its already removed by the timeout code? */
+        if (!list_empty(&qp->timerwait))
+                list_del_init(&qp->timerwait);
+        if (!list_empty(&qp->piowait))
+                list_del_init(&qp->piowait);
+        spin_unlock(&dev->pending_lock);
+
+        wc.status = IB_WC_WR_FLUSH_ERR;
+        wc.vendor_err = 0;
+        wc.byte_len = 0;
+        wc.imm_data = 0;
+        wc.qp_num = qp->ibqp.qp_num;
+        wc.src_qp = 0;
+        wc.wc_flags = 0;
+        wc.pkey_index = 0;
+        wc.slid = 0;
+        wc.sl = 0;
+        wc.dlid_path_bits = 0;
+        wc.port_num = 0;
+
+        while (qp->s_last != qp->s_head) {
+                struct ipath_swqe *wqe = get_swqe_ptr(qp, qp->s_last);
+
+                wc.wr_id = wqe->wr.wr_id;
+                wc.opcode = ib_ipath_wc_opcode[wqe->wr.opcode];
+                if (++qp->s_last >= qp->s_size)
+                        qp->s_last = 0;
+                ipath_cq_enter(to_icq(qp->ibqp.send_cq), &wc, 1);
+        }
+        qp->s_cur = qp->s_tail = qp->s_head;
+        qp->s_hdrwords = 0;
+        qp->s_ack_state = IB_OPCODE_RC_ACKNOWLEDGE;
+
+        wc.opcode = IB_WC_RECV;
+        while (qp->r_rq.tail != qp->r_rq.head) {
+                wc.wr_id = get_rwqe_ptr(&qp->r_rq, qp->r_rq.tail)->wr_id;
+                if (++qp->r_rq.tail >= qp->r_rq.size)
+                        qp->r_rq.tail = 0;
+                ipath_cq_enter(to_icq(qp->ibqp.recv_cq), &wc, 1);
+        }
+}
+
+/**
  * ipath_modify_qp - modify the attributes of a queue pair
  * @ibqp: the queue pair who's attributes we're modifying
  * @attr: the new attributes
@@ -368,6 +427,7 @@ static void ipath_reset_qp(struct ipath_qp *qp)
 int ipath_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
                     int attr_mask)
 {
+        struct ipath_ibdev *dev = to_idev(ibqp->device);
         struct ipath_qp *qp = to_iqp(ibqp);
         enum ib_qp_state cur_state, new_state;
         unsigned long flags;
@@ -384,6 +444,19 @@ int ipath_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
                                 attr_mask))
                 goto inval;
 
+        if (attr_mask & IB_QP_AV)
+                if (attr->ah_attr.dlid == 0 ||
+                    attr->ah_attr.dlid >= IPS_MULTICAST_LID_BASE)
+                        goto inval;
+
+        if (attr_mask & IB_QP_PKEY_INDEX)
+                if (attr->pkey_index >= ipath_layer_get_npkeys(dev->dd))
+                        goto inval;
+
+        if (attr_mask & IB_QP_MIN_RNR_TIMER)
+                if (attr->min_rnr_timer > 31)
+                        goto inval;
+
         switch (new_state) {
         case IB_QPS_RESET:
                 ipath_reset_qp(qp);
@@ -398,13 +471,8 @@ int ipath_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
 
         }
 
-        if (attr_mask & IB_QP_PKEY_INDEX) {
-                struct ipath_ibdev *dev = to_idev(ibqp->device);
-
-                if (attr->pkey_index >= ipath_layer_get_npkeys(dev->dd))
-                        goto inval;
+        if (attr_mask & IB_QP_PKEY_INDEX)
                 qp->s_pkey_index = attr->pkey_index;
-        }
 
         if (attr_mask & IB_QP_DEST_QPN)
                 qp->remote_qpn = attr->dest_qp_num;
@@ -420,12 +488,8 @@ int ipath_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
         if (attr_mask & IB_QP_ACCESS_FLAGS)
                 qp->qp_access_flags = attr->qp_access_flags;
 
-        if (attr_mask & IB_QP_AV) {
-                if (attr->ah_attr.dlid == 0 ||
-                    attr->ah_attr.dlid >= IPS_MULTICAST_LID_BASE)
-                        goto inval;
+        if (attr_mask & IB_QP_AV)
                 qp->remote_ah_attr = attr->ah_attr;
-        }
 
         if (attr_mask & IB_QP_PATH_MTU)
                 qp->path_mtu = attr->path_mtu;
@@ -440,11 +504,8 @@ int ipath_modify_qp(struct ib_qp *ibqp, struct ib_qp_attr *attr,
                 qp->s_rnr_retry_cnt = qp->s_rnr_retry;
         }
 
-        if (attr_mask & IB_QP_MIN_RNR_TIMER) {
-                if (attr->min_rnr_timer > 31)
-                        goto inval;
+        if (attr_mask & IB_QP_MIN_RNR_TIMER)
                 qp->s_min_rnr_timer = attr->min_rnr_timer;
-        }
 
         if (attr_mask & IB_QP_QKEY)
                 qp->qkey = attr->qkey;
@@ -651,10 +712,8 @@ struct ib_qp *ipath_create_qp(struct ib_pd *ibpd,
                              init_attr->qp_type == IB_QPT_RC ?
                              ipath_do_rc_send : ipath_do_uc_send,
                              (unsigned long)qp);
-                qp->piowait.next = LIST_POISON1;
-                qp->piowait.prev = LIST_POISON2;
-                qp->timerwait.next = LIST_POISON1;
-                qp->timerwait.prev = LIST_POISON2;
+                INIT_LIST_HEAD(&qp->piowait);
+                INIT_LIST_HEAD(&qp->timerwait);
                 qp->state = IB_QPS_RESET;
                 qp->s_wq = swq;
                 qp->s_size = init_attr->cap.max_send_wr + 1;
@@ -675,7 +734,7 @@ struct ib_qp *ipath_create_qp(struct ib_pd *ibpd,
                 ipath_reset_qp(qp);
 
                 /* Tell the core driver that the kernel SMA is present. */
-                if (qp->ibqp.qp_type == IB_QPT_SMI)
+                if (init_attr->qp_type == IB_QPT_SMI)
                         ipath_layer_set_verbs_flags(dev->dd,
                                                     IPATH_VERBS_KERNEL_SMA);
                 break;
@@ -724,10 +783,10 @@ int ipath_destroy_qp(struct ib_qp *ibqp)
 
         /* Make sure the QP isn't on the timeout list. */
         spin_lock_irqsave(&dev->pending_lock, flags);
-        if (qp->timerwait.next != LIST_POISON1)
-                list_del(&qp->timerwait);
-        if (qp->piowait.next != LIST_POISON1)
-                list_del(&qp->piowait);
+        if (!list_empty(&qp->timerwait))
+                list_del_init(&qp->timerwait);
+        if (!list_empty(&qp->piowait))
+                list_del_init(&qp->piowait);
         spin_unlock_irqrestore(&dev->pending_lock, flags);
 
         /*
@@ -796,10 +855,10 @@ void ipath_sqerror_qp(struct ipath_qp *qp, struct ib_wc *wc)
 
         spin_lock(&dev->pending_lock);
         /* XXX What if its already removed by the timeout code? */
-        if (qp->timerwait.next != LIST_POISON1)
-                list_del(&qp->timerwait);
-        if (qp->piowait.next != LIST_POISON1)
-                list_del(&qp->piowait);
+        if (!list_empty(&qp->timerwait))
+                list_del_init(&qp->timerwait);
+        if (!list_empty(&qp->piowait))
+                list_del_init(&qp->piowait);
         spin_unlock(&dev->pending_lock);
 
         ipath_cq_enter(to_icq(qp->ibqp.send_cq), wc, 1);
@@ -821,65 +880,6 @@ void ipath_sqerror_qp(struct ipath_qp *qp, struct ib_wc *wc)
 }
 
 /**
- * ipath_error_qp - put a QP into an error state
- * @qp: the QP to put into an error state
- *
- * Flushes both send and receive work queues.
- * QP r_rq.lock and s_lock should be held.
- */
-
-void ipath_error_qp(struct ipath_qp *qp)
-{
-        struct ipath_ibdev *dev = to_idev(qp->ibqp.device);
-        struct ib_wc wc;
-
-        _VERBS_INFO("QP%d/%d in error state\n",
-                    qp->ibqp.qp_num, qp->remote_qpn);
-
-        spin_lock(&dev->pending_lock);
-        /* XXX What if its already removed by the timeout code? */
-        if (qp->timerwait.next != LIST_POISON1)
-                list_del(&qp->timerwait);
-        if (qp->piowait.next != LIST_POISON1)
-                list_del(&qp->piowait);
-        spin_unlock(&dev->pending_lock);
-
-        wc.status = IB_WC_WR_FLUSH_ERR;
-        wc.vendor_err = 0;
-        wc.byte_len = 0;
-        wc.imm_data = 0;
-        wc.qp_num = qp->ibqp.qp_num;
-        wc.src_qp = 0;
-        wc.wc_flags = 0;
-        wc.pkey_index = 0;
-        wc.slid = 0;
-        wc.sl = 0;
-        wc.dlid_path_bits = 0;
-        wc.port_num = 0;
-
-        while (qp->s_last != qp->s_head) {
-                struct ipath_swqe *wqe = get_swqe_ptr(qp, qp->s_last);
-
-                wc.wr_id = wqe->wr.wr_id;
-                wc.opcode = ib_ipath_wc_opcode[wqe->wr.opcode];
-                if (++qp->s_last >= qp->s_size)
-                        qp->s_last = 0;
-                ipath_cq_enter(to_icq(qp->ibqp.send_cq), &wc, 1);
-        }
-        qp->s_cur = qp->s_tail = qp->s_head;
-        qp->s_hdrwords = 0;
-        qp->s_ack_state = IB_OPCODE_RC_ACKNOWLEDGE;
-
-        wc.opcode = IB_WC_RECV;
-        while (qp->r_rq.tail != qp->r_rq.head) {
-                wc.wr_id = get_rwqe_ptr(&qp->r_rq, qp->r_rq.tail)->wr_id;
-                if (++qp->r_rq.tail >= qp->r_rq.size)
-                        qp->r_rq.tail = 0;
-                ipath_cq_enter(to_icq(qp->ibqp.recv_cq), &wc, 1);
-        }
-}
-
-/**
  * ipath_get_credit - flush the send work queue of a QP
  * @qp: the qp who's send work queue to flush
  * @aeth: the Acknowledge Extended Transport Header
diff --git a/drivers/infiniband/hw/ipath/ipath_rc.c b/drivers/infiniband/hw/ipath/ipath_rc.c
index a4055ca00614..493b1821a934 100644
--- a/drivers/infiniband/hw/ipath/ipath_rc.c
+++ b/drivers/infiniband/hw/ipath/ipath_rc.c
@@ -57,7 +57,7 @@ static void ipath_init_restart(struct ipath_qp *qp, struct ipath_swqe *wqe)
         qp->s_len = wqe->length - len;
         dev = to_idev(qp->ibqp.device);
         spin_lock(&dev->pending_lock);
-        if (qp->timerwait.next == LIST_POISON1)
+        if (list_empty(&qp->timerwait))
                 list_add_tail(&qp->timerwait,
                               &dev->pending[dev->pending_index]);
         spin_unlock(&dev->pending_lock);
@@ -356,7 +356,7 @@ static inline int ipath_make_rc_req(struct ipath_qp *qp,
                 if ((int)(qp->s_psn - qp->s_next_psn) > 0)
                         qp->s_next_psn = qp->s_psn;
                 spin_lock(&dev->pending_lock);
-                if (qp->timerwait.next == LIST_POISON1)
+                if (list_empty(&qp->timerwait))
                         list_add_tail(&qp->timerwait,
                                       &dev->pending[dev->pending_index]);
                 spin_unlock(&dev->pending_lock);
@@ -726,8 +726,8 @@ void ipath_restart_rc(struct ipath_qp *qp, u32 psn, struct ib_wc *wc)
          */
         dev = to_idev(qp->ibqp.device);
         spin_lock(&dev->pending_lock);
-        if (qp->timerwait.next != LIST_POISON1)
-                list_del(&qp->timerwait);
+        if (!list_empty(&qp->timerwait))
+                list_del_init(&qp->timerwait);
         spin_unlock(&dev->pending_lock);
 
         if (wqe->wr.opcode == IB_WR_RDMA_READ)
@@ -886,8 +886,8 @@ static int do_rc_ack(struct ipath_qp *qp, u32 aeth, u32 psn, int opcode)
          * just won't find anything to restart if we ACK everything.
          */
         spin_lock(&dev->pending_lock);
-        if (qp->timerwait.next != LIST_POISON1)
-                list_del(&qp->timerwait);
+        if (!list_empty(&qp->timerwait))
+                list_del_init(&qp->timerwait);
         spin_unlock(&dev->pending_lock);
 
         /*
@@ -1194,8 +1194,7 @@ static inline void ipath_rc_rcv_resp(struct ipath_ibdev *dev,
                      IB_WR_RDMA_READ))
                 goto ack_done;
         spin_lock(&dev->pending_lock);
-        if (qp->s_rnr_timeout == 0 &&
-            qp->timerwait.next != LIST_POISON1)
+        if (qp->s_rnr_timeout == 0 && !list_empty(&qp->timerwait))
                 list_move_tail(&qp->timerwait,
                                &dev->pending[dev->pending_index]);
         spin_unlock(&dev->pending_lock);
diff --git a/drivers/infiniband/hw/ipath/ipath_registers.h b/drivers/infiniband/hw/ipath/ipath_registers.h
index 1e59750c5f63..402126eb79c9 100644
--- a/drivers/infiniband/hw/ipath/ipath_registers.h
+++ b/drivers/infiniband/hw/ipath/ipath_registers.h
@@ -34,8 +34,9 @@
 #define _IPATH_REGISTERS_H
 
 /*
- * This file should only be included by kernel source, and by the diags.
- * It defines the registers, and their contents, for the InfiniPath HT-400 chip
+ * This file should only be included by kernel source, and by the diags.  It
+ * defines the registers, and their contents, for the InfiniPath HT-400
+ * chip.
  */
 
 /*
@@ -156,8 +157,10 @@
 #define INFINIPATH_IBCC_FLOWCTRLWATERMARK_SHIFT 8
 #define INFINIPATH_IBCC_LINKINITCMD_MASK 0x3ULL
 #define INFINIPATH_IBCC_LINKINITCMD_DISABLE 1
-#define INFINIPATH_IBCC_LINKINITCMD_POLL 2      /* cycle through TS1/TS2 till OK */
-#define INFINIPATH_IBCC_LINKINITCMD_SLEEP 3     /* wait for TS1, then go on */
+/* cycle through TS1/TS2 till OK */
+#define INFINIPATH_IBCC_LINKINITCMD_POLL 2
+/* wait for TS1, then go on */
+#define INFINIPATH_IBCC_LINKINITCMD_SLEEP 3
 #define INFINIPATH_IBCC_LINKINITCMD_SHIFT 16
 #define INFINIPATH_IBCC_LINKCMD_MASK 0x3ULL
 #define INFINIPATH_IBCC_LINKCMD_INIT 1  /* move to 0x11 */
@@ -182,7 +185,8 @@
 #define INFINIPATH_IBCS_LINKSTATE_SHIFT 4
 #define INFINIPATH_IBCS_TXREADY       0x40000000
 #define INFINIPATH_IBCS_TXCREDITOK    0x80000000
-/* link training states (shift by INFINIPATH_IBCS_LINKTRAININGSTATE_SHIFT) */
+/* link training states (shift by
+   INFINIPATH_IBCS_LINKTRAININGSTATE_SHIFT) */
 #define INFINIPATH_IBCS_LT_STATE_DISABLED       0x00
 #define INFINIPATH_IBCS_LT_STATE_LINKUP         0x01
 #define INFINIPATH_IBCS_LT_STATE_POLLACTIVE     0x02
@@ -267,10 +271,12 @@
 /* kr_serdesconfig0 bits */
 #define INFINIPATH_SERDC0_RESET_MASK  0xfULL    /* overal reset bits */
 #define INFINIPATH_SERDC0_RESET_PLL   0x10000000ULL     /* pll reset */
-#define INFINIPATH_SERDC0_TXIDLE      0xF000ULL /* tx idle enables (per lane) */
-#define INFINIPATH_SERDC0_RXDETECT_EN 0xF0000ULL        /* rx detect enables (per lane) */
-#define INFINIPATH_SERDC0_L1PWR_DN       0xF0ULL        /* L1 Power down; use with RXDETECT,
-                                                           Otherwise not used on IB side */
+/* tx idle enables (per lane) */
+#define INFINIPATH_SERDC0_TXIDLE      0xF000ULL
+/* rx detect enables (per lane) */
+#define INFINIPATH_SERDC0_RXDETECT_EN 0xF0000ULL
+/* L1 Power down; use with RXDETECT, Otherwise not used on IB side */
+#define INFINIPATH_SERDC0_L1PWR_DN       0xF0ULL
 
 /* kr_xgxsconfig bits */
 #define INFINIPATH_XGXS_RESET          0x7ULL
@@ -390,12 +396,13 @@ struct ipath_kregs {
         ipath_kreg kr_txintmemsize;
         ipath_kreg kr_xgxsconfig;
         ipath_kreg kr_ibpllcfg;
-        /* use these two (and the following N ports) only with ipath_k*_kreg64_port();
-         * not *kreg64() */
+        /* use these two (and the following N ports) only with
+         * ipath_k*_kreg64_port(); not *kreg64() */
         ipath_kreg kr_rcvhdraddr;
         ipath_kreg kr_rcvhdrtailaddr;
 
-        /* remaining registers are not present on all types of infinipath chips  */
+        /* remaining registers are not present on all types of infinipath
+           chips  */
         ipath_kreg kr_rcvpktledcnt;
         ipath_kreg kr_pcierbuftestreg0;
         ipath_kreg kr_pcierbuftestreg1;
diff --git a/drivers/infiniband/hw/ipath/ipath_ruc.c b/drivers/infiniband/hw/ipath/ipath_ruc.c
index f232e77b78ee..d38f4f3cfd1d 100644
--- a/drivers/infiniband/hw/ipath/ipath_ruc.c
+++ b/drivers/infiniband/hw/ipath/ipath_ruc.c
@@ -435,7 +435,7 @@ void ipath_no_bufs_available(struct ipath_qp *qp, struct ipath_ibdev *dev)
         unsigned long flags;
 
         spin_lock_irqsave(&dev->pending_lock, flags);
-        if (qp->piowait.next == LIST_POISON1)
+        if (list_empty(&qp->piowait))
                 list_add_tail(&qp->piowait, &dev->piowait);
         spin_unlock_irqrestore(&dev->pending_lock, flags);
         /*
@@ -531,19 +531,12 @@ int ipath_post_rc_send(struct ipath_qp *qp, struct ib_send_wr *wr)
         }
         wqe->wr.num_sge = j;
         qp->s_head = next;
-        /*
-         * Wake up the send tasklet if the QP is not waiting
-         * for an RNR timeout.
-         */
-        next = qp->s_rnr_timeout;
         spin_unlock_irqrestore(&qp->s_lock, flags);
 
-        if (next == 0) {
-                if (qp->ibqp.qp_type == IB_QPT_UC)
-                        ipath_do_uc_send((unsigned long) qp);
-                else
-                        ipath_do_rc_send((unsigned long) qp);
-        }
+        if (qp->ibqp.qp_type == IB_QPT_UC)
+                ipath_do_uc_send((unsigned long) qp);
+        else
+                ipath_do_rc_send((unsigned long) qp);
 
         ret = 0;
 
diff --git a/drivers/infiniband/hw/ipath/ipath_sysfs.c b/drivers/infiniband/hw/ipath/ipath_sysfs.c
index 32acd8048b49..f323791cc495 100644
--- a/drivers/infiniband/hw/ipath/ipath_sysfs.c
+++ b/drivers/infiniband/hw/ipath/ipath_sysfs.c
@@ -711,10 +711,22 @@ static struct attribute_group dev_attr_group = {
  * enters diag mode.  A device reset is quite likely to crash the
  * machine entirely, so we don't want to normally make it
  * available.
+ *
+ * Called with ipath_mutex held.
  */
 int ipath_expose_reset(struct device *dev)
 {
-        return device_create_file(dev, &dev_attr_reset);
+        static int exposed;
+        int ret;
+
+        if (!exposed) {
+                ret = device_create_file(dev, &dev_attr_reset);
+                exposed = 1;
+        }
+        else
+                ret = 0;
+
+        return ret;
 }
 
 int ipath_driver_create_group(struct device_driver *drv)
diff --git a/drivers/infiniband/hw/ipath/ipath_ud.c b/drivers/infiniband/hw/ipath/ipath_ud.c
index 5ff3de6128b2..e606daf83210 100644
--- a/drivers/infiniband/hw/ipath/ipath_ud.c
+++ b/drivers/infiniband/hw/ipath/ipath_ud.c
@@ -46,8 +46,10 @@
  * This is called from ipath_post_ud_send() to forward a WQE addressed
  * to the same HCA.
  */
-void ipath_ud_loopback(struct ipath_qp *sqp, struct ipath_sge_state *ss,
-                       u32 length, struct ib_send_wr *wr, struct ib_wc *wc)
+static void ipath_ud_loopback(struct ipath_qp *sqp,
+                              struct ipath_sge_state *ss,
+                              u32 length, struct ib_send_wr *wr,
+                              struct ib_wc *wc)
 {
         struct ipath_ibdev *dev = to_idev(sqp->ibqp.device);
         struct ipath_qp *qp;
diff --git a/drivers/infiniband/hw/ipath/ipath_verbs.c b/drivers/infiniband/hw/ipath/ipath_verbs.c
index 9f27fd35cdbb..28fdbdaa789d 100644
--- a/drivers/infiniband/hw/ipath/ipath_verbs.c
+++ b/drivers/infiniband/hw/ipath/ipath_verbs.c
@@ -41,7 +41,7 @@
 /* Not static, because we don't want the compiler removing it */
 const char ipath_verbs_version[] = "ipath_verbs " IPATH_IDSTR;
 
-unsigned int ib_ipath_qp_table_size = 251;
+static unsigned int ib_ipath_qp_table_size = 251;
 module_param_named(qp_table_size, ib_ipath_qp_table_size, uint, S_IRUGO);
 MODULE_PARM_DESC(qp_table_size, "QP table size");
 
@@ -87,7 +87,7 @@ const enum ib_wc_opcode ib_ipath_wc_opcode[] = {
 /*
  * System image GUID.
  */
-__be64 sys_image_guid;
+static __be64 sys_image_guid;
 
 /**
  * ipath_copy_sge - copy data to SGE memory
@@ -449,7 +449,6 @@ static void ipath_ib_timer(void *arg)
 {
         struct ipath_ibdev *dev = (struct ipath_ibdev *) arg;
         struct ipath_qp *resend = NULL;
-        struct ipath_qp *rnr = NULL;
         struct list_head *last;
         struct ipath_qp *qp;
         unsigned long flags;
@@ -465,32 +464,18 @@ static void ipath_ib_timer(void *arg)
         last = &dev->pending[dev->pending_index];
         while (!list_empty(last)) {
                 qp = list_entry(last->next, struct ipath_qp, timerwait);
-                if (last->next == LIST_POISON1 ||
-                    last->next != &qp->timerwait ||
-                    qp->timerwait.prev != last) {
-                        INIT_LIST_HEAD(last);
-                } else {
-                        list_del(&qp->timerwait);
-                        qp->timerwait.prev = (struct list_head *) resend;
-                        resend = qp;
-                        atomic_inc(&qp->refcount);
-                }
+                list_del_init(&qp->timerwait);
+                qp->timer_next = resend;
+                resend = qp;
+                atomic_inc(&qp->refcount);
         }
         last = &dev->rnrwait;
         if (!list_empty(last)) {
                 qp = list_entry(last->next, struct ipath_qp, timerwait);
                 if (--qp->s_rnr_timeout == 0) {
                         do {
-                                if (last->next == LIST_POISON1 ||
-                                    last->next != &qp->timerwait ||
-                                    qp->timerwait.prev != last) {
-                                        INIT_LIST_HEAD(last);
-                                        break;
-                                }
-                                list_del(&qp->timerwait);
-                                qp->timerwait.prev =
-                                        (struct list_head *) rnr;
-                                rnr = qp;
+                                list_del_init(&qp->timerwait);
+                                tasklet_hi_schedule(&qp->s_task);
                                 if (list_empty(last))
                                         break;
                                 qp = list_entry(last->next, struct ipath_qp,
@@ -530,8 +515,7 @@ static void ipath_ib_timer(void *arg)
         spin_unlock_irqrestore(&dev->pending_lock, flags);
 
         /* XXX What if timer fires again while this is running? */
-        for (qp = resend; qp != NULL;
-             qp = (struct ipath_qp *) qp->timerwait.prev) {
+        for (qp = resend; qp != NULL; qp = qp->timer_next) {
                 struct ib_wc wc;
 
                 spin_lock_irqsave(&qp->s_lock, flags);
@@ -545,9 +529,6 @@ static void ipath_ib_timer(void *arg)
                 if (atomic_dec_and_test(&qp->refcount))
                         wake_up(&qp->wait);
         }
-        for (qp = rnr; qp != NULL;
-             qp = (struct ipath_qp *) qp->timerwait.prev)
-                tasklet_hi_schedule(&qp->s_task);
 }
 
 /**
@@ -556,9 +537,9 @@ static void ipath_ib_timer(void *arg)
  *
  * This is called from ipath_intr() at interrupt level when a PIO buffer is
  * available after ipath_verbs_send() returned an error that no buffers were
- * available.  Return 0 if we consumed all the PIO buffers and we still have
+ * available.  Return 1 if we consumed all the PIO buffers and we still have
  * QPs waiting for buffers (for now, just do a tasklet_hi_schedule and
- * return one).
+ * return zero).
  */
 static int ipath_ib_piobufavail(void *arg)
 {
@@ -573,13 +554,13 @@ static int ipath_ib_piobufavail(void *arg)
         while (!list_empty(&dev->piowait)) {
                 qp = list_entry(dev->piowait.next, struct ipath_qp,
                                 piowait);
-                list_del(&qp->piowait);
+                list_del_init(&qp->piowait);
                 tasklet_hi_schedule(&qp->s_task);
         }
         spin_unlock_irqrestore(&dev->pending_lock, flags);
 
 bail:
-        return 1;
+        return 0;
 }
 
 static int ipath_query_device(struct ib_device *ibdev,
@@ -970,6 +951,7 @@ static void *ipath_register_ib_device(int unit, struct ipath_devdata *dd)
         idev->dd = dd;
 
         strlcpy(dev->name, "ipath%d", IB_DEVICE_NAME_MAX);
+        dev->owner = THIS_MODULE;
         dev->node_guid = ipath_layer_get_guid(dd);
         dev->uverbs_abi_ver = IPATH_UVERBS_ABI_VERSION;
         dev->uverbs_cmd_mask =
@@ -1110,7 +1092,7 @@ static void ipath_unregister_ib_device(void *arg)
         ib_dealloc_device(ibdev);
 }
 
-int __init ipath_verbs_init(void)
+static int __init ipath_verbs_init(void)
 {
         return ipath_verbs_register(ipath_register_ib_device,
                                     ipath_unregister_ib_device,
@@ -1118,33 +1100,33 @@ int __init ipath_verbs_init(void)
                                     ipath_ib_timer);
 }
 
-void __exit ipath_verbs_cleanup(void)
+static void __exit ipath_verbs_cleanup(void)
 {
         ipath_verbs_unregister();
 }
 
 static ssize_t show_rev(struct class_device *cdev, char *buf)
 {
-        struct ipath_ibdev *dev =
-                container_of(cdev, struct ipath_ibdev, ibdev.class_dev);
-        int vendor, boardrev, majrev, minrev;
+        struct ipath_ibdev *dev =
+                container_of(cdev, struct ipath_ibdev, ibdev.class_dev);
+        int vendor, boardrev, majrev, minrev;
 
-        ipath_layer_query_device(dev->dd, &vendor, &boardrev,
-                                 &majrev, &minrev);
-        return sprintf(buf, "%d.%d\n", majrev, minrev);
+        ipath_layer_query_device(dev->dd, &vendor, &boardrev,
+                                 &majrev, &minrev);
+        return sprintf(buf, "%d.%d\n", majrev, minrev);
 }
 
 static ssize_t show_hca(struct class_device *cdev, char *buf)
 {
-        struct ipath_ibdev *dev =
-                container_of(cdev, struct ipath_ibdev, ibdev.class_dev);
-        int ret;
+        struct ipath_ibdev *dev =
+                container_of(cdev, struct ipath_ibdev, ibdev.class_dev);
+        int ret;
 
-        ret = ipath_layer_get_boardname(dev->dd, buf, 128);
-        if (ret < 0)
-                goto bail;
-        strcat(buf, "\n");
-        ret = strlen(buf);
+        ret = ipath_layer_get_boardname(dev->dd, buf, 128);
+        if (ret < 0)
+                goto bail;
+        strcat(buf, "\n");
+        ret = strlen(buf);
 
 bail:
         return ret;
@@ -1152,40 +1134,40 @@ bail:
 
 static ssize_t show_stats(struct class_device *cdev, char *buf)
 {
-        struct ipath_ibdev *dev =
-                container_of(cdev, struct ipath_ibdev, ibdev.class_dev);
-        int i;
-        int len;
-
-        len = sprintf(buf,
-                      "RC resends  %d\n"
-                      "RC QACKs    %d\n"
-                      "RC ACKs     %d\n"
-                      "RC SEQ NAKs %d\n"
-                      "RC RDMA seq %d\n"
-                      "RC RNR NAKs %d\n"
-                      "RC OTH NAKs %d\n"
-                      "RC timeouts %d\n"
-                      "RC RDMA dup %d\n"
-                      "piobuf wait %d\n"
-                      "no piobuf   %d\n"
-                      "PKT drops   %d\n"
-                      "WQE errs    %d\n",
-                      dev->n_rc_resends, dev->n_rc_qacks, dev->n_rc_acks,
-                      dev->n_seq_naks, dev->n_rdma_seq, dev->n_rnr_naks,
-                      dev->n_other_naks, dev->n_timeouts,
-                      dev->n_rdma_dup_busy, dev->n_piowait,
-                      dev->n_no_piobuf, dev->n_pkt_drops, dev->n_wqe_errs);
-        for (i = 0; i < ARRAY_SIZE(dev->opstats); i++) {
+        struct ipath_ibdev *dev =
+                container_of(cdev, struct ipath_ibdev, ibdev.class_dev);
+        int i;
+        int len;
+
+        len = sprintf(buf,
+                      "RC resends  %d\n"
+                      "RC no QACK  %d\n"
+                      "RC ACKs     %d\n"
+                      "RC SEQ NAKs %d\n"
+                      "RC RDMA seq %d\n"
+                      "RC RNR NAKs %d\n"
+                      "RC OTH NAKs %d\n"
+                      "RC timeouts %d\n"
+                      "RC RDMA dup %d\n"
+                      "piobuf wait %d\n"
+                      "no piobuf   %d\n"
+                      "PKT drops   %d\n"
+                      "WQE errs    %d\n",
+                      dev->n_rc_resends, dev->n_rc_qacks, dev->n_rc_acks,
+                      dev->n_seq_naks, dev->n_rdma_seq, dev->n_rnr_naks,
+                      dev->n_other_naks, dev->n_timeouts,
+                      dev->n_rdma_dup_busy, dev->n_piowait,
+                      dev->n_no_piobuf, dev->n_pkt_drops, dev->n_wqe_errs);
+        for (i = 0; i < ARRAY_SIZE(dev->opstats); i++) {
                 const struct ipath_opcode_stats *si = &dev->opstats[i];
 
-                if (!si->n_packets && !si->n_bytes)
-                        continue;
-                len += sprintf(buf + len, "%02x %llu/%llu\n", i,
+                if (!si->n_packets && !si->n_bytes)
+                        continue;
+                len += sprintf(buf + len, "%02x %llu/%llu\n", i,
                                (unsigned long long) si->n_packets,
-                               (unsigned long long) si->n_bytes);
-        }
-        return len;
+                               (unsigned long long) si->n_bytes);
+        }
+        return len;
 }
 
 static CLASS_DEVICE_ATTR(hw_rev, S_IRUGO, show_rev, NULL);
@@ -1194,25 +1176,25 @@ static CLASS_DEVICE_ATTR(board_id, S_IRUGO, show_hca, NULL);
 static CLASS_DEVICE_ATTR(stats, S_IRUGO, show_stats, NULL);
 
 static struct class_device_attribute *ipath_class_attributes[] = {
-        &class_device_attr_hw_rev,
-        &class_device_attr_hca_type,
-        &class_device_attr_board_id,
-        &class_device_attr_stats
+        &class_device_attr_hw_rev,
+        &class_device_attr_hca_type,
+        &class_device_attr_board_id,
+        &class_device_attr_stats
 };
 
 static int ipath_verbs_register_sysfs(struct ib_device *dev)
 {
-        int i;
+        int i;
         int ret;
 
-        for (i = 0; i < ARRAY_SIZE(ipath_class_attributes); ++i)
-                if (class_device_create_file(&dev->class_dev,
-                                             ipath_class_attributes[i])) {
-                        ret = 1;
+        for (i = 0; i < ARRAY_SIZE(ipath_class_attributes); ++i)
+                if (class_device_create_file(&dev->class_dev,
+                                             ipath_class_attributes[i])) {
+                        ret = 1;
                         goto bail;
                 }
 
-        ret = 0;
+        ret = 0;
 
 bail:
         return ret;
diff --git a/drivers/infiniband/hw/ipath/ipath_verbs.h b/drivers/infiniband/hw/ipath/ipath_verbs.h
index b824632b2a8c..4f8d59300e9b 100644
--- a/drivers/infiniband/hw/ipath/ipath_verbs.h
+++ b/drivers/infiniband/hw/ipath/ipath_verbs.h
@@ -282,7 +282,8 @@ struct ipath_srq {
  */
 struct ipath_qp {
         struct ib_qp ibqp;
-        struct ipath_qp *next;  /* link list for QPN hash table */
+        struct ipath_qp *next;          /* link list for QPN hash table */
+        struct ipath_qp *timer_next;    /* link list for ipath_ib_timer() */
         struct list_head piowait;       /* link for wait PIO buf */
         struct list_head timerwait;     /* link for waiting for timeouts */
         struct ib_ah_attr remote_ah_attr;
@@ -577,8 +578,6 @@ int ipath_init_qp_table(struct ipath_ibdev *idev, int size);
 
 void ipath_sqerror_qp(struct ipath_qp *qp, struct ib_wc *wc);
 
-void ipath_error_qp(struct ipath_qp *qp);
-
 void ipath_get_credit(struct ipath_qp *qp, u32 aeth);
 
 void ipath_do_rc_send(unsigned long data);
@@ -607,9 +606,6 @@ void ipath_rc_rcv(struct ipath_ibdev *dev, struct ipath_ib_header *hdr,
 
 void ipath_restart_rc(struct ipath_qp *qp, u32 psn, struct ib_wc *wc);
 
-void ipath_ud_loopback(struct ipath_qp *sqp, struct ipath_sge_state *ss,
-                       u32 length, struct ib_send_wr *wr, struct ib_wc *wc);
-
 int ipath_post_ud_send(struct ipath_qp *qp, struct ib_send_wr *wr);
 
 void ipath_ud_rcv(struct ipath_ibdev *dev, struct ipath_ib_header *hdr,
diff --git a/drivers/infiniband/hw/ipath/ips_common.h b/drivers/infiniband/hw/ipath/ips_common.h
index 410a764dfcef..ab7cbbbfd03a 100644
--- a/drivers/infiniband/hw/ipath/ips_common.h
+++ b/drivers/infiniband/hw/ipath/ips_common.h
@@ -95,7 +95,7 @@ struct ether_header {
         __u8 seq_num;
         __le32 len;
         /* MUST be of word size due to PIO write requirements */
-        __u32 csum;
+        __le32 csum;
         __le16 csum_offset;
         __le16 flags;
         __u16 first_2_bytes;