6 files changed, 68 insertions, 38 deletions

diff --git a/drivers/infiniband/hw/ipath/ipath_driver.c b/drivers/infiniband/hw/ipath/ipath_driver.c
index e9639860b48d..8b611796f33e 100644
--- a/drivers/infiniband/hw/ipath/ipath_driver.c
+++ b/drivers/infiniband/hw/ipath/ipath_driver.c
@@ -706,9 +706,9 @@ void ipath_disarm_piobufs(struct ipath_devdata *dd, unsigned first,
         u64 sendctrl, sendorig;
 
         ipath_cdbg(PKT, "disarm %u PIObufs first=%u\n", cnt, first);
-        sendorig = dd->ipath_sendctrl | INFINIPATH_S_DISARM;
+        sendorig = dd->ipath_sendctrl;
         for (i = first; i < last; i++) {
-                sendctrl = sendorig |
+                sendctrl = sendorig  | INFINIPATH_S_DISARM |
                         (i << INFINIPATH_S_DISARMPIOBUF_SHIFT);
                 ipath_write_kreg(dd, dd->ipath_kregs->kr_sendctrl,
                                  sendctrl);
@@ -719,12 +719,12 @@ void ipath_disarm_piobufs(struct ipath_devdata *dd, unsigned first,
          * while we were looping; no critical bits that would require
          * locking.
          *
-         * Write a 0, and then the original value, reading scratch in
+         * disable PIOAVAILUPD, then re-enable, reading scratch in
          * between.  This seems to avoid a chip timing race that causes
          * pioavail updates to memory to stop.
          */
         ipath_write_kreg(dd, dd->ipath_kregs->kr_sendctrl,
-                         0);
+                         sendorig & ~IPATH_S_PIOBUFAVAILUPD);
         sendorig = ipath_read_kreg64(dd, dd->ipath_kregs->kr_scratch);
         ipath_write_kreg(dd, dd->ipath_kregs->kr_sendctrl,
                          dd->ipath_sendctrl);
@@ -1596,6 +1596,35 @@ int ipath_waitfor_mdio_cmdready(struct ipath_devdata *dd)
         return ret;
 }
 
+
+/*
+ * Flush all sends that might be in the ready to send state, as well as any
+ * that are in the process of being sent.   Used whenever we need to be
+ * sure the send side is idle.  Cleans up all buffer state by canceling
+ * all pio buffers, and issuing an abort, which cleans up anything in the
+ * launch fifo.  The cancel is superfluous on some chip versions, but
+ * it's safer to always do it.
+ * PIOAvail bits are updated by the chip as if normal send had happened.
+ */
+void ipath_cancel_sends(struct ipath_devdata *dd)
+{
+        ipath_dbg("Cancelling all in-progress send buffers\n");
+        dd->ipath_lastcancel = jiffies+HZ/2; /* skip armlaunch errs a bit */
+        /*
+         * the abort bit is auto-clearing.  We read scratch to be sure
+         * that cancels and the abort have taken effect in the chip.
+         */
+        ipath_write_kreg(dd, dd->ipath_kregs->kr_sendctrl,
+                INFINIPATH_S_ABORT);
+        ipath_read_kreg64(dd, dd->ipath_kregs->kr_scratch);
+        ipath_disarm_piobufs(dd, 0,
+                (unsigned)(dd->ipath_piobcnt2k + dd->ipath_piobcnt4k));
+
+        /* and again, be sure all have hit the chip */
+        ipath_read_kreg64(dd, dd->ipath_kregs->kr_scratch);
+}
+
+
 static void ipath_set_ib_lstate(struct ipath_devdata *dd, int which)
 {
         static const char *what[4] = {
@@ -1617,14 +1646,8 @@ static void ipath_set_ib_lstate(struct ipath_devdata *dd, int which)
                            INFINIPATH_IBCS_LINKTRAININGSTATE_MASK]);
         /* flush all queued sends when going to DOWN or INIT, to be sure that
          * they don't block 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);
-        }
+        if (!linkcmd || linkcmd == INFINIPATH_IBCC_LINKCMD_INIT)
+                ipath_cancel_sends(dd);
 
         ipath_write_kreg(dd, dd->ipath_kregs->kr_ibcctrl,
                          dd->ipath_ibcctrl | which);
@@ -1967,17 +1990,9 @@ void ipath_shutdown_device(struct ipath_devdata *dd)
          */
         udelay(5);
 
-        /*
-         * abort any armed or launched PIO buffers that didn't go. (self
-         * clearing).  Will cause any packet currently being transmitted to
-         * go out with an EBP, and may also cause a short packet error on
-         * the receiver.
-         */
-        ipath_write_kreg(dd, dd->ipath_kregs->kr_sendctrl,
-                         INFINIPATH_S_ABORT);
-
         ipath_set_ib_lstate(dd, INFINIPATH_IBCC_LINKINITCMD_DISABLE <<
                             INFINIPATH_IBCC_LINKINITCMD_SHIFT);
+        ipath_cancel_sends(dd);
 
         /* disable IBC */
         dd->ipath_control &= ~INFINIPATH_C_LINKENABLE;
diff --git a/drivers/infiniband/hw/ipath/ipath_iba6110.c b/drivers/infiniband/hw/ipath/ipath_iba6110.c
index d8ac9f18bf49..34d159ad97b4 100644
--- a/drivers/infiniband/hw/ipath/ipath_iba6110.c
+++ b/drivers/infiniband/hw/ipath/ipath_iba6110.c
@@ -509,6 +509,13 @@ static void ipath_ht_handle_hwerrors(struct ipath_devdata *dd, char *msg,
                 if (!hwerrs) {
                         ipath_dbg("Clearing freezemode on ignored or "
                                   "recovered hardware error\n");
+                        /*
+                         * clear all sends, becauase they have may been
+                         * completed by usercode while in freeze mode, and
+                         * therefore would not be sent, and eventually
+                         * might cause the process to run out of bufs
+                         */
+                        ipath_cancel_sends(dd);
                         ctrl &= ~INFINIPATH_C_FREEZEMODE;
                         ipath_write_kreg(dd, dd->ipath_kregs->kr_control,
                                          ctrl);
@@ -1566,11 +1573,6 @@ static int ipath_ht_early_init(struct ipath_devdata *dd)
                 writel(16, piobuf);
                 piobuf += pioincr;
         }
-        /*
-         * self-clearing
-         */
-        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' &&
@@ -1599,7 +1601,6 @@ static int ipath_ht_txe_recover(struct ipath_devdata *dd)
         }
         dev_info(&dd->pcidev->dev,
                 "Recovering from TXE PIO parity error\n");
-        ipath_disarm_senderrbufs(dd, 1);
         return 1;
 }
 
