Module Name: src
Committed By: martin
Date: Wed Oct 2 12:19:37 UTC 2024
Modified Files:
src/sys/dev/usb [netbsd-10]: ohci.c
Log Message:
Fix previous, pullup of revision 1.328 totally gone wrong, try again:
Pull up following revision(s) (requested by skrll in ticket #926):
sys/dev/usb/ohci.c: revision 1.328
Fix some usb_syncmem calls and add some missing ones.
To generate a diff of this commit:
cvs rdiff -u -r1.323.4.1 -r1.323.4.2 src/sys/dev/usb/ohci.c
Please note that diffs are not public domain; they are subject to the
copyright notices on the relevant files.
Modified files:
Index: src/sys/dev/usb/ohci.c
diff -u src/sys/dev/usb/ohci.c:1.323.4.1 src/sys/dev/usb/ohci.c:1.323.4.2
--- src/sys/dev/usb/ohci.c:1.323.4.1 Wed Oct 2 11:02:43 2024
+++ src/sys/dev/usb/ohci.c Wed Oct 2 12:19:37 2024
@@ -1,4 +1,4 @@
-/* $NetBSD: ohci.c,v 1.323.4.1 2024/10/02 11:02:43 martin Exp $ */
+/* $NetBSD: ohci.c,v 1.323.4.2 2024/10/02 12:19:37 martin Exp $ */
/*
* Copyright (c) 1998, 2004, 2005, 2012, 2016, 2020 The NetBSD Foundation, Inc.
@@ -42,7 +42,7 @@
*/
#include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ohci.c,v 1.323.4.1 2024/10/02 11:02:43 martin Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ohci.c,v 1.323.4.2 2024/10/02 12:19:37 martin Exp $");
#ifdef _KERNEL_OPT
#include "opt_usb.h"
@@ -409,29 +409,19 @@ ohci_alloc_sed(ohci_softc_t *sc)
DPRINTFN(2, "allocating chunk", 0, 0, 0, 0);
mutex_exit(&sc->sc_lock);
- int err = usb_allocmem(sc->sc_bus.ub_dmatag,
- OHCI_ED_SIZE * OHCI_ED_CHUNK,
- OHCI_ED_ALIGN, 0, &dma);
+ int err = usb_allocmem(sc->sc_bus.ub_dmatag, OHCI_SED_SIZE * OHCI_SED_CHUNK,
+ OHCI_ED_ALIGN, 0 /*!USBMALLOC_COHERENT*/, &dma);
if (err)
return NULL;
- ohci_soft_ed_t *seds =
- kmem_alloc(sizeof(*sed) * OHCI_ED_CHUNK, KM_SLEEP);
- /*
- * We can avoid USBMALLOC_COHERENT as the EDs are each on a
- * cacheline.
- */
mutex_enter(&sc->sc_lock);
- for (i = 0; i < OHCI_ED_CHUNK; i++) {
- offs = i * OHCI_ED_SIZE;
-
- sed = &seds[i];
- sed->ed = KERNADDR(&dma, offs);
+ for (i = 0; i < OHCI_SED_CHUNK; i++) {
+ offs = i * OHCI_SED_SIZE;
+ sed = KERNADDR(&dma, offs);
sed->physaddr = DMAADDR(&dma, offs);
sed->dma = dma;
sed->offs = offs;
sed->next = sc->sc_freeeds;
-
sc->sc_freeeds = sed;
}
}
@@ -439,7 +429,7 @@ ohci_alloc_sed(ohci_softc_t *sc)
sc->sc_freeeds = sed->next;
mutex_exit(&sc->sc_lock);
- memset(sed->ed, 0, sizeof(*sed->ed));
+ memset(&sed->ed, 0, sizeof(ohci_ed_t));
sed->next = 0;
return sed;
}
@@ -477,29 +467,19 @@ ohci_alloc_std(ohci_softc_t *sc)
DPRINTFN(2, "allocating chunk", 0, 0, 0, 0);
mutex_exit(&sc->sc_lock);
- ohci_soft_td_t *stds =
- kmem_alloc(sizeof(*std) * OHCI_TD_CHUNK, KM_SLEEP);
- /*
- * We can avoid USBMALLOC_COHERENT as the TDs are each on a
- * cacheline.
- */
- int err = usb_allocmem(sc->sc_bus.ub_dmatag,
- OHCI_TD_SIZE * OHCI_TD_CHUNK,
- OHCI_TD_ALIGN, 0, &dma);
+ int err = usb_allocmem(sc->sc_bus.ub_dmatag, OHCI_STD_SIZE * OHCI_STD_CHUNK,
+ OHCI_TD_ALIGN, USBMALLOC_COHERENT, &dma);
if (err)
return NULL;
mutex_enter(&sc->sc_lock);
- for (i = 0; i < OHCI_TD_CHUNK; i++) {
- offs = i * OHCI_TD_SIZE;
-
- std = &stds[i];
- std->td = KERNADDR(&dma, offs);
+ for (i = 0; i < OHCI_STD_CHUNK; i++) {
+ offs = i * OHCI_STD_SIZE;
+ std = KERNADDR(&dma, offs);
std->physaddr = DMAADDR(&dma, offs);
std->dma = dma;
std->offs = offs;
std->nexttd = sc->sc_freetds;
-
sc->sc_freetds = std;
}
}
@@ -508,7 +488,7 @@ ohci_alloc_std(ohci_softc_t *sc)
sc->sc_freetds = std->nexttd;
mutex_exit(&sc->sc_lock);
- memset(std->td, 0, sizeof(*std->td));
+ memset(&std->td, 0, sizeof(ohci_td_t));
std->nexttd = NULL;
std->xfer = NULL;
std->held = NULL;
@@ -671,10 +651,10 @@ ohci_reset_std_chain(ohci_softc_t *sc, s
DPRINTFN(4, "sdataphys=0x%08jx edataphys=0x%08jx "
"len=%jd curlen=%jd", sdataphys, edataphys, len, curlen);
- cur->td->td_flags = tdflags;
- cur->td->td_cbp = HTOO32(sdataphys);
- cur->td->td_be = HTOO32(edataphys);
- cur->td->td_nexttd = (next != NULL) ? HTOO32(next->physaddr) : 0;
+ cur->td.td_flags = tdflags;
+ cur->td.td_cbp = HTOO32(sdataphys);
+ cur->td.td_be = HTOO32(edataphys);
+ cur->td.td_nexttd = (next != NULL) ? HTOO32(next->physaddr) : 0;
cur->nexttd = next;
cur->len = curlen;
cur->flags = OHCI_ADD_LEN;
@@ -687,20 +667,20 @@ ohci_reset_std_chain(ohci_softc_t *sc, s
if (len != 0) {
KASSERT(next != NULL);
DPRINTFN(10, "extend chain", 0, 0, 0, 0);
- usb_syncmem(&cur->dma, cur->offs, sizeof(*cur->td),
+ usb_syncmem(&cur->dma, cur->offs, sizeof(cur->td),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
cur = next;
}
}
- cur->td->td_flags |=
+ cur->td.td_flags |=
HTOO32(xfer->ux_flags & USBD_SHORT_XFER_OK ? OHCI_TD_R : 0);
if (!rd &&
(flags & USBD_FORCE_SHORT_XFER) &&
alen % mps == 0) {
/* We're adding a ZLP so sync the previous TD */
- usb_syncmem(&cur->dma, cur->offs, sizeof(*cur->td),
+ usb_syncmem(&cur->dma, cur->offs, sizeof(cur->td),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
/* Force a 0 length transfer at the end. */
@@ -708,10 +688,10 @@ ohci_reset_std_chain(ohci_softc_t *sc, s
KASSERT(next != NULL);
cur = next;
- cur->td->td_flags = tdflags;
- cur->td->td_cbp = 0; /* indicate 0 length packet */
- cur->td->td_nexttd = 0;
- cur->td->td_be = ~0;
+ cur->td.td_flags = tdflags;
+ cur->td.td_cbp = 0; /* indicate 0 length packet */
+ cur->td.td_nexttd = 0;
+ cur->td.td_be = ~0;
cur->nexttd = NULL;
cur->len = 0;
cur->flags = 0;
@@ -739,26 +719,18 @@ ohci_alloc_sitd(ohci_softc_t *sc)
DPRINTFN(2, "allocating chunk", 0, 0, 0, 0);
mutex_exit(&sc->sc_lock);
- int err = usb_allocmem(sc->sc_bus.ub_dmatag,
- OHCI_ITD_SIZE * OHCI_ITD_CHUNK,
- OHCI_ITD_ALIGN, 0, &dma);
+ int err = usb_allocmem(sc->sc_bus.ub_dmatag, OHCI_SITD_SIZE * OHCI_SITD_CHUNK,
+ OHCI_ITD_ALIGN, USBMALLOC_COHERENT, &dma);
if (err)
return NULL;
-
- ohci_soft_itd_t *sitds =
- kmem_alloc(sizeof(*sitd) * OHCI_ITD_CHUNK, KM_SLEEP);
-
mutex_enter(&sc->sc_lock);
- for (i = 0; i < OHCI_ITD_CHUNK; i++) {
- offs = i * OHCI_ITD_SIZE;
-
- sitd = &sitds[i];
- sitd->itd = KERNADDR(&dma, offs);
+ for (i = 0; i < OHCI_SITD_CHUNK; i++) {
+ offs = i * OHCI_SITD_SIZE;
+ sitd = KERNADDR(&dma, offs);
sitd->physaddr = DMAADDR(&dma, offs);
sitd->dma = dma;
sitd->offs = offs;
sitd->nextitd = sc->sc_freeitds;
-
sc->sc_freeitds = sitd;
}
}
@@ -767,7 +739,7 @@ ohci_alloc_sitd(ohci_softc_t *sc)
sc->sc_freeitds = sitd->nextitd;
mutex_exit(&sc->sc_lock);
- memset(sitd->itd, 0, sizeof(*sitd->itd));
+ memset(&sitd->itd, 0, sizeof(ohci_itd_t));
sitd->nextitd = NULL;
sitd->xfer = NULL;
@@ -882,9 +854,9 @@ ohci_init(ohci_softc_t *sc)
err = ENOMEM;
goto bad2;
}
- sc->sc_bulk_head->ed->ed_flags |= HTOO32(OHCI_ED_SKIP);
+ sc->sc_bulk_head->ed.ed_flags |= HTOO32(OHCI_ED_SKIP);
usb_syncmem(&sc->sc_bulk_head->dma, sc->sc_bulk_head->offs,
- sizeof(*sc->sc_bulk_head->ed),
+ sizeof(sc->sc_bulk_head->ed),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
/* Allocate dummy ED that starts the isochronous list. */
@@ -893,9 +865,9 @@ ohci_init(ohci_softc_t *sc)
err = ENOMEM;
goto bad3;
}
- sc->sc_isoc_head->ed->ed_flags |= HTOO32(OHCI_ED_SKIP);
+ sc->sc_isoc_head->ed.ed_flags |= HTOO32(OHCI_ED_SKIP);
usb_syncmem(&sc->sc_isoc_head->dma, sc->sc_isoc_head->offs,
- sizeof(*sc->sc_isoc_head->ed),
+ sizeof(sc->sc_isoc_head->ed),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
/* Allocate all the dummy EDs that make up the interrupt tree. */
@@ -909,14 +881,14 @@ ohci_init(ohci_softc_t *sc)
}
/* All ED fields are set to 0. */
sc->sc_eds[i] = sed;
- sed->ed->ed_flags |= HTOO32(OHCI_ED_SKIP);
+ sed->ed.ed_flags |= HTOO32(OHCI_ED_SKIP);
if (i != 0)
psed = sc->sc_eds[(i-1) / 2];
else
psed= sc->sc_isoc_head;
sed->next = psed;
- sed->ed->ed_nexted = HTOO32(psed->physaddr);
- usb_syncmem(&sed->dma, sed->offs, sizeof(*sed->ed),
+ sed->ed.ed_nexted = HTOO32(psed->physaddr);
+ usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
}
/*
@@ -1481,20 +1453,20 @@ ohci_softintr(void *v)
for (sdone = NULL, sidone = NULL; done != 0; ) {
std = ohci_hash_find_td(sc, done);
if (std != NULL) {
- usb_syncmem(&std->dma, std->offs, sizeof(*std->td),
+ usb_syncmem(&std->dma, std->offs, sizeof(std->td),
BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
std->dnext = sdone;
- done = O32TOH(std->td->td_nexttd);
+ done = O32TOH(std->td.td_nexttd);
sdone = std;
DPRINTFN(10, "add TD %#jx", (uintptr_t)std, 0, 0, 0);
continue;
}
sitd = ohci_hash_find_itd(sc, done);
if (sitd != NULL) {
- usb_syncmem(&sitd->dma, sitd->offs, sizeof(*sitd->itd),
+ usb_syncmem(&sitd->dma, sitd->offs, sizeof(sitd->itd),
BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
sitd->dnext = sidone;
- done = O32TOH(sitd->itd->itd_nextitd);
+ done = O32TOH(sitd->itd.itd_nextitd);
sidone = sitd;
DPRINTFN(5, "add ITD %#jx", (uintptr_t)sitd, 0, 0, 0);
continue;
@@ -1547,14 +1519,14 @@ ohci_softintr(void *v)
continue;
len = std->len;
- if (std->td->td_cbp != 0)
- len -= O32TOH(std->td->td_be) -
- O32TOH(std->td->td_cbp) + 1;
+ if (std->td.td_cbp != 0)
+ len -= O32TOH(std->td.td_be) -
+ O32TOH(std->td.td_cbp) + 1;
DPRINTFN(10, "len=%jd, flags=%#jx", len, std->flags, 0, 0);
if (std->flags & OHCI_ADD_LEN)
xfer->ux_actlen += len;
- cc = OHCI_TD_GET_CC(O32TOH(std->td->td_flags));
+ cc = OHCI_TD_GET_CC(O32TOH(std->td.td_flags));
if (cc == OHCI_CC_NO_ERROR) {
ohci_hash_rem_td(sc, std);
if (std->flags & OHCI_CALL_DONE) {
@@ -1581,11 +1553,11 @@ ohci_softintr(void *v)
ohci_soft_ed_t *sed = opipe->sed;
/* clear halt and TD chain, preserving toggle carry */
- sed->ed->ed_headp = HTOO32(p->physaddr |
- (O32TOH(sed->ed->ed_headp) & OHCI_TOGGLECARRY));
+ sed->ed.ed_headp = HTOO32(p->physaddr |
+ (O32TOH(sed->ed.ed_headp) & OHCI_TOGGLECARRY));
usb_syncmem(&sed->dma,
sed->offs + offsetof(ohci_ed_t, ed_headp),
- sizeof(sed->ed->ed_headp),
+ sizeof(sed->ed.ed_headp),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF);
@@ -1841,17 +1813,17 @@ ohci_add_ed(ohci_softc_t *sc, ohci_soft_
KASSERT(mutex_owned(&sc->sc_lock));
usb_syncmem(&head->dma, head->offs + offsetof(ohci_ed_t, ed_nexted),
- sizeof(head->ed->ed_nexted),
+ sizeof(head->ed.ed_nexted),
BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
sed->next = head->next;
- sed->ed->ed_nexted = head->ed->ed_nexted;
+ sed->ed.ed_nexted = head->ed.ed_nexted;
usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_nexted),
- sizeof(sed->ed->ed_nexted),
+ sizeof(sed->ed.ed_nexted),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
head->next = sed;
- head->ed->ed_nexted = HTOO32(sed->physaddr);
+ head->ed.ed_nexted = HTOO32(sed->physaddr);
usb_syncmem(&head->dma, head->offs + offsetof(ohci_ed_t, ed_nexted),
- sizeof(head->ed->ed_nexted),
+ sizeof(head->ed.ed_nexted),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
}
@@ -1871,12 +1843,12 @@ ohci_rem_ed(ohci_softc_t *sc, ohci_soft_
KASSERT(p != NULL);
usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_nexted),
- sizeof(sed->ed->ed_nexted),
+ sizeof(sed->ed.ed_nexted),
BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
p->next = sed->next;
- p->ed->ed_nexted = sed->ed->ed_nexted;
+ p->ed.ed_nexted = sed->ed.ed_nexted;
usb_syncmem(&p->dma, p->offs + offsetof(ohci_ed_t, ed_nexted),
- sizeof(p->ed->ed_nexted),
+ sizeof(p->ed.ed_nexted),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
}
@@ -1987,10 +1959,10 @@ ohci_dump_td(ohci_softc_t *sc, ohci_soft
{
OHCIHIST_FUNC(); OHCIHIST_CALLED();
- usb_syncmem(&std->dma, std->offs, sizeof(*std->td),
+ usb_syncmem(&std->dma, std->offs, sizeof(std->td),
BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
- uint32_t flags = O32TOH(std->td->td_flags);
+ uint32_t flags = O32TOH(std->td.td_flags);
DPRINTF("TD(%#jx) at 0x%08jx:", (uintptr_t)std, std->physaddr, 0, 0);
DPRINTF(" round=%jd DP=%jx DI=%jx T=%jx",
!!(flags & OHCI_TD_R),
@@ -2000,9 +1972,9 @@ ohci_dump_td(ohci_softc_t *sc, ohci_soft
DPRINTF(" EC=%jd CC=%jd", OHCI_TD_GET_EC(flags),
OHCI_TD_GET_CC(flags), 0, 0);
DPRINTF(" td_cbp=0x%08jx td_nexttd=0x%08jx td_be=0x%08jx",
- (u_long)O32TOH(std->td->td_cbp),
- (u_long)O32TOH(std->td->td_nexttd),
- (u_long)O32TOH(std->td->td_be), 0);
+ (u_long)O32TOH(std->td.td_cbp),
+ (u_long)O32TOH(std->td.td_nexttd),
+ (u_long)O32TOH(std->td.td_be), 0);
}
void
@@ -2010,31 +1982,31 @@ ohci_dump_itd(ohci_softc_t *sc, ohci_sof
{
OHCIHIST_FUNC(); OHCIHIST_CALLED();
- usb_syncmem(&sitd->dma, sitd->offs, sizeof(*sitd->itd),
+ usb_syncmem(&sitd->dma, sitd->offs, sizeof(sitd->itd),
BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
- uint32_t flags = O32TOH(sitd->itd->itd_flags);
+ uint32_t flags = O32TOH(sitd->itd.itd_flags);
DPRINTF("ITD(%#jx) at 0x%08jx", (uintptr_t)sitd, sitd->physaddr, 0, 0);
DPRINTF(" sf=%jd di=%jd fc=%jd cc=%jd",
OHCI_ITD_GET_SF(flags), OHCI_ITD_GET_DI(flags),
OHCI_ITD_GET_FC(flags), OHCI_ITD_GET_CC(flags));
DPRINTF(" bp0=0x%08jx next=0x%08jx be=0x%08jx",
- O32TOH(sitd->itd->itd_bp0),
- O32TOH(sitd->itd->itd_nextitd),
- O32TOH(sitd->itd->itd_be), 0);
+ O32TOH(sitd->itd.itd_bp0),
+ O32TOH(sitd->itd.itd_nextitd),
+ O32TOH(sitd->itd.itd_be), 0);
CTASSERT(OHCI_ITD_NOFFSET == 8);
DPRINTF(" offs[0] = 0x%04jx offs[1] = 0x%04jx "
"offs[2] = 0x%04jx offs[3] = 0x%04jx",
- O16TOH(sitd->itd->itd_offset[0]),
- O16TOH(sitd->itd->itd_offset[1]),
- O16TOH(sitd->itd->itd_offset[2]),
- O16TOH(sitd->itd->itd_offset[3]));
+ O16TOH(sitd->itd.itd_offset[0]),
+ O16TOH(sitd->itd.itd_offset[1]),
+ O16TOH(sitd->itd.itd_offset[2]),
+ O16TOH(sitd->itd.itd_offset[3]));
DPRINTF(" offs[4] = 0x%04jx offs[5] = 0x%04jx "
"offs[6] = 0x%04jx offs[7] = 0x%04jx",
- O16TOH(sitd->itd->itd_offset[4]),
- O16TOH(sitd->itd->itd_offset[5]),
- O16TOH(sitd->itd->itd_offset[6]),
- O16TOH(sitd->itd->itd_offset[7]));
+ O16TOH(sitd->itd.itd_offset[4]),
+ O16TOH(sitd->itd.itd_offset[5]),
+ O16TOH(sitd->itd.itd_offset[6]),
+ O16TOH(sitd->itd.itd_offset[7]));
}
void
@@ -2049,10 +2021,10 @@ ohci_dump_ed(ohci_softc_t *sc, ohci_soft
{
OHCIHIST_FUNC(); OHCIHIST_CALLED();
- usb_syncmem(&sed->dma, sed->offs, sizeof(*sed->ed),
+ usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
- uint32_t flags = O32TOH(sed->ed->ed_flags);
+ uint32_t flags = O32TOH(sed->ed.ed_flags);
DPRINTF("ED(%#jx) at 0x%08jx:", (uintptr_t)sed, sed->physaddr, 0, 0);
DPRINTF(" addr=%jd endpt=%jd maxp=%jd",
OHCI_ED_GET_FA(flags),
@@ -2064,12 +2036,12 @@ ohci_dump_ed(ohci_softc_t *sc, ohci_soft
__SHIFTOUT(flags, OHCI_ED_SPEED),
__SHIFTOUT(flags, OHCI_ED_SKIP),
OHCI_ED_GET_FORMAT(flags));
- DPRINTF(" tailp=0x%08jx", (u_long)O32TOH(sed->ed->ed_tailp),
+ DPRINTF(" tailp=0x%08jx", (u_long)O32TOH(sed->ed.ed_tailp),
0, 0, 0);
DPRINTF(" headp=0x%08jx nexted=0x%08jx halted=%jd carry=%jd",
- O32TOH(sed->ed->ed_headp), O32TOH(sed->ed->ed_nexted),
- !!(O32TOH(sed->ed->ed_headp) & OHCI_HALTED),
- !!(O32TOH(sed->ed->ed_headp) & OHCI_TOGGLECARRY));
+ O32TOH(sed->ed.ed_headp), O32TOH(sed->ed.ed_nexted),
+ !!(O32TOH(sed->ed.ed_headp) & OHCI_HALTED),
+ !!(O32TOH(sed->ed.ed_headp) & OHCI_TOGGLECARRY));
}
#endif
@@ -2144,16 +2116,16 @@ ohci_open(struct usbd_pipe *pipe)
OHCI_ED_SET_FORMAT(OHCI_ED_FORMAT_GEN) |
OHCI_ED_SET_DIR(OHCI_ED_DIR_TD);
}
- sed->ed->ed_flags = HTOO32(
+ sed->ed.ed_flags = HTOO32(
OHCI_ED_SET_FA(addr) |
OHCI_ED_SET_EN(UE_GET_ADDR(ed->bEndpointAddress)) |
(dev->ud_speed == USB_SPEED_LOW ? OHCI_ED_SPEED : 0) |
fmt |
OHCI_ED_SET_MAXP(UGETW(ed->wMaxPacketSize)));
- sed->ed->ed_headp = HTOO32(tdphys |
+ sed->ed.ed_headp = HTOO32(tdphys |
(pipe->up_endpoint->ue_toggle ? OHCI_TOGGLECARRY : 0));
- sed->ed->ed_tailp = HTOO32(tdphys);
- usb_syncmem(&sed->dma, sed->offs, sizeof(*sed->ed),
+ sed->ed.ed_tailp = HTOO32(tdphys);
+ usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
switch (xfertype) {
@@ -2216,16 +2188,15 @@ ohci_close_pipe(struct usbd_pipe *pipe,
KASSERT(mutex_owned(&sc->sc_lock));
#ifdef DIAGNOSTIC
- // XXXNH usb_sync
- sed->ed->ed_flags |= HTOO32(OHCI_ED_SKIP);
- if ((O32TOH(sed->ed->ed_tailp) & OHCI_HEADMASK) !=
- (O32TOH(sed->ed->ed_headp) & OHCI_HEADMASK)) {
+ sed->ed.ed_flags |= HTOO32(OHCI_ED_SKIP);
+ if ((O32TOH(sed->ed.ed_tailp) & OHCI_HEADMASK) !=
+ (O32TOH(sed->ed.ed_headp) & OHCI_HEADMASK)) {
ohci_soft_td_t *std;
- std = ohci_hash_find_td(sc, O32TOH(sed->ed->ed_headp));
+ std = ohci_hash_find_td(sc, O32TOH(sed->ed.ed_headp));
printf("ohci_close_pipe: pipe not empty sed=%p hd=%#x "
"tl=%#x pipe=%p, std=%p\n", sed,
- (int)O32TOH(sed->ed->ed_headp),
- (int)O32TOH(sed->ed->ed_tailp),
+ (int)O32TOH(sed->ed.ed_headp),
+ (int)O32TOH(sed->ed.ed_tailp),
pipe, std);
#ifdef OHCI_DEBUG
usbd_dump_pipe(&opipe->pipe);
@@ -2234,8 +2205,8 @@ ohci_close_pipe(struct usbd_pipe *pipe,
ohci_dump_td(sc, std);
#endif
usb_delay_ms(&sc->sc_bus, 2);
- if ((O32TOH(sed->ed->ed_tailp) & OHCI_HEADMASK) !=
- (O32TOH(sed->ed->ed_headp) & OHCI_HEADMASK))
+ if ((O32TOH(sed->ed.ed_tailp) & OHCI_HEADMASK) !=
+ (O32TOH(sed->ed.ed_headp) & OHCI_HEADMASK))
printf("ohci_close_pipe: pipe still not empty\n");
}
#endif
@@ -2243,7 +2214,7 @@ ohci_close_pipe(struct usbd_pipe *pipe,
/* Make sure the host controller is not touching this ED */
usb_delay_ms(&sc->sc_bus, 1);
pipe->up_endpoint->ue_toggle =
- (O32TOH(sed->ed->ed_headp) & OHCI_TOGGLECARRY) ? 1 : 0;
+ (O32TOH(sed->ed.ed_headp) & OHCI_TOGGLECARRY) ? 1 : 0;
ohci_free_sed_locked(sc, opipe->sed);
}
@@ -2409,13 +2380,13 @@ ohci_abortx(struct usbd_xfer *xfer)
/* Zap headp register if hardware pointed inside the xfer. */
if (hit) {
DPRINTFN(1, "set hd=0x%08jx, tl=0x%08jx", (int)p->physaddr,
- (int)O32TOH(sed->ed->ed_tailp), 0, 0);
+ (int)O32TOH(sed->ed.ed_tailp), 0, 0);
/* unlink TDs, preserving toggle carry */
- sed->ed->ed_headp = HTOO32(p->physaddr |
- (O32TOH(sed->ed->ed_headp) & OHCI_TOGGLECARRY));
+ sed->ed.ed_headp = HTOO32(p->physaddr |
+ (O32TOH(sed->ed.ed_headp) & OHCI_TOGGLECARRY));
usb_syncmem(&sed->dma,
sed->offs + offsetof(ohci_ed_t, ed_headp),
- sizeof(sed->ed->ed_headp),
+ sizeof(sed->ed.ed_headp),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
} else {
DPRINTFN(1, "no hit", 0, 0, 0, 0);
@@ -2425,11 +2396,11 @@ ohci_abortx(struct usbd_xfer *xfer)
* HC Step 4: Turn on hardware again.
*/
usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_flags),
- sizeof(sed->ed->ed_flags),
+ sizeof(sed->ed.ed_flags),
BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
- sed->ed->ed_flags &= HTOO32(~OHCI_ED_SKIP); /* remove hardware skip */
+ sed->ed.ed_flags &= HTOO32(~OHCI_ED_SKIP); /* remove hardware skip */
usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_flags),
- sizeof(sed->ed->ed_flags),
+ sizeof(sed->ed.ed_flags),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
dying:
DPRINTFN(14, "end", 0, 0, 0, 0);
@@ -2837,13 +2808,13 @@ ohci_device_ctrl_start(struct usbd_xfer
DPRINTFN(10, "xfer=%#jx new tail=%#jx held at %#jx", (uintptr_t)ox,
(uintptr_t)tail, (uintptr_t)tail->held, 0);
- KASSERTMSG(OHCI_ED_GET_FA(O32TOH(sed->ed->ed_flags)) == dev->ud_addr,
+ KASSERTMSG(OHCI_ED_GET_FA(O32TOH(sed->ed.ed_flags)) == dev->ud_addr,
"address ED %" __PRIuBITS " pipe %d\n",
- OHCI_ED_GET_FA(O32TOH(sed->ed->ed_flags)), dev->ud_addr);
- KASSERTMSG(OHCI_ED_GET_MAXP(O32TOH(sed->ed->ed_flags)) ==
+ OHCI_ED_GET_FA(O32TOH(sed->ed.ed_flags)), dev->ud_addr);
+ KASSERTMSG(OHCI_ED_GET_MAXP(O32TOH(sed->ed.ed_flags)) ==
UGETW(opipe->pipe.up_endpoint->ue_edesc->wMaxPacketSize),
"MPL ED %" __PRIuBITS " pipe %d\n",
- OHCI_ED_GET_MAXP(O32TOH(sed->ed->ed_flags)),
+ OHCI_ED_GET_MAXP(O32TOH(sed->ed.ed_flags)),
UGETW(opipe->pipe.up_endpoint->ue_edesc->wMaxPacketSize));
/* next will point to data if len != 0 */
@@ -2857,21 +2828,21 @@ ohci_device_ctrl_start(struct usbd_xfer
next = ox->ox_stds[0];
ohci_reset_std_chain(sc, xfer, len, isread, next, &end);
- end->td->td_nexttd = HTOO32(stat->physaddr);
+ end->td.td_nexttd = HTOO32(stat->physaddr);
end->nexttd = stat;
- usb_syncmem(&end->dma, end->offs, sizeof(*end->td),
+ usb_syncmem(&end->dma, end->offs, sizeof(end->td),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
usb_syncmem(&xfer->ux_dmabuf, 0, len,
isread ? BUS_DMASYNC_PREREAD : BUS_DMASYNC_PREWRITE);
std = ox->ox_stds[0];
/* Start toggle at 1 and then use the carried toggle. */
- std->td->td_flags &= HTOO32(~OHCI_TD_TOGGLE_MASK);
- std->td->td_flags |= HTOO32(OHCI_TD_SET_TOGGLE(OHCI_TD_TOGGLE_1));
+ std->td.td_flags &= HTOO32(~OHCI_TD_TOGGLE_MASK);
+ std->td.td_flags |= HTOO32(OHCI_TD_SET_TOGGLE(OHCI_TD_TOGGLE_1));
usb_syncmem(&std->dma,
std->offs + offsetof(ohci_td_t, td_flags),
- sizeof(std->td->td_flags),
+ sizeof(std->td.td_flags),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
}
@@ -2884,15 +2855,15 @@ ohci_device_ctrl_start(struct usbd_xfer
memcpy(KERNADDR(&opipe->ctrl.reqdma, 0), req, sizeof(*req));
usb_syncmem(&opipe->ctrl.reqdma, 0, sizeof(*req), BUS_DMASYNC_PREWRITE);
- setup->td->td_flags = HTOO32(
+ setup->td.td_flags = HTOO32(
OHCI_TD_SET_DP(OHCI_TD_DP_SETUP) |
OHCI_TD_SET_CC(OHCI_TD_NOCC) |
OHCI_TD_SET_TOGGLE(OHCI_TD_TOGGLE_0) |
OHCI_TD_SET_DI(OHCI_TD_NOINTR)
);
- setup->td->td_cbp = HTOO32(DMAADDR(&opipe->ctrl.reqdma, 0));
- setup->td->td_nexttd = HTOO32(next->physaddr);
- setup->td->td_be = HTOO32(O32TOH(setup->td->td_cbp) + sizeof(*req) - 1);
+ setup->td.td_cbp = HTOO32(DMAADDR(&opipe->ctrl.reqdma, 0));
+ setup->td.td_nexttd = HTOO32(next->physaddr);
+ setup->td.td_be = HTOO32(O32TOH(setup->td.td_cbp) + sizeof(*req) - 1);
setup->nexttd = next;
setup->len = 0;
setup->xfer = xfer;
@@ -2900,32 +2871,32 @@ ohci_device_ctrl_start(struct usbd_xfer
ohci_hash_add_td(sc, setup);
xfer->ux_hcpriv = setup;
- usb_syncmem(&setup->dma, setup->offs, sizeof(*setup->td),
+ usb_syncmem(&setup->dma, setup->offs, sizeof(setup->td),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
- stat->td->td_flags = HTOO32(
+ stat->td.td_flags = HTOO32(
OHCI_TD_SET_DP(isread ? OHCI_TD_DP_OUT : OHCI_TD_DP_IN) |
OHCI_TD_SET_CC(OHCI_TD_NOCC) |
OHCI_TD_SET_TOGGLE(OHCI_TD_TOGGLE_1) |
OHCI_TD_SET_DI(1)
);
- stat->td->td_cbp = 0;
- stat->td->td_nexttd = HTOO32(tail->physaddr);
- stat->td->td_be = 0;
+ stat->td.td_cbp = 0;
+ stat->td.td_nexttd = HTOO32(tail->physaddr);
+ stat->td.td_be = 0;
stat->nexttd = tail;
stat->flags = OHCI_CALL_DONE;
stat->len = 0;
stat->xfer = xfer;
ohci_hash_add_td(sc, stat);
- usb_syncmem(&stat->dma, stat->offs, sizeof(*stat->td),
+ usb_syncmem(&stat->dma, stat->offs, sizeof(stat->td),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
- memset(tail->td, 0, sizeof(*tail->td));
+ memset(&tail->td, 0, sizeof(tail->td));
tail->nexttd = NULL;
tail->xfer = NULL;
- usb_syncmem(&tail->dma, tail->offs, sizeof(*tail->td),
+ usb_syncmem(&tail->dma, tail->offs, sizeof(tail->td),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
#ifdef OHCI_DEBUG
@@ -2938,10 +2909,10 @@ ohci_device_ctrl_start(struct usbd_xfer
#endif
/* Insert ED in schedule */
- sed->ed->ed_tailp = HTOO32(tail->physaddr);
+ sed->ed.ed_tailp = HTOO32(tail->physaddr);
usb_syncmem(&sed->dma,
sed->offs + offsetof(ohci_ed_t, ed_tailp),
- sizeof(sed->ed->ed_tailp),
+ sizeof(sed->ed.ed_tailp),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_CLF);
usbd_xfer_schedule_timeout(xfer);
@@ -3110,13 +3081,13 @@ ohci_device_bulk_start(struct usbd_xfer
/* point at sentinel */
tail = opipe->tail.td;
- memset(tail->td, 0, sizeof(*tail->td));
+ memset(&tail->td, 0, sizeof(tail->td));
tail->held = &opipe->tail.td;
tail->nexttd = NULL;
tail->xfer = NULL;
DPRINTFN(10, "xfer=%#jx new tail=%#jx held at %#ux",
(uintptr_t)ox, (uintptr_t)tail, (uintptr_t)tail->held, 0);
- usb_syncmem(&tail->dma, tail->offs, sizeof(*tail->td),
+ usb_syncmem(&tail->dma, tail->offs, sizeof(tail->td),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
xfer->ux_hcpriv = data;
@@ -3125,20 +3096,20 @@ ohci_device_bulk_start(struct usbd_xfer
KASSERT(opipe->tail.td == tail);
/* We want interrupt at the end of the transfer. */
- last->td->td_flags &= HTOO32(~OHCI_TD_DI_MASK);
- last->td->td_flags |= HTOO32(OHCI_TD_SET_DI(1));
- last->td->td_nexttd = HTOO32(tail->physaddr);
+ last->td.td_flags &= HTOO32(~OHCI_TD_DI_MASK);
+ last->td.td_flags |= HTOO32(OHCI_TD_SET_DI(1));
+ last->td.td_nexttd = HTOO32(tail->physaddr);
last->nexttd = tail;
last->flags |= OHCI_CALL_DONE;
- usb_syncmem(&last->dma, last->offs, sizeof(*last->td),
+ usb_syncmem(&last->dma, last->offs, sizeof(last->td),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
DPRINTFN(4, "ed_flags=0x%08jx td_flags=0x%08jx "
"td_cbp=0x%08jx td_be=0x%08jx",
- (int)O32TOH(sed->ed->ed_flags),
- (int)O32TOH(data->td->td_flags),
- (int)O32TOH(data->td->td_cbp),
- (int)O32TOH(data->td->td_be));
+ (int)O32TOH(sed->ed.ed_flags),
+ (int)O32TOH(data->td.td_flags),
+ (int)O32TOH(data->td.td_cbp),
+ (int)O32TOH(data->td.td_be));
#ifdef OHCI_DEBUG
DPRINTFN(5, "--- dump start ---", 0, 0, 0, 0);
@@ -3153,11 +3124,11 @@ ohci_device_bulk_start(struct usbd_xfer
for (tdp = data; tdp != tail; tdp = tdp->nexttd) {
KASSERT(tdp->xfer == xfer);
}
- usb_syncmem(&sed->dma, sed->offs, sizeof(*sed->ed),
+ usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
- sed->ed->ed_tailp = HTOO32(tail->physaddr);
- sed->ed->ed_flags &= HTOO32(~OHCI_ED_SKIP);
- usb_syncmem(&sed->dma, sed->offs, sizeof(*sed->ed),
+ sed->ed.ed_tailp = HTOO32(tail->physaddr);
+ sed->ed.ed_flags &= HTOO32(~OHCI_ED_SKIP);
+ usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
OWRITE4(sc, OHCI_COMMAND_STATUS, OHCI_BLF);
usbd_xfer_schedule_timeout(xfer);
@@ -3302,13 +3273,13 @@ ohci_device_intr_start(struct usbd_xfer
/* point at sentinel */
tail = opipe->tail.td;
- memset(tail->td, 0, sizeof(*tail->td));
+ memset(&tail->td, 0, sizeof(tail->td));
tail->held = &opipe->tail.td;
tail->nexttd = NULL;
tail->xfer = NULL;
DPRINTFN(10, "xfer=%#jx new tail=%#jx held at %#jx",
(uintptr_t)ox, (uintptr_t)tail, (uintptr_t)tail->held, 0);
- usb_syncmem(&tail->dma, tail->offs, sizeof(*tail->td),
+ usb_syncmem(&tail->dma, tail->offs, sizeof(tail->td),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
xfer->ux_hcpriv = data;
@@ -3317,13 +3288,13 @@ ohci_device_intr_start(struct usbd_xfer
KASSERT(opipe->tail.td == tail);
/* We want interrupt at the end of the transfer. */
- last->td->td_flags &= HTOO32(~OHCI_TD_DI_MASK);
- last->td->td_flags |= HTOO32(OHCI_TD_SET_DI(1));
+ last->td.td_flags &= HTOO32(~OHCI_TD_DI_MASK);
+ last->td.td_flags |= HTOO32(OHCI_TD_SET_DI(1));
- last->td->td_nexttd = HTOO32(tail->physaddr);
+ last->td.td_nexttd = HTOO32(tail->physaddr);
last->nexttd = tail;
last->flags |= OHCI_CALL_DONE;
- usb_syncmem(&last->dma, last->offs, sizeof(*last->td),
+ usb_syncmem(&last->dma, last->offs, sizeof(last->td),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
#ifdef OHCI_DEBUG
@@ -3336,11 +3307,11 @@ ohci_device_intr_start(struct usbd_xfer
#endif
/* Insert ED in schedule */
- usb_syncmem(&sed->dma, sed->offs, sizeof(*sed->ed),
+ usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
- sed->ed->ed_tailp = HTOO32(tail->physaddr);
- sed->ed->ed_flags &= HTOO32(~OHCI_ED_SKIP);
- usb_syncmem(&sed->dma, sed->offs, sizeof(*sed->ed),
+ sed->ed.ed_tailp = HTOO32(tail->physaddr);
+ sed->ed.ed_flags &= HTOO32(~OHCI_ED_SKIP);
+ usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
xfer->ux_status = USBD_IN_PROGRESS;
@@ -3377,22 +3348,22 @@ ohci_device_intr_close(struct usbd_pipe
DPRINTFN(1, "pipe=%#jx nslots=%jd pos=%jd", (uintptr_t)pipe, nslots,
pos, 0);
usb_syncmem(&sed->dma, sed->offs,
- sizeof(*sed->ed), BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
- sed->ed->ed_flags |= HTOO32(OHCI_ED_SKIP);
+ sizeof(sed->ed), BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
+ 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),
+ sizeof(sed->ed.ed_flags),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
- if ((O32TOH(sed->ed->ed_tailp) & OHCI_HEADMASK) !=
- (O32TOH(sed->ed->ed_headp) & OHCI_HEADMASK))
+ if ((O32TOH(sed->ed.ed_tailp) & OHCI_HEADMASK) !=
+ (O32TOH(sed->ed.ed_headp) & OHCI_HEADMASK))
usb_delay_ms_locked(&sc->sc_bus, 2, &sc->sc_lock);
for (p = sc->sc_eds[pos]; p && p->next != sed; p = p->next)
continue;
KASSERT(p);
p->next = sed->next;
- p->ed->ed_nexted = sed->ed->ed_nexted;
+ p->ed.ed_nexted = sed->ed.ed_nexted;
usb_syncmem(&p->dma, p->offs + offsetof(ohci_ed_t, ed_nexted),
- sizeof(p->ed->ed_nexted),
+ sizeof(p->ed.ed_nexted),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
for (j = 0; j < nslots; j++)
@@ -3654,15 +3625,15 @@ ohci_device_isoc_enter(struct usbd_xfer
KASSERT(j < ox->ox_nsitd);
/* Fill current ITD */
- sitd->itd->itd_flags = HTOO32(
+ sitd->itd.itd_flags = HTOO32(
OHCI_ITD_SET_CC(OHCI_ITD_NOCC) |
OHCI_ITD_SET_SF(isoc->next) |
OHCI_ITD_SET_DI(6) | /* delay intr a little */
OHCI_ITD_SET_FC(ncur)
);
- sitd->itd->itd_bp0 = HTOO32(bp0);
- sitd->itd->itd_nextitd = HTOO32(nsitd->physaddr);
- sitd->itd->itd_be = HTOO32(end);
+ sitd->itd.itd_bp0 = HTOO32(bp0);
+ sitd->itd.itd_nextitd = HTOO32(nsitd->physaddr);
+ sitd->itd.itd_be = HTOO32(end);
sitd->nextitd = nsitd;
sitd->xfer = xfer;
sitd->flags = 0;
@@ -3670,7 +3641,7 @@ ohci_device_isoc_enter(struct usbd_xfer
sitd->isdone = false;
#endif
ohci_hash_add_itd(sc, sitd);
- usb_syncmem(&sitd->dma, sitd->offs, sizeof(*sitd->itd),
+ usb_syncmem(&sitd->dma, sitd->offs, sizeof(sitd->itd),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
sitd = nsitd;
@@ -3678,7 +3649,7 @@ ohci_device_isoc_enter(struct usbd_xfer
bp0 = bp1 = OHCI_PAGE(buf);
ncur = 0;
}
- sitd->itd->itd_offset[ncur] = HTOO16(OHCI_ITD_MK_OFFS(offs));
+ sitd->itd.itd_offset[ncur] = HTOO16(OHCI_ITD_MK_OFFS(offs));
end = nend;
offs = noffs;
}
@@ -3686,23 +3657,23 @@ ohci_device_isoc_enter(struct usbd_xfer
/* point at sentinel */
tail = opipe->tail.itd;
- memset(tail->itd, 0, sizeof(*tail->itd));
+ memset(&tail->itd, 0, sizeof(tail->itd));
tail->held = &opipe->tail.itd;
tail->nextitd = NULL;
tail->xfer = NULL;
- usb_syncmem(&tail->dma, tail->offs, sizeof(*tail->itd),
+ usb_syncmem(&tail->dma, tail->offs, sizeof(tail->itd),
BUS_DMASYNC_PREWRITE);
/* Fixup last used ITD */
- sitd->itd->itd_flags = HTOO32(
+ sitd->itd.itd_flags = HTOO32(
OHCI_ITD_SET_CC(OHCI_ITD_NOCC) |
OHCI_ITD_SET_SF(isoc->next) |
OHCI_ITD_SET_DI(0) |
OHCI_ITD_SET_FC(ncur)
);
- sitd->itd->itd_bp0 = HTOO32(bp0);
- sitd->itd->itd_nextitd = HTOO32(tail->physaddr);
- sitd->itd->itd_be = HTOO32(end);
+ sitd->itd.itd_bp0 = HTOO32(bp0);
+ sitd->itd.itd_nextitd = HTOO32(tail->physaddr);
+ sitd->itd.itd_be = HTOO32(end);
sitd->nextitd = tail;
sitd->xfer = xfer;
sitd->flags = OHCI_CALL_DONE;
@@ -3710,7 +3681,7 @@ ohci_device_isoc_enter(struct usbd_xfer
sitd->isdone = false;
#endif
ohci_hash_add_itd(sc, sitd);
- usb_syncmem(&sitd->dma, sitd->offs, sizeof(*sitd->itd),
+ usb_syncmem(&sitd->dma, sitd->offs, sizeof(sitd->itd),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
isoc->next = isoc->next + ncur;
@@ -3765,11 +3736,11 @@ ohci_device_isoc_abort(struct usbd_xfer
xfer->ux_status = USBD_CANCELLED;
sed = opipe->sed;
- usb_syncmem(&sed->dma, sed->offs, sizeof(*sed->ed),
+ usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
- sed->ed->ed_flags |= HTOO32(OHCI_ED_SKIP); /* force hardware skip */
+ 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),
+ sizeof(sed->ed.ed_flags),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
sitd = xfer->ux_hcpriv;
@@ -3789,9 +3760,9 @@ ohci_device_isoc_abort(struct usbd_xfer
/* Run callback. */
usb_transfer_complete(xfer);
- sed->ed->ed_headp = HTOO32(sitd->physaddr); /* unlink TDs */
- sed->ed->ed_flags &= HTOO32(~OHCI_ED_SKIP); /* remove hardware skip */
- usb_syncmem(&sed->dma, sed->offs, sizeof(*sed->ed),
+ sed->ed.ed_headp = HTOO32(sitd->physaddr); /* unlink TDs */
+ sed->ed.ed_flags &= HTOO32(~OHCI_ED_SKIP); /* remove hardware skip */
+ usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
done:
