[PATCH] IB/ipath: memory management cleanups

Made in-memory rcvhdrq tail update be in dma_alloc'ed memory, not random user
or special kernel (needed for ppc, also "just the right thing to do").

Some cleanups to make unexpected link transitions less likely to produce
complaints about packet errors, and also to not leave SMA packets stuck and
unable to go out.

A few other random debug and comment cleanups.

Always init rcvhdrq head/tail registers to 0, to avoid race conditions (should
have been that way some time ago).

Signed-off-by: Dave Olson <dave.olson@qlogic.com>
Signed-off-by: Bryan O'Sullivan <bryan.osullivan@qlogic.com>
Cc: "Michael S. Tsirkin" <mst@mellanox.co.il>
Cc: Roland Dreier <rolandd@cisco.com>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>

6 files changed, 279 insertions, 370 deletions

diff --git a/drivers/infiniband/hw/ipath/ipath_common.h b/drivers/infiniband/hw/ipath/ipath_common.h
index 9b6ec76c118e..3a849e71638e 100644
--- a/drivers/infiniband/hw/ipath/ipath_common.h
+++ b/drivers/infiniband/hw/ipath/ipath_common.h
@@ -311,6 +311,9 @@ struct ipath_base_info {
         __u32 spi_rcv_egrchunksize;
         /* total size of mmap to cover full rcvegrbuffers */
         __u32 spi_rcv_egrbuftotlen;
+        __u32 spi_filler_for_align;
+        /* address of readonly memory copy of the rcvhdrq tail register. */
+        __u64 spi_rcvhdr_tailaddr;
 } __attribute__ ((aligned(8)));
 
 
@@ -380,13 +383,7 @@ struct ipath_user_info {
          */
         __u32 spu_rcvhdrsize;
 
-        /*
-         * cache line aligned (64 byte) user address to
-         * which the rcvhdrtail register will be written by infinipath
-         * whenever it changes, so that no chip registers are read in
-         * the performance path.
-         */
-        __u64 spu_rcvhdraddr;
+        __u64 spu_unused; /* kept for compatible layout */
 
         /*
          * address of struct base_info to write to
diff --git a/drivers/infiniband/hw/ipath/ipath_driver.c b/drivers/infiniband/hw/ipath/ipath_driver.c
index c92f8e0a117a..0b88642381f8 100644
--- a/drivers/infiniband/hw/ipath/ipath_driver.c
+++ b/drivers/infiniband/hw/ipath/ipath_driver.c
@@ -131,14 +131,6 @@ static struct pci_driver ipath_driver = {
         .id_table = ipath_pci_tbl,
 };
 
-/*
- * This is where port 0's rcvhdrtail register is written back; we also
- * want nothing else sharing the cache line, so make it a cache line
- * in size.  Used for all units.
- */
-volatile __le64 *ipath_port0_rcvhdrtail;
-dma_addr_t ipath_port0_rcvhdrtail_dma;
-static int port0_rcvhdrtail_refs;
 
 static inline void read_bars(struct ipath_devdata *dd, struct pci_dev *dev,
                              u32 *bar0, u32 *bar1)
@@ -268,47 +260,6 @@ int ipath_count_units(int *npresentp, int *nupp, u32 *maxportsp)
         return nunits;
 }
 
-static int init_port0_rcvhdrtail(struct pci_dev *pdev)
-{
-        int ret;
-
-        mutex_lock(&ipath_mutex);
-
-        if (!ipath_port0_rcvhdrtail) {
-                ipath_port0_rcvhdrtail =
-                        dma_alloc_coherent(&pdev->dev,
-                                           IPATH_PORT0_RCVHDRTAIL_SIZE,
-                                           &ipath_port0_rcvhdrtail_dma,
-                                           GFP_KERNEL);
-
-                if (!ipath_port0_rcvhdrtail) {
-                        ret = -ENOMEM;
-                        goto bail;
-                }
-        }
-        port0_rcvhdrtail_refs++;
-        ret = 0;
-
-bail:
-        mutex_unlock(&ipath_mutex);
-
-        return ret;
-}
-
-static void cleanup_port0_rcvhdrtail(struct pci_dev *pdev)
-{
-        mutex_lock(&ipath_mutex);
-
-        if (!--port0_rcvhdrtail_refs) {
-                dma_free_coherent(&pdev->dev, IPATH_PORT0_RCVHDRTAIL_SIZE,
-                                  (void *) ipath_port0_rcvhdrtail,
-                                  ipath_port0_rcvhdrtail_dma);
-                ipath_port0_rcvhdrtail = NULL;
-        }
-
-        mutex_unlock(&ipath_mutex);
-}
-
 /*
  * These next two routines are placeholders in case we don't have per-arch
  * code for controlling write combining.  If explicit control of write
@@ -333,20 +284,12 @@ static int __devinit ipath_init_one(struct pci_dev *pdev,
         u32 bar0 = 0, bar1 = 0;
         u8 rev;
 
-        ret = init_port0_rcvhdrtail(pdev);
-        if (ret < 0) {
-                printk(KERN_ERR IPATH_DRV_NAME
-                       ": Could not allocate port0_rcvhdrtail: error %d\n",
-                       -ret);
-                goto bail;
-        }
-
         dd = ipath_alloc_devdata(pdev);
         if (IS_ERR(dd)) {
                 ret = PTR_ERR(dd);
                 printk(KERN_ERR IPATH_DRV_NAME
                        ": Could not allocate devdata: error %d\n", -ret);
-                goto bail_rcvhdrtail;
+                goto bail;
         }
 
         ipath_cdbg(VERBOSE, "initializing unit #%u\n", dd->ipath_unit);
@@ -574,9 +517,6 @@ bail_disable:
 bail_devdata:
         ipath_free_devdata(pdev, dd);
 
-bail_rcvhdrtail:
-        cleanup_port0_rcvhdrtail(pdev);
-
 bail:
         return ret;
 }
@@ -608,7 +548,6 @@ static void __devexit ipath_remove_one(struct pci_dev *pdev)
         pci_disable_device(pdev);
 
         ipath_free_devdata(pdev, dd);
-        cleanup_port0_rcvhdrtail(pdev);
 }
 
 /* general driver use */
@@ -1383,26 +1322,20 @@ bail:
  * @dd: the infinipath device
  * @pd: the port data
  *