diff --git a/drivers/infiniband/hw/ipath/ipath_iba6120.c b/drivers/infiniband/hw/ipath/ipath_iba6120.c
index b931057bb3e8..0c34555d4979 100644
--- a/drivers/infiniband/hw/ipath/ipath_iba6120.c
+++ b/drivers/infiniband/hw/ipath/ipath_iba6120.c
@@ -430,8 +430,19 @@ static void ipath_pe_handle_hwerrors(struct ipath_devdata *dd, char *msg,
                         *dd->ipath_statusp |= IPATH_STATUS_HWERROR;
                         dd->ipath_flags &= ~IPATH_INITTED;
                 } else {
-                        ipath_dbg("Clearing freezemode on ignored hardware "
-                                  "error\n");
+                        static u32 freeze_cnt;
+
+                        freeze_cnt++;
+                        ipath_dbg("Clearing freezemode on ignored or recovered "
+                                  "hardware error (%u)\n", freeze_cnt);
+                        /*
+                         * clear all sends, becauase they have may been
+                         * completed by usercode while in freeze mode, and
+                         * therefore would not be sent, and eventually
+                         * might cause the process to run out of bufs
+                         */
+                        ipath_cancel_sends(dd);
+                        ctrl &= ~INFINIPATH_C_FREEZEMODE;
                         ipath_write_kreg(dd, dd->ipath_kregs->kr_control,
                                          dd->ipath_control);
                 }
