Source-Changes-HG archive
[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index][Old Index]
[src/netbsd-8]: src/sys/dev/usb Pull up following revision(s) (requested by s...
details: https://anonhg.NetBSD.org/src/rev/4489f6ea1062
branches: netbsd-8
changeset: 947183:4489f6ea1062
user: martin <martin%NetBSD.org@localhost>
date: Sat Dec 12 20:30:57 2020 +0000
description:
Pull up following revision(s) (requested by skrll in ticket #1637):
sys/dev/usb/ohci.c: revision 1.311
sys/dev/usb/ohci.c: revision 1.312
sys/dev/usb/ohcivar.h: revision 1.62
Restructure the abort code for TD based transfers (ctrl, bulk, intr).
In PR kern/22646 some TDs can be on the done queue when the abort start
and, if this is the case, they need to processed after the WDH interrupt.
Instead of waiting for WDH we release TDs that have been touched by the
HC and replace them with new ones. Once WDH happens the floating TDs
will be returned to the free list.
Also addresses the issue seen in PR kern/55835
Thanks to both Andreas Gustafsson and Edgar Fu=C3=9F for testing. Apologi=
es to
Andreas Gustafsson for not committing this to HEAD for 4y6m.w
Remove leading space that crept in in the last change
diffstat:
sys/dev/usb/ohci.c | 203 ++++++++++++++++++++++++++++++++++++++++++-------
sys/dev/usb/ohcivar.h | 11 ++-
2 files changed, 181 insertions(+), 33 deletions(-)
diffs (truncated from 451 to 300 lines):
diff -r 130b80345567 -r 4489f6ea1062 sys/dev/usb/ohci.c
--- a/sys/dev/usb/ohci.c Sat Dec 12 13:00:18 2020 +0000
+++ b/sys/dev/usb/ohci.c Sat Dec 12 20:30:57 2020 +0000
@@ -1,4 +1,4 @@
-/* $NetBSD: ohci.c,v 1.273.6.6 2020/02/25 18:52:44 martin Exp $ */
+/* $NetBSD: ohci.c,v 1.273.6.7 2020/12/12 20:30:57 martin Exp $ */
/*
* Copyright (c) 1998, 2004, 2005, 2012 The NetBSD Foundation, Inc.
@@ -41,7 +41,7 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ohci.c,v 1.273.6.6 2020/02/25 18:52:44 martin Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ohci.c,v 1.273.6.7 2020/12/12 20:30:57 martin Exp $");
#ifdef _KERNEL_OPT
#include "opt_usb.h"
@@ -390,6 +390,7 @@
if (sc->sc_hcca != NULL)
usb_freemem(&sc->sc_bus, &sc->sc_hccadma);
pool_cache_destroy(sc->sc_xferpool);
+ cv_destroy(&sc->sc_abort_cv);
return rv;
}
@@ -492,6 +493,7 @@
memset(&std->td, 0, sizeof(ohci_td_t));
std->nexttd = NULL;
std->xfer = NULL;
+ std->held = NULL;
return std;
}
@@ -539,14 +541,17 @@
DPRINTFN(8, "xfer %#jx nstd %jd", (uintptr_t)xfer, nstd, 0, 0);
- for (size_t j = 0; j < ox->ox_nstd;) {
+ for (size_t j = 0; j < ox->ox_nstd; j++) {
ohci_soft_td_t *cur = ohci_alloc_std(sc);
if (cur == NULL)
goto nomem;
- ox->ox_stds[j++] = cur;
+ ox->ox_stds[j] = cur;
+ cur->held = &ox->ox_stds[j];
cur->xfer = xfer;
cur->flags = 0;
+ DPRINTFN(10, "xfer=%#jx new std=%#jx held at %#jx", (uintptr_t)ox,
+ (uintptr_t)cur, (uintptr_t)cur->held, 0);
}
return 0;
@@ -797,6 +802,9 @@
for (i = 0; i < OHCI_HASH_SIZE; i++)
LIST_INIT(&sc->sc_hash_itds[i]);
+ TAILQ_INIT(&sc->sc_abortingxfers);
+ cv_init(&sc->sc_abort_cv, "ohciabt");
+
sc->sc_xferpool = pool_cache_init(sizeof(struct ohci_xfer), 0, 0, 0,
"ohcixfer", NULL, IPL_USB, NULL, NULL, NULL);
@@ -1313,6 +1321,21 @@
*/
usb_schedsoftintr(&sc->sc_bus);
}
+ if (eintrs & OHCI_SF) {
+ struct ohci_xfer *ox, *tmp;
+ TAILQ_FOREACH_SAFE(ox, &sc->sc_abortingxfers, ox_abnext, tmp) {
+ DPRINTFN(10, "SF %#jx xfer %#jx", (uintptr_t)sc,
+ (uintptr_t)ox, 0, 0);
+ ox->ox_abintrs &= ~OHCI_SF;
+ KASSERT(ox->ox_abintrs == 0);
+ TAILQ_REMOVE(&sc->sc_abortingxfers, ox, ox_abnext);
+ }
+ cv_broadcast(&sc->sc_abort_cv);
+
+ KASSERT(TAILQ_EMPTY(&sc->sc_abortingxfers));
+ DPRINTFN(10, "end SOF %#jx", (uintptr_t)sc, 0, 0, 0);
+ /* Don't remove OHIC_SF from eintrs so it is blocked below */
+ }
if (eintrs & OHCI_RD) {
/* 1 argument, but zero format strings */
DPRINTFN(5, "resume detect", (uintptr_t)sc, 0, 0, 0);
@@ -1391,12 +1414,22 @@
struct ohci_pipe *opipe;
int len, cc;
int i, j, actlen, iframes, uedir;
- ohci_physaddr_t done;
+ ohci_physaddr_t done = 0;
KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
OHCIHIST_FUNC(); OHCIHIST_CALLED();
+ /*
+ * Only read hccadone if WDH is set - we might get here from places
+ * other than an interrupt
+ */
+ if (!(OREAD4(sc, OHCI_INTERRUPT_STATUS) & OHCI_WDH)) {
+ DPRINTFN(10, "no WDH %#jx", (uintptr_t)sc, 0, 0, 0);
+ return;
+ }
+
+ DPRINTFN(10, "WDH %#jx", (uintptr_t)sc, 0, 0, 0);
usb_syncmem(&sc->sc_hccadma, offsetof(struct ohci_hcca, hcca_done_head),
sizeof(sc->sc_hcca->hcca_done_head),
BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
@@ -1449,11 +1482,19 @@
DPRINTFN(10, "--- TD dump end ---", 0, 0, 0, 0);
for (std = sdone; std; std = stdnext) {
+ stdnext = std->dnext;
+ if (std->held == NULL) {
+ DPRINTFN(10, "std=%#jx held is null", (uintptr_t)std,
+ 0, 0, 0);
+ ohci_hash_rem_td(sc, std);
+ ohci_free_std_locked(sc, std);
+ continue;
+ }
+
xfer = std->xfer;
- stdnext = std->dnext;
- DPRINTFN(10, "std=%#jx xfer=%#jx hcpriv=%#jx", (uintptr_t)std,
- (uintptr_t)xfer, (uintptr_t)(xfer ? xfer->ux_hcpriv : 0),
- 0);
+ DPRINTFN(10, "std=%#jx xfer=%#jx hcpriv=%#jx dnext=%#jx",
+ (uintptr_t)std, (uintptr_t)xfer,
+ (uintptr_t)(xfer ? xfer->ux_hcpriv : 0), (uintptr_t)stdnext);
if (xfer == NULL) {
/*
* xfer == NULL: There seems to be no xfer associated
@@ -1463,7 +1504,6 @@
*/
continue;
}
-
/*
* If software has completed it, either by cancellation
* or timeout, drop it on the floor.
@@ -2095,6 +2135,7 @@
goto bad;
opipe->tail.itd = sitd;
+ sitd->held = &opipe->tail.itd;
tdphys = sitd->physaddr;
fmt = OHCI_ED_FORMAT_ISO;
if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN)
@@ -2107,6 +2148,7 @@
goto bad;
opipe->tail.td = std;
+ std->held = &opipe->tail.td;
tdphys = std->physaddr;
fmt = OHCI_ED_FORMAT_GEN | OHCI_ED_DIR_TD;
}
@@ -2296,35 +2338,65 @@
}
/*
- * HC Step 1: Unless the endpoint is already halted, we set the endpoint
- * descriptor sKip bit and wait for hardware to complete processing.
- *
- * This includes ensuring that any TDs of the transfer that got onto
- * the done list are also removed. We ensure this by waiting for
- * both a WDH and SOF interrupt.
+ * HC Step 1: Unless the endpoint is already halted, we set the
+ * endpoint descriptor sKip bit and wait for hardware to complete
+ * processing. We ensure the HC stops processing the endpoint by
+ * waiting for the next start of frame (OHCI_SF)
*/
DPRINTFN(1, "stop ed=%#jx", (uintptr_t)sed, 0, 0, 0);
usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_flags),
sizeof(sed->ed.ed_flags),
BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
- sed->ed.ed_flags |= HTOO32(OHCI_ED_SKIP); /* force hardware skip */
- usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_flags),
- sizeof(sed->ed.ed_flags),
- BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
-
- /*
- * HC Step 2: Wait until we know hardware has finished any possible
- * use of the xfer.
- */
- /* Hardware finishes in 1ms */
- usb_delay_ms_locked(opipe->pipe.up_dev->ud_bus, 20, &sc->sc_lock);
+ if (!(sed->ed.ed_flags & OHCI_HALTED)) {
+ /* force hardware skip */
+ DPRINTFN(1, "pausing ed=%#jx", (uintptr_t)sed, 0, 0, 0);
+ sed->ed.ed_flags |= HTOO32(OHCI_ED_SKIP);
+ usb_syncmem(&sed->dma,
+ sed->offs + offsetof(ohci_ed_t, ed_flags),
+ sizeof(sed->ed.ed_flags),
+ BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
+
+ DPRINTFN(10, "SF %#jx xfer %#jx", (uintptr_t)sc,
+ (uintptr_t)xfer, 0, 0);
+
+ struct ohci_xfer *ox = OHCI_XFER2OXFER(xfer);
+ ox->ox_abintrs = OHCI_SF;
+
+ mutex_enter(&sc->sc_intr_lock);
+ TAILQ_INSERT_TAIL(&sc->sc_abortingxfers, ox, ox_abnext);
+
+ /* Clear any previous SF interrupt */
+ OWRITE4(sc, OHCI_INTERRUPT_STATUS, OHCI_SF);
+
+ /* Tell interrupt handler and HC SF interrupt is requested */
+ sc->sc_eintrs |= OHCI_SF;
+ OWRITE4(sc, OHCI_INTERRUPT_ENABLE, OHCI_SF);
+ /*
+ * Step 2: Wait until we know hardware has finished any
+ * processing of the end-point.
+ */
+ while (ox->ox_abintrs != 0) {
+ DPRINTFN(10, "SF %#jx xfer %#jx intrs %#x",
+ (uintptr_t)sc, (uintptr_t)xfer,
+ (uintptr_t)ox->ox_abintrs, 0);
+ cv_wait(&sc->sc_abort_cv, &sc->sc_intr_lock);
+ }
+ mutex_exit(&sc->sc_intr_lock);
+ } else {
+ DPRINTFN(1, "halted ed=%#jx", (uintptr_t)sed, 0, 0, 0);
+ }
/*
* HC Step 3: Remove any vestiges of the xfer from the hardware.
- * The complication here is that the hardware may have executed
- * beyond the xfer we're trying to abort. So as we're scanning
- * the TDs of this xfer we check if the hardware points to
- * any of them.
+ * There are two complications here
+ *
+ * 1) the hardware may have executed beyond the xfer we're trying to
+ * abort. So as we're scanning the TDs of this xfer we check if
+ * the hardware points to any of them.
+ *
+ * 2) the hardware may have only partially excuted the transfer
+ * which means some TDs will appear on the done list. Wait for
+ * WDH so we can remove them safely.
*/
p = xfer->ux_hcpriv;
KASSERT(p);
@@ -2339,12 +2411,47 @@
}
DPRINTF("--- dump end ---", 0, 0, 0, 0);
#endif
+
+
+#define OHCI_CC_ACCESSED_P(x) \
+ (((x) & OHCI_CC_NOT_ACCESSED_MASK) != OHCI_CC_NOT_ACCESSED)
+
headp = O32TOH(sed->ed.ed_headp) & OHCI_HEADMASK;
hit = 0;
for (; p->xfer == xfer; p = n) {
hit |= headp == p->physaddr;
n = p->nexttd;
- ohci_hash_rem_td(sc, p);
+
+ int cc = OHCI_TD_GET_CC(O32TOH(p->td.td_flags));
+ if (!OHCI_CC_ACCESSED_P(cc)) {
+ ohci_hash_rem_td(sc, p);
+ continue;
+ }
+ DPRINTFN(10, "xfer=%#jx has been touched by HC", (uintptr_t)p,
+ 0, 0, 0);
+
+ mutex_exit(&sc->sc_lock);
+ ohci_soft_td_t *std;
+ for (;;) {
+ std = ohci_alloc_std(sc);
+ if (std)
+ break;
+ kpause("ohciabt2", true, hz, NULL);
+ }
+
+ mutex_enter(&sc->sc_lock);
+ if (sc->sc_dying) {
+ DPRINTFN(4, "xfer %#jx dying %ju", (uintptr_t)xfer,
+ xfer->ux_status, 0, 0);
+ goto dying;
+ }
+
+ DPRINTFN(10, "new std=%#jx now held at %#jx", (uintptr_t)std,
+ (uintptr_t)p->held, 0, 0);
+ *(p->held) = std;
+ std->held = p->held;
+ std->xfer = xfer;
+ p->held = NULL;
}
/* Zap headp register if hardware pointed inside the xfer. */
if (hit) {
@@ -2677,6 +2784,13 @@
ox->ox_setup = setup;
ox->ox_stat = stat;
ox->ox_nstd = 0;
+ setup->held = &ox->ox_setup;
+ stat->held = &ox->ox_stat;
Home |
Main Index |
Thread Index |
Old Index