 @@ -1,14 +1,14 @@
-/*	$NetBSD: ohci.c,v 1.235 2013/03/22 13:28:11 skrll Exp $	*/
+/*	$NetBSD: ohci.c,v 1.236 2013/04/03 19:02:12 skrll Exp $	*/
 /*
  * Copyright (c) 1998, 2004, 2005, 2012 The NetBSD Foundation, Inc.
  * All rights reserved.
+ *
  * This code is derived from software contributed to The NetBSD Foundation
  * by Lennart Augustsson (lennart@augustsson.net) at
  * Carlstedt Research & Technology, Jared D. McNeill (jmcneill@invisible.ca)
  * and Matthew R. Green (mrg@eterna.com.au).
  * This code is derived from software contributed to The NetBSD Foundation
  * by Charles M. Hannum.
+ *
  * Redistribution and use in source and binary forms, with or without
 @@ -31,27 +31,27 @@
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 /*
  * USB Open Host Controller driver.
+ *
  * OHCI spec: http://www.compaq.com/productinfo/development/openhci.html
  * USB spec: http://www.usb.org/developers/docs/
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ohci.c,v 1.235 2013/03/22 13:28:11 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ohci.c,v 1.236 2013/04/03 19:02:12 skrll Exp $");
 #include <sys/param.h>
 #include <sys/systm.h>
 #include <sys/kmem.h>
 #include <sys/kernel.h>
 #include <sys/device.h>
 #include <sys/select.h>
 #include <sys/proc.h>
 #include <sys/queue.h>
 #include <sys/cpu.h>
 #include <machine/endian.h>
 @@ -88,30 +88,28 @@ int ohcidebug = 0;
 #define	HTOO32(val)	O32TOH(val)
 struct ohci_pipe;
 Static ohci_soft_ed_t  *ohci_alloc_sed(ohci_softc_t *);
 Static void		ohci_free_sed(ohci_softc_t *, ohci_soft_ed_t *);
 Static ohci_soft_td_t  *ohci_alloc_std(ohci_softc_t *);
 Static void		ohci_free_std(ohci_softc_t *, ohci_soft_td_t *);
 Static ohci_soft_itd_t *ohci_alloc_sitd(ohci_softc_t *);
 Static void		ohci_free_sitd(ohci_softc_t *,ohci_soft_itd_t *);
 #if 0
 Static void		ohci_free_std_chain(ohci_softc_t *, ohci_soft_td_t *,
 					    ohci_soft_td_t *);
 #endif
 Static usbd_status	ohci_alloc_std_chain(struct ohci_pipe *,
 			    ohci_softc_t *, int, int, usbd_xfer_handle,
 			    ohci_soft_td_t *, ohci_soft_td_t **);
 Static usbd_status	ohci_open(usbd_pipe_handle);
 Static void		ohci_poll(struct usbd_bus *);
 Static void		ohci_softintr(void *);
 Static void		ohci_waitintr(ohci_softc_t *, usbd_xfer_handle);
 Static void		ohci_rhsc(ohci_softc_t *, usbd_xfer_handle);
 Static void		ohci_rhsc_softint(void *arg);
 Static usbd_status	ohci_device_request(usbd_xfer_handle xfer);
 Static void		ohci_add_ed(ohci_softc_t *, ohci_soft_ed_t *,
 @@ -555,43 +553,44 @@ ohci_alloc_std_chain(struct ohci_pipe *o
 		cur->td.td_be = ~0;
 		cur->len = 0;
 		cur->flags = 0;
 		cur->xfer = xfer;
 		usb_syncmem(&cur->dma, cur->offs, sizeof(cur->td),
 		    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 		DPRINTFN(2,("ohci_alloc_std_chain: add 0 xfer\n"));
+	}
 	*ep = cur;
 	return (USBD_NORMAL_COMPLETION);
  nomem:
 	/* XXX free chain */
 	/* Don't free sp - let the caller do that */
 	ohci_free_std_chain(sc, sp->nexttd, NULL);
 	return (USBD_NOMEM);
