 @@ -1,14 +1,14 @@
-/*	$NetBSD: uhidev.c,v 1.90 2022/03/28 12:44:17 riastradh Exp $	*/
+/*	$NetBSD: uhidev.c,v 1.91 2022/03/28 12:44:28 riastradh Exp $	*/
 /*
  * Copyright (c) 2001, 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 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:
  * 1. Redistributions of source code must retain the above copyright
 @@ -25,27 +25,27 @@
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * 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.
  */
 /*
  * HID spec: http://www.usb.org/developers/devclass_docs/HID1_11.pdf
  */
 #include <sys/cdefs.h>
-__KERNEL_RCSID(0, "$NetBSD: uhidev.c,v 1.90 2022/03/28 12:44:17 riastradh Exp $");
+__KERNEL_RCSID(0, "$NetBSD: uhidev.c,v 1.91 2022/03/28 12:44:28 riastradh Exp $");
 #ifdef _KERNEL_OPT
 #include "opt_usb.h"
 #endif
 #include <sys/param.h>
 #include <sys/types.h>
 #include <sys/atomic.h>
 #include <sys/conf.h>
 #include <sys/device.h>
 #include <sys/ioctl.h>
 #include <sys/kernel.h>
 @@ -100,27 +100,26 @@ struct uhidev_softc {
 #define	UHIDEV_OPEN	0x01	/* device is open */
 #define	UHIDEV_STOPPED	0x02	/* xfers are stopped */
 	} *sc_subdevs;
 	kmutex_t sc_lock;
 	kcondvar_t sc_cv;
 	/* Read/written under sc_lock.  */
 	struct lwp *sc_writelock;
 	struct lwp *sc_configlock;
 	int sc_refcnt;
 	int sc_writereportid;
 	int sc_stopreportid;
 	u_char sc_dying;
 	/*
 	 * - Read under sc_lock, provided sc_refcnt > 0.
 	 * - Written under sc_configlock only when transitioning to and
 	 *   from sc_refcnt = 0.
 	 */
 	u_char *sc_ibuf;
 	struct usbd_pipe *sc_ipipe;	/* input interrupt pipe */
 	struct usbd_pipe *sc_opipe;	/* output interrupt pipe */
 	struct usbd_xfer *sc_oxfer;	/* write request */
 	usbd_callback sc_writecallback;	/* async write request callback */
 	void *sc_writecookie;
 @@ -136,30 +135,29 @@ int	uhidevdebug = 0;
 #define DPRINTF(x)
 #define DPRINTFN(n,x)
 #endif
 static void uhidev_intr(struct usbd_xfer *, void *, usbd_status);
 static int uhidev_maxrepid(void *, int);
 static int uhidevprint(void *, const char *);
 static int uhidev_match(device_t, cfdata_t, void *);
 static void uhidev_attach(device_t, device_t, void *);
 static void uhidev_childdet(device_t, device_t);
 static int uhidev_detach(device_t, int);
 static int uhidev_activate(device_t, enum devact);
 CFATTACH_DECL2_NEW(uhidev, sizeof(struct uhidev_softc), uhidev_match,
-    uhidev_attach, uhidev_detach, uhidev_activate, NULL, uhidev_childdet);
+    uhidev_attach, uhidev_detach, NULL, NULL, uhidev_childdet);
 static int
 uhidev_match(device_t parent, cfdata_t match, void *aux)
