D41639.id126660.diff
No OneTemporary
Actions

Size

35 KB

Referenced Files

None

Subscribers

None

D41639.id126660.diff
View Options

	diff --git a/share/man/man4/Makefile b/share/man/man4/Makefile
	--- a/share/man/man4/Makefile
	+++ b/share/man/man4/Makefile
	@@ -563,6 +563,7 @@
	tws.4 \
	udp.4 \
	udplite.4 \
	+ u2f.4 \
	ure.4 \
	vale.4 \
	vga.4 \
	diff --git a/share/man/man4/u2f.4 b/share/man/man4/u2f.4
	new file mode 100644
	--- /dev/null
	+++ b/share/man/man4/u2f.4
	@@ -0,0 +1,93 @@
	+.\" $OpenBSD: fido.4,v 1.4 2020/08/21 19:02:46 mglocker Exp $
	+.\"
	+.\" Copyright (c) 2019 Reyk Floeter <reyk@openbsd.org>
	+.\" Copyright (c) 2023 Vladimir Kondratyev <wulf@FreeBSD.org>
	+.\"
	+.\" Permission to use, copy, modify, and distribute this software for any
	+.\" purpose with or without fee is hereby granted, provided that the above
	+.\" copyright notice and this permission notice appear in all copies.
	+.\"
	+.\" THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	+.\" WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	+.\" MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	+.\" ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	+.\" WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	+.\" ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	+.\" OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	+.\"
	+.Dd August 21, 2023
	+.Dt U2F 4
	+.Os
	+.Sh NAME
	+.Nm u2f
	+.Nd FIDO/U2F security keys
	+.Sh SYNOPSIS
	+To compile this driver into the kernel,
	+place the following line in your
	+kernel configuration file:
	+.Bd -ragged -offset indent
	+.Cd "device u2f"
	+.Ed
	+.Pp
	+Alternatively, to load the driver as a
	+module at boot time, place the following line in
	+.Xr loader.conf 5 :
	+.Bd -literal -offset indent
	+u2f_load="YES"
	+.Ed
	+.Sh DESCRIPTION
	+The
	+.Nm
	+driver provides support for FIDO/U2F-compatible USB security keys.
	+They are Human Interface Devices (HID) which can be accessed via the
	+.Pa /dev/u2f/N
	+interface.
	+.Pp
	+The driver is compatible with the
	+.Xr read 2 ,
	+.Xr write 2 ,
	+and
	+.Xr ioctl 2
	+operations of the generic
	+.Xr uhid 4
	+device but only accepts the optional HID
	+.Xr ioctl 2
	+calls from u2f group users.
	+.Sh SYSCTL VARIABLES
	+The following variables are available as both
	+.Xr sysctl 8
	+variables and
	+.Xr loader 8
	+tunables:
	+.Bl -tag -width indent
	+.It Va hw.hid.u2f.debug
	+Debug output level, where 0 is debugging disabled and larger values increase
	+debug message verbosity.
	+Default is 0.
	+.El
	+.Sh FILES
	+.Bl -tag -width /dev/u2f/* -compact
	+.It Pa /dev/u2f/*
	+.El
	+.Sh SEE ALSO
	+.Xr uhid 4 ,
	+.Xr usbhid 4 ,
	+.Xr usb 4
	+.Sh HISTORY
	+The
	+.Nm
	+driver first appeared in
	+.Fx 14.0 .
	+.Sh AUTHORS
	+.An -nosplit
	+The
	+.Nm
	+driver was written by
	+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
	+.Pp
	+This manual page was written by
	+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org
	+based on
	+.Ox
	+.Xr fido 4
	+manual page.
	diff --git a/sys/amd64/conf/GENERIC b/sys/amd64/conf/GENERIC
	--- a/sys/amd64/conf/GENERIC
	+++ b/sys/amd64/conf/GENERIC
	@@ -394,3 +394,4 @@
	options HID_DEBUG # enable debug msgs
	device hid # Generic HID support
	options IICHID_SAMPLING # Workaround missing GPIO INTR support
	+options U2F_MAKE_UHID_ALIAS # install /dev/uhid alias
	diff --git a/sys/arm/conf/GENERIC b/sys/arm/conf/GENERIC
	--- a/sys/arm/conf/GENERIC
	+++ b/sys/arm/conf/GENERIC
	@@ -263,6 +263,7 @@

	# HID support
	device hid # Generic HID support
	+options U2F_MAKE_UHID_ALIAS # install /dev/uhid alias

	# Flattened Device Tree
	options FDT # Configure using FDT/DTB data
	diff --git a/sys/arm/conf/RPI-B b/sys/arm/conf/RPI-B
	--- a/sys/arm/conf/RPI-B
	+++ b/sys/arm/conf/RPI-B
	@@ -98,6 +98,7 @@

	# HID support
	device hid # Generic HID support
	+options U2F_MAKE_UHID_ALIAS # install /dev/uhid alias

	# Flattened Device Tree
	options FDT # Configure using FDT/DTB data
	diff --git a/sys/arm64/conf/std.dev b/sys/arm64/conf/std.dev
	--- a/sys/arm64/conf/std.dev
	+++ b/sys/arm64/conf/std.dev
	@@ -108,6 +108,7 @@
	# HID support
	options HID_DEBUG # enable debug msgs
	device hid # Generic HID support
	+options U2F_MAKE_UHID_ALIAS # install /dev/uhid alias

	# Firmware
	device mmio_sram # Generic on-chip SRAM
	diff --git a/sys/conf/NOTES b/sys/conf/NOTES
	--- a/sys/conf/NOTES
	+++ b/sys/conf/NOTES
	@@ -2386,6 +2386,8 @@
	device hpen # Generic pen driver
	device hsctrl # System controls
	device ps4dshock # Sony PS4 DualShock 4 gamepad driver
	+device u2f # FIDO/U2F authenticator
	+options U2F_MAKE_UHID_ALIAS # install /dev/uhid alias
	device xb360gp # XBox 360 gamepad driver

	#####################################################################
	diff --git a/sys/conf/files b/sys/conf/files
	--- a/sys/conf/files
	+++ b/sys/conf/files
	@@ -1779,6 +1779,7 @@
	dev/hid/hsctrl.c optional hsctrl
	dev/hid/ietp.c optional ietp
	dev/hid/ps4dshock.c optional ps4dshock
	+dev/hid/u2f.c optional u2f
	dev/hid/xb360gp.c optional xb360gp
	dev/hifn/hifn7751.c optional hifn
	dev/hptiop/hptiop.c optional hptiop scbus
	diff --git a/sys/conf/options b/sys/conf/options
	--- a/sys/conf/options
	+++ b/sys/conf/options
	@@ -1014,6 +1014,7 @@
	IICHID_SAMPLING opt_hid.h
	HKBD_DFLT_KEYMAP opt_hkbd.h
	HIDRAW_MAKE_UHID_ALIAS opt_hid.h
	+U2F_MAKE_UHID_ALIAS opt_hid.h

	# kenv options
	# The early kernel environment (loader environment, config(8)-provided static)
	diff --git a/sys/dev/hid/hid.h b/sys/dev/hid/hid.h
	--- a/sys/dev/hid/hid.h
	+++ b/sys/dev/hid/hid.h
	@@ -57,6 +57,7 @@
	#define HUP_SCALE 0x008c
	#define HUP_CAMERA_CONTROL 0x0090
	#define HUP_ARCADE 0x0091
	+#define HUP_FIDO 0xf1d0
	#define HUP_MICROSOFT 0xff00

	/* Usages, generic desktop */
	@@ -161,6 +162,9 @@
	#define HUC_HEADPHONE 0x0005
	#define HUC_AC_PAN 0x0238

	+/* Usages, FIDO */
	+#define HUF_U2FHID 0x0001
	+
	#define HID_USAGE2(p,u) (((p) << 16) \| (u))
	#define HID_GET_USAGE(u) ((u) & 0xffff)
	#define HID_GET_USAGE_PAGE(u) (((u) >> 16) & 0xffff)
	diff --git a/sys/dev/hid/hidbus.c b/sys/dev/hid/hidbus.c
	--- a/sys/dev/hid/hidbus.c
	+++ b/sys/dev/hid/hidbus.c
	@@ -66,7 +66,7 @@
	struct mtx mtx; / child intr mtx */
	hid_intr_t intr_handler; / executed under mtx*/
	void *intr_ctx;
	- unsigned int refcnt; /* protected by mtx */
	+ bool active; /* protected by mtx */
	struct epoch_context epoch_ctx;
	CK_STAILQ_ENTRY(hidbus_ivars) link;
	};
	@@ -402,7 +402,7 @@
	struct hidbus_softc *sc = device_get_softc(bus);
	struct hidbus_ivars *tlc = device_get_ivars(child);

	- KASSERT(tlc->refcnt == 0, ("Child device is running"));
	+ KASSERT(!tlc->active, ("Child device is running"));
	tlc->mtx = &sc->mtx;
	tlc->intr_handler = NULL;
	tlc->flags &= ~HIDBUS_FLAG_CAN_POLL;
	@@ -427,7 +427,7 @@
	struct hidbus_ivars *tlc = device_get_ivars(child);

	sx_xlock(&sc->sx);
	- KASSERT(tlc->refcnt == 0, ("Child device is running"));
	+ KASSERT(!tlc->active, ("Child device is running"));
	CK_STAILQ_REMOVE(&sc->tlcs, tlc, hidbus_ivars, link);
	sx_unlock(&sc->sx);
	epoch_call(INPUT_EPOCH, hidbus_ivar_dtor, &tlc->epoch_ctx);
	@@ -578,7 +578,7 @@
	if (!HID_IN_POLLING_MODE())
	epoch_enter_preempt(INPUT_EPOCH, &et);
	CK_STAILQ_FOREACH(tlc, &sc->tlcs, link) {
	- if (tlc->refcnt == 0 \|\| tlc->intr_handler == NULL)
	+ if (!tlc->active \|\| tlc->intr_handler == NULL)
	continue;
	if (HID_IN_POLLING_MODE()) {
	if ((tlc->flags & HIDBUS_FLAG_CAN_POLL) != 0)
	@@ -608,21 +608,14 @@
	MPASS(bus = device_get_parent(child));
	struct hidbus_softc *sc = device_get_softc(bus);
	struct hidbus_ivars *ivar = device_get_ivars(child);
	- struct hidbus_ivars *tlc;
	- bool refcnted = false;
	int error;

	if (sx_xlock_sig(&sc->sx) != 0)
	return (EINTR);
	- CK_STAILQ_FOREACH(tlc, &sc->tlcs, link) {
	- refcnted \|= (tlc->refcnt != 0);
	- if (tlc == ivar) {
	- mtx_lock(tlc->mtx);
	- ++tlc->refcnt;
	- mtx_unlock(tlc->mtx);
	- }
	- }
	- error = refcnted ? 0 : hid_intr_start(bus);
	+ mtx_lock(ivar->mtx);
	+ ivar->active = true;
	+ mtx_unlock(ivar->mtx);
	+ error = hid_intr_start(bus);
	sx_unlock(&sc->sx);

	return (error);
	@@ -635,21 +628,17 @@
	struct hidbus_softc *sc = device_get_softc(bus);
	struct hidbus_ivars *ivar = device_get_ivars(child);
	struct hidbus_ivars *tlc;
	- bool refcnted = false;
	+ bool active = false;
	int error;

	if (sx_xlock_sig(&sc->sx) != 0)
	return (EINTR);
	- CK_STAILQ_FOREACH(tlc, &sc->tlcs, link) {
	- if (tlc == ivar) {
	- mtx_lock(tlc->mtx);
	- MPASS(tlc->refcnt != 0);
	- --tlc->refcnt;
	- mtx_unlock(tlc->mtx);
	- }
	- refcnted \|= (tlc->refcnt != 0);
	- }
	- error = refcnted ? 0 : hid_intr_stop(bus);
	+ mtx_lock(ivar->mtx);
	+ ivar->active = false;
	+ mtx_unlock(ivar->mtx);
	+ CK_STAILQ_FOREACH(tlc, &sc->tlcs, link)
	+ active \|= tlc->active;
	+ error = active ? 0 : hid_intr_stop(bus);
	sx_unlock(&sc->sx);

	return (error);
	diff --git a/sys/dev/hid/hidquirk.h b/sys/dev/hid/hidquirk.h
	--- a/sys/dev/hid/hidquirk.h
	+++ b/sys/dev/hid/hidquirk.h
	@@ -50,6 +50,7 @@
	HQ(IS_XBOX360GP), /* device is XBox 360 GamePad */ \
	HQ(NOWRITE), /* device does not support writes */ \
	HQ(IICHID_SAMPLING), /* IIC backend runs in sampling mode */ \
	+ HQ(NO_READAHEAD), /* Disable interrupt after one report */\
	\
	/* Various quirks */ \
	HQ(HID_IGNORE), /* device should be ignored by hid class */ \
	diff --git a/sys/dev/hid/hidraw.c b/sys/dev/hid/hidraw.c
	--- a/sys/dev/hid/hidraw.c
	+++ b/sys/dev/hid/hidraw.c
	@@ -64,6 +64,7 @@
	#define HID_DEBUG_VAR hidraw_debug
	#include <dev/hid/hid.h>
	#include <dev/hid/hidbus.h>
	+#include <dev/hid/hidquirk.h>
	#include <dev/hid/hidraw.h>

	#ifdef HID_DEBUG
	@@ -85,6 +86,12 @@
	free((buf), M_DEVBUF); \
	}

	+#ifdef HIDRAW_MAKE_UHID_ALIAS
	+#define HIDRAW_NAME "uhid"
	+#else
	+#define HIDRAW_NAME "hidraw"
	+#endif
	+
	struct hidraw_softc {
	device_t sc_dev; /* base device */

	@@ -110,6 +117,8 @@
	bool uhid:1; /* driver switched in to uhid mode */
	bool lock:1; /* input queue sleepable lock */
	bool flush:1; /* do not wait for data in read() */
	+ bool nora:1; /* read-ahead is disabled */
	+ bool run:1; /* interrupt handler is started */
	} sc_state;
	int sc_fflags; /* access mode for open lifetime */

	@@ -183,8 +192,8 @@
	{
	device_t child;

	- if (device_find_child(parent, "hidraw", -1) == NULL) {
	- child = BUS_ADD_CHILD(parent, 0, "hidraw",
	+ if (device_find_child(parent, HIDRAW_NAME, -1) == NULL) {
	+ child = BUS_ADD_CHILD(parent, 0, HIDRAW_NAME,
	device_get_unit(parent));
	if (child != NULL)
	hidbus_set_index(child, HIDRAW_INDEX);
	@@ -269,6 +278,31 @@
	return (0);
	}

	+inline static void
	+hidraw_intr_start(struct hidraw_softc *sc)
	+{
	+ bool empty;
	+
	+ if (sc->sc_state.nora) {
	+ mtx_lock(&sc->sc_mtx);
	+ empty = (sc->sc_tail == sc->sc_head);
	+ mtx_unlock(&sc->sc_mtx);
	+ if (empty)
	+ hid_intr_start(sc->sc_dev);
	+ } else if (!sc->sc_state.run) {
	+ mtx_lock(&sc->sc_mtx);
	+ sc->sc_state.run = true;
	+ mtx_unlock(&sc->sc_mtx);
	+ hid_intr_start(sc->sc_dev);
	+ }
	+}
	+
	+inline static void
	+hidraw_intr_stop(struct hidraw_softc *sc)
	+{
	+ hid_intr_stop(sc->sc_dev);
	+}
	+
	void
	hidraw_intr(void context, void buf, hid_size_t len)
	{
	@@ -369,6 +403,9 @@
	sc->sc_qlen = malloc(sizeof(hid_size_t) * HIDRAW_BUFFER_SIZE, M_DEVBUF,
	M_ZERO \| M_WAITOK);

	+ sc->sc_state.nora = hid_test_quirk(sc->sc_hw, HQ_NO_READAHEAD);
	+ sc->sc_state.run = false;
	+
	/* Set up interrupt pipe. */
	sc->sc_state.immed = false;
	sc->sc_async = 0;
	@@ -377,8 +414,6 @@
	sc->sc_head = sc->sc_tail = 0;
	sc->sc_fflags = flag;

	- hid_intr_start(sc->sc_dev);
	-
	return (0);
	}

	@@ -390,7 +425,7 @@
	DPRINTF("sc=%p\n", sc);

	/* Disable interrupts. */
	- hid_intr_stop(sc->sc_dev);
	+ hidraw_intr_stop(sc);

	sc->sc_tail = sc->sc_head = 0;
	sc->sc_async = 0;
	@@ -416,6 +451,8 @@
	if (sc == NULL)
	return (EIO);

	+ hidraw_intr_start(sc);
	+
	mtx_lock(&sc->sc_mtx);
	error = dev->si_drv1 == NULL ? EIO : hidraw_lock_queue(sc, false);
	if (error != 0) {
	@@ -898,6 +935,7 @@
	if (events & (POLLOUT \| POLLWRNORM) && (sc->sc_fflags & FWRITE))
	revents \|= events & (POLLOUT \| POLLWRNORM);
	if (events & (POLLIN \| POLLRDNORM) && (sc->sc_fflags & FREAD)) {
	+ hidraw_intr_start(sc);
	mtx_lock(&sc->sc_mtx);
	if (sc->sc_head != sc->sc_tail)
	revents \|= events & (POLLIN \| POLLRDNORM);
	@@ -923,6 +961,7 @@
	switch(kn->kn_filter) {
	case EVFILT_READ:
	if (sc->sc_fflags & FREAD) {
	+ hidraw_intr_start(sc);
	kn->kn_fop = &hidraw_filterops_read;
	break;
	}
	@@ -999,7 +1038,7 @@
	};

	static driver_t hidraw_driver = {
	- "hidraw",
	+ HIDRAW_NAME,
	hidraw_methods,
	sizeof(struct hidraw_softc)
	};
	diff --git a/sys/dev/hid/ietp.c b/sys/dev/hid/ietp.c
	--- a/sys/dev/hid/ietp.c
	+++ b/sys/dev/hid/ietp.c
	@@ -103,6 +103,7 @@
	device_t dev;

	struct evdev_dev *evdev;
	+ bool open;
	uint8_t report_id;
	hid_size_t report_len;

	@@ -218,13 +219,25 @@
	static int
	ietp_ev_open(struct evdev_dev *evdev)
	{
	- return (hid_intr_start(evdev_get_softc(evdev)));
	+ struct ietp_softc *sc = evdev_get_softc(evdev);
	+ int error;
	+
	+ error = hid_intr_start(sc->dev);
	+ if (error == 0)
	+ sc->open = true;
	+ return (error);
	}

	static int
	ietp_ev_close(struct evdev_dev *evdev)
	{
	- return (hid_intr_stop(evdev_get_softc(evdev)));
	+ struct ietp_softc *sc = evdev_get_softc(evdev);
	+ int error;
	+
	+ error = hid_intr_stop(sc->dev);
	+ if (error == 0)
	+ sc->open = false;
	+ return (error);
	}

	static int
	@@ -276,7 +289,7 @@
	evdev_set_id(sc->evdev, hw->idBus, hw->idVendor, hw->idProduct,
	hw->idVersion);
	evdev_set_serial(sc->evdev, hw->serial);
	- evdev_set_methods(sc->evdev, sc->dev, &ietp_evdev_methods);
	+ evdev_set_methods(sc->evdev, sc, &ietp_evdev_methods);
	evdev_set_flag(sc->evdev, EVDEV_FLAG_MT_STCOMPAT);
	evdev_set_flag(sc->evdev, EVDEV_FLAG_EXT_EPOCH); /* hidbus child */

	@@ -585,11 +598,13 @@
	* Some ASUS touchpads need to be powered on to enter absolute mode.
	*/
	require_wakeup = false;
	- for (i = 0; i < nitems(special_fw); i++) {
	- if (sc->ic_type == special_fw[i].ic_type &&
	- sc->product_id == special_fw[i].product_id) {
	- require_wakeup = true;
	- break;
	+ if (!sc->open) {
	+ for (i = 0; i < nitems(special_fw); i++) {
	+ if (sc->ic_type == special_fw[i].ic_type &&
	+ sc->product_id == special_fw[i].product_id) {
	+ require_wakeup = true;
	+ break;
	+ }
	}
	}

	diff --git a/sys/dev/hid/u2f.c b/sys/dev/hid/u2f.c
	new file mode 100644
	--- /dev/null
	+++ b/sys/dev/hid/u2f.c
	@@ -0,0 +1,589 @@
	+/*-
	+ * SPDX-License-Identifier: BSD-2-Clause
	+ *
	+ * Copyright (c) 2022-2023 Vladimir Kondratyev <wulf@FreeBSD.org>
	+ *
	+ * 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
	+ * notice, this list of conditions and the following disclaimer.
	+ * 2. Redistributions in binary form must reproduce the above copyright
	+ * notice, this list of conditions and the following disclaimer in the
	+ * documentation and/or other materials provided with the distribution.
	+ *
	+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
	+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
	+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
	+ * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
	+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 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.
	+ */
	+
	+#include "opt_hid.h"
	+
	+#include <sys/param.h>
	+#ifdef COMPAT_FREEBSD32
	+#include <sys/abi_compat.h>
	+#endif
	+#include <sys/bus.h>
	+#include <sys/conf.h>
	+#include <sys/fcntl.h>
	+#include <sys/filio.h>
	+#include <sys/ioccom.h>
	+#include <sys/kernel.h>
	+#include <sys/lock.h>
	+#include <sys/malloc.h>
	+#include <sys/module.h>
	+#include <sys/mutex.h>
	+#include <sys/poll.h>
	+#include <sys/priv.h>
	+#include <sys/proc.h>
	+#include <sys/selinfo.h>
	+#include <sys/sysctl.h>
	+#include <sys/systm.h>
	+#include <sys/uio.h>
	+
	+#include <dev/evdev/input.h>
	+
	+#define HID_DEBUG_VAR u2f_debug
	+#include <dev/hid/hid.h>
	+#include <dev/hid/hidbus.h>
	+#include <dev/hid/hidquirk.h>
	+
	+#include <dev/usb/usb_ioctl.h>
	+
	+#ifdef HID_DEBUG
	+static int u2f_debug = 0;
	+static SYSCTL_NODE(_hw_hid, OID_AUTO, u2f, CTLFLAG_RW, 0,
	+ "FIDO/U2F authenticator");
	+SYSCTL_INT(_hw_hid_u2f, OID_AUTO, debug, CTLFLAG_RWTUN,
	+ &u2f_debug, 0, "Debug level");
	+#endif
	+
	+#define U2F_MAX_REPORT_SIZE 64
	+
	+/* A match on these entries will load u2f */
	+static const struct hid_device_id u2f_devs[] = {
	+ { HID_BUS(BUS_USB), HID_TLC(HUP_FIDO, HUF_U2FHID) },
	+};
	+
	+struct u2f_softc {
	+ device_t sc_dev; /* base device */
	+ struct cdev *dev;
	+
	+ struct mtx sc_mtx; /* hidbus private mutex */
	+ void *sc_rdesc;
	+ hid_size_t sc_rdesc_size;
	+ hid_size_t sc_isize;
	+ hid_size_t sc_osize;
	+ struct selinfo sc_rsel;
	+ struct { /* driver state */
	+ bool open:1; /* device is open */
	+ bool aslp:1; /* waiting for device data in read() */
	+ bool sel:1; /* waiting for device data in poll() */
	+ bool data:1; /* input report is stored in sc_buf */
	+ int reserved:28;
	+ } sc_state;
	+ int sc_fflags; /* access mode for open lifetime */
	+
	+ uint8_t sc_buf[U2F_MAX_REPORT_SIZE];
	+};
	+
	+static d_open_t u2f_open;
	+static d_read_t u2f_read;
	+static d_write_t u2f_write;
	+static d_ioctl_t u2f_ioctl;
	+static d_poll_t u2f_poll;
	+static d_kqfilter_t u2f_kqfilter;
	+
	+static d_priv_dtor_t u2f_dtor;
	+
	+static struct cdevsw u2f_cdevsw = {
	+ .d_version = D_VERSION,
	+ .d_open = u2f_open,
	+ .d_read = u2f_read,
	+ .d_write = u2f_write,
	+ .d_ioctl = u2f_ioctl,
	+ .d_poll = u2f_poll,
	+ .d_kqfilter = u2f_kqfilter,
	+ .d_name = "u2f",
	+};
	+
	+static hid_intr_t u2f_intr;
	+
	+static device_probe_t u2f_probe;
	+static device_attach_t u2f_attach;
	+static device_detach_t u2f_detach;
	+
	+static int u2f_kqread(struct knote *, long);
	+static void u2f_kqdetach(struct knote *);
	+static void u2f_notify(struct u2f_softc *);
	+
	+static struct filterops u2f_filterops_read = {
	+ .f_isfd = 1,
	+ .f_detach = u2f_kqdetach,
	+ .f_event = u2f_kqread,
	+};
	+
	+static int
	+u2f_probe(device_t dev)
	+{
	+ int error;
	+
	+ error = HIDBUS_LOOKUP_DRIVER_INFO(dev, u2f_devs);
	+ if (error != 0)
	+ return (error);
	+
	+ hidbus_set_desc(dev, "Authenticator");
	+
	+ return (BUS_PROBE_GENERIC);
	+}
	+
	+static int
	+u2f_attach(device_t dev)
	+{
	+ struct u2f_softc *sc = device_get_softc(dev);
	+ struct hid_device_info hw = __DECONST(struct hid_device_info ,
	+ hid_get_device_info(dev));
	+ struct make_dev_args mda;
	+ int error;
	+
	+ sc->sc_dev = dev;
	+
	+ error = hid_get_report_descr(dev, &sc->sc_rdesc, &sc->sc_rdesc_size);
	+ if (error != 0)
	+ return (ENXIO);
	+ sc->sc_isize = hid_report_size_max(sc->sc_rdesc, sc->sc_rdesc_size,
	+ hid_input, NULL);
	+ if (sc->sc_isize > U2F_MAX_REPORT_SIZE) {
	+ device_printf(dev, "Input report size too large. Truncate.\n");
	+ sc->sc_isize = U2F_MAX_REPORT_SIZE;
	+ }
	+ sc->sc_osize = hid_report_size_max(sc->sc_rdesc, sc->sc_rdesc_size,
	+ hid_output, NULL);
	+ if (sc->sc_osize > U2F_MAX_REPORT_SIZE) {
	+ device_printf(dev, "Output report size too large. Truncate.\n");
	+ sc->sc_osize = U2F_MAX_REPORT_SIZE;
	+ }
	+
	+ mtx_init(&sc->sc_mtx, "u2f lock", NULL, MTX_DEF);
	+ knlist_init_mtx(&sc->sc_rsel.si_note, &sc->sc_mtx);
	+
	+ make_dev_args_init(&mda);
	+ mda.mda_flags = MAKEDEV_WAITOK;
	+ mda.mda_devsw = &u2f_cdevsw;
	+ mda.mda_uid = UID_ROOT;
	+ mda.mda_gid = GID_U2F;
	+ mda.mda_mode = 0660;
	+ mda.mda_si_drv1 = sc;
	+
	+ error = make_dev_s(&mda, &sc->dev, "u2f/%d", device_get_unit(dev));
	+ if (error) {
	+ device_printf(dev, "Can not create character device\n");
	+ u2f_detach(dev);
	+ return (error);
	+ }
	+#ifdef U2F_MAKE_UHID_ALIAS
	+ (void)make_dev_alias(sc->dev, "uhid%d", device_get_unit(dev));
	+#endif
	+
	+ hid_add_dynamic_quirk(hw, HQ_NO_READAHEAD);
	+
	+ hidbus_set_lock(dev, &sc->sc_mtx);
	+ hidbus_set_intr(dev, u2f_intr, sc);
	+
	+ return (0);
	+}
	+
	+static int
	+u2f_detach(device_t dev)
	+{
	+ struct u2f_softc *sc = device_get_softc(dev);
	+
	+ DPRINTF("sc=%p\n", sc);
	+
	+ if (sc->dev != NULL) {
	+ mtx_lock(&sc->sc_mtx);
	+ sc->dev->si_drv1 = NULL;
	+ /* Wake everyone */
	+ u2f_notify(sc);
	+ mtx_unlock(&sc->sc_mtx);
	+ destroy_dev(sc->dev);
	+ }
	+
	+ hid_intr_stop(sc->sc_dev);
	+
	+ knlist_clear(&sc->sc_rsel.si_note, 0);
	+ knlist_destroy(&sc->sc_rsel.si_note);
	+ seldrain(&sc->sc_rsel);
	+ mtx_destroy(&sc->sc_mtx);
	+
	+ return (0);
	+}
	+
	+void
	+u2f_intr(void context, void buf, hid_size_t len)
	+{
	+ struct u2f_softc *sc = context;
	+
	+ mtx_assert(&sc->sc_mtx, MA_OWNED);
	+
	+ DPRINTFN(5, "len=%d\n", len);
	+ DPRINTFN(5, "data = %*D\n", len, buf, " ");
	+
	+ if (sc->sc_state.data)
	+ return;
	+
	+ if (len > sc->sc_isize)
	+ len = sc->sc_isize;
	+
	+ bcopy(buf, sc->sc_buf, len);
	+
	+ /* Make sure we don't process old data */
	+ if (len < sc->sc_isize)
	+ bzero(sc->sc_buf + len, sc->sc_isize - len);
	+
	+ sc->sc_state.data = true;
	+
	+ u2f_notify(sc);
	+}
	+
	+static int
	+u2f_open(struct cdev dev, int flag, int mode, struct thread td)
	+{
	+ struct u2f_softc *sc = dev->si_drv1;
	+ int error;
	+
	+ if (sc == NULL)
	+ return (ENXIO);
	+
	+ DPRINTF("sc=%p\n", sc);
	+
	+ mtx_lock(&sc->sc_mtx);
	+ if (sc->sc_state.open) {
	+ mtx_unlock(&sc->sc_mtx);
	+ return (EBUSY);
	+ }
	+ sc->sc_state.open = true;
	+ mtx_unlock(&sc->sc_mtx);
	+
	+ error = devfs_set_cdevpriv(sc, u2f_dtor);
	+ if (error != 0) {
	+ mtx_lock(&sc->sc_mtx);
	+ sc->sc_state.open = false;
	+ mtx_unlock(&sc->sc_mtx);
	+ return (error);
	+ }
	+
	+ /* Set up interrupt pipe. */
	+ sc->sc_state.data = false;
	+ sc->sc_fflags = flag;
	+
	+ return (0);
	+}
	+
	+
	+static void
	+u2f_dtor(void *data)
	+{
	+ struct u2f_softc *sc = data;
	+
	+#ifdef NOT_YET
	+ /* Disable interrupts. */
	+ hid_intr_stop(sc->sc_dev);
	+#endif
	+
	+ mtx_lock(&sc->sc_mtx);
	+ sc->sc_state.open = false;
	+ mtx_unlock(&sc->sc_mtx);
	+}
	+
	+static int
	+u2f_read(struct cdev dev, struct uio uio, int flag)
	+{
	+ struct u2f_softc *sc = dev->si_drv1;
	+ size_t length;
	+ int error;
	+
	+ DPRINTFN(1, "\n");
	+
	+ if (sc == NULL)
	+ return (EIO);
	+
	+ if (!sc->sc_state.data)
	+ hid_intr_start(sc->sc_dev);
	+
	+ mtx_lock(&sc->sc_mtx);
	+ if (dev->si_drv1 == NULL) {
	+ error = EIO;
	+ goto exit;
	+ }
	+
	+ while (!sc->sc_state.data) {
	+ if (flag & O_NONBLOCK) {
	+ error = EWOULDBLOCK;
	+ goto exit;
	+ }
	+ sc->sc_state.aslp = true;
	+ DPRINTFN(5, "sleep on %p\n", &sc->sc_buf);
	+ error = mtx_sleep(&sc->sc_buf, &sc->sc_mtx, PZERO \| PCATCH,
	+ "u2frd", 0);
	+ DPRINTFN(5, "woke, error=%d\n", error);
	+ if (dev->si_drv1 == NULL)
	+ error = EIO;
	+ if (error) {
	+ sc->sc_state.aslp = false;
	+ goto exit;
	+ }
	+ }
	+
	+ if (sc->sc_state.data && uio->uio_resid > 0) {
	+ length = min(uio->uio_resid, sc->sc_isize);
	+ mtx_unlock(&sc->sc_mtx);
	+
	+ /* Copy the data to the user process. */
	+ DPRINTFN(5, "got %lu chars\n", (u_long)length);
	+ error = uiomove(sc->sc_buf, length, uio);
	+
	+ mtx_lock(&sc->sc_mtx);
	+ if (error != 0)
	+ goto exit;
	+ sc->sc_state.data = false;
	+ }
	+exit:
	+ mtx_unlock(&sc->sc_mtx);
	+
	+ return (error);
	+}
	+
	+static int
	+u2f_write(struct cdev dev, struct uio uio, int flag)
	+{
	+ uint8_t buf[U2F_MAX_REPORT_SIZE];
	+ struct u2f_softc *sc = dev->si_drv1;
	+ int error;
	+
	+ DPRINTFN(1, "\n");
	+
	+ if (sc == NULL)
	+ return (EIO);
	+
	+ if (uio->uio_resid != sc->sc_osize)
	+ return (EINVAL);
	+ error = uiomove(buf, uio->uio_resid, uio);
	+ if (error == 0)
	+ error = hid_write(sc->sc_dev, buf, sc->sc_osize);
	+
	+ return (error);
	+}
	+
	+#ifdef COMPAT_FREEBSD32
	+static void
	+update_ugd32(const struct usb_gen_descriptor *ugd,
	+ struct usb_gen_descriptor32 *ugd32)
	+{
	+ /* Don't update hgd_data pointer */
	+ CP(ugd, ugd32, ugd_lang_id);
	+ CP(ugd, ugd32, ugd_maxlen);
	+ CP(ugd, ugd32, ugd_actlen);
	+ CP(ugd, ugd32, ugd_offset);
	+ CP(ugd, ugd32, ugd_config_index);
	+ CP(ugd, ugd32, ugd_string_index);
	+ CP(ugd, ugd32, ugd_iface_index);
	+ CP(ugd, ugd32, ugd_altif_index);
	+ CP(ugd, ugd32, ugd_endpt_index);
	+ CP(ugd, ugd32, ugd_report_type);
	+ /* Don't update reserved */
	+}
	+#endif
	+
	+static int
	+u2f_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag,
	+ struct thread *td)
	+{
	+#ifdef COMPAT_FREEBSD32
	+ struct usb_gen_descriptor local_ugd;
	+ struct usb_gen_descriptor32 *ugd32 = NULL;
	+#endif
	+ struct u2f_softc *sc = dev->si_drv1;
	+ struct usb_gen_descriptor ugd = (struct usb_gen_descriptor )addr;
	+ uint32_t size;
	+
	+ DPRINTFN(2, "cmd=%lx\n", cmd);
	+
	+ if (sc == NULL)
	+ return (EIO);
	+
	+#ifdef COMPAT_FREEBSD32
	+ switch (cmd) {
	+ case USB_GET_REPORT_DESC32:
	+ cmd = _IOC_NEWTYPE(cmd, struct usb_gen_descriptor);
	+ ugd32 = (struct usb_gen_descriptor32 *)addr;
	+ ugd = &local_ugd;
	+ PTRIN_CP(ugd32, ugd, ugd_data);
	+ CP(ugd32, ugd, ugd_lang_id);
	+ CP(ugd32, ugd, ugd_maxlen);
	+ CP(ugd32, ugd, ugd_actlen);
	+ CP(ugd32, ugd, ugd_offset);
	+ CP(ugd32, ugd, ugd_config_index);
	+ CP(ugd32, ugd, ugd_string_index);
	+ CP(ugd32, ugd, ugd_iface_index);
	+ CP(ugd32, ugd, ugd_altif_index);
	+ CP(ugd32, ugd, ugd_endpt_index);
	+ CP(ugd32, ugd, ugd_report_type);
	+ /* Don't copy reserved */
	+ break;
	+ }
	+#endif
	+
	+ /* fixed-length ioctls handling */
	+ switch (cmd) {
	+ case FIONBIO:
	+ /* All handled in the upper FS layer. */
	+ return (0);
	+
	+ case USB_GET_REPORT_DESC:
	+ size = MIN(sc->sc_rdesc_size, ugd->ugd_maxlen);
	+ ugd->ugd_actlen = size;
	+#ifdef COMPAT_FREEBSD32
	+ if (ugd32 != NULL)
	+ update_ugd32(ugd, ugd32);
	+#endif
	+ if (ugd->ugd_data == NULL)
	+ return (0); /* descriptor length only */
	+
	+ return (copyout(sc->sc_rdesc, ugd->ugd_data, size));
	+
	+ case USB_GET_DEVICEINFO:
	+ return(hid_ioctl(
	+ sc->sc_dev, USB_GET_DEVICEINFO, (uintptr_t)addr));
	+ }
	+
	+ return (EINVAL);
	+}
	+
	+static int
	+u2f_poll(struct cdev dev, int events, struct thread td)
	+{
	+ struct u2f_softc *sc = dev->si_drv1;
	+ int revents = 0;
	+
	+ if (sc == NULL)
	+ return (POLLHUP);
	+
	+ if (events & (POLLOUT \| POLLWRNORM) && (sc->sc_fflags & FWRITE))
	+ revents \|= events & (POLLOUT \| POLLWRNORM);
	+ if (events & (POLLIN \| POLLRDNORM) && (sc->sc_fflags & FREAD)) {
	+ if (!sc->sc_state.data)
	+ hid_intr_start(sc->sc_dev);
	+ mtx_lock(&sc->sc_mtx);
	+ if (sc->sc_state.data)
	+ revents \|= events & (POLLIN \| POLLRDNORM);
	+ else {
	+ sc->sc_state.sel = true;
	+ selrecord(td, &sc->sc_rsel);
	+ }
	+ mtx_unlock(&sc->sc_mtx);
	+ }
	+
	+ return (revents);
	+}
	+
	+static int
	+u2f_kqfilter(struct cdev dev, struct knote kn)
	+{
	+ struct u2f_softc *sc = dev->si_drv1;
	+
	+ if (sc == NULL)
	+ return (ENXIO);
	+
	+ switch(kn->kn_filter) {
	+ case EVFILT_READ:
	+ if (sc->sc_fflags & FREAD) {
	+ if (!sc->sc_state.data)
	+ hid_intr_start(sc->sc_dev);
	+ kn->kn_fop = &u2f_filterops_read;
	+ break;
	+ }
	+ /* FALLTHROUGH */
	+ default:
	+ return(EINVAL);
	+ }
	+ kn->kn_hook = sc;
	+
	+ knlist_add(&sc->sc_rsel.si_note, kn, 0);
	+ return (0);
	+}
	+
	+static int
	+u2f_kqread(struct knote *kn, long hint)
	+{
	+ struct u2f_softc *sc = kn->kn_hook;
	+ int ret;
	+
	+ mtx_assert(&sc->sc_mtx, MA_OWNED);
	+
	+ if (sc->dev->si_drv1 == NULL) {
	+ kn->kn_flags \|= EV_EOF;
	+ ret = 1;
	+ } else
	+ ret = sc->sc_state.data ? 1 : 0;
	+
	+ return (ret);
	+}
	+
	+static void
	+u2f_kqdetach(struct knote *kn)
	+{
	+ struct u2f_softc *sc = kn->kn_hook;
	+
	+ knlist_remove(&sc->sc_rsel.si_note, kn, 0);
	+}
	+
	+static void
	+u2f_notify(struct u2f_softc *sc)
	+{
	+ mtx_assert(&sc->sc_mtx, MA_OWNED);
	+
	+ if (sc->sc_state.aslp) {
	+ sc->sc_state.aslp = false;
	+ DPRINTFN(5, "waking %p\n", &sc->sc_buf);
	+ wakeup(&sc->sc_buf);
	+ }
	+ if (sc->sc_state.sel) {
	+ sc->sc_state.sel = false;
	+ selwakeuppri(&sc->sc_rsel, PZERO);
	+ }
	+ KNOTE_LOCKED(&sc->sc_rsel.si_note, 0);
	+}
	+
	+static device_method_t u2f_methods[] = {
	+ /* Device interface */
	+ DEVMETHOD(device_probe, u2f_probe),
	+ DEVMETHOD(device_attach, u2f_attach),
	+ DEVMETHOD(device_detach, u2f_detach),
	+
	+ DEVMETHOD_END
	+};
	+
	+static driver_t u2f_driver = {
	+#ifdef U2F_MAKE_UHID_ALIAS
	+ "uhid",
	+#else
	+ "u2f",
	+#endif
	+ u2f_methods,
	+ sizeof(struct u2f_softc)
	+};
	+
	+DRIVER_MODULE(u2f, hidbus, u2f_driver, NULL, NULL);
	+MODULE_DEPEND(u2f, hidbus, 1, 1, 1);
	+MODULE_DEPEND(u2f, hid, 1, 1, 1);
	+MODULE_VERSION(u2f, 1);
	+HID_PNP_INFO(u2f_devs);
	diff --git a/sys/dev/iicbus/iichid.c b/sys/dev/iicbus/iichid.c
	--- a/sys/dev/iicbus/iichid.c
	+++ b/sys/dev/iicbus/iichid.c
	@@ -836,7 +836,8 @@

	sc = device_get_softc(dev);
	DPRINTF(sc, "iichid device open\n");
	- iichid_set_power_state(sc, IICHID_PS_ON, IICHID_PS_NULL);
	+ if (!sc->open)
	+ iichid_set_power_state(sc, IICHID_PS_ON, IICHID_PS_NULL);

	return (0);
	}
	diff --git a/sys/dev/usb/input/uhid.c b/sys/dev/usb/input/uhid.c
	--- a/sys/dev/usb/input/uhid.c
	+++ b/sys/dev/usb/input/uhid.c
	@@ -41,8 +41,6 @@
	* HID spec: http://www.usb.org/developers/devclass_docs/HID1_11.pdf
	*/

	-#include "opt_hid.h"
	-
	#include <sys/stdint.h>
	#include <sys/stddef.h>
	#include <sys/param.h>
	@@ -925,11 +923,7 @@
	};

	static driver_t uhid_driver = {
	-#ifdef HIDRAW_MAKE_UHID_ALIAS
	- .name = "hidraw",
	-#else
	.name = "uhid",
	-#endif
	.methods = uhid_methods,
	.size = sizeof(struct uhid_softc),
	};
	diff --git a/sys/dev/usb/input/usbhid.c b/sys/dev/usb/input/usbhid.c
	--- a/sys/dev/usb/input/usbhid.c
	+++ b/sys/dev/usb/input/usbhid.c
	@@ -115,6 +115,7 @@
	void *cb_ctx;
	int waiters;
	bool influx;
	+ bool no_readahead;
	};

	struct usbhid_softc {
	@@ -273,7 +274,7 @@
	sc->sc_intr_handler(sc->sc_intr_ctx, xfer_ctx->buf,
	xfer_ctx->req.intr.actlen);

	- return (0);
	+ return (xfer_ctx->no_readahead ? ECANCELED : 0);
	}

	static int
	@@ -431,6 +432,7 @@
	.cb = usbhid_intr_handler_cb,
	.cb_ctx = sc,
	.buf = sc->sc_intr_buf,
	+ .no_readahead = hid_test_quirk(&sc->sc_hw, HQ_NO_READAHEAD),
	};
	sc->sc_xfer_ctx[POLL_XFER(USBHID_INTR_IN_DT)] = (struct usbhid_xfer_ctx) {
	.req.intr.maxlen =
	@@ -706,6 +708,10 @@
	if (error == 0)
	ucr->ucr_actlen = UGETW(req.ctrl.wLength);
	break;
	+ case USB_GET_DEVICEINFO:
	+ error = usbd_fill_deviceinfo(sc->sc_udev,
	+ (struct usb_device_info *)data);
	+ break;
	default:
	error = EINVAL;
	}
	diff --git a/sys/dev/usb/usb_device.c b/sys/dev/usb/usb_device.c
	--- a/sys/dev/usb/usb_device.c
	+++ b/sys/dev/usb/usb_device.c
	@@ -3109,3 +3109,51 @@
	{
	return (ep->ep_mode);
	}
	+
	+/------------------------------------------------------------------------
	+ * usbd_fill_deviceinfo
	+ *
	+ * This function dumps information about an USB device to the
	+ * structure pointed to by the "di" argument.
	+ *
	+ * Returns:
	+ * 0: Success
	+ * Else: Failure
	+ ------------------------------------------------------------------------/
	+int
	+usbd_fill_deviceinfo(struct usb_device udev, struct usb_device_info di)
	+{
	+ struct usb_device *hub;
	+
	+ bzero(di, sizeof(di[0]));
	+
	+ di->udi_bus = device_get_unit(udev->bus->bdev);
	+ di->udi_addr = udev->address;
	+ di->udi_index = udev->device_index;
	+ strlcpy(di->udi_serial, usb_get_serial(udev), sizeof(di->udi_serial));
	+ strlcpy(di->udi_vendor, usb_get_manufacturer(udev), sizeof(di->udi_vendor));
	+ strlcpy(di->udi_product, usb_get_product(udev), sizeof(di->udi_product));
	+ usb_printbcd(di->udi_release, sizeof(di->udi_release),
	+ UGETW(udev->ddesc.bcdDevice));
	+ di->udi_vendorNo = UGETW(udev->ddesc.idVendor);
	+ di->udi_productNo = UGETW(udev->ddesc.idProduct);
	+ di->udi_releaseNo = UGETW(udev->ddesc.bcdDevice);
	+ di->udi_class = udev->ddesc.bDeviceClass;
	+ di->udi_subclass = udev->ddesc.bDeviceSubClass;
	+ di->udi_protocol = udev->ddesc.bDeviceProtocol;
	+ di->udi_config_no = udev->curr_config_no;
	+ di->udi_config_index = udev->curr_config_index;
	+ di->udi_power = udev->flags.self_powered ? 0 : udev->power;
	+ di->udi_speed = udev->speed;
	+ di->udi_mode = udev->flags.usb_mode;
	+ di->udi_power_mode = udev->power_mode;
	+ di->udi_suspended = udev->flags.peer_suspended;
	+
	+ hub = udev->parent_hub;
	+ if (hub) {
	+ di->udi_hubaddr = hub->address;
	+ di->udi_hubindex = hub->device_index;
	+ di->udi_hubport = udev->port_no;
	+ }
	+ return (0);
	+}
	diff --git a/sys/dev/usb/usb_generic.c b/sys/dev/usb/usb_generic.c
	--- a/sys/dev/usb/usb_generic.c
	+++ b/sys/dev/usb/usb_generic.c
	@@ -831,42 +831,7 @@
	int
	ugen_fill_deviceinfo(struct usb_fifo f, struct usb_device_info di)
	{
	- struct usb_device *udev;
	- struct usb_device *hub;
	-
	- udev = f->udev;
	-
	- bzero(di, sizeof(di[0]));
	-
	- di->udi_bus = device_get_unit(udev->bus->bdev);
	- di->udi_addr = udev->address;
	- di->udi_index = udev->device_index;
	- strlcpy(di->udi_serial, usb_get_serial(udev), sizeof(di->udi_serial));
	- strlcpy(di->udi_vendor, usb_get_manufacturer(udev), sizeof(di->udi_vendor));
	- strlcpy(di->udi_product, usb_get_product(udev), sizeof(di->udi_product));
	- usb_printbcd(di->udi_release, sizeof(di->udi_release),
	- UGETW(udev->ddesc.bcdDevice));
	- di->udi_vendorNo = UGETW(udev->ddesc.idVendor);
	- di->udi_productNo = UGETW(udev->ddesc.idProduct);
	- di->udi_releaseNo = UGETW(udev->ddesc.bcdDevice);
	- di->udi_class = udev->ddesc.bDeviceClass;
	- di->udi_subclass = udev->ddesc.bDeviceSubClass;
	- di->udi_protocol = udev->ddesc.bDeviceProtocol;
	- di->udi_config_no = udev->curr_config_no;
	- di->udi_config_index = udev->curr_config_index;
	- di->udi_power = udev->flags.self_powered ? 0 : udev->power;
	- di->udi_speed = udev->speed;
	- di->udi_mode = udev->flags.usb_mode;
	- di->udi_power_mode = udev->power_mode;
	- di->udi_suspended = udev->flags.peer_suspended;
	-
	- hub = udev->parent_hub;
	- if (hub) {
	- di->udi_hubaddr = hub->address;
	- di->udi_hubindex = hub->device_index;
	- di->udi_hubport = udev->port_no;
	- }
	- return (0);
	+ return (usbd_fill_deviceinfo(f->udev, di));
	}

	int
	diff --git a/sys/dev/usb/usbdi.h b/sys/dev/usb/usbdi.h
	--- a/sys/dev/usb/usbdi.h
	+++ b/sys/dev/usb/usbdi.h
	@@ -38,6 +38,7 @@
	struct usb_proc_msg;
	struct usb_mbuf;
	struct usb_fs_privdata;
	+struct usb_device_info;
	struct mbuf;

	typedef enum { /* keep in sync with usb_errstr_table */
	@@ -585,6 +586,8 @@
	struct usb_endpoint *ep, uint8_t ep_mode);
	uint8_t usbd_get_endpoint_mode(struct usb_device *udev,
	struct usb_endpoint *ep);
	+int usbd_fill_deviceinfo(struct usb_device *udev,
	+ struct usb_device_info *di);

	const struct usb_device_id *usbd_lookup_id_by_info(
	const struct usb_device_id *id, usb_size_t sizeof_id,
	diff --git a/sys/i386/conf/GENERIC b/sys/i386/conf/GENERIC
	--- a/sys/i386/conf/GENERIC
	+++ b/sys/i386/conf/GENERIC
	@@ -347,3 +347,4 @@
	options HID_DEBUG # enable debug msgs
	device hid # Generic HID support
	options IICHID_SAMPLING # Workaround missing GPIO INTR support
	+options U2F_MAKE_UHID_ALIAS # install /dev/uhid alias
	diff --git a/sys/modules/hid/Makefile b/sys/modules/hid/Makefile
	--- a/sys/modules/hid/Makefile
	+++ b/sys/modules/hid/Makefile
	@@ -18,6 +18,7 @@
	hsctrl \
	ietp \
	ps4dshock \
	+ u2f \
	xb360gp

	.include <bsd.subdir.mk>
	diff --git a/sys/modules/hid/u2f/Makefile b/sys/modules/hid/u2f/Makefile
	new file mode 100644
	--- /dev/null
	+++ b/sys/modules/hid/u2f/Makefile
	@@ -0,0 +1,8 @@
	+.PATH: ${SRCTOP}/sys/dev/hid
	+
	+KMOD= u2f
	+SRCS= u2f.c
	+SRCS+= opt_hid.h opt_usb.h
	+SRCS+= bus_if.h device_if.h
	+
	+.include <bsd.kmod.mk>
	diff --git a/sys/powerpc/conf/GENERIC64 b/sys/powerpc/conf/GENERIC64
	--- a/sys/powerpc/conf/GENERIC64
	+++ b/sys/powerpc/conf/GENERIC64
	@@ -295,3 +295,4 @@
	# HID support
	options HID_DEBUG # enable debug msgs
	device hid # Generic HID support
	+options U2F_MAKE_UHID_ALIAS # install /dev/uhid alias
	diff --git a/sys/powerpc/conf/GENERIC64LE b/sys/powerpc/conf/GENERIC64LE
	--- a/sys/powerpc/conf/GENERIC64LE
	+++ b/sys/powerpc/conf/GENERIC64LE
	@@ -276,3 +276,4 @@
	# HID support
	options HID_DEBUG # enable debug msgs
	device hid # Generic HID support
	+options U2F_MAKE_UHID_ALIAS # install /dev/uhid alias
	diff --git a/sys/riscv/conf/GENERIC b/sys/riscv/conf/GENERIC
	--- a/sys/riscv/conf/GENERIC
	+++ b/sys/riscv/conf/GENERIC
	@@ -121,6 +121,7 @@
	# HID support
	options HID_DEBUG # enable debug msgs
	device hid # Generic HID support
	+options U2F_MAKE_UHID_ALIAS # install /dev/uhid alias

	# DTrace support
	# device dtrace
	diff --git a/sys/sys/conf.h b/sys/sys/conf.h
	--- a/sys/sys/conf.h
	+++ b/sys/sys/conf.h
	@@ -160,6 +160,7 @@
	#define GID_RT_PRIO 47
	#define GID_ID_PRIO 48
	#define GID_DIALER 68
	+#define GID_U2F 116
	#define GID_NOGROUP 65533
	#define GID_NOBODY 65534

File Metadata

Mime Type: text/plain
Expires: Mon, Feb 23, 7:43 PM (4 h, 51 m)
Storage Engine: blob
Storage Format: Raw Data
Storage Handle: 28936583
Default Alt Text: D41639.id126660.diff (35 KB)

D41639.id126660.diffNo OneTemporaryActions

D41639.id126660.diffView Options

File Metadata

Event Timeline

D41639.id126660.diff
No OneTemporary
Actions

D41639.id126660.diff
View Options