+}
 #if 0
 Static void
 ohci_free_std_chain(ohci_softc_t *sc, ohci_soft_td_t *std,
 		    ohci_soft_td_t *stdend)
+{
 	ohci_soft_td_t *p;
 	for (; std != stdend; std = p) {
 		p = std->nexttd;
 		ohci_free_std(sc, std);
+	}
+}
 #endif
 ohci_soft_itd_t *
 ohci_alloc_sitd(ohci_softc_t *sc)
+{
 	ohci_soft_itd_t *sitd;
 	usbd_status err;
 	int i, offs;
 	usb_dma_t dma;
 	if (sc->sc_freeitds == NULL) {
 		DPRINTFN(2, ("ohci_alloc_sitd: allocating chunk\n"));
 		err = usb_allocmem(&sc->sc_bus, OHCI_SITD_SIZE * OHCI_SITD_CHUNK,
 			  OHCI_ITD_ALIGN, &dma);
 @@ -1747,29 +1746,32 @@ ohci_device_request(usbd_xfer_handle xfe
 	 OHCI_ED_SET_MAXP(UGETW(opipe->pipe.endpoint->edesc->wMaxPacketSize)));
 	usb_syncmem(&sed->dma, sed->offs + offsetof(ohci_ed_t, ed_flags),
 	    sizeof(sed->ed.ed_flags),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	next = stat;
 	/* Set up data transaction */
 	if (len != 0) {
 		ohci_soft_td_t *std = stat;
 		err = ohci_alloc_std_chain(opipe, sc, len, isread, xfer,
 			  std, &stat);
-		stat = stat->nexttd; /* point at free TD */
+		if (err) {
-		if (err)
+			/* stat is unchanged if error */
 			goto bad3;
+		}
 		stat = stat->nexttd; /* point at free TD */
 		/* 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_TOGGLE_1);
 		usb_syncmem(&std->dma,
 		    std->offs + offsetof(ohci_td_t, td_flags),
 		    sizeof(std->td.td_flags),
 		    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
+	}
 	memcpy(KERNADDR(&opipe->u.ctl.reqdma, 0), req, sizeof *req);
 	usb_syncmem(&opipe->u.ctl.reqdma, 0, sizeof *req, BUS_DMASYNC_PREWRITE);
 	setup->td.td_flags = HTOO32(OHCI_TD_SETUP | OHCI_TD_NOCC |
 @@ -3034,26 +3036,29 @@ ohci_device_bulk_start(usbd_xfer_handle
 	opipe->u.bulk.length = len;
 	usb_syncmem(&sed->dma, sed->offs, sizeof(sed->ed),
 	    BUS_DMASYNC_POSTWRITE | BUS_DMASYNC_POSTREAD);
 	/* Update device address */
 	sed->ed.ed_flags = HTOO32(
 		(O32TOH(sed->ed.ed_flags) & ~OHCI_ED_ADDRMASK) |
 		OHCI_ED_SET_FA(addr));
 	/* Allocate a chain of new TDs (including a new tail). */
 	data = opipe->tail.td;
 	err = ohci_alloc_std_chain(opipe, sc, len, isread, xfer,
 		  data, &tail);
 	if (err)
 		return err;
 	/* We want interrupt at the end of the transfer. */
 	tail->td.td_flags &= HTOO32(~OHCI_TD_INTR_MASK);
 	tail->td.td_flags |= HTOO32(OHCI_TD_SET_DI(1));
 	tail->flags |= OHCI_CALL_DONE;
 	tail = tail->nexttd;	/* point at sentinel */
 	usb_syncmem(&tail->dma, tail->offs + offsetof(ohci_td_t, td_flags),
 	    sizeof(tail->td.td_flags),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	if (err) {
 		mutex_exit(&sc->sc_lock);
 		return (err);
+	}