@@ -1371,7 +1382,6 @@ static int ipath_pe_txe_recover(struct ipath_devdata *dd)
                 dev_info(&dd->pcidev->dev,
                         "Recovering from TXE PIO parity error\n");
         }
-        ipath_disarm_senderrbufs(dd, 1);
         return 1;
 }
 
diff --git a/drivers/infiniband/hw/ipath/ipath_init_chip.c b/drivers/infiniband/hw/ipath/ipath_init_chip.c
index 9f611553ffb3..5193d6945caa 100644
--- a/drivers/infiniband/hw/ipath/ipath_init_chip.c
+++ b/drivers/infiniband/hw/ipath/ipath_init_chip.c
@@ -777,6 +777,12 @@ int ipath_init_chip(struct ipath_devdata *dd, int reinit)
                    piobufs, dd->ipath_pbufsport, uports);
 
         dd->ipath_f_early_init(dd);
+        /*
+         * cancel any possible active sends from early driver load.
+         * Follows early_init because some chips have to initialize
+         * PIO buffers in early_init to avoid false parity errors.
+         */
+        ipath_cancel_sends(dd);
 
         /* early_init sets rcvhdrentsize and rcvhdrsize, so this must be
          * done after early_init */
diff --git a/drivers/infiniband/hw/ipath/ipath_intr.c b/drivers/infiniband/hw/ipath/ipath_intr.c
index d9cdd00c8233..948091f7d5ac 100644
--- a/drivers/infiniband/hw/ipath/ipath_intr.c
+++ b/drivers/infiniband/hw/ipath/ipath_intr.c
@@ -93,7 +93,8 @@ void ipath_disarm_senderrbufs(struct ipath_devdata *dd, int rewrite)
 
         if (sbuf[0] || sbuf[1] || (piobcnt > 128 && (sbuf[2] || sbuf[3]))) {
                 int i;
-                if (ipath_debug & (__IPATH_PKTDBG|__IPATH_DBG)) {
+                if (ipath_debug & (__IPATH_PKTDBG|__IPATH_DBG) &&
+                        dd->ipath_lastcancel > jiffies) {
                         __IPATH_DBG_WHICH(__IPATH_PKTDBG|__IPATH_DBG,
                                           "SendbufErrs %lx %lx", sbuf[0],
                                           sbuf[1]);
@@ -108,7 +109,8 @@ void ipath_disarm_senderrbufs(struct ipath_devdata *dd, int rewrite)
                                         ipath_clrpiobuf(dd, i);
                                 ipath_disarm_piobufs(dd, i, 1);
                         }
-                dd->ipath_lastcancel = jiffies+3; /* no armlaunch for a bit */
+                /* ignore armlaunch errs for a bit */
+                dd->ipath_lastcancel = jiffies+3;
         }
 }
 
@@ -290,12 +292,7 @@ static void handle_e_ibstatuschanged(struct ipath_devdata *dd,
                  * 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);
+                ipath_cancel_sends(dd);
         }
         else if (lstate == IPATH_IBSTATE_INIT || lstate == IPATH_IBSTATE_ARM ||
             lstate == IPATH_IBSTATE_ACTIVE) {
diff --git a/drivers/infiniband/hw/ipath/ipath_kernel.h b/drivers/infiniband/hw/ipath/ipath_kernel.h
index 2a4414b948ee..2e85aeca5eac 100644
--- a/drivers/infiniband/hw/ipath/ipath_kernel.h
+++ b/drivers/infiniband/hw/ipath/ipath_kernel.h
@@ -676,6 +676,7 @@ int ipath_unordered_wc(void);
 
 void ipath_disarm_piobufs(struct ipath_devdata *, unsigned first,
                           unsigned cnt);
+void ipath_cancel_sends(struct ipath_devdata *);
 
 int ipath_create_rcvhdrq(struct ipath_devdata *, struct ipath_portdata *);
 void ipath_free_pddata(struct ipath_devdata *, struct ipath_portdata *);