IB/ipath: Use S_ABORT not cancel and abort on exit freeze mode after recovery

This centralizes the use of the abort functionality, removes the
unneeded buffer cancel (abort does the same thing), sets up to ignore
launch errors after abort, same as cancel.  We need abort on exit from
freeze mode to avoid having buffers stuck in the busy state, if a user
process happened to complete the send while we were in freeze mode
doing the recovery.

Signed-off-by: Dave Olson <dave.olson@qlogic.com>
Signed-off-by: Roland Dreier <rolandd@cisco.com>

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 *);