- * this *must* be physically contiguous memory, and for now,
- * that limits it to what kmalloc can do.
+ * this must be contiguous memory (from an i/o perspective), and must be
+ * DMA'able (which means for some systems, it will go through an IOMMU,
+ * or be forced into a low address range).
  */
 int ipath_create_rcvhdrq(struct ipath_devdata *dd,
                          struct ipath_portdata *pd)
 {
-        int ret = 0, amt;
+        int ret = 0;
 
-        amt = ALIGN(dd->ipath_rcvhdrcnt * dd->ipath_rcvhdrentsize *
-                    sizeof(u32), PAGE_SIZE);
         if (!pd->port_rcvhdrq) {
-                /*
-                 * not using REPEAT isn't viable; at 128KB, we can easily
-                 * fail this.  The problem with REPEAT is we can block here
-                 * "forever".  There isn't an inbetween, unfortunately.  We
-                 * could reduce the risk by never freeing the rcvhdrq except
-                 * at unload, but even then, the first time a port is used,
-                 * we could delay for some time...
-                 */
+                dma_addr_t phys_hdrqtail;
                 gfp_t gfp_flags = GFP_USER | __GFP_COMP;
+                int amt = ALIGN(dd->ipath_rcvhdrcnt * dd->ipath_rcvhdrentsize *
+                                sizeof(u32), PAGE_SIZE);
 
                 pd->port_rcvhdrq = dma_alloc_coherent(
                         &dd->pcidev->dev, amt, &pd->port_rcvhdrq_phys,
@@ -1415,6 +1348,16 @@ int ipath_create_rcvhdrq(struct ipath_devdata *dd,
                         ret = -ENOMEM;
                         goto bail;
                 }
+                pd->port_rcvhdrtail_kvaddr = dma_alloc_coherent(
+                        &dd->pcidev->dev, PAGE_SIZE, &phys_hdrqtail, GFP_KERNEL);
+                if (!pd->port_rcvhdrtail_kvaddr) {
+                        ipath_dev_err(dd, "attempt to allocate 1 page "
+                                      "for port %u rcvhdrqtailaddr failed\n",
+                                      pd->port_port);
+                        ret = -ENOMEM;
+                        goto bail;
+                }
+                pd->port_rcvhdrqtailaddr_phys = phys_hdrqtail;
 
                 pd->port_rcvhdrq_size = amt;
 
@@ -1424,20 +1367,28 @@ int ipath_create_rcvhdrq(struct ipath_devdata *dd,
                            (unsigned long) pd->port_rcvhdrq_phys,
                            (unsigned long) pd->port_rcvhdrq_size,
                            pd->port_port);
-        } else {
-                /*
-                 * clear for security, sanity, and/or debugging, each
-                 * time we reuse
-                 */
-                memset(pd->port_rcvhdrq, 0, amt);
+
+                ipath_cdbg(VERBOSE, "port %d hdrtailaddr, %llx physical\n",
+                           pd->port_port,
+                           (unsigned long long) phys_hdrqtail);
         }
+        else
+                ipath_cdbg(VERBOSE, "reuse port %d rcvhdrq @%p %llx phys; "
+                           "hdrtailaddr@%p %llx physical\n",
+                           pd->port_port, pd->port_rcvhdrq,
+                           pd->port_rcvhdrq_phys, pd->port_rcvhdrtail_kvaddr,
+                           (unsigned long long)pd->port_rcvhdrqtailaddr_phys);
+
+        /* clear for security and sanity on each use */
+        memset(pd->port_rcvhdrq, 0, pd->port_rcvhdrq_size);
+        memset((void *)pd->port_rcvhdrtail_kvaddr, 0, PAGE_SIZE);
 
         /*
          * tell chip each time we init it, even if we are re-using previous
-         * memory (we zero it at process close)
+         * memory (we zero the register at process close)
          */
-        ipath_cdbg(VERBOSE, "writing port %d rcvhdraddr as %lx\n",
-                   pd->port_port, (unsigned long) pd->port_rcvhdrq_phys);
+        ipath_write_kreg_port(dd, dd->ipath_kregs->kr_rcvhdrtailaddr,
+                              pd->port_port, pd->port_rcvhdrqtailaddr_phys);
         ipath_write_kreg_port(dd, dd->ipath_kregs->kr_rcvhdraddr,
                               pd->port_port, pd->port_rcvhdrq_phys);
 
@@ -1525,15 +1476,27 @@ void ipath_set_ib_lstate(struct ipath_devdata *dd, int which)
                 [INFINIPATH_IBCC_LINKCMD_ARMED] = "ARMED",
                 [INFINIPATH_IBCC_LINKCMD_ACTIVE] = "ACTIVE"
         };
+        int linkcmd = (which >> INFINIPATH_IBCC_LINKCMD_SHIFT) &
+                        INFINIPATH_IBCC_LINKCMD_MASK;
+
         ipath_cdbg(SMA, "Trying to move unit %u to %s, current ltstate "
                    "is %s\n", dd->ipath_unit,
-                   what[(which >> INFINIPATH_IBCC_LINKCMD_SHIFT) &
-                        INFINIPATH_IBCC_LINKCMD_MASK],
+                   what[linkcmd],
                    ipath_ibcstatus_str[
                            (ipath_read_kreg64
                             (dd, dd->ipath_kregs->kr_ibcstatus) >>
                             INFINIPATH_IBCS_LINKTRAININGSTATE_SHIFT) &
                            INFINIPATH_IBCS_LINKTRAININGSTATE_MASK]);
+        /* flush all queued sends when going to DOWN or INIT, to be sure that
+         * they don't block SMA and other MAD packets */
+        if (!linkcmd || linkcmd == INFINIPATH_IBCC_LINKCMD_INIT) {
+                ipath_write_kreg(dd, dd->ipath_kregs->kr_sendctrl,
+                                 INFINIPATH_S_ABORT);
+                ipath_disarm_piobufs(dd, dd->ipath_lastport_piobuf,
+                                    (unsigned)(dd->ipath_piobcnt2k +
+                                    dd->ipath_piobcnt4k) -
+                                    dd->ipath_lastport_piobuf);
+        }
 
         ipath_write_kreg(dd, dd->ipath_kregs->kr_ibcctrl,
                          dd->ipath_ibcctrl | which);
@@ -1681,60 +1644,54 @@ void ipath_shutdown_device(struct ipath_devdata *dd)
 /**
  * ipath_free_pddata - free a port's allocated data
  * @dd: the infinipath device
- * @port: the port
- * @freehdrq: free the port data structure if true
+ * @pd: the portdata structure
  *
- * when closing, free up any allocated data for a port, if the
- * reference count goes to zero
- * Note: this also optionally frees the portdata itself!
- * Any changes here have to be matched up with the reinit case
- * of ipath_init_chip(), which calls this routine on reinit after reset.
+ * free up any allocated data for a port
+ * This should not touch anything that would affect a simultaneous
+ * re-allocation of port data, because it is called after ipath_mutex
+ * is released (and can be called from reinit as well).
+ * It should never change any chip state, or global driver state.
+ * (The only exception to global state is freeing the port0 port0_skbs.)
  */
-void ipath_free_pddata(struct ipath_devdata *dd, u32 port, int freehdrq)
+void ipath_free_pddata(struct ipath_devdata *dd, struct ipath_portdata *pd)
 {
-        struct ipath_portdata *pd = dd->ipath_pd[port];
-
         if (!pd)
                 return;
-        if (freehdrq)
-                /*
-                 * only clear and free portdata if we are going to also
-                 * release the hdrq, otherwise we leak the hdrq on each
-                 * open/close cycle
-                 */
-                dd->ipath_pd[port] = NULL;
-        if (freehdrq && pd->port_rcvhdrq) {
+
+        if (pd->port_rcvhdrq) {
                 ipath_cdbg(VERBOSE, "free closed port %d rcvhdrq @ %p "
                            "(size=%lu)\n", pd->port_port, pd->port_rcvhdrq,
                            (unsigned long) pd->port_rcvhdrq_size);
                 dma_free_coherent(&dd->pcidev->dev, pd->port_rcvhdrq_size,
                                   pd->port_rcvhdrq, pd->port_rcvhdrq_phys);
                 pd->port_rcvhdrq = NULL;
+                if (pd->port_rcvhdrtail_kvaddr) {
+                        dma_free_coherent(&dd->pcidev->dev, PAGE_SIZE,
+                                         (void *)pd->port_rcvhdrtail_kvaddr,
+                                         pd->port_rcvhdrqtailaddr_phys);
+                        pd->port_rcvhdrtail_kvaddr = NULL;
+                }
         }
-        if (port && pd->port_rcvegrbuf) {
-                /* always free this */
-                if (pd->port_rcvegrbuf) {
-                        unsigned e;
-
-                        for (e = 0; e < pd->port_rcvegrbuf_chunks; e++) {
-                                void *base = pd->port_rcvegrbuf[e];
-                                size_t size = pd->port_rcvegrbuf_size;
-
-                                ipath_cdbg(VERBOSE, "egrbuf free(%p, %lu), "
-                                           "chunk %u/%u\n", base,
-                                           (unsigned long) size,
-                                           e, pd->port_rcvegrbuf_chunks);
-                                dma_free_coherent(
-                                        &dd->pcidev->dev, size, base,
-                                        pd->port_rcvegrbuf_phys[e]);
-                        }
-                        vfree(pd->port_rcvegrbuf);
-                        pd->port_rcvegrbuf = NULL;
-                        vfree(pd->port_rcvegrbuf_phys);
-                        pd->port_rcvegrbuf_phys = NULL;
+        if (pd->port_port && pd->port_rcvegrbuf) {
+                unsigned e;
+
+                for (e = 0; e < pd->port_rcvegrbuf_chunks; e++) {
+                        void *base = pd->port_rcvegrbuf[e];
+                        size_t size = pd->port_rcvegrbuf_size;
+
+                        ipath_cdbg(VERBOSE, "egrbuf free(%p, %lu), "
+                                   "chunk %u/%u\n", base,
+                                   (unsigned long) size,
+                                   e, pd->port_rcvegrbuf_chunks);
+                        dma_free_coherent(&dd->pcidev->dev, size,
+                                base, pd->port_rcvegrbuf_phys[e]);
                 }
+                vfree(pd->port_rcvegrbuf);
+                pd->port_rcvegrbuf = NULL;
+                vfree(pd->port_rcvegrbuf_phys);
+                pd->port_rcvegrbuf_phys = NULL;
                 pd->port_rcvegrbuf_chunks = 0;
-        } else if (port == 0 && dd->ipath_port0_skbs) {
+        } else if (pd->port_port == 0 && dd->ipath_port0_skbs) {
                 unsigned e;
                 struct sk_buff **skbs = dd->ipath_port0_skbs;
 
@@ -1746,10 +1703,8 @@ void ipath_free_pddata(struct ipath_devdata *dd, u32 port, int freehdrq)
                                 dev_kfree_skb(skbs[e]);
                 vfree(skbs);
         }
-        if (freehdrq) {
-                kfree(pd->port_tid_pg_list);
-                kfree(pd);
-        }
+        kfree(pd->port_tid_pg_list);
+        kfree(pd);
 }
 
 static int __init infinipath_init(void)
@@ -1874,10 +1829,14 @@ static void cleanup_device(struct ipath_devdata *dd)
 
         /*
          * free any resources still in use (usually just kernel ports)
-         * at unload
+         * at unload; we do for portcnt, not cfgports, because cfgports
+         * could have changed while we were loaded.
          */
-        for (port = 0; port < dd->ipath_cfgports; port++)
-                ipath_free_pddata(dd, port, 1);
+        for (port = 0; port < dd->ipath_portcnt; port++) {
+                struct ipath_portdata *pd = dd->ipath_pd[port];
+                dd->ipath_pd[port] = NULL;
+                ipath_free_pddata(dd, pd);
+        }
         kfree(dd->ipath_pd);
         /*
          * debuggability, in case some cleanup path tries to use it
diff --git a/drivers/infiniband/hw/ipath/ipath_file_ops.c b/drivers/infiniband/hw/ipath/ipath_file_ops.c
index 03689dbe1a9e..e89d3a17acd9 100644
--- a/drivers/infiniband/hw/ipath/ipath_file_ops.c
+++ b/drivers/infiniband/hw/ipath/ipath_file_ops.c
@@ -123,6 +123,7 @@ static int ipath_get_base_info(struct ipath_portdata *pd,
          * on to yet another method of dealing with this
          */
         kinfo->spi_rcvhdr_base = (u64) pd->port_rcvhdrq_phys;
+        kinfo->spi_rcvhdr_tailaddr = (u64)pd->port_rcvhdrqtailaddr_phys;
         kinfo->spi_rcv_egrbufs = (u64) pd->port_rcvegr_phys;
         kinfo->spi_pioavailaddr = (u64) dd->ipath_pioavailregs_phys;
         kinfo->spi_status = (u64) kinfo->spi_pioavailaddr +
@@ -785,11 +786,12 @@ static int ipath_create_user_egr(struct ipath_portdata *pd)
 
 bail_rcvegrbuf_phys:
         for (e = 0; e < pd->port_rcvegrbuf_chunks &&
-                     pd->port_rcvegrbuf[e]; e++)
+                pd->port_rcvegrbuf[e]; e++) {
                 dma_free_coherent(&dd->pcidev->dev, size,
                                   pd->port_rcvegrbuf[e],
                                   pd->port_rcvegrbuf_phys[e]);
 
+        }
         vfree(pd->port_rcvegrbuf_phys);
         pd->port_rcvegrbuf_phys = NULL;
 bail_rcvegrbuf:
@@ -804,10 +806,7 @@ static int ipath_do_user_init(struct ipath_portdata *pd,
 {
         int ret = 0;
         struct ipath_devdata *dd = pd->port_dd;
-        u64 physaddr, uaddr, off, atmp;
-        struct page *pagep;
         u32 head32;
-        u64 head;
 
         /* for now, if major version is different, bail */
         if ((uinfo->spu_userversion >> 16) != IPATH_USER_SWMAJOR) {
@@ -832,54 +831,6 @@ static int ipath_do_user_init(struct ipath_portdata *pd,
 
         /* for now we do nothing with rcvhdrcnt: uinfo->spu_rcvhdrcnt */
 
-        /* set up for the rcvhdr Q tail register writeback to user memory */
-        if (!uinfo->spu_rcvhdraddr ||
-            !access_ok(VERIFY_WRITE, (u64 __user *) (unsigned long)
-                       uinfo->spu_rcvhdraddr, sizeof(u64))) {
-                ipath_dbg("Port %d rcvhdrtail addr %llx not valid\n",
-                          pd->port_port,
-                          (unsigned long long) uinfo->spu_rcvhdraddr);
-                ret = -EINVAL;
-                goto done;
-        }
-
-        off = offset_in_page(uinfo->spu_rcvhdraddr);
-        uaddr = PAGE_MASK & (unsigned long) uinfo->spu_rcvhdraddr;
-        ret = ipath_get_user_pages_nocopy(uaddr, &pagep);
-        if (ret) {
-                dev_info(&dd->pcidev->dev, "Failed to lookup and lock "
-                         "address %llx for rcvhdrtail: errno %d\n",
-                         (unsigned long long) uinfo->spu_rcvhdraddr, -ret);
-                goto done;
-        }
-        ipath_stats.sps_pagelocks++;
-        pd->port_rcvhdrtail_uaddr = uaddr;
-        pd->port_rcvhdrtail_pagep = pagep;
-        pd->port_rcvhdrtail_kvaddr =
-                page_address(pagep);
-        pd->port_rcvhdrtail_kvaddr += off;
-        physaddr = page_to_phys(pagep) + off;
-        ipath_cdbg(VERBOSE, "port %d user addr %llx hdrtailaddr, %llx "
-                   "physical (off=%llx)\n",
-                   pd->port_port,
-                   (unsigned long long) uinfo->spu_rcvhdraddr,
-                   (unsigned long long) physaddr, (unsigned long long) off);
-        ipath_write_kreg_port(dd, dd->ipath_kregs->kr_rcvhdrtailaddr,
-                              pd->port_port, physaddr);
-        atmp = ipath_read_kreg64_port(dd,
-                                      dd->ipath_kregs->kr_rcvhdrtailaddr,
-                                      pd->port_port);
-        if (physaddr != atmp) {
-                ipath_dev_err(dd,
-                              "Catastrophic software error, "
-                              "RcvHdrTailAddr%u written as %llx, "
-                              "read back as %llx\n", pd->port_port,
-                              (unsigned long long) physaddr,
-                              (unsigned long long) atmp);
-                ret = -EINVAL;
-                goto done;
-        }
-
         /* for right now, kernel piobufs are at end, so port 1 is at 0 */
         pd->port_piobufs = dd->ipath_piobufbase +
                 dd->ipath_pbufsport * (pd->port_port -
@@ -898,26 +849,18 @@ static int ipath_do_user_init(struct ipath_portdata *pd,
                 ret = ipath_create_user_egr(pd);
         if (ret)
                 goto done;
-        /* enable receives now */
-        /* atomically set enable bit for this port */
-        set_bit(INFINIPATH_R_PORTENABLE_SHIFT + pd->port_port,
-                &dd->ipath_rcvctrl);
 
         /*
-         * set the head registers for this port to the current values
+         * set the eager head register for this port to the current values
          * of the tail pointers, since we don't know if they were
          * updated on last use of the port.
          */
-        head32 = ipath_read_ureg32(dd, ur_rcvhdrtail, pd->port_port);
-        head = (u64) head32;
-        ipath_write_ureg(dd, ur_rcvhdrhead, head, pd->port_port);
         head32 = ipath_read_ureg32(dd, ur_rcvegrindextail, pd->port_port);
         ipath_write_ureg(dd, ur_rcvegrindexhead, head32, pd->port_port);
         dd->ipath_lastegrheads[pd->port_port] = -1;
         dd->ipath_lastrcvhdrqtails[pd->port_port] = -1;
-        ipath_cdbg(VERBOSE, "Wrote port%d head %llx, egrhead %x from "
-                   "tail regs\n", pd->port_port,
-                   (unsigned long long) head, head32);
+        ipath_cdbg(VERBOSE, "Wrote port%d egrhead %x from tail regs\n",
+                pd->port_port, head32);
         pd->port_tidcursor = 0; /* start at beginning after open */
         /*
          * now enable the port; the tail registers will be written to memory
@@ -926,24 +869,76 @@ static int ipath_do_user_init(struct ipath_portdata *pd,
          * transition from 0 to 1, so clear it first, then set it as part of
          * enabling the port.  This will (very briefly) affect any other
          * open ports, but it shouldn't be long enough to be an issue.
+         * We explictly set the in-memory copy to 0 beforehand, so we don't
+         * have to wait to be sure the DMA update has happened.
          */
+        *pd->port_rcvhdrtail_kvaddr = 0ULL;
+        set_bit(INFINIPATH_R_PORTENABLE_SHIFT + pd->port_port,
+                &dd->ipath_rcvctrl);
         ipath_write_kreg(dd, dd->ipath_kregs->kr_rcvctrl,
                          dd->ipath_rcvctrl & ~INFINIPATH_R_TAILUPD);
         ipath_write_kreg(dd, dd->ipath_kregs->kr_rcvctrl,
                          dd->ipath_rcvctrl);
-
 done:
         return ret;
 }
 
+
+/* common code for the mappings on dma_alloc_coherent mem */
+static int ipath_mmap_mem(struct vm_area_struct *vma,
+                             struct ipath_portdata *pd, unsigned len,
+                             int write_ok, dma_addr_t addr, char *what)
+{
+        struct ipath_devdata *dd = pd->port_dd;
+        unsigned pfn = (unsigned long)addr >> PAGE_SHIFT;
+        int ret;
+
+        if ((vma->vm_end - vma->vm_start) > len) {
+                dev_info(&dd->pcidev->dev,
+                         "FAIL on %s: len %lx > %x\n", what,
+                         vma->vm_end - vma->vm_start, len);
+                ret = -EFAULT;
+                goto bail;
+        }
+
+        if (!write_ok) {
+                if (vma->vm_flags & VM_WRITE) {
+                        dev_info(&dd->pcidev->dev,
+                                 "%s must be mapped readonly\n", what);
+                        ret = -EPERM;
+                        goto bail;
+                }
+
+                /* don't allow them to later change with mprotect */
+                vma->vm_flags &= ~VM_MAYWRITE;
+        }
+
+        ret = remap_pfn_range(vma, vma->vm_start, pfn,
+                              len, vma->vm_page_prot);
+        if (ret)
+                dev_info(&dd->pcidev->dev,
+                         "%s port%u mmap of %lx, %x bytes r%c failed: %d\n",
+                         what, pd->port_port, (unsigned long)addr, len,
+                         write_ok?'w':'o', ret);
+        else
+                ipath_cdbg(VERBOSE, "%s port%u mmaped %lx, %x bytes r%c\n",
+                        what, pd->port_port, (unsigned long)addr, len,
+                         write_ok?'w':'o');
+bail:
+        return ret;
+}
+
 static int mmap_ureg(struct vm_area_struct *vma, struct ipath_devdata *dd,
                      u64 ureg)
 {
         unsigned long phys;
         int ret;
 
-        /* it's the real hardware, so io_remap works */
-
+        /*
+         * This is real hardware, so use io_remap.  This is the mechanism
+         * for the user process to update the head registers for their port
+         * in the chip.
+         */
         if ((vma->vm_end - vma->vm_start) > PAGE_SIZE) {
                 dev_info(&dd->pcidev->dev, "FAIL mmap userreg: reqlen "
                          "%lx > PAGE\n", vma->vm_end - vma->vm_start);
@@ -969,10 +964,11 @@ static int mmap_piobufs(struct vm_area_struct *vma,
         int ret;
 
         /*
-         * When we map the PIO buffers, we want to map them as writeonly, no
-         * read possible.
+         * When we map the PIO buffers in the chip, we want to map them as
+         * writeonly, no read possible.   This prevents access to previous
+         * process data, and catches users who might try to read the i/o
+         * space due to a bug.
          */
-
         if ((vma->vm_end - vma->vm_start) >
             (dd->ipath_pbufsport * dd->ipath_palign)) {
                 dev_info(&dd->pcidev->dev, "FAIL mmap piobufs: "
@@ -983,11 +979,10 @@ static int mmap_piobufs(struct vm_area_struct *vma,
         }
 
         phys = dd->ipath_physaddr + pd->port_piobufs;
+
         /*
-         * Do *NOT* mark this as non-cached (PWT bit), or we don't get the
+         * Don't mark this as non-cached, or we don't get the
          * write combining behavior we want on the PIO buffers!
-         * vma->vm_page_prot =
-         *        pgprot_noncached(vma->vm_page_prot);
          */
 
         if (vma->vm_flags & VM_READ) {
@@ -999,8 +994,7 @@ static int mmap_piobufs(struct vm_area_struct *vma,
         }
 
         /* don't allow them to later change to readable with mprotect */
-
-        vma->vm_flags &= ~VM_MAYWRITE;
+        vma->vm_flags &= ~VM_MAYREAD;
         vma->vm_flags |= VM_DONTCOPY | VM_DONTEXPAND;
 
         ret = io_remap_pfn_range(vma, vma->vm_start, phys >> PAGE_SHIFT,
@@ -1019,11 +1013,6 @@ static int mmap_rcvegrbufs(struct vm_area_struct *vma,
         dma_addr_t *phys;
         int ret;
 
-        if (!pd->port_rcvegrbuf) {
-                ret = -EFAULT;
-                goto bail;
-        }
-
         size = pd->port_rcvegrbuf_size;
         total_size = pd->port_rcvegrbuf_chunks * size;
         if ((vma->vm_end - vma->vm_start) > total_size) {
@@ -1041,13 +1030,12 @@ static int mmap_rcvegrbufs(struct vm_area_struct *vma,
                 ret = -EPERM;
                 goto bail;
         }
+        /* don't allow them to later change to writeable with mprotect */
+        vma->vm_flags &= ~VM_MAYWRITE;
 
         start = vma->vm_start;
         phys = pd->port_rcvegrbuf_phys;
 
-        /* don't allow them to later change to writeable with mprotect */
-        vma->vm_flags &= ~VM_MAYWRITE;
-
         for (i = 0; i < pd->port_rcvegrbuf_chunks; i++, start += size) {
                 ret = remap_pfn_range(vma, start, phys[i] >> PAGE_SHIFT,
                                       size, vma->vm_page_prot);
@@ -1060,78 +1048,6 @@ bail:
         return ret;
 }
 
-static int mmap_rcvhdrq(struct vm_area_struct *vma,
-                        struct ipath_portdata *pd)
-{
-        struct ipath_devdata *dd = pd->port_dd;
-        size_t total_size;
-        int ret;
-
-        /*
-         * kmalloc'ed memory, physically contiguous; this is from
-         * spi_rcvhdr_base; we allow user to map read-write so they can
-         * write hdrq entries to allow protocol code to directly poll
-         * whether a hdrq entry has been written.
-         */
-        total_size = ALIGN(dd->ipath_rcvhdrcnt * dd->ipath_rcvhdrentsize *
-                           sizeof(u32), PAGE_SIZE);
-        if ((vma->vm_end - vma->vm_start) > total_size) {
-                dev_info(&dd->pcidev->dev,
-                         "FAIL on rcvhdrq: reqlen %lx > actual %lx\n",
-                         vma->vm_end - vma->vm_start,
-                         (unsigned long) total_size);
-                ret = -EFAULT;
-                goto bail;
-        }
-
-        ret = remap_pfn_range(vma, vma->vm_start,
-                              pd->port_rcvhdrq_phys >> PAGE_SHIFT,
-                              vma->vm_end - vma->vm_start,
-                              vma->vm_page_prot);
-bail:
-        return ret;
-}
-
-static int mmap_pioavailregs(struct vm_area_struct *vma,
-                             struct ipath_portdata *pd)
-{
-        struct ipath_devdata *dd = pd->port_dd;
-        int ret;
-
-        /*
-         * when we map the PIO bufferavail registers, we want to map them as
-         * readonly, no write possible.
-         *
-         * kmalloc'ed memory, physically contiguous, one page only, readonly
-         */
-
-        if ((vma->vm_end - vma->vm_start) > PAGE_SIZE) {
-                dev_info(&dd->pcidev->dev, "FAIL on pioavailregs_dma: "
-                         "reqlen %lx > actual %lx\n",
-                         vma->vm_end - vma->vm_start,
-                         (unsigned long) PAGE_SIZE);
-                ret = -EFAULT;
-                goto bail;
-        }
-
-        if (vma->vm_flags & VM_WRITE) {
-                dev_info(&dd->pcidev->dev,
-                         "Can't map pioavailregs as writable (flags=%lx)\n",
-                         vma->vm_flags);
-                ret = -EPERM;
-                goto bail;
-        }
-
-        /* don't allow them to later change with mprotect */
-        vma->vm_flags &= ~VM_MAYWRITE;
-
-        ret = remap_pfn_range(vma, vma->vm_start,
-                              dd->ipath_pioavailregs_phys >> PAGE_SHIFT,
-                              PAGE_SIZE, vma->vm_page_prot);
-bail:
-        return ret;
-}
-
 /**
  * ipath_mmap - mmap various structures into user space
  * @fp: the file pointer
@@ -1151,6 +1067,7 @@ static int ipath_mmap(struct file *fp, struct vm_area_struct *vma)
 
         pd = port_fp(fp);
         dd = pd->port_dd;
+
         /*
          * This is the ipath_do_user_init() code, mapping the shared buffers
          * into the user process. The address referred to by vm_pgoff is the
@@ -1160,29 +1077,59 @@ static int ipath_mmap(struct file *fp, struct vm_area_struct *vma)
         pgaddr = vma->vm_pgoff << PAGE_SHIFT;
 
         /*
-         * note that ureg does *NOT* have the kregvirt as part of it, to be
-         * sure that for 32 bit programs, we don't end up trying to map a >
-         * 44 address.  Has to match ipath_get_base_info() code that sets
-         * __spi_uregbase
+         * Must fit in 40 bits for our hardware; some checked elsewhere,
+         * but we'll be paranoid.  Check for 0 is mostly in case one of the
+         * allocations failed, but user called mmap anyway.   We want to catch
+         * that before it can match.
          */
+        if (!pgaddr || pgaddr >= (1ULL<<40))  {
+                ipath_dev_err(dd, "Bad phys addr %llx, start %lx, end %lx\n",
+                        (unsigned long long)pgaddr, vma->vm_start, vma->vm_end);
+                return -EINVAL;
+        }
 
+        /* just the offset of the port user registers, not physical addr */
         ureg = dd->ipath_uregbase + dd->ipath_palign * pd->port_port;
 
-        ipath_cdbg(MM, "pgaddr %llx vm_start=%lx len %lx port %u:%u\n",
+        ipath_cdbg(MM, "ushare: pgaddr %llx vm_start=%lx, vmlen %lx\n",
                    (unsigned long long) pgaddr, vma->vm_start,
-                   vma->vm_end - vma->vm_start, dd->ipath_unit,
-                   pd->port_port);
+                   vma->vm_end - vma->vm_start);
 
-        if (pgaddr == ureg)
+        if (vma->vm_start & (PAGE_SIZE-1)) {
+                ipath_dev_err(dd,
+                        "vm_start not aligned: %lx, end=%lx phys %lx\n",
+                        vma->vm_start, vma->vm_end, (unsigned long)pgaddr);
+                ret = -EINVAL;
+        }
+        else if (pgaddr == ureg)
                 ret = mmap_ureg(vma, dd, ureg);
         else if (pgaddr == pd->port_piobufs)
                 ret = mmap_piobufs(vma, dd, pd);
         else if (pgaddr == (u64) pd->port_rcvegr_phys)
                 ret = mmap_rcvegrbufs(vma, pd);
-        else if (pgaddr == (u64) pd->port_rcvhdrq_phys)
-                ret = mmap_rcvhdrq(vma, pd);
+        else if (pgaddr == (u64) pd->port_rcvhdrq_phys) {
+                /*
+                 * The rcvhdrq itself; readonly except on HT-400 (so have
+                 * to allow writable mapping), multiple pages, contiguous
+                 * from an i/o perspective.
+                 */
+                unsigned total_size =
+                        ALIGN(dd->ipath_rcvhdrcnt * dd->ipath_rcvhdrentsize
+                           * sizeof(u32), PAGE_SIZE);
+                ret = ipath_mmap_mem(vma, pd, total_size, 1,
+                                     pd->port_rcvhdrq_phys,
+                                     "rcvhdrq");
+        }
+        else if (pgaddr == (u64)pd->port_rcvhdrqtailaddr_phys)
+                /* in-memory copy of rcvhdrq tail register */
+                ret = ipath_mmap_mem(vma, pd, PAGE_SIZE, 0,
+                                     pd->port_rcvhdrqtailaddr_phys,
+                                     "rcvhdrq tail");
         else if (pgaddr == dd->ipath_pioavailregs_phys)
-                ret = mmap_pioavailregs(vma, pd);
+                /* in-memory copy of pioavail registers */
+                ret = ipath_mmap_mem(vma, pd, PAGE_SIZE, 0,
+                                     dd->ipath_pioavailregs_phys,
+                                     "pioavail registers");
         else
                 ret = -EINVAL;
 
@@ -1539,14 +1486,6 @@ static int ipath_close(struct inode *in, struct file *fp)
         }
 
         if (dd->ipath_kregbase) {
-                if (pd->port_rcvhdrtail_uaddr) {
-                        pd->port_rcvhdrtail_uaddr = 0;
-                        pd->port_rcvhdrtail_kvaddr = NULL;
-                        ipath_release_user_pages_on_close(
-                                &pd->port_rcvhdrtail_pagep, 1);
-                        pd->port_rcvhdrtail_pagep = NULL;
-                        ipath_stats.sps_pageunlocks++;
-                }
                 ipath_write_kreg_port(
                         dd, dd->ipath_kregs->kr_rcvhdrtailaddr,
                         port, 0ULL);
@@ -1583,9 +1522,9 @@ static int ipath_close(struct inode *in, struct file *fp)
 
         dd->ipath_f_clear_tids(dd, pd->port_port);
 
-        ipath_free_pddata(dd, pd->port_port, 0);
-
+        dd->ipath_pd[pd->port_port] = NULL; /* before releasing mutex */
         mutex_unlock(&ipath_mutex);
+        ipath_free_pddata(dd, pd); /* after releasing the mutex */
 
         return ret;
 }
@@ -1905,3 +1844,4 @@ void ipath_user_remove(struct ipath_devdata *dd)
 bail:
         return;
 }
+
diff --git a/drivers/infiniband/hw/ipath/ipath_init_chip.c b/drivers/infiniband/hw/ipath/ipath_init_chip.c
index 37cd96e96e3e..385605f63f0f 100644
--- a/drivers/infiniband/hw/ipath/ipath_init_chip.c
+++ b/drivers/infiniband/hw/ipath/ipath_init_chip.c
@@ -411,17 +411,8 @@ static int init_pioavailregs(struct ipath_devdata *dd)
         /* and its length */
         dd->ipath_freezelen = L1_CACHE_BYTES - sizeof(dd->ipath_statusp[0]);
 
-        if (dd->ipath_unit * 64 > (IPATH_PORT0_RCVHDRTAIL_SIZE - 64)) {
-                ipath_dev_err(dd, "unit %u too large for port 0 "
-                              "rcvhdrtail buffer size\n", dd->ipath_unit);
-                ret = -ENODEV;
-        }
-        else
-                ret = 0;
+        ret = 0;
 
-        /* so we can get current tail in ipath_kreceive(), per chip */
-        dd->ipath_hdrqtailptr = &ipath_port0_rcvhdrtail[
-                dd->ipath_unit * (64 / sizeof(*ipath_port0_rcvhdrtail))];
 done:
         return ret;
 }
@@ -654,7 +645,7 @@ int ipath_init_chip(struct ipath_devdata *dd, int reinit)
 {
         int ret = 0, i;
         u32 val32, kpiobufs;
-        u64 val, atmp;
+        u64 val;
         struct ipath_portdata *pd = NULL; /* keep gcc4 happy */
 
         ret = init_housekeeping(dd, &pd, reinit);
@@ -777,24 +768,6 @@ int ipath_init_chip(struct ipath_devdata *dd, int reinit)
                 goto done;
         }
 
-        val = ipath_port0_rcvhdrtail_dma + dd->ipath_unit * 64;
-
-        /* verify that the alignment requirement was met */
-        ipath_write_kreg_port(dd, dd->ipath_kregs->kr_rcvhdrtailaddr,
-                              0, val);
-        atmp = ipath_read_kreg64_port(
-                dd, dd->ipath_kregs->kr_rcvhdrtailaddr, 0);
-        if (val != atmp) {
-                ipath_dev_err(dd, "Catastrophic software error, "
-                              "RcvHdrTailAddr0 written as %llx, "
-                              "read back as %llx from %x\n",
-                              (unsigned long long) val,
-                              (unsigned long long) atmp,
-                              dd->ipath_kregs->kr_rcvhdrtailaddr);
-                ret = -EINVAL;
-                goto done;
-        }
-
         ipath_write_kreg(dd, dd->ipath_kregs->kr_rcvbthqp, IPATH_KD_QP);
 
         /*
@@ -845,12 +818,18 @@ int ipath_init_chip(struct ipath_devdata *dd, int reinit)
          * re-init, the simplest way to handle this is to free
          * existing, and re-allocate.
          */
-        if (reinit)
-                ipath_free_pddata(dd, 0, 0);
+        if (reinit) {
+                struct ipath_portdata *pd = dd->ipath_pd[0];
+                dd->ipath_pd[0] = NULL;
+                ipath_free_pddata(dd, pd);
+        }
         dd->ipath_f_tidtemplate(dd);
         ret = ipath_create_rcvhdrq(dd, pd);
-        if (!ret)
+        if (!ret) {
+                dd->ipath_hdrqtailptr =
+                        (volatile __le64 *)pd->port_rcvhdrtail_kvaddr;
                 ret = create_port0_egr(dd);
+        }
         if (ret)
                 ipath_dev_err(dd, "failed to allocate port 0 (kernel) "
                               "rcvhdrq and/or egr bufs\n");
diff --git a/drivers/infiniband/hw/ipath/ipath_intr.c b/drivers/infiniband/hw/ipath/ipath_intr.c
index 9004be32f3e6..8a4d732b4858 100644
--- a/drivers/infiniband/hw/ipath/ipath_intr.c
+++ b/drivers/infiniband/hw/ipath/ipath_intr.c
@@ -37,6 +37,7 @@
 #include "ips_common.h"
 #include "ipath_layer.h"
 
+/* These are all rcv-related errors which we want to count for stats */
 #define E_SUM_PKTERRS \
         (INFINIPATH_E_RHDRLEN | INFINIPATH_E_RBADTID | \
          INFINIPATH_E_RBADVERSION | INFINIPATH_E_RHDR | \
@@ -45,6 +46,7 @@
          INFINIPATH_E_RFORMATERR | INFINIPATH_E_RUNSUPVL | \
          INFINIPATH_E_RUNEXPCHAR | INFINIPATH_E_REBP)
 
+/* These are all send-related errors which we want to count for stats */
 #define E_SUM_ERRS \
         (INFINIPATH_E_SPIOARMLAUNCH | INFINIPATH_E_SUNEXPERRPKTNUM | \
          INFINIPATH_E_SDROPPEDDATAPKT | INFINIPATH_E_SDROPPEDSMPPKT | \
@@ -52,6 +54,18 @@
          INFINIPATH_E_SMINPKTLEN | INFINIPATH_E_SPKTLEN | \
          INFINIPATH_E_INVALIDADDR)
 
+/*
+ * these are errors that can occur when the link changes state while
+ * a packet is being sent or received.  This doesn't cover things
+ * like EBP or VCRC that can be the result of a sending having the
+ * link change state, so we receive a "known bad" packet.
+ */
+#define E_SUM_LINK_PKTERRS \
+        (INFINIPATH_E_SDROPPEDDATAPKT | INFINIPATH_E_SDROPPEDSMPPKT | \
+         INFINIPATH_E_SMINPKTLEN | INFINIPATH_E_SPKTLEN | \
+         INFINIPATH_E_RSHORTPKTLEN | INFINIPATH_E_RMINPKTLEN | \
+         INFINIPATH_E_RUNEXPCHAR)
+
 static u64 handle_e_sum_errs(struct ipath_devdata *dd, ipath_err_t errs)
 {
         unsigned long sbuf[4];
@@ -101,9 +115,7 @@ static u64 handle_e_sum_errs(struct ipath_devdata *dd, ipath_err_t errs)
                 if (ipath_debug & __IPATH_PKTDBG)
                         printk("\n");
         }
-        if ((errs & (INFINIPATH_E_SDROPPEDDATAPKT |
-                     INFINIPATH_E_SDROPPEDSMPPKT |
-                     INFINIPATH_E_SMINPKTLEN)) &&
+        if ((errs & E_SUM_LINK_PKTERRS) &&
             !(dd->ipath_flags & IPATH_LINKACTIVE)) {
                 /*
                  * This can happen when SMA is trying to bring the link
@@ -112,11 +124,9 @@ static u64 handle_e_sum_errs(struct ipath_devdata *dd, ipath_err_t errs)
                  * valid.  We don't want to confuse people, so we just
                  * don't print them, except at debug
                  */
-                ipath_dbg("Ignoring pktsend errors %llx, because not "
-                          "yet active\n", (unsigned long long) errs);
-                ignore_this_time = INFINIPATH_E_SDROPPEDDATAPKT |
-                        INFINIPATH_E_SDROPPEDSMPPKT |
-                        INFINIPATH_E_SMINPKTLEN;
+                ipath_dbg("Ignoring packet errors %llx, because link not "
+                          "ACTIVE\n", (unsigned long long) errs);
+                ignore_this_time = errs & E_SUM_LINK_PKTERRS;
         }
 
         return ignore_this_time;
@@ -157,7 +167,29 @@ static void handle_e_ibstatuschanged(struct ipath_devdata *dd,
          */
         val = ipath_read_kreg64(dd, dd->ipath_kregs->kr_ibcstatus);
         lstate = val & IPATH_IBSTATE_MASK;
-        if (lstate == IPATH_IBSTATE_INIT || lstate == IPATH_IBSTATE_ARM ||
+
+        /*
+         * this is confusing enough when it happens that I want to always put it
+         * on the console and in the logs.  If it was a requested state change,
+         * we'll have already cleared the flags, so we won't print this warning
+         */
+        if ((lstate != IPATH_IBSTATE_ARM && lstate != IPATH_IBSTATE_ACTIVE)
+                && (dd->ipath_flags & (IPATH_LINKARMED | IPATH_LINKACTIVE))) {
+                dev_info(&dd->pcidev->dev, "Link state changed from %s to %s\n",
+                                 (dd->ipath_flags & IPATH_LINKARMED) ? "ARM" : "ACTIVE",
+                                 ib_linkstate(lstate));
+                /*
+                 * Flush all queued sends when link went to DOWN or INIT,
+                 * to be sure that they don't block SMA and other MAD packets
+                 */
+                ipath_write_kreg(dd, dd->ipath_kregs->kr_sendctrl,
+                                 INFINIPATH_S_ABORT);
+                ipath_disarm_piobufs(dd, dd->ipath_lastport_piobuf,
+                                                        (unsigned)(dd->ipath_piobcnt2k +
+                                        dd->ipath_piobcnt4k) -
+                                        dd->ipath_lastport_piobuf);
+        }
+        else if (lstate == IPATH_IBSTATE_INIT || lstate == IPATH_IBSTATE_ARM ||
             lstate == IPATH_IBSTATE_ACTIVE) {
                 /*
                  * only print at SMA if there is a change, debug if not
@@ -380,6 +412,19 @@ static void handle_errors(struct ipath_devdata *dd, ipath_err_t errs)
 
         if (errs & E_SUM_ERRS)
                 ignore_this_time = handle_e_sum_errs(dd, errs);
+        else if ((errs & E_SUM_LINK_PKTERRS) &&
+            !(dd->ipath_flags & IPATH_LINKACTIVE)) {
+                /*
+                 * This can happen when SMA is trying to bring the link
+                 * up, but the IB link changes state at the "wrong" time.
+                 * The IB logic then complains that the packet isn't
+                 * valid.  We don't want to confuse people, so we just
+                 * don't print them, except at debug
+                 */
+                ipath_dbg("Ignoring packet errors %llx, because link not "
+                          "ACTIVE\n", (unsigned long long) errs);
+                ignore_this_time = errs & E_SUM_LINK_PKTERRS;
+        }
 
         if (supp_msgs == 250000) {
                 /*
diff --git a/drivers/infiniband/hw/ipath/ipath_kernel.h b/drivers/infiniband/hw/ipath/ipath_kernel.h
index d9764c289bd1..493100dfbf59 100644
--- a/drivers/infiniband/hw/ipath/ipath_kernel.h
+++ b/drivers/infiniband/hw/ipath/ipath_kernel.h
@@ -62,9 +62,7 @@ struct ipath_portdata {
         /* rcvhdrq base, needs mmap before useful */
         void *port_rcvhdrq;
         /* kernel virtual address where hdrqtail is updated */
-        u64 *port_rcvhdrtail_kvaddr;
-        /* page * used for uaddr */
-        struct page *port_rcvhdrtail_pagep;
+        volatile __le64 *port_rcvhdrtail_kvaddr;
         /*
          * temp buffer for expected send setup, allocated at open, instead
          * of each setup call
@@ -79,11 +77,7 @@ struct ipath_portdata {
         dma_addr_t port_rcvegr_phys;
         /* mmap of hdrq, must fit in 44 bits */
         dma_addr_t port_rcvhdrq_phys;
-        /*
-         * the actual user address that we ipath_mlock'ed, so we can
-         * ipath_munlock it at close
-         */
-        unsigned long port_rcvhdrtail_uaddr;
+        dma_addr_t port_rcvhdrqtailaddr_phys;
         /*
          * number of opens on this instance (0 or 1; ignoring forks, dup,
          * etc. for now)
@@ -515,11 +509,6 @@ struct ipath_devdata {
         u8 ipath_lmc;
 };
 
-extern volatile __le64 *ipath_port0_rcvhdrtail;
-extern dma_addr_t ipath_port0_rcvhdrtail_dma;
-
-#define IPATH_PORT0_RCVHDRTAIL_SIZE PAGE_SIZE
-
 extern struct list_head ipath_dev_list;
 extern spinlock_t ipath_devs_lock;
 extern struct ipath_devdata *ipath_lookup(int unit);
@@ -579,7 +568,7 @@ void ipath_disarm_piobufs(struct ipath_devdata *, unsigned first,
                           unsigned cnt);
 
 int ipath_create_rcvhdrq(struct ipath_devdata *, struct ipath_portdata *);
-void ipath_free_pddata(struct ipath_devdata *, u32, int);
+void ipath_free_pddata(struct ipath_devdata *, struct ipath_portdata *);
 
 int ipath_parse_ushort(const char *str, unsigned short *valp);