+{
 	struct usbif_attach_arg *uiaa = aux;
 	/* Game controllers in "XInput" mode */
 	if (USBIF_IS_XINPUT(uiaa))
 		return UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO;
 	/* Xbox One controllers */
 	if (USBIF_IS_X1INPUT(uiaa) && uiaa->uiaa_ifaceno == 0)
 		return UMATCH_IFACECLASS_IFACESUBCLASS_IFACEPROTO;
 @@ -193,27 +191,26 @@ uhidev_attach(device_t parent, device_t
 	sc->sc_udev = uiaa->uiaa_device;
 	sc->sc_iface = iface;
 	aprint_naive("\n");
 	aprint_normal("\n");
 	mutex_init(&sc->sc_lock, MUTEX_DEFAULT, IPL_SOFTUSB);
 	cv_init(&sc->sc_cv, "uhidev");
 	sc->sc_writelock = NULL;
 	sc->sc_configlock = NULL;
 	sc->sc_refcnt = 0;
 	sc->sc_writereportid = -1;
 	sc->sc_stopreportid = -1;
 	sc->sc_dying = false;
 	id = usbd_get_interface_descriptor(iface);
 	devinfop = usbd_devinfo_alloc(uiaa->uiaa_device, 0);
 	aprint_normal_dev(self, "%s, iclass %d/%d\n",
 	       devinfop, id->bInterfaceClass, id->bInterfaceSubClass);
 	usbd_devinfo_free(devinfop);
 	if (!pmf_device_register(self, NULL, NULL))
 		aprint_error_dev(self, "couldn't establish power handler\n");
 	if (uiaa->uiaa_vendor == USB_VENDOR_WACOM) {
 		if (uiaa->uiaa_product == USB_PRODUCT_WACOM_XD0912U) {
 @@ -234,27 +231,26 @@ uhidev_attach(device_t parent, device_t
 	 */
 	if ((usbd_get_quirks(sc->sc_udev)->uq_flags & UQ_NO_SET_PROTO) == 0 &&
 	    id->bInterfaceSubClass == UISUBCLASS_BOOT)
 		(void)usbd_set_protocol(iface, 1);
 #endif
 	maxinpktsize = 0;
 	sc->sc_iep_addr = sc->sc_oep_addr = -1;
 	for (i = 0; i < id->bNumEndpoints; i++) {
 		ed = usbd_interface2endpoint_descriptor(iface, i);
 		if (ed == NULL) {
 			aprint_error_dev(self,
 			    "could not read endpoint descriptor\n");
 			sc->sc_dying = 1;
 			return;
+		}
 		DPRINTFN(10,("uhidev_attach: bLength=%d bDescriptorType=%d "
 		    "bEndpointAddress=%d-%s bmAttributes=%d wMaxPacketSize=%d"
 		    " bInterval=%d\n",
 		    ed->bLength, ed->bDescriptorType,
 		    ed->bEndpointAddress & UE_ADDR,
 		    UE_GET_DIR(ed->bEndpointAddress)==UE_DIR_IN? "in" : "out",
 		    ed->bmAttributes & UE_XFERTYPE,
 		    UGETW(ed->wMaxPacketSize), ed->bInterval));
 		if (UE_GET_DIR(ed->bEndpointAddress) == UE_DIR_IN &&
 @@ -265,27 +261,26 @@ uhidev_attach(device_t parent, device_t
 		    (ed->bmAttributes & UE_XFERTYPE) == UE_INTERRUPT) {
 			sc->sc_oep_addr = ed->bEndpointAddress;
 		} else {
 			aprint_verbose_dev(self, "endpoint %d: ignored\n", i);
+		}
+	}
 	/*
 	 * Check that we found an input interrupt endpoint. The output interrupt
 	 * endpoint is optional
 	 */
 	if (sc->sc_iep_addr == -1) {
 		aprint_error_dev(self, "no input interrupt endpoint\n");
 		sc->sc_dying = 1;
 		return;
+	}
 	/* XXX need to extend this */
 	descptr = NULL;
 	if (uiaa->uiaa_vendor == USB_VENDOR_WACOM) {
 		static uByte reportbuf[3];
 		/* The report descriptor for the Wacom Graphire is broken. */
 		switch (uiaa->uiaa_product) {
 		case USB_PRODUCT_WACOM_GRAPHIRE3_4X5:
 		case USB_PRODUCT_WACOM_GRAPHIRE3_6X8:
 		case USB_PRODUCT_WACOM_GRAPHIRE4_4X5: /* The 6x8 too? */
 @@ -326,27 +321,26 @@ uhidev_attach(device_t parent, device_t
 		descptr = uhid_x1input_report_descr;
+	}
 	if (descptr) {
 		desc = kmem_alloc(size, KM_SLEEP);
 		err = USBD_NORMAL_COMPLETION;
 		memcpy(desc, descptr, size);
 	} else {
 		desc = NULL;
 		err = usbd_read_report_desc(uiaa->uiaa_iface, &desc, &size);
+	}
 	if (err) {
 		aprint_error_dev(self, "no report descriptor\n");
 		sc->sc_dying = 1;
 		return;
+	}
 	if (uiaa->uiaa_vendor == USB_VENDOR_HOSIDEN &&
 	    uiaa->uiaa_product == USB_PRODUCT_HOSIDEN_PPP) {
 		static uByte reportbuf[] = { 1 };
 		/*
 		 *  This device was sold by Konami with its ParaParaParadise
 		 *  game for PlayStation2.  It needs to be "turned on"
 		 *  before it will send any reports.
 		 */
 		usbd_set_report(uiaa->uiaa_iface, UHID_FEATURE_REPORT, 0,
 @@ -469,40 +463,26 @@ uhidev_maxrepid(void *buf, int len)
 static int
 uhidevprint(void *aux, const char *pnp)
+{
 	struct uhidev_attach_arg *uha = aux;
 	if (pnp)
 		aprint_normal("uhid at %s", pnp);
 	if (uha->reportid != 0)
 		aprint_normal(" reportid %d", uha->reportid);
 	return UNCONF;
+}
 static int
 uhidev_activate(device_t self, enum devact act)
 	struct uhidev_softc *sc = device_private(self);
 	switch (act) {
 	case DVACT_DEACTIVATE:
 		sc->sc_dying = 1;
 		return 0;
 	default:
 		return EOPNOTSUPP;
 static void
 uhidev_childdet(device_t self, device_t child)
+{
 	int i;
 	struct uhidev_softc *sc = device_private(self);
 	for (i = 0; i < sc->sc_nrepid; i++) {
 		if (sc->sc_subdevs[i].sc_dev == child)
 			break;
+	}
 	KASSERT(i < sc->sc_nrepid);
 	sc->sc_subdevs[i].sc_dev = NULL;
 	/*
 @@ -513,46 +493,37 @@ uhidev_childdet(device_t self, device_t
 	 * rescan method, but if there were, it could.)
 	 */
 	rnd_detach_source(&sc->sc_subdevs[i].sc_rndsource);
+}
 static int
 uhidev_detach(device_t self, int flags)
+{
 	struct uhidev_softc *sc = device_private(self);
 	int rv;
 	DPRINTF(("uhidev_detach: sc=%p flags=%d\n", sc, flags));
 	/* Notify that we are going away.  */
 	mutex_enter(&sc->sc_lock);
 	sc->sc_dying = 1;
 	cv_broadcast(&sc->sc_cv);
 	mutex_exit(&sc->sc_lock);
 	/*
 	 * Try to detach all our children.  If anything fails, bail.
 	 * Failure can happen if this is from drvctl -d; of course, if
 	 * this is a USB device being yanked, flags will have
 	 * DETACH_FORCE and the children will not have the option of
-	 * refusing detachment.
+	 * refusing detachment.  If they do detach, the pipes can no
 	 * longer be in use.
 	 */
 	rv = config_detach_children(self, flags);
-	if (rv) {
+	if (rv)
 		mutex_enter(&sc->sc_lock);
 		sc->sc_dying = 0;
 		mutex_exit(&sc->sc_lock);
 		return rv;
 	KASSERTMSG(sc->sc_refcnt == 0,
 	    "%s: %d refs remain", device_xname(sc->sc_dev), sc->sc_refcnt);
 	KASSERT(sc->sc_opipe == NULL);
 	KASSERT(sc->sc_ipipe == NULL);
 	KASSERT(sc->sc_ibuf == NULL);
 	if (sc->sc_repdesc != NULL) {
 		kmem_free(sc->sc_repdesc, sc->sc_repdesc_size);
 		sc->sc_repdesc = NULL;
+	}
 	if (sc->sc_subdevs != NULL) {
 		int nrepid = sc->sc_nrepid;
 @@ -640,28 +611,26 @@ uhidev_get_report_desc(struct uhidev *sc
 	*desc = sc->sc_repdesc;
 	*size = sc->sc_repdesc_size;
+}
 static int
 uhidev_config_enter(struct uhidev_softc *sc)
+{
 	int error;
 	KASSERT(mutex_owned(&sc->sc_lock));
 	for (;;) {
 		if (sc->sc_dying)
 			return ENXIO;
 		if (sc->sc_configlock == NULL)
 			break;
 		error = cv_wait_sig(&sc->sc_cv, &sc->sc_lock);
 		if (error)
 			return error;
+	}
 	sc->sc_configlock = curlwp;
 	return 0;
+}
 static void
 uhidev_config_enter_nointr(struct uhidev_softc *sc)
 @@ -690,30 +659,26 @@ uhidev_config_exit(struct uhidev_softc *
  * uhidev_open_pipes(sc)
+ *
  *	Ensure the pipes of the softc are open.  Caller must hold
  *	sc_lock, which may be released and reacquired.
  */
 static int
 uhidev_open_pipes(struct uhidev_softc *sc)
+{
 	usbd_status err;
 	int error;
 	KASSERT(mutex_owned(&sc->sc_lock));
 	/* If the device is dying, refuse.  */
 	if (sc->sc_dying)
 		return ENXIO;
 	/*
 	 * If the pipes are already open, just increment the reference
 	 * count, or fail if it would overflow.
 	 */
 	if (sc->sc_refcnt) {
 		if (sc->sc_refcnt == INT_MAX)
 			return EBUSY;
 		sc->sc_refcnt++;
 		return 0;
+	}
 	/*
 	 * If there's no input data to prepare, don't bother with the
 @@ -1112,30 +1077,26 @@ usbd_status
 uhidev_write(struct uhidev *scd, void *data, int len)
+{
 	struct uhidev_softc *sc = scd->sc_parent;
 	usbd_status err;
 	DPRINTF(("uhidev_write: data=%p, len=%d\n", data, len));
 	if (sc->sc_opipe == NULL)
 		return USBD_INVAL;
 	mutex_enter(&sc->sc_lock);
 	KASSERT(sc->sc_refcnt);
 	for (;;) {
 		if (sc->sc_dying) {
 			err = USBD_IOERROR;
 			goto out;
 		if (scd->sc_state & UHIDEV_STOPPED) {
 			err = USBD_CANCELLED;
 			goto out;
+		}
 		if (sc->sc_writelock == NULL && sc->sc_stopreportid == -1)
 			break;
 		if (cv_wait_sig(&sc->sc_cv, &sc->sc_lock)) {
 			err = USBD_INTERRUPTED;
 			goto out;
+		}
+	}
 	sc->sc_writelock = curlwp;
 	sc->sc_writereportid = scd->sc_report_id;
 @@ -1200,30 +1161,26 @@ usbd_status
 uhidev_write_async(struct uhidev *scd, void *data, int len, int flags,
     int timo, usbd_callback writecallback, void *writecookie)
+{
 	struct uhidev_softc *sc = scd->sc_parent;
 	usbd_status err;
 	DPRINTF(("%s: data=%p, len=%d\n", __func__, data, len));
 	if (sc->sc_opipe == NULL)
 		return USBD_INVAL;
 	mutex_enter(&sc->sc_lock);
 	KASSERT(sc->sc_refcnt);
 	if (sc->sc_dying) {
 		err = USBD_IOERROR;
 		goto out;
 	if (scd->sc_state & UHIDEV_STOPPED) {
 		err = USBD_CANCELLED;
 		goto out;
+	}
 	if (sc->sc_writelock != NULL || sc->sc_stopreportid != -1) {
 		err = USBD_IN_USE;
 		goto out;
+	}
 	sc->sc_writelock = (void *)1; /* XXX no lwp to attribute async xfer */
 	sc->sc_writereportid = scd->sc_report_id;
 	sc->sc_writecallback = writecallback;
 	sc->sc_writecookie = writecookie;
 	usbd_setup_xfer(sc->sc_oxfer, sc, data, len, flags, timo,