 @@ -1,14 +1,14 @@
-/*	$NetBSD: ehci.c,v 1.234.2.46 2015/03/21 16:42:55 skrll Exp $ */
+/*	$NetBSD: ehci.c,v 1.234.2.47 2015/04/06 07:08:59 skrll Exp $ */
 /*
  * Copyright (c) 2004-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), Charles M. Hannum,
  * Jeremy Morse (jeremy.morse@gmail.com), Jared D. McNeill
  * (jmcneill@invisible.ca) and Matthew R. Green (mrg@eterna.com.au).
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
 @@ -43,27 +43,27 @@
 /*
  * TODO:
  * 1) hold off explorations by companion controllers until ehci has started.
+ *
  * 2) The hub driver needs to handle and schedule the transaction translator,
  *    to assign place in frame where different devices get to go. See chapter
  *    on hubs in USB 2.0 for details.
+ *
  * 3) Command failures are not recovered correctly.
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: ehci.c,v 1.234.2.46 2015/03/21 16:42:55 skrll Exp $");
+__KERNEL_RCSID(0, "$NetBSD: ehci.c,v 1.234.2.47 2015/04/06 07:08:59 skrll Exp $");
 #include "ohci.h"
 #include "uhci.h"
 #include "opt_usb.h"
 #include <sys/param.h>
 #include <sys/bus.h>
 #include <sys/cpu.h>
 #include <sys/device.h>
 #include <sys/kernel.h>
 #include <sys/kmem.h>
 #include <sys/mutex.h>
 @@ -127,37 +127,37 @@ struct ehci_pipe {
 	struct usbd_pipe pipe;
 	int nexttoggle;
 	ehci_soft_qh_t *sqh;
 	union {
 		ehci_soft_qtd_t *qtd;
 		/* ehci_soft_itd_t *itd; */
 		/* ehci_soft_sitd_t *sitd; */
 	} tail;
 	union {
 		/* Control pipe */
 		struct {
 			usb_dma_t reqdma;
-		} ctl;
+		} ctrl;
 		/* Interrupt pipe */
 		struct {
 			u_int length;
 		} intr;
 		/* Iso pipe */
 		struct {
 			u_int next_frame;
 			u_int cur_xfers;
 		} isoc;
-	} u;
+	};
 };
 Static usbd_status	ehci_open(struct usbd_pipe *);
 Static void		ehci_poll(struct usbd_bus *);
 Static void		ehci_softintr(void *);
 Static int		ehci_intr1(ehci_softc_t *);
 Static void		ehci_waitintr(ehci_softc_t *, struct usbd_xfer *);
 Static void		ehci_check_intr(ehci_softc_t *, struct ehci_xfer *);
 Static void		ehci_check_qh_intr(ehci_softc_t *, struct ehci_xfer *);
 Static void		ehci_check_itd_intr(ehci_softc_t *, struct ehci_xfer *);
 Static void		ehci_check_sitd_intr(ehci_softc_t *, struct ehci_xfer *);
 Static void		ehci_idone(struct ehci_xfer *);
 Static void		ehci_timeout(void *);
 @@ -1955,27 +1955,27 @@ ehci_open(struct usbd_pipe *pipe)
 		sqh->qh.qh_qtd.qtd_altnext = EHCI_NULL;
 		sqh->qh.qh_qtd.qtd_status = htole32(0);
 		usb_syncmem(&sqh->dma, sqh->offs, sizeof(sqh->qh),
 		    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 		epipe->sqh = sqh;
 	} else {
 		sqh = NULL;
 	} /*xfertype == UE_ISOC*/
 	switch (xfertype) {
 	case UE_CONTROL:
 		err = usb_allocmem(&sc->sc_bus, sizeof(usb_device_request_t),
-, &epipe->u.ctl.reqdma);
+, &epipe->ctrl.reqdma);
 #ifdef EHCI_DEBUG
 		if (err)
 			printf("ehci_open: usb_allocmem()=%d\n", err);
 #endif
 		if (err)
 			goto bad;
 		pipe->up_methods = &ehci_device_ctrl_methods;
 		mutex_enter(&sc->sc_lock);
 		ehci_add_qh(sc, sqh, sc->sc_async_head);
 		mutex_exit(&sc->sc_lock);
 		break;
 	case UE_BULK:
 		pipe->up_methods = &ehci_device_bulk_methods;
 @@ -2009,28 +2009,28 @@ ehci_open(struct usbd_pipe *pipe)
 			pipe->up_methods = &ehci_device_isoc_methods;
 		else
 			pipe->up_methods = &ehci_device_fs_isoc_methods;
 		if (ed->bInterval == 0 || ed->bInterval > 16) {
 			printf("ehci: opening pipe with invalid bInterval\n");
 			err = USBD_INVAL;
 			goto bad;
+		}
 		if (UGETW(ed->wMaxPacketSize) == 0) {
 			printf("ehci: zero length endpoint open request\n");
 			err = USBD_INVAL;
 			goto bad;
+		}
-		epipe->u.isoc.next_frame = 0;
+		epipe->isoc.next_frame = 0;
-		epipe->u.isoc.cur_xfers = 0;
+		epipe->isoc.cur_xfers = 0;
 		break;
 	default:
 		USBHIST_LOG(ehcidebug, "bad xfer type %d", xfertype, 0, 0, 0);
 		err = USBD_INVAL;
 		goto bad;
+	}
 	return USBD_NORMAL_COMPLETION;
  bad:
 	if (sqh != NULL)
 		ehci_free_sqh(sc, sqh);
 	return err;
+}
 @@ -3460,27 +3460,27 @@ ehci_device_ctrl_done(struct usbd_xfer *
 	int len = UGETW(req->wLength);
 	int rd = req->bmRequestType & UT_READ;
 	USBHIST_FUNC(); USBHIST_CALLED(ehcidebug);
 	USBHIST_LOG(ehcidebug, "xfer=%p", xfer, 0, 0, 0);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	KASSERT(xfer->ux_rqflags & URQ_REQUEST);
 	if (xfer->ux_status != USBD_NOMEM && ehci_active_intr_list(ex)) {
 		ehci_del_intr_list(sc, ex);	/* remove from active list */
 		ehci_free_sqtd_chain(sc, ex->ex_sqtdstart, NULL);
-		usb_syncmem(&epipe->u.ctl.reqdma, 0, sizeof(*req),
+		usb_syncmem(&epipe->ctrl.reqdma, 0, sizeof(*req),
 		    BUS_DMASYNC_POSTWRITE);
 		if (len)
 			usb_syncmem(&xfer->ux_dmabuf, 0, len,
 			    rd ? BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
+	}
 	USBHIST_LOG(ehcidebug, "length=%d", xfer->ux_actlen, 0, 0, 0);
+}
 /* Abort a device control request. */
 Static void
 ehci_device_ctrl_abort(struct usbd_xfer *xfer)
+{
 @@ -3567,38 +3567,38 @@ ehci_device_request(struct usbd_xfer *xf
 			  &next, &end);
 		if (err)
 			goto bad3;
 		end->qtd.qtd_status &= htole32(~EHCI_QTD_IOC);
 		end->nextqtd = stat;
 		end->qtd.qtd_next = end->qtd.qtd_altnext =
 		    htole32(stat->physaddr);
 		usb_syncmem(&end->dma, end->offs, sizeof(end->qtd),
 		   BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	} else {
 		next = stat;
+	}
-	memcpy(KERNADDR(&epipe->u.ctl.reqdma, 0), req, sizeof(*req));
+	memcpy(KERNADDR(&epipe->ctrl.reqdma, 0), req, sizeof(*req));
-	usb_syncmem(&epipe->u.ctl.reqdma, 0, sizeof(*req), BUS_DMASYNC_PREWRITE);
+	usb_syncmem(&epipe->ctrl.reqdma, 0, sizeof(*req), BUS_DMASYNC_PREWRITE);
 	/* Clear toggle */
 	setup->qtd.qtd_status = htole32(
 	    EHCI_QTD_ACTIVE |
 	    EHCI_QTD_SET_PID(EHCI_QTD_PID_SETUP) |
 	    EHCI_QTD_SET_CERR(3) |
 	    EHCI_QTD_SET_TOGGLE(0) |
 	    EHCI_QTD_SET_BYTES(sizeof(*req))
 	    );
-	setup->qtd.qtd_buffer[0] = htole32(DMAADDR(&epipe->u.ctl.reqdma, 0));
+	setup->qtd.qtd_buffer[0] = htole32(DMAADDR(&epipe->ctrl.reqdma, 0));
 	setup->qtd.qtd_buffer_hi[0] = 0;
 	setup->nextqtd = next;
 	setup->qtd.qtd_next = setup->qtd.qtd_altnext = htole32(next->physaddr);
 	setup->xfer = xfer;
 	setup->len = sizeof(*req);
 	usb_syncmem(&setup->dma, setup->offs, sizeof(setup->qtd),
 	    BUS_DMASYNC_PREWRITE | BUS_DMASYNC_PREREAD);
 	stat->qtd.qtd_status = htole32(
 	    EHCI_QTD_ACTIVE |
 	    EHCI_QTD_SET_PID(isread ? EHCI_QTD_PID_OUT : EHCI_QTD_PID_IN) |
 	    EHCI_QTD_SET_CERR(3) |
 	    EHCI_QTD_SET_TOGGLE(1) |
 @@ -3904,27 +3904,27 @@ ehci_device_intr_start(struct usbd_xfer
 	if (sc->sc_dying)
 		return USBD_IOERROR;
 	KASSERT(!(xfer->ux_rqflags & URQ_REQUEST));
 	mutex_enter(&sc->sc_lock);
 	len = xfer->ux_length;
 	endpt = epipe->pipe.up_endpoint->ue_edesc->bEndpointAddress;
 	isread = UE_GET_DIR(endpt) == UE_DIR_IN;
 	sqh = epipe->sqh;
-	epipe->u.intr.length = len;
+	epipe->intr.length = len;
 	err = ehci_alloc_sqtd_chain(epipe, sc, len, isread, xfer, &data,
 	    &dataend);
 	if (err) {
 		USBHIST_LOG(ehcidebug, "no memory", 0, 0, 0, 0);
 		xfer->ux_status = err;
 		usb_transfer_complete(xfer);
 		mutex_exit(&sc->sc_lock);
 		return err;
+	}
 #ifdef EHCI_DEBUG
 	USBHIST_LOGN(ehcidebug, 5, "--- dump start ---", 0, 0, 0, 0);
 @@ -4006,27 +4006,27 @@ ehci_device_intr_done(struct usbd_xfer *
 	usbd_status err;
 	int len, isread, endpt;
 	USBHIST_FUNC(); USBHIST_CALLED(ehcidebug);
 	USBHIST_LOG(ehcidebug, "xfer=%p, actlen=%d",
 	    xfer, xfer->ux_actlen, 0, 0);
 	KASSERT(sc->sc_bus.ub_usepolling || mutex_owned(&sc->sc_lock));
 	if (xfer->ux_pipe->up_repeat) {
 		ehci_free_sqtd_chain(sc, exfer->ex_sqtdstart, NULL);
-		len = epipe->u.intr.length;
+		len = epipe->intr.length;
 		xfer->ux_length = len;
 		endpt = epipe->pipe.up_endpoint->ue_edesc->bEndpointAddress;
 		isread = UE_GET_DIR(endpt) == UE_DIR_IN;
 		usb_syncmem(&xfer->ux_dmabuf, 0, len,
 		    isread ? BUS_DMASYNC_POSTREAD : BUS_DMASYNC_POSTWRITE);
 		sqh = epipe->sqh;
 		err = ehci_alloc_sqtd_chain(epipe, sc, len, isread, xfer,
 		    &data, &dataend);
 		if (err) {
 			USBHIST_LOG(ehcidebug, "no memory", 0, 0, 0, 0);
 			xfer->ux_status = err;
 			return;
 @@ -4263,28 +4263,28 @@ ehci_device_fs_isoc_start(struct usbd_xf
 	usb_syncmem(&exfer->ex_xfer.ux_dmabuf, 0, total_length,
 		BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 	/*
 	 * Part 2: Transfer descriptors have now been set up, now they must
 	 * be scheduled into the periodic frame list. Erk. Not wanting to
 	 * complicate matters, transfer is denied if the transfer spans
 	 * more than the period frame list.
 	 */
 	mutex_enter(&sc->sc_lock);
 	/* Start inserting frames */
-	if (epipe->u.isoc.cur_xfers > 0) {
+	if (epipe->isoc.cur_xfers > 0) {
-		frindex = epipe->u.isoc.next_frame;
+		frindex = epipe->isoc.next_frame;
 	} else {
 		frindex = EOREAD4(sc, EHCI_FRINDEX);
 		frindex = frindex >> 3; /* Erase microframe index */
 		frindex += 2;
+	}
 	if (frindex >= sc->sc_flsize)
 		frindex &= (sc->sc_flsize - 1);
 	/* Whats the frame interval? */
 	i = epipe->pipe.up_endpoint->ue_edesc->bInterval;
 	sitd = start;
 @@ -4322,28 +4322,28 @@ ehci_device_fs_isoc_start(struct usbd_xf
 		sc->sc_softsitds[frindex] = sitd;
 		if (sitd->u.frame_list.next != NULL)
 			sitd->u.frame_list.next->u.frame_list.prev = sitd;
 		sitd->slot = frindex;
 		sitd->u.frame_list.prev = NULL;
 		frindex += i;
 		if (frindex >= sc->sc_flsize)
 			frindex -= sc->sc_flsize;
 		sitd = sitd->xfer_next;
+	}
-	epipe->u.isoc.cur_xfers++;
+	epipe->isoc.cur_xfers++;
-	epipe->u.isoc.next_frame = frindex;
+	epipe->isoc.next_frame = frindex;
 	exfer->ex_sitdstart = start;
 	exfer->ex_sitdend = stop;
 	ehci_add_intr_list(sc, exfer);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	mutex_exit(&sc->sc_lock);
 	if (sc->sc_bus.ub_usepolling) {
 		printf("Starting ehci isoc xfer with polling. Bad idea?\n");
 		ehci_waitintr(sc, xfer);
+	}
 @@ -4371,27 +4371,27 @@ ehci_device_fs_isoc_close(struct usbd_pi
 Static void
 ehci_device_fs_isoc_done(struct usbd_xfer *xfer)
+{
 	struct ehci_xfer *exfer;
 	ehci_softc_t *sc;
 	struct ehci_pipe *epipe;
 	exfer = EXFER(xfer);
 	sc = xfer->ux_pipe->up_dev->ud_bus->ub_hcpriv;
 	epipe = (struct ehci_pipe *) xfer->ux_pipe;
 	KASSERT(mutex_owned(&sc->sc_lock));
-	epipe->u.isoc.cur_xfers--;
+	epipe->isoc.cur_xfers--;
 	if (xfer->ux_status != USBD_NOMEM && ehci_active_intr_list(exfer)) {
 		ehci_del_intr_list(sc, exfer);
 		ehci_rem_free_sitd_chain(sc, exfer);
+	}
 	usb_syncmem(&xfer->ux_dmabuf, 0, xfer->ux_length, BUS_DMASYNC_POSTWRITE |
 		    BUS_DMASYNC_POSTREAD);
+}
 Static usbd_status
 ehci_device_isoc_transfer(struct usbd_xfer *xfer)
+{
 	ehci_softc_t *sc = xfer->ux_pipe->up_dev->ud_bus->ub_hcpriv;
 	usbd_status err;
 @@ -4591,28 +4591,28 @@ ehci_device_isoc_start(struct usbd_xfer
 	usb_syncmem(&exfer->ex_xfer.ux_dmabuf, 0, total_length,
 		BUS_DMASYNC_PREREAD | BUS_DMASYNC_PREWRITE);
 	/*
 	 * Part 2: Transfer descriptors have now been set up, now they must
 	 * be scheduled into the period frame list. Erk. Not wanting to
 	 * complicate matters, transfer is denied if the transfer spans
 	 * more than the period frame list.
 	 */
 	mutex_enter(&sc->sc_lock);
 	/* Start inserting frames */
-	if (epipe->u.isoc.cur_xfers > 0) {
+	if (epipe->isoc.cur_xfers > 0) {
-		frindex = epipe->u.isoc.next_frame;
+		frindex = epipe->isoc.next_frame;
 	} else {
 		frindex = EOREAD4(sc, EHCI_FRINDEX);
 		frindex = frindex >> 3; /* Erase microframe index */
 		frindex += 2;
+	}
 	if (frindex >= sc->sc_flsize)
 		frindex &= (sc->sc_flsize - 1);
 	/* What's the frame interval? */
 	i = (1 << (epipe->pipe.up_endpoint->ue_edesc->bInterval - 1));
 	if (i / USB_UFRAMES_PER_FRAME == 0)
 		i = 1;
 @@ -4651,28 +4651,28 @@ ehci_device_isoc_start(struct usbd_xfer
 		sc->sc_softitds[frindex] = itd;
 		if (itd->u.frame_list.next != NULL)
 			itd->u.frame_list.next->u.frame_list.prev = itd;
 		itd->slot = frindex;
 		itd->u.frame_list.prev = NULL;
 		frindex += i;
 		if (frindex >= sc->sc_flsize)
 			frindex -= sc->sc_flsize;
 		itd = itd->xfer_next;
+	}
-	epipe->u.isoc.cur_xfers++;
+	epipe->isoc.cur_xfers++;
-	epipe->u.isoc.next_frame = frindex;
+	epipe->isoc.next_frame = frindex;
 	exfer->ex_itdstart = start;
 	exfer->ex_itdend = stop;
 	ehci_add_intr_list(sc, exfer);
 	xfer->ux_status = USBD_IN_PROGRESS;
 	mutex_exit(&sc->sc_lock);
 	if (sc->sc_bus.ub_usepolling) {
 		printf("Starting ehci isoc xfer with polling. Bad idea?\n");
 		ehci_waitintr(sc, xfer);
+	}
 @@ -4699,23 +4699,23 @@ ehci_device_isoc_close(struct usbd_pipe
 Static void
 ehci_device_isoc_done(struct usbd_xfer *xfer)
+{
 	struct ehci_xfer *exfer;
 	ehci_softc_t *sc;
 	struct ehci_pipe *epipe;
 	exfer = EXFER(xfer);
 	sc = xfer->ux_pipe->up_dev->ud_bus->ub_hcpriv;
 	epipe = (struct ehci_pipe *) xfer->ux_pipe;
 	KASSERT(mutex_owned(&sc->sc_lock));
-	epipe->u.isoc.cur_xfers--;
+	epipe->isoc.cur_xfers--;
 	if (xfer->ux_status != USBD_NOMEM && ehci_active_intr_list(exfer)) {
 		ehci_del_intr_list(sc, exfer);
 		ehci_rem_free_itd_chain(sc, exfer);
+	}
 	usb_syncmem(&xfer->ux_dmabuf, 0, xfer->ux_length, BUS_DMASYNC_POSTWRITE |
 	    BUS_DMASYNC_POSTREAD);
+}