Page MenuHomeFreeBSD
Files F110650265

D27777.id81194.diff
No OneTemporary
Actions

D27777.id81194.diff
View Options

This file is larger than 256 KB, so syntax highlighting was skipped.
diff --git a/etc/mtree/BSD.include.dist b/etc/mtree/BSD.include.dist
--- a/etc/mtree/BSD.include.dist
+++ b/etc/mtree/BSD.include.dist
@@ -54,6 +54,8 @@
..
firewire
..
+ hid
+ ..
hwpmc
..
hyperv
diff --git a/include/Makefile b/include/Makefile
--- a/include/Makefile
+++ b/include/Makefile
@@ -159,7 +159,7 @@
done; \
fi
.endfor
-.for i in ${LDIRS} ${LSUBDIRS:Ndev/agp:Ndev/acpica:Ndev/evdev:Ndev/hyperv:Ndev/pci:Ndev/veriexec} ${LSUBSUBDIRS}
+.for i in ${LDIRS} ${LSUBDIRS:Ndev/agp:Ndev/acpica:Ndev/evdev:Ndev/hid:Ndev/hyperv:Ndev/pci:Ndev/veriexec} ${LSUBSUBDIRS}
cd ${SRCTOP}/sys; \
${INSTALL} -C ${TAG_ARGS} -o ${BINOWN} -g ${BINGRP} -m 444 $i/*.h \
${SDESTDIR}${INCLUDEDIR}/$i
@@ -179,6 +179,11 @@
${SDESTDIR}${INCLUDEDIR}/dev/evdev; \
${INSTALL} -C ${TAG_ARGS} -o ${BINOWN} -g ${BINGRP} -m 444 uinput.h \
${SDESTDIR}${INCLUDEDIR}/dev/evdev
+ cd ${SRCTOP}/sys/dev/hid; \
+ ${INSTALL} -C ${TAG_ARGS} -o ${BINOWN} -g ${BINGRP} -m 444 hid.h \
+ ${SDESTDIR}${INCLUDEDIR}/dev/hid; \
+ ${INSTALL} -C ${TAG_ARGS} -o ${BINOWN} -g ${BINGRP} -m 444 hidraw.h \
+ ${SDESTDIR}${INCLUDEDIR}/dev/hid
cd ${SRCTOP}/sys/dev/hyperv/include; \
${INSTALL} -C ${TAG_ARGS} -o ${BINOWN} -g ${BINGRP} -m 444 hyperv.h \
${SDESTDIR}${INCLUDEDIR}/dev/hyperv
@@ -262,7 +267,7 @@
${INSTALL_SYMLINK} ${TAG_ARGS} ../../../sys/$i/$$h ${SDESTDIR}${INCLUDEDIR}/$i; \
done
.endfor
-.for i in ${LSUBDIRS:Ndev/agp:Ndev/acpica:Ndev/evdev:Ndev/hyperv:Ndev/pci:Ndev/veriexec}
+.for i in ${LSUBDIRS:Ndev/agp:Ndev/acpica:Ndev/evdev:Ndev/hid:Ndev/hyperv:Ndev/pci:Ndev/veriexec}
cd ${SRCTOP}/sys/$i; \
for h in *.h; do \
${INSTALL_SYMLINK} ${TAG_ARGS} ../../../../sys/$i/$$h ${SDESTDIR}${INCLUDEDIR}/$i; \
@@ -283,6 +288,11 @@
ln -fs ../../../../sys/dev/evdev/$$h \
${SDESTDIR}${INCLUDEDIR}/dev/evdev; \
done
+ cd ${SRCTOP}/sys/dev/hid; \
+ for h in hid.h hidraw.h; do \
+ ln -fs ../../../../sys/dev/hid/$$h \
+ ${SDESTDIR}${INCLUDEDIR}/dev/hid; \
+ done
cd ${SRCTOP}/sys/dev/hyperv/include; \
for h in hyperv.h; do \
${INSTALL_SYMLINK} ${TAG_ARGS} ../../../../sys/dev/hyperv/include/$$h \
diff --git a/share/man/man4/Makefile b/share/man/man4/Makefile
--- a/share/man/man4/Makefile
+++ b/share/man/man4/Makefile
@@ -181,13 +181,24 @@
gpioths.4 \
gre.4 \
h_ertt.4 \
+ hconf.4 \
+ hcons.4 \
+ hgame.4 \
+ hidbus.4 \
+ hidquirk.4 \
+ hidraw.4 \
hifn.4 \
+ hkbd.4 \
+ hms.4 \
+ hmt.4 \
+ hpen.4 \
hpet.4 \
${_hpt27xx.4} \
${_hptiop.4} \
${_hptmv.4} \
${_hptnr.4} \
${_hptrr.4} \
+ hsctrl.4 \
${_hv_kvp.4} \
${_hv_netvsc.4} \
${_hv_storvsc.4} \
@@ -211,6 +222,7 @@
iic_gpiomux.4 \
iicbb.4 \
iicbus.4 \
+ iichid.4 \
iicmux.4 \
iicsmb.4 \
iir.4 \
@@ -428,6 +440,7 @@
ppi.4 \
procdesc.4 \
proto.4 \
+ ps4dshock.4 \
psm.4 \
pst.4 \
pt.4 \
@@ -584,6 +597,7 @@
wmt.4 \
${_wpi.4} \
wsp.4 \
+ xb360gp.4 \
${_xen.4} \
xhci.4 \
xl.4 \
@@ -1019,6 +1033,7 @@
usb.4 \
usb_quirk.4 \
usb_template.4 \
+ usbhid.4 \
usfs.4 \
uslcom.4 \
uvisor.4 \
diff --git a/share/man/man4/atp.4 b/share/man/man4/atp.4
--- a/share/man/man4/atp.4
+++ b/share/man/man4/atp.4
@@ -38,6 +38,7 @@
your kernel configuration file:
.Bd -ragged -offset indent
.Cd "device atp"
+.Cd "device hid"
.Cd "device usb"
.Ed
.Pp
diff --git a/share/man/man4/hconf.4 b/share/man/man4/hconf.4
new file mode 100644
--- /dev/null
+++ b/share/man/man4/hconf.4
@@ -0,0 +1,90 @@
+.\" Copyright (c) 2020 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd September 14, 2020
+.Dt HCONF 4
+.Os
+.Sh NAME
+.Nm hconf
+.Nd MS Windows Precision Touchpad configuration driver
+.Sh SYNOPSIS
+To compile this driver into the kernel,
+place the following lines in your
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device hconf"
+.Cd "device hid"
+.Cd "device hidbus"
+.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
+hconf_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+driver provides support for generic MS Windows Precision Touchpad
+configuration collection.
+It enables the host to configure two different aspects of the device.
+One allows the host to select input mode, and the other allows the host to be
+selective in what is reported.
+.Sh SYSCTL VARIABLES
+Next parameters are available as
+.Xr sysctl 8
+variables.
+Debug parameter is available as
+.Xr loader 8
+tunable as well.
+.Bl -tag -width indent
+.It Va dev.hmt.*.input_mode
+HID device input mode: 0 = mouse, 3 = touchpad.
+.It Va dev.hmt.*.surface_switch
+Enable / disable switch for surface: 1 = on, 0 = off.
+.It Va dev.hmt.*.buttons_switch
+Enable / disable switch for buttons: 1 = on, 0 = off.
+.It Va hw.hid.hconf.debug
+Debug output level, where 0 is debugging disabled and larger values increase
+debug message verbosity.
+Default is 0.
+.El
+.Sh SEE ALSO
+.Xr hms 4 ,
+.Xr hmt 4
+.Sh HISTORY
+The
+.Nm
+driver first appeared in
+.Fx 13.0.
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
+Switch parameter support was added by
+.An Andriy Gapon Aq Mt avg@FreeBSD.org .
diff --git a/share/man/man4/hcons.4 b/share/man/man4/hcons.4
new file mode 100644
--- /dev/null
+++ b/share/man/man4/hcons.4
@@ -0,0 +1,91 @@
+.\" Copyright (c) 2020 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd September 14, 2020
+.Dt HCONS 4
+.Os
+.Sh NAME
+.Nm hcons
+.Nd HID consumer page controls driver
+.Sh SYNOPSIS
+To compile this driver into the kernel,
+place the following lines in your
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device hcons"
+.Cd "device hid"
+.Cd "device hidbus"
+.Cd "device hidmap"
+.Cd "device evdev"
+.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
+hgame_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+driver provides support for HID consumer page controls most often used as
+"Multimedia keys" found on many keyboards.
+.Pp
+The
+.Pa /dev/input/event*
+device presents the consumer page controls as a
+.Ar evdev
+type device.
+.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.hcons.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/input/event* -compact
+.It Pa /dev/input/event*
+input event device node.
+.El
+.Sh SEE ALSO
+.Xr iichid 4 ,
+.Xr usbhid 4
+.Sh HISTORY
+The
+.Nm
+driver first appeared in
+.Fx 13.0.
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
diff --git a/share/man/man4/hgame.4 b/share/man/man4/hgame.4
new file mode 100644
--- /dev/null
+++ b/share/man/man4/hgame.4
@@ -0,0 +1,98 @@
+.\" Copyright (c) 2020 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd September 14, 2020
+.Dt HGAME 4
+.Os
+.Sh NAME
+.Nm hgame
+.Nd Generic HID game controller (joystick/gamepad) driver
+.Sh SYNOPSIS
+To compile this driver into the kernel,
+place the following lines in your
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device hgame"
+.Cd "device hid"
+.Cd "device hidbus"
+.Cd "device hidmap"
+.Cd "device evdev"
+.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
+hgame_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+driver provides support for generic game controllers (joysticks/gamepads)
+that attach to the HID transport backend.
+See
+.Xr iichid 4
+or
+.Xr usbhid 4 .
+.Pp
+The
+.Pa /dev/input/event*
+device presents the game controller as a
+.Ar evdev
+type device.
+.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.hgame.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/input/event* -compact
+.It Pa /dev/input/event*
+input event device node.
+.El
+.Sh SEE ALSO
+.Xr iichid 4 ,
+.Xr usbhid 4
+.Sh HISTORY
+The
+.Nm
+driver first appeared in
+.Fx 13.0.
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Greg V Aq Mt greg@unrelenting.technology .
+.Pp
+This manual page was written by
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
diff --git a/share/man/man4/hidbus.4 b/share/man/man4/hidbus.4
new file mode 100644
--- /dev/null
+++ b/share/man/man4/hidbus.4
@@ -0,0 +1,102 @@
+.\" Copyright (c) 2020 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd September 14, 2020
+.Dt HIDBUS 4
+.Os
+.Sh NAME
+.Nm hidbus
+.Nd generic HID bus driver
+.Sh SYNOPSIS
+To compile this driver into the kernel,
+place the following lines in your
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device hidbus"
+.Cd "device hid"
+.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
+hidbus_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+driver provides support for multiple HID driver attachments to single HID
+transport backend.
+See
+.Xr iichid 4
+or
+.Xr usbhid 4 .
+.Pp
+Each HID device can have several components, e.g., a keyboard and
+a mouse.
+These components use different report identifiers (a byte) combined into
+groups called collections to distinguish which one data is coming from.
+The
+.Nm
+driver has other drivers attached that handle particular
+kinds of devices and
+.Nm
+broadcasts data to all of them.
+.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.hidbus.debug
+Debug output level, where 0 is debugging disabled and larger values increase
+debug message verbosity.
+Default is 0.
+.El
+.Sh SEE ALSO
+.Xr hconf 4 ,
+.Xr hcons 4 ,
+.Xr hgame 4 ,
+.Xr hidraw 4 ,
+.Xr hkbd 4 ,
+.Xr hms 4 ,
+.Xr hmt 4 ,
+.Xr hpen 4 ,
+.Xr hsctrl 4 ,
+.Xr hskbd 4 ,
+.Xr iichid 4 ,
+.Xr usbhid 4
+.Sh HISTORY
+The
+.Nm
+driver first appeared in
+.Fx 13.0.
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
diff --git a/share/man/man4/hidquirk.4 b/share/man/man4/hidquirk.4
new file mode 100644
--- /dev/null
+++ b/share/man/man4/hidquirk.4
@@ -0,0 +1,143 @@
+.\"
+.\" Copyright (c) 2010 AnyWi Technologies
+.\" All rights reserved.
+.\"
+.\" 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd September 16, 2020
+.Dt HIDQUIRK 4
+.Os
+.Sh NAME
+.Nm hidquirk
+.Nd HID quirks module
+.Sh SYNOPSIS
+To compile this module into the kernel,
+place the following line in your
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device hid"
+.Ed
+.Pp
+Alternatively, to load the module at boot
+time, place the following line in
+.Xr loader.conf 5 :
+.Bd -literal -offset indent
+hidquirk_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+module provides support for adding quirks for HID devices
+.Bl -tag -width Ds
+.It HQ_HID_IGNORE
+device should be ignored by hid class
+.It HQ_KBD_BOOTPROTO
+device should set the boot protocol
+.It HQ_MS_BOOTPROTO
+device should set the boot protocol
+.It HQ_MS_BAD_CLASS
+doesn't identify properly
+.It HQ_MS_LEADING_BYTE
+mouse sends an unknown leading byte
+.It HQ_MS_REVZ
+mouse has Z-axis reversed
+.It HQ_SPUR_BUT_UP
+spurious mouse button up events
+.It HQ_MT_TIMESTAMP
+Multitouch device exports HW timestamps
+.Dv 0x1b5a01
+.El
+.Pp
+See
+.Pa /sys/dev/hid/hidquirk.h
+for the complete list of supported quirks.
+.Sh LOADER TUNABLE
+The following tunable can be set at the
+.Xr loader 8
+prompt before booting the kernel, or stored in
+.Xr loader.conf 5 .
+.Bl -tag -width indent
+.It Va hw.hid.quirk.%d
+The value is a string whose format is:
+.Bd -literal -offset indent
+.Qo BusId VendorId ProductId LowRevision HighRevision HQ_QUIRK,... Qc
+.Ed
+.Pp
+Installs the quirks
+.Ic HQ_QUIRK,...
+for all HID devices matching
+.Ic BusId
+and
+.Ic VendorId
+and
+.Ic ProductId
+which have a hardware revision between and including
+.Ic LowRevision
+and
+.Ic HighRevision .
+.Pp
+.Ic BusId ,
+.Ic VendorId ,
+.Ic ProductId ,
+.Ic LowRevision
+and
+.Ic HighRevision
+are all 16 bits numbers which can be decimal or hexadecimal based.
+.Pp
+A maximum of 100 variables
+.Ic hw.hid.quirk.0, .1, ..., .99
+can be defined.
+.Pp
+If a matching entry is found in the kernel's internal quirks table, it
+is replaced by the new definition.
+.Pp
+Else a new entry is created given that the quirk table is not full.
+.Pp
+The kernel iterates over the
+.Ic hw.hid.quirk.N
+variables starting at
+.Ic N = 0
+and stops at
+.Ic N = 99
+or the first non-existing one.
+.El
+.Sh EXAMPLES
+To install a quirk at boot time, place one or several lines like the
+following in
+.Xr loader.conf 5 :
+.Bd -literal -offset indent
+hw.hid.quirk.0="0x18 0x6cb 0x1941 0 0xffff HQ_MT_TIMESTAMP"
+.Ed
+.Sh HISTORY
+The
+.Nm
+module appeared in
+.Fx 13.0 .
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Hans Petter Selasky Aq Mt hselasky@FreeBSD.org
+for
+.Xr usb 4
+subsystem and adopted to
+.Xr hid 4
+by
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
+This manual page is based on
+.Xr usb_quirk 4
+manual page written by
+.An Nick Hibma Aq Mt n_hibma@FreeBSD.org .
diff --git a/share/man/man4/hidraw.4 b/share/man/man4/hidraw.4
new file mode 100644
--- /dev/null
+++ b/share/man/man4/hidraw.4
@@ -0,0 +1,308 @@
+.\" $NetBSD: uhid.4,v 1.13 2001/12/29 14:41:59 augustss Exp $
+.\"
+.\" Copyright (c) 1999, 2001 The NetBSD Foundation, Inc.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to The NetBSD Foundation
+.\" by Lennart Augustsson.
+.\"
+.\" 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd July 1, 2018
+.Dt HIDRAW 4
+.Os
+.Sh NAME
+.Nm hidraw
+.Nd Raw Access to HID devices
+.Sh SYNOPSIS
+To compile this driver into the kernel,
+place the following line in your
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device hidraw"
+.Cd "device hid"
+.Cd "device hidbus"
+.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
+hidraw_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+driver provides a raw interface to Human Interface Devices (HIDs).
+The reports are sent to and received from the device unmodified.
+.Pp
+The device handles 2 sets of
+.Xr ioctl 2
+calls:
+.Pp
+.Fx
+.Xr uhid 4
+\-compatible calls:
+.Bl -tag -width indent
+.It Dv HID_GET_REPORT_ID Pq Vt int
+Get the report identifier used by this HID report.
+.It Dv HID_GET_REPORT_DESC Pq Vt "struct hidraw_gen_descriptor"
+Get the HID report descriptor.
+Copies a maximum of
+.Va hgd_maxlen
+bytes of the report descriptor data into the memory
+specified by
+.Va hgd_data .
+Upon return
+.Va hgd_actlen
+is set to the number of bytes copied.
+Using
+this descriptor the exact layout and meaning of data to/from
+the device can be found.
+The report descriptor is delivered
+without any processing.
+.Bd -literal
+struct hidraw_gen_descriptor {
+ void *hgd_data;
+ uint16_t hgd_maxlen;
+ uint16_t hgd_actlen;
+ uint8_t hgd_report_type;
+ ...
+};
+.Ed
+.It Dv HID_SET_IMMED Pq Vt int
+Sets the device in a mode where each
+.Xr read 2
+will return the current value of the input report.
+Normally
+a
+.Xr read 2
+will only return the data that the device reports on its
+interrupt pipe.
+This call may fail if the device does not support
+this feature.
+.It Dv HID_GET_REPORT Pq Vt "struct hidraw_gen_descriptor"
+Get a report from the device without waiting for data on
+the interrupt pipe.
+Copies a maximum of
+.Va hgd_maxlen
+bytes of the report data into the memory specified by
+.Va hgd_data .
+Upon return
+.Va hgd_actlen
+is set to the number of bytes copied.
+The
+.Va hgd_report_type
+field indicates which report is requested.
+It should be
+.Dv HID_INPUT_REPORT ,
+.Dv HID_OUTPUT_REPORT ,
+or
+.Dv HID_FEATURE_REPORT .
+On a device which uses numbered reports, the first byte of the returned data
+is the report number.
+The report data begins from the second byte.
+For devices which do not use numbered reports, the report data begins at the
+first byte.
+This call may fail if the device does not support this feature.
+.It Dv HID_SET_REPORT Pq Vt "struct hidraw_gen_descriptor"
+Set a report in the device.
+The
+.Va hgd_report_type
+field indicates which report is to be set.
+It should be
+.Dv HID_INPUT_REPORT ,
+.Dv HID_OUTPUT_REPORT ,
+or
+.Dv HID_FEATURE_REPORT .
+The value of the report is specified by the
+.Va hgd_data
+and the
+.Va hgd_maxlen
+fields.
+On a device which uses numbered reports, the first byte of data to be sent is
+the report number.
+The report data begins from the second byte.
+For devices which do not use numbered reports, the report data begins at the
+first byte.
+This call may fail if the device does not support this feature.
+.El
+.Pp
+Linux
+.Nm
+\-compatible calls:
+.Bl -tag -width indent
+.It Dv HIDIOCGRDESCSIZE Pq Vt int
+Get the HID report descriptor size.
+Returns the size of the device report descriptor to use with
+.Dv HIDIOCGRDESC
+.Xr ioctl 2 .
+.It Dv HIDIOCGRDESC Pq Vt "struct hidraw_report_descriptor"
+Get the HID report descriptor.
+Copies a maximum of
+.Va size
+bytes of the report descriptor data into the memory
+specified by
+.Va value .
+.Bd -literal
+struct hidraw_report_descriptor {
+ uint32_t size;
+ uint8_t value[HID_MAX_DESCRIPTOR_SIZE];
+};
+.Ed
+.It Dv HIDIOCGRAWINFO Pq Vt "struct hidraw_devinfo"
+Get structure containing the bus type, the vendor ID (VID), and product ID
+(PID) of the device. The bus type can be one of:
+.Dv BUS_USB
+or
+.Dv BUS_I2C
+which are defined in dev/evdev/input.h.
+.Bd -literal
+struct hidraw_devinfo {
+ uint32_t bustype;
+ int16_t vendor;
+ int16_t product;
+};
+.Ed
+.It Dv HIDIOCGRAWNAME(len) Pq Vt "char[] buf"
+Get device description.
+Copies a maximum of
+.Va len
+bytes of the device description previously set with
+.Xr device_set_desc 9
+procedure into the memory
+specified by
+.Va buf .
+.It Dv HIDIOCGRAWPHYS(len) Pq Vt "char[] buf"
+Get the newbus path to the device.
+.\For Bluetooth devices, it returns the hardware (MAC) address of the device.
+Copies a maximum of
+.Va len
+bytes of the newbus device path
+into the memory
+specified by
+.Va buf .
+.It Dv HIDIOCGFEATURE(len) Pq Vt "void[] buf"
+Get a feature report from the device.
+Copies a maximum of
+.Va len
+bytes of the feature report data into the memory specified by
+.Va buf .
+The first byte of the supplied buffer should be set to the report
+number of the requested report.
+For devices which do not use numbered reports, set the first byte to 0.
+The report will be returned starting at the first byte of the buffer
+(ie: the report number is not returned).
+This call may fail if the device does not support this feature.
+.It Dv HIDIOCSFEATURE(len) Pq Vt "void[] buf"
+Set a feature Report in the device.
+The value of the report is specified by the
+.Va buf
+and the
+.Va len
+parameters.
+Set the first byte of the supplied buffer to the report number.
+For devices which do not use numbered reports, set the first byte to 0.
+The report data begins in the second byte.
+Make sure to set len accordingly, to one more than the length of the report
+(to account for the report number).
+This call may fail if the device does not support this feature.
+.El
+.Pp
+Use
+.Xr read 2
+to get data from the device.
+Data should be read in chunks of the
+size prescribed by the report descriptor.
+On a device which uses numbered reports, the first byte of the returned data
+is the report number.
+The report data begins from the second byte.
+For devices which do not use numbered reports, the report data begins at the
+first byte.
+.Pp
+Use
+.Xr write 2
+to send data to the device.
+Data should be written in chunks of the
+size prescribed by the report descriptor.
+The first byte of the buffer passed to
+.Xr write 2
+should be set to the report number.
+If the device does not use numbered reports, there are 2 operation modes:
+.Nm
+mode and
+.Xr uhid 4
+mode.
+In the
+.Nm
+mode, the first byte should be set to 0 and the report data itself should
+begin at the second byte.
+In the
+.Xr uhid 4
+mode, the report data should begin at the first byte.
+The modes can be switched with issuing one of
+.Dv HIDIOCGRDESC
+or
+.Dv HID_GET_REPORT_DESC
+.Xr ioctl 2
+accordingly.
+Default mode is
+.Nm .
+.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.hidraw.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 ".Pa /dev/hidraw?"
+.It Pa /dev/hidraw?
+.El
+.Sh SEE ALSO
+.Xr usbhidctl 1 ,
+.Xr hid 4 ,
+.Xr hidbus 4 ,
+.Xr uhid 4
+.Sh HISTORY
+The
+.Xr uhid 4
+driver
+appeared in
+.Nx 1.4 .
+.Nm
+protocol support was added in
+.Fx 13
+by
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
+This manual page was adopted from
+.Nx
+by
+.An Tom Rhodes Aq Mt trhodes@FreeBSD.org
+in April 2002.
diff --git a/share/man/man4/hkbd.4 b/share/man/man4/hkbd.4
new file mode 100644
--- /dev/null
+++ b/share/man/man4/hkbd.4
@@ -0,0 +1,195 @@
+.\" Copyright (c) 1997, 1998
+.\" Nick Hibma <n_hibma@FreeBSD.org>. All rights reserved.
+.\"
+.\" 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd September 12, 2020
+.Dt HKBD 4
+.Os
+.Sh NAME
+.Nm hkbd
+.Nd HID keyboard driver
+.Sh SYNOPSIS
+To compile this driver into the kernel,
+place the following line in your
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device hkbd"
+.Cd "device hid"
+.Cd "device hidbus"
+.Cd "device evdev"
+.Cd "options EVDEV_SUPPORT"
+.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
+hkbd_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+driver provides support for keyboards that attach to the HID transport
+backend.
+.Xr hid 4 ,
+.Xr hidbus 4 ,
+and one of
+.Xr iichid 4
+or
+.Xr usbhid 4
+must be configured in the kernel as well.
+.Sh CONFIGURATION
+By default, the keyboard subsystem does not create the appropriate devices yet.
+Make sure you reconfigure your kernel with the following option in the kernel
+config file:
+.Pp
+.Dl "options KBD_INSTALL_CDEV"
+.Pp
+If both an AT keyboard USB keyboards are used at the same time, the
+AT keyboard will appear as
+.Pa kbd0
+in
+.Pa /dev .
+The USB keyboards will be
+.Pa kbd1 , kbd2 ,
+etc.
+You can see some information about the keyboard with the following command:
+.Pp
+.Dl "kbdcontrol -i < /dev/kbd1"
+.Pp
+or load a keymap with
+.Pp
+.Dl "kbdcontrol -l keymaps/pt.iso < /dev/kbd1"
+.Pp
+See
+.Xr kbdcontrol 1
+for more possible options.
+.Pp
+You can swap console keyboards by using the command
+.Pp
+.Dl "kbdcontrol -k /dev/kbd1"
+.Pp
+From this point on, the first USB keyboard will be the keyboard
+to be used by the console.
+.Pp
+If you want to use a USB keyboard as your default and not use an AT keyboard at
+all, you will have to remove the
+.Cd "device atkbd"
+line from the kernel configuration file.
+Because of the device initialization order,
+the USB keyboard will be detected
+.Em after
+the console driver
+initializes itself and you have to explicitly tell the console
+driver to use the existence of the USB keyboard.
+This can be done in
+one of the following two ways.
+.Pp
+Run the following command as a part of system initialization:
+.Pp
+.Dl "kbdcontrol -k /dev/kbd0 < /dev/ttyv0 > /dev/null"
+.Pp
+(Note that as the USB keyboard is the only keyboard, it is accessed as
+.Pa /dev/kbd0 )
+or otherwise tell the console driver to periodically look for a
+keyboard by setting a flag in the kernel configuration file:
+.Pp
+.Dl "device sc0 at isa? flags 0x100"
+.Pp
+With the above flag, the console driver will try to detect any
+keyboard in the system if it did not detect one while it was
+initialized at boot time.
+.Sh DRIVER CONFIGURATION
+.D1 Cd "options KBD_INSTALL_CDEV"
+.Pp
+Make the keyboards available through a character device in
+.Pa /dev .
+.Pp
+.D1 Cd options HKBD_DFLT_KEYMAP
+.D1 Cd makeoptions HKBD_DFLT_KEYMAP=fr.iso
+.Pp
+The above lines will put the French ISO keymap in the ukbd driver.
+You can specify any keymap in
+.Pa /usr/share/syscons/keymaps
+or
+.Pa /usr/share/vt/keymaps
+(depending on the console driver being used) with this option.
+.Pp
+.D1 Cd "options KBD_DISABLE_KEYMAP_LOADING"
+.Pp
+Do not allow the user to change the keymap.
+Note that these options also affect the AT keyboard driver,
+.Xr atkbd 4 .
+.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.hkbd.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 ".Pa /dev/input/event*" -compact
+.It Pa /dev/kbd*
+blocking device nodes
+.It Pa /dev/input/event*
+input event device nodes.
+.El
+.Sh EXAMPLES
+.D1 Cd "device hkbd"
+.Pp
+Add the
+.Nm
+driver to the kernel.
+.Sh SEE ALSO
+.Xr kbdcontrol 1 ,
+.Xr hid 4 ,
+.Xr hidbus 4 ,
+.Xr iichid 4 ,
+.Xr syscons 4 ,
+.Xr usbhid 4 ,
+.Xr vt 4 ,
+.Xr config 8
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Lennart Augustsson Aq Mt augustss@cs.chalmers.se
+for
+.Nx
+and was substantially rewritten for
+.Fx
+by
+.An Kazutaka YOKOTA Aq Mt yokota@zodiac.mech.utsunomiya-u.ac.jp .
+.Pp
+This manual page was written by
+.An Nick Hibma Aq Mt n_hibma@FreeBSD.org
+with a large amount of input from
+.An Kazutaka YOKOTA Aq Mt yokota@zodiac.mech.utsunomiya-u.ac.jp .
diff --git a/share/man/man4/hms.4 b/share/man/man4/hms.4
new file mode 100644
--- /dev/null
+++ b/share/man/man4/hms.4
@@ -0,0 +1,108 @@
+.\" Copyright (c)
+.\" 1999 Nick Hibma <n_hibma@FreeBSD.org>. All rights reserved.
+.\" 2020 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd September 12, 2020
+.Dt HMS 4
+.Os
+.Sh NAME
+.Nm hms
+.Nd HID mouse driver
+.Sh SYNOPSIS
+To compile this driver into the kernel,
+place the following lines in your
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device hms"
+.Cd "device hidbus"
+.Cd "device hid"
+.Cd "device evdev"
+.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
+hms_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+driver provides support for HID mice that attach to the HID transport
+backend.
+See
+.Xr iichid 4
+or
+.Xr usbhid 4 .
+Supported are
+mice with any number of buttons, mice with a wheel and absolute mice.
+.Pp
+The
+.Pa /dev/input/eventX
+device presents the mouse as a
+.Ar evdev
+type device.
+.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.hms.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/input/eventX -compact
+.It Pa /dev/input/eventX
+input event device node.
+.El
+.Sh SEE ALSO
+.Xr iichid 4 ,
+.Xr usbhid 4 ,
+.Xr xorg.conf 5 Pq Pa ports/x11/xorg
+.\.Xr moused 8
+.Sh BUGS
+.Nm
+cannot act like
+.Xr sysmouse 4
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
+.Pp
+This manual page was originally written by
+.An Nick Hibma Aq Mt n_hibma@FreeBSD.org
+for
+.Xr umt 4
+driver and was adopted for
+.Nm
+by
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
diff --git a/share/man/man4/hmt.4 b/share/man/man4/hmt.4
new file mode 100644
--- /dev/null
+++ b/share/man/man4/hmt.4
@@ -0,0 +1,80 @@
+.\" Copyright (c) 2014-2020 Vladimir Kondratyev <wulf@FreeBSD.org>
+.\" All rights reserved.
+.\"
+.\" 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd August 11, 2020
+.Dt HMT 4
+.Os
+.Sh NAME
+.Nm hmt
+.Nd MS Windows 7/8/10 - compatible HID multi-touch device driver
+.Sh SYNOPSIS
+To compile this driver into the kernel, place the following lines into
+your kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device hmt"
+.Cd "device hidbus"
+.Cd "device hid"
+.Cd "device hconf"
+.Cd "device evdev"
+
+.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
+hmt_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+driver provides support for the MS Windows 7/8/10 - compatible HID
+multi-touch devices found in many laptops.
+.Pp
+To get multi-touch device working in
+.Xr X 7 ,
+install
+.Pa ports/x11-drivers/xf86-input-evdev .
+.Sh FILES
+.Nm
+creates a pseudo-device file,
+.Pa /dev/input/eventX
+which presents the multi-touch device as an input event device.
+.Sh SEE ALSO
+.Xr hid 4 ,
+.Xr loader.conf 5 ,
+.Xr xorg.conf 5 Pq Pa ports/x11/xorg ,
+.Xr evdev 4 Pq Pa ports/x11-drivers/xf86-input-evdev .
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
+.Sh BUGS
+.Nm
+cannot act like
+.Xr sysmouse 4
diff --git a/share/man/man4/hpen.4 b/share/man/man4/hpen.4
new file mode 100644
--- /dev/null
+++ b/share/man/man4/hpen.4
@@ -0,0 +1,105 @@
+.\" Copyright (c) 2020 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd September 14, 2020
+.Dt HPEN 4
+.Os
+.Sh NAME
+.Nm hpen
+.Nd MS Windows compatible HID pen tablet driver
+.Sh SYNOPSIS
+To compile this driver into the kernel,
+place the following lines in your
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device hpen"
+.Cd "device hid"
+.Cd "device hidbus"
+.Cd "device hidmap"
+.Cd "device evdev"
+.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
+hpen_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+driver provides support for generic MS Windows compatible HID pen tablet
+and digitizer that attach to the HID transport backend.
+See
+.Xr iichid 4
+or
+.Xr usbhid 4 .
+.Pp
+The
+.Pa /dev/input/event*
+device presents the pen as a
+.Ar evdev
+type device.
+.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.hpen.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/input/event* -compact
+.It Pa /dev/input/event*
+input event device node.
+.El
+.Sh SEE ALSO
+.Xr iichid 4 ,
+.Xr usbhid 4 ,
+.Xr xorg.conf 5 Pq Pa ports/x11/xorg
+.Sh BUGS
+.Nm
+cannot act like
+.Xr sysmouse 4 .
+.Pp
+Pen battery charge level reporting is not supported.
+.Sh HISTORY
+The
+.Nm
+driver first appeared in
+.Fx 13.0.
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Greg V Aq Mt greg@unrelenting.technology .
+.Pp
+This manual page was written by
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
diff --git a/share/man/man4/hsctrl.4 b/share/man/man4/hsctrl.4
new file mode 100644
--- /dev/null
+++ b/share/man/man4/hsctrl.4
@@ -0,0 +1,91 @@
+.\" Copyright (c) 2020 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd September 14, 2020
+.Dt HSCTRL 4
+.Os
+.Sh NAME
+.Nm hsctrl
+.Nd HID system controls driver
+.Sh SYNOPSIS
+To compile this driver into the kernel,
+place the following lines in your
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device hsctrl"
+.Cd "device hid"
+.Cd "device hidbus"
+.Cd "device hidmap"
+.Cd "device evdev"
+.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
+hgame_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+driver provides support for HID system controls most often used as
+"Power off/Sleep keys" found on many keyboards.
+.Pp
+The
+.Pa /dev/input/event*
+device presents the consumer page controls as a
+.Ar evdev
+type device.
+.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.hsctrl.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/input/event* -compact
+.It Pa /dev/input/event*
+input event device node.
+.El
+.Sh SEE ALSO
+.Xr iichid 4 ,
+.Xr usbhid 4
+.Sh HISTORY
+The
+.Nm
+driver first appeared in
+.Fx 13.0.
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
diff --git a/share/man/man4/iichid.4 b/share/man/man4/iichid.4
new file mode 100644
--- /dev/null
+++ b/share/man/man4/iichid.4
@@ -0,0 +1,96 @@
+.\" Copyright (c) 2020 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd September 21, 2020
+.Dt IICHID 4
+.Os
+.Sh NAME
+.Nm iichid
+.Nd I2C HID transport driver
+.Sh SYNOPSIS
+To compile this driver into the kernel,
+place the following lines in your
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device iichid"
+.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
+iichid_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+driver provides a interface to I2C Human Interface Devices (HIDs).
+.Sh SYSCTL VARIABLES
+Next parameters are available as
+.Xr sysctl 8
+variables.
+Debug parameter is available as
+.Xr loader 8
+tunable as well.
+.Bl -tag -width indent
+.It Va dev.iichid.*.sampling_rate_fast
+Active sampling rate in num/second (for sampling mode).
+.It Va dev.iichid.*.sampling_rate_slow
+Idle sampling rate in num/second (for sampling mode).
+.It Va dev.iichid.*.sampling_hysteresis
+Number of missing samples before enabling of slow mode (for sampling mode).
+.It Va hw.iichid.debug
+Debug output level, where 0 is debugging disabled and larger values increase
+debug message verbosity.
+Default is 0.
+.El
+.Sh SEE ALSO
+.Xr ig4 4
+.Sh BUGS
+The
+.Nm
+does not support GPIO interrupts yet.
+In that case
+.Nm
+enables sampling mode with periodic polling of hardware by driver means.
+See dev.iichid.*.sampling_*
+.Xr sysctl 4
+variables for tuning of sampling parameters.
+.Sh HISTORY
+The
+.Nm
+driver first appeared in
+.Fx 13.0.
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Marc Priggemeyer Aq Mt marc.priggemeyer@gmail.com
+and
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
+.Pp
+This manual page was written by
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
diff --git a/share/man/man4/ps4dshock.4 b/share/man/man4/ps4dshock.4
new file mode 100644
--- /dev/null
+++ b/share/man/man4/ps4dshock.4
@@ -0,0 +1,109 @@
+.\" Copyright (c) 2020 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd September 19, 2020
+.Dt PS4DSHOCK 4
+.Os
+.Sh NAME
+.Nm ps4dshock
+.Nd Sony PlayStation 4 Dualshock 4 gamepad driver
+.Sh SYNOPSIS
+To compile this driver into the kernel,
+place the following lines in your
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device ps4dshock"
+.Cd "device hid"
+.Cd "device hidbus"
+.Cd "device hidmap"
+.Cd "device evdev"
+.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
+ps4dshock_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+driver provides support for Sony PlayStation 4 Dualshock 4 gamepad driver.
+.Pp
+The
+.Pa /dev/input/event*
+device presents the game controller as a
+.Ar evdev
+type device.
+.Sh SYSCTL VARIABLES
+Next parameters are available as
+.Xr sysctl 8
+variables.
+Debug parameter is available as
+.Xr loader 8
+tunable as well.
+.Bl -tag -width indent
+.It Va dev.p4dshock.*.led_state
+LED state: 0 - off, 1 - on, 2 - blinking.
+.It Va dev.p4dshock.*.led_color_r
+LED color.
+Red component.
+.It Va dev.p4dshock.*.led_color_g
+LED color.
+Green component.
+.It Va dev.p4dshock.*.led_color_b
+LED color.
+Blue component.
+.It Va dev.p4dshock.*.led_delay_on
+LED blink.
+On delay, msecs.
+.It Va dev.p4dshock.*.led_delay_off
+LED blink.
+Off delay, msecs.
+.It Va hw.hid.ps4dshock.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/input/event* -compact
+.It Pa /dev/input/event*
+input event device node.
+.El
+.Sh BUGS
+The
+.Nm
+does not support force-feedback events.
+.Sh HISTORY
+The
+.Nm
+driver first appeared in
+.Fx 13.0.
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
diff --git a/share/man/man4/ucycom.4 b/share/man/man4/ucycom.4
--- a/share/man/man4/ucycom.4
+++ b/share/man/man4/ucycom.4
@@ -39,6 +39,7 @@
kernel configuration file:
.Bd -ragged -offset indent
.Cd "device usb"
+.Cd "device hid"
.Cd "device ucom"
.Cd "device ucycom"
.Ed
diff --git a/share/man/man4/ugold.4 b/share/man/man4/ugold.4
--- a/share/man/man4/ugold.4
+++ b/share/man/man4/ugold.4
@@ -28,6 +28,7 @@
your kernel configuration file:
.Bd -ragged -offset indent
.Cd "device usb"
+.Cd "device hid"
.Cd "device ugold"
.Ed
.Pp
diff --git a/share/man/man4/uhid.4 b/share/man/man4/uhid.4
--- a/share/man/man4/uhid.4
+++ b/share/man/man4/uhid.4
@@ -41,6 +41,8 @@
kernel configuration file:
.Bd -ragged -offset indent
.Cd "device uhid"
+.Cd "device hid"
+.Cd "device usb"
.Ed
.Pp
Alternatively, to load the driver as a
diff --git a/share/man/man4/ukbd.4 b/share/man/man4/ukbd.4
--- a/share/man/man4/ukbd.4
+++ b/share/man/man4/ukbd.4
@@ -36,6 +36,8 @@
kernel configuration file:
.Bd -ragged -offset indent
.Cd "device ukbd"
+.Cd "device hid"
+.Cd "device usb"
.Ed
.Pp
Alternatively, to load the driver as a
diff --git a/share/man/man4/ums.4 b/share/man/man4/ums.4
--- a/share/man/man4/ums.4
+++ b/share/man/man4/ums.4
@@ -36,6 +36,7 @@
kernel configuration file:
.Bd -ragged -offset indent
.Cd "device ums"
+.Cd "device hid"
.Cd "device uhci"
.Cd "device ohci"
.Cd "device usb"
diff --git a/share/man/man4/usbhid.4 b/share/man/man4/usbhid.4
new file mode 100644
--- /dev/null
+++ b/share/man/man4/usbhid.4
@@ -0,0 +1,79 @@
+.\" Copyright (c) 2020 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd September 21, 2020
+.Dt USBHID 4
+.Os
+.Sh NAME
+.Nm usbhid
+.Nd USB HID transport driver
+.Sh SYNOPSIS
+To compile this driver into the kernel,
+place the following lines in your
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device usbhid"
+.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
+usbhid_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+driver provides a interface to USB Human Interface Devices (HIDs).
+.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.usb.usbhid.debug
+Debug output level, where 0 is debugging disabled and larger values increase
+debug message verbosity.
+Default is 0.
+.El
+.Sh SEE ALSO
+.Xr ehci 4 ,
+.Xr ohci 4 ,
+.Xr uhci 4 ,
+.Xr usb 4 ,
+.Xr xhci 4 ,
+.Xr usbconfig 8
+.Sh HISTORY
+The
+.Nm
+driver first appeared in
+.Fx 13.0.
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
diff --git a/share/man/man4/wmt.4 b/share/man/man4/wmt.4
--- a/share/man/man4/wmt.4
+++ b/share/man/man4/wmt.4
@@ -36,6 +36,7 @@
.Bd -ragged -offset indent
.Cd "device wmt"
.Cd "device usb"
+.Cd "device hid"
.Cd "device evdev"
.Ed
.Pp
diff --git a/share/man/man4/wsp.4 b/share/man/man4/wsp.4
--- a/share/man/man4/wsp.4
+++ b/share/man/man4/wsp.4
@@ -35,6 +35,7 @@
your kernel configuration file:
.Bd -ragged -offset indent
.Cd "device wsp"
+.Cd "device hid"
.Cd "device usb"
.Ed
.Pp
diff --git a/share/man/man4/xb360gp.4 b/share/man/man4/xb360gp.4
new file mode 100644
--- /dev/null
+++ b/share/man/man4/xb360gp.4
@@ -0,0 +1,91 @@
+.\" Copyright (c) 2020 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.
+.\"
+.\" $FreeBSD$
+.\"
+.Dd September 16, 2020
+.Dt XB360GP 4
+.Os
+.Sh NAME
+.Nm xb360gp
+.Nd XBox 360 gamepad driver
+.Sh SYNOPSIS
+To compile this driver into the kernel,
+place the following lines in your
+kernel configuration file:
+.Bd -ragged -offset indent
+.Cd "device xb360gp"
+.Cd "device hgame"
+.Cd "device hid"
+.Cd "device hidbus"
+.Cd "device hidmap"
+.Cd "device evdev"
+.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
+xb360gp_load="YES"
+.Ed
+.Sh DESCRIPTION
+The
+.Nm
+driver provides support for XBox 360 gamepad driver.
+.Pp
+The
+.Pa /dev/input/event*
+device presents the game controller as a
+.Ar evdev
+type device.
+.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.xb360gp.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/input/event* -compact
+.It Pa /dev/input/event*
+input event device node.
+.El
+.Sh HISTORY
+The
+.Nm
+driver first appeared in
+.Fx 13.0.
+.Sh AUTHORS
+.An -nosplit
+The
+.Nm
+driver was written by
+.An Greg V Aq Mt greg@unrelenting.technology .
+.Pp
+This manual page was written by
+.An Vladimir Kondratyev Aq Mt wulf@FreeBSD.org .
diff --git a/sys/amd64/conf/GENERIC b/sys/amd64/conf/GENERIC
--- a/sys/amd64/conf/GENERIC
+++ b/sys/amd64/conf/GENERIC
@@ -380,3 +380,12 @@
options EVDEV_SUPPORT # evdev support in legacy drivers
device evdev # input event device support
device uinput # install /dev/uinput cdev
+
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
+options IICHID_DEBUG # enable debug msgs for I2C transport
+options IICHID_SAMPLING # Workaround missing GPIO INTR support
+#device usbhid # USB transport support.
+#device hidbus # HID bus (required by usbhid/iichid)
+#options USBHID_ENABLED # Prefer usbhid to other USB drivers
diff --git a/sys/arm/broadcom/bcm2835/bcm2835_ft5406.c b/sys/arm/broadcom/bcm2835/bcm2835_ft5406.c
--- a/sys/arm/broadcom/bcm2835/bcm2835_ft5406.c
+++ b/sys/arm/broadcom/bcm2835/bcm2835_ft5406.c
@@ -246,13 +246,13 @@
evdev_support_event(sc->sc_evdev, EV_SYN);
evdev_support_event(sc->sc_evdev, EV_ABS);
- evdev_support_abs(sc->sc_evdev, ABS_MT_SLOT, 0, 0,
+ evdev_support_abs(sc->sc_evdev, ABS_MT_SLOT, 0,
MAX_TOUCH_ID, 0, 0, 0);
- evdev_support_abs(sc->sc_evdev, ABS_MT_TRACKING_ID, 0, -1,
+ evdev_support_abs(sc->sc_evdev, ABS_MT_TRACKING_ID, -1,
MAX_TOUCH_ID, 0, 0, 0);
- evdev_support_abs(sc->sc_evdev, ABS_MT_POSITION_X, 0, 0,
+ evdev_support_abs(sc->sc_evdev, ABS_MT_POSITION_X, 0,
SCREEN_WIDTH, 0, 0, SCREEN_RES_X);
- evdev_support_abs(sc->sc_evdev, ABS_MT_POSITION_Y, 0, 0,
+ evdev_support_abs(sc->sc_evdev, ABS_MT_POSITION_Y, 0,
SCREEN_HEIGHT, 0, 0, SCREEN_RES_Y);
err = evdev_register_mtx(sc->sc_evdev, &sc->sc_mtx);
diff --git a/sys/arm/conf/EFIKA_MX b/sys/arm/conf/EFIKA_MX
--- a/sys/arm/conf/EFIKA_MX
+++ b/sys/arm/conf/EFIKA_MX
@@ -116,6 +116,10 @@
device wlan_tkip # 802.11 TKIP support
device wlan_amrr # AMRR transmit rate control algorithm
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
+
# Flattened Device Tree
options FDT # Configure using FDT/DTB data
options FDT_DTB_STATIC
diff --git a/sys/arm/conf/GENERIC b/sys/arm/conf/GENERIC
--- a/sys/arm/conf/GENERIC
+++ b/sys/arm/conf/GENERIC
@@ -280,6 +280,10 @@
# Thermal sensors
device aw_thermal # Allwinner Thermal Sensor Controller
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
+
# Flattened Device Tree
options FDT # Configure using FDT/DTB data
makeoptions MODULES_EXTRA+="dtb/allwinner"
diff --git a/sys/arm/conf/IMX53 b/sys/arm/conf/IMX53
--- a/sys/arm/conf/IMX53
+++ b/sys/arm/conf/IMX53
@@ -113,6 +113,10 @@
#device mmc # SD/MMC protocol
#device mmcsd # SDCard disk device
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
+
# Flattened Device Tree
options FDT # Configure using FDT/DTB data
diff --git a/sys/arm/conf/IMX6 b/sys/arm/conf/IMX6
--- a/sys/arm/conf/IMX6
+++ b/sys/arm/conf/IMX6
@@ -106,6 +106,10 @@
#device wlan_tkip # 802.11 TKIP support
#device wlan_amrr # AMRR transmit rate control algorithm
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
+
device vt
device kbdmux
device ukbd
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
@@ -89,6 +89,10 @@
device fdt_pinctrl
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
+
# Flattened Device Tree
options FDT # Configure using FDT/DTB data
# Note: DTB is normally loaded and modified by RPi boot loader, then
diff --git a/sys/arm/conf/TEGRA124 b/sys/arm/conf/TEGRA124
--- a/sys/arm/conf/TEGRA124
+++ b/sys/arm/conf/TEGRA124
@@ -130,6 +130,10 @@
#device sound
#device snd_hda
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
+
# Flattened Device Tree
options FDT # Configure using FDT/DTB data
device fdt_pinctrl
diff --git a/sys/arm/conf/VYBRID b/sys/arm/conf/VYBRID
--- a/sys/arm/conf/VYBRID
+++ b/sys/arm/conf/VYBRID
@@ -103,5 +103,9 @@
device kbdmux
device ukbd
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
+
# Flattened Device Tree
options FDT # Configure using FDT/DTB data
diff --git a/sys/arm/ti/ti_adc.c b/sys/arm/ti/ti_adc.c
--- a/sys/arm/ti/ti_adc.c
+++ b/sys/arm/ti/ti_adc.c
@@ -890,9 +890,9 @@
evdev_support_event(sc->sc_evdev, EV_ABS);
evdev_support_event(sc->sc_evdev, EV_KEY);
- evdev_support_abs(sc->sc_evdev, ABS_X, 0, 0,
+ evdev_support_abs(sc->sc_evdev, ABS_X, 0,
ADC_MAX_VALUE, 0, 0, 0);
- evdev_support_abs(sc->sc_evdev, ABS_Y, 0, 0,
+ evdev_support_abs(sc->sc_evdev, ABS_Y, 0,
ADC_MAX_VALUE, 0, 0, 0);
evdev_support_key(sc->sc_evdev, BTN_TOUCH);
diff --git a/sys/arm64/conf/GENERIC b/sys/arm64/conf/GENERIC
--- a/sys/arm64/conf/GENERIC
+++ b/sys/arm64/conf/GENERIC
@@ -369,3 +369,7 @@
# DTBs
makeoptions MODULES_EXTRA="dtb/allwinner dtb/freescale dtb/imx8 dtb/mv dtb/rockchip dtb/rpi"
+
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
diff --git a/sys/conf/files b/sys/conf/files
--- a/sys/conf/files
+++ b/sys/conf/files
@@ -1817,6 +1817,22 @@
dev/gpio/gpiobus_if.m optional gpio
dev/gpio/gpiopps.c optional gpiopps fdt
dev/gpio/ofw_gpiobus.c optional fdt gpio
+dev/hid/hconf.c optional hconf
+dev/hid/hcons.c optional hcons
+dev/hid/hgame.c optional hgame
+dev/hid/hid.c optional hid
+dev/hid/hid_if.m optional hid
+dev/hid/hidbus.c optional hidbus
+dev/hid/hidmap.c optional hidmap
+dev/hid/hidquirk.c optional hid
+dev/hid/hidraw.c optional hidraw
+dev/hid/hkbd.c optional hkbd
+dev/hid/hms.c optional hms
+dev/hid/hmt.c optional hmt hconf
+dev/hid/hpen.c optional hpen
+dev/hid/hsctrl.c optional hsctrl
+dev/hid/ps4dshock.c optional ps4dshock
+dev/hid/xb360gp.c optional xb360gp
dev/hifn/hifn7751.c optional hifn
dev/hptiop/hptiop.c optional hptiop scbus
dev/hwpmc/hwpmc_logging.c optional hwpmc
@@ -1846,6 +1862,7 @@
dev/iicbus/iicbb_if.m optional iicbb
dev/iicbus/iicbus.c optional iicbus
dev/iicbus/iicbus_if.m optional iicbus
+dev/iicbus/iichid.c optional iichid acpi hid iicbus
dev/iicbus/iiconf.c optional iicbus
dev/iicbus/iicsmb.c optional iicsmb \
dependency "iicbus_if.h"
@@ -2322,7 +2339,7 @@
compile-with "${NORMAL_C} -I$S/dev/ixgbe"
dev/jedec_dimm/jedec_dimm.c optional jedec_dimm smbus
dev/jme/if_jme.c optional jme pci
-dev/kbd/kbd.c optional atkbd | pckbd | sc | ukbd | vt
+dev/kbd/kbd.c optional atkbd | pckbd | sc | ukbd | vt | hkbd
dev/kbdmux/kbdmux.c optional kbdmux
dev/ksyms/ksyms.c optional ksyms
dev/le/am7990.c optional le
@@ -3409,6 +3426,7 @@
dev/usb/input/uhid_snes.c optional uhid_snes
dev/usb/input/ukbd.c optional ukbd
dev/usb/input/ums.c optional ums
+dev/usb/input/usbhid.c optional usbhid
dev/usb/input/wmt.c optional wmt
dev/usb/input/wsp.c optional wsp
#
@@ -4065,6 +4083,7 @@
libkern/random.c standard
libkern/scanc.c standard
libkern/strcasecmp.c standard
+libkern/strcasestr.c standard
libkern/strcat.c standard
libkern/strchr.c standard
libkern/strchrnul.c optional gdb
diff --git a/sys/conf/options b/sys/conf/options
--- a/sys/conf/options
+++ b/sys/conf/options
@@ -668,6 +668,7 @@
UPLCOM_INTR_INTERVAL opt_uplcom.h
UVSCOM_DEFAULT_OPKTSIZE opt_uvscom.h
UVSCOM_INTR_INTERVAL opt_uvscom.h
+USBHID_ENABLED opt_usb.h
# options for the Realtek rtwn driver
RTWN_DEBUG opt_rtwn.h
@@ -1012,3 +1013,10 @@
# gcov support
GCOV opt_global.h
LINDEBUGFS
+
+# options for HID support
+HID_DEBUG opt_hid.h
+IICHID_DEBUG opt_hid.h
+IICHID_SAMPLING opt_hid.h
+HKBD_DFLT_KEYMAP opt_hkbd.h
+HIDRAW_MAKE_UHID_ALIAS opt_hid.h
diff --git a/sys/dev/atkbdc/psm.c b/sys/dev/atkbdc/psm.c
--- a/sys/dev/atkbdc/psm.c
+++ b/sys/dev/atkbdc/psm.c
@@ -1705,7 +1705,7 @@
size_t i;
for (i = 0; info[i][0] != ABS_CNT; i++)
- evdev_support_abs(evdev, info[i][0], 0, info[i][1], info[i][2],
+ evdev_support_abs(evdev, info[i][0], info[i][1], info[i][2],
0, 0, info[i][3]);
}
@@ -1865,7 +1865,7 @@
if (sc->synhw.capAdvancedGestures || sc->synhw.capReportsV)
psm_support_abs_bulk(evdev_a, synaptics_absinfo_mt);
if (sc->synhw.capPalmDetect)
- evdev_support_abs(evdev_a, ABS_TOOL_WIDTH, 0, 0, 15, 0, 0, 0);
+ evdev_support_abs(evdev_a, ABS_TOOL_WIDTH, 0, 15, 0, 0, 0);
evdev_support_key(evdev_a, BTN_LEFT);
if (!sc->synhw.capClickPad) {
evdev_support_key(evdev_a, BTN_RIGHT);
diff --git a/sys/dev/cyapa/cyapa.c b/sys/dev/cyapa/cyapa.c
--- a/sys/dev/cyapa/cyapa.c
+++ b/sys/dev/cyapa/cyapa.c
@@ -594,13 +594,13 @@
evdev_support_prop(sc->evdev, INPUT_PROP_BUTTONPAD);
evdev_support_abs(sc->evdev, ABS_MT_SLOT,
- 0, 0, CYAPA_MAX_MT - 1, 0, 0, 0);
- evdev_support_abs(sc->evdev, ABS_MT_TRACKING_ID, 0, -1, 15, 0, 0, 0);
- evdev_support_abs(sc->evdev, ABS_MT_POSITION_X, 0, 0, sc->cap_resx,
- 0, 0, sc->cap_phyx != 0 ? sc->cap_resx / sc->cap_phyx : 0);
- evdev_support_abs(sc->evdev, ABS_MT_POSITION_Y, 0, 0, sc->cap_resy,
- 0, 0, sc->cap_phyy != 0 ? sc->cap_resy / sc->cap_phyy : 0);
- evdev_support_abs(sc->evdev, ABS_MT_PRESSURE, 0, 0, 255, 0, 0, 0);
+ 0, CYAPA_MAX_MT - 1, 0, 0, 0);
+ evdev_support_abs(sc->evdev, ABS_MT_TRACKING_ID, -1, 15, 0, 0, 0);
+ evdev_support_abs(sc->evdev, ABS_MT_POSITION_X, 0, sc->cap_resx, 0, 0,
+ sc->cap_phyx != 0 ? sc->cap_resx / sc->cap_phyx : 0);
+ evdev_support_abs(sc->evdev, ABS_MT_POSITION_Y, 0, sc->cap_resy, 0, 0,
+ sc->cap_phyy != 0 ? sc->cap_resy / sc->cap_phyy : 0);
+ evdev_support_abs(sc->evdev, ABS_MT_PRESSURE, 0, 255, 0, 0, 0);
if (evdev_register(sc->evdev) != 0) {
mtx_destroy(&sc->mutex);
diff --git a/sys/dev/evdev/cdev.c b/sys/dev/evdev/cdev.c
--- a/sys/dev/evdev/cdev.c
+++ b/sys/dev/evdev/cdev.c
@@ -32,6 +32,7 @@
#include <sys/param.h>
#include <sys/bitstring.h>
#include <sys/conf.h>
+#include <sys/epoch.h>
#include <sys/filio.h>
#include <sys/fcntl.h>
#include <sys/kernel.h>
@@ -125,23 +126,20 @@
mtx_init(&client->ec_buffer_mtx, "evclient", "evdev", MTX_DEF);
knlist_init_mtx(&client->ec_selp.si_note, &client->ec_buffer_mtx);
+ ret = EVDEV_LIST_LOCK_SIG(evdev);
+ if (ret != 0)
+ goto out;
/* Avoid race with evdev_unregister */
- EVDEV_LOCK(evdev);
if (dev->si_drv1 == NULL)
ret = ENODEV;
else
ret = evdev_register_client(evdev, client);
-
- if (ret != 0)
- evdev_revoke_client(client);
- /*
- * Unlock evdev here because non-sleepable lock held
- * while calling devfs_set_cdevpriv upsets WITNESS
- */
- EVDEV_UNLOCK(evdev);
-
- if (!ret)
+ EVDEV_LIST_UNLOCK(evdev);
+out:
+ if (ret == 0)
ret = devfs_set_cdevpriv(client, evdev_dtor);
+ else
+ client->ec_revoked = true;
if (ret != 0) {
debugf(client, "cannot register evdev client");
@@ -156,11 +154,13 @@
{
struct evdev_client *client = (struct evdev_client *)data;
- EVDEV_LOCK(client->ec_evdev);
+ EVDEV_LIST_LOCK(client->ec_evdev);
if (!client->ec_revoked)
evdev_dispose_client(client->ec_evdev, client);
- EVDEV_UNLOCK(client->ec_evdev);
+ EVDEV_LIST_UNLOCK(client->ec_evdev);
+ if (client->ec_evdev->ev_lock_type != EV_LOCK_MTX)
+ epoch_wait_preempt(client->ec_evdev->ev_epoch);
knlist_clear(&client->ec_selp.si_note, 0);
seldrain(&client->ec_selp);
knlist_destroy(&client->ec_selp.si_note);
@@ -547,12 +547,12 @@
if (*(int *)data != 0)
return (EINVAL);
- EVDEV_LOCK(evdev);
+ EVDEV_LIST_LOCK(evdev);
if (dev->si_drv1 != NULL && !client->ec_revoked) {
evdev_dispose_client(evdev, client);
evdev_revoke_client(client);
}
- EVDEV_UNLOCK(evdev);
+ EVDEV_LIST_UNLOCK(evdev);
return (0);
case EVIOCSCLOCKID:
@@ -717,7 +717,7 @@
evdev_revoke_client(struct evdev_client *client)
{
- EVDEV_LOCK_ASSERT(client->ec_evdev);
+ EVDEV_LIST_LOCK_ASSERT(client->ec_evdev);
client->ec_revoked = true;
}
diff --git a/sys/dev/evdev/evdev.h b/sys/dev/evdev/evdev.h
--- a/sys/dev/evdev/evdev.h
+++ b/sys/dev/evdev/evdev.h
@@ -30,6 +30,7 @@
#define _DEV_EVDEV_EVDEV_H
#include <sys/types.h>
+#include <sys/epoch.h>
#include <sys/kbio.h>
#include <dev/evdev/input.h>
#include <dev/kbd/kbdreg.h>
@@ -110,6 +111,7 @@
const struct evdev_methods *);
int evdev_register(struct evdev_dev *);
int evdev_register_mtx(struct evdev_dev *, struct mtx *);
+int evdev_register_epoch(struct evdev_dev *, epoch_t);
int evdev_unregister(struct evdev_dev *);
int evdev_push_event(struct evdev_dev *, uint16_t, uint16_t, int32_t);
void evdev_support_prop(struct evdev_dev *, uint16_t);
@@ -117,7 +119,7 @@
void evdev_support_key(struct evdev_dev *, uint16_t);
void evdev_support_rel(struct evdev_dev *, uint16_t);
void evdev_support_abs(struct evdev_dev *, uint16_t, int32_t, int32_t, int32_t,
- int32_t, int32_t, int32_t);
+ int32_t, int32_t);
void evdev_support_msc(struct evdev_dev *, uint16_t);
void evdev_support_led(struct evdev_dev *, uint16_t);
void evdev_support_snd(struct evdev_dev *, uint16_t);
diff --git a/sys/dev/evdev/evdev.c b/sys/dev/evdev/evdev.c
--- a/sys/dev/evdev/evdev.c
+++ b/sys/dev/evdev/evdev.c
@@ -31,12 +31,15 @@
#include <sys/param.h>
#include <sys/bitstring.h>
+#include <sys/ck.h>
#include <sys/conf.h>
+#include <sys/epoch.h>
#include <sys/kdb.h>
#include <sys/kernel.h>
#include <sys/malloc.h>
#include <sys/module.h>
#include <sys/proc.h>
+#include <sys/sx.h>
#include <sys/sysctl.h>
#include <sys/systm.h>
@@ -295,12 +298,14 @@
evdev->ev_shortname, evdev->ev_name, evdev->ev_serial);
/* Initialize internal structures */
- LIST_INIT(&evdev->ev_clients);
+ CK_SLIST_INIT(&evdev->ev_clients);
+ sx_init(&evdev->ev_list_lock, "evsx");
if (evdev_event_supported(evdev, EV_REP) &&
bit_test(evdev->ev_flags, EVDEV_FLAG_SOFTREPEAT)) {
/* Initialize callout */
- callout_init_mtx(&evdev->ev_rep_callout, evdev->ev_lock, 0);
+ callout_init_mtx(&evdev->ev_rep_callout,
+ evdev->ev_state_lock, 0);
if (evdev->ev_rep[REP_DELAY] == 0 &&
evdev->ev_rep[REP_PERIOD] == 0) {
@@ -332,6 +337,8 @@
evdev_sysctl_create(evdev);
bail_out:
+ if (ret != 0)
+ sx_destroy(&evdev->ev_list_lock);
return (ret);
}
@@ -341,8 +348,9 @@
int ret;
evdev->ev_lock_type = EV_LOCK_INTERNAL;
- evdev->ev_lock = &evdev->ev_mtx;
+ evdev->ev_state_lock = &evdev->ev_mtx;
mtx_init(&evdev->ev_mtx, "evmtx", NULL, MTX_DEF);
+ evdev->ev_epoch = global_epoch_preempt;
ret = evdev_register_common(evdev);
if (ret != 0)
@@ -356,10 +364,27 @@
{
evdev->ev_lock_type = EV_LOCK_MTX;
- evdev->ev_lock = mtx;
+ evdev->ev_state_lock = mtx;
return (evdev_register_common(evdev));
}
+int
+evdev_register_epoch(struct evdev_dev *evdev, epoch_t epoch)
+{
+ int ret;
+
+ evdev->ev_lock_type = EV_LOCK_EPOCH;
+ evdev->ev_state_lock = &evdev->ev_mtx;
+ mtx_init(&evdev->ev_mtx, "evmtx", NULL, MTX_DEF);
+ evdev->ev_epoch = epoch;
+
+ ret = evdev_register_common(evdev);
+ if (ret != 0)
+ mtx_destroy(&evdev->ev_mtx);
+
+ return (ret);
+}
+
int
evdev_unregister(struct evdev_dev *evdev)
{
@@ -370,22 +395,23 @@
sysctl_ctx_free(&evdev->ev_sysctl_ctx);
- EVDEV_LOCK(evdev);
+ EVDEV_LIST_LOCK(evdev);
evdev->ev_cdev->si_drv1 = NULL;
/* Wake up sleepers */
- LIST_FOREACH_SAFE(client, &evdev->ev_clients, ec_link, tmp) {
+ CK_SLIST_FOREACH_SAFE(client, &evdev->ev_clients, ec_link, tmp) {
evdev_revoke_client(client);
evdev_dispose_client(evdev, client);
EVDEV_CLIENT_LOCKQ(client);
evdev_notify_event(client);
EVDEV_CLIENT_UNLOCKQ(client);
}
- EVDEV_UNLOCK(evdev);
+ EVDEV_LIST_UNLOCK(evdev);
- /* destroy_dev can sleep so release lock */
+ /* release lock to avoid deadlock with evdev_dtor */
ret = evdev_cdev_destroy(evdev);
evdev->ev_cdev = NULL;
- if (ret == 0 && evdev->ev_lock_type == EV_LOCK_INTERNAL)
+ sx_destroy(&evdev->ev_list_lock);
+ if (ret == 0 && evdev->ev_lock_type != EV_LOCK_MTX)
mtx_destroy(&evdev->ev_mtx);
evdev_free_absinfo(evdev->ev_absinfo);
@@ -477,16 +503,15 @@
}
inline void
-evdev_support_abs(struct evdev_dev *evdev, uint16_t code, int32_t value,
- int32_t minimum, int32_t maximum, int32_t fuzz, int32_t flat,
- int32_t resolution)
+evdev_support_abs(struct evdev_dev *evdev, uint16_t code, int32_t minimum,
+ int32_t maximum, int32_t fuzz, int32_t flat, int32_t resolution)
{
struct input_absinfo absinfo;
KASSERT(code < ABS_CNT, ("invalid evdev abs property"));
absinfo = (struct input_absinfo) {
- .value = value,
+ .value = 0,
.minimum = minimum,
.maximum = maximum,
.fuzz = fuzz,
@@ -692,7 +717,7 @@
} else {
/* Start/stop callout for evdev repeats */
if (bit_test(evdev->ev_key_states, code) == !*value &&
- !LIST_EMPTY(&evdev->ev_clients)) {
+ !CK_SLIST_EMPTY(&evdev->ev_clients)) {
if (*value == KEY_EVENT_DOWN)
evdev_start_repeat(evdev, code);
else {
@@ -845,6 +870,7 @@
evdev_propagate_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
int32_t value)
{
+ struct epoch_tracker et;
struct evdev_client *client;
debugf(evdev, "%s pushed event %d/%d/%d",
@@ -853,7 +879,9 @@
EVDEV_LOCK_ASSERT(evdev);
/* Propagate event through all clients */
- LIST_FOREACH(client, &evdev->ev_clients, ec_link) {
+ if (evdev->ev_lock_type != EV_LOCK_MTX)
+ epoch_enter_preempt(evdev->ev_epoch, &et);
+ CK_SLIST_FOREACH(client, &evdev->ev_clients, ec_link) {
if (evdev->ev_grabber != NULL && evdev->ev_grabber != client)
continue;
@@ -863,6 +891,8 @@
evdev_notify_event(client);
EVDEV_CLIENT_UNLOCKQ(client);
}
+ if (evdev->ev_lock_type != EV_LOCK_MTX)
+ epoch_exit_preempt(evdev->ev_epoch, &et);
evdev->ev_event_count++;
}
@@ -990,10 +1020,10 @@
case EV_ABS:
case EV_SW:
push:
- if (evdev->ev_lock_type != EV_LOCK_INTERNAL)
+ if (evdev->ev_lock_type == EV_LOCK_MTX)
EVDEV_LOCK(evdev);
ret = evdev_push_event(evdev, type, code, value);
- if (evdev->ev_lock_type != EV_LOCK_INTERNAL)
+ if (evdev->ev_lock_type == EV_LOCK_MTX)
EVDEV_UNLOCK(evdev);
break;
@@ -1011,16 +1041,16 @@
debugf(evdev, "adding new client for device %s", evdev->ev_shortname);
- EVDEV_LOCK_ASSERT(evdev);
+ EVDEV_LIST_LOCK_ASSERT(evdev);
- if (LIST_EMPTY(&evdev->ev_clients) && evdev->ev_methods != NULL &&
+ if (CK_SLIST_EMPTY(&evdev->ev_clients) && evdev->ev_methods != NULL &&
evdev->ev_methods->ev_open != NULL) {
debugf(evdev, "calling ev_open() on device %s",
evdev->ev_shortname);
ret = evdev->ev_methods->ev_open(evdev);
}
if (ret == 0)
- LIST_INSERT_HEAD(&evdev->ev_clients, client, ec_link);
+ CK_SLIST_INSERT_HEAD(&evdev->ev_clients, client, ec_link);
return (ret);
}
@@ -1029,18 +1059,27 @@
{
debugf(evdev, "removing client for device %s", evdev->ev_shortname);
- EVDEV_LOCK_ASSERT(evdev);
+ EVDEV_LIST_LOCK_ASSERT(evdev);
- LIST_REMOVE(client, ec_link);
- if (LIST_EMPTY(&evdev->ev_clients)) {
+ CK_SLIST_REMOVE(&evdev->ev_clients, client, evdev_client, ec_link);
+ if (CK_SLIST_EMPTY(&evdev->ev_clients)) {
if (evdev->ev_methods != NULL &&
evdev->ev_methods->ev_close != NULL)
(void)evdev->ev_methods->ev_close(evdev);
if (evdev_event_supported(evdev, EV_REP) &&
- bit_test(evdev->ev_flags, EVDEV_FLAG_SOFTREPEAT))
+ bit_test(evdev->ev_flags, EVDEV_FLAG_SOFTREPEAT)) {
+ if (evdev->ev_lock_type != EV_LOCK_MTX)
+ EVDEV_LOCK(evdev);
evdev_stop_repeat(evdev);
+ if (evdev->ev_lock_type != EV_LOCK_MTX)
+ EVDEV_UNLOCK(evdev);
+ }
}
+ if (evdev->ev_lock_type != EV_LOCK_MTX)
+ EVDEV_LOCK(evdev);
evdev_release_client(evdev, client);
+ if (evdev->ev_lock_type != EV_LOCK_MTX)
+ EVDEV_UNLOCK(evdev);
}
int
diff --git a/sys/dev/evdev/evdev_mt.c b/sys/dev/evdev/evdev_mt.c
--- a/sys/dev/evdev/evdev_mt.c
+++ b/sys/dev/evdev/evdev_mt.c
@@ -185,7 +185,6 @@
for (i = 0; i < nitems(evdev_mtstmap); i++)
if (bit_test(evdev->ev_abs_flags, evdev_mtstmap[i][0]))
evdev_support_abs(evdev, evdev_mtstmap[i][1],
- evdev->ev_absinfo[evdev_mtstmap[i][0]].value,
evdev->ev_absinfo[evdev_mtstmap[i][0]].minimum,
evdev->ev_absinfo[evdev_mtstmap[i][0]].maximum,
evdev->ev_absinfo[evdev_mtstmap[i][0]].fuzz,
diff --git a/sys/dev/evdev/evdev_private.h b/sys/dev/evdev/evdev_private.h
--- a/sys/dev/evdev/evdev_private.h
+++ b/sys/dev/evdev/evdev_private.h
@@ -31,12 +31,15 @@
#define _DEV_EVDEV_EVDEV_PRIVATE_H
#include <sys/bitstring.h>
+#include <sys/ck.h>
+#include <sys/epoch.h>
#include <sys/kbio.h>
#include <sys/lock.h>
#include <sys/malloc.h>
#include <sys/mutex.h>
#include <sys/queue.h>
#include <sys/selinfo.h>
+#include <sys/sx.h>
#include <sys/sysctl.h>
#include <dev/evdev/evdev.h>
@@ -77,8 +80,9 @@
enum evdev_lock_type
{
- EV_LOCK_INTERNAL = 0, /* Internal evdev mutex */
+ EV_LOCK_INTERNAL = 0, /* Internal epoch */
EV_LOCK_MTX, /* Driver`s mutex */
+ EV_LOCK_EPOCH, /* External epoch */
};
struct evdev_dev
@@ -89,8 +93,10 @@
struct cdev * ev_cdev;
int ev_unit;
enum evdev_lock_type ev_lock_type;
- struct mtx * ev_lock;
- struct mtx ev_mtx;
+ struct mtx * ev_state_lock; /* Evdev state lock */
+ struct mtx ev_mtx; /* Evdev internal state lock */
+ epoch_t ev_epoch;
+ struct sx ev_list_lock; /* Evdev client list lock */
struct input_id ev_id;
struct evdev_client * ev_grabber;
size_t ev_report_size;
@@ -139,28 +145,56 @@
struct sysctl_ctx_list ev_sysctl_ctx;
LIST_ENTRY(evdev_dev) ev_link;
- LIST_HEAD(, evdev_client) ev_clients;
+ CK_SLIST_HEAD(, evdev_client) ev_clients;
};
#define SYSTEM_CONSOLE_LOCK &Giant
-#define EVDEV_LOCK(evdev) mtx_lock((evdev)->ev_lock)
-#define EVDEV_UNLOCK(evdev) mtx_unlock((evdev)->ev_lock)
+#define EVDEV_LOCK(evdev) mtx_lock((evdev)->ev_state_lock)
+#define EVDEV_UNLOCK(evdev) mtx_unlock((evdev)->ev_state_lock)
#define EVDEV_LOCK_ASSERT(evdev) do { \
- if ((evdev)->ev_lock != SYSTEM_CONSOLE_LOCK) \
- mtx_assert((evdev)->ev_lock, MA_OWNED); \
+ if ((evdev)->ev_state_lock != SYSTEM_CONSOLE_LOCK) \
+ mtx_assert((evdev)->ev_state_lock, MA_OWNED); \
} while (0)
#define EVDEV_ENTER(evdev) do { \
- if ((evdev)->ev_lock_type == EV_LOCK_INTERNAL) \
+ if ((evdev)->ev_lock_type != EV_LOCK_MTX) \
EVDEV_LOCK(evdev); \
else \
EVDEV_LOCK_ASSERT(evdev); \
} while (0)
#define EVDEV_EXIT(evdev) do { \
- if ((evdev)->ev_lock_type == EV_LOCK_INTERNAL) \
+ if ((evdev)->ev_lock_type != EV_LOCK_MTX) \
EVDEV_UNLOCK(evdev); \
} while (0)
+#define EVDEV_LIST_LOCK(evdev) do { \
+ if ((evdev)->ev_lock_type == EV_LOCK_MTX) \
+ EVDEV_LOCK(evdev); \
+ else \
+ sx_xlock(&(evdev)->ev_list_lock); \
+} while (0)
+#define EVDEV_LIST_UNLOCK(evdev) do { \
+ if ((evdev)->ev_lock_type == EV_LOCK_MTX) \
+ EVDEV_UNLOCK(evdev); \
+ else \
+ sx_unlock(&(evdev)->ev_list_lock); \
+} while (0)
+#define EVDEV_LIST_LOCK_ASSERT(evdev) do { \
+ if ((evdev)->ev_lock_type == EV_LOCK_MTX) \
+ EVDEV_LOCK_ASSERT(evdev); \
+ else \
+ sx_assert(&(evdev)->ev_list_lock, MA_OWNED); \
+} while (0)
+static inline int
+EVDEV_LIST_LOCK_SIG(struct evdev_dev *evdev)
+{
+ if (evdev->ev_lock_type == EV_LOCK_MTX) {
+ EVDEV_LOCK(evdev);
+ return (0);
+ }
+ return (sx_xlock_sig(&evdev->ev_list_lock));
+}
+
struct evdev_client
{
struct evdev_dev * ec_evdev;
@@ -177,7 +211,7 @@
bool ec_blocked;
bool ec_selected;
- LIST_ENTRY(evdev_client) ec_link;
+ CK_SLIST_ENTRY(evdev_client) ec_link;
struct input_event ec_buffer[];
};
diff --git a/sys/dev/evdev/uinput.c b/sys/dev/evdev/uinput.c
--- a/sys/dev/evdev/uinput.c
+++ b/sys/dev/evdev/uinput.c
@@ -525,10 +525,9 @@
if (uabs->code > ABS_MAX)
return (EINVAL);
- evdev_support_abs(state->ucs_evdev, uabs->code,
- uabs->absinfo.value, uabs->absinfo.minimum,
- uabs->absinfo.maximum, uabs->absinfo.fuzz,
- uabs->absinfo.flat, uabs->absinfo.resolution);
+ evdev_set_abs_bit(state->ucs_evdev, uabs->code);
+ evdev_set_absinfo(state->ucs_evdev, uabs->code,
+ &uabs->absinfo);
return (0);
case UI_SET_EVBIT:
diff --git a/sys/dev/hid/hconf.h b/sys/dev/hid/hconf.h
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hconf.h
@@ -0,0 +1,41 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2019 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.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef _HCONF_H_
+#define _HCONF_H_
+
+enum hconf_input_mode {
+ HCONF_INPUT_MODE_MOUSE = 0x0,
+ HCONF_INPUT_MODE_MT_TOUCHSCREEN = 0x2,
+ HCONF_INPUT_MODE_MT_TOUCHPAD = 0x3,
+};
+
+int hconf_set_input_mode(device_t, enum hconf_input_mode);
+
+#endif /* _HCONF_H_ */
diff --git a/sys/dev/hid/hconf.c b/sys/dev/hid/hconf.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hconf.c
@@ -0,0 +1,331 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2019 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 <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * Digitizer configuration top-level collection support.
+ * https://docs.microsoft.com/en-us/windows-hardware/design/component-guidelines/windows-precision-touchpad-required-hid-top-level-collections
+ */
+
+#include <sys/param.h>
+#include <sys/bus.h>
+#include <sys/kernel.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/module.h>
+#include <sys/sysctl.h>
+#include <sys/systm.h>
+#include <sys/sx.h>
+
+#define HID_DEBUG_VAR hconf_debug
+#include <dev/hid/hid.h>
+#include <dev/hid/hidbus.h>
+
+#include <dev/hid/hconf.h>
+
+#ifdef HID_DEBUG
+static int hconf_debug = 0;
+
+static SYSCTL_NODE(_hw_hid, OID_AUTO, hconf, CTLFLAG_RW, 0,
+ "Digitizer configuration top-level collection");
+SYSCTL_INT(_hw_hid_hconf, OID_AUTO, debug, CTLFLAG_RWTUN,
+ &hconf_debug, 1, "Debug level");
+#endif
+
+enum feature_control_type {
+ INPUT_MODE = 0,
+ SURFACE_SWITCH,
+ BUTTONS_SWITCH,
+ CONTROLS_COUNT
+};
+
+struct feature_control_descr {
+ const char *name;
+ const char *descr;
+ uint16_t usage;
+} feature_control_descrs[] = {
+ [INPUT_MODE] = {
+ .name = "input_mode",
+ .descr = "HID device input mode: 0 = mouse, 3 = touchpad",
+ .usage = HUD_INPUT_MODE
+ },
+ [SURFACE_SWITCH] = {
+ .name = "surface_switch",
+ .descr = "Enable / disable switch for surface: 1 = on, 0 = off",
+ .usage = HUD_SURFACE_SWITCH
+ },
+ [BUTTONS_SWITCH] = {
+ .name = "buttons_switch",
+ .descr = "Enable / disable switch for buttons: 1 = on, 0 = off",
+ .usage = HUD_BUTTONS_SWITCH
+ },
+};
+
+struct feature_control {
+ u_int val;
+ struct hid_location loc;
+ hid_size_t rlen;
+ uint8_t rid;
+};
+
+struct hconf_softc {
+ device_t dev;
+ struct sx lock;
+
+ struct feature_control feature_controls[CONTROLS_COUNT];
+};
+
+static device_probe_t hconf_probe;
+static device_attach_t hconf_attach;
+static device_detach_t hconf_detach;
+static device_resume_t hconf_resume;
+
+static devclass_t hconf_devclass;
+
+static device_method_t hconf_methods[] = {
+
+ DEVMETHOD(device_probe, hconf_probe),
+ DEVMETHOD(device_attach, hconf_attach),
+ DEVMETHOD(device_detach, hconf_detach),
+ DEVMETHOD(device_resume, hconf_resume),
+
+ DEVMETHOD_END
+};
+
+static driver_t hconf_driver = {
+ .name = "hconf",
+ .methods = hconf_methods,
+ .size = sizeof(struct hconf_softc),
+};
+
+static const struct hid_device_id hconf_devs[] = {
+ { HID_TLC(HUP_DIGITIZERS, HUD_CONFIG) },
+};
+
+static int
+hconf_set_feature_control(struct hconf_softc *sc, int ctrl_id, u_int val)
+{
+ struct feature_control *fc;
+ uint8_t *fbuf;
+ int error;
+ int i;
+
+ KASSERT(ctrl_id >= 0 && ctrl_id < CONTROLS_COUNT,
+ ("impossible ctrl id %d", ctrl_id));
+ fc = &sc->feature_controls[ctrl_id];
+ if (fc->rlen <= 1)
+ return (ENXIO);
+
+ fbuf = malloc(fc->rlen, M_TEMP, M_WAITOK | M_ZERO);
+ sx_xlock(&sc->lock);
+
+ /* Reports are not strictly required to be readable */
+ error = hid_get_report(sc->dev, fbuf, fc->rlen, NULL,
+ HID_FEATURE_REPORT, fc->rid);
+
+ /*
+ * If the report is write-only, then we have to check for other controls
+ * that may share the same report and set their bits as well.
+ */
+ if (error != 0) {
+ bzero(fbuf + 1, fc->rlen - 1);
+ for (i = 0; i < nitems(sc->feature_controls); i++) {
+ struct feature_control *ofc = &sc->feature_controls[i];
+
+ /* Skip unrelated report IDs. */
+ if (ofc->rid != fc->rid)
+ continue;
+ /* Skip self. */
+ if (ofc == fc)
+ continue;
+ KASSERT(fc->rlen == ofc->rlen,
+ ("different lengths for report %d: %d vs %d\n",
+ fc->rid, fc->rlen, ofc->rlen));
+ hid_put_data_unsigned(fbuf + 1, ofc->rlen - 1,
+ &ofc->loc, ofc->val);
+ }
+ }
+
+ fbuf[0] = fc->rid;
+ hid_put_data_unsigned(fbuf + 1, fc->rlen - 1, &fc->loc, val);
+
+ error = hid_set_report(sc->dev, fbuf, fc->rlen,
+ HID_FEATURE_REPORT, fc->rid);
+ if (error == 0)
+ fc->val = val;
+
+ sx_unlock(&sc->lock);
+ free(fbuf, M_TEMP);
+
+ return (error);
+}
+
+static int
+hconf_feature_control_handler(SYSCTL_HANDLER_ARGS)
+{
+ struct feature_control *fc;
+ struct hconf_softc *sc = arg1;
+ int ctrl_id = arg2;
+ u_int value;
+ int error;
+
+ if (ctrl_id < 0 || ctrl_id >= CONTROLS_COUNT)
+ return (ENXIO);
+
+ fc = &sc->feature_controls[ctrl_id];
+ value = fc->val;
+ error = sysctl_handle_int(oidp, &value, 0, req);
+ if (error != 0 || req->newptr == NULL)
+ return (error);
+
+ error = hconf_set_feature_control(sc, ctrl_id, value);
+ if (error != 0) {
+ DPRINTF("Failed to set %s: %d\n",
+ feature_control_descrs[ctrl_id].name, error);
+ }
+ return (0);
+}
+
+
+static int
+hconf_parse_feature(struct feature_control *fc, uint8_t tlc_index,
+ uint16_t usage, void *d_ptr, hid_size_t d_len)
+{
+ uint32_t flags;
+
+ if (!hidbus_locate(d_ptr, d_len, HID_USAGE2(HUP_DIGITIZERS, usage),
+ hid_feature, tlc_index, 0, &fc->loc, &flags, &fc->rid, NULL))
+ return (ENOENT);
+
+ if ((flags & (HIO_VARIABLE | HIO_RELATIVE)) != HIO_VARIABLE)
+ return (EINVAL);
+
+ fc->rlen = hid_report_size(d_ptr, d_len, hid_feature, fc->rid);
+ return (0);
+}
+
+static int
+hconf_probe(device_t dev)
+{
+ int error;
+
+ error = HIDBUS_LOOKUP_DRIVER_INFO(dev, hconf_devs);
+ if (error != 0)
+ return (error);
+
+ hidbus_set_desc(dev, "Configuration");
+
+ return (BUS_PROBE_DEFAULT);
+}
+
+static int
+hconf_attach(device_t dev)
+{
+ struct hconf_softc *sc = device_get_softc(dev);
+ struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
+ struct sysctl_oid *tree = device_get_sysctl_tree(dev);
+ void *d_ptr;
+ hid_size_t d_len;
+ uint8_t tlc_index;
+ int error;
+ int i;
+
+ error = hid_get_report_descr(dev, &d_ptr, &d_len);
+ if (error) {
+ device_printf(dev, "could not retrieve report descriptor from "
+ "device: %d\n", error);
+ return (ENXIO);
+ }
+
+ sc->dev = dev;
+ sx_init(&sc->lock, device_get_nameunit(dev));
+
+ tlc_index = hidbus_get_index(dev);
+ for (i = 0; i < nitems(sc->feature_controls); i++) {
+ (void)hconf_parse_feature(&sc->feature_controls[i], tlc_index,
+ feature_control_descrs[i].usage, d_ptr, d_len);
+ if (sc->feature_controls[i].rlen > 1) {
+ SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+ feature_control_descrs[i].name,
+ CTLTYPE_UINT | CTLFLAG_RW,
+ sc, i, hconf_feature_control_handler, "I",
+ feature_control_descrs[i].descr);
+ }
+ }
+
+ /* Fully enable (at least, try to). */
+ (void)hconf_set_feature_control(sc, SURFACE_SWITCH, 1);
+ (void)hconf_set_feature_control(sc, BUTTONS_SWITCH, 1);
+ return (0);
+}
+
+static int
+hconf_detach(device_t dev)
+{
+ struct hconf_softc *sc = device_get_softc(dev);
+
+ sx_destroy(&sc->lock);
+
+ return (0);
+}
+
+static int
+hconf_resume(device_t dev)
+{
+ struct hconf_softc *sc = device_get_softc(dev);
+ int error;
+ int i;
+
+ for (i = 0; i < nitems(sc->feature_controls); i++) {
+ if (sc->feature_controls[i].rlen < 2)
+ continue;
+ error = hconf_set_feature_control(sc, i,
+ sc->feature_controls[i].val);
+ if (error != 0) {
+ DPRINTF("Failed to restore %s: %d\n",
+ feature_control_descrs[i].name, error);
+ }
+ }
+
+ return (0);
+}
+
+int
+hconf_set_input_mode(device_t dev, enum hconf_input_mode mode)
+{
+ struct hconf_softc *sc = device_get_softc(dev);
+
+ return (hconf_set_feature_control(sc, INPUT_MODE, mode));
+}
+
+DRIVER_MODULE(hconf, hidbus, hconf_driver, hconf_devclass, NULL, 0);
+MODULE_DEPEND(hconf, hidbus, 1, 1, 1);
+MODULE_DEPEND(hconf, hid, 1, 1, 1);
+MODULE_VERSION(hconf, 1);
+HID_PNP_INFO(hconf_devs);
diff --git a/sys/dev/hid/hcons.c b/sys/dev/hid/hcons.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hcons.c
@@ -0,0 +1,295 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2020 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 <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * Consumer Controls usage page driver
+ * https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf
+ */
+
+#include <sys/param.h>
+#include <sys/bitstring.h>
+#include <sys/bus.h>
+#include <sys/kernel.h>
+#include <sys/module.h>
+#include <sys/sysctl.h>
+
+#include <dev/evdev/input.h>
+#include <dev/evdev/evdev.h>
+
+#include <dev/hid/hid.h>
+#include <dev/hid/hidbus.h>
+#include <dev/hid/hidmap.h>
+
+static hidmap_cb_t hcons_rel_volume_cb;
+
+#define HCONS_MAP_KEY(usage, code) \
+ { HIDMAP_KEY(HUP_CONSUMER, usage, code) }
+#define HCONS_MAP_ABS(usage, code) \
+ { HIDMAP_ABS(HUP_CONSUMER, usage, code) }
+#define HCONS_MAP_REL(usage, code) \
+ { HIDMAP_REL(HUP_CONSUMER, usage, code) }
+#define HCONS_MAP_REL_CB(usage, callback) \
+ { HIDMAP_REL_CB(HUP_CONSUMER, usage, &callback) }
+
+static const struct hidmap_item hcons_map[] = {
+ HCONS_MAP_KEY(0x030, KEY_POWER),
+ HCONS_MAP_KEY(0x031, KEY_RESTART),
+ HCONS_MAP_KEY(0x032, KEY_SLEEP),
+ HCONS_MAP_KEY(0x034, KEY_SLEEP),
+ HCONS_MAP_KEY(0x035, KEY_KBDILLUMTOGGLE),
+ HCONS_MAP_KEY(0x036, BTN_MISC),
+ HCONS_MAP_KEY(0x040, KEY_MENU), /* Menu */
+ HCONS_MAP_KEY(0x041, KEY_SELECT), /* Menu Pick */
+ HCONS_MAP_KEY(0x042, KEY_UP), /* Menu Up */
+ HCONS_MAP_KEY(0x043, KEY_DOWN), /* Menu Down */
+ HCONS_MAP_KEY(0x044, KEY_LEFT), /* Menu Left */
+ HCONS_MAP_KEY(0x045, KEY_RIGHT), /* Menu Right */
+ HCONS_MAP_KEY(0x046, KEY_ESC), /* Menu Escape */
+ HCONS_MAP_KEY(0x047, KEY_KPPLUS), /* Menu Value Increase */
+ HCONS_MAP_KEY(0x048, KEY_KPMINUS), /* Menu Value Decrease */
+ HCONS_MAP_KEY(0x060, KEY_INFO), /* Data On Screen */
+ HCONS_MAP_KEY(0x061, KEY_SUBTITLE), /* Closed Caption */
+ HCONS_MAP_KEY(0x063, KEY_VCR), /* VCR/TV */
+ HCONS_MAP_KEY(0x065, KEY_CAMERA), /* Snapshot */
+ HCONS_MAP_KEY(0x069, KEY_RED),
+ HCONS_MAP_KEY(0x06a, KEY_GREEN),
+ HCONS_MAP_KEY(0x06b, KEY_BLUE),
+ HCONS_MAP_KEY(0x06c, KEY_YELLOW),
+ HCONS_MAP_KEY(0x06d, KEY_ASPECT_RATIO),
+ HCONS_MAP_KEY(0x06f, KEY_BRIGHTNESSUP),
+ HCONS_MAP_KEY(0x070, KEY_BRIGHTNESSDOWN),
+ HCONS_MAP_KEY(0x072, KEY_BRIGHTNESS_TOGGLE),
+ HCONS_MAP_KEY(0x073, KEY_BRIGHTNESS_MIN),
+ HCONS_MAP_KEY(0x074, KEY_BRIGHTNESS_MAX),
+ HCONS_MAP_KEY(0x075, KEY_BRIGHTNESS_AUTO),
+ HCONS_MAP_KEY(0x079, KEY_KBDILLUMUP),
+ HCONS_MAP_KEY(0x07a, KEY_KBDILLUMDOWN),
+ HCONS_MAP_KEY(0x07c, KEY_KBDILLUMTOGGLE),
+ HCONS_MAP_KEY(0x082, KEY_VIDEO_NEXT),
+ HCONS_MAP_KEY(0x083, KEY_LAST),
+ HCONS_MAP_KEY(0x084, KEY_ENTER),
+ HCONS_MAP_KEY(0x088, KEY_PC),
+ HCONS_MAP_KEY(0x089, KEY_TV),
+ HCONS_MAP_KEY(0x08a, KEY_WWW),
+ HCONS_MAP_KEY(0x08b, KEY_DVD),
+ HCONS_MAP_KEY(0x08c, KEY_PHONE),
+ HCONS_MAP_KEY(0x08d, KEY_PROGRAM),
+ HCONS_MAP_KEY(0x08e, KEY_VIDEOPHONE),
+ HCONS_MAP_KEY(0x08f, KEY_GAMES),
+ HCONS_MAP_KEY(0x090, KEY_MEMO),
+ HCONS_MAP_KEY(0x091, KEY_CD),
+ HCONS_MAP_KEY(0x092, KEY_VCR),
+ HCONS_MAP_KEY(0x093, KEY_TUNER),
+ HCONS_MAP_KEY(0x094, KEY_EXIT),
+ HCONS_MAP_KEY(0x095, KEY_HELP),
+ HCONS_MAP_KEY(0x096, KEY_TAPE),
+ HCONS_MAP_KEY(0x097, KEY_TV2),
+ HCONS_MAP_KEY(0x098, KEY_SAT),
+ HCONS_MAP_KEY(0x09a, KEY_PVR),
+ HCONS_MAP_KEY(0x09c, KEY_CHANNELUP),
+ HCONS_MAP_KEY(0x09d, KEY_CHANNELDOWN),
+ HCONS_MAP_KEY(0x0a0, KEY_VCR2),
+ HCONS_MAP_KEY(0x0b0, KEY_PLAY),
+ HCONS_MAP_KEY(0x0b1, KEY_PAUSE),
+ HCONS_MAP_KEY(0x0b2, KEY_RECORD),
+ HCONS_MAP_KEY(0x0b3, KEY_FASTFORWARD),
+ HCONS_MAP_KEY(0x0b4, KEY_REWIND),
+ HCONS_MAP_KEY(0x0b5, KEY_NEXTSONG),
+ HCONS_MAP_KEY(0x0b6, KEY_PREVIOUSSONG),
+ HCONS_MAP_KEY(0x0b7, KEY_STOPCD),
+ HCONS_MAP_KEY(0x0b8, KEY_EJECTCD),
+ HCONS_MAP_KEY(0x0bc, KEY_MEDIA_REPEAT),
+ HCONS_MAP_KEY(0x0b9, KEY_SHUFFLE),
+ HCONS_MAP_KEY(0x0bf, KEY_SLOW),
+ HCONS_MAP_KEY(0x0cd, KEY_PLAYPAUSE),
+ HCONS_MAP_KEY(0x0cf, KEY_VOICECOMMAND),
+ HCONS_MAP_ABS(0x0e0, ABS_VOLUME),
+ HCONS_MAP_REL_CB(0x0e0, hcons_rel_volume_cb),
+ HCONS_MAP_KEY(0x0e2, KEY_MUTE),
+ HCONS_MAP_KEY(0x0e5, KEY_BASSBOOST),
+ HCONS_MAP_KEY(0x0e9, KEY_VOLUMEUP),
+ HCONS_MAP_KEY(0x0ea, KEY_VOLUMEDOWN),
+ HCONS_MAP_KEY(0x0f5, KEY_SLOW),
+ HCONS_MAP_KEY(0x181, KEY_BUTTONCONFIG),
+ HCONS_MAP_KEY(0x182, KEY_BOOKMARKS),
+ HCONS_MAP_KEY(0x183, KEY_CONFIG),
+ HCONS_MAP_KEY(0x184, KEY_WORDPROCESSOR),
+ HCONS_MAP_KEY(0x185, KEY_EDITOR),
+ HCONS_MAP_KEY(0x186, KEY_SPREADSHEET),
+ HCONS_MAP_KEY(0x187, KEY_GRAPHICSEDITOR),
+ HCONS_MAP_KEY(0x188, KEY_PRESENTATION),
+ HCONS_MAP_KEY(0x189, KEY_DATABASE),
+ HCONS_MAP_KEY(0x18a, KEY_MAIL),
+ HCONS_MAP_KEY(0x18b, KEY_NEWS),
+ HCONS_MAP_KEY(0x18c, KEY_VOICEMAIL),
+ HCONS_MAP_KEY(0x18d, KEY_ADDRESSBOOK),
+ HCONS_MAP_KEY(0x18e, KEY_CALENDAR),
+ HCONS_MAP_KEY(0x18f, KEY_TASKMANAGER),
+ HCONS_MAP_KEY(0x190, KEY_JOURNAL),
+ HCONS_MAP_KEY(0x191, KEY_FINANCE),
+ HCONS_MAP_KEY(0x192, KEY_CALC),
+ HCONS_MAP_KEY(0x193, KEY_PLAYER),
+ HCONS_MAP_KEY(0x194, KEY_FILE),
+ HCONS_MAP_KEY(0x196, KEY_WWW),
+ HCONS_MAP_KEY(0x199, KEY_CHAT),
+ HCONS_MAP_KEY(0x19c, KEY_LOGOFF),
+ HCONS_MAP_KEY(0x19e, KEY_COFFEE),
+ HCONS_MAP_KEY(0x19f, KEY_CONTROLPANEL),
+ HCONS_MAP_KEY(0x1a2, KEY_APPSELECT),
+ HCONS_MAP_KEY(0x1a3, KEY_NEXT),
+ HCONS_MAP_KEY(0x1a4, KEY_PREVIOUS),
+ HCONS_MAP_KEY(0x1a6, KEY_HELP),
+ HCONS_MAP_KEY(0x1a7, KEY_DOCUMENTS),
+ HCONS_MAP_KEY(0x1ab, KEY_SPELLCHECK),
+ HCONS_MAP_KEY(0x1ae, KEY_KEYBOARD),
+ HCONS_MAP_KEY(0x1b1, KEY_SCREENSAVER),
+ HCONS_MAP_KEY(0x1b4, KEY_FILE),
+ HCONS_MAP_KEY(0x1b6, KEY_IMAGES),
+ HCONS_MAP_KEY(0x1b7, KEY_AUDIO),
+ HCONS_MAP_KEY(0x1b8, KEY_VIDEO),
+ HCONS_MAP_KEY(0x1bc, KEY_MESSENGER),
+ HCONS_MAP_KEY(0x1bd, KEY_INFO),
+ HCONS_MAP_KEY(0x1cb, KEY_ASSISTANT),
+ HCONS_MAP_KEY(0x201, KEY_NEW),
+ HCONS_MAP_KEY(0x202, KEY_OPEN),
+ HCONS_MAP_KEY(0x203, KEY_CLOSE),
+ HCONS_MAP_KEY(0x204, KEY_EXIT),
+ HCONS_MAP_KEY(0x207, KEY_SAVE),
+ HCONS_MAP_KEY(0x208, KEY_PRINT),
+ HCONS_MAP_KEY(0x209, KEY_PROPS),
+ HCONS_MAP_KEY(0x21a, KEY_UNDO),
+ HCONS_MAP_KEY(0x21b, KEY_COPY),
+ HCONS_MAP_KEY(0x21c, KEY_CUT),
+ HCONS_MAP_KEY(0x21d, KEY_PASTE),
+ HCONS_MAP_KEY(0x21f, KEY_FIND),
+ HCONS_MAP_KEY(0x221, KEY_SEARCH),
+ HCONS_MAP_KEY(0x222, KEY_GOTO),
+ HCONS_MAP_KEY(0x223, KEY_HOMEPAGE),
+ HCONS_MAP_KEY(0x224, KEY_BACK),
+ HCONS_MAP_KEY(0x225, KEY_FORWARD),
+ HCONS_MAP_KEY(0x226, KEY_STOP),
+ HCONS_MAP_KEY(0x227, KEY_REFRESH),
+ HCONS_MAP_KEY(0x22a, KEY_BOOKMARKS),
+ HCONS_MAP_KEY(0x22d, KEY_ZOOMIN),
+ HCONS_MAP_KEY(0x22e, KEY_ZOOMOUT),
+ HCONS_MAP_KEY(0x22f, KEY_ZOOMRESET),
+ HCONS_MAP_KEY(0x232, KEY_FULL_SCREEN),
+ HCONS_MAP_KEY(0x233, KEY_SCROLLUP),
+ HCONS_MAP_KEY(0x234, KEY_SCROLLDOWN),
+ HCONS_MAP_REL(0x238, REL_HWHEEL), /* AC Pan */
+ HCONS_MAP_KEY(0x23d, KEY_EDIT),
+ HCONS_MAP_KEY(0x25f, KEY_CANCEL),
+ HCONS_MAP_KEY(0x269, KEY_INSERT),
+ HCONS_MAP_KEY(0x26a, KEY_DELETE),
+ HCONS_MAP_KEY(0x279, KEY_REDO),
+ HCONS_MAP_KEY(0x289, KEY_REPLY),
+ HCONS_MAP_KEY(0x28b, KEY_FORWARDMAIL),
+ HCONS_MAP_KEY(0x28c, KEY_SEND),
+ HCONS_MAP_KEY(0x29d, KEY_KBD_LAYOUT_NEXT),
+ HCONS_MAP_KEY(0x2c7, KEY_KBDINPUTASSIST_PREV),
+ HCONS_MAP_KEY(0x2c8, KEY_KBDINPUTASSIST_NEXT),
+ HCONS_MAP_KEY(0x2c9, KEY_KBDINPUTASSIST_PREVGROUP),
+ HCONS_MAP_KEY(0x2ca, KEY_KBDINPUTASSIST_NEXTGROUP),
+ HCONS_MAP_KEY(0x2cb, KEY_KBDINPUTASSIST_ACCEPT),
+ HCONS_MAP_KEY(0x2cc, KEY_KBDINPUTASSIST_CANCEL),
+ HCONS_MAP_KEY(0x29f, KEY_SCALE),
+};
+
+static const struct hid_device_id hcons_devs[] = {
+ { HID_TLC(HUP_CONSUMER, HUC_CONSUMER_CONTROL) },
+};
+
+/*
+ * Emulate relative Consumer volume usage with pressing
+ * VOLUMEUP and VOLUMEDOWN keys appropriate number of times
+ */
+static int
+hcons_rel_volume_cb(HIDMAP_CB_ARGS)
+{
+ struct evdev_dev *evdev = HIDMAP_CB_GET_EVDEV();
+ int32_t code;
+ int nrepeats;
+
+ switch (HIDMAP_CB_GET_STATE()) {
+ case HIDMAP_CB_IS_ATTACHING:
+ evdev_support_event(evdev, EV_KEY);
+ evdev_support_key(evdev, KEY_VOLUMEUP);
+ evdev_support_key(evdev, KEY_VOLUMEDOWN);
+ break;
+ case HIDMAP_CB_IS_RUNNING:
+ /* Nothing to report. */
+ if (ctx.data == 0)
+ return (ENOMSG);
+ code = ctx.data > 0 ? KEY_VOLUMEUP : KEY_VOLUMEDOWN;
+ for (nrepeats = abs(ctx.data); nrepeats > 0; nrepeats--) {
+ evdev_push_key(evdev, code, 1);
+ evdev_push_key(evdev, code, 0);
+ }
+ }
+
+ return (0);
+}
+
+static int
+hcons_probe(device_t dev)
+{
+ return (HIDMAP_PROBE(device_get_softc(dev), dev,
+ hcons_devs, hcons_map, "Consumer Control"));
+}
+
+static int
+hcons_attach(device_t dev)
+{
+ return (hidmap_attach(device_get_softc(dev)));
+}
+
+static int
+hcons_detach(device_t dev)
+{
+ return (hidmap_detach(device_get_softc(dev)));
+}
+
+static devclass_t hcons_devclass;
+static device_method_t hcons_methods[] = {
+ DEVMETHOD(device_probe, hcons_probe),
+ DEVMETHOD(device_attach, hcons_attach),
+ DEVMETHOD(device_detach, hcons_detach),
+
+ DEVMETHOD_END
+};
+
+DEFINE_CLASS_0(hcons, hcons_driver, hcons_methods, sizeof(struct hidmap));
+DRIVER_MODULE(hcons, hidbus, hcons_driver, hcons_devclass, NULL, 0);
+MODULE_DEPEND(hcons, hid, 1, 1, 1);
+MODULE_DEPEND(hcons, hidbus, 1, 1, 1);
+MODULE_DEPEND(hcons, hidmap, 1, 1, 1);
+MODULE_DEPEND(hcons, evdev, 1, 1, 1);
+MODULE_VERSION(hcons, 1);
+HID_PNP_INFO(hcons_devs);
diff --git a/sys/dev/hid/hgame.h b/sys/dev/hid/hgame.h
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hgame.h
@@ -0,0 +1,45 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2020 Vladimir Kondratyev <wulf@FreeBSD.org>
+ * Copyright (c) 2020 Greg V <greg@unrelenting.technology>
+ *
+ * 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.
+ */
+
+#ifndef _HID_HGAME_H_
+#define _HID_HGAME_H_
+
+#include <dev/hid/hidmap.h>
+
+hidmap_cb_t hgame_dpad_cb;
+hidmap_cb_t hgame_final_cb;
+
+struct hgame_softc {
+ struct hidmap hm;
+ bool dpad_up;
+ bool dpad_down;
+ bool dpad_right;
+ bool dpad_left;
+};
+
+#endif /* !_HGAME_H_ */
diff --git a/sys/dev/hid/hgame.c b/sys/dev/hid/hgame.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hgame.c
@@ -0,0 +1,200 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2020 Vladimir Kondratyev <wulf@FreeBSD.org>
+ * Copyright (c) 2020 Greg V <greg@unrelenting.technology>
+ *
+ * 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 <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * Generic HID game controller (joystick/gamepad) driver,
+ */
+
+#include <sys/param.h>
+#include <sys/bus.h>
+#include <sys/kernel.h>
+#include <sys/module.h>
+#include <sys/sysctl.h>
+
+#include <dev/evdev/input.h>
+#include <dev/evdev/evdev.h>
+
+#include <dev/hid/hgame.h>
+#include <dev/hid/hid.h>
+#include <dev/hid/hidbus.h>
+#include <dev/hid/hidquirk.h>
+#include <dev/hid/hidmap.h>
+
+#define HGAME_MAP_BRG(number_from, number_to, code) \
+ { HIDMAP_KEY_RANGE(HUP_BUTTON, number_from, number_to, code) }
+#define HGAME_MAP_ABS(usage, code) \
+ { HIDMAP_ABS(HUP_GENERIC_DESKTOP, HUG_##usage, code) }
+#define HGAME_MAP_CRG(usage_from, usage_to, callback) \
+ { HIDMAP_ANY_CB_RANGE(HUP_GENERIC_DESKTOP, \
+ HUG_##usage_from, HUG_##usage_to, callback) }
+#define HGAME_FINALCB(cb) \
+ { HIDMAP_FINAL_CB(&cb) }
+
+static const struct hidmap_item hgame_map[] = {
+ HGAME_MAP_BRG(1, 16, BTN_TRIGGER),
+ HGAME_MAP_ABS(X, ABS_X),
+ HGAME_MAP_ABS(Y, ABS_Y),
+ HGAME_MAP_ABS(Z, ABS_Z),
+ HGAME_MAP_ABS(RX, ABS_RX),
+ HGAME_MAP_ABS(RY, ABS_RY),
+ HGAME_MAP_ABS(RZ, ABS_RZ),
+ HGAME_MAP_ABS(HAT_SWITCH, ABS_HAT0X),
+ HGAME_MAP_CRG(D_PAD_UP, D_PAD_LEFT, hgame_dpad_cb),
+ HGAME_MAP_BRG(17, 57, BTN_TRIGGER_HAPPY),
+ HGAME_FINALCB( hgame_final_cb),
+};
+
+static const struct hid_device_id hgame_devs[] = {
+ { HID_TLC(HUP_GENERIC_DESKTOP, HUG_JOYSTICK),
+ HID_DRIVER_INFO(HUG_JOYSTICK) },
+ { HID_TLC(HUP_GENERIC_DESKTOP, HUG_GAME_PAD),
+ HID_DRIVER_INFO(HUG_GAME_PAD) },
+};
+
+/*
+ * Emulate the hat switch report via the D-pad usages
+ * found on XInput/XBox style devices
+ */
+int
+hgame_dpad_cb(HIDMAP_CB_ARGS)
+{
+ struct hgame_softc *sc = HIDMAP_CB_GET_SOFTC();
+ struct evdev_dev *evdev = HIDMAP_CB_GET_EVDEV();
+ int32_t data;
+
+ switch (HIDMAP_CB_GET_STATE()) {
+ case HIDMAP_CB_IS_ATTACHING:
+ HIDMAP_CB_UDATA64 = HID_GET_USAGE(ctx.hi->usage);
+ evdev_support_event(evdev, EV_ABS);
+ evdev_support_abs(evdev, ABS_HAT0X, -1, 1, 0, 0, 0);
+ evdev_support_abs(evdev, ABS_HAT0Y, -1, 1, 0, 0, 0);
+ break;
+
+ case HIDMAP_CB_IS_RUNNING:
+ data = ctx.data;
+ switch (HIDMAP_CB_UDATA64) {
+ case HUG_D_PAD_UP:
+ if (sc->dpad_down)
+ return (ENOMSG);
+ evdev_push_abs(evdev, ABS_HAT0Y, (data == 0) ? 0 : -1);
+ sc->dpad_up = (data != 0);
+ break;
+ case HUG_D_PAD_DOWN:
+ if (sc->dpad_up)
+ return (ENOMSG);
+ evdev_push_abs(evdev, ABS_HAT0Y, (data == 0) ? 0 : 1);
+ sc->dpad_down = (data != 0);
+ break;
+ case HUG_D_PAD_RIGHT:
+ if (sc->dpad_left)
+ return (ENOMSG);
+ evdev_push_abs(evdev, ABS_HAT0X, (data == 0) ? 0 : 1);
+ sc->dpad_right = (data != 0);
+ break;
+ case HUG_D_PAD_LEFT:
+ if (sc->dpad_right)
+ return (ENOMSG);
+ evdev_push_abs(evdev, ABS_HAT0X, (data == 0) ? 0 : -1);
+ sc->dpad_left = (data != 0);
+ break;
+ }
+ }
+
+ return (0);
+}
+
+int
+hgame_final_cb(HIDMAP_CB_ARGS)
+{
+ struct evdev_dev *evdev = HIDMAP_CB_GET_EVDEV();
+
+ if (HIDMAP_CB_GET_STATE() == HIDMAP_CB_IS_ATTACHING)
+ evdev_support_prop(evdev, INPUT_PROP_DIRECT);
+
+ /* Do not execute callback at interrupt handler and detach */
+ return (ENOSYS);
+}
+
+static int
+hgame_probe(device_t dev)
+{
+ const struct hid_device_info *hw = hid_get_device_info(dev);
+ struct hgame_softc *sc = device_get_softc(dev);
+ int error;
+
+ if (hid_test_quirk(hw, HQ_IS_XBOX360GP))
+ return(ENXIO);
+
+ error = HIDMAP_PROBE(&sc->hm, dev, hgame_devs, hgame_map, NULL);
+ if (error > 0)
+ return (error);
+
+ hidbus_set_desc(dev, hidbus_get_driver_info(dev) == HUG_GAME_PAD ?
+ "Gamepad" : "Joystick");
+
+ return (BUS_PROBE_GENERIC);
+}
+
+
+
+static int
+hgame_attach(device_t dev)
+{
+ struct hgame_softc *sc = device_get_softc(dev);
+
+ return (hidmap_attach(&sc->hm));
+}
+
+static int
+hgame_detach(device_t dev)
+{
+ struct hgame_softc *sc = device_get_softc(dev);
+
+ return (hidmap_detach(&sc->hm));
+}
+
+static devclass_t hgame_devclass;
+static device_method_t hgame_methods[] = {
+ DEVMETHOD(device_probe, hgame_probe),
+ DEVMETHOD(device_attach, hgame_attach),
+ DEVMETHOD(device_detach, hgame_detach),
+
+ DEVMETHOD_END
+};
+
+DEFINE_CLASS_0(hgame, hgame_driver, hgame_methods, sizeof(struct hgame_softc));
+DRIVER_MODULE(hgame, hidbus, hgame_driver, hgame_devclass, NULL, 0);
+MODULE_DEPEND(hgame, hid, 1, 1, 1);
+MODULE_DEPEND(hgame, hidbus, 1, 1, 1);
+MODULE_DEPEND(hgame, hidmap, 1, 1, 1);
+MODULE_DEPEND(hgame, evdev, 1, 1, 1);
+MODULE_VERSION(hgame, 1);
+HID_PNP_INFO(hgame_devs);
diff --git a/sys/dev/hid/hid.h b/sys/dev/hid/hid.h
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hid.h
@@ -0,0 +1,347 @@
+/* $FreeBSD$ */
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-NetBSD
+ *
+ * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
+ * Copyright (c) 1998 The NetBSD Foundation, Inc. All rights reserved.
+ * Copyright (c) 1998 Lennart Augustsson. All rights reserved.
+ *
+ * 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.
+ */
+
+#ifndef _HID_HID_H_
+#define _HID_HID_H_
+
+/* Usage pages */
+#define HUP_UNDEFINED 0x0000
+#define HUP_GENERIC_DESKTOP 0x0001
+#define HUP_SIMULATION 0x0002
+#define HUP_VR_CONTROLS 0x0003
+#define HUP_SPORTS_CONTROLS 0x0004
+#define HUP_GAMING_CONTROLS 0x0005
+#define HUP_KEYBOARD 0x0007
+#define HUP_LEDS 0x0008
+#define HUP_BUTTON 0x0009
+#define HUP_ORDINALS 0x000a
+#define HUP_TELEPHONY 0x000b
+#define HUP_CONSUMER 0x000c
+#define HUP_DIGITIZERS 0x000d
+#define HUP_PHYSICAL_IFACE 0x000e
+#define HUP_UNICODE 0x0010
+#define HUP_ALPHANUM_DISPLAY 0x0014
+#define HUP_MONITOR 0x0080
+#define HUP_MONITOR_ENUM_VAL 0x0081
+#define HUP_VESA_VC 0x0082
+#define HUP_VESA_CMD 0x0083
+#define HUP_POWER 0x0084
+#define HUP_BATTERY_SYSTEM 0x0085
+#define HUP_BARCODE_SCANNER 0x008b
+#define HUP_SCALE 0x008c
+#define HUP_CAMERA_CONTROL 0x0090
+#define HUP_ARCADE 0x0091
+#define HUP_MICROSOFT 0xff00
+
+/* Usages, generic desktop */
+#define HUG_POINTER 0x0001
+#define HUG_MOUSE 0x0002
+#define HUG_JOYSTICK 0x0004
+#define HUG_GAME_PAD 0x0005
+#define HUG_KEYBOARD 0x0006
+#define HUG_KEYPAD 0x0007
+#define HUG_MULTIAXIS_CNTROLLER 0x0008
+#define HUG_X 0x0030
+#define HUG_Y 0x0031
+#define HUG_Z 0x0032
+#define HUG_RX 0x0033
+#define HUG_RY 0x0034
+#define HUG_RZ 0x0035
+#define HUG_SLIDER 0x0036
+#define HUG_DIAL 0x0037
+#define HUG_WHEEL 0x0038
+#define HUG_HAT_SWITCH 0x0039
+#define HUG_COUNTED_BUFFER 0x003a
+#define HUG_BYTE_COUNT 0x003b
+#define HUG_MOTION_WAKEUP 0x003c
+#define HUG_VX 0x0040
+#define HUG_VY 0x0041
+#define HUG_VZ 0x0042
+#define HUG_VBRX 0x0043
+#define HUG_VBRY 0x0044
+#define HUG_VBRZ 0x0045
+#define HUG_VNO 0x0046
+#define HUG_TWHEEL 0x0048 /* M$ Wireless Intellimouse Wheel */
+#define HUG_SYSTEM_CONTROL 0x0080
+#define HUG_SYSTEM_POWER_DOWN 0x0081
+#define HUG_SYSTEM_SLEEP 0x0082
+#define HUG_SYSTEM_WAKEUP 0x0083
+#define HUG_SYSTEM_CONTEXT_MENU 0x0084
+#define HUG_SYSTEM_MAIN_MENU 0x0085
+#define HUG_SYSTEM_APP_MENU 0x0086
+#define HUG_SYSTEM_MENU_HELP 0x0087
+#define HUG_SYSTEM_MENU_EXIT 0x0088
+#define HUG_SYSTEM_MENU_SELECT 0x0089
+#define HUG_SYSTEM_MENU_RIGHT 0x008a
+#define HUG_SYSTEM_MENU_LEFT 0x008b
+#define HUG_SYSTEM_MENU_UP 0x008c
+#define HUG_SYSTEM_MENU_DOWN 0x008d
+#define HUG_SYSTEM_POWER_UP 0x008e
+#define HUG_SYSTEM_RESTART 0x008f
+#define HUG_D_PAD_UP 0x0090
+#define HUG_D_PAD_DOWN 0x0091
+#define HUG_D_PAD_RIGHT 0x0092
+#define HUG_D_PAD_LEFT 0x0093
+#define HUG_APPLE_EJECT 0x00b8
+
+/* Usages Digitizers */
+#define HUD_UNDEFINED 0x0000
+#define HUD_DIGITIZER 0x0001
+#define HUD_PEN 0x0002
+#define HUD_TOUCHSCREEN 0x0004
+#define HUD_TOUCHPAD 0x0005
+#define HUD_CONFIG 0x000e
+#define HUD_FINGER 0x0022
+#define HUD_TIP_PRESSURE 0x0030
+#define HUD_BARREL_PRESSURE 0x0031
+#define HUD_IN_RANGE 0x0032
+#define HUD_TOUCH 0x0033
+#define HUD_UNTOUCH 0x0034
+#define HUD_TAP 0x0035
+#define HUD_QUALITY 0x0036
+#define HUD_DATA_VALID 0x0037
+#define HUD_TRANSDUCER_INDEX 0x0038
+#define HUD_TABLET_FKEYS 0x0039
+#define HUD_PROGRAM_CHANGE_KEYS 0x003a
+#define HUD_BATTERY_STRENGTH 0x003b
+#define HUD_INVERT 0x003c
+#define HUD_X_TILT 0x003d
+#define HUD_Y_TILT 0x003e
+#define HUD_AZIMUTH 0x003f
+#define HUD_ALTITUDE 0x0040
+#define HUD_TWIST 0x0041
+#define HUD_TIP_SWITCH 0x0042
+#define HUD_SEC_TIP_SWITCH 0x0043
+#define HUD_BARREL_SWITCH 0x0044
+#define HUD_ERASER 0x0045
+#define HUD_TABLET_PICK 0x0046
+#define HUD_CONFIDENCE 0x0047
+#define HUD_WIDTH 0x0048
+#define HUD_HEIGHT 0x0049
+#define HUD_CONTACTID 0x0051
+#define HUD_INPUT_MODE 0x0052
+#define HUD_DEVICE_INDEX 0x0053
+#define HUD_CONTACTCOUNT 0x0054
+#define HUD_CONTACT_MAX 0x0055
+#define HUD_SCAN_TIME 0x0056
+#define HUD_SURFACE_SWITCH 0x0057
+#define HUD_BUTTONS_SWITCH 0x0058
+#define HUD_BUTTON_TYPE 0x0059
+#define HUD_SEC_BARREL_SWITCH 0x005a
+#define HUD_LATENCY_MODE 0x0060
+
+/* Usages, Consumer */
+#define HUC_CONSUMER_CONTROL 0x0001
+#define HUC_HEADPHONE 0x0005
+#define HUC_AC_PAN 0x0238
+
+#define HID_USAGE2(p,u) (((p) << 16) | (u))
+#define HID_GET_USAGE(u) ((u) & 0xffff)
+#define HID_GET_USAGE_PAGE(u) (((u) >> 16) & 0xffff)
+
+#define HID_INPUT_REPORT 0x01
+#define HID_OUTPUT_REPORT 0x02
+#define HID_FEATURE_REPORT 0x03
+
+/* Bits in the input/output/feature items */
+#define HIO_CONST 0x001
+#define HIO_VARIABLE 0x002
+#define HIO_RELATIVE 0x004
+#define HIO_WRAP 0x008
+#define HIO_NONLINEAR 0x010
+#define HIO_NOPREF 0x020
+#define HIO_NULLSTATE 0x040
+#define HIO_VOLATILE 0x080
+#define HIO_BUFBYTES 0x100
+
+/* Units of Measure */
+#define HUM_CENTIMETER 0x11
+#define HUM_RADIAN 0x12
+#define HUM_INCH 0x13
+#define HUM_DEGREE 0x14
+
+#if defined(_KERNEL) || defined(_STANDALONE)
+
+#define HID_ITEM_MAXUSAGE 4
+#define HID_MAX_AUTO_QUIRK 8 /* maximum number of dynamic quirks */
+#define HID_PNP_ID_SIZE 20 /* includes null terminator */
+
+/* Share unit number pool between uhid and hidraw */
+extern devclass_t hidraw_devclass;
+
+/* Declare global HID debug variable. */
+extern int hid_debug;
+
+/* Check if HID debugging is enabled. */
+#ifdef HID_DEBUG_VAR
+#ifdef HID_DEBUG
+#define DPRINTFN(n,fmt,...) do { \
+ if ((HID_DEBUG_VAR) >= (n)) { \
+ printf("%s: " fmt, \
+ __FUNCTION__ ,##__VA_ARGS__); \
+ } \
+} while (0)
+#define DPRINTF(...) DPRINTFN(1, __VA_ARGS__)
+#else
+#define DPRINTF(...) do { } while (0)
+#define DPRINTFN(...) do { } while (0)
+#endif
+#endif
+
+/* Declare parent SYSCTL HID node. */
+#ifdef SYSCTL_DECL
+SYSCTL_DECL(_hw_hid);
+#endif
+
+typedef uint32_t hid_size_t;
+
+#define HID_IN_POLLING_MODE() (SCHEDULER_STOPPED() || kdb_active)
+
+enum hid_kind {
+ hid_input, hid_output, hid_feature, hid_collection, hid_endcollection
+};
+
+struct hid_location {
+ uint32_t size;
+ uint32_t count;
+ uint32_t pos;
+};
+
+struct hid_item {
+ /* Global */
+ int32_t _usage_page;
+ int32_t logical_minimum;
+ int32_t logical_maximum;
+ int32_t physical_minimum;
+ int32_t physical_maximum;
+ int32_t unit_exponent;
+ int32_t unit;
+ int32_t report_ID;
+ /* Local */
+ int nusages;
+ union {
+ int32_t usage;
+ int32_t usages[HID_ITEM_MAXUSAGE];
+ };
+ int32_t usage_minimum;
+ int32_t usage_maximum;
+ int32_t designator_index;
+ int32_t designator_minimum;
+ int32_t designator_maximum;
+ int32_t string_index;
+ int32_t string_minimum;
+ int32_t string_maximum;
+ int32_t set_delimiter;
+ /* Misc */
+ int32_t collection;
+ int collevel;
+ enum hid_kind kind;
+ uint32_t flags;
+ /* Location */
+ struct hid_location loc;
+};
+
+struct hid_absinfo {
+ int32_t min;
+ int32_t max;
+ int32_t res;
+};
+
+struct hid_device_info {
+ char name[80];
+ char serial[80];
+ char idPnP[HID_PNP_ID_SIZE];
+ uint16_t idBus;
+ uint16_t idVendor;
+ uint16_t idProduct;
+ uint16_t idVersion;
+ hid_size_t rdescsize; /* Report descriptor size */
+ uint8_t autoQuirk[HID_MAX_AUTO_QUIRK];
+};
+
+struct hid_rdesc_info {
+ void *data;
+ hid_size_t len;
+ hid_size_t isize;
+ hid_size_t osize;
+ hid_size_t fsize;
+ uint8_t iid;
+ uint8_t oid;
+ uint8_t fid;
+ /* Max sizes for HID requests supported by transport backend */
+ hid_size_t rdsize;
+ hid_size_t wrsize;
+ hid_size_t grsize;
+ hid_size_t srsize;
+};
+
+typedef void hid_intr_t(void *context, void *data, hid_size_t len);
+typedef bool hid_test_quirk_t(const struct hid_device_info *dev_info,
+ uint16_t quirk);
+
+extern hid_test_quirk_t *hid_test_quirk_p;
+
+/* prototypes from "usb_hid.c" */
+
+struct hid_data *hid_start_parse(const void *d, hid_size_t len, int kindset);
+void hid_end_parse(struct hid_data *s);
+int hid_get_item(struct hid_data *s, struct hid_item *h);
+int hid_report_size(const void *buf, hid_size_t len, enum hid_kind k,
+ uint8_t id);
+int hid_report_size_max(const void *buf, hid_size_t len, enum hid_kind k,
+ uint8_t *id);
+int hid_locate(const void *desc, hid_size_t size, int32_t usage,
+ enum hid_kind kind, uint8_t index, struct hid_location *loc,
+ uint32_t *flags, uint8_t *id);
+int32_t hid_get_data(const uint8_t *buf, hid_size_t len,
+ struct hid_location *loc);
+uint32_t hid_get_udata(const uint8_t *buf, hid_size_t len,
+ struct hid_location *loc);
+void hid_put_data_unsigned(uint8_t *buf, hid_size_t len,
+ struct hid_location *loc, unsigned int value);
+int hid_is_collection(const void *desc, hid_size_t size, int32_t usage);
+int32_t hid_item_resolution(struct hid_item *hi);
+int hid_is_mouse(const void *d_ptr, uint16_t d_len);
+int hid_is_keyboard(const void *d_ptr, uint16_t d_len);
+bool hid_test_quirk(const struct hid_device_info *dev_info, uint16_t quirk);
+int hid_add_dynamic_quirk(struct hid_device_info *dev_info,
+ uint16_t quirk);
+void hid_quirk_unload(void *arg);
+
+int hid_get_rdesc(device_t, void *, hid_size_t);
+int hid_read(device_t, void *, hid_size_t, hid_size_t *);
+int hid_write(device_t, const void *, hid_size_t);
+int hid_get_report(device_t, void *, hid_size_t, hid_size_t *, uint8_t,
+ uint8_t);
+int hid_set_report(device_t, const void *, hid_size_t, uint8_t, uint8_t);
+int hid_set_idle(device_t, uint16_t, uint8_t);
+int hid_set_protocol(device_t, uint16_t);
+#endif /* _KERNEL || _STANDALONE */
+#endif /* _HID_HID_H_ */
diff --git a/sys/dev/hid/hid.c b/sys/dev/hid/hid.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hid.c
@@ -0,0 +1,1080 @@
+/* $FreeBSD$ */
+/* $NetBSD: hid.c,v 1.17 2001/11/13 06:24:53 lukem Exp $ */
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-NetBSD
+ *
+ * Copyright (c) 1998 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.
+ *
+ * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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>
+#include <sys/bus.h>
+#include <sys/kdb.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/module.h>
+#include <sys/sysctl.h>
+
+#define HID_DEBUG_VAR hid_debug
+#include <dev/hid/hid.h>
+#include <dev/hid/hidquirk.h>
+
+#include "hid_if.h"
+
+/*
+ * Define this unconditionally in case a kernel module is loaded that
+ * has been compiled with debugging options.
+ */
+int hid_debug = 0;
+
+SYSCTL_NODE(_hw, OID_AUTO, hid, CTLFLAG_RW, 0, "HID debugging");
+SYSCTL_INT(_hw_hid, OID_AUTO, debug, CTLFLAG_RWTUN,
+ &hid_debug, 0, "Debug level");
+
+#ifdef HIDRAW_MAKE_UHID_ALIAS
+devclass_t hidraw_devclass;
+#endif
+
+static void hid_clear_local(struct hid_item *);
+static uint8_t hid_get_byte(struct hid_data *s, const uint16_t wSize);
+
+static hid_test_quirk_t hid_test_quirk_w;
+hid_test_quirk_t *hid_test_quirk_p = &hid_test_quirk_w;
+
+#define MAXUSAGE 64
+#define MAXPUSH 4
+#define MAXID 16
+#define MAXLOCCNT 2048
+
+struct hid_pos_data {
+ int32_t rid;
+ uint32_t pos;
+};
+
+struct hid_data {
+ const uint8_t *start;
+ const uint8_t *end;
+ const uint8_t *p;
+ struct hid_item cur[MAXPUSH];
+ struct hid_pos_data last_pos[MAXID];
+ int32_t usages_min[MAXUSAGE];
+ int32_t usages_max[MAXUSAGE];
+ int32_t usage_last; /* last seen usage */
+ uint32_t loc_size; /* last seen size */
+ uint32_t loc_count; /* last seen count */
+ uint32_t ncount; /* end usage item count */
+ uint32_t icount; /* current usage item count */
+ uint8_t kindset; /* we have 5 kinds so 8 bits are enough */
+ uint8_t pushlevel; /* current pushlevel */
+ uint8_t nusage; /* end "usages_min/max" index */
+ uint8_t iusage; /* current "usages_min/max" index */
+ uint8_t ousage; /* current "usages_min/max" offset */
+ uint8_t susage; /* usage set flags */
+};
+
+/*------------------------------------------------------------------------*
+ * hid_clear_local
+ *------------------------------------------------------------------------*/
+static void
+hid_clear_local(struct hid_item *c)
+{
+
+ c->loc.count = 0;
+ c->loc.size = 0;
+ c->nusages = 0;
+ memset(c->usages, 0, sizeof(c->usages));
+ c->usage_minimum = 0;
+ c->usage_maximum = 0;
+ c->designator_index = 0;
+ c->designator_minimum = 0;
+ c->designator_maximum = 0;
+ c->string_index = 0;
+ c->string_minimum = 0;
+ c->string_maximum = 0;
+ c->set_delimiter = 0;
+}
+
+static void
+hid_switch_rid(struct hid_data *s, struct hid_item *c, int32_t next_rID)
+{
+ uint8_t i;
+
+ /* check for same report ID - optimise */
+
+ if (c->report_ID == next_rID)
+ return;
+
+ /* save current position for current rID */
+
+ if (c->report_ID == 0) {
+ i = 0;
+ } else {
+ for (i = 1; i != MAXID; i++) {
+ if (s->last_pos[i].rid == c->report_ID)
+ break;
+ if (s->last_pos[i].rid == 0)
+ break;
+ }
+ }
+ if (i != MAXID) {
+ s->last_pos[i].rid = c->report_ID;
+ s->last_pos[i].pos = c->loc.pos;
+ }
+
+ /* store next report ID */
+
+ c->report_ID = next_rID;
+
+ /* lookup last position for next rID */
+
+ if (next_rID == 0) {
+ i = 0;
+ } else {
+ for (i = 1; i != MAXID; i++) {
+ if (s->last_pos[i].rid == next_rID)
+ break;
+ if (s->last_pos[i].rid == 0)
+ break;
+ }
+ }
+ if (i != MAXID) {
+ s->last_pos[i].rid = next_rID;
+ c->loc.pos = s->last_pos[i].pos;
+ } else {
+ DPRINTF("Out of RID entries, position is set to zero!\n");
+ c->loc.pos = 0;
+ }
+}
+
+/*------------------------------------------------------------------------*
+ * hid_start_parse
+ *------------------------------------------------------------------------*/
+struct hid_data *
+hid_start_parse(const void *d, hid_size_t len, int kindset)
+{
+ struct hid_data *s;
+
+ if ((kindset-1) & kindset) {
+ DPRINTFN(0, "Only one bit can be "
+ "set in the kindset\n");
+ return (NULL);
+ }
+
+ s = malloc(sizeof *s, M_TEMP, M_WAITOK | M_ZERO);
+ s->start = s->p = d;
+ s->end = ((const uint8_t *)d) + len;
+ s->kindset = kindset;
+ return (s);
+}
+
+/*------------------------------------------------------------------------*
+ * hid_end_parse
+ *------------------------------------------------------------------------*/
+void
+hid_end_parse(struct hid_data *s)
+{
+ if (s == NULL)
+ return;
+
+ free(s, M_TEMP);
+}
+
+/*------------------------------------------------------------------------*
+ * get byte from HID descriptor
+ *------------------------------------------------------------------------*/
+static uint8_t
+hid_get_byte(struct hid_data *s, const uint16_t wSize)
+{
+ const uint8_t *ptr;
+ uint8_t retval;
+
+ ptr = s->p;
+
+ /* check if end is reached */
+ if (ptr == s->end)
+ return (0);
+
+ /* read out a byte */
+ retval = *ptr;
+
+ /* check if data pointer can be advanced by "wSize" bytes */
+ if ((s->end - ptr) < wSize)
+ ptr = s->end;
+ else
+ ptr += wSize;
+
+ /* update pointer */
+ s->p = ptr;
+
+ return (retval);
+}
+
+/*------------------------------------------------------------------------*
+ * hid_get_item
+ *------------------------------------------------------------------------*/
+int
+hid_get_item(struct hid_data *s, struct hid_item *h)
+{
+ struct hid_item *c;
+ unsigned int bTag, bType, bSize;
+ uint32_t oldpos;
+ int32_t mask;
+ int32_t dval;
+
+ if (s == NULL)
+ return (0);
+
+ c = &s->cur[s->pushlevel];
+
+ top:
+ /* check if there is an array of items */
+ if (s->icount < s->ncount) {
+ /* get current usage */
+ if (s->iusage < s->nusage) {
+ dval = s->usages_min[s->iusage] + s->ousage;
+ c->usage = dval;
+ s->usage_last = dval;
+ if (dval == s->usages_max[s->iusage]) {
+ if (s->iusage < MAXUSAGE - 1)
+ s->iusage ++;
+ s->ousage = 0;
+ } else {
+ s->ousage ++;
+ }
+ } else {
+ DPRINTFN(1, "Using last usage\n");
+ dval = s->usage_last;
+ }
+ c->nusages = 1;
+ /* array type HID item may have multiple usages */
+ while ((c->flags & HIO_VARIABLE) == 0 && s->ousage == 0 &&
+ s->iusage < s->nusage && c->nusages < HID_ITEM_MAXUSAGE)
+ c->usages[c->nusages++] = s->usages_min[s->iusage++];
+ if ((c->flags & HIO_VARIABLE) == 0 && s->ousage == 0 &&
+ s->iusage < s->nusage)
+ DPRINTFN(0, "HID_ITEM_MAXUSAGE should be increased "
+ "up to %hhu to parse the HID report descriptor\n",
+ s->nusage);
+ s->icount ++;
+ /*
+ * Only copy HID item, increment position and return
+ * if correct kindset!
+ */
+ if (s->kindset & (1 << c->kind)) {
+ *h = *c;
+ DPRINTFN(1, "%u,%u,%u\n", h->loc.pos,
+ h->loc.size, h->loc.count);
+ c->loc.pos += c->loc.size * c->loc.count;
+ return (1);
+ }
+ }
+
+ /* reset state variables */
+ s->icount = 0;
+ s->ncount = 0;
+ s->iusage = 0;
+ s->nusage = 0;
+ s->susage = 0;
+ s->ousage = 0;
+ hid_clear_local(c);
+
+ /* get next item */
+ while (s->p != s->end) {
+ bSize = hid_get_byte(s, 1);
+ if (bSize == 0xfe) {
+ /* long item */
+ bSize = hid_get_byte(s, 1);
+ bSize |= hid_get_byte(s, 1) << 8;
+ bTag = hid_get_byte(s, 1);
+ bType = 0xff; /* XXX what should it be */
+ } else {
+ /* short item */
+ bTag = bSize >> 4;
+ bType = (bSize >> 2) & 3;
+ bSize &= 3;
+ if (bSize == 3)
+ bSize = 4;
+ }
+ switch (bSize) {
+ case 0:
+ dval = 0;
+ mask = 0;
+ break;
+ case 1:
+ dval = (int8_t)hid_get_byte(s, 1);
+ mask = 0xFF;
+ break;
+ case 2:
+ dval = hid_get_byte(s, 1);
+ dval |= hid_get_byte(s, 1) << 8;
+ dval = (int16_t)dval;
+ mask = 0xFFFF;
+ break;
+ case 4:
+ dval = hid_get_byte(s, 1);
+ dval |= hid_get_byte(s, 1) << 8;
+ dval |= hid_get_byte(s, 1) << 16;
+ dval |= hid_get_byte(s, 1) << 24;
+ mask = 0xFFFFFFFF;
+ break;
+ default:
+ dval = hid_get_byte(s, bSize);
+ DPRINTFN(0, "bad length %u (data=0x%02x)\n",
+ bSize, dval);
+ continue;
+ }
+
+ switch (bType) {
+ case 0: /* Main */
+ switch (bTag) {
+ case 8: /* Input */
+ c->kind = hid_input;
+ ret:
+ c->flags = dval;
+ c->loc.count = s->loc_count;
+ c->loc.size = s->loc_size;
+
+ if (c->flags & HIO_VARIABLE) {
+ /* range check usage count */
+ if (c->loc.count > MAXLOCCNT) {
+ DPRINTFN(0, "Number of "
+ "items(%u) truncated to %u\n",
+ (unsigned)(c->loc.count),
+ MAXLOCCNT);
+ s->ncount = MAXLOCCNT;
+ } else
+ s->ncount = c->loc.count;
+
+ /*
+ * The "top" loop will return
+ * one and one item:
+ */
+ c->loc.count = 1;
+ } else {
+ s->ncount = 1;
+ }
+ goto top;
+
+ case 9: /* Output */
+ c->kind = hid_output;
+ goto ret;
+ case 10: /* Collection */
+ c->kind = hid_collection;
+ c->collection = dval;
+ c->collevel++;
+ c->usage = s->usage_last;
+ c->nusages = 1;
+ *h = *c;
+ return (1);
+ case 11: /* Feature */
+ c->kind = hid_feature;
+ goto ret;
+ case 12: /* End collection */
+ c->kind = hid_endcollection;
+ if (c->collevel == 0) {
+ DPRINTFN(0, "invalid end collection\n");
+ return (0);
+ }
+ c->collevel--;
+ *h = *c;
+ return (1);
+ default:
+ DPRINTFN(0, "Main bTag=%d\n", bTag);
+ break;
+ }
+ break;
+ case 1: /* Global */
+ switch (bTag) {
+ case 0:
+ c->_usage_page = dval << 16;
+ break;
+ case 1:
+ c->logical_minimum = dval;
+ break;
+ case 2:
+ c->logical_maximum = dval;
+ break;
+ case 3:
+ c->physical_minimum = dval;
+ break;
+ case 4:
+ c->physical_maximum = dval;
+ break;
+ case 5:
+ c->unit_exponent = dval;
+ break;
+ case 6:
+ c->unit = dval;
+ break;
+ case 7:
+ /* mask because value is unsigned */
+ s->loc_size = dval & mask;
+ break;
+ case 8:
+ hid_switch_rid(s, c, dval & mask);
+ break;
+ case 9:
+ /* mask because value is unsigned */
+ s->loc_count = dval & mask;
+ break;
+ case 10: /* Push */
+ /* stop parsing, if invalid push level */
+ if ((s->pushlevel + 1) >= MAXPUSH) {
+ DPRINTFN(0, "Cannot push item @ %d\n", s->pushlevel);
+ return (0);
+ }
+ s->pushlevel ++;
+ s->cur[s->pushlevel] = *c;
+ /* store size and count */
+ c->loc.size = s->loc_size;
+ c->loc.count = s->loc_count;
+ /* update current item pointer */
+ c = &s->cur[s->pushlevel];
+ break;
+ case 11: /* Pop */
+ /* stop parsing, if invalid push level */
+ if (s->pushlevel == 0) {
+ DPRINTFN(0, "Cannot pop item @ 0\n");
+ return (0);
+ }
+ s->pushlevel --;
+ /* preserve position */
+ oldpos = c->loc.pos;
+ c = &s->cur[s->pushlevel];
+ /* restore size and count */
+ s->loc_size = c->loc.size;
+ s->loc_count = c->loc.count;
+ /* set default item location */
+ c->loc.pos = oldpos;
+ c->loc.size = 0;
+ c->loc.count = 0;
+ break;
+ default:
+ DPRINTFN(0, "Global bTag=%d\n", bTag);
+ break;
+ }
+ break;
+ case 2: /* Local */
+ switch (bTag) {
+ case 0:
+ if (bSize != 4)
+ dval = (dval & mask) | c->_usage_page;
+
+ /* set last usage, in case of a collection */
+ s->usage_last = dval;
+
+ if (s->nusage < MAXUSAGE) {
+ s->usages_min[s->nusage] = dval;
+ s->usages_max[s->nusage] = dval;
+ s->nusage ++;
+ } else {
+ DPRINTFN(0, "max usage reached\n");
+ }
+
+ /* clear any pending usage sets */
+ s->susage = 0;
+ break;
+ case 1:
+ s->susage |= 1;
+
+ if (bSize != 4)
+ dval = (dval & mask) | c->_usage_page;
+ c->usage_minimum = dval;
+
+ goto check_set;
+ case 2:
+ s->susage |= 2;
+
+ if (bSize != 4)
+ dval = (dval & mask) | c->_usage_page;
+ c->usage_maximum = dval;
+
+ check_set:
+ if (s->susage != 3)
+ break;
+
+ /* sanity check */
+ if ((s->nusage < MAXUSAGE) &&
+ (c->usage_minimum <= c->usage_maximum)) {
+ /* add usage range */
+ s->usages_min[s->nusage] =
+ c->usage_minimum;
+ s->usages_max[s->nusage] =
+ c->usage_maximum;
+ s->nusage ++;
+ } else {
+ DPRINTFN(0, "Usage set dropped\n");
+ }
+ s->susage = 0;
+ break;
+ case 3:
+ c->designator_index = dval;
+ break;
+ case 4:
+ c->designator_minimum = dval;
+ break;
+ case 5:
+ c->designator_maximum = dval;
+ break;
+ case 7:
+ c->string_index = dval;
+ break;
+ case 8:
+ c->string_minimum = dval;
+ break;
+ case 9:
+ c->string_maximum = dval;
+ break;
+ case 10:
+ c->set_delimiter = dval;
+ break;
+ default:
+ DPRINTFN(0, "Local bTag=%d\n", bTag);
+ break;
+ }
+ break;
+ default:
+ DPRINTFN(0, "default bType=%d\n", bType);
+ break;
+ }
+ }
+ return (0);
+}
+
+/*------------------------------------------------------------------------*
+ * hid_report_size
+ *------------------------------------------------------------------------*/
+int
+hid_report_size(const void *buf, hid_size_t len, enum hid_kind k, uint8_t id)
+{
+ struct hid_data *d;
+ struct hid_item h;
+ uint32_t temp;
+ uint32_t hpos;
+ uint32_t lpos;
+ int report_id = 0;
+
+ hpos = 0;
+ lpos = 0xFFFFFFFF;
+
+ for (d = hid_start_parse(buf, len, 1 << k); hid_get_item(d, &h);) {
+ if (h.kind == k && h.report_ID == id) {
+ /* compute minimum */
+ if (lpos > h.loc.pos)
+ lpos = h.loc.pos;
+ /* compute end position */
+ temp = h.loc.pos + (h.loc.size * h.loc.count);
+ /* compute maximum */
+ if (hpos < temp)
+ hpos = temp;
+ if (h.report_ID != 0)
+ report_id = 1;
+ }
+ }
+ hid_end_parse(d);
+
+ /* safety check - can happen in case of currupt descriptors */
+ if (lpos > hpos)
+ temp = 0;
+ else
+ temp = hpos - lpos;
+
+ /* return length in bytes rounded up */
+ return ((temp + 7) / 8 + report_id);
+}
+
+int
+hid_report_size_max(const void *buf, hid_size_t len, enum hid_kind k,
+ uint8_t *id)
+{
+ struct hid_data *d;
+ struct hid_item h;
+ uint32_t temp;
+ uint32_t hpos;
+ uint32_t lpos;
+ uint8_t any_id;
+
+ any_id = 0;
+ hpos = 0;
+ lpos = 0xFFFFFFFF;
+
+ for (d = hid_start_parse(buf, len, 1 << k); hid_get_item(d, &h);) {
+ if (h.kind == k) {
+ /* check for ID-byte presence */
+ if ((h.report_ID != 0) && !any_id) {
+ if (id != NULL)
+ *id = h.report_ID;
+ any_id = 1;
+ }
+ /* compute minimum */
+ if (lpos > h.loc.pos)
+ lpos = h.loc.pos;
+ /* compute end position */
+ temp = h.loc.pos + (h.loc.size * h.loc.count);
+ /* compute maximum */
+ if (hpos < temp)
+ hpos = temp;
+ }
+ }
+ hid_end_parse(d);
+
+ /* safety check - can happen in case of currupt descriptors */
+ if (lpos > hpos)
+ temp = 0;
+ else
+ temp = hpos - lpos;
+
+ /* check for ID byte */
+ if (any_id)
+ temp += 8;
+ else if (id != NULL)
+ *id = 0;
+
+ /* return length in bytes rounded up */
+ return ((temp + 7) / 8);
+}
+
+/*------------------------------------------------------------------------*
+ * hid_locate
+ *------------------------------------------------------------------------*/
+int
+hid_locate(const void *desc, hid_size_t size, int32_t u, enum hid_kind k,
+ uint8_t index, struct hid_location *loc, uint32_t *flags, uint8_t *id)
+{
+ struct hid_data *d;
+ struct hid_item h;
+ int i;
+
+ for (d = hid_start_parse(desc, size, 1 << k); hid_get_item(d, &h);) {
+ for (i = 0; i < h.nusages; i++) {
+ if (h.kind == k && h.usages[i] == u) {
+ if (index--)
+ break;
+ if (loc != NULL)
+ *loc = h.loc;
+ if (flags != NULL)
+ *flags = h.flags;
+ if (id != NULL)
+ *id = h.report_ID;
+ hid_end_parse(d);
+ return (1);
+ }
+ }
+ }
+ if (loc != NULL)
+ loc->size = 0;
+ if (flags != NULL)
+ *flags = 0;
+ if (id != NULL)
+ *id = 0;
+ hid_end_parse(d);
+ return (0);
+}
+
+/*------------------------------------------------------------------------*
+ * hid_get_data
+ *------------------------------------------------------------------------*/
+static uint32_t
+hid_get_data_sub(const uint8_t *buf, hid_size_t len, struct hid_location *loc,
+ int is_signed)
+{
+ uint32_t hpos = loc->pos;
+ uint32_t hsize = loc->size;
+ uint32_t data;
+ uint32_t rpos;
+ uint8_t n;
+
+ DPRINTFN(11, "hid_get_data: loc %d/%d\n", hpos, hsize);
+
+ /* Range check and limit */
+ if (hsize == 0)
+ return (0);
+ if (hsize > 32)
+ hsize = 32;
+
+ /* Get data in a safe way */
+ data = 0;
+ rpos = (hpos / 8);
+ n = (hsize + 7) / 8;
+ rpos += n;
+ while (n--) {
+ rpos--;
+ if (rpos < len)
+ data |= buf[rpos] << (8 * n);
+ }
+
+ /* Correctly shift down data */
+ data = (data >> (hpos % 8));
+ n = 32 - hsize;
+
+ /* Mask and sign extend in one */
+ if (is_signed != 0)
+ data = (int32_t)((int32_t)data << n) >> n;
+ else
+ data = (uint32_t)((uint32_t)data << n) >> n;
+
+ DPRINTFN(11, "hid_get_data: loc %d/%d = %lu\n",
+ loc->pos, loc->size, (long)data);
+ return (data);
+}
+
+int32_t
+hid_get_data(const uint8_t *buf, hid_size_t len, struct hid_location *loc)
+{
+ return (hid_get_data_sub(buf, len, loc, 1));
+}
+
+uint32_t
+hid_get_udata(const uint8_t *buf, hid_size_t len, struct hid_location *loc)
+{
+ return (hid_get_data_sub(buf, len, loc, 0));
+}
+
+/*------------------------------------------------------------------------*
+ * hid_put_data
+ *------------------------------------------------------------------------*/
+void
+hid_put_data_unsigned(uint8_t *buf, hid_size_t len,
+ struct hid_location *loc, unsigned int value)
+{
+ uint32_t hpos = loc->pos;
+ uint32_t hsize = loc->size;
+ uint64_t data;
+ uint64_t mask;
+ uint32_t rpos;
+ uint8_t n;
+
+ DPRINTFN(11, "hid_put_data: loc %d/%d = %u\n", hpos, hsize, value);
+
+ /* Range check and limit */
+ if (hsize == 0)
+ return;
+ if (hsize > 32)
+ hsize = 32;
+
+ /* Put data in a safe way */
+ rpos = (hpos / 8);
+ n = (hsize + 7) / 8;
+ data = ((uint64_t)value) << (hpos % 8);
+ mask = ((1ULL << hsize) - 1ULL) << (hpos % 8);
+ rpos += n;
+ while (n--) {
+ rpos--;
+ if (rpos < len) {
+ buf[rpos] &= ~(mask >> (8 * n));
+ buf[rpos] |= (data >> (8 * n));
+ }
+ }
+}
+
+/*------------------------------------------------------------------------*
+ * hid_is_collection
+ *------------------------------------------------------------------------*/
+int
+hid_is_collection(const void *desc, hid_size_t size, int32_t usage)
+{
+ struct hid_data *hd;
+ struct hid_item hi;
+ int err;
+
+ hd = hid_start_parse(desc, size, hid_input);
+ if (hd == NULL)
+ return (0);
+
+ while ((err = hid_get_item(hd, &hi))) {
+ if (hi.kind == hid_collection &&
+ hi.usage == usage)
+ break;
+ }
+ hid_end_parse(hd);
+ return (err);
+}
+
+/*------------------------------------------------------------------------*
+ * calculate HID item resolution. unit/mm for distances, unit/rad for angles
+ *------------------------------------------------------------------------*/
+int32_t
+hid_item_resolution(struct hid_item *hi)
+{
+ /*
+ * hid unit scaling table according to HID Usage Table Review
+ * Request 39 Tbl 17 http://www.usb.org/developers/hidpage/HUTRR39b.pdf
+ */
+ static const int64_t scale[0x10][2] = {
+ [0x00] = { 1, 1 },
+ [0x01] = { 1, 10 },
+ [0x02] = { 1, 100 },
+ [0x03] = { 1, 1000 },
+ [0x04] = { 1, 10000 },
+ [0x05] = { 1, 100000 },
+ [0x06] = { 1, 1000000 },
+ [0x07] = { 1, 10000000 },
+ [0x08] = { 100000000, 1 },
+ [0x09] = { 10000000, 1 },
+ [0x0A] = { 1000000, 1 },
+ [0x0B] = { 100000, 1 },
+ [0x0C] = { 10000, 1 },
+ [0x0D] = { 1000, 1 },
+ [0x0E] = { 100, 1 },
+ [0x0F] = { 10, 1 },
+ };
+ int64_t logical_size;
+ int64_t physical_size;
+ int64_t multiplier;
+ int64_t divisor;
+ int64_t resolution;
+
+ switch (hi->unit) {
+ case HUM_CENTIMETER:
+ multiplier = 1;
+ divisor = 10;
+ break;
+ case HUM_INCH:
+ multiplier = 10;
+ divisor = 254;
+ break;
+ case HUM_RADIAN:
+ multiplier = 1;
+ divisor = 1;
+ break;
+ case HUM_DEGREE:
+ multiplier = 573;
+ divisor = 10;
+ break;
+ default:
+ return (0);
+ }
+
+ if ((hi->logical_maximum <= hi->logical_minimum) ||
+ (hi->physical_maximum <= hi->physical_minimum) ||
+ (hi->unit_exponent < 0) || (hi->unit_exponent >= nitems(scale)))
+ return (0);
+
+ logical_size = (int64_t)hi->logical_maximum -
+ (int64_t)hi->logical_minimum;
+ physical_size = (int64_t)hi->physical_maximum -
+ (int64_t)hi->physical_minimum;
+ /* Round to ceiling */
+ resolution = logical_size * multiplier * scale[hi->unit_exponent][0] /
+ (physical_size * divisor * scale[hi->unit_exponent][1]);
+
+ if (resolution > INT32_MAX)
+ return (0);
+
+ return (resolution);
+}
+
+/*------------------------------------------------------------------------*
+ * hid_is_mouse
+ *
+ * This function will decide if a USB descriptor belongs to a USB mouse.
+ *
+ * Return values:
+ * Zero: Not a USB mouse.
+ * Else: Is a USB mouse.
+ *------------------------------------------------------------------------*/
+int
+hid_is_mouse(const void *d_ptr, uint16_t d_len)
+{
+ struct hid_data *hd;
+ struct hid_item hi;
+ int mdepth;
+ int found;
+
+ hd = hid_start_parse(d_ptr, d_len, 1 << hid_input);
+ if (hd == NULL)
+ return (0);
+
+ mdepth = 0;
+ found = 0;
+
+ while (hid_get_item(hd, &hi)) {
+ switch (hi.kind) {
+ case hid_collection:
+ if (mdepth != 0)
+ mdepth++;
+ else if (hi.collection == 1 &&
+ hi.usage ==
+ HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_MOUSE))
+ mdepth++;
+ break;
+ case hid_endcollection:
+ if (mdepth != 0)
+ mdepth--;
+ break;
+ case hid_input:
+ if (mdepth == 0)
+ break;
+ if (hi.usage ==
+ HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X) &&
+ (hi.flags & (HIO_CONST|HIO_RELATIVE)) == HIO_RELATIVE)
+ found++;
+ if (hi.usage ==
+ HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y) &&
+ (hi.flags & (HIO_CONST|HIO_RELATIVE)) == HIO_RELATIVE)
+ found++;
+ break;
+ default:
+ break;
+ }
+ }
+ hid_end_parse(hd);
+ return (found);
+}
+
+/*------------------------------------------------------------------------*
+ * hid_is_keyboard
+ *
+ * This function will decide if a USB descriptor belongs to a USB keyboard.
+ *
+ * Return values:
+ * Zero: Not a USB keyboard.
+ * Else: Is a USB keyboard.
+ *------------------------------------------------------------------------*/
+int
+hid_is_keyboard(const void *d_ptr, uint16_t d_len)
+{
+ if (hid_is_collection(d_ptr, d_len,
+ HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_KEYBOARD)))
+ return (1);
+ return (0);
+}
+
+/*------------------------------------------------------------------------*
+ * hid_test_quirk - test a device for a given quirk
+ *
+ * Return values:
+ * false: The HID device does not have the given quirk.
+ * true: The HID device has the given quirk.
+ *------------------------------------------------------------------------*/
+bool
+hid_test_quirk(const struct hid_device_info *dev_info, uint16_t quirk)
+{
+ bool found;
+ uint8_t x;
+
+ if (quirk == HQ_NONE)
+ return (false);
+
+ /* search the automatic per device quirks first */
+ for (x = 0; x != HID_MAX_AUTO_QUIRK; x++) {
+ if (dev_info->autoQuirk[x] == quirk)
+ return (true);
+ }
+
+ /* search global quirk table, if any */
+ found = (hid_test_quirk_p) (dev_info, quirk);
+
+ return (found);
+}
+
+static bool
+hid_test_quirk_w(const struct hid_device_info *dev_info, uint16_t quirk)
+{
+ return (false); /* no match */
+}
+
+int
+hid_add_dynamic_quirk(struct hid_device_info *dev_info, uint16_t quirk)
+{
+ uint8_t x;
+
+ for (x = 0; x != HID_MAX_AUTO_QUIRK; x++) {
+ if (dev_info->autoQuirk[x] == 0 ||
+ dev_info->autoQuirk[x] == quirk) {
+ dev_info->autoQuirk[x] = quirk;
+ return (0); /* success */
+ }
+ }
+ return (ENOSPC);
+}
+
+void
+hid_quirk_unload(void *arg)
+{
+ /* reset function pointer */
+ hid_test_quirk_p = &hid_test_quirk_w;
+#ifdef NOT_YET
+ hidquirk_ioctl_p = &hidquirk_ioctl_w;
+#endif
+
+ /* wait for CPU to exit the loaded functions, if any */
+
+ /* XXX this is a tradeoff */
+
+ pause("WAIT", hz);
+}
+
+int
+hid_get_rdesc(device_t dev, void *data, hid_size_t len)
+{
+ return (HID_GET_RDESC(device_get_parent(dev), data, len));
+}
+
+int
+hid_read(device_t dev, void *data, hid_size_t maxlen, hid_size_t *actlen)
+{
+ return (HID_READ(device_get_parent(dev), data, maxlen, actlen));
+}
+
+int
+hid_write(device_t dev, const void *data, hid_size_t len)
+{
+ return (HID_WRITE(device_get_parent(dev), data, len));
+}
+
+int
+hid_get_report(device_t dev, void *data, hid_size_t maxlen, hid_size_t *actlen,
+ uint8_t type, uint8_t id)
+{
+ return (HID_GET_REPORT(device_get_parent(dev), data, maxlen, actlen,
+ type, id));
+}
+
+int
+hid_set_report(device_t dev, const void *data, hid_size_t len, uint8_t type,
+ uint8_t id)
+{
+ return (HID_SET_REPORT(device_get_parent(dev), data, len, type, id));
+}
+
+int
+hid_set_idle(device_t dev, uint16_t duration, uint8_t id)
+{
+ return (HID_SET_IDLE(device_get_parent(dev), duration, id));
+}
+
+int
+hid_set_protocol(device_t dev, uint16_t protocol)
+{
+ return (HID_SET_PROTOCOL(device_get_parent(dev), protocol));
+}
+
+MODULE_VERSION(hid, 1);
diff --git a/sys/dev/hid/hid_if.m b/sys/dev/hid/hid_if.m
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hid_if.m
@@ -0,0 +1,164 @@
+#-
+# Copyright (c) 2019 Vladimir Kondratyev
+#
+# 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.
+#
+# $FreeBSD$
+#
+
+#include <sys/param.h>
+#include <sys/bus.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <dev/hid/hid.h>
+
+# Any function listed here can do unbound sleeps waiting for IO to complete.
+
+INTERFACE hid;
+
+# Interrupts interface
+
+#
+# Allocate memory and initialise interrupt transfers.
+# intr callback function which is called if input data is available.
+# context is the private softc pointer, which will be used to callback.
+# isize, osize and fsize are requested maximal sizes of input, output and
+# feature reports and used to determine sizes of driver internal buffers.
+# This function returns zero upon success. A non-zero return value indicates
+# failure.
+#
+METHOD void intr_setup {
+ device_t dev;
+ hid_intr_t intr;
+ void *context;
+ struct hid_rdesc_info *rdesc;
+};
+
+#
+# Release all allocated resources associated with interrupt transfers.
+#
+METHOD void intr_unsetup {
+ device_t dev;
+};
+
+#
+# Start the interrupt transfers if not already started.
+#
+METHOD int intr_start {
+ device_t dev;
+};
+
+#
+# Stop the interrupt transfers if not already stopped.
+#
+METHOD int intr_stop {
+ device_t dev;
+};
+
+#
+# The following function gets called from the HID keyboard driver
+# when the system has paniced.
+#
+METHOD void intr_poll {
+ device_t dev;
+};
+
+# HID interface
+
+#
+# Read out an report descriptor from the HID device.
+#
+METHOD int get_rdesc {
+ device_t dev;
+ void *data;
+ hid_size_t len;
+};
+
+#
+# Get input data from the device. Data should be read in chunks
+# of the size prescribed by the report descriptor.
+# This function interferes with interrupt transfers and should not be used.
+#
+METHOD int read {
+ device_t dev;
+ void *data;
+ hid_size_t maxlen;
+ hid_size_t *actlen;
+};
+
+#
+# Send data to the device. Data should be written in
+# chunks of the size prescribed by the report descriptor.
+#
+METHOD int write {
+ device_t dev;
+ const void *data;
+ hid_size_t len;
+};
+
+#
+# Get a report from the device without waiting for data on the interrupt.
+# Copies a maximum of len bytes of the report data into the memory specified
+# by data. Upon return actlen is set to the number of bytes copied. The type
+# field indicates which report is requested. It should be HID_INPUT_REPORT,
+# HID_OUTPUT_REPORT, or HID_FEATURE_REPORT. This call may fail if the device
+# does not support this feature.
+#
+METHOD int get_report {
+ device_t dev;
+ void *data;
+ hid_size_t maxlen;
+ hid_size_t *actlen;
+ uint8_t type;
+ uint8_t id;
+};
+
+#
+# Set a report in the device. The type field indicates which report is to be
+# set. It should be HID_INPUT_REPORT, HID_OUTPUT_REPORT, or HID_FEATURE_REPORT.
+# The value of the report is specified by the data and the len fields.
+# This call may fail if the device does not support this feature.
+#
+METHOD int set_report {
+ device_t dev;
+ const void *data;
+ hid_size_t len;
+ uint8_t type;
+ uint8_t id;
+};
+
+#
+# Set duration between input reports (in mSec).
+#
+METHOD int set_idle {
+ device_t dev;
+ uint16_t duration;
+ uint8_t id;
+};
+
+#
+# Switch between the boot protocol and the report protocol (or vice versa).
+#
+METHOD int set_protocol {
+ device_t dev;
+ uint16_t protocol;
+};
diff --git a/sys/dev/hid/hidbus.h b/sys/dev/hid/hidbus.h
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hidbus.h
@@ -0,0 +1,178 @@
+/*-
+ * Copyright (c) 2019 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.
+ */
+
+#ifndef _HID_HIDBUS_H_
+#define _HID_HIDBUS_H_
+
+#define HIDBUS_EPOCH global_epoch_preempt
+
+enum {
+ HIDBUS_IVAR_USAGE,
+ HIDBUS_IVAR_INDEX,
+ HIDBUS_IVAR_FLAGS,
+#define HIDBUS_FLAG_AUTOCHILD (0<<1) /* Child is autodiscovered */
+#define HIDBUS_FLAG_CAN_POLL (1<<1) /* Child can work during panic */
+ HIDBUS_IVAR_DRIVER_INFO,
+ HIDBUS_IVAR_LOCK,
+};
+
+#define HIDBUS_ACCESSOR(A, B, T) \
+ __BUS_ACCESSOR(hidbus, A, HIDBUS, B, T)
+
+HIDBUS_ACCESSOR(usage, USAGE, int32_t)
+HIDBUS_ACCESSOR(index, INDEX, uint8_t)
+HIDBUS_ACCESSOR(flags, FLAGS, uint32_t)
+HIDBUS_ACCESSOR(driver_info, DRIVER_INFO, uintptr_t)
+HIDBUS_ACCESSOR(lock, LOCK, struct mtx *)
+
+/*
+ * The following structure is used when looking up an HID driver for
+ * an HID device. It is inspired by the structure called "usb_device_id".
+ * which is originated in Linux and ported to FreeBSD.
+ */
+struct hid_device_id {
+
+ /* Select which fields to match against */
+#if BYTE_ORDER == LITTLE_ENDIAN
+ uint16_t
+ match_flag_page:1,
+ match_flag_usage:1,
+ match_flag_bus:1,
+ match_flag_vendor:1,
+ match_flag_product:1,
+ match_flag_ver_lo:1,
+ match_flag_ver_hi:1,
+ match_flag_pnp:1,
+ match_flag_unused:8;
+#else
+ uint16_t
+ match_flag_unused:8,
+ match_flag_pnp:1,
+ match_flag_ver_hi:1,
+ match_flag_ver_lo:1,
+ match_flag_product:1,
+ match_flag_vendor:1,
+ match_flag_bus:1,
+ match_flag_usage:1,
+ match_flag_page:1;
+#endif
+
+ /* Used for top level collection usage matches */
+ uint16_t page;
+ uint16_t usage;
+
+ /* Used for product specific matches; the Version range is inclusive */
+ uint8_t idBus;
+ uint16_t idVendor;
+ uint16_t idProduct;
+ uint16_t idVersion_lo;
+ uint16_t idVersion_hi;
+ char *idPnP;
+
+ /* Hook for driver specific information */
+ uintptr_t driver_info;
+};
+
+#define HID_STD_PNP_INFO \
+ "M16:mask;U16:page;U16:usage;U8:bus;U16:vendor;U16:product;" \
+ "L16:version;G16:version;Z:_HID"
+#define HID_PNP_INFO(table) \
+ MODULE_PNP_INFO(HID_STD_PNP_INFO, hidbus, table, table, nitems(table))
+
+#define HID_TLC(pg,usg) \
+ .match_flag_page = 1, .match_flag_usage = 1, .page = (pg), .usage = (usg)
+
+#define HID_BUS(bus) \
+ .match_flag_bus = 1, .idBus = (bus)
+
+#define HID_VENDOR(vend) \
+ .match_flag_vendor = 1, .idVendor = (vend)
+
+#define HID_PRODUCT(prod) \
+ .match_flag_product = 1, .idProduct = (prod)
+
+#define HID_VP(vend,prod) \
+ HID_VENDOR(vend), HID_PRODUCT(prod)
+
+#define HID_BVP(bus,vend,prod) \
+ HID_BUS(bus), HID_VENDOR(vend), HID_PRODUCT(prod)
+
+#define HID_BVPI(bus,vend,prod,info) \
+ HID_BUS(bus), HID_VENDOR(vend), HID_PRODUCT(prod), HID_DRIVER_INFO(info)
+
+#define HID_VERSION_GTEQ(lo) /* greater than or equal */ \
+ .match_flag_ver_lo = 1, .idVersion_lo = (lo)
+
+#define HID_VERSION_LTEQ(hi) /* less than or equal */ \
+ .match_flag_ver_hi = 1, .idVersion_hi = (hi)
+
+#define HID_PNP(pnp) \
+ .match_flag_pnp = 1, .idPnP = (pnp)
+
+#define HID_DRIVER_INFO(n) \
+ .driver_info = (n)
+
+#define HID_GET_DRIVER_INFO(did) \
+ (did)->driver_info
+
+#define HIDBUS_LOOKUP_ID(d, h) hidbus_lookup_id((d), (h), nitems(h))
+#define HIDBUS_LOOKUP_DRIVER_INFO(d, h) \
+ hidbus_lookup_driver_info((d), (h), nitems(h))
+
+/*
+ * Walk through all HID items hi belonging Top Level Collection #tlc_index
+ */
+#define HIDBUS_FOREACH_ITEM(hd, hi, tlc_index) \
+ for (uint8_t _iter = 0; \
+ _iter <= (tlc_index) && hid_get_item((hd), (hi)); \
+ _iter += (hi)->kind == hid_endcollection && (hi)->collevel == 0) \
+ if (_iter == (tlc_index))
+
+int hidbus_locate(const void *desc, hid_size_t size, int32_t u,
+ enum hid_kind k, uint8_t tlc_index, uint8_t index,
+ struct hid_location *loc, uint32_t *flags, uint8_t *id,
+ struct hid_absinfo *ai);
+
+const struct hid_device_id *hidbus_lookup_id(device_t,
+ const struct hid_device_id *, int);
+struct hid_rdesc_info *hidbus_get_rdesc_info(device_t);
+int hidbus_lookup_driver_info(device_t,
+ const struct hid_device_id *, int);
+void hidbus_set_intr(device_t, hid_intr_t*, void *);
+int hidbus_intr_start(device_t);
+int hidbus_intr_stop(device_t);
+void hidbus_intr_poll(device_t);
+void hidbus_set_desc(device_t, const char *);
+device_t hidbus_find_child(device_t, int32_t);
+
+/* hidbus HID interface */
+int hid_get_report_descr(device_t, void **, hid_size_t *);
+int hid_set_report_descr(device_t, const void *, hid_size_t);
+
+const struct hid_device_info *hid_get_device_info(device_t);
+
+extern devclass_t hidbus_devclass;
+
+#endif /* _HID_HIDBUS_H_ */
diff --git a/sys/dev/hid/hidbus.c b/sys/dev/hid/hidbus.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hidbus.c
@@ -0,0 +1,905 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2019-2020 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 <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/bus.h>
+#include <sys/ck.h>
+#include <sys/epoch.h>
+#include <sys/kdb.h>
+#include <sys/kernel.h>
+#include <sys/libkern.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/module.h>
+#include <sys/mutex.h>
+#include <sys/proc.h>
+#include <sys/systm.h>
+#include <sys/sx.h>
+
+#define HID_DEBUG_VAR hid_debug
+#include <dev/hid/hid.h>
+#include <dev/hid/hidbus.h>
+#include <dev/hid/hidquirk.h>
+
+#include "hid_if.h"
+
+#define HID_RSIZE_MAX 1024
+
+static hid_intr_t hidbus_intr;
+
+static device_probe_t hidbus_probe;
+static device_attach_t hidbus_attach;
+static device_detach_t hidbus_detach;
+
+struct hidbus_ivars {
+ int32_t usage;
+ uint8_t index;
+ uint32_t flags;
+ uintptr_t driver_info; /* for internal use */
+ struct mtx *mtx; /* child intr mtx */
+ hid_intr_t *intr_handler; /* executed under mtx*/
+ void *intr_ctx;
+ unsigned int refcnt; /* protected by mtx */
+ struct epoch_context epoch_ctx;
+ CK_STAILQ_ENTRY(hidbus_ivars) link;
+};
+
+struct hidbus_softc {
+ device_t dev;
+ struct sx sx;
+ struct mtx mtx;
+
+ bool nowrite;
+
+ struct hid_rdesc_info rdesc;
+ bool overloaded;
+ int nest; /* Child attach nesting lvl */
+ int nauto; /* Number of autochildren */
+
+ CK_STAILQ_HEAD(, hidbus_ivars) tlcs;
+};
+
+static int
+hidbus_fill_rdesc_info(struct hid_rdesc_info *hri, const void *data,
+ hid_size_t len)
+{
+ int error = 0;
+
+ hri->data = __DECONST(void *, data);
+ hri->len = len;
+
+ /*
+ * If report descriptor is not available yet, set maximal
+ * report sizes high enough to allow hidraw to work.
+ */
+ hri->isize = len == 0 ? HID_RSIZE_MAX :
+ hid_report_size_max(data, len, hid_input, &hri->iid);
+ hri->osize = len == 0 ? HID_RSIZE_MAX :
+ hid_report_size_max(data, len, hid_output, &hri->oid);
+ hri->fsize = len == 0 ? HID_RSIZE_MAX :
+ hid_report_size_max(data, len, hid_feature, &hri->fid);
+
+ if (hri->isize > HID_RSIZE_MAX) {
+ DPRINTF("input size is too large, %u bytes (truncating)\n",
+ hri->isize);
+ hri->isize = HID_RSIZE_MAX;
+ error = EOVERFLOW;
+ }
+ if (hri->osize > HID_RSIZE_MAX) {
+ DPRINTF("output size is too large, %u bytes (truncating)\n",
+ hri->osize);
+ hri->osize = HID_RSIZE_MAX;
+ error = EOVERFLOW;
+ }
+ if (hri->fsize > HID_RSIZE_MAX) {
+ DPRINTF("feature size is too large, %u bytes (truncating)\n",
+ hri->fsize);
+ hri->fsize = HID_RSIZE_MAX;
+ error = EOVERFLOW;
+ }
+
+ return (error);
+}
+
+int
+hidbus_locate(const void *desc, hid_size_t size, int32_t u, enum hid_kind k,
+ uint8_t tlc_index, uint8_t index, struct hid_location *loc,
+ uint32_t *flags, uint8_t *id, struct hid_absinfo *ai)
+{
+ struct hid_data *d;
+ struct hid_item h;
+ int i;
+
+ d = hid_start_parse(desc, size, 1 << k);
+ HIDBUS_FOREACH_ITEM(d, &h, tlc_index) {
+ for (i = 0; i < h.nusages; i++) {
+ if (h.kind == k && h.usages[i] == u) {
+ if (index--)
+ break;
+ if (loc != NULL)
+ *loc = h.loc;
+ if (flags != NULL)
+ *flags = h.flags;
+ if (id != NULL)
+ *id = h.report_ID;
+ if (ai != NULL && (h.flags&HIO_RELATIVE) == 0)
+ *ai = (struct hid_absinfo) {
+ .max = h.logical_maximum,
+ .min = h.logical_minimum,
+ .res = hid_item_resolution(&h),
+ };
+ hid_end_parse(d);
+ return (1);
+ }
+ }
+ }
+ if (loc != NULL)
+ loc->size = 0;
+ if (flags != NULL)
+ *flags = 0;
+ if (id != NULL)
+ *id = 0;
+ hid_end_parse(d);
+ return (0);
+}
+
+static device_t
+hidbus_add_child(device_t dev, u_int order, const char *name, int unit)
+{
+ struct hidbus_softc *sc = device_get_softc(dev);
+ struct hidbus_ivars *tlc;
+ device_t child;
+
+ child = device_add_child_ordered(dev, order, name, unit);
+ if (child == NULL)
+ return (child);
+
+ tlc = malloc(sizeof(struct hidbus_ivars), M_DEVBUF, M_WAITOK | M_ZERO);
+ tlc->mtx = &sc->mtx;
+ device_set_ivars(child, tlc);
+ sx_xlock(&sc->sx);
+ CK_STAILQ_INSERT_TAIL(&sc->tlcs, tlc, link);
+ sx_unlock(&sc->sx);
+
+ return (child);
+}
+
+static int
+hidbus_enumerate_children(device_t dev, const void* data, hid_size_t len)
+{
+ struct hidbus_softc *sc = device_get_softc(dev);
+ struct hid_data *hd;
+ struct hid_item hi;
+ device_t child;
+ uint8_t index = 0;
+
+ if (data == NULL || len == 0)
+ return (ENXIO);
+
+ /* Add a child for each top level collection */
+ hd = hid_start_parse(data, len, 1 << hid_input);
+ while (hid_get_item(hd, &hi)) {
+ if (hi.kind != hid_collection || hi.collevel != 1)
+ continue;
+ child = BUS_ADD_CHILD(dev, 0, NULL, -1);
+ if (child == NULL) {
+ device_printf(dev, "Could not add HID device\n");
+ continue;
+ }
+ hidbus_set_index(child, index);
+ hidbus_set_usage(child, hi.usage);
+ hidbus_set_flags(child, HIDBUS_FLAG_AUTOCHILD);
+ index++;
+ DPRINTF("Add child TLC: 0x%04x:0x%04x\n",
+ HID_GET_USAGE_PAGE(hi.usage), HID_GET_USAGE(hi.usage));
+ }
+ hid_end_parse(hd);
+
+ if (index == 0)
+ return (ENXIO);
+
+ sc->nauto = index;
+
+ return (0);
+}
+
+static int
+hidbus_attach_children(device_t dev)
+{
+ struct hidbus_softc *sc = device_get_softc(dev);
+ int error;
+
+ HID_INTR_SETUP(device_get_parent(dev), hidbus_intr, sc, &sc->rdesc);
+
+ error = hidbus_enumerate_children(dev, sc->rdesc.data, sc->rdesc.len);
+ if (error != 0)
+ DPRINTF("failed to enumerate children: error %d\n", error);
+
+ /*
+ * hidbus_attach_children() can recurse through device_identify->
+ * hid_set_report_descr() call sequence. Do not perform children
+ * attach twice in that case.
+ */
+ sc->nest++;
+ bus_generic_probe(dev);
+ sc->nest--;
+ if (sc->nest != 0)
+ return (0);
+
+ if (hid_is_keyboard(sc->rdesc.data, sc->rdesc.len) != 0)
+ error = bus_generic_attach(dev);
+ else
+ error = bus_delayed_attach_children(dev);
+ if (error != 0)
+ device_printf(dev, "failed to attach child: error %d\n", error);
+
+ return (error);
+}
+
+static int
+hidbus_detach_children(device_t dev)
+{
+ device_t *children, bus;
+ bool is_bus;
+ int i, error;
+
+ error = 0;
+
+ is_bus = device_get_devclass(dev) == hidbus_devclass;
+ bus = is_bus ? dev : device_get_parent(dev);
+
+ KASSERT(device_get_devclass(bus) == hidbus_devclass,
+ ("Device is not hidbus or it's child"));
+
+ if (is_bus) {
+ /* If hidbus is passed, delete all children. */
+ bus_generic_detach(bus);
+ device_delete_children(bus);
+ } else {
+ /*
+ * If hidbus child is passed, delete all hidbus children
+ * except caller. Deleting the caller may result in deadlock.
+ */
+ error = device_get_children(bus, &children, &i);
+ if (error != 0)
+ return (error);
+ while (i-- > 0) {
+ if (children[i] == dev)
+ continue;
+ DPRINTF("Delete child. index=%d (%s)\n",
+ hidbus_get_index(children[i]),
+ device_get_nameunit(children[i]));
+ error = device_delete_child(bus, children[i]);
+ if (error) {
+ DPRINTF("Failed deleting %s\n",
+ device_get_nameunit(children[i]));
+ break;
+ }
+ }
+ free(children, M_TEMP);
+ }
+
+ HID_INTR_UNSETUP(device_get_parent(bus));
+
+ return (error);
+}
+
+static int
+hidbus_probe(device_t dev)
+{
+
+ device_set_desc(dev, "HID bus");
+
+ /* Allow other subclasses to override this driver. */
+ return (BUS_PROBE_GENERIC);
+}
+
+static int
+hidbus_attach(device_t dev)
+{
+ struct hidbus_softc *sc = device_get_softc(dev);
+ struct hid_device_info *devinfo = device_get_ivars(dev);
+ void *d_ptr = NULL;
+ hid_size_t d_len;
+ int error;
+
+ sc->dev = dev;
+ CK_STAILQ_INIT(&sc->tlcs);
+ mtx_init(&sc->mtx, "hidbus ivar lock", NULL, MTX_DEF);
+ sx_init(&sc->sx, "hidbus ivar list lock");
+
+ /*
+ * Ignore error. It is possible for non-HID device e.g. XBox360 gamepad
+ * to emulate HID through overloading of report descriptor.
+ */
+ d_len = devinfo->rdescsize;
+ if (d_len != 0) {
+ d_ptr = malloc(d_len, M_DEVBUF, M_ZERO | M_WAITOK);
+ error = hid_get_rdesc(dev, d_ptr, d_len);
+ if (error != 0) {
+ free(d_ptr, M_DEVBUF);
+ d_len = 0;
+ d_ptr = NULL;
+ }
+ }
+
+ hidbus_fill_rdesc_info(&sc->rdesc, d_ptr, d_len);
+
+ sc->nowrite = hid_test_quirk(devinfo, HQ_NOWRITE);
+
+ error = hidbus_attach_children(dev);
+ if (error != 0) {
+ hidbus_detach(dev);
+ return (ENXIO);
+ }
+
+ return (0);
+}
+
+static int
+hidbus_detach(device_t dev)
+{
+ struct hidbus_softc *sc = device_get_softc(dev);
+
+ hidbus_detach_children(dev);
+ sx_destroy(&sc->sx);
+ mtx_destroy(&sc->mtx);
+ free(sc->rdesc.data, M_DEVBUF);
+
+ return (0);
+}
+
+static void
+hidbus_child_detached(device_t bus, device_t child)
+{
+ struct hidbus_softc *sc = device_get_softc(bus);
+ struct hidbus_ivars *tlc = device_get_ivars(child);
+
+ KASSERT(tlc->refcnt == 0, ("Child device is running"));
+ tlc->mtx = &sc->mtx;
+ tlc->intr_handler = NULL;
+ tlc->flags &= ~HIDBUS_FLAG_CAN_POLL;
+}
+
+/*
+ * Epoch callback indicating tlc is safe to destroy
+ */
+static void
+hidbus_ivar_dtor(epoch_context_t ctx)
+{
+ struct hidbus_ivars *tlc;
+
+ tlc = __containerof(ctx, struct hidbus_ivars, epoch_ctx);
+ free(tlc, M_DEVBUF);
+}
+
+static void
+hidbus_child_deleted(device_t bus, device_t child)
+{
+ struct hidbus_softc *sc = device_get_softc(bus);
+ struct hidbus_ivars *tlc = device_get_ivars(child);
+
+ sx_xlock(&sc->sx);
+ KASSERT(tlc->refcnt == 0, ("Child device is running"));
+ CK_STAILQ_REMOVE(&sc->tlcs, tlc, hidbus_ivars, link);
+ sx_unlock(&sc->sx);
+ epoch_call(HIDBUS_EPOCH, hidbus_ivar_dtor, &tlc->epoch_ctx);
+}
+
+static int
+hidbus_read_ivar(device_t bus, device_t child, int which, uintptr_t *result)
+{
+ struct hidbus_softc *sc = device_get_softc(bus);
+ struct hidbus_ivars *tlc = device_get_ivars(child);
+
+ switch (which) {
+ case HIDBUS_IVAR_INDEX:
+ *result = tlc->index;
+ break;
+ case HIDBUS_IVAR_USAGE:
+ *result = tlc->usage;
+ break;
+ case HIDBUS_IVAR_FLAGS:
+ *result = tlc->flags;
+ break;
+ case HIDBUS_IVAR_DRIVER_INFO:
+ *result = tlc->driver_info;
+ break;
+ case HIDBUS_IVAR_LOCK:
+ *result = (uintptr_t)(tlc->mtx == &sc->mtx ? NULL : tlc->mtx);
+ break;
+ default:
+ return (EINVAL);
+ }
+ return (0);
+}
+
+static int
+hidbus_write_ivar(device_t bus, device_t child, int which, uintptr_t value)
+{
+ struct hidbus_softc *sc = device_get_softc(bus);
+ struct hidbus_ivars *tlc = device_get_ivars(child);
+
+ switch (which) {
+ case HIDBUS_IVAR_INDEX:
+ tlc->index = value;
+ break;
+ case HIDBUS_IVAR_USAGE:
+ tlc->usage = value;
+ break;
+ case HIDBUS_IVAR_FLAGS:
+ tlc->flags = value;
+ break;
+ case HIDBUS_IVAR_DRIVER_INFO:
+ tlc->driver_info = value;
+ break;
+ case HIDBUS_IVAR_LOCK:
+ tlc->mtx = (struct mtx *)value == NULL ?
+ &sc->mtx : (struct mtx *)value;
+ break;
+ default:
+ return (EINVAL);
+ }
+ return (0);
+}
+
+/* Location hint for devctl(8) */
+static int
+hidbus_child_location_str(device_t bus, device_t child, char *buf,
+ size_t buflen)
+{
+ struct hidbus_ivars *tlc = device_get_ivars(child);
+
+ snprintf(buf, buflen, "index=%hhu", tlc->index);
+ return (0);
+}
+
+/* PnP information for devctl(8) */
+static int
+hidbus_child_pnpinfo_str(device_t bus, device_t child, char *buf,
+ size_t buflen)
+{
+ struct hidbus_ivars *tlc = device_get_ivars(child);
+ struct hid_device_info *devinfo = device_get_ivars(bus);
+
+ snprintf(buf, buflen, "page=0x%04x usage=0x%04x bus=0x%02hx "
+ "vendor=0x%04hx product=0x%04hx version=0x%04hx%s%s",
+ HID_GET_USAGE_PAGE(tlc->usage), HID_GET_USAGE(tlc->usage),
+ devinfo->idBus, devinfo->idVendor, devinfo->idProduct,
+ devinfo->idVersion, devinfo->idPnP[0] == '\0' ? "" : " _HID=",
+ devinfo->idPnP[0] == '\0' ? "" : devinfo->idPnP);
+ return (0);
+}
+
+void
+hidbus_set_desc(device_t child, const char *suffix)
+{
+ device_t bus = device_get_parent(child);
+ struct hidbus_softc *sc = device_get_softc(bus);
+ struct hid_device_info *devinfo = device_get_ivars(bus);
+ char buf[80];
+
+ /* Do not add NULL suffix or if device name already contains it. */
+ if (suffix != NULL && sc->nauto > 1 &&
+ strcasestr(devinfo->name, suffix) == NULL) {
+ snprintf(buf, sizeof(buf), "%s %s", devinfo->name, suffix);
+ device_set_desc_copy(child, buf);
+ } else
+ device_set_desc(child, devinfo->name);
+}
+
+device_t
+hidbus_find_child(device_t bus, int32_t usage)
+{
+ device_t *children, child;
+ int ccount, i;
+
+ GIANT_REQUIRED;
+
+ /* Get a list of all hidbus children */
+ if (device_get_children(bus, &children, &ccount) != 0)
+ return (NULL);
+
+ /* Scan through to find required TLC */
+ for (i = 0, child = NULL; i < ccount; i++) {
+ if (hidbus_get_usage(children[i]) == usage) {
+ child = children[i];
+ break;
+ }
+ }
+ free(children, M_TEMP);
+
+ return (child);
+}
+
+void
+hidbus_intr(void *context, void *buf, hid_size_t len)
+{
+ struct hidbus_softc *sc = context;
+ struct hidbus_ivars *tlc;
+ struct epoch_tracker et;
+
+ /*
+ * Broadcast input report to all subscribers.
+ * TODO: Add check for input report ID.
+ *
+ * Relock mutex on every TLC item as we can't hold any locks over whole
+ * TLC list here due to LOR with open()/close() handlers.
+ */
+ if (!HID_IN_POLLING_MODE())
+ epoch_enter_preempt(HIDBUS_EPOCH, &et);
+ CK_STAILQ_FOREACH(tlc, &sc->tlcs, link) {
+ if (tlc->refcnt == 0 || tlc->intr_handler == NULL)
+ continue;
+ if (HID_IN_POLLING_MODE()) {
+ if ((tlc->flags & HIDBUS_FLAG_CAN_POLL) != 0)
+ tlc->intr_handler(tlc->intr_ctx, buf, len);
+ } else {
+ mtx_lock(tlc->mtx);
+ tlc->intr_handler(tlc->intr_ctx, buf, len);
+ mtx_unlock(tlc->mtx);
+ }
+ }
+ if (!HID_IN_POLLING_MODE())
+ epoch_exit_preempt(HIDBUS_EPOCH, &et);
+}
+
+void
+hidbus_set_intr(device_t child, hid_intr_t *handler, void *context)
+{
+ struct hidbus_ivars *tlc = device_get_ivars(child);
+
+ tlc->intr_handler = handler;
+ tlc->intr_ctx = context;
+}
+
+int
+hidbus_intr_start(device_t child)
+{
+ device_t 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;
+ int refcnt = 0;
+ int error;
+
+ if (sx_xlock_sig(&sc->sx) != 0)
+ return (EINTR);
+ CK_STAILQ_FOREACH(tlc, &sc->tlcs, link) {
+ refcnt += tlc->refcnt;
+ if (tlc == ivar) {
+ mtx_lock(tlc->mtx);
+ ++tlc->refcnt;
+ mtx_unlock(tlc->mtx);
+ }
+ }
+ error = refcnt != 0 ? 0 : HID_INTR_START(device_get_parent(bus));
+ sx_unlock(&sc->sx);
+
+ return (error);
+}
+
+int
+hidbus_intr_stop(device_t child)
+{
+ device_t 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 refcnt = 0;
+ 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);
+ }
+ refcnt += tlc->refcnt;
+ }
+ error = refcnt != 0 ? 0 : HID_INTR_STOP(device_get_parent(bus));
+ sx_unlock(&sc->sx);
+
+ return (error);
+}
+
+void
+hidbus_intr_poll(device_t child)
+{
+ device_t bus = device_get_parent(child);
+
+ HID_INTR_POLL(device_get_parent(bus));
+}
+
+struct hid_rdesc_info *
+hidbus_get_rdesc_info(device_t child)
+{
+ device_t bus = device_get_parent(child);
+ struct hidbus_softc *sc = device_get_softc(bus);
+
+ return (&sc->rdesc);
+}
+
+/*
+ * HID interface.
+ *
+ * Hidbus as well as any hidbus child can be passed as first arg.
+ */
+
+/* Read cached report descriptor */
+int
+hid_get_report_descr(device_t dev, void **data, hid_size_t *len)
+{
+ device_t bus;
+ struct hidbus_softc *sc;
+
+ bus = device_get_devclass(dev) == hidbus_devclass ?
+ dev : device_get_parent(dev);
+ sc = device_get_softc(bus);
+
+ /*
+ * Do not send request to a transport backend.
+ * Use cached report descriptor instead of it.
+ */
+ if (sc->rdesc.data == NULL || sc->rdesc.len == 0)
+ return (ENXIO);
+
+ if (data != NULL)
+ *data = sc->rdesc.data;
+ if (len != NULL)
+ *len = sc->rdesc.len;
+
+ return (0);
+}
+
+/*
+ * Replace cached report descriptor with top level driver provided one.
+ *
+ * It deletes all hidbus children except caller and enumerates them again after
+ * new descriptor has been registered. Currently it can not be called from
+ * autoenumerated (by report's TLC) child device context as it results in child
+ * duplication. To overcome this limitation hid_set_report_descr() should be
+ * called from device_identify driver's handler with hidbus itself passed as
+ * 'device_t dev' parameter.
+ */
+int
+hid_set_report_descr(device_t dev, const void *data, hid_size_t len)
+{
+ struct hid_rdesc_info rdesc;
+ device_t bus;
+ struct hidbus_softc *sc;
+ bool is_bus;
+ int error;
+
+ GIANT_REQUIRED;
+
+ is_bus = device_get_devclass(dev) == hidbus_devclass;
+ bus = is_bus ? dev : device_get_parent(dev);
+ sc = device_get_softc(bus);
+
+ /*
+ * Do not overload already overloaded report descriptor in
+ * device_identify handler. It causes infinite recursion loop.
+ */
+ if (is_bus && sc->overloaded)
+ return(0);
+
+ DPRINTFN(5, "len=%d\n", len);
+ DPRINTFN(5, "data = %*D\n", len, data, " ");
+
+ error = hidbus_fill_rdesc_info(&rdesc, data, len);
+ if (error != 0)
+ return (error);
+
+ error = hidbus_detach_children(dev);
+ if (error != 0)
+ return(error);
+
+ /* Make private copy to handle a case of dynamicaly allocated data. */
+ rdesc.data = malloc(len, M_DEVBUF, M_ZERO | M_WAITOK);
+ bcopy(data, rdesc.data, len);
+ sc->overloaded = true;
+ free(sc->rdesc.data, M_DEVBUF);
+ bcopy(&rdesc, &sc->rdesc, sizeof(struct hid_rdesc_info));
+
+ error = hidbus_attach_children(bus);
+
+ return (error);
+}
+
+static int
+hidbus_write(device_t dev, const void *data, hid_size_t len)
+{
+ struct hidbus_softc *sc;
+ uint8_t id;
+
+ sc = device_get_softc(dev);
+ /*
+ * Output interrupt endpoint is often optional. If HID device
+ * does not provide it, send reports via control pipe.
+ */
+ if (sc->nowrite) {
+ /* try to extract the ID byte */
+ id = (sc->rdesc.oid & (len > 0)) ? *(const uint8_t*)data : 0;
+ return (hid_set_report(dev, data, len, HID_OUTPUT_REPORT, id));
+ }
+
+ return (hid_write(dev, data, len));
+}
+
+/*------------------------------------------------------------------------*
+ * hidbus_lookup_id
+ *
+ * This functions takes an array of "struct hid_device_id" and tries
+ * to match the entries with the information in "struct hid_device_info".
+ *
+ * Return values:
+ * NULL: No match found.
+ * Else: Pointer to matching entry.
+ *------------------------------------------------------------------------*/
+const struct hid_device_id *
+hidbus_lookup_id(device_t dev, const struct hid_device_id *id, int nitems_id)
+{
+ const struct hid_device_id *id_end;
+ const struct hid_device_info *info;
+ int32_t usage;
+ bool is_child;
+
+ if (id == NULL) {
+ goto done;
+ }
+
+ id_end = id + nitems_id;
+ info = hid_get_device_info(dev);
+ is_child = device_get_devclass(dev) != hidbus_devclass;
+ if (is_child)
+ usage = hidbus_get_usage(dev);
+
+ /*
+ * Keep on matching array entries until we find a match or
+ * until we reach the end of the matching array:
+ */
+ for (; id != id_end; id++) {
+
+ if (is_child && (id->match_flag_page) &&
+ (id->page != HID_GET_USAGE_PAGE(usage))) {
+ continue;
+ }
+ if (is_child && (id->match_flag_usage) &&
+ (id->usage != HID_GET_USAGE(usage))) {
+ continue;
+ }
+ if ((id->match_flag_bus) &&
+ (id->idBus != info->idBus)) {
+ continue;
+ }
+ if ((id->match_flag_vendor) &&
+ (id->idVendor != info->idVendor)) {
+ continue;
+ }
+ if ((id->match_flag_product) &&
+ (id->idProduct != info->idProduct)) {
+ continue;
+ }
+ if ((id->match_flag_ver_lo) &&
+ (id->idVersion_lo > info->idVersion)) {
+ continue;
+ }
+ if ((id->match_flag_ver_hi) &&
+ (id->idVersion_hi < info->idVersion)) {
+ continue;
+ }
+ if (id->match_flag_pnp &&
+ strncmp(id->idPnP, info->idPnP, HID_PNP_ID_SIZE) != 0) {
+ continue;
+ }
+ /* We found a match! */
+ return (id);
+ }
+
+done:
+ return (NULL);
+}
+
+/*------------------------------------------------------------------------*
+ * hidbus_lookup_driver_info - factored out code
+ *
+ * Return values:
+ * 0: Success
+ * Else: Failure
+ *------------------------------------------------------------------------*/
+int
+hidbus_lookup_driver_info(device_t child, const struct hid_device_id *id,
+ int nitems_id)
+{
+
+ id = hidbus_lookup_id(child, id, nitems_id);
+ if (id) {
+ /* copy driver info */
+ hidbus_set_driver_info(child, id->driver_info);
+ return (0);
+ }
+ return (ENXIO);
+}
+
+const struct hid_device_info *
+hid_get_device_info(device_t dev)
+{
+ device_t bus;
+
+ bus = device_get_devclass(dev) == hidbus_devclass ?
+ dev : device_get_parent(dev);
+
+ return (device_get_ivars(bus));
+}
+
+static device_method_t hidbus_methods[] = {
+ /* device interface */
+ DEVMETHOD(device_probe, hidbus_probe),
+ DEVMETHOD(device_attach, hidbus_attach),
+ DEVMETHOD(device_detach, hidbus_detach),
+ DEVMETHOD(device_suspend, bus_generic_suspend),
+ DEVMETHOD(device_resume, bus_generic_resume),
+
+ /* bus interface */
+ DEVMETHOD(bus_add_child, hidbus_add_child),
+ DEVMETHOD(bus_child_detached, hidbus_child_detached),
+ DEVMETHOD(bus_child_deleted, hidbus_child_deleted),
+ DEVMETHOD(bus_read_ivar, hidbus_read_ivar),
+ DEVMETHOD(bus_write_ivar, hidbus_write_ivar),
+ DEVMETHOD(bus_child_pnpinfo_str,hidbus_child_pnpinfo_str),
+ DEVMETHOD(bus_child_location_str,hidbus_child_location_str),
+
+ /* hid interface */
+ DEVMETHOD(hid_get_rdesc, hid_get_rdesc),
+ DEVMETHOD(hid_read, hid_read),
+ DEVMETHOD(hid_write, hidbus_write),
+ DEVMETHOD(hid_get_report, hid_get_report),
+ DEVMETHOD(hid_set_report, hid_set_report),
+ DEVMETHOD(hid_set_idle, hid_set_idle),
+ DEVMETHOD(hid_set_protocol, hid_set_protocol),
+
+ DEVMETHOD_END
+};
+
+devclass_t hidbus_devclass;
+driver_t hidbus_driver = {
+ "hidbus",
+ hidbus_methods,
+ sizeof(struct hidbus_softc),
+};
+
+MODULE_DEPEND(hidbus, hid, 1, 1, 1);
+MODULE_VERSION(hidbus, 1);
+DRIVER_MODULE(hidbus, usbhid, hidbus_driver, hidbus_devclass, 0, 0);
+DRIVER_MODULE(hidbus, iichid, hidbus_driver, hidbus_devclass, 0, 0);
diff --git a/sys/dev/hid/hidmap.h b/sys/dev/hid/hidmap.h
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hidmap.h
@@ -0,0 +1,261 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2020 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.
+ */
+
+#ifndef _HIDMAP_H_
+#define _HIDMAP_H_
+
+#include <sys/param.h>
+
+#include <dev/hid/hid.h>
+
+#define HIDMAP_MAX_MAPS 4
+
+struct hid_device_id;
+struct hidmap_hid_item;
+struct hidmap_item;
+struct hidmap;
+
+enum hidmap_cb_state {
+ HIDMAP_CB_IS_PROBING,
+ HIDMAP_CB_IS_ATTACHING,
+ HIDMAP_CB_IS_RUNNING,
+ HIDMAP_CB_IS_DETACHING,
+};
+
+#define HIDMAP_KEY_NULL 0xFF /* Special event code to discard input */
+
+/* Third parameter of hidmap callback has different type depending on state */
+union hidmap_cb_ctx {
+ struct hid_item *hi; /* Probe- and attach-stage callbacks */
+ int32_t data; /* Run-stage callbacks */
+ uint8_t rid; /* Run-stage finalizing callbacks */
+};
+
+#define HIDMAP_CB_ARGS \
+ struct hidmap *hm, struct hidmap_hid_item *hi, union hidmap_cb_ctx ctx
+typedef int hidmap_cb_t(HIDMAP_CB_ARGS);
+
+/* These helpers can be used at any stage of any callbacks */
+#define HIDMAP_CB_GET_STATE(...) \
+ ((hm == NULL) ? HIDMAP_CB_IS_PROBING : hm->cb_state)
+#define HIDMAP_CB_GET_SOFTC(...) \
+ (hm == NULL ? NULL : device_get_softc(hm->dev))
+#define HIDMAP_CB_GET_EVDEV(...) \
+ (hm == NULL ? NULL : hm->evdev)
+#define HIDMAP_CB_UDATA (hi->udata)
+#define HIDMAP_CB_UDATA64 (hi->udata64)
+/* Special helpers for run-stage of finalizing callbacks */
+#define HIDMAP_CB_GET_RID(...) (ctx.rid)
+#define HIDMAP_CB_GET_DATA(loc) \
+ hid_get_data(hm->intr_buf, hm->intr_len, (loc))
+#define HIDMAP_CB_GET_UDATA(loc) \
+ hid_get_udata(hm->intr_buf, hm->intr_len, (loc))
+
+enum hidmap_relabs {
+ HIDMAP_RELABS_ANY = 0,
+ HIDMAP_RELATIVE,
+ HIDMAP_ABSOLUTE,
+};
+
+struct hidmap_item {
+ union {
+ struct {
+ uint16_t type; /* Evdev event type */
+ uint16_t code; /* Evdev event code */
+ uint16_t fuzz; /* Evdev event fuzz */
+ uint16_t flat; /* Evdev event flat */
+ };
+ hidmap_cb_t *cb; /* Reporting callback */
+ };
+ int32_t usage; /* HID usage (base) */
+ uint16_t nusages; /* number of usages */
+ bool required:1; /* Required by driver */
+ enum hidmap_relabs relabs:2;
+ bool has_cb:1;
+ bool final_cb:1;
+ bool invert_value:1;
+ u_int reserved:10;
+};
+
+#define HIDMAP_ANY(_page, _usage, _type, _code) \
+ .usage = HID_USAGE2((_page), (_usage)), \
+ .nusages = 1, \
+ .type = (_type), \
+ .code = (_code)
+#define HIDMAP_ANY_RANGE(_page, _usage_from, _usage_to, _type, _code) \
+ .usage = HID_USAGE2((_page), (_usage_from)), \
+ .nusages = (_usage_to) - (_usage_from) + 1, \
+ .type = (_type), \
+ .code = (_code)
+#define HIDMAP_ANY_CB(_page, _usage, _callback) \
+ .usage = HID_USAGE2((_page), (_usage)), \
+ .nusages = 1, \
+ .cb = (_callback), \
+ .has_cb = true
+#define HIDMAP_ANY_CB_RANGE(_page, _usage_from, _usage_to, _callback) \
+ .usage = HID_USAGE2((_page), (_usage_from)), \
+ .nusages = (_usage_to) - (_usage_from) + 1, \
+ .cb = (_callback), \
+ .has_cb = true
+#define HIDMAP_KEY(_page, _usage, _code) \
+ HIDMAP_ANY((_page), (_usage), EV_KEY, (_code)), \
+ .relabs = HIDMAP_RELABS_ANY
+#define HIDMAP_KEY_RANGE(_page, _ufrom, _uto, _code) \
+ HIDMAP_ANY_RANGE((_page), (_ufrom), (_uto), EV_KEY, (_code)), \
+ .relabs = HIDMAP_RELABS_ANY
+#define HIDMAP_REL(_page, _usage, _code) \
+ HIDMAP_ANY((_page), (_usage), EV_REL, (_code)), \
+ .relabs = HIDMAP_RELATIVE
+#define HIDMAP_ABS(_page, _usage, _code) \
+ HIDMAP_ANY((_page), (_usage), EV_ABS, (_code)), \
+ .relabs = HIDMAP_ABSOLUTE
+#define HIDMAP_SW(_page, _usage, _code) \
+ HIDMAP_ANY((_page), (_usage), EV_SW, (_code)), \
+ .relabs = HIDMAP_RELABS_ANY
+#define HIDMAP_REL_CB(_page, _usage, _callback) \
+ HIDMAP_ANY_CB((_page), (_usage), (_callback)), \
+ .relabs = HIDMAP_RELATIVE
+#define HIDMAP_ABS_CB(_page, _usage, _callback) \
+ HIDMAP_ANY_CB((_page), (_usage), (_callback)), \
+ .relabs = HIDMAP_ABSOLUTE
+/*
+ * Special callback function which is not tied to particular HID input usage
+ * but called at the end evdev properties setting or interrupt handler
+ * just before evdev_register() or evdev_sync() calls.
+ */
+#define HIDMAP_FINAL_CB(_callback) \
+ HIDMAP_ANY_CB(0, 0, (_callback)), .final_cb = true
+
+enum hidmap_type {
+ HIDMAP_TYPE_FINALCB = 0,/* No HID item associated. Runs unconditionally
+ * at the end of other items processing */
+ HIDMAP_TYPE_CALLBACK, /* HID item is reported with user callback */
+ HIDMAP_TYPE_VARIABLE, /* HID item is variable (single usage) */
+ HIDMAP_TYPE_VAR_NULLST, /* HID item is null state variable */
+ HIDMAP_TYPE_ARR_LIST, /* HID item is array with list of usages */
+ HIDMAP_TYPE_ARR_RANGE, /* Array with range (min;max) of usages */
+};
+
+struct hidmap_hid_item {
+ union {
+ hidmap_cb_t *cb; /* Callback */
+ struct { /* Variable */
+ uint16_t evtype; /* Evdev event type */
+ uint16_t code; /* Evdev event code */
+ };
+ uint16_t *codes; /* Array list map type */
+ int32_t umin; /* Array range map type */
+ };
+ union {
+ void *udata; /* Callback private context */
+ uint64_t udata64;
+ int32_t last_val; /* Last reported value (var) */
+ uint16_t last_key; /* Last reported key (array) */
+ };
+ struct hid_location loc; /* HID item location */
+ int32_t lmin; /* HID item logical minimum */
+ int32_t lmax; /* HID item logical maximum */
+ enum hidmap_type type:8;
+ uint8_t id; /* Report ID */
+ bool invert_value;
+};
+
+struct hidmap {
+ device_t dev;
+
+ struct evdev_dev *evdev;
+ struct evdev_methods evdev_methods;
+
+ /* Scatter-gather list of maps */
+ int nmaps;
+ uint32_t nmap_items[HIDMAP_MAX_MAPS];
+ const struct hidmap_item *map[HIDMAP_MAX_MAPS];
+
+ /* List of preparsed HID items */
+ uint32_t nhid_items;
+ struct hidmap_hid_item *hid_items;
+
+ /* Key event merging buffers */
+ uint8_t *key_press;
+ uint8_t *key_rel;
+ uint16_t key_min;
+ uint16_t key_max;
+
+ int *debug_var;
+ int debug_level;
+ enum hidmap_cb_state cb_state;
+ void * intr_buf;
+ hid_size_t intr_len;
+};
+
+typedef uint8_t * hidmap_caps_t;
+#define HIDMAP_CAPS_SZ(nitems) howmany((nitems), 8)
+#define HIDMAP_CAPS(name, map) uint8_t (name)[HIDMAP_CAPS_SZ(nitems(map))]
+static inline bool
+hidmap_test_cap(hidmap_caps_t caps, int cap)
+{
+ return (isset(caps, cap) != 0);
+}
+
+/*
+ * It is safe to call any of following procedures in device_probe context
+ * that makes possible to write probe-only drivers with attach/detach handlers
+ * inherited from hidmap. See hcons and hsctrl drivers for example.
+ */
+static inline void
+hidmap_set_dev(struct hidmap *hm, device_t dev)
+{
+ hm->dev = dev;
+}
+
+/* Hack to avoid #ifdef-ing of hidmap_set_debug_var in hidmap based drivers */
+#ifdef HID_DEBUG
+#define hidmap_set_debug_var(h, d) _hidmap_set_debug_var((h), (d))
+#else
+#define hidmap_set_debug_var(...)
+#endif
+void _hidmap_set_debug_var(struct hidmap *hm, int *debug_var);
+#define HIDMAP_ADD_MAP(hm, map, caps) \
+ hidmap_add_map((hm), (map), nitems(map), (caps))
+uint32_t hidmap_add_map(struct hidmap *hm, const struct hidmap_item *map,
+ int nitems_map, hidmap_caps_t caps);
+
+/* Versions of evdev_* functions capable to merge key events with same codes */
+void hidmap_support_key(struct hidmap *hm, uint16_t key);
+void hidmap_push_key(struct hidmap *hm, uint16_t key, int32_t value);
+
+#define HIDMAP_PROBE(hm, dev, id, map, suffix) \
+ hidmap_probe((hm), (dev), (id), nitems(id), (map), nitems(map), \
+ (suffix), NULL)
+int hidmap_probe(struct hidmap* hm, device_t dev,
+ const struct hid_device_id *id, int nitems_id,
+ const struct hidmap_item *map, int nitems_map,
+ const char *suffix, hidmap_caps_t caps);
+int hidmap_attach(struct hidmap *hm);
+int hidmap_detach(struct hidmap *hm);
+
+#endif /* _HIDMAP_H_ */
diff --git a/sys/dev/hid/hidmap.c b/sys/dev/hid/hidmap.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hidmap.c
@@ -0,0 +1,829 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2020 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 <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * Abstract 1 to 1 HID input usage to evdev event mapper driver.
+ */
+
+#include <sys/param.h>
+#include <sys/bus.h>
+#include <sys/kernel.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/module.h>
+#include <sys/sysctl.h>
+#include <sys/systm.h>
+
+#include <dev/evdev/input.h>
+#include <dev/evdev/evdev.h>
+
+#include <dev/hid/hid.h>
+#include <dev/hid/hidbus.h>
+#include <dev/hid/hidmap.h>
+
+#ifdef HID_DEBUG
+#define DPRINTFN(hm, n, fmt, ...) do { \
+ if ((hm)->debug_var != NULL && *(hm)->debug_var >= (n)) { \
+ device_printf((hm)->dev, "%s: " fmt, \
+ __FUNCTION__ ,##__VA_ARGS__); \
+ } \
+} while (0)
+#define DPRINTF(hm, ...) DPRINTFN(hm, 1, __VA_ARGS__)
+#else
+#define DPRINTF(...) do { } while (0)
+#define DPRINTFN(...) do { } while (0)
+#endif
+
+static evdev_open_t hidmap_ev_open;
+static evdev_close_t hidmap_ev_close;
+
+#define HIDMAP_WANT_MERGE_KEYS(hm) ((hm)->key_rel != NULL)
+
+#define HIDMAP_FOREACH_ITEM(hm, mi, uoff) \
+ for (u_int _map = 0, _item = 0, _uoff_priv = -1; \
+ ((mi) = hidmap_get_next_map_item( \
+ (hm), &_map, &_item, &_uoff_priv, &(uoff))) != NULL;)
+
+static inline bool
+hidmap_get_next_map_index(const struct hidmap_item *map, int nmap_items,
+ uint32_t *index, uint16_t *usage_offset)
+{
+
+ ++*usage_offset;
+ if ((*index != 0 || *usage_offset != 0) &&
+ *usage_offset >= map[*index].nusages) {
+ ++*index;
+ *usage_offset = 0;
+ }
+
+ return (*index < nmap_items);
+}
+
+static inline const struct hidmap_item *
+hidmap_get_next_map_item(struct hidmap *hm, u_int *map, u_int *item,
+ u_int *uoff_priv, uint16_t *uoff)
+{
+
+ *uoff = *uoff_priv;
+ while (!hidmap_get_next_map_index(
+ hm->map[*map], hm->nmap_items[*map], item, uoff)) {
+ ++*map;
+ *item = 0;
+ *uoff = -1;
+ if (*map >= hm->nmaps)
+ return (NULL);
+ }
+ *uoff_priv = *uoff;
+
+ return (hm->map[*map] + *item);
+}
+
+void
+_hidmap_set_debug_var(struct hidmap *hm, int *debug_var)
+{
+#ifdef HID_DEBUG
+ hm->debug_var = debug_var;
+#endif
+}
+
+static int
+hidmap_ev_close(struct evdev_dev *evdev)
+{
+ return (hidbus_intr_stop(evdev_get_softc(evdev)));
+}
+
+static int
+hidmap_ev_open(struct evdev_dev *evdev)
+{
+ return (hidbus_intr_start(evdev_get_softc(evdev)));
+}
+
+void
+hidmap_support_key(struct hidmap *hm, uint16_t key)
+{
+ if (hm->key_press == NULL) {
+ hm->key_press = malloc(howmany(KEY_CNT, 8), M_DEVBUF,
+ M_ZERO | M_WAITOK);
+ evdev_support_event(hm->evdev, EV_KEY);
+ hm->key_min = key;
+ hm->key_max = key;
+ }
+ hm->key_min = MIN(hm->key_min, key);
+ hm->key_max = MAX(hm->key_max, key);
+ if (isset(hm->key_press, key)) {
+ if (hm->key_rel == NULL)
+ hm->key_rel = malloc(howmany(KEY_CNT, 8), M_DEVBUF,
+ M_ZERO | M_WAITOK);
+ } else {
+ setbit(hm->key_press, key);
+ evdev_support_key(hm->evdev, key);
+ }
+}
+
+void
+hidmap_push_key(struct hidmap *hm, uint16_t key, int32_t value)
+{
+ if (HIDMAP_WANT_MERGE_KEYS(hm))
+ setbit(value != 0 ? hm->key_press : hm->key_rel, key);
+ else
+ evdev_push_key(hm->evdev, key, value);
+}
+
+static void
+hidmap_sync_keys(struct hidmap *hm)
+{
+ int i, j;
+ bool press, rel;
+
+ for (j = hm->key_min / 8; j <= hm->key_max / 8; j++) {
+ if (hm->key_press[j] != hm->key_rel[j]) {
+ for (i = j * 8; i < j * 8 + 8; i++) {
+ press = isset(hm->key_press, i);
+ rel = isset(hm->key_rel, i);
+ if (press != rel)
+ evdev_push_key(hm->evdev, i, press);
+ }
+ }
+ }
+ bzero(hm->key_press, howmany(KEY_CNT, 8));
+ bzero(hm->key_rel, howmany(KEY_CNT, 8));
+}
+
+static void
+hidmap_intr(void *context, void *buf, hid_size_t len)
+{
+ struct hidmap *hm = context;
+ struct hidmap_hid_item *hi;
+ const struct hidmap_item *mi;
+ int32_t usage;
+ int32_t data;
+ uint16_t key, uoff;
+ uint8_t id = 0;
+ bool found, do_sync = false;
+
+ DPRINTFN(hm, 6, "hm=%p len=%d\n", hm, len);
+ DPRINTFN(hm, 6, "data = %*D\n", len, buf, " ");
+
+ /* Strip leading "report ID" byte */
+ if (hm->hid_items[0].id) {
+ id = *(uint8_t *)buf;
+ len--;
+ buf = (uint8_t *)buf + 1;
+ }
+
+ hm->intr_buf = buf;
+ hm->intr_len = len;
+
+ for (hi = hm->hid_items; hi < hm->hid_items + hm->nhid_items; hi++) {
+ /* At first run callbacks that not tied to HID items */
+ if (hi->type == HIDMAP_TYPE_FINALCB) {
+ DPRINTFN(hm, 6, "type=%d item=%*D\n", hi->type,
+ (int)sizeof(hi->cb), &hi->cb, " ");
+ if (hi->cb(hm, hi, (union hidmap_cb_ctx){.rid = id})
+ == 0)
+ do_sync = true;
+ continue;
+ }
+
+ /* Ignore irrelevant reports */
+ if (id != hi->id)
+ continue;
+
+ /*
+ * 5.8. If Logical Minimum and Logical Maximum are both
+ * positive values then the contents of a field can be assumed
+ * to be an unsigned value. Otherwise, all integer values are
+ * signed values represented in 2’s complement format.
+ */
+ data = hi->lmin < 0 || hi->lmax < 0
+ ? hid_get_data(buf, len, &hi->loc)
+ : hid_get_udata(buf, len, &hi->loc);
+
+ DPRINTFN(hm, 6, "type=%d data=%d item=%*D\n", hi->type, data,
+ (int)sizeof(hi->cb), &hi->cb, " ");
+
+ if (hi->invert_value && hi->type < HIDMAP_TYPE_ARR_LIST)
+ data = hi->evtype == EV_REL
+ ? -data
+ : hi->lmin + hi->lmax - data;
+
+ switch (hi->type) {
+ case HIDMAP_TYPE_CALLBACK:
+ if (hi->cb(hm, hi, (union hidmap_cb_ctx){.data = data})
+ != 0)
+ continue;
+ break;
+
+ case HIDMAP_TYPE_VAR_NULLST:
+ /*
+ * 5.10. If the host or the device receives an
+ * out-of-range value then the current value for the
+ * respective control will not be modified.
+ */
+ if (data < hi->lmin || data > hi->lmax)
+ continue;
+ /* FALLTHROUGH */
+ case HIDMAP_TYPE_VARIABLE:
+ /*
+ * Ignore reports for absolute data if the data did not
+ * change and for relative data if data is 0.
+ * Evdev layer filters out them anyway.
+ */
+ if (data == (hi->evtype == EV_REL ? 0 : hi->last_val))
+ continue;
+ if (hi->evtype == EV_KEY)
+ hidmap_push_key(hm, hi->code, data);
+ else
+ evdev_push_event(hm->evdev, hi->evtype,
+ hi->code, data);
+ hi->last_val = data;
+ break;
+
+ case HIDMAP_TYPE_ARR_LIST:
+ key = KEY_RESERVED;
+ /*
+ * 6.2.2.5. An out-of range value in an array field
+ * is considered no controls asserted.
+ */
+ if (data < hi->lmin || data > hi->lmax)
+ goto report_key;
+ /*
+ * 6.2.2.5. Rather than returning a single bit for each
+ * button in the group, an array returns an index in
+ * each field that corresponds to the pressed button.
+ */
+ key = hi->codes[data - hi->lmin];
+ if (key == KEY_RESERVED)
+ DPRINTF(hm, "Can not map unknown HID "
+ "array index: %08x\n", data);
+ goto report_key;
+
+ case HIDMAP_TYPE_ARR_RANGE:
+ key = KEY_RESERVED;
+ /*
+ * 6.2.2.5. An out-of range value in an array field
+ * is considered no controls asserted.
+ */
+ if (data < hi->lmin || data > hi->lmax)
+ goto report_key;
+ /*
+ * When the input field is an array and the usage is
+ * specified with a range instead of an ID, we have to
+ * derive the actual usage by using the item value as
+ * an index in the usage range list.
+ */
+ usage = data - hi->lmin + hi->umin;
+ found = false;
+ HIDMAP_FOREACH_ITEM(hm, mi, uoff) {
+ if (usage == mi->usage + uoff &&
+ mi->type == EV_KEY && !mi->has_cb) {
+ key = mi->code;
+ found = true;
+ break;
+ }
+ }
+ if (!found)
+ DPRINTF(hm, "Can not map unknown HID "
+ "usage: %08x\n", usage);
+report_key:
+ if (key == HIDMAP_KEY_NULL || key == hi->last_key)
+ continue;
+ if (hi->last_key != KEY_RESERVED)
+ hidmap_push_key(hm, hi->last_key, 0);
+ if (key != KEY_RESERVED)
+ hidmap_push_key(hm, key, 1);
+ hi->last_key = key;
+ break;
+
+ default:
+ KASSERT(0, ("Unknown map type (%d)", hi->type));
+ }
+ do_sync = true;
+ }
+
+ if (do_sync) {
+ if (HIDMAP_WANT_MERGE_KEYS(hm))
+ hidmap_sync_keys(hm);
+ evdev_sync(hm->evdev);
+ }
+}
+
+static inline bool
+can_map_callback(struct hid_item *hi, const struct hidmap_item *mi,
+ uint16_t usage_offset)
+{
+
+ return (mi->has_cb && !mi->final_cb &&
+ hi->usage == mi->usage + usage_offset &&
+ (mi->relabs == HIDMAP_RELABS_ANY ||
+ !(hi->flags & HIO_RELATIVE) == !(mi->relabs == HIDMAP_RELATIVE)));
+}
+
+static inline bool
+can_map_variable(struct hid_item *hi, const struct hidmap_item *mi,
+ uint16_t usage_offset)
+{
+
+ return ((hi->flags & HIO_VARIABLE) != 0 && !mi->has_cb &&
+ hi->usage == mi->usage + usage_offset &&
+ (mi->relabs == HIDMAP_RELABS_ANY ||
+ !(hi->flags & HIO_RELATIVE) == !(mi->relabs == HIDMAP_RELATIVE)));
+}
+
+static inline bool
+can_map_arr_range(struct hid_item *hi, const struct hidmap_item *mi,
+ uint16_t usage_offset)
+{
+
+ return ((hi->flags & HIO_VARIABLE) == 0 && !mi->has_cb &&
+ hi->usage_minimum <= mi->usage + usage_offset &&
+ hi->usage_maximum >= mi->usage + usage_offset &&
+ mi->type == EV_KEY &&
+ (mi->code != KEY_RESERVED && mi->code != HIDMAP_KEY_NULL));
+}
+
+static inline bool
+can_map_arr_list(struct hid_item *hi, const struct hidmap_item *mi,
+ uint32_t usage, uint16_t usage_offset)
+{
+
+ return ((hi->flags & HIO_VARIABLE) == 0 && !mi->has_cb &&
+ usage == mi->usage + usage_offset &&
+ mi->type == EV_KEY &&
+ (mi->code != KEY_RESERVED && mi->code != HIDMAP_KEY_NULL));
+}
+
+static bool
+hidmap_probe_hid_item(struct hid_item *hi, const struct hidmap_item *map,
+ int nitems_map, hidmap_caps_t caps)
+{
+ u_int i, j;
+ uint16_t uoff;
+ bool found = false;
+
+#define HIDMAP_FOREACH_INDEX(map, nitems, idx, uoff) \
+ for ((idx) = 0, (uoff) = -1; \
+ hidmap_get_next_map_index((map), (nitems), &(idx), &(uoff));)
+
+ HIDMAP_FOREACH_INDEX(map, nitems_map, i, uoff) {
+ if (can_map_callback(hi, map + i, uoff)) {
+ if (map[i].cb(NULL, NULL,
+ (union hidmap_cb_ctx){.hi = hi}) != 0)
+ break;
+ setbit(caps, i);
+ return (true);
+ }
+ }
+
+ if (hi->flags & HIO_VARIABLE) {
+ HIDMAP_FOREACH_INDEX(map, nitems_map, i, uoff) {
+ if (can_map_variable(hi, map + i, uoff)) {
+ KASSERT(map[i].type == EV_KEY ||
+ map[i].type == EV_REL ||
+ map[i].type == EV_ABS ||
+ map[i].type == EV_SW,
+ ("Unsupported event type"));
+ setbit(caps, i);
+ return (true);
+ }
+ }
+ return (false);
+ }
+
+ if (hi->usage_minimum != 0 || hi->usage_maximum != 0) {
+ HIDMAP_FOREACH_INDEX(map, nitems_map, i, uoff) {
+ if (can_map_arr_range(hi, map + i, uoff)) {
+ setbit(caps, i);
+ found = true;
+ }
+ }
+ return (found);
+ }
+
+ for (j = 0; j < hi->nusages; j++) {
+ HIDMAP_FOREACH_INDEX(map, nitems_map, i, uoff) {
+ if (can_map_arr_list(hi, map+i, hi->usages[j], uoff)) {
+ setbit(caps, i);
+ found = true;
+ }
+ }
+ }
+
+ return (found);
+}
+
+static uint32_t
+hidmap_probe_hid_descr(void *d_ptr, hid_size_t d_len, uint8_t tlc_index,
+ const struct hidmap_item *map, int nitems_map, hidmap_caps_t caps)
+{
+ struct hid_data *hd;
+ struct hid_item hi;
+ uint32_t i, items = 0;
+ bool do_free = false;
+
+ if (caps == NULL) {
+ caps = malloc(HIDMAP_CAPS_SZ(nitems_map), M_DEVBUF, M_WAITOK);
+ do_free = true;
+ } else
+ bzero (caps, HIDMAP_CAPS_SZ(nitems_map));
+
+ /* Parse inputs */
+ hd = hid_start_parse(d_ptr, d_len, 1 << hid_input);
+ HIDBUS_FOREACH_ITEM(hd, &hi, tlc_index) {
+ if (hi.kind != hid_input)
+ continue;
+ if (hi.flags & HIO_CONST)
+ continue;
+ for (i = 0; i < hi.loc.count; i++, hi.loc.pos += hi.loc.size)
+ if (hidmap_probe_hid_item(&hi, map, nitems_map, caps))
+ items++;
+ }
+ hid_end_parse(hd);
+
+ /* Take finalizing callbacks in to account */
+ for (i = 0; i < nitems_map; i++) {
+ if (map[i].has_cb && map[i].final_cb &&
+ map[i].cb(NULL, NULL, (union hidmap_cb_ctx){}) == 0) {
+ setbit(caps, i);
+ items++;
+ }
+ }
+
+ /* Check that all mandatory usages are present in report descriptor */
+ if (items != 0) {
+ for (i = 0; i < nitems_map; i++) {
+ if (map[i].required && isclr(caps, i)) {
+ items = 0;
+ break;
+ }
+ }
+ }
+
+ if (do_free)
+ free(caps, M_DEVBUF);
+
+ return (items);
+}
+
+uint32_t
+hidmap_add_map(struct hidmap *hm, const struct hidmap_item *map,
+ int nitems_map, hidmap_caps_t caps)
+{
+ void *d_ptr;
+ uint32_t items;
+ int i, error;
+ hid_size_t d_len;
+ uint8_t tlc_index = hidbus_get_index(hm->dev);
+
+ /* Avoid double-adding of map in probe() handler */
+ for (i = 0; i < hm->nmaps; i++)
+ if (hm->map[i] == map)
+ return (0);
+
+ error = hid_get_report_descr(hm->dev, &d_ptr, &d_len);
+ if (error != 0) {
+ device_printf(hm->dev, "could not retrieve report descriptor "
+ "from device: %d\n", error);
+ return (error);
+ }
+
+ hm->cb_state = HIDMAP_CB_IS_PROBING;
+ items = hidmap_probe_hid_descr(d_ptr, d_len, tlc_index, map,
+ nitems_map, caps);
+ if (items == 0)
+ return (ENXIO);
+
+ KASSERT(hm->nmaps < HIDMAP_MAX_MAPS,
+ ("Not more than %d maps is supported", HIDMAP_MAX_MAPS));
+ hm->nhid_items += items;
+ hm->map[hm->nmaps] = map;
+ hm->nmap_items[hm->nmaps] = nitems_map;
+ hm->nmaps++;
+
+ return (0);
+}
+
+static bool
+hidmap_parse_hid_item(struct hidmap *hm, struct hid_item *hi,
+ struct hidmap_hid_item *item)
+{
+ const struct hidmap_item *mi;
+ struct hidmap_hid_item hi_temp;
+ uint32_t i;
+ uint16_t uoff;
+ bool found = false;
+
+ HIDMAP_FOREACH_ITEM(hm, mi, uoff) {
+ if (can_map_callback(hi, mi, uoff)) {
+ bzero(&hi_temp, sizeof(hi_temp));
+ hi_temp.cb = mi->cb;
+ hi_temp.type = HIDMAP_TYPE_CALLBACK;
+ /*
+ * Values returned by probe- and attach-stage
+ * callbacks MUST be identical.
+ */
+ if (mi->cb(hm, &hi_temp,
+ (union hidmap_cb_ctx){.hi = hi}) != 0)
+ break;
+ bcopy(&hi_temp, item, sizeof(hi_temp));
+ goto mapped;
+ }
+ }
+
+ if (hi->flags & HIO_VARIABLE) {
+ HIDMAP_FOREACH_ITEM(hm, mi, uoff) {
+ if (can_map_variable(hi, mi, uoff)) {
+ item->evtype = mi->type;
+ item->code = mi->code + uoff;
+ item->type = hi->flags & HIO_NULLSTATE
+ ? HIDMAP_TYPE_VAR_NULLST
+ : HIDMAP_TYPE_VARIABLE;
+ item->last_val = 0;
+ item->invert_value = mi->invert_value;
+ switch (mi->type) {
+ case EV_KEY:
+ hidmap_support_key(hm, item->code);
+ break;
+ case EV_REL:
+ evdev_support_event(hm->evdev, EV_REL);
+ evdev_support_rel(hm->evdev,
+ item->code);
+ break;
+ case EV_ABS:
+ evdev_support_event(hm->evdev, EV_ABS);
+ evdev_support_abs(hm->evdev,
+ item->code,
+ hi->logical_minimum,
+ hi->logical_maximum,
+ mi->fuzz,
+ mi->flat,
+ hid_item_resolution(hi));
+ break;
+ case EV_SW:
+ evdev_support_event(hm->evdev, EV_SW);
+ evdev_support_sw(hm->evdev,
+ item->code);
+ break;
+ default:
+ KASSERT(0, ("Unsupported event type"));
+ }
+ goto mapped;
+ }
+ }
+ return (false);
+ }
+
+ if (hi->usage_minimum != 0 || hi->usage_maximum != 0) {
+ HIDMAP_FOREACH_ITEM(hm, mi, uoff) {
+ if (can_map_arr_range(hi, mi, uoff)) {
+ hidmap_support_key(hm, mi->code + uoff);
+ found = true;
+ }
+ }
+ if (!found)
+ return (false);
+ item->umin = hi->usage_minimum;
+ item->type = HIDMAP_TYPE_ARR_RANGE;
+ item->last_key = KEY_RESERVED;
+ goto mapped;
+ }
+
+ for (i = 0; i < hi->nusages; i++) {
+ HIDMAP_FOREACH_ITEM(hm, mi, uoff) {
+ if (can_map_arr_list(hi, mi, hi->usages[i], uoff)) {
+ hidmap_support_key(hm, mi->code + uoff);
+ if (item->codes == NULL)
+ item->codes = malloc(
+ hi->nusages * sizeof(uint16_t),
+ M_DEVBUF, M_WAITOK | M_ZERO);
+ item->codes[i] = mi->code + uoff;
+ found = true;
+ break;
+ }
+ }
+ }
+ if (!found)
+ return (false);
+ item->type = HIDMAP_TYPE_ARR_LIST;
+ item->last_key = KEY_RESERVED;
+
+mapped:
+ item->id = hi->report_ID;
+ item->loc = hi->loc;
+ item->loc.count = 1;
+ item->lmin = hi->logical_minimum;
+ item->lmax = hi->logical_maximum;
+
+ DPRINTFN(hm, 6, "usage=%04x id=%d loc=%u/%u type=%d item=%*D\n",
+ hi->usage, hi->report_ID, hi->loc.pos, hi->loc.size, item->type,
+ (int)sizeof(item->cb), &item->cb, " ");
+
+ return (true);
+}
+
+static int
+hidmap_parse_hid_descr(struct hidmap *hm, uint8_t tlc_index)
+{
+ const struct hidmap_item *map;
+ struct hidmap_hid_item *item = hm->hid_items;
+ void *d_ptr;
+ struct hid_data *hd;
+ struct hid_item hi;
+ int i, error;
+ hid_size_t d_len;
+
+ error = hid_get_report_descr(hm->dev, &d_ptr, &d_len);
+ if (error != 0) {
+ DPRINTF(hm, "could not retrieve report descriptor from "
+ "device: %d\n", error);
+ return (error);
+ }
+
+ /* Parse inputs */
+ hd = hid_start_parse(d_ptr, d_len, 1 << hid_input);
+ HIDBUS_FOREACH_ITEM(hd, &hi, tlc_index) {
+ if (hi.kind != hid_input)
+ continue;
+ if (hi.flags & HIO_CONST)
+ continue;
+ for (i = 0; i < hi.loc.count; i++, hi.loc.pos += hi.loc.size)
+ if (hidmap_parse_hid_item(hm, &hi, item))
+ item++;
+ KASSERT(item <= hm->hid_items + hm->nhid_items,
+ ("Parsed HID item array overflow"));
+ }
+ hid_end_parse(hd);
+
+ /* Add finalizing callbacks to the end of list */
+ for (i = 0; i < hm->nmaps; i++) {
+ for (map = hm->map[i];
+ map < hm->map[i] + hm->nmap_items[i];
+ map++) {
+ if (map->has_cb && map->final_cb &&
+ map->cb(hm, item, (union hidmap_cb_ctx){}) == 0) {
+ item->cb = map->cb;
+ item->type = HIDMAP_TYPE_FINALCB;
+ item++;
+ }
+ }
+ }
+
+ /*
+ * Resulting number of parsed HID items can be less than expected as
+ * map items might be duplicated in different maps. Save real number.
+ */
+ if (hm->nhid_items != item - hm->hid_items)
+ DPRINTF(hm, "Parsed HID item number mismatch: expected=%u "
+ "result=%td\n", hm->nhid_items, item - hm->hid_items);
+ hm->nhid_items = item - hm->hid_items;
+
+ if (HIDMAP_WANT_MERGE_KEYS(hm))
+ bzero(hm->key_press, howmany(KEY_CNT, 8));
+
+ return (0);
+}
+
+int
+hidmap_probe(struct hidmap* hm, device_t dev,
+ const struct hid_device_id *id, int nitems_id,
+ const struct hidmap_item *map, int nitems_map,
+ const char *suffix, hidmap_caps_t caps)
+{
+ int error;
+
+ error = hidbus_lookup_driver_info(dev, id, nitems_id);
+ if (error != 0)
+ return (error);
+
+ hidmap_set_dev(hm, dev);
+
+ error = hidmap_add_map(hm, map, nitems_map, caps);
+ if (error != 0)
+ return (error);
+
+ hidbus_set_desc(dev, suffix);
+
+ return (BUS_PROBE_DEFAULT);
+}
+
+int
+hidmap_attach(struct hidmap* hm)
+{
+ const struct hid_device_info *hw = hid_get_device_info(hm->dev);
+#ifdef HID_DEBUG
+ char tunable[40];
+#endif
+ int error;
+
+#ifdef HID_DEBUG
+ if (hm->debug_var == NULL) {
+ hm->debug_var = &hm->debug_level;
+ snprintf(tunable, sizeof(tunable), "hw.hid.%s.debug",
+ device_get_name(hm->dev));
+ TUNABLE_INT_FETCH(tunable, &hm->debug_level);
+ SYSCTL_ADD_INT(device_get_sysctl_ctx(hm->dev),
+ SYSCTL_CHILDREN(device_get_sysctl_tree(hm->dev)),
+ OID_AUTO, "debug", CTLTYPE_INT | CTLFLAG_RWTUN,
+ &hm->debug_level, 0, "Verbosity level");
+ }
+#endif
+
+ DPRINTFN(hm, 11, "hm=%p\n", hm);
+
+ hm->cb_state = HIDMAP_CB_IS_ATTACHING;
+
+ hm->hid_items = malloc(hm->nhid_items * sizeof(struct hid_item),
+ M_DEVBUF, M_WAITOK | M_ZERO);
+
+ hidbus_set_intr(hm->dev, hidmap_intr, hm);
+ hm->evdev_methods = (struct evdev_methods) {
+ .ev_open = &hidmap_ev_open,
+ .ev_close = &hidmap_ev_close,
+ };
+
+ hm->evdev = evdev_alloc();
+ evdev_set_name(hm->evdev, device_get_desc(hm->dev));
+ evdev_set_phys(hm->evdev, device_get_nameunit(hm->dev));
+ evdev_set_id(hm->evdev, hw->idBus, hw->idVendor, hw->idProduct,
+ hw->idVersion);
+ evdev_set_serial(hm->evdev, hw->serial);
+ evdev_support_event(hm->evdev, EV_SYN);
+ error = hidmap_parse_hid_descr(hm, hidbus_get_index(hm->dev));
+ if (error) {
+ DPRINTF(hm, "error=%d\n", error);
+ hidmap_detach(hm);
+ return (ENXIO);
+ }
+
+ evdev_set_methods(hm->evdev, hm->dev, &hm->evdev_methods);
+ hm->cb_state = HIDMAP_CB_IS_RUNNING;
+
+ error = evdev_register_epoch(hm->evdev, HIDBUS_EPOCH);
+ if (error) {
+ DPRINTF(hm, "error=%d\n", error);
+ hidmap_detach(hm);
+ return (ENXIO);
+ }
+
+ return (0);
+}
+
+int
+hidmap_detach(struct hidmap* hm)
+{
+ struct hidmap_hid_item *hi;
+
+ DPRINTFN(hm, 11, "\n");
+
+ hm->cb_state = HIDMAP_CB_IS_DETACHING;
+
+ evdev_free(hm->evdev);
+ if (hm->hid_items != NULL) {
+ for (hi = hm->hid_items;
+ hi < hm->hid_items + hm->nhid_items;
+ hi++)
+ if (hi->type == HIDMAP_TYPE_FINALCB ||
+ hi->type == HIDMAP_TYPE_CALLBACK)
+ hi->cb(hm, hi, (union hidmap_cb_ctx){});
+ else if (hi->type == HIDMAP_TYPE_ARR_LIST)
+ free(hi->codes, M_DEVBUF);
+ free(hm->hid_items, M_DEVBUF);
+ }
+
+ free(hm->key_press, M_DEVBUF);
+ free(hm->key_rel, M_DEVBUF);
+
+ return (0);
+}
+
+MODULE_DEPEND(hidmap, hid, 1, 1, 1);
+MODULE_DEPEND(hidmap, hidbus, 1, 1, 1);
+MODULE_DEPEND(hidmap, evdev, 1, 1, 1);
+MODULE_VERSION(hidmap, 1);
diff --git a/sys/dev/hid/hidquirk.h b/sys/dev/hid/hidquirk.h
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hidquirk.h
@@ -0,0 +1,74 @@
+/* $FreeBSD$ */
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
+ * Copyright (c) 2020 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.
+ */
+
+/*
+ * Screening of all content of this file except HID_QUIRK_LIST is a kind of
+ * hack that allows multiple HID_QUIRK_LIST inclusion with different HQ()
+ * wrappers. That save us splitting hidquirk.h on two header files.
+ */
+#ifndef HQ
+#ifndef _HID_QUIRK_H_
+#define _HID_QUIRK_H_
+#endif
+
+/*
+ * Keep in sync with share/man/man4/hidquirk.4
+ */
+#define HID_QUIRK_LIST(...) \
+ HQ(NONE), /* not a valid quirk */ \
+ \
+ HQ(MATCH_VENDOR_ONLY), /* match quirk on vendor only */ \
+ \
+ /* Autoquirks */ \
+ HQ(HAS_KBD_BOOTPROTO), /* device supports keyboard boot protocol */ \
+ HQ(HAS_MS_BOOTPROTO), /* device supports mouse boot protocol */ \
+ HQ(IS_XBOX360GP), /* device is XBox 360 GamePad */ \
+ HQ(NOWRITE), /* device does not support writes */ \
+ HQ(IICHID_SAMPLING), /* IIC backend runs in sampling mode */ \
+ \
+ /* Various quirks */ \
+ HQ(HID_IGNORE), /* device should be ignored by hid class */ \
+ HQ(KBD_BOOTPROTO), /* device should set the boot protocol */ \
+ HQ(MS_BOOTPROTO), /* device should set the boot protocol */ \
+ HQ(MS_BAD_CLASS), /* doesn't identify properly */ \
+ HQ(MS_LEADING_BYTE), /* mouse sends an unknown leading byte */ \
+ HQ(MS_REVZ), /* mouse has Z-axis reversed */ \
+ HQ(SPUR_BUT_UP), /* spurious mouse button up events */ \
+ HQ(MT_TIMESTAMP) /* Multitouch device exports HW timestamps */
+
+#ifndef HQ
+#define HQ(x) HQ_##x
+enum {
+ HID_QUIRK_LIST(),
+ HID_QUIRK_MAX
+};
+#undef HQ
+
+#endif /* _HID_QUIRK_H_ */
+#endif /* HQ */
diff --git a/sys/dev/hid/hidquirk.c b/sys/dev/hid/hidquirk.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hidquirk.c
@@ -0,0 +1,437 @@
+/* $FreeBSD$ */
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-NetBSD
+ *
+ * Copyright (c) 1998 The NetBSD Foundation, Inc. All rights reserved.
+ * Copyright (c) 1998 Lennart Augustsson. All rights reserved.
+ * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
+ * Copyright (c) 2020 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 <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+
+#include <dev/evdev/input.h>
+
+#define HID_DEBUG_VAR hid_debug
+#include <dev/hid/hid.h>
+#include <dev/hid/hidquirk.h>
+#include "usbdevs.h"
+
+
+MODULE_DEPEND(hidquirk, hid, 1, 1, 1);
+MODULE_VERSION(hidquirk, 1);
+
+#define HID_DEV_QUIRKS_MAX 384
+#define HID_SUB_QUIRKS_MAX 8
+#define HID_QUIRK_ENVROOT "hw.hid.quirk."
+
+struct hidquirk_entry {
+ uint16_t bus;
+ uint16_t vid;
+ uint16_t pid;
+ uint16_t lo_rev;
+ uint16_t hi_rev;
+ uint16_t quirks[HID_SUB_QUIRKS_MAX];
+};
+
+static struct mtx hidquirk_mtx;
+
+#define HID_QUIRK_VP(b,v,p,l,h,...) \
+ { .bus = (b), .vid = (v), .pid = (p), .lo_rev = (l), .hi_rev = (h), \
+ .quirks = { __VA_ARGS__ } }
+#define USB_QUIRK(v,p,l,h,...) \
+ HID_QUIRK_VP(BUS_USB, USB_VENDOR_##v, USB_PRODUCT_##v##_##p, l, h, __VA_ARGS__)
+
+static struct hidquirk_entry hidquirks[HID_DEV_QUIRKS_MAX] = {
+ USB_QUIRK(ASUS, LCM, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(QTRONIX, 980N, 0x110, 0x110, HQ_SPUR_BUT_UP),
+ USB_QUIRK(ALCOR2, KBD_HUB, 0x001, 0x001, HQ_SPUR_BUT_UP),
+ USB_QUIRK(LOGITECH, G510S, 0x0000, 0xFFFF, HQ_KBD_BOOTPROTO),
+ /* Devices which should be ignored by usbhid */
+ USB_QUIRK(APC, UPS, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(BELKIN, F6H375USB, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(BELKIN, F6C550AVR, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(BELKIN, F6C1250TWRK, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(BELKIN, F6C1500TWRK, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(BELKIN, F6C900UNV, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(BELKIN, F6C100UNV, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(BELKIN, F6C120UNV, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(BELKIN, F6C800UNV, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(BELKIN, F6C1100UNV, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(CYBERPOWER, BC900D, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(CYBERPOWER, 1500CAVRLCD, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(CYBERPOWER, OR2200LCDRM2U, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(DELL2, VARIOUS_UPS, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(CYPRESS, SILVERSHIELD, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(DELORME, EARTHMATE, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(DREAMLINK, DL100B, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(MICROCHIP, PICOLCD20X2, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(MICROCHIP, PICOLCD4X20, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(LIEBERT, POWERSURE_PXT, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(LIEBERT2, PSI1000, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(LIEBERT2, POWERSURE_PSA, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(MGE, UPS1, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(MGE, UPS2, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(POWERCOM, IMPERIAL_SERIES, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(POWERCOM, SMART_KING_PRO, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(POWERCOM, WOW, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(POWERCOM, VANGUARD, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(POWERCOM, BLACK_KNIGHT_PRO, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(TRIPPLITE2, AVR550U, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(TRIPPLITE2, AVR750U, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(TRIPPLITE2, ECO550UPS, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(TRIPPLITE2, T750_INTL, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(TRIPPLITE2, RT_2200_INTL, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(TRIPPLITE2, OMNI1000LCD, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(TRIPPLITE2, OMNI900LCD, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(TRIPPLITE2, SMART_2200RMXL2U, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(TRIPPLITE2, UPS_3014, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(TRIPPLITE2, SU1500RTXL2UA, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(TRIPPLITE2, SU6000RT4U, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(TRIPPLITE2, SU1500RTXL2UA_2, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(APPLE, IPHONE, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(APPLE, IPHONE_3G, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(MEGATEC, UPS, 0x0000, 0xffff, HQ_HID_IGNORE),
+ /* Devices which should be ignored by both ukbd and uhid */
+ USB_QUIRK(CYPRESS, WISPY1A, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(METAGEEK, WISPY1B, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(METAGEEK, WISPY24X, 0x0000, 0xffff, HQ_HID_IGNORE),
+ USB_QUIRK(METAGEEK2, WISPYDBX, 0x0000, 0xffff, HQ_HID_IGNORE),
+ /* MS keyboards do weird things */
+ USB_QUIRK(MICROSOFT, NATURAL4000, 0x0000, 0xFFFF, HQ_KBD_BOOTPROTO),
+ USB_QUIRK(MICROSOFT, WLINTELLIMOUSE, 0x0000, 0xffff, HQ_MS_LEADING_BYTE),
+ /* Quirk for Corsair Vengeance K60 keyboard */
+ USB_QUIRK(CORSAIR, K60, 0x0000, 0xffff, HQ_KBD_BOOTPROTO),
+ /* Quirk for Corsair Gaming K68 keyboard */
+ USB_QUIRK(CORSAIR, K68, 0x0000, 0xffff, HQ_KBD_BOOTPROTO),
+ /* Quirk for Corsair Vengeance K70 keyboard */
+ USB_QUIRK(CORSAIR, K70, 0x0000, 0xffff, HQ_KBD_BOOTPROTO),
+ /* Quirk for Corsair K70 RGB keyboard */
+ USB_QUIRK(CORSAIR, K70_RGB, 0x0000, 0xffff, HQ_KBD_BOOTPROTO),
+ /* Quirk for Corsair STRAFE Gaming keyboard */
+ USB_QUIRK(CORSAIR, STRAFE, 0x0000, 0xffff, HQ_KBD_BOOTPROTO),
+ USB_QUIRK(CORSAIR, STRAFE2, 0x0000, 0xffff, HQ_KBD_BOOTPROTO),
+ /* Holtek USB gaming keyboard */
+ USB_QUIRK(HOLTEK, F85, 0x0000, 0xffff, HQ_KBD_BOOTPROTO),
+};
+#undef HID_QUIRK_VP
+#undef USB_QUIRK
+
+/* hidquirk.h exposes only HID_QUIRK_LIST macro when HQ() is defined */
+#define HQ(x) [HQ_##x] = "HQ_"#x
+#include "hidquirk.h"
+static const char *hidquirk_str[HID_QUIRK_MAX] = { HID_QUIRK_LIST() };
+#undef HQ
+
+static hid_test_quirk_t hid_test_quirk_by_info;
+
+/*------------------------------------------------------------------------*
+ * hidquirkstr
+ *
+ * This function converts an USB quirk code into a string.
+ *------------------------------------------------------------------------*/
+static const char *
+hidquirkstr(uint16_t quirk)
+{
+ return ((quirk < HID_QUIRK_MAX && hidquirk_str[quirk] != NULL) ?
+ hidquirk_str[quirk] : "HQ_UNKNOWN");
+}
+
+/*------------------------------------------------------------------------*
+ * hid_strquirk
+ *
+ * This function converts a string into a HID quirk code.
+ *
+ * Returns:
+ * Less than HID_QUIRK_MAX: Quirk code
+ * Else: Quirk code not found
+ *------------------------------------------------------------------------*/
+static uint16_t
+hid_strquirk(const char *str, size_t len)
+{
+ const char *quirk;
+ uint16_t x;
+
+ for (x = 0; x != HID_QUIRK_MAX; x++) {
+ quirk = hidquirkstr(x);
+ if (strncmp(str, quirk, len) == 0 &&
+ quirk[len] == 0)
+ break;
+ }
+ return (x);
+}
+
+/*------------------------------------------------------------------------*
+ * hid_test_quirk_by_info
+ *
+ * Returns:
+ * false: Quirk not found
+ * true: Quirk found
+ *------------------------------------------------------------------------*/
+bool
+hid_test_quirk_by_info(const struct hid_device_info *info, uint16_t quirk)
+{
+ uint16_t x;
+ uint16_t y;
+
+ if (quirk == HQ_NONE)
+ goto done;
+
+ mtx_lock(&hidquirk_mtx);
+
+ for (x = 0; x != HID_DEV_QUIRKS_MAX; x++) {
+ /* see if quirk information does not match */
+ if ((hidquirks[x].bus != info->idBus) ||
+ (hidquirks[x].vid != info->idVendor) ||
+ (hidquirks[x].lo_rev > info->idVersion) ||
+ (hidquirks[x].hi_rev < info->idVersion)) {
+ continue;
+ }
+ /* see if quirk only should match vendor ID */
+ if (hidquirks[x].pid != info->idProduct) {
+ if (hidquirks[x].pid != 0)
+ continue;
+
+ for (y = 0; y != HID_SUB_QUIRKS_MAX; y++) {
+ if (hidquirks[x].quirks[y] == HQ_MATCH_VENDOR_ONLY)
+ break;
+ }
+ if (y == HID_SUB_QUIRKS_MAX)
+ continue;
+ }
+ /* lookup quirk */
+ for (y = 0; y != HID_SUB_QUIRKS_MAX; y++) {
+ if (hidquirks[x].quirks[y] == quirk) {
+ mtx_unlock(&hidquirk_mtx);
+ DPRINTF("Found quirk '%s'.\n", hidquirkstr(quirk));
+ return (true);
+ }
+ }
+ }
+ mtx_unlock(&hidquirk_mtx);
+done:
+ return (false); /* no quirk match */
+}
+
+static struct hidquirk_entry *
+hidquirk_get_entry(uint16_t bus, uint16_t vid, uint16_t pid,
+ uint16_t lo_rev, uint16_t hi_rev, uint8_t do_alloc)
+{
+ uint16_t x;
+
+ mtx_assert(&hidquirk_mtx, MA_OWNED);
+
+ if ((bus | vid | pid | lo_rev | hi_rev) == 0) {
+ /* all zero - special case */
+ return (hidquirks + HID_DEV_QUIRKS_MAX - 1);
+ }
+ /* search for an existing entry */
+ for (x = 0; x != HID_DEV_QUIRKS_MAX; x++) {
+ /* see if quirk information does not match */
+ if ((hidquirks[x].bus != bus) ||
+ (hidquirks[x].vid != vid) ||
+ (hidquirks[x].pid != pid) ||
+ (hidquirks[x].lo_rev != lo_rev) ||
+ (hidquirks[x].hi_rev != hi_rev)) {
+ continue;
+ }
+ return (hidquirks + x);
+ }
+
+ if (do_alloc == 0) {
+ /* no match */
+ return (NULL);
+ }
+ /* search for a free entry */
+ for (x = 0; x != HID_DEV_QUIRKS_MAX; x++) {
+ /* see if quirk information does not match */
+ if ((hidquirks[x].bus |
+ hidquirks[x].vid |
+ hidquirks[x].pid |
+ hidquirks[x].lo_rev |
+ hidquirks[x].hi_rev) != 0) {
+ continue;
+ }
+ hidquirks[x].bus = bus;
+ hidquirks[x].vid = vid;
+ hidquirks[x].pid = pid;
+ hidquirks[x].lo_rev = lo_rev;
+ hidquirks[x].hi_rev = hi_rev;
+
+ return (hidquirks + x);
+ }
+
+ /* no entry found */
+ return (NULL);
+}
+
+/*------------------------------------------------------------------------*
+ * usb_quirk_strtou16
+ *
+ * Helper function to scan a 16-bit integer.
+ *------------------------------------------------------------------------*/
+static uint16_t
+hidquirk_strtou16(const char **pptr, const char *name, const char *what)
+{
+ unsigned long value;
+ char *end;
+
+ value = strtoul(*pptr, &end, 0);
+ if (value > 65535 || *pptr == end || (*end != ' ' && *end != '\t')) {
+ printf("%s: %s 16-bit %s value set to zero\n",
+ name, what, *end == 0 ? "incomplete" : "invalid");
+ return (0);
+ }
+ *pptr = end + 1;
+ return ((uint16_t)value);
+}
+
+/*------------------------------------------------------------------------*
+ * usb_quirk_add_entry_from_str
+ *
+ * Add a USB quirk entry from string.
+ * "VENDOR PRODUCT LO_REV HI_REV QUIRK[,QUIRK[,...]]"
+ *------------------------------------------------------------------------*/
+static void
+hidquirk_add_entry_from_str(const char *name, const char *env)
+{
+ struct hidquirk_entry entry = { };
+ struct hidquirk_entry *new;
+ uint16_t quirk_idx;
+ uint16_t quirk;
+ const char *end;
+
+ /* check for invalid environment variable */
+ if (name == NULL || env == NULL)
+ return;
+
+ if (bootverbose)
+ printf("Adding HID QUIRK '%s' = '%s'\n", name, env);
+
+ /* parse device information */
+ entry.bus = hidquirk_strtou16(&env, name, "Bus ID");
+ entry.vid = hidquirk_strtou16(&env, name, "Vendor ID");
+ entry.pid = hidquirk_strtou16(&env, name, "Product ID");
+ entry.lo_rev = hidquirk_strtou16(&env, name, "Low revision");
+ entry.hi_rev = hidquirk_strtou16(&env, name, "High revision");
+
+ /* parse quirk information */
+ quirk_idx = 0;
+ while (*env != 0 && quirk_idx != HID_SUB_QUIRKS_MAX) {
+ /* skip whitespace before quirks */
+ while (*env == ' ' || *env == '\t')
+ env++;
+
+ /* look for quirk separation character */
+ end = strchr(env, ',');
+ if (end == NULL)
+ end = env + strlen(env);
+
+ /* lookup quirk in string table */
+ quirk = hid_strquirk(env, end - env);
+ if (quirk < HID_QUIRK_MAX) {
+ entry.quirks[quirk_idx++] = quirk;
+ } else {
+ printf("%s: unknown HID quirk '%.*s' (skipped)\n",
+ name, (int)(end - env), env);
+ }
+ env = end;
+
+ /* skip quirk delimiter, if any */
+ if (*env != 0)
+ env++;
+ }
+
+ /* register quirk */
+ if (quirk_idx != 0) {
+ if (*env != 0) {
+ printf("%s: Too many HID quirks, only %d allowed!\n",
+ name, HID_SUB_QUIRKS_MAX);
+ }
+ mtx_lock(&hidquirk_mtx);
+ new = hidquirk_get_entry(entry.bus, entry.vid, entry.pid,
+ entry.lo_rev, entry.hi_rev, 1);
+ if (new == NULL)
+ printf("%s: HID quirks table is full!\n", name);
+ else
+ memcpy(new->quirks, entry.quirks, sizeof(entry.quirks));
+ mtx_unlock(&hidquirk_mtx);
+ } else {
+ printf("%s: No USB quirks found!\n", name);
+ }
+}
+
+static void
+hidquirk_init(void *arg)
+{
+ char envkey[sizeof(HID_QUIRK_ENVROOT) + 2]; /* 2 digits max, 0 to 99 */
+ int i;
+
+ /* initialize mutex */
+ mtx_init(&hidquirk_mtx, "HID quirk", NULL, MTX_DEF);
+
+ /* look for quirks defined by the environment variable */
+ for (i = 0; i != 100; i++) {
+ snprintf(envkey, sizeof(envkey), HID_QUIRK_ENVROOT "%d", i);
+
+ /* Stop at first undefined var */
+ if (!testenv(envkey))
+ break;
+
+ /* parse environment variable */
+ hidquirk_add_entry_from_str(envkey, kern_getenv(envkey));
+ }
+
+ /* register our function */
+ hid_test_quirk_p = &hid_test_quirk_by_info;
+}
+
+static void
+hidquirk_uninit(void *arg)
+{
+ hid_quirk_unload(arg);
+
+ /* destroy mutex */
+ mtx_destroy(&hidquirk_mtx);
+}
+
+SYSINIT(hidquirk_init, SI_SUB_LOCK, SI_ORDER_FIRST, hidquirk_init, NULL);
+SYSUNINIT(hidquirk_uninit, SI_SUB_LOCK, SI_ORDER_ANY, hidquirk_uninit, NULL);
diff --git a/sys/dev/hid/hidraw.h b/sys/dev/hid/hidraw.h
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hidraw.h
@@ -0,0 +1,97 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2020 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.
+ *
+ * $FreeBSD$
+ */
+
+#ifndef _HID_HIDRAW_H
+#define _HID_HIDRAW_H
+
+#include <sys/ioccom.h>
+
+#define HIDRAW_BUFFER_SIZE 64 /* number of input reports buffered */
+#define HID_MAX_DESCRIPTOR_SIZE 4096 /* artificial limit taken from Linux */
+
+/*
+ * Align IOCTL structures to hide differences when running 32-bit
+ * programs under 64-bit kernels:
+ */
+#ifdef COMPAT_32BIT
+#define HIDRAW_IOCTL_STRUCT_ALIGN(n) __aligned(n)
+#else
+#define HIDRAW_IOCTL_STRUCT_ALIGN(n)
+#endif
+
+/* Compatible with usb_gen_descriptor structure */
+struct hidraw_gen_descriptor {
+#ifdef COMPAT_32BIT
+ uint64_t hgd_data;
+#else
+ void *hgd_data;
+#endif
+ uint16_t hgd_lang_id;
+ uint16_t hgd_maxlen;
+ uint16_t hgd_actlen;
+ uint16_t hgd_offset;
+ uint8_t hgd_config_index;
+ uint8_t hgd_string_index;
+ uint8_t hgd_iface_index;
+ uint8_t hgd_altif_index;
+ uint8_t hgd_endpt_index;
+ uint8_t hgd_report_type;
+ uint8_t reserved[8];
+} HIDRAW_IOCTL_STRUCT_ALIGN(8);
+
+struct hidraw_report_descriptor {
+ uint32_t size;
+ uint8_t value[HID_MAX_DESCRIPTOR_SIZE];
+} HIDRAW_IOCTL_STRUCT_ALIGN(4);
+
+struct hidraw_devinfo {
+ uint32_t bustype;
+ int16_t vendor;
+ int16_t product;
+} HIDRAW_IOCTL_STRUCT_ALIGN(4);
+
+/* FreeBSD uhid(4)-compatible ioctl interface */
+#define HID_GET_REPORT_DESC _IOWR('U', 21, struct hidraw_gen_descriptor)
+#define HID_SET_IMMED _IOW ('U', 22, int)
+#define HID_GET_REPORT _IOWR('U', 23, struct hidraw_gen_descriptor)
+#define HID_SET_REPORT _IOW ('U', 24, struct hidraw_gen_descriptor)
+#define HID_GET_REPORT_ID _IOR ('U', 25, int)
+#define HID_SET_REPORT_DESC _IOW ('U', 26, struct hidraw_gen_descriptor)
+
+/* Linux hidraw-compatible ioctl interface */
+#define HIDIOCGRDESCSIZE _IOR('U', 30, int)
+#define HIDIOCGRDESC _IO ('U', 31)
+#define HIDIOCGRAWINFO _IOR('U', 32, struct hidraw_devinfo)
+#define HIDIOCGRAWNAME(len) _IOC(IOC_OUT, 'U', 33, len)
+#define HIDIOCGRAWPHYS(len) _IOC(IOC_OUT, 'U', 34, len)
+#define HIDIOCSFEATURE(len) _IOC(IOC_IN, 'U', 35, len)
+#define HIDIOCGFEATURE(len) _IOC(IOC_INOUT, 'U', 36, len)
+#define HIDIOCGRAWUNIQ(len) _IOC(IOC_OUT, 'U', 37, len)
+
+#endif /* _HID_HIDRAW_H */
diff --git a/sys/dev/hid/hidraw.c b/sys/dev/hid/hidraw.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hidraw.c
@@ -0,0 +1,909 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-NetBSD
+ *
+ * Copyright (c) 1998 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ * Copyright (c) 2020 Vladimir Kondratyev <wulf@FreeBSD.org>
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Lennart Augustsson (lennart@augustsson.net) at
+ * Carlstedt Research & Technology.
+ *
+ * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
+ */
+
+/*
+ * HID spec: http://www.usb.org/developers/devclass_docs/HID1_11.pdf
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include "opt_hid.h"
+
+#include <sys/param.h>
+#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/tty.h>
+#include <sys/uio.h>
+
+#define HID_DEBUG_VAR hidraw_debug
+#include <dev/hid/hid.h>
+#include <dev/hid/hidbus.h>
+#include <dev/hid/hidraw.h>
+
+#ifdef HID_DEBUG
+static int hidraw_debug = 0;
+static SYSCTL_NODE(_hw_hid, OID_AUTO, hidraw, CTLFLAG_RW, 0,
+ "HID raw interface");
+SYSCTL_INT(_hw_hid_hidraw, OID_AUTO, debug, CTLFLAG_RWTUN,
+ &hidraw_debug, 0, "Debug level");
+#endif
+
+#define HIDRAW_INDEX 0xFF /* Arbitrary high value */
+
+#define HIDRAW_LOCAL_BUFSIZE 64 /* Size of on-stack buffer. */
+#define HIDRAW_LOCAL_ALLOC(local_buf, size) \
+ (sizeof(local_buf) > (size) ? (local_buf) : \
+ malloc((size), M_DEVBUF, M_ZERO | M_WAITOK))
+#define HIDRAW_LOCAL_FREE(local_buf, buf) \
+ if ((local_buf) != (buf)) { \
+ free((buf), M_DEVBUF); \
+ }
+
+struct hidraw_softc {
+ device_t sc_dev; /* base device */
+
+ struct mtx sc_mtx; /* hidbus private mutex */
+
+ struct hid_rdesc_info *sc_rdesc;
+ const struct hid_device_info *sc_hw;
+
+ uint8_t *sc_q;
+ hid_size_t *sc_qlen;
+ int sc_head;
+ int sc_tail;
+ int sc_sleepcnt;
+
+ struct selinfo sc_rsel;
+ struct proc *sc_async; /* process that wants SIGIO */
+ 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 quiet:1; /* Ignore input data */
+ bool immed:1; /* return read data immediately */
+ 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() */
+ } sc_state;
+ int sc_fflags; /* access mode for open lifetime */
+
+ struct cdev *dev;
+};
+
+static d_open_t hidraw_open;
+static d_read_t hidraw_read;
+static d_write_t hidraw_write;
+static d_ioctl_t hidraw_ioctl;
+static d_poll_t hidraw_poll;
+static d_kqfilter_t hidraw_kqfilter;
+
+static d_priv_dtor_t hidraw_dtor;
+
+static struct cdevsw hidraw_cdevsw = {
+ .d_version = D_VERSION,
+ .d_open = hidraw_open,
+ .d_read = hidraw_read,
+ .d_write = hidraw_write,
+ .d_ioctl = hidraw_ioctl,
+ .d_poll = hidraw_poll,
+ .d_kqfilter = hidraw_kqfilter,
+ .d_name = "hidraw",
+};
+
+static hid_intr_t hidraw_intr;
+
+static device_identify_t hidraw_identify;
+static device_probe_t hidraw_probe;
+static device_attach_t hidraw_attach;
+static device_detach_t hidraw_detach;
+
+static int hidraw_kqread(struct knote *, long);
+static void hidraw_kqdetach(struct knote *);
+static void hidraw_notify(struct hidraw_softc *);
+
+static struct filterops hidraw_filterops_read = {
+ .f_isfd = 1,
+ .f_detach = hidraw_kqdetach,
+ .f_event = hidraw_kqread,
+};
+
+static void
+hidraw_identify(driver_t *driver, device_t parent)
+{
+ device_t child;
+
+ if (device_find_child(parent, "hidraw", -1) == NULL) {
+ child = BUS_ADD_CHILD(parent, 0, "hidraw",
+ device_get_unit(parent));
+ if (child != NULL)
+ hidbus_set_index(child, HIDRAW_INDEX);
+ }
+}
+
+static int
+hidraw_probe(device_t self)
+{
+
+ if (hidbus_get_index(self) != HIDRAW_INDEX)
+ return (ENXIO);
+
+ hidbus_set_desc(self, "Raw HID Device");
+
+ return (BUS_PROBE_GENERIC);
+}
+
+static int
+hidraw_attach(device_t self)
+{
+ struct hidraw_softc *sc = device_get_softc(self);
+ struct make_dev_args mda;
+ int error;
+
+ sc->sc_dev = self;
+ sc->sc_rdesc = hidbus_get_rdesc_info(self);
+ sc->sc_hw = hid_get_device_info(self);
+
+ /* Hidraw mode does not require report descriptor to work */
+ if (sc->sc_rdesc->data == NULL || sc->sc_rdesc->len == 0)
+ device_printf(self, "no report descriptor\n");
+
+ mtx_init(&sc->sc_mtx, "hidraw 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 = &hidraw_cdevsw;
+ mda.mda_uid = UID_ROOT;
+ mda.mda_gid = GID_OPERATOR;
+ mda.mda_mode = 0600;
+ mda.mda_si_drv1 = sc;
+
+ error = make_dev_s(&mda, &sc->dev, "hidraw%d", device_get_unit(self));
+ if (error) {
+ device_printf(self, "Can not create character device\n");
+ hidraw_detach(self);
+ return (error);
+ }
+#ifdef HIDRAW_MAKE_UHID_ALIAS
+ (void)make_dev_alias(sc->dev, "uhid%d", device_get_unit(self));
+#endif
+
+ hidbus_set_lock(self, &sc->sc_mtx);
+ hidbus_set_intr(self, hidraw_intr, sc);
+
+ return (0);
+}
+
+static int
+hidraw_detach(device_t self)
+{
+ struct hidraw_softc *sc = device_get_softc(self);
+
+ DPRINTF("sc=%p\n", sc);
+
+ if (sc->dev != NULL) {
+ mtx_lock(&sc->sc_mtx);
+ sc->dev->si_drv1 = NULL;
+ /* Wake everyone */
+ hidraw_notify(sc);
+ mtx_unlock(&sc->sc_mtx);
+ destroy_dev(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
+hidraw_intr(void *context, void *buf, hid_size_t len)
+{
+ struct hidraw_softc *sc = context;
+ int next;
+
+ DPRINTFN(5, "len=%d\n", len);
+ DPRINTFN(5, "data = %*D\n", len, buf, " ");
+
+ next = (sc->sc_tail + 1) % HIDRAW_BUFFER_SIZE;
+ if (sc->sc_state.quiet || next == sc->sc_head)
+ return;
+
+ bcopy(buf, sc->sc_q + sc->sc_tail * sc->sc_rdesc->rdsize, len);
+
+ /* Make sure we don't process old data */
+ if (len < sc->sc_rdesc->rdsize)
+ bzero(sc->sc_q + sc->sc_tail * sc->sc_rdesc->rdsize + len,
+ sc->sc_rdesc->isize - len);
+
+ sc->sc_qlen[sc->sc_tail] = len;
+ sc->sc_tail = next;
+
+ hidraw_notify(sc);
+}
+
+static inline int
+hidraw_lock_queue(struct hidraw_softc *sc, bool flush)
+{
+ int error = 0;
+
+ mtx_assert(&sc->sc_mtx, MA_OWNED);
+
+ if (flush)
+ sc->sc_state.flush = true;
+ ++sc->sc_sleepcnt;
+ while (sc->sc_state.lock && error == 0) {
+ /* Flush is requested. Wakeup all readers and forbid sleeps */
+ if (flush && sc->sc_state.aslp) {
+ sc->sc_state.aslp = false;
+ DPRINTFN(5, "waking %p\n", &sc->sc_q);
+ wakeup(&sc->sc_q);
+ }
+ error = mtx_sleep(&sc->sc_sleepcnt, &sc->sc_mtx,
+ PZERO | PCATCH, "hidrawio", 0);
+ }
+ --sc->sc_sleepcnt;
+ if (flush)
+ sc->sc_state.flush = false;
+ if (error == 0)
+ sc->sc_state.lock = true;
+
+ return (error);
+}
+
+static inline void
+hidraw_unlock_queue(struct hidraw_softc *sc)
+{
+
+ mtx_assert(&sc->sc_mtx, MA_OWNED);
+ KASSERT(sc->sc_state.lock, ("input buffer is not locked"));
+
+ if (sc->sc_sleepcnt != 0)
+ wakeup_one(&sc->sc_sleepcnt);
+ sc->sc_state.lock = false;
+}
+
+static int
+hidraw_open(struct cdev *dev, int flag, int mode, struct thread *td)
+{
+ struct hidraw_softc *sc;
+ int error;
+
+ sc = dev->si_drv1;
+ 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, hidraw_dtor);
+ if (error != 0) {
+ mtx_lock(&sc->sc_mtx);
+ sc->sc_state.open = false;
+ mtx_unlock(&sc->sc_mtx);
+ return (error);
+ }
+
+ sc->sc_q = malloc(sc->sc_rdesc->rdsize * HIDRAW_BUFFER_SIZE, M_DEVBUF,
+ M_ZERO | M_WAITOK);
+ sc->sc_qlen = malloc(sizeof(hid_size_t) * HIDRAW_BUFFER_SIZE, M_DEVBUF,
+ M_ZERO | M_WAITOK);
+
+ /* Set up interrupt pipe. */
+ sc->sc_state.immed = false;
+ sc->sc_async = 0;
+ sc->sc_state.uhid = false; /* hidraw mode is default */
+ sc->sc_state.quiet = false;
+ sc->sc_head = sc->sc_tail = 0;
+ sc->sc_fflags = flag;
+
+ hidbus_intr_start(sc->sc_dev);
+
+ return (0);
+}
+
+static void
+hidraw_dtor(void *data)
+{
+ struct hidraw_softc *sc = data;
+
+ DPRINTF("sc=%p\n", sc);
+
+ /* Disable interrupts. */
+ hidbus_intr_stop(sc->sc_dev);
+
+ sc->sc_tail = sc->sc_head = 0;
+ sc->sc_async = 0;
+ free(sc->sc_q, M_DEVBUF);
+ free(sc->sc_qlen, M_DEVBUF);
+ sc->sc_q = NULL;
+
+ mtx_lock(&sc->sc_mtx);
+ sc->sc_state.open = false;
+ mtx_unlock(&sc->sc_mtx);
+}
+
+static int
+hidraw_read(struct cdev *dev, struct uio *uio, int flag)
+{
+ struct hidraw_softc *sc;
+ size_t length;
+ int error;
+
+ DPRINTFN(1, "\n");
+
+ sc = dev->si_drv1;
+ if (sc == NULL)
+ return (EIO);
+
+ mtx_lock(&sc->sc_mtx);
+ error = dev->si_drv1 == NULL ? EIO : hidraw_lock_queue(sc, false);
+ if (error != 0) {
+ mtx_unlock(&sc->sc_mtx);
+ return (error);
+ }
+
+ if (sc->sc_state.immed) {
+ mtx_unlock(&sc->sc_mtx);
+ DPRINTFN(1, "immed\n");
+
+ error = hid_get_report(sc->sc_dev, sc->sc_q,
+ sc->sc_rdesc->isize, NULL, HID_INPUT_REPORT,
+ sc->sc_rdesc->iid);
+ if (error == 0)
+ error = uiomove(sc->sc_q, sc->sc_rdesc->isize, uio);
+ mtx_lock(&sc->sc_mtx);
+ goto exit;
+ }
+
+ while (sc->sc_tail == sc->sc_head && !sc->sc_state.flush) {
+ if (flag & O_NONBLOCK) {
+ error = EWOULDBLOCK;
+ goto exit;
+ }
+ sc->sc_state.aslp = true;
+ DPRINTFN(5, "sleep on %p\n", &sc->sc_q);
+ error = mtx_sleep(&sc->sc_q, &sc->sc_mtx, PZERO | PCATCH,
+ "hidrawrd", 0);
+ DPRINTFN(5, "woke, error=%d\n", error);
+ if (dev->si_drv1 == NULL)
+ error = EIO;
+ if (error) {
+ sc->sc_state.aslp = false;
+ goto exit;
+ }
+ }
+
+ while (sc->sc_tail != sc->sc_head && uio->uio_resid > 0) {
+ length = min(uio->uio_resid, sc->sc_state.uhid ?
+ sc->sc_rdesc->isize : sc->sc_qlen[sc->sc_head]);
+ 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_q + sc->sc_head * sc->sc_rdesc->rdsize,
+ length, uio);
+
+ mtx_lock(&sc->sc_mtx);
+ if (error != 0)
+ goto exit;
+ /* Remove a small chunk from the input queue. */
+ sc->sc_head = (sc->sc_head + 1) % HIDRAW_BUFFER_SIZE;
+ /*
+ * In uhid mode transfer as many chunks as possible. Hidraw
+ * packets are transferred one by one due to different length.
+ */
+ if (!sc->sc_state.uhid)
+ goto exit;
+ }
+exit:
+ hidraw_unlock_queue(sc);
+ mtx_unlock(&sc->sc_mtx);
+
+ return (error);
+}
+
+static int
+hidraw_write(struct cdev *dev, struct uio *uio, int flag)
+{
+ uint8_t local_buf[HIDRAW_LOCAL_BUFSIZE], *buf;
+ struct hidraw_softc *sc;
+ int error;
+ int size;
+ size_t buf_offset;
+ uint8_t id = 0;
+
+ DPRINTFN(1, "\n");
+
+ sc = dev->si_drv1;
+ if (sc == NULL)
+ return (EIO);
+
+ if (sc->sc_rdesc->osize == 0)
+ return (EOPNOTSUPP);
+
+ buf_offset = 0;
+ if (sc->sc_state.uhid) {
+ size = sc->sc_rdesc->osize;
+ if (uio->uio_resid != size)
+ return (EINVAL);
+ } else {
+ size = uio->uio_resid;
+ if (size < 2)
+ return (EINVAL);
+ /* Strip leading 0 if the device doesnt use numbered reports */
+ error = uiomove(&id, 1, uio);
+ if (error)
+ return (error);
+ if (id != 0)
+ buf_offset++;
+ else
+ size--;
+ /* Check if underlying driver could process this request */
+ if (size > sc->sc_rdesc->wrsize)
+ return (ENOBUFS);
+ }
+ buf = HIDRAW_LOCAL_ALLOC(local_buf, size);
+ buf[0] = id;
+ error = uiomove(buf + buf_offset, uio->uio_resid, uio);
+ if (error == 0)
+ error = hid_write(sc->sc_dev, buf, size);
+ HIDRAW_LOCAL_FREE(local_buf, buf);
+
+ return (error);
+}
+
+static int
+hidraw_ioctl(struct cdev *dev, u_long cmd, caddr_t addr, int flag,
+ struct thread *td)
+{
+ uint8_t local_buf[HIDRAW_LOCAL_BUFSIZE];
+ void *buf;
+ struct hidraw_softc *sc;
+ struct hidraw_gen_descriptor *hgd;
+ struct hidraw_report_descriptor *hrd;
+ struct hidraw_devinfo *hdi;
+ uint32_t size;
+ int id, len;
+ int error = 0;
+
+ DPRINTFN(2, "cmd=%lx\n", cmd);
+
+ sc = dev->si_drv1;
+ if (sc == NULL)
+ return (EIO);
+
+ /* fixed-length ioctls handling */
+ switch (cmd) {
+ case FIONBIO:
+ /* All handled in the upper FS layer. */
+ return (0);
+
+ case FIOASYNC:
+ mtx_lock(&sc->sc_mtx);
+ if (*(int *)addr) {
+ if (sc->sc_async == NULL) {
+ sc->sc_async = td->td_proc;
+ DPRINTF("FIOASYNC %p\n", sc->sc_async);
+ } else
+ error = EBUSY;
+ } else
+ sc->sc_async = NULL;
+ mtx_unlock(&sc->sc_mtx);
+ return (error);
+
+ /* XXX this is not the most general solution. */
+ case TIOCSPGRP:
+ mtx_lock(&sc->sc_mtx);
+ if (sc->sc_async == NULL)
+ error = EINVAL;
+ else if (*(int *)addr != sc->sc_async->p_pgid)
+ error = EPERM;
+ mtx_unlock(&sc->sc_mtx);
+ return (error);
+
+ case HID_GET_REPORT_DESC:
+ if (sc->sc_rdesc->data == NULL || sc->sc_rdesc->len == 0)
+ return (EOPNOTSUPP);
+ mtx_lock(&sc->sc_mtx);
+ sc->sc_state.uhid = true;
+ mtx_unlock(&sc->sc_mtx);
+ hgd = (struct hidraw_gen_descriptor *)addr;
+ if (sc->sc_rdesc->len > hgd->hgd_maxlen) {
+ size = hgd->hgd_maxlen;
+ } else {
+ size = sc->sc_rdesc->len;
+ }
+ hgd->hgd_actlen = size;
+ if (hgd->hgd_data == NULL)
+ return (0); /* descriptor length only */
+ return (copyout(sc->sc_rdesc->data, hgd->hgd_data, size));
+
+
+ case HID_SET_REPORT_DESC:
+ if (!(sc->sc_fflags & FWRITE))
+ return (EPERM);
+
+ /* check privileges */
+ error = priv_check(curthread, PRIV_DRIVER);
+ if (error)
+ return (error);
+
+ /* Stop interrupts and clear input report buffer */
+ mtx_lock(&sc->sc_mtx);
+ sc->sc_tail = sc->sc_head = 0;
+ error = hidraw_lock_queue(sc, true);
+ if (error == 0)
+ sc->sc_state.quiet = true;
+ mtx_unlock(&sc->sc_mtx);
+ if (error != 0)
+ return(error);
+
+ hgd = (struct hidraw_gen_descriptor *)addr;
+ buf = HIDRAW_LOCAL_ALLOC(local_buf, hgd->hgd_maxlen);
+ copyin(hgd->hgd_data, buf, hgd->hgd_maxlen);
+ /* Lock newbus around set_report_descr call */
+ mtx_lock(&Giant);
+ error = hid_set_report_descr(sc->sc_dev, buf, hgd->hgd_maxlen);
+ mtx_unlock(&Giant);
+ HIDRAW_LOCAL_FREE(local_buf, buf);
+
+ /* Realloc hidraw input queue */
+ if (error == 0)
+ sc->sc_q = realloc(sc->sc_q,
+ sc->sc_rdesc->rdsize * HIDRAW_BUFFER_SIZE,
+ M_DEVBUF, M_ZERO | M_WAITOK);
+
+ /* Start interrupts again */
+ mtx_lock(&sc->sc_mtx);
+ sc->sc_state.quiet = false;
+ hidraw_unlock_queue(sc);
+ mtx_unlock(&sc->sc_mtx);
+ return (error);
+ case HID_SET_IMMED:
+ if (!(sc->sc_fflags & FREAD))
+ return (EPERM);
+ if (*(int *)addr) {
+ /* XXX should read into ibuf, but does it matter? */
+ size = sc->sc_rdesc->isize;
+ buf = HIDRAW_LOCAL_ALLOC(local_buf, size);
+ error = hid_get_report(sc->sc_dev, buf, size, NULL,
+ HID_INPUT_REPORT, sc->sc_rdesc->iid);
+ HIDRAW_LOCAL_FREE(local_buf, buf);
+ if (error)
+ return (EOPNOTSUPP);
+
+ mtx_lock(&sc->sc_mtx);
+ sc->sc_state.immed = true;
+ mtx_unlock(&sc->sc_mtx);
+ } else {
+ mtx_lock(&sc->sc_mtx);
+ sc->sc_state.immed = false;
+ mtx_unlock(&sc->sc_mtx);
+ }
+ return (0);
+
+ case HID_GET_REPORT:
+ if (!(sc->sc_fflags & FREAD))
+ return (EPERM);
+ hgd = (struct hidraw_gen_descriptor *)addr;
+ switch (hgd->hgd_report_type) {
+ case HID_INPUT_REPORT:
+ size = sc->sc_rdesc->isize;
+ id = sc->sc_rdesc->iid;
+ break;
+ case HID_OUTPUT_REPORT:
+ size = sc->sc_rdesc->osize;
+ id = sc->sc_rdesc->oid;
+ break;
+ case HID_FEATURE_REPORT:
+ size = sc->sc_rdesc->fsize;
+ id = sc->sc_rdesc->fid;
+ break;
+ default:
+ return (EINVAL);
+ }
+ if (id != 0)
+ copyin(hgd->hgd_data, &id, 1);
+ size = MIN(hgd->hgd_maxlen, size);
+ buf = HIDRAW_LOCAL_ALLOC(local_buf, size);
+ error = hid_get_report(sc->sc_dev, buf, size, NULL,
+ hgd->hgd_report_type, id);
+ if (!error)
+ error = copyout(buf, hgd->hgd_data, size);
+ HIDRAW_LOCAL_FREE(local_buf, buf);
+ return (error);
+
+ case HID_SET_REPORT:
+ if (!(sc->sc_fflags & FWRITE))
+ return (EPERM);
+ hgd = (struct hidraw_gen_descriptor *)addr;
+ switch (hgd->hgd_report_type) {
+ case HID_INPUT_REPORT:
+ size = sc->sc_rdesc->isize;
+ id = sc->sc_rdesc->iid;
+ break;
+ case HID_OUTPUT_REPORT:
+ size = sc->sc_rdesc->osize;
+ id = sc->sc_rdesc->oid;
+ break;
+ case HID_FEATURE_REPORT:
+ size = sc->sc_rdesc->fsize;
+ id = sc->sc_rdesc->fid;
+ break;
+ default:
+ return (EINVAL);
+ }
+ size = MIN(hgd->hgd_maxlen, size);
+ buf = HIDRAW_LOCAL_ALLOC(local_buf, size);
+ copyin(hgd->hgd_data, buf, size);
+ if (id != 0)
+ id = *(uint8_t *)buf;
+ error = hid_set_report(sc->sc_dev, buf, size,
+ hgd->hgd_report_type, id);
+ HIDRAW_LOCAL_FREE(local_buf, buf);
+ return (error);
+
+ case HID_GET_REPORT_ID:
+ *(int *)addr = 0; /* XXX: we only support reportid 0? */
+ return (0);
+
+ case HIDIOCGRDESCSIZE:
+ *(int *)addr = sc->sc_rdesc->len;
+ return (0);
+
+ case HIDIOCGRDESC:
+ hrd = *(struct hidraw_report_descriptor **)addr;
+ error = copyin(&hrd->size, &size, sizeof(uint32_t));
+ if (error)
+ return (error);
+ /*
+ * HID_MAX_DESCRIPTOR_SIZE-1 is a limit of report descriptor
+ * size in current Linux implementation.
+ */
+ if (size >= HID_MAX_DESCRIPTOR_SIZE)
+ return (EINVAL);
+ buf = HIDRAW_LOCAL_ALLOC(local_buf, size);
+ error = hid_get_rdesc(sc->sc_dev, buf, size);
+ if (error == 0) {
+ size = MIN(size, sc->sc_rdesc->len);
+ error = copyout(buf, hrd->value, size);
+ }
+ HIDRAW_LOCAL_FREE(local_buf, buf);
+ return (error);
+
+ case HIDIOCGRAWINFO:
+ hdi = (struct hidraw_devinfo *)addr;
+ hdi->bustype = sc->sc_hw->idBus;
+ hdi->vendor = sc->sc_hw->idVendor;
+ hdi->product = sc->sc_hw->idProduct;
+ return (0);
+ }
+
+ /* variable-length ioctls handling */
+ len = IOCPARM_LEN(cmd);
+ switch (IOCBASECMD(cmd)) {
+ case HIDIOCGRAWNAME(0):
+ strlcpy(addr, sc->sc_hw->name, len);
+ return (0);
+
+ case HIDIOCGRAWPHYS(0):
+ strlcpy(addr, device_get_nameunit(sc->sc_dev), len);
+ return (0);
+
+ case HIDIOCSFEATURE(0):
+ if (!(sc->sc_fflags & FWRITE))
+ return (EPERM);
+ if (len < 2)
+ return (EINVAL);
+ id = *(uint8_t *)addr;
+ if (id == 0) {
+ addr = (uint8_t *)addr + 1;
+ len--;
+ }
+ return (hid_set_report(sc->sc_dev, addr, len,
+ HID_FEATURE_REPORT, id));
+
+ case HIDIOCGFEATURE(0):
+ if (!(sc->sc_fflags & FREAD))
+ return (EPERM);
+ if (len < 2)
+ return (EINVAL);
+ id = *(uint8_t *)addr;
+ if (id == 0) {
+ addr = (uint8_t *)addr + 1;
+ len--;
+ }
+ return (hid_get_report(sc->sc_dev, addr, len, NULL,
+ HID_FEATURE_REPORT, id));
+
+ case HIDIOCGRAWUNIQ(0):
+ strlcpy(addr, sc->sc_hw->serial, len);
+ return (0);
+ }
+
+ return (EINVAL);
+}
+
+static int
+hidraw_poll(struct cdev *dev, int events, struct thread *td)
+{
+ struct hidraw_softc *sc;
+ int revents = 0;
+
+ sc = dev->si_drv1;
+ 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)) {
+ mtx_lock(&sc->sc_mtx);
+ if (sc->sc_head != sc->sc_tail)
+ revents |= events & (POLLIN | POLLRDNORM);
+ else {
+ sc->sc_state.sel = true;
+ selrecord(td, &sc->sc_rsel);
+ }
+ mtx_unlock(&sc->sc_mtx);
+ }
+
+ return (revents);
+}
+
+static int
+hidraw_kqfilter(struct cdev *dev, struct knote *kn)
+{
+ struct hidraw_softc *sc;
+
+ sc = dev->si_drv1;
+ if (sc == NULL)
+ return (ENXIO);
+
+ switch(kn->kn_filter) {
+ case EVFILT_READ:
+ if (sc->sc_fflags & FREAD) {
+ kn->kn_fop = &hidraw_filterops_read;
+ break;
+ }
+ /* FALLTHROUGH */
+ default:
+ return(EINVAL);
+ }
+ kn->kn_hook = sc;
+
+ knlist_add(&sc->sc_rsel.si_note, kn, 0);
+ return (0);
+}
+
+static int
+hidraw_kqread(struct knote *kn, long hint)
+{
+ struct hidraw_softc *sc;
+ int ret;
+
+ sc = kn->kn_hook;
+
+ mtx_assert(&sc->sc_mtx, MA_OWNED);
+
+ if (sc->dev->si_drv1 == NULL) {
+ kn->kn_flags |= EV_EOF;
+ ret = 1;
+ } else
+ ret = (sc->sc_head != sc->sc_tail) ? 1 : 0;
+
+ return (ret);
+}
+
+static void
+hidraw_kqdetach(struct knote *kn)
+{
+ struct hidraw_softc *sc;
+
+ sc = kn->kn_hook;
+ knlist_remove(&sc->sc_rsel.si_note, kn, 0);
+}
+
+static void
+hidraw_notify(struct hidraw_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_q);
+ wakeup(&sc->sc_q);
+ }
+ if (sc->sc_state.sel) {
+ sc->sc_state.sel = false;
+ selwakeuppri(&sc->sc_rsel, PZERO);
+ }
+ if (sc->sc_async != NULL) {
+ DPRINTFN(3, "sending SIGIO %p\n", sc->sc_async);
+ PROC_LOCK(sc->sc_async);
+ kern_psignal(sc->sc_async, SIGIO);
+ PROC_UNLOCK(sc->sc_async);
+ }
+ KNOTE_LOCKED(&sc->sc_rsel.si_note, 0);
+}
+
+static device_method_t hidraw_methods[] = {
+ /* Device interface */
+ DEVMETHOD(device_identify, hidraw_identify),
+ DEVMETHOD(device_probe, hidraw_probe),
+ DEVMETHOD(device_attach, hidraw_attach),
+ DEVMETHOD(device_detach, hidraw_detach),
+
+ DEVMETHOD_END
+};
+
+static driver_t hidraw_driver = {
+ "hidraw",
+ hidraw_methods,
+ sizeof(struct hidraw_softc)
+};
+
+#ifndef HIDRAW_MAKE_UHID_ALIAS
+devclass_t hidraw_devclass;
+#endif
+
+DRIVER_MODULE(hidraw, hidbus, hidraw_driver, hidraw_devclass, NULL, 0);
+MODULE_DEPEND(hidraw, hidbus, 1, 1, 1);
+MODULE_DEPEND(hidraw, hid, 1, 1, 1);
+MODULE_DEPEND(hidraw, usb, 1, 1, 1);
+MODULE_VERSION(hidraw, 1);
diff --git a/sys/dev/hid/hidrdesc.h b/sys/dev/hid/hidrdesc.h
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hidrdesc.h
@@ -0,0 +1,370 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2000 Nick Hibma <n_hibma@FreeBSD.org>
+ * All rights reserved.
+ *
+ * Copyright (c) 2005 Ed Schouten <ed@FreeBSD.org>
+ * All rights reserved.
+ *
+ * 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.
+ *
+ * $FreeBSD$
+ *
+ * This file contains replacements for broken HID report descriptors.
+ */
+
+#define HID_GRAPHIRE_REPORT_DESCR(...) \
+ 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
+ 0x09, 0x01, /* USAGE (Digitizer) */\
+ 0xa1, 0x01, /* COLLECTION (Application) */\
+ 0x85, 0x02, /* REPORT_ID (2) */\
+ 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
+ 0x09, 0x01, /* USAGE (Digitizer) */\
+ 0xa1, 0x00, /* COLLECTION (Physical) */\
+ 0x15, 0x00, /* LOGICAL_MINIMUM (0) */\
+ 0x25, 0x01, /* LOGICAL_MAXIMUM (1) */\
+ 0x09, 0x33, /* USAGE (Touch) */\
+ 0x95, 0x01, /* REPORT_COUNT (1) */\
+ 0x75, 0x01, /* REPORT_SIZE (1) */\
+ 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
+ 0x09, 0x44, /* USAGE (Barrel Switch) */\
+ 0x95, 0x02, /* REPORT_COUNT (2) */\
+ 0x75, 0x01, /* REPORT_SIZE (1) */\
+ 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
+ 0x09, 0x00, /* USAGE (Undefined) */\
+ 0x95, 0x02, /* REPORT_COUNT (2) */\
+ 0x75, 0x01, /* REPORT_SIZE (1) */\
+ 0x81, 0x03, /* INPUT (Cnst,Var,Abs) */\
+ 0x09, 0x3c, /* USAGE (Invert) */\
+ 0x95, 0x01, /* REPORT_COUNT (1) */\
+ 0x75, 0x01, /* REPORT_SIZE (1) */\
+ 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
+ 0x09, 0x38, /* USAGE (Transducer Index) */\
+ 0x95, 0x01, /* REPORT_COUNT (1) */\
+ 0x75, 0x01, /* REPORT_SIZE (1) */\
+ 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
+ 0x09, 0x32, /* USAGE (In Range) */\
+ 0x95, 0x01, /* REPORT_COUNT (1) */\
+ 0x75, 0x01, /* REPORT_SIZE (1) */\
+ 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
+ 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */\
+ 0x09, 0x30, /* USAGE (X) */\
+ 0x15, 0x00, /* LOGICAL_MINIMUM (0) */\
+ 0x26, 0xde, 0x27, /* LOGICAL_MAXIMUM (10206) */\
+ 0x95, 0x01, /* REPORT_COUNT (1) */\
+ 0x75, 0x10, /* REPORT_SIZE (16) */\
+ 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
+ 0x09, 0x31, /* USAGE (Y) */\
+ 0x26, 0xfe, 0x1c, /* LOGICAL_MAXIMUM (7422) */\
+ 0x95, 0x01, /* REPORT_COUNT (1) */\
+ 0x75, 0x10, /* REPORT_SIZE (16) */\
+ 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
+ 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
+ 0x09, 0x30, /* USAGE (Tip Pressure) */\
+ 0x26, 0xff, 0x01, /* LOGICAL_MAXIMUM (511) */\
+ 0x95, 0x01, /* REPORT_COUNT (1) */\
+ 0x75, 0x10, /* REPORT_SIZE (16) */\
+ 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
+ 0xc0, /* END_COLLECTION */\
+ 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
+ 0x09, 0x00, /* USAGE (Undefined) */\
+ 0x85, 0x02, /* REPORT_ID (2) */\
+ 0x95, 0x01, /* REPORT_COUNT (1) */\
+ 0xb1, 0x02, /* FEATURE (Data,Var,Abs) */\
+ 0x09, 0x00, /* USAGE (Undefined) */\
+ 0x85, 0x03, /* REPORT_ID (3) */\
+ 0x95, 0x01, /* REPORT_COUNT (1) */\
+ 0xb1, 0x02, /* FEATURE (Data,Var,Abs) */\
+ 0xc0, /* END_COLLECTION */\
+
+#define HID_GRAPHIRE3_4X5_REPORT_DESCR(...) \
+ 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */\
+ 0x09, 0x02, /* USAGE (Mouse) */\
+ 0xa1, 0x01, /* COLLECTION (Application) */\
+ 0x85, 0x01, /* REPORT_ID (1) */\
+ 0x09, 0x01, /* USAGE (Pointer) */\
+ 0xa1, 0x00, /* COLLECTION (Physical) */\
+ 0x05, 0x09, /* USAGE_PAGE (Button) */\
+ 0x19, 0x01, /* USAGE_MINIMUM (Button 1) */\
+ 0x29, 0x03, /* USAGE_MAXIMUM (Button 3) */\
+ 0x15, 0x00, /* LOGICAL_MINIMUM (0) */\
+ 0x25, 0x01, /* LOGICAL_MAXIMUM (1) */\
+ 0x95, 0x03, /* REPORT_COUNT (3) */\
+ 0x75, 0x01, /* REPORT_SIZE (1) */\
+ 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
+ 0x95, 0x01, /* REPORT_COUNT (1) */\
+ 0x75, 0x05, /* REPORT_SIZE (5) */\
+ 0x81, 0x01, /* INPUT (Cnst,Ary,Abs) */\
+ 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */\
+ 0x09, 0x30, /* USAGE (X) */\
+ 0x09, 0x31, /* USAGE (Y) */\
+ 0x09, 0x38, /* USAGE (Wheel) */\
+ 0x15, 0x81, /* LOGICAL_MINIMUM (-127) */\
+ 0x25, 0x7f, /* LOGICAL_MAXIMUM (127) */\
+ 0x75, 0x08, /* REPORT_SIZE (8) */\
+ 0x95, 0x03, /* REPORT_COUNT (3) */\
+ 0x81, 0x06, /* INPUT (Data,Var,Rel) */\
+ 0xc0, /* END_COLLECTION */\
+ 0xc0, /* END_COLLECTION */\
+ 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
+ 0x09, 0x01, /* USAGE (Pointer) */\
+ 0xa1, 0x01, /* COLLECTION (Applicaption) */\
+ 0x85, 0x02, /* REPORT_ID (2) */\
+ 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
+ 0x09, 0x01, /* USAGE (Digitizer) */\
+ 0xa1, 0x00, /* COLLECTION (Physical) */\
+ 0x09, 0x33, /* USAGE (Touch) */\
+ 0x09, 0x44, /* USAGE (Barrel Switch) */\
+ 0x09, 0x44, /* USAGE (Barrel Switch) */\
+ 0x15, 0x00, /* LOGICAL_MINIMUM (0) */\
+ 0x25, 0x01, /* LOGICAL_MAXIMUM (1) */\
+ 0x75, 0x01, /* REPORT_SIZE (1) */\
+ 0x95, 0x03, /* REPORT_COUNT (3) */\
+ 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
+ 0x75, 0x01, /* REPORT_SIZE (1) */\
+ 0x95, 0x02, /* REPORT_COUNT (2) */\
+ 0x81, 0x01, /* INPUT (Cnst,Ary,Abs) */\
+ 0x09, 0x3c, /* USAGE (Invert) */\
+ 0x09, 0x38, /* USAGE (Transducer Index) */\
+ 0x09, 0x32, /* USAGE (In Range) */\
+ 0x75, 0x01, /* REPORT_SIZE (1) */\
+ 0x95, 0x03, /* REPORT_COUNT (3) */\
+ 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
+ 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */\
+ 0x09, 0x30, /* USAGE (X) */\
+ 0x15, 0x00, /* LOGICAL_MINIMUM (0) */\
+ 0x26, 0xde, 0x27, /* LOGICAL_MAXIMUM (10206) */\
+ 0x75, 0x10, /* REPORT_SIZE (16) */\
+ 0x95, 0x01, /* REPORT_COUNT (1) */\
+ 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
+ 0x09, 0x31, /* USAGE (Y) */\
+ 0x26, 0xfe, 0x1c, /* LOGICAL_MAXIMUM (7422) */\
+ 0x75, 0x10, /* REPORT_SIZE (16) */\
+ 0x95, 0x01, /* REPORT_COUNT (1) */\
+ 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
+ 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
+ 0x09, 0x30, /* USAGE (Tip Pressure) */\
+ 0x26, 0xff, 0x01, /* LOGICAL_MAXIMUM (511) */\
+ 0x75, 0x10, /* REPORT_SIZE (16) */\
+ 0x95, 0x01, /* REPORT_COUNT (1) */\
+ 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
+ 0xc0, /* END_COLLECTION */\
+ 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
+ 0x09, 0x00, /* USAGE (Undefined) */\
+ 0x85, 0x02, /* REPORT_ID (2) */\
+ 0x95, 0x01, /* REPORT_COUNT (1) */\
+ 0xb1, 0x02, /* FEATURE (Data,Var,Abs) */\
+ 0x09, 0x00, /* USAGE (Undefined) */\
+ 0x85, 0x03, /* REPORT_ID (3) */\
+ 0x95, 0x01, /* REPORT_COUNT (1) */\
+ 0xb1, 0x02, /* FEATURE (Data,Var,Abs) */\
+ 0xc0 /* END_COLLECTION */\
+
+/*
+ * The descriptor has no output report format, thus preventing you from
+ * controlling the LEDs and the built-in rumblers.
+ */
+#define HID_XB360GP_REPORT_DESCR(...) \
+ 0x05, 0x01, /* USAGE PAGE (Generic Desktop) */\
+ 0x09, 0x05, /* USAGE (Gamepad) */\
+ 0xa1, 0x01, /* COLLECTION (Application) */\
+ /* Unused */\
+ 0x75, 0x08, /* REPORT SIZE (8) */\
+ 0x95, 0x01, /* REPORT COUNT (1) */\
+ 0x81, 0x01, /* INPUT (Constant) */\
+ /* Byte count */\
+ 0x75, 0x08, /* REPORT SIZE (8) */\
+ 0x95, 0x01, /* REPORT COUNT (1) */\
+ 0x05, 0x01, /* USAGE PAGE (Generic Desktop) */\
+ 0x09, 0x3b, /* USAGE (Byte Count) */\
+ 0x81, 0x01, /* INPUT (Constant) */\
+ /* D-Pad */\
+ 0x05, 0x01, /* USAGE PAGE (Generic Desktop) */\
+ 0x09, 0x01, /* USAGE (Pointer) */\
+ 0xa1, 0x00, /* COLLECTION (Physical) */\
+ 0x75, 0x01, /* REPORT SIZE (1) */\
+ 0x15, 0x00, /* LOGICAL MINIMUM (0) */\
+ 0x25, 0x01, /* LOGICAL MAXIMUM (1) */\
+ 0x35, 0x00, /* PHYSICAL MINIMUM (0) */\
+ 0x45, 0x01, /* PHYSICAL MAXIMUM (1) */\
+ 0x95, 0x04, /* REPORT COUNT (4) */\
+ 0x05, 0x01, /* USAGE PAGE (Generic Desktop) */\
+ 0x09, 0x90, /* USAGE (D-Pad Up) */\
+ 0x09, 0x91, /* USAGE (D-Pad Down) */\
+ 0x09, 0x93, /* USAGE (D-Pad Left) */\
+ 0x09, 0x92, /* USAGE (D-Pad Right) */\
+ 0x81, 0x02, /* INPUT (Data, Variable, Absolute) */\
+ 0xc0, /* END COLLECTION */\
+ /* Buttons 5-11 */\
+ 0x75, 0x01, /* REPORT SIZE (1) */\
+ 0x15, 0x00, /* LOGICAL MINIMUM (0) */\
+ 0x25, 0x01, /* LOGICAL MAXIMUM (1) */\
+ 0x35, 0x00, /* PHYSICAL MINIMUM (0) */\
+ 0x45, 0x01, /* PHYSICAL MAXIMUM (1) */\
+ 0x95, 0x07, /* REPORT COUNT (7) */\
+ 0x05, 0x09, /* USAGE PAGE (Button) */\
+ 0x09, 0x08, /* USAGE (Button 8) */\
+ 0x09, 0x07, /* USAGE (Button 7) */\
+ 0x09, 0x09, /* USAGE (Button 9) */\
+ 0x09, 0x0a, /* USAGE (Button 10) */\
+ 0x09, 0x05, /* USAGE (Button 5) */\
+ 0x09, 0x06, /* USAGE (Button 6) */\
+ 0x09, 0x0b, /* USAGE (Button 11) */\
+ 0x81, 0x02, /* INPUT (Data, Variable, Absolute) */\
+ /* Unused */\
+ 0x75, 0x01, /* REPORT SIZE (1) */\
+ 0x95, 0x01, /* REPORT COUNT (1) */\
+ 0x81, 0x01, /* INPUT (Constant) */\
+ /* Buttons 1-4 */\
+ 0x75, 0x01, /* REPORT SIZE (1) */\
+ 0x15, 0x00, /* LOGICAL MINIMUM (0) */\
+ 0x25, 0x01, /* LOGICAL MAXIMUM (1) */\
+ 0x35, 0x00, /* PHYSICAL MINIMUM (0) */\
+ 0x45, 0x01, /* PHYSICAL MAXIMUM (1) */\
+ 0x95, 0x04, /* REPORT COUNT (4) */\
+ 0x05, 0x09, /* USAGE PAGE (Button) */\
+ 0x19, 0x01, /* USAGE MINIMUM (Button 1) */\
+ 0x29, 0x04, /* USAGE MAXIMUM (Button 4) */\
+ 0x81, 0x02, /* INPUT (Data, Variable, Absolute) */\
+ /* Triggers */\
+ 0x75, 0x08, /* REPORT SIZE (8) */\
+ 0x15, 0x00, /* LOGICAL MINIMUM (0) */\
+ 0x26, 0xff, 0x00, /* LOGICAL MAXIMUM (255) */\
+ 0x35, 0x00, /* PHYSICAL MINIMUM (0) */\
+ 0x46, 0xff, 0x00, /* PHYSICAL MAXIMUM (255) */\
+ 0x95, 0x02, /* REPORT SIZE (2) */\
+ 0x05, 0x01, /* USAGE PAGE (Generic Desktop) */\
+ 0x09, 0x32, /* USAGE (Z) */\
+ 0x09, 0x35, /* USAGE (Rz) */\
+ 0x81, 0x02, /* INPUT (Data, Variable, Absolute) */\
+ /* Sticks */\
+ 0x75, 0x10, /* REPORT SIZE (16) */\
+ 0x16, 0x00, 0x80, /* LOGICAL MINIMUM (-32768) */\
+ 0x26, 0xff, 0x7f, /* LOGICAL MAXIMUM (32767) */\
+ 0x36, 0x00, 0x80, /* PHYSICAL MINIMUM (-32768) */\
+ 0x46, 0xff, 0x7f, /* PHYSICAL MAXIMUM (32767) */\
+ 0x95, 0x04, /* REPORT COUNT (4) */\
+ 0x05, 0x01, /* USAGE PAGE (Generic Desktop) */\
+ 0x09, 0x30, /* USAGE (X) */\
+ 0x09, 0x31, /* USAGE (Y) */\
+ 0x09, 0x33, /* USAGE (Rx) */\
+ 0x09, 0x34, /* USAGE (Ry) */\
+ 0x81, 0x02, /* INPUT (Data, Variable, Absolute) */\
+ /* Unused */\
+ 0x75, 0x30, /* REPORT SIZE (48) */\
+ 0x95, 0x01, /* REPORT COUNT (1) */\
+ 0x81, 0x01, /* INPUT (Constant) */\
+ 0xc0 /* END COLLECTION */\
+
+/* Fixed report descriptor for Super Nintendo gamepads */
+#define HID_SNES_REPORT_DESCR(...) \
+ 0x05, 0x01, /* Usage Page (Desktop), */\
+ 0x09, 0x04, /* Usage (Joystik), */\
+ 0xA1, 0x01, /* Collection (Application), */\
+ 0xA1, 0x02, /* Collection (Logical), */\
+ 0x14, /* Logical Minimum (0), */\
+ 0x75, 0x08, /* Report Size (8), */\
+ 0x95, 0x03, /* Report Count (3), */\
+ 0x81, 0x01, /* Input (Constant), */\
+ 0x26, 0xFF, 0x00, /* Logical Maximum (255), */\
+ 0x95, 0x02, /* Report Count (2), */\
+ 0x09, 0x30, /* Usage (X), */\
+ 0x09, 0x31, /* Usage (Y), */\
+ 0x81, 0x02, /* Input (Variable), */\
+ 0x75, 0x01, /* Report Size (1), */\
+ 0x95, 0x04, /* Report Count (4), */\
+ 0x81, 0x01, /* Input (Constant), */\
+ 0x25, 0x01, /* Logical Maximum (1), */\
+ 0x95, 0x0A, /* Report Count (10), */\
+ 0x05, 0x09, /* Usage Page (Button), */\
+ 0x19, 0x01, /* Usage Minimum (01h), */\
+ 0x29, 0x0A, /* Usage Maximum (0Ah), */\
+ 0x81, 0x02, /* Input (Variable), */\
+ 0x95, 0x0A, /* Report Count (10), */\
+ 0x81, 0x01, /* Input (Constant), */\
+ 0xC0, /* End Collection, */\
+ 0xC0 /* End Collection */
+
+/* HID mouse boot protocol descriptor */
+#define HID_MOUSE_BOOTPROTO_DESCR(...) \
+ 0x05, 0x01, /* Usage Page (Generic Desktop Ctrls) */\
+ 0x09, 0x02, /* Usage (Mouse) */\
+ 0xA1, 0x01, /* Collection (Application) */\
+ 0x09, 0x01, /* Usage (Pointer) */\
+ 0xA1, 0x00, /* Collection (Physical) */\
+ 0x95, 0x03, /* Report Count (3) */\
+ 0x75, 0x01, /* Report Size (1) */\
+ 0x05, 0x09, /* Usage Page (Button) */\
+ 0x19, 0x01, /* Usage Minimum (0x01) */\
+ 0x29, 0x03, /* Usage Maximum (0x03) */\
+ 0x15, 0x00, /* Logical Minimum (0) */\
+ 0x25, 0x01, /* Logical Maximum (1) */\
+ 0x81, 0x02, /* Input (Data,Var,Abs) */\
+ 0x95, 0x01, /* Report Count (1) */\
+ 0x75, 0x05, /* Report Size (5) */\
+ 0x81, 0x03, /* Input (Const) */\
+ 0x75, 0x08, /* Report Size (8) */\
+ 0x95, 0x02, /* Report Count (2) */\
+ 0x05, 0x01, /* Usage Page (Generic Desktop Ctrls) */\
+ 0x09, 0x30, /* Usage (X) */\
+ 0x09, 0x31, /* Usage (Y) */\
+ 0x15, 0x81, /* Logical Minimum (-127) */\
+ 0x25, 0x7F, /* Logical Maximum (127) */\
+ 0x81, 0x06, /* Input (Data,Var,Rel) */\
+ 0xC0, /* End Collection */\
+ 0xC0, /* End Collection */
+
+/* HID keyboard boot protocol descriptor */
+#define HID_KBD_BOOTPROTO_DESCR(...) \
+ 0x05, 0x01, /* Usage Page (Generic Desktop Ctrls) */\
+ 0x09, 0x06, /* Usage (Keyboard) */\
+ 0xA1, 0x01, /* Collection (Application) */\
+ 0x05, 0x07, /* Usage Page (Kbrd/Keypad) */\
+ 0x19, 0xE0, /* Usage Minimum (0xE0) */\
+ 0x29, 0xE7, /* Usage Maximum (0xE7) */\
+ 0x15, 0x00, /* Logical Minimum (0) */\
+ 0x25, 0x01, /* Logical Maximum (1) */\
+ 0x75, 0x01, /* Report Size (1) */\
+ 0x95, 0x08, /* Report Count (8) */\
+ 0x81, 0x02, /* Input (Data,Var,Abs) */\
+ 0x95, 0x01, /* Report Count (1) */\
+ 0x75, 0x08, /* Report Size (8) */\
+ 0x81, 0x01, /* Input (Const,Array,Abs) */\
+ 0x95, 0x03, /* Report Count (3) */\
+ 0x75, 0x01, /* Report Size (1) */\
+ 0x05, 0x08, /* Usage Page (LEDs) */\
+ 0x19, 0x01, /* Usage Minimum (Num Lock) */\
+ 0x29, 0x03, /* Usage Maximum (Scroll Lock) */\
+ 0x91, 0x02, /* Output (Data,Var,Abs) */\
+ 0x95, 0x05, /* Report Count (5) */\
+ 0x75, 0x01, /* Report Size (1) */\
+ 0x91, 0x01, /* Output (Const,Array,Abs) */\
+ 0x95, 0x06, /* Report Count (6) */\
+ 0x75, 0x08, /* Report Size (8) */\
+ 0x15, 0x00, /* Logical Minimum (0) */\
+ 0x26, 0xFF, 0x00, /* Logical Maximum (255) */\
+ 0x05, 0x07, /* Usage Page (Kbrd/Keypad) */\
+ 0x19, 0x00, /* Usage Minimum (0x00) */\
+ 0x2A, 0xFF, 0x00, /* Usage Maximum (0xFF) */\
+ 0x81, 0x00, /* Input (Data,Array,Abs) */\
+ 0xC0, /* End Collection */
diff --git a/sys/dev/hid/hkbd.c b/sys/dev/hid/hkbd.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hkbd.c
@@ -0,0 +1,2009 @@
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-NetBSD
+ *
+ * Copyright (c) 1998 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.
+ *
+ * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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.
+ *
+ */
+
+/*
+ * HID spec: http://www.usb.org/developers/devclass_docs/HID1_11.pdf
+ */
+
+#include "opt_kbd.h"
+#include "opt_hkbd.h"
+#include "opt_evdev.h"
+
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+#include <sys/proc.h>
+#include <sys/kdb.h>
+#include <sys/taskqueue.h>
+
+#include <machine/atomic.h>
+
+#define HID_DEBUG_VAR hkbd_debug
+#include <dev/hid/hid.h>
+#include <dev/hid/hidbus.h>
+#include <dev/hid/hidquirk.h>
+#include <dev/hid/hidrdesc.h>
+
+#ifdef EVDEV_SUPPORT
+#include <dev/evdev/input.h>
+#include <dev/evdev/evdev.h>
+#endif
+
+#include <sys/ioccom.h>
+#include <sys/filio.h>
+#include <sys/kbio.h>
+
+#include <dev/kbd/kbdreg.h>
+
+/* the initial key map, accent map and fkey strings */
+#if defined(HKBD_DFLT_KEYMAP) && !defined(KLD_MODULE)
+#define KBD_DFLT_KEYMAP
+#include "ukbdmap.h"
+#endif
+
+/* the following file must be included after "ukbdmap.h" */
+#include <dev/kbd/kbdtables.h>
+
+#ifdef HID_DEBUG
+static int hkbd_debug = 0;
+static int hkbd_no_leds = 0;
+
+static SYSCTL_NODE(_hw_hid, OID_AUTO, hkbd, CTLFLAG_RW, 0, "USB keyboard");
+SYSCTL_INT(_hw_hid_hkbd, OID_AUTO, debug, CTLFLAG_RWTUN,
+ &hkbd_debug, 0, "Debug level");
+SYSCTL_INT(_hw_hid_hkbd, OID_AUTO, no_leds, CTLFLAG_RWTUN,
+ &hkbd_no_leds, 0, "Disables setting of keyboard leds");
+#endif
+
+#define HKBD_EMULATE_ATSCANCODE 1
+#define HKBD_DRIVER_NAME "hkbd"
+#define HKBD_NKEYCODE 256 /* units */
+#define HKBD_IN_BUF_SIZE (4 * HKBD_NKEYCODE) /* scancodes */
+#define HKBD_IN_BUF_FULL ((HKBD_IN_BUF_SIZE / 2) - 1) /* scancodes */
+#define HKBD_NFKEY (sizeof(fkey_tab)/sizeof(fkey_tab[0])) /* units */
+#define HKBD_BUFFER_SIZE 64 /* bytes */
+#define HKBD_KEY_PRESSED(map, key) ({ \
+ CTASSERT((key) >= 0 && (key) < HKBD_NKEYCODE); \
+ ((map)[(key) / 64] & (1ULL << ((key) % 64))); \
+})
+
+#define MOD_EJECT 0x01
+#define MOD_FN 0x02
+
+#define MOD_MIN 0xe0
+#define MOD_MAX 0xe7
+
+struct hkbd_data {
+ uint64_t bitmap[howmany(HKBD_NKEYCODE, 64)];
+};
+
+struct hkbd_softc {
+ device_t sc_dev;
+
+ keyboard_t sc_kbd;
+ keymap_t sc_keymap;
+ accentmap_t sc_accmap;
+ fkeytab_t sc_fkeymap[HKBD_NFKEY];
+ uint64_t sc_loc_key_valid[howmany(HKBD_NKEYCODE, 64)];
+ struct hid_location sc_loc_apple_eject;
+ struct hid_location sc_loc_apple_fn;
+ struct hid_location sc_loc_key[HKBD_NKEYCODE];
+ struct hid_location sc_loc_numlock;
+ struct hid_location sc_loc_capslock;
+ struct hid_location sc_loc_scrolllock;
+ struct mtx sc_mtx;
+ struct task sc_task;
+ struct callout sc_callout;
+ struct hkbd_data sc_ndata;
+ struct hkbd_data sc_odata;
+
+ struct thread *sc_poll_thread;
+#ifdef EVDEV_SUPPORT
+ struct evdev_dev *sc_evdev;
+#endif
+
+ sbintime_t sc_co_basetime;
+ int sc_delay;
+ uint32_t sc_repeat_time;
+ uint32_t sc_input[HKBD_IN_BUF_SIZE]; /* input buffer */
+ uint32_t sc_time_ms;
+ uint32_t sc_composed_char; /* composed char code, if non-zero */
+#ifdef HKBD_EMULATE_ATSCANCODE
+ uint32_t sc_buffered_char[2];
+#endif
+ uint32_t sc_flags; /* flags */
+#define HKBD_FLAG_COMPOSE 0x00000001
+#define HKBD_FLAG_POLLING 0x00000002
+#define HKBD_FLAG_ATTACHED 0x00000010
+#define HKBD_FLAG_GONE 0x00000020
+
+#define HKBD_FLAG_HID_MASK 0x003fffc0
+#define HKBD_FLAG_APPLE_EJECT 0x00000040
+#define HKBD_FLAG_APPLE_FN 0x00000080
+#define HKBD_FLAG_APPLE_SWAP 0x00000100
+#define HKBD_FLAG_NUMLOCK 0x00080000
+#define HKBD_FLAG_CAPSLOCK 0x00100000
+#define HKBD_FLAG_SCROLLLOCK 0x00200000
+
+ int sc_mode; /* input mode (K_XLATE,K_RAW,K_CODE) */
+ int sc_state; /* shift/lock key state */
+ int sc_accents; /* accent key index (> 0) */
+ int sc_polling; /* polling recursion count */
+ int sc_led_size;
+ int sc_kbd_size;
+
+ uint32_t sc_inputhead;
+ uint32_t sc_inputtail;
+
+ uint8_t sc_iface_index;
+ uint8_t sc_iface_no;
+ uint8_t sc_id_apple_eject;
+ uint8_t sc_id_apple_fn;
+ uint8_t sc_id_loc_key[HKBD_NKEYCODE];
+ uint8_t sc_id_leds;
+ uint8_t sc_kbd_id;
+ uint8_t sc_repeat_key;
+
+ uint8_t sc_buffer[HKBD_BUFFER_SIZE];
+};
+
+#define KEY_NONE 0x00
+#define KEY_ERROR 0x01
+
+#define KEY_PRESS 0
+#define KEY_RELEASE 0x400
+#define KEY_INDEX(c) ((c) & 0xFF)
+
+#define SCAN_PRESS 0
+#define SCAN_RELEASE 0x80
+#define SCAN_PREFIX_E0 0x100
+#define SCAN_PREFIX_E1 0x200
+#define SCAN_PREFIX_CTL 0x400
+#define SCAN_PREFIX_SHIFT 0x800
+#define SCAN_PREFIX (SCAN_PREFIX_E0 | SCAN_PREFIX_E1 | \
+ SCAN_PREFIX_CTL | SCAN_PREFIX_SHIFT)
+#define SCAN_CHAR(c) ((c) & 0x7f)
+
+#define HKBD_LOCK(sc) do { \
+ if (!HID_IN_POLLING_MODE()) \
+ mtx_lock(&(sc)->sc_mtx); \
+} while (0)
+#define HKBD_UNLOCK(sc) do { \
+ if (!HID_IN_POLLING_MODE()) \
+ mtx_unlock(&(sc)->sc_mtx); \
+} while (0)
+#define HKBD_LOCK_ASSERT(sc) do { \
+ if (!HID_IN_POLLING_MODE()) \
+ mtx_assert(&(sc)->sc_mtx, MA_OWNED); \
+} while (0)
+#define SYSCONS_LOCK() do { \
+ if (!HID_IN_POLLING_MODE()) \
+ mtx_lock(&Giant); \
+} while (0)
+#define SYSCONS_UNLOCK() do { \
+ if (!HID_IN_POLLING_MODE()) \
+ mtx_unlock(&Giant); \
+} while (0)
+#define SYSCONS_LOCK_ASSERT() do { \
+ if (!HID_IN_POLLING_MODE()) \
+ mtx_assert(&Giant, MA_OWNED); \
+} while (0)
+
+#define NN 0 /* no translation */
+/*
+ * Translate USB keycodes to AT keyboard scancodes.
+ */
+/*
+ * FIXME: Mac USB keyboard generates:
+ * 0x53: keypad NumLock/Clear
+ * 0x66: Power
+ * 0x67: keypad =
+ * 0x68: F13
+ * 0x69: F14
+ * 0x6a: F15
+ *
+ * USB Apple Keyboard JIS generates:
+ * 0x90: Kana
+ * 0x91: Eisu
+ */
+static const uint8_t hkbd_trtab[256] = {
+ 0, 0, 0, 0, 30, 48, 46, 32, /* 00 - 07 */
+ 18, 33, 34, 35, 23, 36, 37, 38, /* 08 - 0F */
+ 50, 49, 24, 25, 16, 19, 31, 20, /* 10 - 17 */
+ 22, 47, 17, 45, 21, 44, 2, 3, /* 18 - 1F */
+ 4, 5, 6, 7, 8, 9, 10, 11, /* 20 - 27 */
+ 28, 1, 14, 15, 57, 12, 13, 26, /* 28 - 2F */
+ 27, 43, 43, 39, 40, 41, 51, 52, /* 30 - 37 */
+ 53, 58, 59, 60, 61, 62, 63, 64, /* 38 - 3F */
+ 65, 66, 67, 68, 87, 88, 92, 70, /* 40 - 47 */
+ 104, 102, 94, 96, 103, 99, 101, 98, /* 48 - 4F */
+ 97, 100, 95, 69, 91, 55, 74, 78,/* 50 - 57 */
+ 89, 79, 80, 81, 75, 76, 77, 71, /* 58 - 5F */
+ 72, 73, 82, 83, 86, 107, 122, NN, /* 60 - 67 */
+ NN, NN, NN, NN, NN, NN, NN, NN, /* 68 - 6F */
+ NN, NN, NN, NN, 115, 108, 111, 113, /* 70 - 77 */
+ 109, 110, 112, 118, 114, 116, 117, 119, /* 78 - 7F */
+ 121, 120, NN, NN, NN, NN, NN, 123, /* 80 - 87 */
+ 124, 125, 126, 127, 128, NN, NN, NN, /* 88 - 8F */
+ 129, 130, NN, NN, NN, NN, NN, NN, /* 90 - 97 */
+ NN, NN, NN, NN, NN, NN, NN, NN, /* 98 - 9F */
+ NN, NN, NN, NN, NN, NN, NN, NN, /* A0 - A7 */
+ NN, NN, NN, NN, NN, NN, NN, NN, /* A8 - AF */
+ NN, NN, NN, NN, NN, NN, NN, NN, /* B0 - B7 */
+ NN, NN, NN, NN, NN, NN, NN, NN, /* B8 - BF */
+ NN, NN, NN, NN, NN, NN, NN, NN, /* C0 - C7 */
+ NN, NN, NN, NN, NN, NN, NN, NN, /* C8 - CF */
+ NN, NN, NN, NN, NN, NN, NN, NN, /* D0 - D7 */
+ NN, NN, NN, NN, NN, NN, NN, NN, /* D8 - DF */
+ 29, 42, 56, 105, 90, 54, 93, 106, /* E0 - E7 */
+ NN, NN, NN, NN, NN, NN, NN, NN, /* E8 - EF */
+ NN, NN, NN, NN, NN, NN, NN, NN, /* F0 - F7 */
+ NN, NN, NN, NN, NN, NN, NN, NN, /* F8 - FF */
+};
+
+static const uint8_t hkbd_boot_desc[] = { HID_KBD_BOOTPROTO_DESCR() };
+
+/* prototypes */
+static void hkbd_timeout(void *);
+static int hkbd_set_leds(struct hkbd_softc *, uint8_t);
+static int hkbd_set_typematic(keyboard_t *, int);
+#ifdef HKBD_EMULATE_ATSCANCODE
+static uint32_t hkbd_atkeycode(int, const uint64_t *);
+static int hkbd_key2scan(struct hkbd_softc *, int, const uint64_t *, int);
+#endif
+static uint32_t hkbd_read_char(keyboard_t *, int);
+static void hkbd_clear_state(keyboard_t *);
+static int hkbd_ioctl(keyboard_t *, u_long, caddr_t);
+static int hkbd_enable(keyboard_t *);
+static int hkbd_disable(keyboard_t *);
+static void hkbd_interrupt(struct hkbd_softc *);
+
+static task_fn_t hkbd_event_keyinput;
+
+static device_probe_t hkbd_probe;
+static device_attach_t hkbd_attach;
+static device_detach_t hkbd_detach;
+static device_resume_t hkbd_resume;
+
+#ifdef EVDEV_SUPPORT
+static evdev_event_t hkbd_ev_event;
+
+static const struct evdev_methods hkbd_evdev_methods = {
+ .ev_event = hkbd_ev_event,
+};
+#endif
+
+static bool
+hkbd_any_key_pressed(struct hkbd_softc *sc)
+{
+ bool ret = false;
+ unsigned i;
+
+ for (i = 0; i != howmany(HKBD_NKEYCODE, 64); i++)
+ ret |= (sc->sc_odata.bitmap[i] != 0);
+ return (ret);
+}
+
+static bool
+hkbd_any_key_valid(struct hkbd_softc *sc)
+{
+ bool ret = false;
+ unsigned i;
+
+ for (i = 0; i != howmany(HKBD_NKEYCODE, 64); i++)
+ ret |= (sc->sc_loc_key_valid[i] != 0);
+ return (ret);
+}
+
+static bool
+hkbd_is_modifier_key(uint32_t key)
+{
+
+ return (key >= MOD_MIN && key <= MOD_MAX);
+}
+
+static void
+hkbd_start_timer(struct hkbd_softc *sc)
+{
+ sbintime_t delay, now, prec;
+
+ now = sbinuptime();
+
+ /* check if initial delay passed and fallback to key repeat delay */
+ if (sc->sc_delay == 0)
+ sc->sc_delay = sc->sc_kbd.kb_delay2;
+
+ /* compute timeout */
+ delay = SBT_1MS * sc->sc_delay;
+ sc->sc_co_basetime += delay;
+
+ /* check if we are running behind */
+ if (sc->sc_co_basetime < now)
+ sc->sc_co_basetime = now;
+
+ /* This is rarely called, so prefer precision to efficiency. */
+ prec = qmin(delay >> 7, SBT_1MS * 10);
+ if (!HID_IN_POLLING_MODE())
+ callout_reset_sbt(&sc->sc_callout, sc->sc_co_basetime, prec,
+ hkbd_timeout, sc, C_ABSOLUTE);
+}
+
+static void
+hkbd_put_key(struct hkbd_softc *sc, uint32_t key)
+{
+ uint32_t tail;
+
+ HKBD_LOCK_ASSERT(sc);
+
+ DPRINTF("0x%02x (%d) %s\n", key, key,
+ (key & KEY_RELEASE) ? "released" : "pressed");
+
+#ifdef EVDEV_SUPPORT
+ if (evdev_rcpt_mask & EVDEV_RCPT_HW_KBD && sc->sc_evdev != NULL)
+ evdev_push_event(sc->sc_evdev, EV_KEY,
+ evdev_hid2key(KEY_INDEX(key)), !(key & KEY_RELEASE));
+#endif
+
+ tail = (sc->sc_inputtail + 1) % HKBD_IN_BUF_SIZE;
+ if (tail != atomic_load_acq_32(&sc->sc_inputhead)) {
+ sc->sc_input[sc->sc_inputtail] = key;
+ atomic_store_rel_32(&sc->sc_inputtail, tail);
+ } else {
+ DPRINTF("input buffer is full\n");
+ }
+}
+
+static void
+hkbd_do_poll(struct hkbd_softc *sc, uint8_t wait)
+{
+
+ SYSCONS_LOCK_ASSERT();
+ KASSERT((sc->sc_flags & HKBD_FLAG_POLLING) != 0,
+ ("hkbd_do_poll called when not polling\n"));
+ DPRINTFN(2, "polling\n");
+
+ if (!HID_IN_POLLING_MODE()) {
+ /*
+ * In this context the kernel is polling for input,
+ * but the USB subsystem works in normal interrupt-driven
+ * mode, so we just wait on the USB threads to do the job.
+ * Note that we currently hold the Giant, but it's also used
+ * as the transfer mtx, so we must release it while waiting.
+ */
+ while (sc->sc_inputhead ==
+ atomic_load_acq_32(&sc->sc_inputtail)) {
+ /*
+ * Give USB threads a chance to run. Note that
+ * kern_yield performs DROP_GIANT + PICKUP_GIANT.
+ */
+ kern_yield(PRI_UNCHANGED);
+ if (!wait)
+ break;
+ }
+ return;
+ }
+
+ while (sc->sc_inputhead == sc->sc_inputtail) {
+ hidbus_intr_poll(sc->sc_dev);
+
+ /* Delay-optimised support for repetition of keys */
+ if (hkbd_any_key_pressed(sc)) {
+ /* a key is pressed - need timekeeping */
+ DELAY(1000);
+
+ /* 1 millisecond has passed */
+ sc->sc_time_ms += 1;
+ }
+
+ hkbd_interrupt(sc);
+
+ if (!wait)
+ break;
+ }
+}
+
+static int32_t
+hkbd_get_key(struct hkbd_softc *sc, uint8_t wait)
+{
+ uint32_t head;
+ int32_t c;
+
+ SYSCONS_LOCK_ASSERT();
+ KASSERT(!HID_IN_POLLING_MODE() ||
+ (sc->sc_flags & HKBD_FLAG_POLLING) != 0,
+ ("not polling in kdb or panic\n"));
+
+ if (sc->sc_flags & HKBD_FLAG_POLLING)
+ hkbd_do_poll(sc, wait);
+
+ head = sc->sc_inputhead;
+ if (head == atomic_load_acq_32(&sc->sc_inputtail)) {
+ c = -1;
+ } else {
+ c = sc->sc_input[head];
+ head = (head + 1) % HKBD_IN_BUF_SIZE;
+ atomic_store_rel_32(&sc->sc_inputhead, head);
+ }
+ return (c);
+}
+
+static void
+hkbd_interrupt(struct hkbd_softc *sc)
+{
+ const uint32_t now = sc->sc_time_ms;
+ unsigned key;
+
+ HKBD_LOCK_ASSERT(sc);
+
+ /* Check for key changes, the order is:
+ * 1. Modifier keys down
+ * 2. Regular keys up/down
+ * 3. Modifier keys up
+ *
+ * This allows devices which send events changing the state of
+ * both a modifier key and a regular key, to be correctly
+ * translated. */
+ for (key = MOD_MIN; key <= MOD_MAX; key++) {
+ const uint64_t mask = 1ULL << (key % 64);
+
+ if (!(sc->sc_odata.bitmap[key / 64] & mask) &&
+ (sc->sc_ndata.bitmap[key / 64] & mask)) {
+ hkbd_put_key(sc, key | KEY_PRESS);
+ }
+ }
+ for (key = 0; key != HKBD_NKEYCODE; key++) {
+ const uint64_t mask = 1ULL << (key % 64);
+ const uint64_t delta =
+ sc->sc_odata.bitmap[key / 64] ^
+ sc->sc_ndata.bitmap[key / 64];
+
+ if (hkbd_is_modifier_key(key))
+ continue;
+
+ if (mask == 1 && delta == 0) {
+ key += 63;
+ continue; /* skip empty areas */
+ } else if (delta & mask) {
+ if (sc->sc_odata.bitmap[key / 64] & mask) {
+ hkbd_put_key(sc, key | KEY_RELEASE);
+
+ /* clear repeating key, if any */
+ if (sc->sc_repeat_key == key)
+ sc->sc_repeat_key = 0;
+ } else {
+ hkbd_put_key(sc, key | KEY_PRESS);
+
+ sc->sc_co_basetime = sbinuptime();
+ sc->sc_delay = sc->sc_kbd.kb_delay1;
+ hkbd_start_timer(sc);
+
+ /* set repeat time for last key */
+ sc->sc_repeat_time = now + sc->sc_kbd.kb_delay1;
+ sc->sc_repeat_key = key;
+ }
+ }
+ }
+ for (key = MOD_MIN; key <= MOD_MAX; key++) {
+ const uint64_t mask = 1ULL << (key % 64);
+
+ if ((sc->sc_odata.bitmap[key / 64] & mask) &&
+ !(sc->sc_ndata.bitmap[key / 64] & mask)) {
+ hkbd_put_key(sc, key | KEY_RELEASE);
+ }
+ }
+
+ /* synchronize old data with new data */
+ sc->sc_odata = sc->sc_ndata;
+
+ /* check if last key is still pressed */
+ if (sc->sc_repeat_key != 0) {
+ const int32_t dtime = (sc->sc_repeat_time - now);
+
+ /* check if time has elapsed */
+ if (dtime <= 0) {
+ hkbd_put_key(sc, sc->sc_repeat_key | KEY_PRESS);
+ sc->sc_repeat_time = now + sc->sc_kbd.kb_delay2;
+ }
+ }
+
+#ifdef EVDEV_SUPPORT
+ if (evdev_rcpt_mask & EVDEV_RCPT_HW_KBD && sc->sc_evdev != NULL)
+ evdev_sync(sc->sc_evdev);
+#endif
+
+ /* wakeup keyboard system */
+ if (!HID_IN_POLLING_MODE())
+ taskqueue_enqueue(taskqueue_swi_giant, &sc->sc_task);
+}
+
+static void
+hkbd_event_keyinput(void *context, int pending)
+{
+ struct hkbd_softc *sc = context;
+ int c;
+
+ SYSCONS_LOCK_ASSERT();
+
+ if ((sc->sc_flags & HKBD_FLAG_POLLING) != 0)
+ return;
+
+ if (sc->sc_inputhead == atomic_load_acq_32(&sc->sc_inputtail))
+ return;
+
+ if (KBD_IS_ACTIVE(&sc->sc_kbd) &&
+ KBD_IS_BUSY(&sc->sc_kbd)) {
+ /* let the callback function process the input */
+ (sc->sc_kbd.kb_callback.kc_func) (&sc->sc_kbd, KBDIO_KEYINPUT,
+ sc->sc_kbd.kb_callback.kc_arg);
+ } else {
+ /* read and discard the input, no one is waiting for it */
+ do {
+ c = hkbd_read_char(&sc->sc_kbd, 0);
+ } while (c != NOKEY);
+ }
+}
+
+static void
+hkbd_timeout(void *arg)
+{
+ struct hkbd_softc *sc = arg;
+
+ HKBD_LOCK_ASSERT(sc);
+
+ sc->sc_time_ms += sc->sc_delay;
+ sc->sc_delay = 0;
+
+ hkbd_interrupt(sc);
+
+ /* Make sure any leftover key events gets read out */
+ taskqueue_enqueue(taskqueue_swi_giant, &sc->sc_task);
+
+ if (hkbd_any_key_pressed(sc) ||
+ atomic_load_acq_32(&sc->sc_inputhead) != sc->sc_inputtail) {
+ hkbd_start_timer(sc);
+ }
+}
+
+static uint32_t
+hkbd_apple_fn(uint32_t keycode)
+{
+ switch (keycode) {
+ case 0x28: return 0x49; /* RETURN -> INSERT */
+ case 0x2a: return 0x4c; /* BACKSPACE -> DEL */
+ case 0x50: return 0x4a; /* LEFT ARROW -> HOME */
+ case 0x4f: return 0x4d; /* RIGHT ARROW -> END */
+ case 0x52: return 0x4b; /* UP ARROW -> PGUP */
+ case 0x51: return 0x4e; /* DOWN ARROW -> PGDN */
+ default: return keycode;
+ }
+}
+
+static uint32_t
+hkbd_apple_swap(uint32_t keycode)
+{
+ switch (keycode) {
+ case 0x35: return 0x64;
+ case 0x64: return 0x35;
+ default: return keycode;
+ }
+}
+
+static void
+hkbd_intr_callback(void *context, void *data, hid_size_t len)
+{
+ struct hkbd_softc *sc = context;
+ uint8_t *buf = data;
+ uint32_t i;
+ uint8_t id = 0;
+ uint8_t modifiers;
+ int offset;
+
+ HKBD_LOCK_ASSERT(sc);
+
+ DPRINTF("actlen=%d bytes\n", len);
+
+ if (len == 0) {
+ DPRINTF("zero length data\n");
+ return;
+ }
+
+ if (sc->sc_kbd_id != 0) {
+ /* check and remove HID ID byte */
+ id = buf[0];
+ buf++;
+ len--;
+ if (len == 0) {
+ DPRINTF("zero length data\n");
+ return;
+ }
+ }
+
+ /* clear temporary storage */
+ memset(&sc->sc_ndata, 0, sizeof(sc->sc_ndata));
+
+ /* clear modifiers */
+ modifiers = 0;
+
+ /* scan through HID data */
+ if ((sc->sc_flags & HKBD_FLAG_APPLE_EJECT) &&
+ (id == sc->sc_id_apple_eject)) {
+ if (hid_get_data(buf, len, &sc->sc_loc_apple_eject))
+ modifiers |= MOD_EJECT;
+ }
+ if ((sc->sc_flags & HKBD_FLAG_APPLE_FN) &&
+ (id == sc->sc_id_apple_fn)) {
+ if (hid_get_data(buf, len, &sc->sc_loc_apple_fn))
+ modifiers |= MOD_FN;
+ }
+
+ for (i = 0; i != HKBD_NKEYCODE; i++) {
+ const uint64_t valid = sc->sc_loc_key_valid[i / 64];
+ const uint64_t mask = 1ULL << (i % 64);
+
+ if (mask == 1 && valid == 0) {
+ i += 63;
+ continue; /* skip empty areas */
+ } else if (~valid & mask) {
+ continue; /* location is not valid */
+ } else if (id != sc->sc_id_loc_key[i]) {
+ continue; /* invalid HID ID */
+ } else if (i == 0) {
+ offset = sc->sc_loc_key[0].count;
+ if (offset < 0 || offset > len)
+ offset = len;
+ while (offset--) {
+ uint32_t key =
+ hid_get_data(buf + offset, len - offset,
+ &sc->sc_loc_key[i]);
+ if (modifiers & MOD_FN)
+ key = hkbd_apple_fn(key);
+ if (sc->sc_flags & HKBD_FLAG_APPLE_SWAP)
+ key = hkbd_apple_swap(key);
+ if (key == KEY_NONE || key == KEY_ERROR || key >= HKBD_NKEYCODE)
+ continue;
+ /* set key in bitmap */
+ sc->sc_ndata.bitmap[key / 64] |= 1ULL << (key % 64);
+ }
+ } else if (hid_get_data(buf, len, &sc->sc_loc_key[i])) {
+ uint32_t key = i;
+
+ if (modifiers & MOD_FN)
+ key = hkbd_apple_fn(key);
+ if (sc->sc_flags & HKBD_FLAG_APPLE_SWAP)
+ key = hkbd_apple_swap(key);
+ if (key == KEY_NONE || key == KEY_ERROR || key >= HKBD_NKEYCODE)
+ continue;
+ /* set key in bitmap */
+ sc->sc_ndata.bitmap[key / 64] |= 1ULL << (key % 64);
+ }
+ }
+#ifdef HID_DEBUG
+ DPRINTF("modifiers = 0x%04x\n", modifiers);
+ for (i = 0; i != HKBD_NKEYCODE; i++) {
+ const uint64_t valid = sc->sc_ndata.bitmap[i / 64];
+ const uint64_t mask = 1ULL << (i % 64);
+
+ if (valid & mask)
+ DPRINTF("Key 0x%02x pressed\n", i);
+ }
+#endif
+ hkbd_interrupt(sc);
+}
+
+/* A match on these entries will load ukbd */
+static const struct hid_device_id __used hkbd_devs[] = {
+ { HID_TLC(HUP_GENERIC_DESKTOP, HUG_KEYBOARD) },
+};
+
+static int
+hkbd_probe(device_t dev)
+{
+ keyboard_switch_t *sw = kbd_get_switch(HKBD_DRIVER_NAME);
+ int error;
+
+ DPRINTFN(11, "\n");
+
+ if (sw == NULL) {
+ return (ENXIO);
+ }
+
+ error = HIDBUS_LOOKUP_DRIVER_INFO(dev, hkbd_devs);
+ if (error != 0)
+ return (error);
+
+ hidbus_set_desc(dev, "Keyboard");
+
+ return (BUS_PROBE_DEFAULT);
+}
+
+static void
+hkbd_parse_hid(struct hkbd_softc *sc, const uint8_t *ptr, uint32_t len,
+ uint8_t tlc_index)
+{
+ uint32_t flags;
+ uint32_t key;
+ uint8_t id;
+
+ /* reset detected bits */
+ sc->sc_flags &= ~HKBD_FLAG_HID_MASK;
+
+ /* reset detected keys */
+ memset(sc->sc_loc_key_valid, 0, sizeof(sc->sc_loc_key_valid));
+
+ /* check if there is an ID byte */
+ sc->sc_kbd_size = hid_report_size_max(ptr, len,
+ hid_input, &sc->sc_kbd_id);
+
+ /* investigate if this is an Apple Keyboard */
+ if (hidbus_locate(ptr, len,
+ HID_USAGE2(HUP_CONSUMER, HUG_APPLE_EJECT),
+ hid_input, tlc_index, 0, &sc->sc_loc_apple_eject, &flags,
+ &sc->sc_id_apple_eject, NULL)) {
+ if (flags & HIO_VARIABLE)
+ sc->sc_flags |= HKBD_FLAG_APPLE_EJECT |
+ HKBD_FLAG_APPLE_SWAP;
+ DPRINTFN(1, "Found Apple eject-key\n");
+ }
+ if (hidbus_locate(ptr, len,
+ HID_USAGE2(0xFFFF, 0x0003),
+ hid_input, tlc_index, 0, &sc->sc_loc_apple_fn, &flags,
+ &sc->sc_id_apple_fn, NULL)) {
+ if (flags & HIO_VARIABLE)
+ sc->sc_flags |= HKBD_FLAG_APPLE_FN;
+ DPRINTFN(1, "Found Apple FN-key\n");
+ }
+
+ /* figure out event buffer */
+ if (hidbus_locate(ptr, len,
+ HID_USAGE2(HUP_KEYBOARD, 0x00),
+ hid_input, tlc_index, 0, &sc->sc_loc_key[0], &flags,
+ &sc->sc_id_loc_key[0], NULL)) {
+ if (flags & HIO_VARIABLE) {
+ DPRINTFN(1, "Ignoring keyboard event control\n");
+ } else {
+ sc->sc_loc_key_valid[0] |= 1;
+ DPRINTFN(1, "Found keyboard event array\n");
+ }
+ }
+
+ /* figure out the keys */
+ for (key = 1; key != HKBD_NKEYCODE; key++) {
+ if (hidbus_locate(ptr, len,
+ HID_USAGE2(HUP_KEYBOARD, key),
+ hid_input, tlc_index, 0, &sc->sc_loc_key[key], &flags,
+ &sc->sc_id_loc_key[key], NULL)) {
+ if (flags & HIO_VARIABLE) {
+ sc->sc_loc_key_valid[key / 64] |=
+ 1ULL << (key % 64);
+ DPRINTFN(1, "Found key 0x%02x\n", key);
+ }
+ }
+ }
+
+ /* figure out leds on keyboard */
+ if (hidbus_locate(ptr, len,
+ HID_USAGE2(HUP_LEDS, 0x01),
+ hid_output, tlc_index, 0, &sc->sc_loc_numlock, &flags,
+ &sc->sc_id_leds, NULL)) {
+ if (flags & HIO_VARIABLE)
+ sc->sc_flags |= HKBD_FLAG_NUMLOCK;
+ DPRINTFN(1, "Found keyboard numlock\n");
+ }
+ if (hidbus_locate(ptr, len,
+ HID_USAGE2(HUP_LEDS, 0x02),
+ hid_output, tlc_index, 0, &sc->sc_loc_capslock, &flags,
+ &id, NULL)) {
+ if ((sc->sc_flags & HKBD_FLAG_NUMLOCK) == 0)
+ sc->sc_id_leds = id;
+ if (flags & HIO_VARIABLE && sc->sc_id_leds == id)
+ sc->sc_flags |= HKBD_FLAG_CAPSLOCK;
+ DPRINTFN(1, "Found keyboard capslock\n");
+ }
+ if (hidbus_locate(ptr, len,
+ HID_USAGE2(HUP_LEDS, 0x03),
+ hid_output, tlc_index, 0, &sc->sc_loc_scrolllock, &flags,
+ &id, NULL)) {
+ if ((sc->sc_flags & (HKBD_FLAG_NUMLOCK | HKBD_FLAG_CAPSLOCK))
+ == 0)
+ sc->sc_id_leds = id;
+ if (flags & HIO_VARIABLE && sc->sc_id_leds == id)
+ sc->sc_flags |= HKBD_FLAG_SCROLLLOCK;
+ DPRINTFN(1, "Found keyboard scrolllock\n");
+ }
+
+ if ((sc->sc_flags & (HKBD_FLAG_NUMLOCK | HKBD_FLAG_CAPSLOCK |
+ HKBD_FLAG_SCROLLLOCK)) != 0)
+ sc->sc_led_size = hid_report_size(ptr, len,
+ hid_output, sc->sc_id_leds);
+}
+
+static int
+hkbd_attach(device_t dev)
+{
+ struct hkbd_softc *sc = device_get_softc(dev);
+ const struct hid_device_info *hw = hid_get_device_info(dev);
+ int unit = device_get_unit(dev);
+ keyboard_t *kbd = &sc->sc_kbd;
+ void *hid_ptr = NULL;
+ int err;
+ uint16_t n;
+ hid_size_t hid_len;
+ uint8_t tlc_index = hidbus_get_index(dev);
+#ifdef EVDEV_SUPPORT
+ struct evdev_dev *evdev;
+ int i;
+#endif
+
+ sc->sc_dev = dev;
+ SYSCONS_LOCK_ASSERT();
+
+ kbd_init_struct(kbd, HKBD_DRIVER_NAME, KB_OTHER, unit, 0, 0, 0);
+
+ kbd->kb_data = (void *)sc;
+
+ sc->sc_mode = K_XLATE;
+
+ mtx_init(&sc->sc_mtx, "hkbd lock", NULL, MTX_DEF);
+ TASK_INIT(&sc->sc_task, 0, hkbd_event_keyinput, sc);
+ callout_init_mtx(&sc->sc_callout, &sc->sc_mtx, 0);
+
+ hidbus_set_intr(dev, hkbd_intr_callback, sc);
+ /* interrupt handler will be called with hkbd mutex taken */
+ hidbus_set_lock(dev, &sc->sc_mtx);
+ /* interrupt handler can be called during panic */
+ hidbus_set_flags(dev, hidbus_get_flags(dev) & HIDBUS_FLAG_CAN_POLL);
+
+ /* setup default keyboard maps */
+
+ sc->sc_keymap = key_map;
+ sc->sc_accmap = accent_map;
+ for (n = 0; n < HKBD_NFKEY; n++) {
+ sc->sc_fkeymap[n] = fkey_tab[n];
+ }
+
+ kbd_set_maps(kbd, &sc->sc_keymap, &sc->sc_accmap,
+ sc->sc_fkeymap, HKBD_NFKEY);
+
+ KBD_FOUND_DEVICE(kbd);
+
+ hkbd_clear_state(kbd);
+
+ /*
+ * FIXME: set the initial value for lock keys in "sc_state"
+ * according to the BIOS data?
+ */
+ KBD_PROBE_DONE(kbd);
+
+ /* get HID descriptor */
+ err = hid_get_report_descr(dev, &hid_ptr, &hid_len);
+
+ if (err == 0) {
+ DPRINTF("Parsing HID descriptor of %d bytes\n",
+ (int)hid_len);
+
+ hkbd_parse_hid(sc, hid_ptr, hid_len, tlc_index);
+ }
+
+ /* check if we should use the boot protocol */
+ if (hid_test_quirk(hw, HQ_KBD_BOOTPROTO) ||
+ (err != 0) || hkbd_any_key_valid(sc) == false) {
+ DPRINTF("Forcing boot protocol\n");
+
+ err = hid_set_protocol(dev, 0);
+
+ if (err != 0) {
+ DPRINTF("Set protocol error=%d (ignored)\n", err);
+ }
+
+ hkbd_parse_hid(sc, hkbd_boot_desc, sizeof(hkbd_boot_desc), 0);
+ }
+
+ /* ignore if SETIDLE fails, hence it is not crucial */
+ hid_set_idle(dev, 0, 0);
+
+ hkbd_ioctl(kbd, KDSETLED, (caddr_t)&sc->sc_state);
+
+ KBD_INIT_DONE(kbd);
+
+ if (kbd_register(kbd) < 0) {
+ goto detach;
+ }
+ KBD_CONFIG_DONE(kbd);
+
+ hkbd_enable(kbd);
+
+#ifdef KBD_INSTALL_CDEV
+ if (kbd_attach(kbd)) {
+ goto detach;
+ }
+#endif
+
+#ifdef EVDEV_SUPPORT
+ evdev = evdev_alloc();
+ evdev_set_name(evdev, device_get_desc(dev));
+ evdev_set_phys(evdev, device_get_nameunit(dev));
+ evdev_set_id(evdev, hw->idBus, hw->idVendor, hw->idProduct,
+ hw->idVersion);
+ evdev_set_serial(evdev, hw->serial);
+ evdev_set_methods(evdev, kbd, &hkbd_evdev_methods);
+ evdev_support_event(evdev, EV_SYN);
+ evdev_support_event(evdev, EV_KEY);
+ if (sc->sc_flags & (HKBD_FLAG_NUMLOCK | HKBD_FLAG_CAPSLOCK |
+ HKBD_FLAG_SCROLLLOCK))
+ evdev_support_event(evdev, EV_LED);
+ evdev_support_event(evdev, EV_REP);
+
+ for (i = 0x00; i <= 0xFF; i++)
+ evdev_support_key(evdev, evdev_hid2key(i));
+ if (sc->sc_flags & HKBD_FLAG_NUMLOCK)
+ evdev_support_led(evdev, LED_NUML);
+ if (sc->sc_flags & HKBD_FLAG_CAPSLOCK)
+ evdev_support_led(evdev, LED_CAPSL);
+ if (sc->sc_flags & HKBD_FLAG_SCROLLLOCK)
+ evdev_support_led(evdev, LED_SCROLLL);
+
+ if (evdev_register_epoch(evdev, HIDBUS_EPOCH))
+ evdev_free(evdev);
+ else
+ sc->sc_evdev = evdev;
+#endif
+
+ sc->sc_flags |= HKBD_FLAG_ATTACHED;
+
+ if (bootverbose) {
+ kbdd_diag(kbd, bootverbose);
+ }
+
+ /* start the keyboard */
+ hidbus_intr_start(dev);
+
+ return (0); /* success */
+
+detach:
+ hkbd_detach(dev);
+ return (ENXIO); /* error */
+}
+
+static int
+hkbd_detach(device_t dev)
+{
+ struct hkbd_softc *sc = device_get_softc(dev);
+ int error;
+
+ SYSCONS_LOCK_ASSERT();
+
+ DPRINTF("\n");
+
+ sc->sc_flags |= HKBD_FLAG_GONE;
+
+ HKBD_LOCK(sc);
+ callout_stop(&sc->sc_callout);
+ HKBD_UNLOCK(sc);
+
+ /* kill any stuck keys */
+ if (sc->sc_flags & HKBD_FLAG_ATTACHED) {
+ /* stop receiving events from the USB keyboard */
+ hidbus_intr_stop(dev);
+
+ /* release all leftover keys, if any */
+ memset(&sc->sc_ndata, 0, sizeof(sc->sc_ndata));
+
+ /* process releasing of all keys */
+ HKBD_LOCK(sc);
+ hkbd_interrupt(sc);
+ HKBD_UNLOCK(sc);
+ taskqueue_drain(taskqueue_swi_giant, &sc->sc_task);
+ }
+
+ mtx_destroy(&sc->sc_mtx);
+ hkbd_disable(&sc->sc_kbd);
+
+#ifdef KBD_INSTALL_CDEV
+ if (sc->sc_flags & HKBD_FLAG_ATTACHED) {
+ error = kbd_detach(&sc->sc_kbd);
+ if (error) {
+ /* usb attach cannot return an error */
+ device_printf(dev, "WARNING: kbd_detach() "
+ "returned non-zero! (ignored)\n");
+ }
+ }
+#endif
+
+#ifdef EVDEV_SUPPORT
+ evdev_free(sc->sc_evdev);
+#endif
+
+ if (KBD_IS_CONFIGURED(&sc->sc_kbd)) {
+ error = kbd_unregister(&sc->sc_kbd);
+ if (error) {
+ /* usb attach cannot return an error */
+ device_printf(dev, "WARNING: kbd_unregister() "
+ "returned non-zero! (ignored)\n");
+ }
+ }
+ sc->sc_kbd.kb_flags = 0;
+
+ DPRINTF("%s: disconnected\n",
+ device_get_nameunit(dev));
+
+ return (0);
+}
+
+static int
+hkbd_resume(device_t dev)
+{
+ struct hkbd_softc *sc = device_get_softc(dev);
+
+ SYSCONS_LOCK_ASSERT();
+
+ hkbd_clear_state(&sc->sc_kbd);
+
+ return (0);
+}
+
+#ifdef EVDEV_SUPPORT
+static void
+hkbd_ev_event(struct evdev_dev *evdev, uint16_t type, uint16_t code,
+ int32_t value)
+{
+ keyboard_t *kbd = evdev_get_softc(evdev);
+
+ if (evdev_rcpt_mask & EVDEV_RCPT_HW_KBD &&
+ (type == EV_LED || type == EV_REP)) {
+ mtx_lock(&Giant);
+ kbd_ev_event(kbd, type, code, value);
+ mtx_unlock(&Giant);
+ }
+}
+#endif
+
+/* early keyboard probe, not supported */
+static int
+hkbd_configure(int flags)
+{
+ return (0);
+}
+
+/* detect a keyboard, not used */
+static int
+hkbd__probe(int unit, void *arg, int flags)
+{
+ return (ENXIO);
+}
+
+/* reset and initialize the device, not used */
+static int
+hkbd_init(int unit, keyboard_t **kbdp, void *arg, int flags)
+{
+ return (ENXIO);
+}
+
+/* test the interface to the device, not used */
+static int
+hkbd_test_if(keyboard_t *kbd)
+{
+ return (0);
+}
+
+/* finish using this keyboard, not used */
+static int
+hkbd_term(keyboard_t *kbd)
+{
+ return (ENXIO);
+}
+
+/* keyboard interrupt routine, not used */
+static int
+hkbd_intr(keyboard_t *kbd, void *arg)
+{
+ return (0);
+}
+
+/* lock the access to the keyboard, not used */
+static int
+hkbd_lock(keyboard_t *kbd, int lock)
+{
+ return (1);
+}
+
+/*
+ * Enable the access to the device; until this function is called,
+ * the client cannot read from the keyboard.
+ */
+static int
+hkbd_enable(keyboard_t *kbd)
+{
+
+ SYSCONS_LOCK();
+ KBD_ACTIVATE(kbd);
+ SYSCONS_UNLOCK();
+
+ return (0);
+}
+
+/* disallow the access to the device */
+static int
+hkbd_disable(keyboard_t *kbd)
+{
+
+ SYSCONS_LOCK();
+ KBD_DEACTIVATE(kbd);
+ SYSCONS_UNLOCK();
+
+ return (0);
+}
+
+/* check if data is waiting */
+/* Currently unused. */
+static int
+hkbd_check(keyboard_t *kbd)
+{
+ struct hkbd_softc *sc = kbd->kb_data;
+
+ SYSCONS_LOCK_ASSERT();
+
+ if (!KBD_IS_ACTIVE(kbd))
+ return (0);
+
+ if (sc->sc_flags & HKBD_FLAG_POLLING)
+ hkbd_do_poll(sc, 0);
+
+#ifdef HKBD_EMULATE_ATSCANCODE
+ if (sc->sc_buffered_char[0]) {
+ return (1);
+ }
+#endif
+ if (sc->sc_inputhead != atomic_load_acq_32(&sc->sc_inputtail)) {
+ return (1);
+ }
+ return (0);
+}
+
+/* check if char is waiting */
+static int
+hkbd_check_char_locked(keyboard_t *kbd)
+{
+ struct hkbd_softc *sc = kbd->kb_data;
+
+ SYSCONS_LOCK_ASSERT();
+
+ if (!KBD_IS_ACTIVE(kbd))
+ return (0);
+
+ if ((sc->sc_composed_char > 0) &&
+ (!(sc->sc_flags & HKBD_FLAG_COMPOSE))) {
+ return (1);
+ }
+ return (hkbd_check(kbd));
+}
+
+static int
+hkbd_check_char(keyboard_t *kbd)
+{
+ int result;
+
+ SYSCONS_LOCK();
+ result = hkbd_check_char_locked(kbd);
+ SYSCONS_UNLOCK();
+
+ return (result);
+}
+
+/* read one byte from the keyboard if it's allowed */
+/* Currently unused. */
+static int
+hkbd_read(keyboard_t *kbd, int wait)
+{
+ struct hkbd_softc *sc = kbd->kb_data;
+ int32_t usbcode;
+#ifdef HKBD_EMULATE_ATSCANCODE
+ uint32_t keycode;
+ uint32_t scancode;
+
+#endif
+
+ SYSCONS_LOCK_ASSERT();
+
+ if (!KBD_IS_ACTIVE(kbd))
+ return (-1);
+
+#ifdef HKBD_EMULATE_ATSCANCODE
+ if (sc->sc_buffered_char[0]) {
+ scancode = sc->sc_buffered_char[0];
+ if (scancode & SCAN_PREFIX) {
+ sc->sc_buffered_char[0] &= ~SCAN_PREFIX;
+ return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1);
+ }
+ sc->sc_buffered_char[0] = sc->sc_buffered_char[1];
+ sc->sc_buffered_char[1] = 0;
+ return (scancode);
+ }
+#endif /* HKBD_EMULATE_ATSCANCODE */
+
+ /* XXX */
+ usbcode = hkbd_get_key(sc, (wait == FALSE) ? 0 : 1);
+ if (!KBD_IS_ACTIVE(kbd) || (usbcode == -1))
+ return (-1);
+
+ ++(kbd->kb_count);
+
+#ifdef HKBD_EMULATE_ATSCANCODE
+ keycode = hkbd_atkeycode(usbcode, sc->sc_ndata.bitmap);
+ if (keycode == NN) {
+ return -1;
+ }
+ return (hkbd_key2scan(sc, keycode, sc->sc_ndata.bitmap,
+ (usbcode & KEY_RELEASE)));
+#else /* !HKBD_EMULATE_ATSCANCODE */
+ return (usbcode);
+#endif /* HKBD_EMULATE_ATSCANCODE */
+}
+
+/* read char from the keyboard */
+static uint32_t
+hkbd_read_char_locked(keyboard_t *kbd, int wait)
+{
+ struct hkbd_softc *sc = kbd->kb_data;
+ uint32_t action;
+ uint32_t keycode;
+ int32_t usbcode;
+#ifdef HKBD_EMULATE_ATSCANCODE
+ uint32_t scancode;
+#endif
+
+ SYSCONS_LOCK_ASSERT();
+
+ if (!KBD_IS_ACTIVE(kbd))
+ return (NOKEY);
+
+next_code:
+
+ /* do we have a composed char to return ? */
+
+ if ((sc->sc_composed_char > 0) &&
+ (!(sc->sc_flags & HKBD_FLAG_COMPOSE))) {
+ action = sc->sc_composed_char;
+ sc->sc_composed_char = 0;
+
+ if (action > 0xFF) {
+ goto errkey;
+ }
+ goto done;
+ }
+#ifdef HKBD_EMULATE_ATSCANCODE
+
+ /* do we have a pending raw scan code? */
+
+ if (sc->sc_mode == K_RAW) {
+ scancode = sc->sc_buffered_char[0];
+ if (scancode) {
+ if (scancode & SCAN_PREFIX) {
+ sc->sc_buffered_char[0] = (scancode & ~SCAN_PREFIX);
+ return ((scancode & SCAN_PREFIX_E0) ? 0xe0 : 0xe1);
+ }
+ sc->sc_buffered_char[0] = sc->sc_buffered_char[1];
+ sc->sc_buffered_char[1] = 0;
+ return (scancode);
+ }
+ }
+#endif /* HKBD_EMULATE_ATSCANCODE */
+
+ /* see if there is something in the keyboard port */
+ /* XXX */
+ usbcode = hkbd_get_key(sc, (wait == FALSE) ? 0 : 1);
+ if (usbcode == -1) {
+ return (NOKEY);
+ }
+ ++kbd->kb_count;
+
+#ifdef HKBD_EMULATE_ATSCANCODE
+ /* USB key index -> key code -> AT scan code */
+ keycode = hkbd_atkeycode(usbcode, sc->sc_ndata.bitmap);
+ if (keycode == NN) {
+ return (NOKEY);
+ }
+ /* return an AT scan code for the K_RAW mode */
+ if (sc->sc_mode == K_RAW) {
+ return (hkbd_key2scan(sc, keycode, sc->sc_ndata.bitmap,
+ (usbcode & KEY_RELEASE)));
+ }
+#else /* !HKBD_EMULATE_ATSCANCODE */
+
+ /* return the byte as is for the K_RAW mode */
+ if (sc->sc_mode == K_RAW) {
+ return (usbcode);
+ }
+ /* USB key index -> key code */
+ keycode = hkbd_trtab[KEY_INDEX(usbcode)];
+ if (keycode == NN) {
+ return (NOKEY);
+ }
+#endif /* HKBD_EMULATE_ATSCANCODE */
+
+ switch (keycode) {
+ case 0x38: /* left alt (compose key) */
+ if (usbcode & KEY_RELEASE) {
+ if (sc->sc_flags & HKBD_FLAG_COMPOSE) {
+ sc->sc_flags &= ~HKBD_FLAG_COMPOSE;
+
+ if (sc->sc_composed_char > 0xFF) {
+ sc->sc_composed_char = 0;
+ }
+ }
+ } else {
+ if (!(sc->sc_flags & HKBD_FLAG_COMPOSE)) {
+ sc->sc_flags |= HKBD_FLAG_COMPOSE;
+ sc->sc_composed_char = 0;
+ }
+ }
+ break;
+ }
+
+ /* return the key code in the K_CODE mode */
+ if (usbcode & KEY_RELEASE) {
+ keycode |= SCAN_RELEASE;
+ }
+ if (sc->sc_mode == K_CODE) {
+ return (keycode);
+ }
+ /* compose a character code */
+ if (sc->sc_flags & HKBD_FLAG_COMPOSE) {
+ switch (keycode) {
+ /* key pressed, process it */
+ case 0x47:
+ case 0x48:
+ case 0x49: /* keypad 7,8,9 */
+ sc->sc_composed_char *= 10;
+ sc->sc_composed_char += keycode - 0x40;
+ goto check_composed;
+
+ case 0x4B:
+ case 0x4C:
+ case 0x4D: /* keypad 4,5,6 */
+ sc->sc_composed_char *= 10;
+ sc->sc_composed_char += keycode - 0x47;
+ goto check_composed;
+
+ case 0x4F:
+ case 0x50:
+ case 0x51: /* keypad 1,2,3 */
+ sc->sc_composed_char *= 10;
+ sc->sc_composed_char += keycode - 0x4E;
+ goto check_composed;
+
+ case 0x52: /* keypad 0 */
+ sc->sc_composed_char *= 10;
+ goto check_composed;
+
+ /* key released, no interest here */
+ case SCAN_RELEASE | 0x47:
+ case SCAN_RELEASE | 0x48:
+ case SCAN_RELEASE | 0x49: /* keypad 7,8,9 */
+ case SCAN_RELEASE | 0x4B:
+ case SCAN_RELEASE | 0x4C:
+ case SCAN_RELEASE | 0x4D: /* keypad 4,5,6 */
+ case SCAN_RELEASE | 0x4F:
+ case SCAN_RELEASE | 0x50:
+ case SCAN_RELEASE | 0x51: /* keypad 1,2,3 */
+ case SCAN_RELEASE | 0x52: /* keypad 0 */
+ goto next_code;
+
+ case 0x38: /* left alt key */
+ break;
+
+ default:
+ if (sc->sc_composed_char > 0) {
+ sc->sc_flags &= ~HKBD_FLAG_COMPOSE;
+ sc->sc_composed_char = 0;
+ goto errkey;
+ }
+ break;
+ }
+ }
+ /* keycode to key action */
+ action = genkbd_keyaction(kbd, SCAN_CHAR(keycode),
+ (keycode & SCAN_RELEASE),
+ &sc->sc_state, &sc->sc_accents);
+ if (action == NOKEY) {
+ goto next_code;
+ }
+done:
+ return (action);
+
+check_composed:
+ if (sc->sc_composed_char <= 0xFF) {
+ goto next_code;
+ }
+errkey:
+ return (ERRKEY);
+}
+
+/* Currently wait is always false. */
+static uint32_t
+hkbd_read_char(keyboard_t *kbd, int wait)
+{
+ uint32_t keycode;
+
+ SYSCONS_LOCK();
+ keycode = hkbd_read_char_locked(kbd, wait);
+ SYSCONS_UNLOCK();
+
+ return (keycode);
+}
+
+/* some useful control functions */
+static int
+hkbd_ioctl_locked(keyboard_t *kbd, u_long cmd, caddr_t arg)
+{
+ struct hkbd_softc *sc = kbd->kb_data;
+ int i;
+#if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
+ defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
+ int ival;
+
+#endif
+
+ SYSCONS_LOCK_ASSERT();
+
+ switch (cmd) {
+ case KDGKBMODE: /* get keyboard mode */
+ *(int *)arg = sc->sc_mode;
+ break;
+#if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
+ defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
+ case _IO('K', 7):
+ ival = IOCPARM_IVAL(arg);
+ arg = (caddr_t)&ival;
+ /* FALLTHROUGH */
+#endif
+ case KDSKBMODE: /* set keyboard mode */
+ switch (*(int *)arg) {
+ case K_XLATE:
+ if (sc->sc_mode != K_XLATE) {
+ /* make lock key state and LED state match */
+ sc->sc_state &= ~LOCK_MASK;
+ sc->sc_state |= KBD_LED_VAL(kbd);
+ }
+ /* FALLTHROUGH */
+ case K_RAW:
+ case K_CODE:
+ if (sc->sc_mode != *(int *)arg) {
+ if ((sc->sc_flags & HKBD_FLAG_POLLING) == 0)
+ hkbd_clear_state(kbd);
+ sc->sc_mode = *(int *)arg;
+ }
+ break;
+ default:
+ return (EINVAL);
+ }
+ break;
+
+ case KDGETLED: /* get keyboard LED */
+ *(int *)arg = KBD_LED_VAL(kbd);
+ break;
+#if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
+ defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
+ case _IO('K', 66):
+ ival = IOCPARM_IVAL(arg);
+ arg = (caddr_t)&ival;
+ /* FALLTHROUGH */
+#endif
+ case KDSETLED: /* set keyboard LED */
+ /* NOTE: lock key state in "sc_state" won't be changed */
+ if (*(int *)arg & ~LOCK_MASK)
+ return (EINVAL);
+
+ i = *(int *)arg;
+
+ /* replace CAPS LED with ALTGR LED for ALTGR keyboards */
+ if (sc->sc_mode == K_XLATE &&
+ kbd->kb_keymap->n_keys > ALTGR_OFFSET) {
+ if (i & ALKED)
+ i |= CLKED;
+ else
+ i &= ~CLKED;
+ }
+ KBD_LED_VAL(kbd) = *(int *)arg;
+ if (KBD_HAS_DEVICE(kbd))
+ return (hkbd_set_leds(sc, i));
+ break;
+
+ case KDGKBSTATE: /* get lock key state */
+ *(int *)arg = sc->sc_state & LOCK_MASK;
+ break;
+#if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
+ defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
+ case _IO('K', 20):
+ ival = IOCPARM_IVAL(arg);
+ arg = (caddr_t)&ival;
+ /* FALLTHROUGH */
+#endif
+ case KDSKBSTATE: /* set lock key state */
+ if (*(int *)arg & ~LOCK_MASK) {
+ return (EINVAL);
+ }
+ sc->sc_state &= ~LOCK_MASK;
+ sc->sc_state |= *(int *)arg;
+
+ /* set LEDs and quit */
+ return (hkbd_ioctl(kbd, KDSETLED, arg));
+
+ case KDSETREPEAT: /* set keyboard repeat rate (new
+ * interface) */
+ if (!KBD_HAS_DEVICE(kbd)) {
+ return (0);
+ }
+ /*
+ * Convert negative, zero and tiny args to the same limits
+ * as atkbd. We could support delays of 1 msec, but
+ * anything much shorter than the shortest atkbd value
+ * of 250.34 is almost unusable as well as incompatible.
+ */
+ kbd->kb_delay1 = imax(((int *)arg)[0], 250);
+ kbd->kb_delay2 = imax(((int *)arg)[1], 34);
+#ifdef EVDEV_SUPPORT
+ if (sc->sc_evdev != NULL)
+ evdev_push_repeats(sc->sc_evdev, kbd);
+#endif
+ return (0);
+
+#if defined(COMPAT_FREEBSD6) || defined(COMPAT_FREEBSD5) || \
+ defined(COMPAT_FREEBSD4) || defined(COMPAT_43)
+ case _IO('K', 67):
+ ival = IOCPARM_IVAL(arg);
+ arg = (caddr_t)&ival;
+ /* FALLTHROUGH */
+#endif
+ case KDSETRAD: /* set keyboard repeat rate (old
+ * interface) */
+ return (hkbd_set_typematic(kbd, *(int *)arg));
+
+ case PIO_KEYMAP: /* set keyboard translation table */
+ case OPIO_KEYMAP: /* set keyboard translation table
+ * (compat) */
+ case PIO_KEYMAPENT: /* set keyboard translation table
+ * entry */
+ case PIO_DEADKEYMAP: /* set accent key translation table */
+ sc->sc_accents = 0;
+ /* FALLTHROUGH */
+ default:
+ return (genkbd_commonioctl(kbd, cmd, arg));
+ }
+
+ return (0);
+}
+
+static int
+hkbd_ioctl(keyboard_t *kbd, u_long cmd, caddr_t arg)
+{
+ int result;
+
+ /*
+ * XXX Check if someone is calling us from a critical section:
+ */
+ if (curthread->td_critnest != 0)
+ return (EDEADLK);
+
+ /*
+ * XXX KDGKBSTATE, KDSKBSTATE and KDSETLED can be called from any
+ * context where printf(9) can be called, which among other things
+ * includes interrupt filters and threads with any kinds of locks
+ * already held. For this reason it would be dangerous to acquire
+ * the Giant here unconditionally. On the other hand we have to
+ * have it to handle the ioctl.
+ * So we make our best effort to auto-detect whether we can grab
+ * the Giant or not. Blame syscons(4) for this.
+ */
+ switch (cmd) {
+ case KDGKBSTATE:
+ case KDSKBSTATE:
+ case KDSETLED:
+ if (!mtx_owned(&Giant) && !HID_IN_POLLING_MODE())
+ return (EDEADLK); /* best I could come up with */
+ /* FALLTHROUGH */
+ default:
+ SYSCONS_LOCK();
+ result = hkbd_ioctl_locked(kbd, cmd, arg);
+ SYSCONS_UNLOCK();
+ return (result);
+ }
+}
+
+/* clear the internal state of the keyboard */
+static void
+hkbd_clear_state(keyboard_t *kbd)
+{
+ struct hkbd_softc *sc = kbd->kb_data;
+
+ SYSCONS_LOCK_ASSERT();
+
+ sc->sc_flags &= ~(HKBD_FLAG_COMPOSE | HKBD_FLAG_POLLING);
+ sc->sc_state &= LOCK_MASK; /* preserve locking key state */
+ sc->sc_accents = 0;
+ sc->sc_composed_char = 0;
+#ifdef HKBD_EMULATE_ATSCANCODE
+ sc->sc_buffered_char[0] = 0;
+ sc->sc_buffered_char[1] = 0;
+#endif
+ memset(&sc->sc_ndata, 0, sizeof(sc->sc_ndata));
+ memset(&sc->sc_odata, 0, sizeof(sc->sc_odata));
+ sc->sc_repeat_time = 0;
+ sc->sc_repeat_key = 0;
+}
+
+/* save the internal state, not used */
+static int
+hkbd_get_state(keyboard_t *kbd, void *buf, size_t len)
+{
+ return (len == 0) ? 1 : -1;
+}
+
+/* set the internal state, not used */
+static int
+hkbd_set_state(keyboard_t *kbd, void *buf, size_t len)
+{
+ return (EINVAL);
+}
+
+static int
+hkbd_poll(keyboard_t *kbd, int on)
+{
+ struct hkbd_softc *sc = kbd->kb_data;
+
+ SYSCONS_LOCK();
+ /*
+ * Keep a reference count on polling to allow recursive
+ * cngrab() during a panic for example.
+ */
+ if (on)
+ sc->sc_polling++;
+ else if (sc->sc_polling > 0)
+ sc->sc_polling--;
+
+ if (sc->sc_polling != 0) {
+ sc->sc_flags |= HKBD_FLAG_POLLING;
+ sc->sc_poll_thread = curthread;
+ } else {
+ sc->sc_flags &= ~HKBD_FLAG_POLLING;
+ sc->sc_delay = 0;
+ }
+ SYSCONS_UNLOCK();
+
+ return (0);
+}
+
+/* local functions */
+
+static int
+hkbd_set_leds(struct hkbd_softc *sc, uint8_t leds)
+{
+ uint8_t id;
+ uint8_t any;
+ uint8_t *buf;
+ int len;
+ int error;
+
+ SYSCONS_LOCK_ASSERT();
+ DPRINTF("leds=0x%02x\n", leds);
+
+#ifdef HID_DEBUG
+ if (hkbd_no_leds)
+ return (0);
+#endif
+
+ memset(sc->sc_buffer, 0, HKBD_BUFFER_SIZE);
+
+ id = sc->sc_id_leds;
+ any = 0;
+
+ /* Assumption: All led bits must be in the same ID. */
+
+ if (sc->sc_flags & HKBD_FLAG_NUMLOCK) {
+ hid_put_data_unsigned(sc->sc_buffer + 1, HKBD_BUFFER_SIZE - 1,
+ &sc->sc_loc_numlock, leds & NLKED ? 1 : 0);
+ any = 1;
+ }
+
+ if (sc->sc_flags & HKBD_FLAG_SCROLLLOCK) {
+ hid_put_data_unsigned(sc->sc_buffer + 1, HKBD_BUFFER_SIZE - 1,
+ &sc->sc_loc_scrolllock, leds & SLKED ? 1 : 0);
+ any = 1;
+ }
+
+ if (sc->sc_flags & HKBD_FLAG_CAPSLOCK) {
+ hid_put_data_unsigned(sc->sc_buffer + 1, HKBD_BUFFER_SIZE - 1,
+ &sc->sc_loc_capslock, leds & CLKED ? 1 : 0);
+ any = 1;
+ }
+
+ /* if no leds, nothing to do */
+ if (!any)
+ return (0);
+
+#ifdef EVDEV_SUPPORT
+ if (sc->sc_evdev != NULL)
+ evdev_push_leds(sc->sc_evdev, leds);
+#endif
+
+ /* range check output report length */
+ len = sc->sc_led_size;
+ if (len > (HKBD_BUFFER_SIZE - 1))
+ len = (HKBD_BUFFER_SIZE - 1);
+
+ /* check if we need to prefix an ID byte */
+
+ if (id != 0) {
+ sc->sc_buffer[0] = id;
+ buf = sc->sc_buffer;
+ } else {
+ buf = sc->sc_buffer + 1;
+ }
+
+ DPRINTF("len=%d, id=%d\n", len, id);
+
+ /* start data transfer */
+ SYSCONS_UNLOCK();
+ error = hid_write(sc->sc_dev, buf, len);
+ SYSCONS_LOCK();
+
+ return (error);
+}
+
+static int
+hkbd_set_typematic(keyboard_t *kbd, int code)
+{
+#ifdef EVDEV_SUPPORT
+ struct hkbd_softc *sc = kbd->kb_data;
+#endif
+ static const int delays[] = {250, 500, 750, 1000};
+ static const int rates[] = {34, 38, 42, 46, 50, 55, 59, 63,
+ 68, 76, 84, 92, 100, 110, 118, 126,
+ 136, 152, 168, 184, 200, 220, 236, 252,
+ 272, 304, 336, 368, 400, 440, 472, 504};
+
+ if (code & ~0x7f) {
+ return (EINVAL);
+ }
+ kbd->kb_delay1 = delays[(code >> 5) & 3];
+ kbd->kb_delay2 = rates[code & 0x1f];
+#ifdef EVDEV_SUPPORT
+ if (sc->sc_evdev != NULL)
+ evdev_push_repeats(sc->sc_evdev, kbd);
+#endif
+ return (0);
+}
+
+#ifdef HKBD_EMULATE_ATSCANCODE
+static uint32_t
+hkbd_atkeycode(int usbcode, const uint64_t *bitmap)
+{
+ uint32_t keycode;
+
+ keycode = hkbd_trtab[KEY_INDEX(usbcode)];
+
+ /*
+ * Translate Alt-PrintScreen to SysRq.
+ *
+ * Some or all AT keyboards connected through USB have already
+ * mapped Alted PrintScreens to an unusual usbcode (0x8a).
+ * hkbd_trtab translates this to 0x7e, and key2scan() would
+ * translate that to 0x79 (Intl' 4). Assume that if we have
+ * an Alted 0x7e here then it actually is an Alted PrintScreen.
+ *
+ * The usual usbcode for all PrintScreens is 0x46. hkbd_trtab
+ * translates this to 0x5c, so the Alt check to classify 0x5c
+ * is routine.
+ */
+ if ((keycode == 0x5c || keycode == 0x7e) &&
+ (HKBD_KEY_PRESSED(bitmap, 0xe2 /* ALT-L */) ||
+ HKBD_KEY_PRESSED(bitmap, 0xe6 /* ALT-R */)))
+ return (0x54);
+ return (keycode);
+}
+
+static int
+hkbd_key2scan(struct hkbd_softc *sc, int code, const uint64_t *bitmap, int up)
+{
+ static const int scan[] = {
+ /* 89 */
+ 0x11c, /* Enter */
+ /* 90-99 */
+ 0x11d, /* Ctrl-R */
+ 0x135, /* Divide */
+ 0x137, /* PrintScreen */
+ 0x138, /* Alt-R */
+ 0x147, /* Home */
+ 0x148, /* Up */
+ 0x149, /* PageUp */
+ 0x14b, /* Left */
+ 0x14d, /* Right */
+ 0x14f, /* End */
+ /* 100-109 */
+ 0x150, /* Down */
+ 0x151, /* PageDown */
+ 0x152, /* Insert */
+ 0x153, /* Delete */
+ 0x146, /* Pause/Break */
+ 0x15b, /* Win_L(Super_L) */
+ 0x15c, /* Win_R(Super_R) */
+ 0x15d, /* Application(Menu) */
+
+ /* SUN TYPE 6 USB KEYBOARD */
+ 0x168, /* Sun Type 6 Help */
+ 0x15e, /* Sun Type 6 Stop */
+ /* 110 - 119 */
+ 0x15f, /* Sun Type 6 Again */
+ 0x160, /* Sun Type 6 Props */
+ 0x161, /* Sun Type 6 Undo */
+ 0x162, /* Sun Type 6 Front */
+ 0x163, /* Sun Type 6 Copy */
+ 0x164, /* Sun Type 6 Open */
+ 0x165, /* Sun Type 6 Paste */
+ 0x166, /* Sun Type 6 Find */
+ 0x167, /* Sun Type 6 Cut */
+ 0x125, /* Sun Type 6 Mute */
+ /* 120 - 130 */
+ 0x11f, /* Sun Type 6 VolumeDown */
+ 0x11e, /* Sun Type 6 VolumeUp */
+ 0x120, /* Sun Type 6 PowerDown */
+
+ /* Japanese 106/109 keyboard */
+ 0x73, /* Keyboard Intl' 1 (backslash / underscore) */
+ 0x70, /* Keyboard Intl' 2 (Katakana / Hiragana) */
+ 0x7d, /* Keyboard Intl' 3 (Yen sign) (Not using in jp106/109) */
+ 0x79, /* Keyboard Intl' 4 (Henkan) */
+ 0x7b, /* Keyboard Intl' 5 (Muhenkan) */
+ 0x5c, /* Keyboard Intl' 6 (Keypad ,) (For PC-9821 layout) */
+ 0x71, /* Apple Keyboard JIS (Kana) */
+ 0x72, /* Apple Keyboard JIS (Eisu) */
+ };
+
+ if ((code >= 89) && (code < (int)(89 + nitems(scan)))) {
+ code = scan[code - 89];
+ }
+ /* PrintScreen */
+ if (code == 0x137 && (!(
+ HKBD_KEY_PRESSED(bitmap, 0xe0 /* CTRL-L */) ||
+ HKBD_KEY_PRESSED(bitmap, 0xe4 /* CTRL-R */) ||
+ HKBD_KEY_PRESSED(bitmap, 0xe1 /* SHIFT-L */) ||
+ HKBD_KEY_PRESSED(bitmap, 0xe5 /* SHIFT-R */)))) {
+ code |= SCAN_PREFIX_SHIFT;
+ }
+ /* Pause/Break */
+ if ((code == 0x146) && (!(
+ HKBD_KEY_PRESSED(bitmap, 0xe0 /* CTRL-L */) ||
+ HKBD_KEY_PRESSED(bitmap, 0xe4 /* CTRL-R */)))) {
+ code = (0x45 | SCAN_PREFIX_E1 | SCAN_PREFIX_CTL);
+ }
+ code |= (up ? SCAN_RELEASE : SCAN_PRESS);
+
+ if (code & SCAN_PREFIX) {
+ if (code & SCAN_PREFIX_CTL) {
+ /* Ctrl */
+ sc->sc_buffered_char[0] = (0x1d | (code & SCAN_RELEASE));
+ sc->sc_buffered_char[1] = (code & ~SCAN_PREFIX);
+ } else if (code & SCAN_PREFIX_SHIFT) {
+ /* Shift */
+ sc->sc_buffered_char[0] = (0x2a | (code & SCAN_RELEASE));
+ sc->sc_buffered_char[1] = (code & ~SCAN_PREFIX_SHIFT);
+ } else {
+ sc->sc_buffered_char[0] = (code & ~SCAN_PREFIX);
+ sc->sc_buffered_char[1] = 0;
+ }
+ return ((code & SCAN_PREFIX_E0) ? 0xe0 : 0xe1);
+ }
+ return (code);
+
+}
+
+#endif /* HKBD_EMULATE_ATSCANCODE */
+
+static keyboard_switch_t hkbdsw = {
+ .probe = &hkbd__probe,
+ .init = &hkbd_init,
+ .term = &hkbd_term,
+ .intr = &hkbd_intr,
+ .test_if = &hkbd_test_if,
+ .enable = &hkbd_enable,
+ .disable = &hkbd_disable,
+ .read = &hkbd_read,
+ .check = &hkbd_check,
+ .read_char = &hkbd_read_char,
+ .check_char = &hkbd_check_char,
+ .ioctl = &hkbd_ioctl,
+ .lock = &hkbd_lock,
+ .clear_state = &hkbd_clear_state,
+ .get_state = &hkbd_get_state,
+ .set_state = &hkbd_set_state,
+ .poll = &hkbd_poll,
+};
+
+KEYBOARD_DRIVER(hkbd, hkbdsw, hkbd_configure);
+
+static int
+hkbd_driver_load(module_t mod, int what, void *arg)
+{
+ switch (what) {
+ case MOD_LOAD:
+ kbd_add_driver(&hkbd_kbd_driver);
+ break;
+ case MOD_UNLOAD:
+ kbd_delete_driver(&hkbd_kbd_driver);
+ break;
+ }
+ return (0);
+}
+
+static devclass_t hkbd_devclass;
+
+static device_method_t hkbd_methods[] = {
+ DEVMETHOD(device_probe, hkbd_probe),
+ DEVMETHOD(device_attach, hkbd_attach),
+ DEVMETHOD(device_detach, hkbd_detach),
+ DEVMETHOD(device_resume, hkbd_resume),
+
+ DEVMETHOD_END
+};
+
+static driver_t hkbd_driver = {
+ .name = "hkbd",
+ .methods = hkbd_methods,
+ .size = sizeof(struct hkbd_softc),
+};
+
+DRIVER_MODULE(hkbd, hidbus, hkbd_driver, hkbd_devclass, hkbd_driver_load, 0);
+MODULE_DEPEND(hkbd, hid, 1, 1, 1);
+MODULE_DEPEND(hkbd, hidbus, 1, 1, 1);
+#ifdef EVDEV_SUPPORT
+MODULE_DEPEND(hkbd, evdev, 1, 1, 1);
+#endif
+MODULE_VERSION(hkbd, 1);
+HID_PNP_INFO(hkbd_devs);
diff --git a/sys/dev/hid/hms.c b/sys/dev/hid/hms.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hms.c
@@ -0,0 +1,267 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2020 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 <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * HID spec: https://www.usb.org/sites/default/files/documents/hid1_11.pdf
+ */
+
+#include <sys/param.h>
+#include <sys/bus.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/module.h>
+#include <sys/sysctl.h>
+
+#include <dev/evdev/input.h>
+#include <dev/evdev/evdev.h>
+
+#include <dev/hid/hid.h>
+#include <dev/hid/hidbus.h>
+#include <dev/hid/hidmap.h>
+#include <dev/hid/hidquirk.h>
+#include <dev/hid/hidrdesc.h>
+
+static const uint8_t hms_boot_desc[] = { HID_MOUSE_BOOTPROTO_DESCR() };
+
+enum {
+ HMS_REL_X,
+ HMS_REL_Y,
+ HMS_REL_Z,
+ HMS_ABS_X,
+ HMS_ABS_Y,
+ HMS_ABS_Z,
+ HMS_HWHEEL,
+ HMS_BTN,
+ HMS_BTN_MS1,
+ HMS_BTN_MS2,
+ HMS_FINAL_CB,
+};
+
+static hidmap_cb_t hms_final_cb;
+
+#define HMS_MAP_BUT_RG(usage_from, usage_to, code) \
+ { HIDMAP_KEY_RANGE(HUP_BUTTON, usage_from, usage_to, code) }
+#define HMS_MAP_BUT_MS(usage, code) \
+ { HIDMAP_KEY(HUP_MICROSOFT, usage, code) }
+#define HMS_MAP_ABS(usage, code) \
+ { HIDMAP_ABS(HUP_GENERIC_DESKTOP, usage, code) }
+#define HMS_MAP_REL(usage, code) \
+ { HIDMAP_REL(HUP_GENERIC_DESKTOP, usage, code) }
+#define HMS_MAP_REL_REV(usage, code) \
+ { HIDMAP_REL(HUP_GENERIC_DESKTOP, usage, code), .invert_value = true }
+#define HMS_MAP_REL_CN(usage, code) \
+ { HIDMAP_REL(HUP_CONSUMER, usage, code) }
+#define HMS_FINAL_CB(cb) \
+ { HIDMAP_FINAL_CB(&cb) }
+
+static const struct hidmap_item hms_map[] = {
+ [HMS_REL_X] = HMS_MAP_REL(HUG_X, REL_X),
+ [HMS_REL_Y] = HMS_MAP_REL(HUG_Y, REL_Y),
+ [HMS_REL_Z] = HMS_MAP_REL(HUG_Z, REL_Z),
+ [HMS_ABS_X] = HMS_MAP_ABS(HUG_X, ABS_X),
+ [HMS_ABS_Y] = HMS_MAP_ABS(HUG_Y, ABS_Y),
+ [HMS_ABS_Z] = HMS_MAP_ABS(HUG_Z, ABS_Z),
+ [HMS_HWHEEL] = HMS_MAP_REL_CN(HUC_AC_PAN, REL_HWHEEL),
+ [HMS_BTN] = HMS_MAP_BUT_RG(1, 16, BTN_MOUSE),
+ [HMS_BTN_MS1] = HMS_MAP_BUT_MS(1, BTN_RIGHT),
+ [HMS_BTN_MS2] = HMS_MAP_BUT_MS(2, BTN_MIDDLE),
+ [HMS_FINAL_CB] = HMS_FINAL_CB(hms_final_cb),
+};
+
+static const struct hidmap_item hms_map_wheel[] = {
+ HMS_MAP_REL(HUG_WHEEL, REL_WHEEL),
+};
+static const struct hidmap_item hms_map_wheel_rev[] = {
+ HMS_MAP_REL_REV(HUG_WHEEL, REL_WHEEL),
+};
+
+/* A match on these entries will load hms */
+static const struct hid_device_id hms_devs[] = {
+ { HID_TLC(HUP_GENERIC_DESKTOP, HUG_MOUSE) },
+};
+
+struct hms_softc {
+ struct hidmap hm;
+ HIDMAP_CAPS(caps, hms_map);
+};
+
+static int
+hms_final_cb(HIDMAP_CB_ARGS)
+{
+ struct hms_softc *sc = HIDMAP_CB_GET_SOFTC();
+ struct evdev_dev *evdev = HIDMAP_CB_GET_EVDEV();
+
+ if (HIDMAP_CB_GET_STATE() == HIDMAP_CB_IS_ATTACHING) {
+ if (hidmap_test_cap(sc->caps, HMS_ABS_X) ||
+ hidmap_test_cap(sc->caps, HMS_ABS_Y))
+ evdev_support_prop(evdev, INPUT_PROP_DIRECT);
+ else
+ evdev_support_prop(evdev, INPUT_PROP_POINTER);
+ }
+
+ /* Do not execute callback at interrupt handler and detach */
+ return (ENOSYS);
+}
+
+static void
+hms_identify(driver_t *driver, device_t parent)
+{
+ const struct hid_device_info *hw = hid_get_device_info(parent);
+ void *d_ptr;
+ hid_size_t d_len;
+ int error;
+
+ /*
+ * If device claimed boot protocol support but do not have report
+ * descriptor, load one defined in "Appendix B.2" of HID1_11.pdf
+ */
+ error = hid_get_report_descr(parent, &d_ptr, &d_len);
+ if ((error != 0 && hid_test_quirk(hw, HQ_HAS_MS_BOOTPROTO)) ||
+ (error == 0 && hid_test_quirk(hw, HQ_MS_BOOTPROTO) &&
+ hid_is_mouse(d_ptr, d_len)))
+ (void)hid_set_report_descr(parent, hms_boot_desc,
+ sizeof(hms_boot_desc));
+}
+
+static int
+hms_probe(device_t dev)
+{
+ struct hms_softc *sc = device_get_softc(dev);
+ int error;
+
+ error = HIDBUS_LOOKUP_DRIVER_INFO(dev, hms_devs);
+ if (error != 0)
+ return (error);
+
+ hidmap_set_dev(&sc->hm, dev);
+
+ /* Check if report descriptor belongs to mouse */
+ error = HIDMAP_ADD_MAP(&sc->hm, hms_map, sc->caps);
+ if (error != 0)
+ return (error);
+
+ /* There should be at least one X or Y axis */
+ if (!hidmap_test_cap(sc->caps, HMS_REL_X) &&
+ !hidmap_test_cap(sc->caps, HMS_REL_X) &&
+ !hidmap_test_cap(sc->caps, HMS_ABS_X) &&
+ !hidmap_test_cap(sc->caps, HMS_ABS_Y))
+ return (ENXIO);
+
+ if (hidmap_test_cap(sc->caps, HMS_ABS_X) ||
+ hidmap_test_cap(sc->caps, HMS_ABS_Y))
+ hidbus_set_desc(dev, "Tablet");
+ else
+ hidbus_set_desc(dev, "Mouse");
+
+ return (BUS_PROBE_DEFAULT);
+}
+
+static int
+hms_attach(device_t dev)
+{
+ struct hms_softc *sc = device_get_softc(dev);
+ const struct hid_device_info *hw = hid_get_device_info(dev);
+ struct hidmap_hid_item *hi;
+ HIDMAP_CAPS(cap_wheel, hms_map_wheel);
+ void *d_ptr;
+ hid_size_t d_len;
+ bool set_report_proto;
+ int error, nbuttons = 0;
+
+ /*
+ * Set the report (non-boot) protocol if report descriptor has not been
+ * overloaded with boot protocol report descriptor.
+ *
+ * Mice without boot protocol support may choose not to implement
+ * Set_Protocol at all; Ignore any error.
+ */
+ error = hid_get_report_descr(dev, &d_ptr, &d_len);
+ set_report_proto = !(error == 0 && d_len == sizeof(hms_boot_desc) &&
+ memcmp(d_ptr, hms_boot_desc, sizeof(hms_boot_desc)) == 0);
+ (void)hid_set_protocol(dev, set_report_proto ? 1 : 0);
+
+ if (hid_test_quirk(hw, HQ_MS_REVZ))
+ HIDMAP_ADD_MAP(&sc->hm, hms_map_wheel_rev, cap_wheel);
+ else
+ HIDMAP_ADD_MAP(&sc->hm, hms_map_wheel, cap_wheel);
+
+ error = hidmap_attach(&sc->hm);
+ if (error)
+ return (error);
+
+ /* Count number of input usages of variable type mapped to buttons */
+ for (hi = sc->hm.hid_items;
+ hi < sc->hm.hid_items + sc->hm.nhid_items;
+ hi++)
+ if (hi->type == HIDMAP_TYPE_VARIABLE && hi->evtype == EV_KEY)
+ nbuttons++;
+
+ /* announce information about the mouse */
+ device_printf(dev, "%d buttons and [%s%s%s%s%s] coordinates ID=%u\n",
+ nbuttons,
+ (hidmap_test_cap(sc->caps, HMS_REL_X) ||
+ hidmap_test_cap(sc->caps, HMS_ABS_X)) ? "X" : "",
+ (hidmap_test_cap(sc->caps, HMS_REL_Y) ||
+ hidmap_test_cap(sc->caps, HMS_ABS_Y)) ? "Y" : "",
+ (hidmap_test_cap(sc->caps, HMS_REL_Z) ||
+ hidmap_test_cap(sc->caps, HMS_ABS_Z)) ? "Z" : "",
+ hidmap_test_cap(cap_wheel, 0) ? "W" : "",
+ hidmap_test_cap(sc->caps, HMS_HWHEEL) ? "H" : "",
+ sc->hm.hid_items[0].id);
+
+ return (0);
+}
+
+static int
+hms_detach(device_t dev)
+{
+ struct hms_softc *sc = device_get_softc(dev);
+
+ return (hidmap_detach(&sc->hm));
+}
+
+static devclass_t hms_devclass;
+static device_method_t hms_methods[] = {
+ DEVMETHOD(device_identify, hms_identify),
+ DEVMETHOD(device_probe, hms_probe),
+ DEVMETHOD(device_attach, hms_attach),
+ DEVMETHOD(device_detach, hms_detach),
+
+ DEVMETHOD_END
+};
+
+DEFINE_CLASS_0(hms, hms_driver, hms_methods, sizeof(struct hms_softc));
+DRIVER_MODULE(hms, hidbus, hms_driver, hms_devclass, NULL, 0);
+MODULE_DEPEND(hms, hid, 1, 1, 1);
+MODULE_DEPEND(hms, hidbus, 1, 1, 1);
+MODULE_DEPEND(hms, hidmap, 1, 1, 1);
+MODULE_DEPEND(hms, evdev, 1, 1, 1);
+MODULE_VERSION(hms, 1);
+HID_PNP_INFO(hms_devs);
diff --git a/sys/dev/hid/hmt.c b/sys/dev/hid/hmt.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hmt.c
@@ -0,0 +1,911 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2014-2020 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 <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * MS Windows 7/8/10 compatible HID Multi-touch Device driver.
+ * https://msdn.microsoft.com/en-us/library/windows/hardware/jj151569(v=vs.85).aspx
+ * http://download.microsoft.com/download/7/d/d/7dd44bb7-2a7a-4505-ac1c-7227d3d96d5b/hid-over-i2c-protocol-spec-v1-0.docx
+ * https://www.kernel.org/doc/Documentation/input/multi-touch-protocol.txt
+ */
+
+#include <sys/param.h>
+#include <sys/bus.h>
+#include <sys/kernel.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/module.h>
+#include <sys/mutex.h>
+#include <sys/sysctl.h>
+#include <sys/systm.h>
+
+#include <dev/evdev/evdev.h>
+#include <dev/evdev/input.h>
+
+#define HID_DEBUG_VAR hmt_debug
+#include <dev/hid/hid.h>
+#include <dev/hid/hidbus.h>
+#include <dev/hid/hidquirk.h>
+
+#include <dev/hid/hconf.h>
+
+static SYSCTL_NODE(_hw_hid, OID_AUTO, hmt, CTLFLAG_RW, 0,
+ "MSWindows 7/8/10 compatible HID Multi-touch Device");
+#ifdef HID_DEBUG
+static int hmt_debug = 0;
+SYSCTL_INT(_hw_hid_hmt, OID_AUTO, debug, CTLFLAG_RWTUN,
+ &hmt_debug, 1, "Debug level");
+#endif
+static bool hmt_timestamps = 0;
+SYSCTL_BOOL(_hw_hid_hmt, OID_AUTO, timestamps, CTLFLAG_RDTUN,
+ &hmt_timestamps, 1, "Enable hardware timestamp reporting");
+
+#define HMT_BTN_MAX 8 /* Number of buttons supported */
+
+enum hmt_type {
+ HMT_TYPE_UNKNOWN = 0, /* HID report descriptor is not probed */
+ HMT_TYPE_UNSUPPORTED, /* Repdescr does not belong to MT device */
+ HMT_TYPE_TOUCHPAD,
+ HMT_TYPE_TOUCHSCREEN,
+};
+
+enum {
+ HMT_TIP_SWITCH,
+#define HMT_SLOT HMT_TIP_SWITCH
+ HMT_WIDTH,
+#define HMT_MAJOR HMT_WIDTH
+ HMT_HEIGHT,
+#define HMT_MINOR HMT_HEIGHT
+ HMT_ORIENTATION,
+ HMT_X,
+ HMT_Y,
+ HMT_CONTACTID,
+ HMT_PRESSURE,
+ HMT_IN_RANGE,
+ HMT_CONFIDENCE,
+ HMT_TOOL_X,
+ HMT_TOOL_Y,
+ HMT_N_USAGES,
+};
+
+#define HMT_NO_CODE (ABS_MAX + 10)
+#define HMT_NO_USAGE -1
+
+struct hmt_hid_map_item {
+ char name[5];
+ int32_t usage; /* HID usage */
+ uint32_t code; /* Evdev event code */
+ bool required; /* Required for MT Digitizers */
+};
+
+static const struct hmt_hid_map_item hmt_hid_map[HMT_N_USAGES] = {
+ [HMT_TIP_SWITCH] = { /* HMT_SLOT */
+ .name = "TIP",
+ .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_TIP_SWITCH),
+ .code = ABS_MT_SLOT,
+ .required = true,
+ },
+ [HMT_WIDTH] = { /* HMT_MAJOR */
+ .name = "WDTH",
+ .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_WIDTH),
+ .code = ABS_MT_TOUCH_MAJOR,
+ .required = false,
+ },
+ [HMT_HEIGHT] = { /* HMT_MINOR */
+ .name = "HGHT",
+ .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_HEIGHT),
+ .code = ABS_MT_TOUCH_MINOR,
+ .required = false,
+ },
+ [HMT_ORIENTATION] = {
+ .name = "ORIE",
+ .usage = HMT_NO_USAGE,
+ .code = ABS_MT_ORIENTATION,
+ .required = false,
+ },
+ [HMT_X] = {
+ .name = "X",
+ .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X),
+ .code = ABS_MT_POSITION_X,
+ .required = true,
+ },
+ [HMT_Y] = {
+ .name = "Y",
+ .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y),
+ .code = ABS_MT_POSITION_Y,
+ .required = true,
+ },
+ [HMT_CONTACTID] = {
+ .name = "C_ID",
+ .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_CONTACTID),
+ .code = ABS_MT_TRACKING_ID,
+ .required = true,
+ },
+ [HMT_PRESSURE] = {
+ .name = "PRES",
+ .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_TIP_PRESSURE),
+ .code = ABS_MT_PRESSURE,
+ .required = false,
+ },
+ [HMT_IN_RANGE] = {
+ .name = "RANG",
+ .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_IN_RANGE),
+ .code = ABS_MT_DISTANCE,
+ .required = false,
+ },
+ [HMT_CONFIDENCE] = {
+ .name = "CONF",
+ .usage = HID_USAGE2(HUP_DIGITIZERS, HUD_CONFIDENCE),
+ .code = HMT_NO_CODE,
+ .required = false,
+ },
+ [HMT_TOOL_X] = { /* Shares HID usage with HMT_X */
+ .name = "TL_X",
+ .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X),
+ .code = ABS_MT_TOOL_X,
+ .required = false,
+ },
+ [HMT_TOOL_Y] = { /* Shares HID usage with HMT_Y */
+ .name = "TL_Y",
+ .usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y),
+ .code = ABS_MT_TOOL_Y,
+ .required = false,
+ },
+};
+
+struct hmt_softc {
+ device_t dev;
+ enum hmt_type type;
+
+ struct hid_absinfo ai[HMT_N_USAGES];
+ struct hid_location locs[MAX_MT_SLOTS][HMT_N_USAGES];
+ struct hid_location cont_count_loc;
+ struct hid_location btn_loc[HMT_BTN_MAX];
+ struct hid_location int_btn_loc;
+ struct hid_location scan_time_loc;
+ int32_t scan_time_max;
+ int32_t scan_time;
+ int32_t timestamp;
+ bool touch;
+ bool prev_touch;
+
+ struct evdev_dev *evdev;
+
+ uint32_t slot_data[HMT_N_USAGES];
+ uint8_t caps[howmany(HMT_N_USAGES, 8)];
+ uint8_t buttons[howmany(HMT_BTN_MAX, 8)];
+ uint32_t nconts_per_report;
+ uint32_t nconts_todo;
+ uint8_t report_id;
+ uint32_t max_button;
+ bool has_int_button;
+ bool is_clickpad;
+ bool do_timestamps;
+ bool iichid_sampling;
+
+ struct hid_location cont_max_loc;
+ uint32_t cont_max_rlen;
+ uint8_t cont_max_rid;
+ struct hid_location btn_type_loc;
+ uint32_t btn_type_rlen;
+ uint8_t btn_type_rid;
+ uint32_t thqa_cert_rlen;
+ uint8_t thqa_cert_rid;
+};
+
+#define HMT_FOREACH_USAGE(caps, usage) \
+ for ((usage) = 0; (usage) < HMT_N_USAGES; ++(usage)) \
+ if (isset((caps), (usage)))
+
+static enum hmt_type hmt_hid_parse(struct hmt_softc *, const void *,
+ hid_size_t, uint32_t, uint8_t);
+static int hmt_set_input_mode(struct hmt_softc *, enum hconf_input_mode);
+
+static hid_intr_t hmt_intr;
+
+static device_probe_t hmt_probe;
+static device_attach_t hmt_attach;
+static device_detach_t hmt_detach;
+
+static evdev_open_t hmt_ev_open;
+static evdev_close_t hmt_ev_close;
+
+static const struct evdev_methods hmt_evdev_methods = {
+ .ev_open = &hmt_ev_open,
+ .ev_close = &hmt_ev_close,
+};
+
+static const struct hid_device_id hmt_devs[] = {
+ { HID_TLC(HUP_DIGITIZERS, HUD_TOUCHSCREEN) },
+ { HID_TLC(HUP_DIGITIZERS, HUD_TOUCHPAD) },
+};
+
+static int
+hmt_ev_close(struct evdev_dev *evdev)
+{
+ return (hidbus_intr_stop(evdev_get_softc(evdev)));
+}
+
+static int
+hmt_ev_open(struct evdev_dev *evdev)
+{
+ return (hidbus_intr_start(evdev_get_softc(evdev)));
+}
+
+static int
+hmt_probe(device_t dev)
+{
+ struct hmt_softc *sc = device_get_softc(dev);
+ void *d_ptr;
+ hid_size_t d_len;
+ int err;
+
+ err = HIDBUS_LOOKUP_DRIVER_INFO(dev, hmt_devs);
+ if (err != 0)
+ return (err);
+
+ err = hid_get_report_descr(dev, &d_ptr, &d_len);
+ if (err != 0) {
+ device_printf(dev, "could not retrieve report descriptor from "
+ "device: %d\n", err);
+ return (ENXIO);
+ }
+
+ /* Check if report descriptor belongs to a HID multitouch device */
+ if (sc->type == HMT_TYPE_UNKNOWN)
+ sc->type = hmt_hid_parse(sc, d_ptr, d_len,
+ hidbus_get_usage(dev), hidbus_get_index(dev));
+ if (sc->type == HMT_TYPE_UNSUPPORTED)
+ return (ENXIO);
+
+ hidbus_set_desc(dev,
+ sc->type == HMT_TYPE_TOUCHPAD ? "TouchPad" : "TouchScreen");
+
+ return (BUS_PROBE_DEFAULT);
+}
+
+static int
+hmt_attach(device_t dev)
+{
+ struct hmt_softc *sc = device_get_softc(dev);
+ const struct hid_device_info *hw = hid_get_device_info(dev);
+ void *d_ptr;
+ uint8_t *fbuf = NULL;
+ hid_size_t d_len, fsize;
+ uint32_t cont_count_max;
+ int nbuttons, btn;
+ size_t i;
+ int err;
+
+ err = hid_get_report_descr(dev, &d_ptr, &d_len);
+ if (err != 0) {
+ device_printf(dev, "could not retrieve report descriptor from "
+ "device: %d\n", err);
+ return (ENXIO);
+ }
+
+ sc->dev = dev;
+
+ fsize = hid_report_size_max(d_ptr, d_len, hid_feature, NULL);
+ if (fsize != 0)
+ fbuf = malloc(fsize, M_TEMP, M_WAITOK | M_ZERO);
+
+ /* Fetch and parse "Contact count maximum" feature report */
+ if (sc->cont_max_rlen > 1) {
+ err = hid_get_report(dev, fbuf, sc->cont_max_rlen, NULL,
+ HID_FEATURE_REPORT, sc->cont_max_rid);
+ if (err == 0) {
+ cont_count_max = hid_get_udata(fbuf + 1,
+ sc->cont_max_rlen - 1, &sc->cont_max_loc);
+ /*
+ * Feature report is a primary source of
+ * 'Contact Count Maximum'
+ */
+ if (cont_count_max > 0)
+ sc->ai[HMT_SLOT].max = cont_count_max - 1;
+ } else
+ DPRINTF("hid_get_report error=%d\n", err);
+ } else
+ DPRINTF("Feature report %hhu size invalid: %u\n",
+ sc->cont_max_rid, sc->cont_max_rlen);
+
+ /* Fetch and parse "Button type" feature report */
+ if (sc->btn_type_rlen > 1 && sc->btn_type_rid != sc->cont_max_rid) {
+ bzero(fbuf, fsize);
+ err = hid_get_report(dev, fbuf, sc->btn_type_rlen, NULL,
+ HID_FEATURE_REPORT, sc->btn_type_rid);
+ }
+ if (sc->btn_type_rlen > 1) {
+ if (err == 0)
+ sc->is_clickpad = hid_get_udata(fbuf + 1,
+ sc->btn_type_rlen - 1, &sc->btn_type_loc) == 0;
+ else
+ DPRINTF("hid_get_report error=%d\n", err);
+ }
+
+ /* Fetch THQA certificate to enable some devices like WaveShare */
+ if (sc->thqa_cert_rlen > 1 && sc->thqa_cert_rid != sc->cont_max_rid)
+ (void)hid_get_report(dev, fbuf, sc->thqa_cert_rlen, NULL,
+ HID_FEATURE_REPORT, sc->thqa_cert_rid);
+
+ free(fbuf, M_TEMP);
+
+ /* Switch touchpad in to absolute multitouch mode */
+ if (sc->type == HMT_TYPE_TOUCHPAD) {
+ err = hmt_set_input_mode(sc, HCONF_INPUT_MODE_MT_TOUCHPAD);
+ if (err != 0)
+ DPRINTF("Failed to set input mode: %d\n", err);
+ }
+
+ /* Cap contact count maximum to MAX_MT_SLOTS */
+ if (sc->ai[HMT_SLOT].max >= MAX_MT_SLOTS) {
+ DPRINTF("Hardware reported %d contacts while only %d is "
+ "supported\n", (int)sc->ai[HMT_SLOT].max+1, MAX_MT_SLOTS);
+ sc->ai[HMT_SLOT].max = MAX_MT_SLOTS - 1;
+ }
+
+ if (hid_test_quirk(hw, HQ_MT_TIMESTAMP) || hmt_timestamps)
+ sc->do_timestamps = true;
+ if (hid_test_quirk(hw, HQ_IICHID_SAMPLING))
+ sc->iichid_sampling = true;
+
+ hidbus_set_intr(dev, hmt_intr, sc);
+
+ sc->evdev = evdev_alloc();
+ evdev_set_name(sc->evdev, device_get_desc(dev));
+ evdev_set_phys(sc->evdev, device_get_nameunit(dev));
+ 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, dev, &hmt_evdev_methods);
+ evdev_set_flag(sc->evdev, EVDEV_FLAG_MT_STCOMPAT);
+ switch (sc->type) {
+ case HMT_TYPE_TOUCHSCREEN:
+ evdev_support_prop(sc->evdev, INPUT_PROP_DIRECT);
+ break;
+ case HMT_TYPE_TOUCHPAD:
+ evdev_support_prop(sc->evdev, INPUT_PROP_POINTER);
+ if (sc->is_clickpad)
+ evdev_support_prop(sc->evdev, INPUT_PROP_BUTTONPAD);
+ break;
+ default:
+ KASSERT(0, ("hmt_attach: unsupported touch device type"));
+ }
+ evdev_support_event(sc->evdev, EV_SYN);
+ evdev_support_event(sc->evdev, EV_ABS);
+ if (sc->do_timestamps) {
+ evdev_support_event(sc->evdev, EV_MSC);
+ evdev_support_msc(sc->evdev, MSC_TIMESTAMP);
+ }
+ if (sc->iichid_sampling)
+ evdev_set_flag(sc->evdev, EVDEV_FLAG_MT_AUTOREL);
+ nbuttons = 0;
+ if (sc->max_button != 0 || sc->has_int_button) {
+ evdev_support_event(sc->evdev, EV_KEY);
+ if (sc->has_int_button)
+ evdev_support_key(sc->evdev, BTN_LEFT);
+ for (btn = 0; btn < sc->max_button; ++btn) {
+ if (isset(sc->buttons, btn)) {
+ evdev_support_key(sc->evdev, BTN_MOUSE + btn);
+ nbuttons++;
+ }
+ }
+ }
+ HMT_FOREACH_USAGE(sc->caps, i) {
+ if (hmt_hid_map[i].code != HMT_NO_CODE)
+ evdev_support_abs(sc->evdev, hmt_hid_map[i].code,
+ sc->ai[i].min, sc->ai[i].max, 0, 0, sc->ai[i].res);
+ }
+
+ err = evdev_register_epoch(sc->evdev, HIDBUS_EPOCH);
+ if (err) {
+ hmt_detach(dev);
+ return (ENXIO);
+ }
+
+ /* Announce information about the touch device */
+ device_printf(sc->dev, "Multitouch %s with %d external button%s%s\n",
+ sc->type == HMT_TYPE_TOUCHSCREEN ? "touchscreen" : "touchpad",
+ nbuttons, nbuttons != 1 ? "s" : "",
+ sc->is_clickpad ? ", click-pad" : "");
+ device_printf(sc->dev,
+ "%d contacts with [%s%s%s%s%s] properties. Report range [%d:%d] - [%d:%d]\n",
+ (int)sc->ai[HMT_SLOT].max + 1,
+ isset(sc->caps, HMT_IN_RANGE) ? "R" : "",
+ isset(sc->caps, HMT_CONFIDENCE) ? "C" : "",
+ isset(sc->caps, HMT_WIDTH) ? "W" : "",
+ isset(sc->caps, HMT_HEIGHT) ? "H" : "",
+ isset(sc->caps, HMT_PRESSURE) ? "P" : "",
+ (int)sc->ai[HMT_X].min, (int)sc->ai[HMT_Y].min,
+ (int)sc->ai[HMT_X].max, (int)sc->ai[HMT_Y].max);
+
+ return (0);
+}
+
+static int
+hmt_detach(device_t dev)
+{
+ struct hmt_softc *sc = device_get_softc(dev);
+
+ evdev_free(sc->evdev);
+
+ return (0);
+}
+
+static void
+hmt_intr(void *context, void *buf, hid_size_t len)
+{
+ struct hmt_softc *sc = context;
+ size_t usage;
+ uint32_t *slot_data = sc->slot_data;
+ uint32_t cont, btn;
+ uint32_t cont_count;
+ uint32_t width;
+ uint32_t height;
+ uint32_t int_btn = 0;
+ uint32_t left_btn = 0;
+ int32_t slot;
+ uint32_t scan_time;
+ int32_t delta;
+ uint8_t id;
+
+ MPASS(in_epoch(HIDBUS_EPOCH) == 1);
+
+ /*
+ * Special packet of zero length is generated by iichid driver running
+ * in polling mode at the start of inactivity period to workaround
+ * "stuck touch" problem caused by miss of finger release events.
+ * This snippet is to be removed after GPIO interrupt support is added.
+ */
+ if (sc->iichid_sampling && len == 0) {
+ sc->prev_touch = false;
+ sc->timestamp = 0;
+ for (slot = 0; slot <= sc->ai[HMT_SLOT].max; slot++) {
+ evdev_push_abs(sc->evdev, ABS_MT_SLOT, slot);
+ evdev_push_abs(sc->evdev, ABS_MT_TRACKING_ID, -1);
+ }
+ evdev_sync(sc->evdev);
+ return;
+ }
+
+ /* Ignore irrelevant reports */
+ id = sc->report_id != 0 ? *(uint8_t *)buf : 0;
+ if (sc->report_id != id) {
+ DPRINTF("Skip report with unexpected ID: %hhu\n", id);
+ return;
+ }
+
+ /* Strip leading "report ID" byte */
+ if (sc->report_id != 0) {
+ len--;
+ buf = (uint8_t *)buf + 1;
+ }
+
+ /*
+ * "In Parallel mode, devices report all contact information in a
+ * single packet. Each physical contact is represented by a logical
+ * collection that is embedded in the top-level collection."
+ *
+ * Since additional contacts that were not present will still be in the
+ * report with contactid=0 but contactids are zero-based, find
+ * contactcount first.
+ */
+ cont_count = hid_get_udata(buf, len, &sc->cont_count_loc);
+ /*
+ * "In Hybrid mode, the number of contacts that can be reported in one
+ * report is less than the maximum number of contacts that the device
+ * supports. For example, a device that supports a maximum of
+ * 4 concurrent physical contacts, can set up its top-level collection
+ * to deliver a maximum of two contacts in one report. If four contact
+ * points are present, the device can break these up into two serial
+ * reports that deliver two contacts each.
+ *
+ * "When a device delivers data in this manner, the Contact Count usage
+ * value in the first report should reflect the total number of
+ * contacts that are being delivered in the hybrid reports. The other
+ * serial reports should have a contact count of zero (0)."
+ */
+ if (cont_count != 0)
+ sc->nconts_todo = cont_count;
+
+#ifdef HID_DEBUG
+ DPRINTFN(6, "cont_count:%2u", (unsigned)cont_count);
+ if (hmt_debug >= 6) {
+ HMT_FOREACH_USAGE(sc->caps, usage) {
+ if (hmt_hid_map[usage].usage != HMT_NO_USAGE)
+ printf(" %-4s", hmt_hid_map[usage].name);
+ }
+ printf("\n");
+ }
+#endif
+
+ /* Find the number of contacts reported in current report */
+ cont_count = MIN(sc->nconts_todo, sc->nconts_per_report);
+
+ /* Use protocol Type B for reporting events */
+ for (cont = 0; cont < cont_count; cont++) {
+ bzero(slot_data, sizeof(sc->slot_data));
+ HMT_FOREACH_USAGE(sc->caps, usage) {
+ if (sc->locs[cont][usage].size > 0)
+ slot_data[usage] = hid_get_udata(
+ buf, len, &sc->locs[cont][usage]);
+ }
+
+ slot = evdev_get_mt_slot_by_tracking_id(sc->evdev,
+ slot_data[HMT_CONTACTID]);
+
+#ifdef HID_DEBUG
+ DPRINTFN(6, "cont%01x: data = ", cont);
+ if (hmt_debug >= 6) {
+ HMT_FOREACH_USAGE(sc->caps, usage) {
+ if (hmt_hid_map[usage].usage != HMT_NO_USAGE)
+ printf("%04x ", slot_data[usage]);
+ }
+ printf("slot = %d\n", (int)slot);
+ }
+#endif
+
+ if (slot == -1) {
+ DPRINTF("Slot overflow for contact_id %u\n",
+ (unsigned)slot_data[HMT_CONTACTID]);
+ continue;
+ }
+
+ if (slot_data[HMT_TIP_SWITCH] != 0 &&
+ !(isset(sc->caps, HMT_CONFIDENCE) &&
+ slot_data[HMT_CONFIDENCE] == 0)) {
+ /* This finger is in proximity of the sensor */
+ sc->touch = true;
+ slot_data[HMT_SLOT] = slot;
+ slot_data[HMT_IN_RANGE] = !slot_data[HMT_IN_RANGE];
+ /* Divided by two to match visual scale of touch */
+ width = slot_data[HMT_WIDTH] >> 1;
+ height = slot_data[HMT_HEIGHT] >> 1;
+ slot_data[HMT_ORIENTATION] = width > height;
+ slot_data[HMT_MAJOR] = MAX(width, height);
+ slot_data[HMT_MINOR] = MIN(width, height);
+
+ HMT_FOREACH_USAGE(sc->caps, usage)
+ if (hmt_hid_map[usage].code != HMT_NO_CODE)
+ evdev_push_abs(sc->evdev,
+ hmt_hid_map[usage].code,
+ slot_data[usage]);
+ } else {
+ evdev_push_abs(sc->evdev, ABS_MT_SLOT, slot);
+ evdev_push_abs(sc->evdev, ABS_MT_TRACKING_ID, -1);
+ }
+ }
+
+ sc->nconts_todo -= cont_count;
+ if (sc->do_timestamps && sc->nconts_todo == 0) {
+ /* HUD_SCAN_TIME is measured in 100us, convert to us. */
+ scan_time = hid_get_udata(buf, len, &sc->scan_time_loc);
+ if (sc->prev_touch) {
+ delta = scan_time - sc->scan_time;
+ if (delta < 0)
+ delta += sc->scan_time_max;
+ } else
+ delta = 0;
+ sc->scan_time = scan_time;
+ sc->timestamp += delta * 100;
+ evdev_push_msc(sc->evdev, MSC_TIMESTAMP, sc->timestamp);
+ sc->prev_touch = sc->touch;
+ sc->touch = false;
+ if (!sc->prev_touch)
+ sc->timestamp = 0;
+ }
+ if (sc->nconts_todo == 0) {
+ /* Report both the click and external left btns as BTN_LEFT */
+ if (sc->has_int_button)
+ int_btn = hid_get_data(buf, len, &sc->int_btn_loc);
+ if (isset(sc->buttons, 0))
+ left_btn = hid_get_data(buf, len, &sc->btn_loc[0]);
+ if (sc->has_int_button || isset(sc->buttons, 0))
+ evdev_push_key(sc->evdev, BTN_LEFT,
+ (int_btn != 0) | (left_btn != 0));
+ for (btn = 1; btn < sc->max_button; ++btn) {
+ if (isset(sc->buttons, btn))
+ evdev_push_key(sc->evdev, BTN_MOUSE + btn,
+ hid_get_data(buf,
+ len,
+ &sc->btn_loc[btn]) != 0);
+ }
+ evdev_sync(sc->evdev);
+ }
+}
+
+static enum hmt_type
+hmt_hid_parse(struct hmt_softc *sc, const void *d_ptr, hid_size_t d_len,
+ uint32_t tlc_usage, uint8_t tlc_index)
+{
+ struct hid_absinfo ai;
+ struct hid_item hi;
+ struct hid_data *hd;
+ uint32_t flags;
+ size_t i;
+ size_t cont = 0;
+ enum hmt_type type;
+ uint32_t left_btn, btn;
+ int32_t cont_count_max = 0;
+ uint8_t report_id = 0;
+ bool finger_coll = false;
+ bool cont_count_found = false;
+ bool scan_time_found = false;
+ bool has_int_button = false;
+
+#define HMT_HI_ABSOLUTE(hi) \
+ (((hi).flags & (HIO_CONST|HIO_VARIABLE|HIO_RELATIVE)) == HIO_VARIABLE)
+#define HUMS_THQA_CERT 0xC5
+
+ /*
+ * Get left button usage taking in account MS Precision Touchpad specs.
+ * For Windows PTP report descriptor assigns buttons in following way:
+ * Button 1 - Indicates Button State for touchpad button integrated
+ * with digitizer.
+ * Button 2 - Indicates Button State for external button for primary
+ * (default left) clicking.
+ * Button 3 - Indicates Button State for external button for secondary
+ * (default right) clicking.
+ * If a device only supports external buttons, it must still use
+ * Button 2 and Button 3 to reference the external buttons.
+ */
+ switch (tlc_usage) {
+ case HID_USAGE2(HUP_DIGITIZERS, HUD_TOUCHSCREEN):
+ type = HMT_TYPE_TOUCHSCREEN;
+ left_btn = 1;
+ break;
+ case HID_USAGE2(HUP_DIGITIZERS, HUD_TOUCHPAD):
+ type = HMT_TYPE_TOUCHPAD;
+ left_btn = 2;
+ break;
+ default:
+ return (HMT_TYPE_UNSUPPORTED);
+ }
+
+ /* Parse features for mandatory maximum contact count usage */
+ if (!hidbus_locate(d_ptr, d_len,
+ HID_USAGE2(HUP_DIGITIZERS, HUD_CONTACT_MAX), hid_feature,
+ tlc_index, 0, &sc->cont_max_loc, &flags, &sc->cont_max_rid, &ai) ||
+ (flags & (HIO_VARIABLE | HIO_RELATIVE)) != HIO_VARIABLE)
+ return (HMT_TYPE_UNSUPPORTED);
+
+ cont_count_max = ai.max;
+
+ /* Parse features for button type usage */
+ if (hidbus_locate(d_ptr, d_len,
+ HID_USAGE2(HUP_DIGITIZERS, HUD_BUTTON_TYPE), hid_feature,
+ tlc_index, 0, &sc->btn_type_loc, &flags, &sc->btn_type_rid, NULL)
+ && (flags & (HIO_VARIABLE | HIO_RELATIVE)) != HIO_VARIABLE)
+ sc->btn_type_rid = 0;
+
+ /* Parse features for THQA certificate report ID */
+ hidbus_locate(d_ptr, d_len, HID_USAGE2(HUP_MICROSOFT, HUMS_THQA_CERT),
+ hid_feature, tlc_index, 0, NULL, NULL, &sc->thqa_cert_rid, NULL);
+
+ /* Parse input for other parameters */
+ hd = hid_start_parse(d_ptr, d_len, 1 << hid_input);
+ HIDBUS_FOREACH_ITEM(hd, &hi, tlc_index) {
+ switch (hi.kind) {
+ case hid_collection:
+ if (hi.collevel == 2 &&
+ hi.usage == HID_USAGE2(HUP_DIGITIZERS, HUD_FINGER))
+ finger_coll = true;
+ break;
+ case hid_endcollection:
+ if (hi.collevel == 1 && finger_coll) {
+ finger_coll = false;
+ cont++;
+ }
+ break;
+ case hid_input:
+ /*
+ * Ensure that all usages belong to the same report
+ */
+ if (HMT_HI_ABSOLUTE(hi) &&
+ (report_id == 0 || report_id == hi.report_ID))
+ report_id = hi.report_ID;
+ else
+ break;
+
+ if (hi.collevel == 1 && left_btn == 2 &&
+ hi.usage == HID_USAGE2(HUP_BUTTON, 1)) {
+ has_int_button = true;
+ sc->int_btn_loc = hi.loc;
+ break;
+ }
+ if (hi.collevel == 1 &&
+ hi.usage >= HID_USAGE2(HUP_BUTTON, left_btn) &&
+ hi.usage <= HID_USAGE2(HUP_BUTTON, HMT_BTN_MAX)) {
+ btn = (hi.usage & 0xFFFF) - left_btn;
+ setbit(sc->buttons, btn);
+ sc->btn_loc[btn] = hi.loc;
+ if (btn >= sc->max_button)
+ sc->max_button = btn + 1;
+ break;
+ }
+ if (hi.collevel == 1 && hi.usage ==
+ HID_USAGE2(HUP_DIGITIZERS, HUD_CONTACTCOUNT)) {
+ cont_count_found = true;
+ sc->cont_count_loc = hi.loc;
+ break;
+ }
+ /* Scan time is required but clobbered by evdev */
+ if (hi.collevel == 1 && hi.usage ==
+ HID_USAGE2(HUP_DIGITIZERS, HUD_SCAN_TIME)) {
+ scan_time_found = true;
+ sc->scan_time_loc = hi.loc;
+ sc->scan_time_max = hi.logical_maximum;
+ break;
+ }
+
+ if (!finger_coll || hi.collevel != 2)
+ break;
+ if (cont >= MAX_MT_SLOTS) {
+ DPRINTF("Finger %zu ignored\n", cont);
+ break;
+ }
+
+ for (i = 0; i < HMT_N_USAGES; i++) {
+ if (hi.usage == hmt_hid_map[i].usage) {
+ /*
+ * HUG_X usage is an array mapped to
+ * both ABS_MT_POSITION and ABS_MT_TOOL
+ * events. So don`t stop search if we
+ * already have HUG_X mapping done.
+ */
+ if (sc->locs[cont][i].size)
+ continue;
+ sc->locs[cont][i] = hi.loc;
+ /*
+ * Hid parser returns valid logical and
+ * physical sizes for first finger only
+ * at least on ElanTS 0x04f3:0x0012.
+ */
+ if (cont > 0)
+ break;
+ setbit(sc->caps, i);
+ sc->ai[i] = (struct hid_absinfo) {
+ .max = hi.logical_maximum,
+ .min = hi.logical_minimum,
+ .res = hid_item_resolution(&hi),
+ };
+ break;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ }
+ hid_end_parse(hd);
+
+ /* Check for required HID Usages */
+ if (!cont_count_found || !scan_time_found || cont == 0)
+ return (HMT_TYPE_UNSUPPORTED);
+ for (i = 0; i < HMT_N_USAGES; i++) {
+ if (hmt_hid_map[i].required && isclr(sc->caps, i))
+ return (HMT_TYPE_UNSUPPORTED);
+ }
+
+ /* Touchpads must have at least one button */
+ if (type == HMT_TYPE_TOUCHPAD && !sc->max_button && !has_int_button)
+ return (HMT_TYPE_UNSUPPORTED);
+
+ /*
+ * According to specifications 'Contact Count Maximum' should be read
+ * from Feature Report rather than from HID descriptor. Set sane
+ * default value now to handle the case of 'Get Report' request failure
+ */
+ if (cont_count_max < 1)
+ cont_count_max = cont;
+
+ /* Set number of MT protocol type B slots */
+ sc->ai[HMT_SLOT] = (struct hid_absinfo) {
+ .min = 0,
+ .max = cont_count_max - 1,
+ .res = 0,
+ };
+
+ /* Report touch orientation if both width and height are supported */
+ if (isset(sc->caps, HMT_WIDTH) && isset(sc->caps, HMT_HEIGHT)) {
+ setbit(sc->caps, HMT_ORIENTATION);
+ sc->ai[HMT_ORIENTATION].max = 1;
+ }
+
+ sc->cont_max_rlen = hid_report_size(d_ptr, d_len, hid_feature,
+ sc->cont_max_rid);
+ if (sc->btn_type_rid > 0)
+ sc->btn_type_rlen = hid_report_size(d_ptr, d_len,
+ hid_feature, sc->btn_type_rid);
+ if (sc->thqa_cert_rid > 0)
+ sc->thqa_cert_rlen = hid_report_size(d_ptr, d_len,
+ hid_feature, sc->thqa_cert_rid);
+
+ sc->report_id = report_id;
+ sc->nconts_per_report = cont;
+ sc->has_int_button = has_int_button;
+
+ return (type);
+}
+
+static int
+hmt_set_input_mode(struct hmt_softc *sc, enum hconf_input_mode mode)
+{
+ devclass_t hconf_devclass;
+ device_t hconf;
+ int err;
+
+ GIANT_REQUIRED;
+
+ /* Find touchpad's configuration TLC */
+ hconf = hidbus_find_child(device_get_parent(sc->dev),
+ HID_USAGE2(HUP_DIGITIZERS, HUD_CONFIG));
+ if (hconf == NULL)
+ return (ENXIO);
+
+ /* Ensure that hconf driver is attached to configuration TLC */
+ if (device_is_alive(hconf) == 0)
+ device_probe_and_attach(hconf);
+ if (device_is_attached(hconf) == 0)
+ return (ENXIO);
+ hconf_devclass = devclass_find("hconf");
+ if (device_get_devclass(hconf) != hconf_devclass)
+ return (ENXIO);
+
+ /* hconf_set_input_mode can drop the Giant while sleeping */
+ device_busy(hconf);
+ err = hconf_set_input_mode(hconf, mode);
+ device_unbusy(hconf);
+
+ return (err);
+}
+
+static devclass_t hmt_devclass;
+
+static device_method_t hmt_methods[] = {
+ DEVMETHOD(device_probe, hmt_probe),
+ DEVMETHOD(device_attach, hmt_attach),
+ DEVMETHOD(device_detach, hmt_detach),
+
+ DEVMETHOD_END
+};
+
+static driver_t hmt_driver = {
+ .name = "hmt",
+ .methods = hmt_methods,
+ .size = sizeof(struct hmt_softc),
+};
+
+DRIVER_MODULE(hmt, hidbus, hmt_driver, hmt_devclass, NULL, 0);
+MODULE_DEPEND(hmt, hidbus, 1, 1, 1);
+MODULE_DEPEND(hmt, hid, 1, 1, 1);
+MODULE_DEPEND(hmt, hconf, 1, 1, 1);
+MODULE_DEPEND(hmt, evdev, 1, 1, 1);
+MODULE_VERSION(hmt, 1);
+HID_PNP_INFO(hmt_devs);
diff --git a/sys/dev/hid/hpen.c b/sys/dev/hid/hpen.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hpen.c
@@ -0,0 +1,256 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2019 Vladimir Kondratyev <wulf@FreeBSD.org>
+ * Copyright (c) 2019 Greg V <greg@unrelenting.technology>
+ *
+ * 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 <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * Generic / MS Windows compatible HID pen tablet driver:
+ * https://docs.microsoft.com/en-us/windows-hardware/design/component-guidelines/required-hid-top-level-collections
+ *
+ * Tested on: Wacom WCOM50C1 (Google Pixelbook "eve")
+ */
+
+#include <sys/param.h>
+#include <sys/bus.h>
+#include <sys/kernel.h>
+#include <sys/malloc.h>
+#include <sys/module.h>
+#include <sys/sysctl.h>
+
+#include <dev/evdev/input.h>
+#include <dev/evdev/evdev.h>
+
+#include <dev/hid/hid.h>
+#include <dev/hid/hidbus.h>
+#include <dev/hid/hidmap.h>
+#include <dev/hid/hidrdesc.h>
+
+#include "usbdevs.h"
+
+static const uint8_t hpen_graphire_report_descr[] =
+ { HID_GRAPHIRE_REPORT_DESCR() };
+static const uint8_t hpen_graphire3_4x5_report_descr[] =
+ { HID_GRAPHIRE3_4X5_REPORT_DESCR() };
+
+static hidmap_cb_t hpen_battery_strenght_cb;
+static hidmap_cb_t hpen_final_digi_cb;
+static hidmap_cb_t hpen_final_pen_cb;
+
+#define HPEN_MAP_BUT(usage, code) \
+ HIDMAP_KEY(HUP_DIGITIZERS, HUD_##usage, code)
+#define HPEN_MAP_ABS(usage, code) \
+ HIDMAP_ABS(HUP_DIGITIZERS, HUD_##usage, code)
+#define HPEN_MAP_ABS_GD(usage, code) \
+ HIDMAP_ABS(HUP_GENERIC_DESKTOP, HUG_##usage, code)
+#define HPEN_MAP_ABS_CB(usage, cb) \
+ HIDMAP_ABS_CB(HUP_DIGITIZERS, HUD_##usage, &cb)
+
+/* Generic map digitizer page map according to hut1_12v2.pdf */
+static const struct hidmap_item hpen_map_digi[] = {
+ { HPEN_MAP_ABS_GD(X, ABS_X), .required = true },
+ { HPEN_MAP_ABS_GD(Y, ABS_Y), .required = true },
+ { HPEN_MAP_ABS( TIP_PRESSURE, ABS_PRESSURE) },
+ { HPEN_MAP_ABS( X_TILT, ABS_TILT_X) },
+ { HPEN_MAP_ABS( Y_TILT, ABS_TILT_Y) },
+ { HPEN_MAP_ABS_CB(BATTERY_STRENGTH, hpen_battery_strenght_cb) },
+ { HPEN_MAP_BUT( TOUCH, BTN_TOUCH) },
+ { HPEN_MAP_BUT( TIP_SWITCH, BTN_TOUCH) },
+ { HPEN_MAP_BUT( SEC_TIP_SWITCH, BTN_TOUCH) },
+ { HPEN_MAP_BUT( IN_RANGE, BTN_TOOL_PEN) },
+ { HPEN_MAP_BUT( BARREL_SWITCH, BTN_STYLUS) },
+ { HPEN_MAP_BUT( INVERT, BTN_TOOL_RUBBER) },
+ { HPEN_MAP_BUT( ERASER, BTN_TOUCH) },
+ { HPEN_MAP_BUT( TABLET_PICK, BTN_STYLUS2) },
+ { HPEN_MAP_BUT( SEC_BARREL_SWITCH,BTN_STYLUS2) },
+ { HIDMAP_FINAL_CB( &hpen_final_digi_cb) },
+};
+
+/* Microsoft-standardized pen support */
+static const struct hidmap_item hpen_map_pen[] = {
+ { HPEN_MAP_ABS_GD(X, ABS_X), .required = true },
+ { HPEN_MAP_ABS_GD(Y, ABS_Y), .required = true },
+ { HPEN_MAP_ABS( TIP_PRESSURE, ABS_PRESSURE), .required = true },
+ { HPEN_MAP_ABS( X_TILT, ABS_TILT_X) },
+ { HPEN_MAP_ABS( Y_TILT, ABS_TILT_Y) },
+ { HPEN_MAP_ABS_CB(BATTERY_STRENGTH, hpen_battery_strenght_cb) },
+ { HPEN_MAP_BUT( TIP_SWITCH, BTN_TOUCH), .required = true },
+ { HPEN_MAP_BUT( IN_RANGE, BTN_TOOL_PEN), .required = true },
+ { HPEN_MAP_BUT( BARREL_SWITCH, BTN_STYLUS) },
+ { HPEN_MAP_BUT( INVERT, BTN_TOOL_RUBBER), .required = true },
+ { HPEN_MAP_BUT( ERASER, BTN_TOUCH), .required = true },
+ { HIDMAP_FINAL_CB( &hpen_final_pen_cb) },
+};
+
+static const struct hid_device_id hpen_devs[] = {
+ { HID_TLC(HUP_DIGITIZERS, HUD_DIGITIZER) },
+ { HID_TLC(HUP_DIGITIZERS, HUD_PEN) },
+};
+
+static int
+hpen_battery_strenght_cb(HIDMAP_CB_ARGS)
+{
+ struct evdev_dev *evdev = HIDMAP_CB_GET_EVDEV();
+ int32_t data;
+
+ switch (HIDMAP_CB_GET_STATE()) {
+ case HIDMAP_CB_IS_ATTACHING:
+ evdev_support_event(evdev, EV_PWR);
+ /* TODO */
+ break;
+ case HIDMAP_CB_IS_RUNNING:
+ data = ctx.data;
+ /* TODO */
+ }
+
+ return (0);
+}
+
+static int
+hpen_final_digi_cb(HIDMAP_CB_ARGS)
+{
+ struct evdev_dev *evdev = HIDMAP_CB_GET_EVDEV();
+
+ if (HIDMAP_CB_GET_STATE() == HIDMAP_CB_IS_ATTACHING)
+ evdev_support_prop(evdev, INPUT_PROP_POINTER);
+
+ /* Do not execute callback at interrupt handler and detach */
+ return (ENOSYS);
+}
+
+static int
+hpen_final_pen_cb(HIDMAP_CB_ARGS)
+{
+ struct evdev_dev *evdev = HIDMAP_CB_GET_EVDEV();
+
+ if (HIDMAP_CB_GET_STATE() == HIDMAP_CB_IS_ATTACHING)
+ evdev_support_prop(evdev, INPUT_PROP_DIRECT);
+
+ /* Do not execute callback at interrupt handler and detach */
+ return (ENOSYS);
+}
+
+static void
+hpen_identify(driver_t *driver, device_t parent)
+{
+ const struct hid_device_info *hw = hid_get_device_info(parent);
+
+ /* the report descriptor for the Wacom Graphire is broken */
+ if (hw->idBus == BUS_USB && hw->idVendor == USB_VENDOR_WACOM) {
+ switch (hw->idProduct) {
+ case USB_PRODUCT_WACOM_GRAPHIRE:
+ hid_set_report_descr(parent,
+ hpen_graphire_report_descr,
+ sizeof(hpen_graphire_report_descr));
+ break;
+
+ case USB_PRODUCT_WACOM_GRAPHIRE3_4X5:
+ hid_set_report_descr(parent,
+ hpen_graphire3_4x5_report_descr,
+ sizeof(hpen_graphire3_4x5_report_descr));
+ break;
+ }
+ }
+}
+
+static int
+hpen_probe(device_t dev)
+{
+ struct hidmap *hm = device_get_softc(dev);
+ int error;
+ bool is_pen;
+
+ error = HIDBUS_LOOKUP_DRIVER_INFO(dev, hpen_devs);
+ if (error != 0)
+ return (error);
+
+ hidmap_set_dev(hm, dev);
+
+ /* Check if report descriptor belongs to a HID tablet device */
+ is_pen = hidbus_get_usage(dev) == HID_USAGE2(HUP_DIGITIZERS, HUD_PEN);
+ error = is_pen
+ ? HIDMAP_ADD_MAP(hm, hpen_map_pen, NULL)
+ : HIDMAP_ADD_MAP(hm, hpen_map_digi, NULL);
+ if (error != 0)
+ return (error);
+
+ hidbus_set_desc(dev, is_pen ? "Pen" : "Digitizer");
+
+ return (BUS_PROBE_DEFAULT);
+}
+
+static int
+hpen_attach(device_t dev)
+{
+ const struct hid_device_info *hw = hid_get_device_info(dev);
+ struct hidmap *hm = device_get_softc(dev);
+ int error;
+
+ if (hw->idBus == BUS_USB && hw->idVendor == USB_VENDOR_WACOM &&
+ hw->idProduct == USB_PRODUCT_WACOM_GRAPHIRE3_4X5) {
+ /*
+ * The Graphire3 needs 0x0202 to be written to
+ * feature report ID 2 before it'll start
+ * returning digitizer data.
+ */
+ static const uint8_t reportbuf[3] = {2, 2, 2};
+ error = hid_set_report(dev, reportbuf, sizeof(reportbuf),
+ HID_FEATURE_REPORT, reportbuf[0]);
+ if (error)
+ device_printf(dev, "set feature report failed, "
+ "error=%d (ignored)\n", error);
+ }
+
+ return (hidmap_attach(hm));
+}
+
+static int
+hpen_detach(device_t dev)
+{
+ return (hidmap_detach(device_get_softc(dev)));
+}
+
+
+static devclass_t hpen_devclass;
+static device_method_t hpen_methods[] = {
+ DEVMETHOD(device_identify, hpen_identify),
+ DEVMETHOD(device_probe, hpen_probe),
+ DEVMETHOD(device_attach, hpen_attach),
+ DEVMETHOD(device_detach, hpen_detach),
+
+ DEVMETHOD_END
+};
+
+DEFINE_CLASS_0(hpen, hpen_driver, hpen_methods, sizeof(struct hidmap));
+DRIVER_MODULE(hpen, hidbus, hpen_driver, hpen_devclass, NULL, 0);
+MODULE_DEPEND(hpen, hid, 1, 1, 1);
+MODULE_DEPEND(hpen, hidbus, 1, 1, 1);
+MODULE_DEPEND(hpen, hidmap, 1, 1, 1);
+MODULE_DEPEND(hpen, evdev, 1, 1, 1);
+MODULE_VERSION(hpen, 1);
+HID_PNP_INFO(hpen_devs);
diff --git a/sys/dev/hid/hsctrl.c b/sys/dev/hid/hsctrl.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/hsctrl.c
@@ -0,0 +1,110 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2020 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 <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * General Desktop/System Controls usage page driver
+ * https://www.usb.org/sites/default/files/documents/hut1_12v2.pdf
+ */
+
+#include <sys/param.h>
+#include <sys/bitstring.h>
+#include <sys/bus.h>
+#include <sys/kernel.h>
+#include <sys/module.h>
+#include <sys/sysctl.h>
+
+#include <dev/evdev/input.h>
+#include <dev/evdev/evdev.h>
+
+#include <dev/hid/hid.h>
+#include <dev/hid/hidbus.h>
+#include <dev/hid/hidmap.h>
+
+#define HSCTRL_MAP(usage, code) \
+ { HIDMAP_KEY(HUP_GENERIC_DESKTOP, HUG_SYSTEM_##usage, code) }
+
+static const struct hidmap_item hsctrl_map[] = {
+ HSCTRL_MAP(POWER_DOWN, KEY_POWER),
+ HSCTRL_MAP(SLEEP, KEY_SLEEP),
+ HSCTRL_MAP(WAKEUP, KEY_WAKEUP),
+ HSCTRL_MAP(CONTEXT_MENU, KEY_CONTEXT_MENU),
+ HSCTRL_MAP(MAIN_MENU, KEY_MENU),
+ HSCTRL_MAP(APP_MENU, KEY_PROG1),
+ HSCTRL_MAP(MENU_HELP, KEY_HELP),
+ HSCTRL_MAP(MENU_EXIT, KEY_EXIT),
+ HSCTRL_MAP(MENU_SELECT, KEY_SELECT),
+ HSCTRL_MAP(MENU_RIGHT, KEY_RIGHT),
+ HSCTRL_MAP(MENU_LEFT, KEY_LEFT),
+ HSCTRL_MAP(MENU_UP, KEY_UP),
+ HSCTRL_MAP(MENU_DOWN, KEY_DOWN),
+ HSCTRL_MAP(POWER_UP, KEY_POWER2),
+ HSCTRL_MAP(RESTART, KEY_RESTART),
+};
+
+static const struct hid_device_id hsctrl_devs[] = {
+ { HID_TLC(HUP_GENERIC_DESKTOP, HUG_SYSTEM_CONTROL) },
+};
+
+static int
+hsctrl_probe(device_t dev)
+{
+ return (HIDMAP_PROBE(device_get_softc(dev), dev,
+ hsctrl_devs, hsctrl_map, "System Control"));
+}
+
+static int
+hsctrl_attach(device_t dev)
+{
+ return (hidmap_attach(device_get_softc(dev)));
+}
+
+static int
+hsctrl_detach(device_t dev)
+{
+ return (hidmap_detach(device_get_softc(dev)));
+}
+
+static devclass_t hsctrl_devclass;
+static device_method_t hsctrl_methods[] = {
+ DEVMETHOD(device_probe, hsctrl_probe),
+ DEVMETHOD(device_attach, hsctrl_attach),
+ DEVMETHOD(device_detach, hsctrl_detach),
+
+ DEVMETHOD_END
+};
+
+DEFINE_CLASS_0(hsctrl, hsctrl_driver, hsctrl_methods, sizeof(struct hidmap));
+DRIVER_MODULE(hsctrl, hidbus, hsctrl_driver, hsctrl_devclass, NULL, 0);
+MODULE_DEPEND(hsctrl, hid, 1, 1, 1);
+MODULE_DEPEND(hsctrl, hidbus, 1, 1, 1);
+MODULE_DEPEND(hsctrl, hidmap, 1, 1, 1);
+MODULE_DEPEND(hsctrl, evdev, 1, 1, 1);
+MODULE_VERSION(hsctrl, 1);
+HID_PNP_INFO(hsctrl_devs);
diff --git a/sys/dev/hid/ps4dshock.c b/sys/dev/hid/ps4dshock.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/ps4dshock.c
@@ -0,0 +1,1437 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2020 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 <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * Sony PS4 DualShock 4 driver
+ * https://eleccelerator.com/wiki/index.php?title=DualShock_4
+ * https://gist.github.com/johndrinkwater/7708901
+ * https://www.psdevwiki.com/ps4/DS4-USB
+ */
+
+#include <sys/param.h>
+#include <sys/bus.h>
+#include <sys/kernel.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/module.h>
+#include <sys/sx.h>
+#include <sys/sysctl.h>
+
+#include <dev/evdev/input.h>
+#include <dev/evdev/evdev.h>
+
+#define HID_DEBUG_VAR ps4dshock_debug
+#include <dev/hid/hid.h>
+#include <dev/hid/hidbus.h>
+#include <dev/hid/hidquirk.h>
+#include <dev/hid/hidmap.h>
+#include "usbdevs.h"
+
+#ifdef HID_DEBUG
+static int ps4dshock_debug = 1;
+
+static SYSCTL_NODE(_hw_hid, OID_AUTO, ps4dshock, CTLFLAG_RW, 0,
+ "Sony PS4 DualShock Gamepad");
+SYSCTL_INT(_hw_hid_ps4dshock, OID_AUTO, debug, CTLFLAG_RWTUN,
+ &ps4dshock_debug, 0, "Debug level");
+#endif
+
+#define PS4DS_NAME "Sony PS4 Dualshock 4"
+
+/*
+ * Hardware timestamp export is functional but as of May 2020 it does not
+ * fully supported by libinput. Disable it for now as it results in extra
+ * userland wakeups when touch state does not change between consecutive
+ * reports. Evdev tries to filter out such an events but ever changing
+ * timestamp interferes with that.
+ */
+/* #define PS4DSMTP_ENABLE_HW_TIMESTAMPS 1 */
+
+static const uint8_t ps4dshock_rdesc[] = {
+ 0x05, 0x01, // Usage Page (Generic Desktop Ctrls)
+ 0x09, 0x05, // Usage (Game Pad)
+ 0xA1, 0x01, // Collection (Application)
+ 0x85, 0x01, // Report ID (1)
+ 0x09, 0x30, // Usage (X)
+ 0x09, 0x31, // Usage (Y)
+ 0x09, 0x33, // Usage (Rx)
+ 0x09, 0x34, // Usage (Ry)
+ 0x15, 0x00, // Logical Minimum (0)
+ 0x26, 0xFF, 0x00, // Logical Maximum (255)
+ 0x75, 0x08, // Report Size (8)
+ 0x95, 0x04, // Report Count (4)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x09, 0x39, // Usage (Hat switch)
+ 0x15, 0x00, // Logical Minimum (0)
+ 0x25, 0x07, // Logical Maximum (7)
+ 0x35, 0x00, // Physical Minimum (0)
+ 0x46, 0x3B, 0x01, // Physical Maximum (315)
+ 0x65, 0x14, // Unit (System: English Rotation, Length: Centimeter)
+ 0x75, 0x04, // Report Size (4)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x42, // Input (Data,Var,Abs,Null State)
+ 0x65, 0x00, // Unit (None)
+ 0x45, 0x00, // Physical Maximum (0)
+ 0x05, 0x09, // Usage Page (Button)
+ 0x19, 0x01, // Usage Minimum (0x01)
+ 0x29, 0x0E, // Usage Maximum (0x0E)
+ 0x15, 0x00, // Logical Minimum (0)
+ 0x25, 0x01, // Logical Maximum (1)
+ 0x75, 0x01, // Report Size (1)
+ 0x95, 0x0E, // Report Count (14)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x06, 0x00, 0xFF, // Usage Page (Vendor Defined 0xFF00)
+ 0x09, 0x20, // Usage (0x20)
+ 0x75, 0x06, // Report Size (6)
+ 0x95, 0x01, // Report Count (1)
+ 0x15, 0x00, // Logical Minimum (0)
+ 0x25, 0x3F, // Logical Maximum (63)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x05, 0x01, // Usage Page (Generic Desktop Ctrls)
+ 0x09, 0x32, // Usage (Z)
+ 0x09, 0x35, // Usage (Rz)
+ 0x15, 0x00, // Logical Minimum (0)
+ 0x26, 0xFF, 0x00, // Logical Maximum (255)
+ 0x75, 0x08, // Report Size (8)
+ 0x95, 0x02, // Report Count (2)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0xC0, // End Collection
+ 0x05, 0x01, // Usage Page (Generic Desktop Ctrls)
+ 0x09, 0x08, // Usage (Multi-axis Controller)
+ 0xA1, 0x01, // Collection (Application)
+ 0x06, 0x00, 0xFF, // Usage Page (Vendor Defined 0xFF00)
+ 0x09, 0x21, // Usage (0x21)
+ 0x27, 0xFF, 0xFF, 0x00, 0x00, // Logical Maximum (65534)
+ 0x75, 0x10, // Report Size (16)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x05, 0x06, // Usage Page (Generic Dev Ctrls)
+ 0x09, 0x20, // Usage (Battery Strength)
+ 0x26, 0xFF, 0x00, // Logical Maximum (255)
+ 0x75, 0x08, // Report Size (8)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x05, 0x01, // Usage Page (Generic Desktop Ctrls)
+ 0x19, 0x33, // Usage Minimum (RX)
+ 0x29, 0x35, // Usage Maximum (RZ)
+ 0x16, 0x00, 0x80, // Logical Minimum (-32768)
+ 0x26, 0xFF, 0x7F, // Logical Maximum (32767)
+ 0x75, 0x10, // Report Size (16)
+ 0x95, 0x03, // Report Count (3)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x19, 0x30, // Usage Minimum (X)
+ 0x29, 0x32, // Usage Maximum (Z)
+ 0x16, 0x00, 0x80, // Logical Minimum (-32768)
+ 0x26, 0xFF, 0x7F, // Logical Maximum (32767)
+ 0x95, 0x03, // Report Count (3)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x06, 0x00, 0xFF, // Usage Page (Vendor Defined 0xFF00)
+ 0x09, 0x21, // Usage (0x21)
+ 0x15, 0x00, // Logical Minimum (0)
+ 0x26, 0xFF, 0x00, // Logical Maximum (255)
+ 0x75, 0x08, // Report Size (8)
+ 0x95, 0x05, // Report Count (5)
+ 0x81, 0x03, // Input (Const)
+ 0xC0, // End Collection
+ 0x05, 0x0C, // Usage Page (Consumer)
+ 0x09, 0x05, // Usage (Headphone)
+ 0xA1, 0x01, // Collection (Application)
+ 0x75, 0x05, // Report Size (5)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x03, // Input (Const)
+ 0x06, 0x00, 0xFF, // Usage Page (Vendor Defined 0xFF00)
+ 0x09, 0x20, // Usage (0x20)
+ 0x09, 0x21, // Usage (0x21)
+ 0x15, 0x00, // Logical Minimum (0)
+ 0x25, 0x01, // Logical Maximum (1)
+ 0x75, 0x01, // Report Size (1)
+ 0x95, 0x02, // Report Count (2)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x75, 0x01, // Report Size (1)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x03, // Input (Const)
+ 0x75, 0x08, // Report Size (8)
+ 0x95, 0x02, // Report Count (2)
+ 0x81, 0x03, // Input (Const)
+ 0xC0, // End Collection
+ 0x05, 0x0D, // Usage Page (Digitizer)
+ 0x09, 0x05, // Usage (Touch Pad)
+ 0xA1, 0x01, // Collection (Application)
+ 0x06, 0x00, 0xFF, // Usage Page (Vendor Defined 0xFF00)
+ 0x09, 0x21, // Usage (0x21)
+ 0x15, 0x00, // Logical Minimum (0)
+ 0x25, 0x03, // Logical Maximum (3)
+ 0x75, 0x04, // Report Size (4)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x75, 0x04, // Report Size (4)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x03, // Input (Data,Var,Abs)
+ 0x05, 0x0D, // Usage Page (Digitizer)
+ 0x09, 0x56, // Usage (0x56)
+ 0x55, 0x0C, // Unit Exponent (-4)
+ 0x66, 0x01, 0x10, // Unit (System: SI Linear, Time: Seconds)
+ 0x46, 0xCC, 0x06, // Physical Maximum (1740)
+ 0x26, 0xFF, 0x00, // Logical Maximum (255)
+ 0x75, 0x08, // Report Size (8)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x65, 0x00, // Unit (None)
+ 0x45, 0x00, // Physical Maximum (0)
+ 0x05, 0x0D, // Usage Page (Digitizer)
+ 0x09, 0x22, // Usage (Finger)
+ 0xA1, 0x02, // Collection (Logical)
+ 0x09, 0x51, // Usage (0x51)
+ 0x25, 0x7F, // Logical Maximum (127)
+ 0x75, 0x07, // Report Size (7)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x09, 0x42, // Usage (Tip Switch)
+ 0x25, 0x01, // Logical Maximum (1)
+ 0x75, 0x01, // Report Size (1)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x05, 0x01, // Usage Page (Generic Desktop Ctrls)
+ 0x09, 0x30, // Usage (X)
+ 0x55, 0x0E, // Unit Exponent (-2)
+ 0x65, 0x11, // Unit (System: SI Linear, Length: Centimeter)
+ 0x35, 0x00, // Physical Minimum (0)
+ 0x46, 0x80, 0x02, // Physical Maximum (640)
+ 0x26, 0x80, 0x07, // Logical Maximum (1920)
+ 0x75, 0x0C, // Report Size (12)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x09, 0x31, // Usage (Y)
+ 0x46, 0xC0, 0x00, // Physical Maximum (192)
+ 0x26, 0xAE, 0x03, // Logical Maximum (942)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x65, 0x00, // Unit (None)
+ 0x45, 0x00, // Physical Maximum (0)
+ 0xC0, // End Collection
+ 0x05, 0x0D, // Usage Page (Digitizer)
+ 0x09, 0x22, // Usage (Finger)
+ 0xA1, 0x02, // Collection (Logical)
+ 0x09, 0x51, // Usage (0x51)
+ 0x25, 0x7F, // Logical Maximum (127)
+ 0x75, 0x07, // Report Size (7)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x09, 0x42, // Usage (Tip Switch)
+ 0x25, 0x01, // Logical Maximum (1)
+ 0x75, 0x01, // Report Size (1)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x05, 0x01, // Usage Page (Generic Desktop Ctrls)
+ 0x09, 0x30, // Usage (X)
+ 0x55, 0x0E, // Unit Exponent (-2)
+ 0x65, 0x11, // Unit (System: SI Linear, Length: Centimeter)
+ 0x35, 0x00, // Physical Minimum (0)
+ 0x46, 0x80, 0x02, // Physical Maximum (640)
+ 0x26, 0x80, 0x07, // Logical Maximum (1920)
+ 0x75, 0x0C, // Report Size (12)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x09, 0x31, // Usage (Y)
+ 0x46, 0xC0, 0x00, // Physical Maximum (192)
+ 0x26, 0xAE, 0x03, // Logical Maximum (942)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x65, 0x00, // Unit (None)
+ 0x45, 0x00, // Physical Maximum (0)
+ 0xC0, // End Collection
+ 0x05, 0x0D, // Usage Page (Digitizer)
+ 0x09, 0x56, // Usage (0x56)
+ 0x55, 0x0C, // Unit Exponent (-4)
+ 0x66, 0x01, 0x10, // Unit (System: SI Linear, Time: Seconds)
+ 0x46, 0xCC, 0x06, // Physical Maximum (1740)
+ 0x26, 0xFF, 0x00, // Logical Maximum (255)
+ 0x75, 0x08, // Report Size (8)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x65, 0x00, // Unit (None)
+ 0x45, 0x00, // Physical Maximum (0)
+ 0x05, 0x0D, // Usage Page (Digitizer)
+ 0x09, 0x22, // Usage (Finger)
+ 0xA1, 0x02, // Collection (Logical)
+ 0x09, 0x51, // Usage (0x51)
+ 0x25, 0x7F, // Logical Maximum (127)
+ 0x75, 0x07, // Report Size (7)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x09, 0x42, // Usage (Tip Switch)
+ 0x25, 0x01, // Logical Maximum (1)
+ 0x75, 0x01, // Report Size (1)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x05, 0x01, // Usage Page (Generic Desktop Ctrls)
+ 0x09, 0x30, // Usage (X)
+ 0x55, 0x0E, // Unit Exponent (-2)
+ 0x65, 0x11, // Unit (System: SI Linear, Length: Centimeter)
+ 0x35, 0x00, // Physical Minimum (0)
+ 0x46, 0x80, 0x02, // Physical Maximum (640)
+ 0x26, 0x80, 0x07, // Logical Maximum (1920)
+ 0x75, 0x0C, // Report Size (12)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x09, 0x31, // Usage (Y)
+ 0x46, 0xC0, 0x00, // Physical Maximum (192)
+ 0x26, 0xAE, 0x03, // Logical Maximum (942)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x65, 0x00, // Unit (None)
+ 0x45, 0x00, // Physical Maximum (0)
+ 0xC0, // End Collection
+ 0x05, 0x0D, // Usage Page (Digitizer)
+ 0x09, 0x22, // Usage (Finger)
+ 0xA1, 0x02, // Collection (Logical)
+ 0x09, 0x51, // Usage (0x51)
+ 0x25, 0x7F, // Logical Maximum (127)
+ 0x75, 0x07, // Report Size (7)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x09, 0x42, // Usage (Tip Switch)
+ 0x25, 0x01, // Logical Maximum (1)
+ 0x75, 0x01, // Report Size (1)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x05, 0x01, // Usage Page (Generic Desktop Ctrls)
+ 0x09, 0x30, // Usage (X)
+ 0x55, 0x0E, // Unit Exponent (-2)
+ 0x65, 0x11, // Unit (System: SI Linear, Length: Centimeter)
+ 0x35, 0x00, // Physical Minimum (0)
+ 0x46, 0x80, 0x02, // Physical Maximum (640)
+ 0x26, 0x80, 0x07, // Logical Maximum (1920)
+ 0x75, 0x0C, // Report Size (12)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x09, 0x31, // Usage (Y)
+ 0x46, 0xC0, 0x00, // Physical Maximum (192)
+ 0x26, 0xAE, 0x03, // Logical Maximum (942)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x65, 0x00, // Unit (None)
+ 0x45, 0x00, // Physical Maximum (0)
+ 0xC0, // End Collection
+ 0x05, 0x0D, // Usage Page (Digitizer)
+ 0x09, 0x56, // Usage (0x56)
+ 0x55, 0x0C, // Unit Exponent (-4)
+ 0x66, 0x01, 0x10, // Unit (System: SI Linear, Time: Seconds)
+ 0x46, 0xCC, 0x06, // Physical Maximum (1740)
+ 0x26, 0xFF, 0x00, // Logical Maximum (255)
+ 0x75, 0x08, // Report Size (8)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x65, 0x00, // Unit (None)
+ 0x45, 0x00, // Physical Maximum (0)
+ 0x05, 0x0D, // Usage Page (Digitizer)
+ 0x09, 0x22, // Usage (Finger)
+ 0xA1, 0x02, // Collection (Logical)
+ 0x09, 0x51, // Usage (0x51)
+ 0x25, 0x7F, // Logical Maximum (127)
+ 0x75, 0x07, // Report Size (7)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x09, 0x42, // Usage (Tip Switch)
+ 0x25, 0x01, // Logical Maximum (1)
+ 0x75, 0x01, // Report Size (1)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x05, 0x01, // Usage Page (Generic Desktop Ctrls)
+ 0x09, 0x30, // Usage (X)
+ 0x55, 0x0E, // Unit Exponent (-2)
+ 0x65, 0x11, // Unit (System: SI Linear, Length: Centimeter)
+ 0x35, 0x00, // Physical Minimum (0)
+ 0x46, 0x80, 0x02, // Physical Maximum (640)
+ 0x26, 0x80, 0x07, // Logical Maximum (1920)
+ 0x75, 0x0C, // Report Size (12)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x09, 0x31, // Usage (Y)
+ 0x46, 0xC0, 0x00, // Physical Maximum (192)
+ 0x26, 0xAE, 0x03, // Logical Maximum (942)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x65, 0x00, // Unit (None)
+ 0x45, 0x00, // Physical Maximum (0)
+ 0xC0, // End Collection
+ 0x05, 0x0D, // Usage Page (Digitizer)
+ 0x09, 0x22, // Usage (Finger)
+ 0xA1, 0x02, // Collection (Logical)
+ 0x09, 0x51, // Usage (0x51)
+ 0x25, 0x7F, // Logical Maximum (127)
+ 0x75, 0x07, // Report Size (7)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x09, 0x42, // Usage (Tip Switch)
+ 0x25, 0x01, // Logical Maximum (1)
+ 0x75, 0x01, // Report Size (1)
+ 0x95, 0x01, // Report Count (1)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x05, 0x01, // Usage Page (Generic Desktop Ctrls)
+ 0x09, 0x30, // Usage (X)
+ 0x55, 0x0E, // Unit Exponent (-2)
+ 0x65, 0x11, // Unit (System: SI Linear, Length: Centimeter)
+ 0x35, 0x00, // Physical Minimum (0)
+ 0x46, 0x80, 0x02, // Physical Maximum (640)
+ 0x26, 0x80, 0x07, // Logical Maximum (1920)
+ 0x75, 0x0C, // Report Size (12)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x09, 0x31, // Usage (Y)
+ 0x46, 0xC0, 0x00, // Physical Maximum (192)
+ 0x26, 0xAE, 0x03, // Logical Maximum (942)
+ 0x81, 0x02, // Input (Data,Var,Abs)
+ 0x65, 0x00, // Unit (None)
+ 0x45, 0x00, // Physical Maximum (0)
+ 0xC0, // End Collection
+ 0x75, 0x08, // Report Size (8)
+ 0x95, 0x03, // Report Count (3)
+ 0x81, 0x03, // Input (Const)
+ /* Output and feature reports */
+ 0x85, 0x05, // Report ID (5)
+ 0x06, 0x00, 0xFF, // Usage Page (Vendor Defined 0xFF00)
+ 0x09, 0x22, // Usage (0x22)
+ 0x15, 0x00, // Logical Minimum (0)
+ 0x26, 0xFF, 0x00, // Logical Maximum (255)
+ 0x95, 0x1F, // Report Count (31)
+ 0x91, 0x02, // Output (Data,Var,Abs)
+ 0x85, 0x04, // Report ID (4)
+ 0x09, 0x23, // Usage (0x23)
+ 0x95, 0x24, // Report Count (36)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x02, // Report ID (2)
+ 0x09, 0x24, // Usage (0x24)
+ 0x95, 0x24, // Report Count (36)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x08, // Report ID (8)
+ 0x09, 0x25, // Usage (0x25)
+ 0x95, 0x03, // Report Count (3)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x10, // Report ID (16)
+ 0x09, 0x26, // Usage (0x26)
+ 0x95, 0x04, // Report Count (4)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x11, // Report ID (17)
+ 0x09, 0x27, // Usage (0x27)
+ 0x95, 0x02, // Report Count (2)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x12, // Report ID (18)
+ 0x06, 0x02, 0xFF, // Usage Page (Vendor Defined 0xFF02)
+ 0x09, 0x21, // Usage (0x21)
+ 0x95, 0x0F, // Report Count (15)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x13, // Report ID (19)
+ 0x09, 0x22, // Usage (0x22)
+ 0x95, 0x16, // Report Count (22)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x14, // Report ID (20)
+ 0x06, 0x05, 0xFF, // Usage Page (Vendor Defined 0xFF05)
+ 0x09, 0x20, // Usage (0x20)
+ 0x95, 0x10, // Report Count (16)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x15, // Report ID (21)
+ 0x09, 0x21, // Usage (0x21)
+ 0x95, 0x2C, // Report Count (44)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x06, 0x80, 0xFF, // Usage Page (Vendor Defined 0xFF80)
+ 0x85, 0x80, // Report ID (-128)
+ 0x09, 0x20, // Usage (0x20)
+ 0x95, 0x06, // Report Count (6)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x81, // Report ID (-127)
+ 0x09, 0x21, // Usage (0x21)
+ 0x95, 0x06, // Report Count (6)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x82, // Report ID (-126)
+ 0x09, 0x22, // Usage (0x22)
+ 0x95, 0x05, // Report Count (5)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x83, // Report ID (-125)
+ 0x09, 0x23, // Usage (0x23)
+ 0x95, 0x01, // Report Count (1)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x84, // Report ID (-124)
+ 0x09, 0x24, // Usage (0x24)
+ 0x95, 0x04, // Report Count (4)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x85, // Report ID (-123)
+ 0x09, 0x25, // Usage (0x25)
+ 0x95, 0x06, // Report Count (6)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x86, // Report ID (-122)
+ 0x09, 0x26, // Usage (0x26)
+ 0x95, 0x06, // Report Count (6)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x87, // Report ID (-121)
+ 0x09, 0x27, // Usage (0x27)
+ 0x95, 0x23, // Report Count (35)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x88, // Report ID (-120)
+ 0x09, 0x28, // Usage (0x28)
+ 0x95, 0x22, // Report Count (34)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x89, // Report ID (-119)
+ 0x09, 0x29, // Usage (0x29)
+ 0x95, 0x02, // Report Count (2)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x90, // Report ID (-112)
+ 0x09, 0x30, // Usage (0x30)
+ 0x95, 0x05, // Report Count (5)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x91, // Report ID (-111)
+ 0x09, 0x31, // Usage (0x31)
+ 0x95, 0x03, // Report Count (3)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x92, // Report ID (-110)
+ 0x09, 0x32, // Usage (0x32)
+ 0x95, 0x03, // Report Count (3)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0x93, // Report ID (-109)
+ 0x09, 0x33, // Usage (0x33)
+ 0x95, 0x0C, // Report Count (12)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xA0, // Report ID (-96)
+ 0x09, 0x40, // Usage (0x40)
+ 0x95, 0x06, // Report Count (6)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xA1, // Report ID (-95)
+ 0x09, 0x41, // Usage (0x41)
+ 0x95, 0x01, // Report Count (1)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xA2, // Report ID (-94)
+ 0x09, 0x42, // Usage (0x42)
+ 0x95, 0x01, // Report Count (1)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xA3, // Report ID (-93)
+ 0x09, 0x43, // Usage (0x43)
+ 0x95, 0x30, // Report Count (48)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xA4, // Report ID (-92)
+ 0x09, 0x44, // Usage (0x44)
+ 0x95, 0x0D, // Report Count (13)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xA5, // Report ID (-91)
+ 0x09, 0x45, // Usage (0x45)
+ 0x95, 0x15, // Report Count (21)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xA6, // Report ID (-90)
+ 0x09, 0x46, // Usage (0x46)
+ 0x95, 0x15, // Report Count (21)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xF0, // Report ID (-16)
+ 0x09, 0x47, // Usage (0x47)
+ 0x95, 0x3F, // Report Count (63)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xF1, // Report ID (-15)
+ 0x09, 0x48, // Usage (0x48)
+ 0x95, 0x3F, // Report Count (63)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xF2, // Report ID (-14)
+ 0x09, 0x49, // Usage (0x49)
+ 0x95, 0x0F, // Report Count (15)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xA7, // Report ID (-89)
+ 0x09, 0x4A, // Usage (0x4A)
+ 0x95, 0x01, // Report Count (1)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xA8, // Report ID (-88)
+ 0x09, 0x4B, // Usage (0x4B)
+ 0x95, 0x01, // Report Count (1)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xA9, // Report ID (-87)
+ 0x09, 0x4C, // Usage (0x4C)
+ 0x95, 0x08, // Report Count (8)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xAA, // Report ID (-86)
+ 0x09, 0x4E, // Usage (0x4E)
+ 0x95, 0x01, // Report Count (1)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xAB, // Report ID (-85)
+ 0x09, 0x4F, // Usage (0x4F)
+ 0x95, 0x39, // Report Count (57)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xAC, // Report ID (-84)
+ 0x09, 0x50, // Usage (0x50)
+ 0x95, 0x39, // Report Count (57)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xAD, // Report ID (-83)
+ 0x09, 0x51, // Usage (0x51)
+ 0x95, 0x0B, // Report Count (11)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xAE, // Report ID (-82)
+ 0x09, 0x52, // Usage (0x52)
+ 0x95, 0x01, // Report Count (1)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xAF, // Report ID (-81)
+ 0x09, 0x53, // Usage (0x53)
+ 0x95, 0x02, // Report Count (2)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0x85, 0xB0, // Report ID (-80)
+ 0x09, 0x54, // Usage (0x54)
+ 0x95, 0x3F, // Report Count (63)
+ 0xB1, 0x02, // Feature (Data,Var,Abs)
+ 0xC0, // End Collection
+};
+
+#define PS4DS_GYRO_RES_PER_DEG_S 1024
+#define PS4DS_ACC_RES_PER_G 8192
+#define PS4DS_MAX_TOUCHPAD_PACKETS 4
+#define PS4DS_FEATURE_REPORT2_SIZE 37
+#define PS4DS_OUTPUT_REPORT5_SIZE 32
+#define PS4DS_OUTPUT_REPORT11_SIZE 78
+
+static hidmap_cb_t ps4dshock_hat_switch_cb;
+static hidmap_cb_t ps4dshock_final_cb;
+static hidmap_cb_t ps4dsacc_data_cb;
+static hidmap_cb_t ps4dsacc_tstamp_cb;
+static hidmap_cb_t ps4dsacc_final_cb;
+static hidmap_cb_t ps4dsmtp_data_cb;
+static hidmap_cb_t ps4dsmtp_npackets_cb;
+static hidmap_cb_t ps4dsmtp_final_cb;
+
+struct ps4ds_out5 {
+ uint8_t features;
+ uint8_t reserved1;
+ uint8_t reserved2;
+ uint8_t rumble_right;
+ uint8_t rumble_left;
+ uint8_t led_color_r;
+ uint8_t led_color_g;
+ uint8_t led_color_b;
+ uint8_t led_delay_on; /* centiseconds */
+ uint8_t led_delay_off;
+} __attribute__((packed));
+
+static const struct ps4ds_led {
+ int r;
+ int g;
+ int b;
+} ps4ds_leds[] = {
+ /* The first 4 entries match the PS4, other from Linux driver */
+ { 0x00, 0x00, 0x40 }, /* Blue */
+ { 0x40, 0x00, 0x00 }, /* Red */
+ { 0x00, 0x40, 0x00 }, /* Green */
+ { 0x20, 0x00, 0x20 }, /* Pink */
+ { 0x02, 0x01, 0x00 }, /* Orange */
+ { 0x00, 0x01, 0x01 }, /* Teal */
+ { 0x01, 0x01, 0x01 } /* White */
+};
+
+enum ps4ds_led_state {
+ PS4DS_LED_OFF,
+ PS4DS_LED_ON,
+ PS4DS_LED_BLINKING,
+ PD4DS_LED_CNT,
+};
+
+/* Map structure for accelerometer and gyro. */
+struct ps4ds_calib_data {
+ int32_t usage;
+ int32_t code;
+ int32_t res;
+ int32_t range;
+ /* Calibration data for accelerometer and gyro. */
+ int16_t bias;
+ int32_t sens_numer;
+ int32_t sens_denom;
+};
+
+enum {
+ PS4DS_TSTAMP,
+ PS4DS_CID1,
+ PS4DS_TIP1,
+ PS4DS_X1,
+ PS4DS_Y1,
+ PS4DS_CID2,
+ PS4DS_TIP2,
+ PS4DS_X2,
+ PS4DS_Y2,
+ PS4DS_NTPUSAGES,
+};
+
+struct ps4dshock_softc {
+ struct hidmap hm;
+
+ bool is_bluetooth;
+
+ struct sx lock;
+ enum ps4ds_led_state led_state;
+ struct ps4ds_led led_color;
+ int led_delay_on; /* msecs */
+ int led_delay_off;
+
+ int rumble_right;
+ int rumble_left;
+};
+
+struct ps4dsacc_softc {
+ struct hidmap hm;
+
+ uint16_t hw_tstamp;
+ int32_t ev_tstamp;
+
+ struct ps4ds_calib_data calib_data[6];
+};
+
+struct ps4dsmtp_softc {
+ struct hidmap hm;
+
+ struct hid_location btn_loc;
+ u_int npackets;
+ int32_t *data_ptr;
+ int32_t data[PS4DS_MAX_TOUCHPAD_PACKETS * PS4DS_NTPUSAGES];
+
+ bool do_tstamps;
+ uint8_t hw_tstamp;
+ int32_t ev_tstamp;
+ bool touch;
+};
+
+#define PD4DSHOCK_OFFSET(field) offsetof(struct ps4dshock_softc, field)
+enum {
+ PD4DSHOCK_SYSCTL_LED_STATE = PD4DSHOCK_OFFSET(led_state),
+ PD4DSHOCK_SYSCTL_LED_COLOR_R = PD4DSHOCK_OFFSET(led_color.r),
+ PD4DSHOCK_SYSCTL_LED_COLOR_G = PD4DSHOCK_OFFSET(led_color.g),
+ PD4DSHOCK_SYSCTL_LED_COLOR_B = PD4DSHOCK_OFFSET(led_color.b),
+ PD4DSHOCK_SYSCTL_LED_DELAY_ON = PD4DSHOCK_OFFSET(led_delay_on),
+ PD4DSHOCK_SYSCTL_LED_DELAY_OFF= PD4DSHOCK_OFFSET(led_delay_off),
+#define PD4DSHOCK_SYSCTL_LAST PD4DSHOCK_SYSCTL_LED_DELAY_OFF
+};
+
+#define PS4DS_MAP_BTN(number, code) \
+ { HIDMAP_KEY(HUP_BUTTON, number, code) }
+#define PS4DS_MAP_ABS(usage, code) \
+ { HIDMAP_ABS(HUP_GENERIC_DESKTOP, HUG_##usage, code) }
+#define PS4DS_MAP_FLT(usage, code) \
+ { HIDMAP_ABS(HUP_GENERIC_DESKTOP, HUG_##usage, code), .flat = 15 }
+#define PS4DS_MAP_VSW(usage, code) \
+ { HIDMAP_SW(HUP_MICROSOFT, usage, code) }
+#define PS4DS_MAP_GCB(usage, callback) \
+ { HIDMAP_ANY_CB(HUP_GENERIC_DESKTOP, HUG_##usage, callback) }
+#define PS4DS_MAP_VCB(usage, callback) \
+ { HIDMAP_ANY_CB(HUP_MICROSOFT, usage, callback) }
+#define PS4DS_FINALCB(cb) \
+ { HIDMAP_FINAL_CB(&cb) }
+
+static const struct hidmap_item ps4dshock_map[] = {
+ PS4DS_MAP_FLT(X, ABS_X),
+ PS4DS_MAP_FLT(Y, ABS_Y),
+ PS4DS_MAP_ABS(Z, ABS_Z),
+ PS4DS_MAP_FLT(RX, ABS_RX),
+ PS4DS_MAP_FLT(RY, ABS_RY),
+ PS4DS_MAP_ABS(RZ, ABS_RZ),
+ PS4DS_MAP_BTN(1, BTN_WEST),
+ PS4DS_MAP_BTN(2, BTN_SOUTH),
+ PS4DS_MAP_BTN(3, BTN_EAST),
+ PS4DS_MAP_BTN(4, BTN_NORTH),
+ PS4DS_MAP_BTN(5, BTN_TL),
+ PS4DS_MAP_BTN(6, BTN_TR),
+ PS4DS_MAP_BTN(7, BTN_TL2),
+ PS4DS_MAP_BTN(8, BTN_TR2),
+ PS4DS_MAP_BTN(9, BTN_SELECT),
+ PS4DS_MAP_BTN(10, BTN_START),
+ PS4DS_MAP_BTN(11, BTN_THUMBL),
+ PS4DS_MAP_BTN(12, BTN_THUMBR),
+ PS4DS_MAP_BTN(13, BTN_MODE),
+ /* Click button is handled by touchpad driver */
+ /* PS4DS_MAP_BTN(14, BTN_LEFT), */
+ PS4DS_MAP_GCB(HAT_SWITCH, ps4dshock_hat_switch_cb),
+ PS4DS_FINALCB( ps4dshock_final_cb),
+};
+static const struct hidmap_item ps4dsacc_map[] = {
+ PS4DS_MAP_GCB(X, ps4dsacc_data_cb),
+ PS4DS_MAP_GCB(Y, ps4dsacc_data_cb),
+ PS4DS_MAP_GCB(Z, ps4dsacc_data_cb),
+ PS4DS_MAP_GCB(RX, ps4dsacc_data_cb),
+ PS4DS_MAP_GCB(RY, ps4dsacc_data_cb),
+ PS4DS_MAP_GCB(RZ, ps4dsacc_data_cb),
+ PS4DS_MAP_VCB(0x0021, ps4dsacc_tstamp_cb),
+ PS4DS_FINALCB( ps4dsacc_final_cb),
+};
+static const struct hidmap_item ps4dshead_map[] = {
+ PS4DS_MAP_VSW(0x0020, SW_MICROPHONE_INSERT),
+ PS4DS_MAP_VSW(0x0021, SW_HEADPHONE_INSERT),
+};
+static const struct hidmap_item ps4dsmtp_map[] = {
+ { HIDMAP_ABS_CB(HUP_MICROSOFT, 0x0021, ps4dsmtp_npackets_cb)},
+ { HIDMAP_ABS_CB(HUP_DIGITIZERS, HUD_SCAN_TIME, ps4dsmtp_data_cb) },
+ { HIDMAP_ABS_CB(HUP_DIGITIZERS, HUD_CONTACTID, ps4dsmtp_data_cb) },
+ { HIDMAP_ABS_CB(HUP_DIGITIZERS, HUD_TIP_SWITCH, ps4dsmtp_data_cb) },
+ { HIDMAP_ABS_CB(HUP_GENERIC_DESKTOP, HUG_X, ps4dsmtp_data_cb) },
+ { HIDMAP_ABS_CB(HUP_GENERIC_DESKTOP, HUG_Y, ps4dsmtp_data_cb) },
+ { HIDMAP_FINAL_CB( ps4dsmtp_final_cb) },
+};
+
+static const struct hid_device_id ps4dshock_devs[] = {
+ { HID_BVP(BUS_USB, USB_VENDOR_SONY, 0x9cc),
+ HID_TLC(HUP_GENERIC_DESKTOP, HUG_GAME_PAD) },
+};
+static const struct hid_device_id ps4dsacc_devs[] = {
+ { HID_BVP(BUS_USB, USB_VENDOR_SONY, 0x9cc),
+ HID_TLC(HUP_GENERIC_DESKTOP, HUG_MULTIAXIS_CNTROLLER) },
+};
+static const struct hid_device_id ps4dshead_devs[] = {
+ { HID_BVP(BUS_USB, USB_VENDOR_SONY, 0x9cc),
+ HID_TLC(HUP_CONSUMER, HUC_HEADPHONE) },
+};
+static const struct hid_device_id ps4dsmtp_devs[] = {
+ { HID_BVP(BUS_USB, USB_VENDOR_SONY, 0x9cc),
+ HID_TLC(HUP_DIGITIZERS, HUD_TOUCHPAD) },
+};
+
+static int
+ps4dshock_hat_switch_cb(HIDMAP_CB_ARGS)
+{
+ static const struct { int32_t x; int32_t y; } hat_switch_map[] = {
+ {0, -1}, {1, -1}, {1, 0}, {1, 1}, {0, 1}, {-1, 1}, {-1, 0},
+ {-1, -1},{0, 0}
+ };
+ struct evdev_dev *evdev = HIDMAP_CB_GET_EVDEV();
+ u_int idx;
+
+ switch (HIDMAP_CB_GET_STATE()) {
+ case HIDMAP_CB_IS_ATTACHING:
+ evdev_support_event(evdev, EV_ABS);
+ evdev_support_abs(evdev, ABS_HAT0X, -1, 1, 0, 0, 0);
+ evdev_support_abs(evdev, ABS_HAT0Y, -1, 1, 0, 0, 0);
+ break;
+
+ case HIDMAP_CB_IS_RUNNING:
+ idx = MIN(nitems(hat_switch_map) - 1, (u_int)ctx.data);
+ evdev_push_abs(evdev, ABS_HAT0X, hat_switch_map[idx].x);
+ evdev_push_abs(evdev, ABS_HAT0Y, hat_switch_map[idx].y);
+ }
+
+ return (0);
+}
+
+static int
+ps4dshock_final_cb(HIDMAP_CB_ARGS)
+{
+ struct evdev_dev *evdev = HIDMAP_CB_GET_EVDEV();
+
+ if (HIDMAP_CB_GET_STATE() == HIDMAP_CB_IS_ATTACHING)
+ evdev_support_prop(evdev, INPUT_PROP_DIRECT);
+
+ /* Do not execute callback at interrupt handler and detach */
+ return (ENOSYS);
+}
+
+static int
+ps4dsacc_data_cb(HIDMAP_CB_ARGS)
+{
+ struct evdev_dev *evdev = HIDMAP_CB_GET_EVDEV();
+ struct ps4dsacc_softc *sc = HIDMAP_CB_GET_SOFTC();
+ struct ps4ds_calib_data *calib;
+ u_int i;
+
+ switch (HIDMAP_CB_GET_STATE()) {
+ case HIDMAP_CB_IS_ATTACHING:
+ for (i = 0; i < nitems(sc->calib_data); i++) {
+ if (sc->calib_data[i].usage == ctx.hi->usage) {
+ evdev_support_abs(evdev,
+ sc->calib_data[i].code,
+ -sc->calib_data[i].range,
+ sc->calib_data[i].range, 16, 0,
+ sc->calib_data[i].res);
+ HIDMAP_CB_UDATA = &sc->calib_data[i];
+ break;
+ }
+ }
+ break;
+
+ case HIDMAP_CB_IS_RUNNING:
+ calib = HIDMAP_CB_UDATA;
+ evdev_push_abs(evdev, calib->code,
+ ((int64_t)ctx.data - calib->bias) * calib->sens_numer /
+ calib->sens_denom);
+ break;
+ }
+
+ return (0);
+}
+
+static int
+ps4dsacc_tstamp_cb(HIDMAP_CB_ARGS)
+{
+ struct evdev_dev *evdev = HIDMAP_CB_GET_EVDEV();
+ struct ps4dsacc_softc *sc = HIDMAP_CB_GET_SOFTC();
+ uint16_t tstamp;
+
+ switch (HIDMAP_CB_GET_STATE()) {
+ case HIDMAP_CB_IS_ATTACHING:
+ evdev_support_event(evdev, EV_MSC);
+ evdev_support_msc(evdev, MSC_TIMESTAMP);
+ break;
+
+ case HIDMAP_CB_IS_RUNNING:
+ /* Convert timestamp (in 5.33us unit) to timestamp_us */
+ tstamp = (uint16_t)ctx.data;
+ sc->ev_tstamp += (uint16_t)(tstamp - sc->hw_tstamp) * 16 / 3;
+ sc->hw_tstamp = tstamp;
+ evdev_push_msc(evdev, MSC_TIMESTAMP, sc->ev_tstamp);
+ break;
+ }
+
+ return (0);
+}
+
+static int
+ps4dsacc_final_cb(HIDMAP_CB_ARGS)
+{
+ struct evdev_dev *evdev = HIDMAP_CB_GET_EVDEV();
+
+ if (HIDMAP_CB_GET_STATE() == HIDMAP_CB_IS_ATTACHING) {
+ evdev_support_event(evdev, EV_ABS);
+ evdev_support_prop(evdev, INPUT_PROP_ACCELEROMETER);
+ }
+ /* Do not execute callback at interrupt handler and detach */
+ return (ENOSYS);
+}
+
+static int
+ps4dsmtp_npackets_cb(HIDMAP_CB_ARGS)
+{
+ struct ps4dsmtp_softc *sc = HIDMAP_CB_GET_SOFTC();
+
+ if (HIDMAP_CB_GET_STATE() == HIDMAP_CB_IS_RUNNING) {
+ sc->npackets = MIN(PS4DS_MAX_TOUCHPAD_PACKETS,(u_int)ctx.data);
+ /* Reset pointer here as it is first usage in touchpad TLC */
+ sc->data_ptr = sc->data;
+ }
+
+ return (0);
+}
+
+static int
+ps4dsmtp_data_cb(HIDMAP_CB_ARGS)
+{
+ struct ps4dsmtp_softc *sc = HIDMAP_CB_GET_SOFTC();
+
+ if (HIDMAP_CB_GET_STATE() == HIDMAP_CB_IS_RUNNING) {
+ *sc->data_ptr = ctx.data;
+ ++sc->data_ptr;
+ }
+
+ return (0);
+}
+
+static void
+ps4dsmtp_push_packet(struct ps4dsmtp_softc *sc, struct evdev_dev *evdev,
+ int32_t *data)
+{
+ uint8_t hw_tstamp, delta;
+ bool touch;
+
+ evdev_push_abs(evdev, ABS_MT_SLOT, 0);
+ if (data[PS4DS_TIP1] == 0) {
+ evdev_push_abs(evdev, ABS_MT_TRACKING_ID, data[PS4DS_CID1]);
+ evdev_push_abs(evdev, ABS_MT_POSITION_X, data[PS4DS_X1]);
+ evdev_push_abs(evdev, ABS_MT_POSITION_Y, data[PS4DS_Y1]);
+ } else
+ evdev_push_abs(evdev, ABS_MT_TRACKING_ID, -1);
+ evdev_push_abs(evdev, ABS_MT_SLOT, 1);
+ if (data[PS4DS_TIP2] == 0) {
+ evdev_push_abs(evdev, ABS_MT_TRACKING_ID, data[PS4DS_CID2]);
+ evdev_push_abs(evdev, ABS_MT_POSITION_X, data[PS4DS_X2]);
+ evdev_push_abs(evdev, ABS_MT_POSITION_Y, data[PS4DS_Y2]);
+ } else
+ evdev_push_abs(evdev, ABS_MT_TRACKING_ID, -1);
+
+ if (sc->do_tstamps) {
+ /*
+ * Export hardware timestamps in libinput-friendly way.
+ * Make timestamp counter 32-bit, scale up hardware
+ * timestamps to be on per 1usec basis and reset
+ * counter at the start of each touch.
+ */
+ hw_tstamp = (uint8_t)data[PS4DS_TSTAMP];
+ delta = hw_tstamp - sc->hw_tstamp;
+ sc->hw_tstamp = hw_tstamp;
+ touch = data[PS4DS_TIP1] == 0 || data[PS4DS_TIP2] == 0;
+ /* Hardware timestamp counter ticks in 682 usec interval. */
+ if ((touch || sc->touch) && delta != 0) {
+ if (sc->touch)
+ sc->ev_tstamp += delta * 682;
+ evdev_push_msc(evdev, MSC_TIMESTAMP, sc->ev_tstamp);
+ }
+ if (!touch)
+ sc->ev_tstamp = 0;
+ sc->touch = touch;
+ }
+}
+
+static int
+ps4dsmtp_final_cb(HIDMAP_CB_ARGS)
+{
+ struct ps4dsmtp_softc *sc = HIDMAP_CB_GET_SOFTC();
+ struct evdev_dev *evdev = HIDMAP_CB_GET_EVDEV();
+ int32_t *data;
+
+ switch (HIDMAP_CB_GET_STATE()) {
+ case HIDMAP_CB_IS_ATTACHING:
+ if (hid_test_quirk(hid_get_device_info(sc->hm.dev),
+ HQ_MT_TIMESTAMP))
+ sc->do_tstamps = true;
+ /*
+ * Dualshock 4 touchpad TLC contained in fixed report
+ * descriptor is almost compatible with MS precission touchpad
+ * specs and hmt(4) driver. But... for some reasons "Click"
+ * button location was grouped with other GamePad buttons by
+ * touchpad designers so it belongs to GamePad TLC. Fix it with
+ * direct reading of "Click" button value from interrupt frame.
+ */
+ sc->btn_loc = (struct hid_location) { 1, 0, 49 };
+ evdev_support_event(evdev, EV_SYN);
+ evdev_support_event(evdev, EV_KEY);
+ evdev_support_event(evdev, EV_ABS);
+ if (sc->do_tstamps) {
+ evdev_support_event(evdev, EV_MSC);
+ evdev_support_msc(evdev, MSC_TIMESTAMP);
+ }
+ evdev_support_key(evdev, BTN_LEFT);
+ evdev_support_abs(evdev, ABS_MT_SLOT, 0, 1, 0, 0, 0);
+ evdev_support_abs(evdev, ABS_MT_TRACKING_ID, -1, 127, 0, 0, 0);
+ evdev_support_abs(evdev, ABS_MT_POSITION_X, 0, 1920, 0, 0, 30);
+ evdev_support_abs(evdev, ABS_MT_POSITION_Y, 0, 942, 0, 0, 49);
+ evdev_support_prop(evdev, INPUT_PROP_POINTER);
+ evdev_support_prop(evdev, INPUT_PROP_BUTTONPAD);
+ evdev_set_flag(evdev, EVDEV_FLAG_MT_STCOMPAT);
+ break;
+
+ case HIDMAP_CB_IS_RUNNING:
+ /* Only packets with ReportID=1 are accepted */
+ if (HIDMAP_CB_GET_RID() != 1)
+ return (ENOTSUP);
+ evdev_push_key(evdev, BTN_LEFT,
+ HIDMAP_CB_GET_UDATA(&sc->btn_loc));
+ for (data = sc->data;
+ data < sc->data + PS4DS_NTPUSAGES * sc->npackets;
+ data += PS4DS_NTPUSAGES) {
+ ps4dsmtp_push_packet(sc, evdev, data);
+ evdev_sync(evdev);
+ }
+ break;
+ }
+
+ /* Do execute callback at interrupt handler and detach */
+ return (0);
+}
+
+static int
+ps4dshock_write(struct ps4dshock_softc *sc)
+{
+ hid_size_t osize = sc->is_bluetooth ?
+ PS4DS_OUTPUT_REPORT11_SIZE : PS4DS_OUTPUT_REPORT5_SIZE;
+ uint8_t buf[osize];
+ int offset;
+ bool led_on, led_blinks;
+
+ memset(buf, 0, osize);
+ buf[0] = sc->is_bluetooth ? 0x11 : 0x05;
+ offset = sc->is_bluetooth ? 3 : 1;
+ led_on = sc->led_state != PS4DS_LED_OFF;
+ led_blinks = sc->led_state == PS4DS_LED_BLINKING;
+ *(struct ps4ds_out5 *)(buf + offset) = (struct ps4ds_out5) {
+ .features = 0x07, /* blink + LEDs + motor */
+ .rumble_right = sc->rumble_right,
+ .rumble_left = sc->rumble_left,
+ .led_color_r = led_on ? sc->led_color.r : 0,
+ .led_color_g = led_on ? sc->led_color.g : 0,
+ .led_color_b = led_on ? sc->led_color.b : 0,
+ /* convert milliseconds to centiseconds */
+ .led_delay_on = led_blinks ? sc->led_delay_on / 10 : 0,
+ .led_delay_off = led_blinks ? sc->led_delay_off / 10 : 0,
+ };
+
+ /*
+ * The lower 6 bits of buf[1] field of the Bluetooth report
+ * control the interval at which Dualshock 4 reports data:
+ * 0x00 - 1ms
+ * 0x01 - 1ms
+ * 0x02 - 2ms
+ * 0x3E - 62ms
+ * 0x3F - disabled
+ */
+#if 0
+ if (sc->sc->is_bluetooth) {
+ buf[1] = 0xC0 /* HID + CRC */ | sc->bt_poll_interval;
+ /* CRC generation */
+ uint8_t bthdr = 0xA2;
+ uint32_t crc;
+
+ crc = crc32_le(0xFFFFFFFF, &bthdr, 1);
+ crc = ~crc32_le(crc, buf, osize - 4);
+ put_unaligned_le32(crc, &buf[74]);
+ }
+#endif
+
+ return (hid_write(sc->hm.dev, buf, osize));
+}
+
+/* Synaptics Touchpad */
+static int
+ps4dshock_sysctl(SYSCTL_HANDLER_ARGS)
+{
+ struct ps4dshock_softc *sc;
+ int error, arg;
+
+ if (oidp->oid_arg1 == NULL || oidp->oid_arg2 < 0 ||
+ oidp->oid_arg2 > PD4DSHOCK_SYSCTL_LAST)
+ return (EINVAL);
+
+ sc = oidp->oid_arg1;
+ sx_xlock(&sc->lock);
+
+ /* Read the current value. */
+ arg = *(int *)((char *)sc + oidp->oid_arg2);
+ error = sysctl_handle_int(oidp, &arg, 0, req);
+
+ /* Sanity check. */
+ if (error || !req->newptr)
+ goto unlock;
+
+ /*
+ * Check that the new value is in the concerned node's range
+ * of values.
+ */
+ switch (oidp->oid_arg2) {
+ case PD4DSHOCK_SYSCTL_LED_STATE:
+ if (arg < 0 || arg >= PD4DS_LED_CNT)
+ error = EINVAL;
+ break;
+ case PD4DSHOCK_SYSCTL_LED_COLOR_R:
+ case PD4DSHOCK_SYSCTL_LED_COLOR_G:
+ case PD4DSHOCK_SYSCTL_LED_COLOR_B:
+ if (arg < 0 || arg > UINT8_MAX)
+ error = EINVAL;
+ break;
+ case PD4DSHOCK_SYSCTL_LED_DELAY_ON:
+ case PD4DSHOCK_SYSCTL_LED_DELAY_OFF:
+ if (arg < 0 || arg > UINT8_MAX * 10)
+ error = EINVAL;
+ break;
+ default:
+ error = EINVAL;
+ }
+
+ /* Update. */
+ if (error == 0) {
+ *(int *)((char *)sc + oidp->oid_arg2) = arg;
+ ps4dshock_write(sc);
+ }
+unlock:
+ sx_unlock(&sc->lock);
+
+ return (error);
+}
+
+static void
+ps4dshock_identify(driver_t *driver, device_t parent)
+{
+
+ /* Overload PS4 DualShock gamepad rudimentary report descriptor */
+ if (HIDBUS_LOOKUP_ID(parent, ps4dshock_devs) != NULL)
+ hid_set_report_descr(parent, ps4dshock_rdesc,
+ sizeof(ps4dshock_rdesc));
+}
+
+static int
+ps4dshock_probe(device_t dev)
+{
+ struct ps4dshock_softc *sc = device_get_softc(dev);
+
+ hidmap_set_debug_var(&sc->hm, &HID_DEBUG_VAR);
+ return (
+ HIDMAP_PROBE(&sc->hm, dev, ps4dshock_devs, ps4dshock_map, NULL)
+ );
+}
+
+static int
+ps4dsacc_probe(device_t dev)
+{
+ struct ps4dsacc_softc *sc = device_get_softc(dev);
+
+ hidmap_set_debug_var(&sc->hm, &HID_DEBUG_VAR);
+ return (
+ HIDMAP_PROBE(&sc->hm, dev, ps4dsacc_devs, ps4dsacc_map, "Sensors")
+ );
+}
+
+static int
+ps4dshead_probe(device_t dev)
+{
+ struct hidmap *hm = device_get_softc(dev);
+
+ hidmap_set_debug_var(hm, &HID_DEBUG_VAR);
+ return (
+ HIDMAP_PROBE(hm, dev, ps4dshead_devs, ps4dshead_map, "Headset")
+ );
+}
+
+static int
+ps4dsmtp_probe(device_t dev)
+{
+ struct ps4dshock_softc *sc = device_get_softc(dev);
+
+ hidmap_set_debug_var(&sc->hm, &HID_DEBUG_VAR);
+ return (
+ HIDMAP_PROBE(&sc->hm, dev, ps4dsmtp_devs, ps4dsmtp_map, "Touchpad")
+ );
+}
+
+static int
+ps4dshock_attach(device_t dev)
+{
+ struct ps4dshock_softc *sc = device_get_softc(dev);
+ struct sysctl_ctx_list *ctx = device_get_sysctl_ctx(dev);
+ struct sysctl_oid *tree = device_get_sysctl_tree(dev);
+
+ sc->led_state = PS4DS_LED_ON;
+ sc->led_color = ps4ds_leds[device_get_unit(dev) % nitems(ps4ds_leds)];
+ sc->led_delay_on = 500; /* 1 Hz */
+ sc->led_delay_off = 500;
+ ps4dshock_write(sc);
+
+ sx_init(&sc->lock, "ps4dshock");
+
+ SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+ "led_state", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY, sc,
+ PD4DSHOCK_SYSCTL_LED_STATE, ps4dshock_sysctl, "I",
+ "LED state: 0 - off, 1 - on, 2 - blinking.");
+
+ SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+ "led_color_r", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY, sc,
+ PD4DSHOCK_SYSCTL_LED_COLOR_R, ps4dshock_sysctl, "I",
+ "LED color. Red component.");
+
+ SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+ "led_color_g", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY, sc,
+ PD4DSHOCK_SYSCTL_LED_COLOR_G, ps4dshock_sysctl, "I",
+ "LED color. Green component.");
+
+ SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+ "led_color_b", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY, sc,
+ PD4DSHOCK_SYSCTL_LED_COLOR_B, ps4dshock_sysctl, "I",
+ "LED color. Blue component.");
+
+ SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+ "led_delay_on", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY, sc,
+ PD4DSHOCK_SYSCTL_LED_DELAY_ON, ps4dshock_sysctl, "I",
+ "LED blink. On delay, msecs.");
+
+ SYSCTL_ADD_PROC(ctx, SYSCTL_CHILDREN(tree), OID_AUTO,
+ "led_delay_off", CTLTYPE_INT | CTLFLAG_RW | CTLFLAG_ANYBODY, sc,
+ PD4DSHOCK_SYSCTL_LED_DELAY_OFF, ps4dshock_sysctl, "I",
+ "LED blink. Off delay, msecs.");
+
+ return (hidmap_attach(&sc->hm));
+}
+
+static int
+ps4dsacc_attach(device_t dev)
+{
+ struct ps4dsacc_softc *sc = device_get_softc(dev);
+ uint8_t buf[PS4DS_FEATURE_REPORT2_SIZE];
+ int error, speed_2x, range_2g;
+
+ /* Read accelerometers and gyroscopes calibration data */
+ error = hid_get_report(dev, buf, sizeof(buf), NULL,
+ HID_FEATURE_REPORT, 0x02);
+ if (error)
+ DPRINTF("get feature report failed, error=%d "
+ "(ignored)\n", error);
+
+ DPRINTFN(5, "calibration data: %*D\n", (int)sizeof(buf), buf, " ");
+
+ /*
+ * Set gyroscope calibration and normalization parameters.
+ * Data values will be normalized to 1/ PS4DS_GYRO_RES_PER_DEG_S
+ * degree/s.
+ */
+#define HGETW(w) ((int16_t)((w)[0] | (((uint16_t)((w)[1])) << 8)))
+ speed_2x = HGETW(&buf[19]) + HGETW(&buf[21]);
+ sc->calib_data[0].usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_RX);
+ sc->calib_data[0].code = ABS_RX;
+ sc->calib_data[0].range = PS4DS_GYRO_RES_PER_DEG_S * 2048;
+ sc->calib_data[0].res = PS4DS_GYRO_RES_PER_DEG_S;
+ sc->calib_data[0].bias = HGETW(&buf[1]);
+ sc->calib_data[0].sens_numer = speed_2x * PS4DS_GYRO_RES_PER_DEG_S;
+ sc->calib_data[0].sens_denom = HGETW(&buf[7]) - HGETW(&buf[9]);
+ /* BT case */
+ /* sc->calib_data[0].sens_denom = HGETW(&buf[7]) - HGETW(&buf[13]); */
+
+ sc->calib_data[1].usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_RY);
+ sc->calib_data[1].code = ABS_RY;
+ sc->calib_data[1].range = PS4DS_GYRO_RES_PER_DEG_S * 2048;
+ sc->calib_data[1].res = PS4DS_GYRO_RES_PER_DEG_S;
+ sc->calib_data[1].bias = HGETW(&buf[3]);
+ sc->calib_data[1].sens_numer = speed_2x * PS4DS_GYRO_RES_PER_DEG_S;
+ sc->calib_data[1].sens_denom = HGETW(&buf[11]) - HGETW(&buf[13]);
+ /* BT case */
+ /* sc->calib_data[1].sens_denom = HGETW(&buf[9]) - HGETW(&buf[15]); */
+
+ sc->calib_data[2].usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_RZ);
+ sc->calib_data[2].code = ABS_RZ;
+ sc->calib_data[2].range = PS4DS_GYRO_RES_PER_DEG_S * 2048;
+ sc->calib_data[2].res = PS4DS_GYRO_RES_PER_DEG_S;
+ sc->calib_data[2].bias = HGETW(&buf[5]);
+ sc->calib_data[2].sens_numer = speed_2x * PS4DS_GYRO_RES_PER_DEG_S;
+ sc->calib_data[2].sens_denom = HGETW(&buf[15]) - HGETW(&buf[17]);
+ /* BT case */
+ /* sc->calib_data[2].sens_denom = HGETW(&buf[11]) - HGETW(&buf[17]); */
+
+ /*
+ * Set accelerometer calibration and normalization parameters.
+ * Data values will be normalized to 1 / PS4DS_ACC_RES_PER_G G.
+ */
+ range_2g = HGETW(&buf[23]) - HGETW(&buf[25]);
+ sc->calib_data[3].usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X);
+ sc->calib_data[3].code = ABS_X;
+ sc->calib_data[3].range = PS4DS_ACC_RES_PER_G * 4;
+ sc->calib_data[3].res = PS4DS_ACC_RES_PER_G;
+ sc->calib_data[3].bias = HGETW(&buf[23]) - range_2g / 2;
+ sc->calib_data[3].sens_numer = 2 * PS4DS_ACC_RES_PER_G;
+ sc->calib_data[3].sens_denom = range_2g;
+
+ range_2g = HGETW(&buf[27]) - HGETW(&buf[29]);
+ sc->calib_data[4].usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y);
+ sc->calib_data[4].code = ABS_Y;
+ sc->calib_data[4].range = PS4DS_ACC_RES_PER_G * 4;
+ sc->calib_data[4].res = PS4DS_ACC_RES_PER_G;
+ sc->calib_data[4].bias = HGETW(&buf[27]) - range_2g / 2;
+ sc->calib_data[4].sens_numer = 2 * PS4DS_ACC_RES_PER_G;
+ sc->calib_data[4].sens_denom = range_2g;
+
+ range_2g = HGETW(&buf[31]) - HGETW(&buf[33]);
+ sc->calib_data[5].usage = HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Z);
+ sc->calib_data[5].code = ABS_Z;
+ sc->calib_data[5].range = PS4DS_ACC_RES_PER_G * 4;
+ sc->calib_data[5].res = PS4DS_ACC_RES_PER_G;
+ sc->calib_data[5].bias = HGETW(&buf[31]) - range_2g / 2;
+ sc->calib_data[5].sens_numer = 2 * PS4DS_ACC_RES_PER_G;
+ sc->calib_data[5].sens_denom = range_2g;
+
+ return (hidmap_attach(&sc->hm));
+}
+
+static int
+ps4dshead_attach(device_t dev)
+{
+ return (hidmap_attach(device_get_softc(dev)));
+}
+
+static int
+ps4dsmtp_attach(device_t dev)
+{
+ struct ps4dsmtp_softc *sc = device_get_softc(dev);
+
+ return (hidmap_attach(&sc->hm));
+}
+
+static int
+ps4dshock_detach(device_t dev)
+{
+ struct ps4dshock_softc *sc = device_get_softc(dev);
+
+ hidmap_detach(&sc->hm);
+ sc->led_state = PS4DS_LED_OFF;
+ ps4dshock_write(sc);
+ sx_destroy(&sc->lock);
+
+ return (0);
+}
+
+static int
+ps4dsacc_detach(device_t dev)
+{
+ struct ps4dsacc_softc *sc = device_get_softc(dev);
+
+ return (hidmap_detach(&sc->hm));
+}
+
+static int
+ps4dshead_detach(device_t dev)
+{
+ return (hidmap_detach(device_get_softc(dev)));
+}
+
+static int
+ps4dsmtp_detach(device_t dev)
+{
+ struct ps4dsmtp_softc *sc = device_get_softc(dev);
+
+ return (hidmap_detach(&sc->hm));
+}
+
+static devclass_t ps4dshock_devclass;
+static devclass_t ps4dsacc_devclass;
+static devclass_t ps4dshead_devclass;
+static devclass_t ps4dsmtp_devclass;
+
+static device_method_t ps4dshock_methods[] = {
+ DEVMETHOD(device_identify, ps4dshock_identify),
+ DEVMETHOD(device_probe, ps4dshock_probe),
+ DEVMETHOD(device_attach, ps4dshock_attach),
+ DEVMETHOD(device_detach, ps4dshock_detach),
+
+ DEVMETHOD_END
+};
+static device_method_t ps4dsacc_methods[] = {
+ DEVMETHOD(device_probe, ps4dsacc_probe),
+ DEVMETHOD(device_attach, ps4dsacc_attach),
+ DEVMETHOD(device_detach, ps4dsacc_detach),
+
+ DEVMETHOD_END
+};
+static device_method_t ps4dshead_methods[] = {
+ DEVMETHOD(device_probe, ps4dshead_probe),
+ DEVMETHOD(device_attach, ps4dshead_attach),
+ DEVMETHOD(device_detach, ps4dshead_detach),
+
+ DEVMETHOD_END
+};
+static device_method_t ps4dsmtp_methods[] = {
+ DEVMETHOD(device_probe, ps4dsmtp_probe),
+ DEVMETHOD(device_attach, ps4dsmtp_attach),
+ DEVMETHOD(device_detach, ps4dsmtp_detach),
+
+ DEVMETHOD_END
+};
+
+DEFINE_CLASS_0(ps4dsacc, ps4dsacc_driver, ps4dsacc_methods,
+ sizeof(struct ps4dsacc_softc));
+DRIVER_MODULE(ps4dsacc, hidbus, ps4dsacc_driver, ps4dsacc_devclass, NULL, 0);
+DEFINE_CLASS_0(ps4dshead, ps4dshead_driver, ps4dshead_methods,
+ sizeof(struct hidmap));
+DRIVER_MODULE(ps4dshead, hidbus, ps4dshead_driver, ps4dshead_devclass, NULL, 0);
+DEFINE_CLASS_0(ps4dsmtp, ps4dsmtp_driver, ps4dsmtp_methods,
+ sizeof(struct ps4dsmtp_softc));
+DRIVER_MODULE(ps4dsmtp, hidbus, ps4dsmtp_driver, ps4dsmtp_devclass, NULL, 0);
+DEFINE_CLASS_0(ps4dshock, ps4dshock_driver, ps4dshock_methods,
+ sizeof(struct ps4dshock_softc));
+DRIVER_MODULE(ps4dshock, hidbus, ps4dshock_driver, ps4dshock_devclass, NULL, 0);
+
+MODULE_DEPEND(ps4dshock, hid, 1, 1, 1);
+MODULE_DEPEND(ps4dshock, hidbus, 1, 1, 1);
+MODULE_DEPEND(ps4dshock, hidmap, 1, 1, 1);
+MODULE_DEPEND(ps4dshock, evdev, 1, 1, 1);
+MODULE_VERSION(ps4dshock, 1);
+HID_PNP_INFO(ps4dshock_devs);
diff --git a/sys/dev/hid/xb360gp.c b/sys/dev/hid/xb360gp.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/hid/xb360gp.c
@@ -0,0 +1,183 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-FreeBSD
+ *
+ * Copyright (c) 2020 Vladimir Kondratyev <wulf@FreeBSD.org>
+ * Copyright (c) 2020 Greg V <greg@unrelenting.technology>
+ *
+ * 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 <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * XBox 360 gamepad driver thanks to the custom descriptor in usbhid.
+ *
+ * Tested on: SVEN GC-5070 in both XInput (XBox 360) and DirectInput modes
+ */
+
+#include <sys/param.h>
+#include <sys/bus.h>
+#include <sys/kernel.h>
+#include <sys/module.h>
+#include <sys/sysctl.h>
+
+#include <dev/evdev/input.h>
+#include <dev/evdev/evdev.h>
+
+#include <dev/hid/hgame.h>
+#include <dev/hid/hid.h>
+#include <dev/hid/hidbus.h>
+#include <dev/hid/hidmap.h>
+#include <dev/hid/hidquirk.h>
+#include <dev/hid/hidrdesc.h>
+
+#include <dev/usb/usb.h>
+#include <dev/usb/usbdi.h>
+
+static const uint8_t xb360gp_rdesc[] = {HID_XB360GP_REPORT_DESCR()};
+
+#define XB360GP_MAP_BUT(number, code) \
+ { HIDMAP_KEY(HUP_BUTTON, number, code) }
+#define XB360GP_MAP_ABS(usage, code) \
+ { HIDMAP_ABS(HUP_GENERIC_DESKTOP, HUG_##usage, code) }
+#define XB360GP_MAP_ABS_FLT(usage, code) \
+ { HIDMAP_ABS(HUP_GENERIC_DESKTOP, HUG_##usage, code), \
+ .fuzz = 16, .flat = 128 }
+#define XB360GP_MAP_ABS_INV(usage, code) \
+ { HIDMAP_ABS(HUP_GENERIC_DESKTOP, HUG_##usage, code), \
+ .fuzz = 16, .flat = 128, .invert_value = true }
+#define XB360GP_MAP_CRG(usage_from, usage_to, callback) \
+ { HIDMAP_ANY_CB_RANGE(HUP_GENERIC_DESKTOP, \
+ HUG_##usage_from, HUG_##usage_to, callback) }
+#define XB360GP_FINALCB(cb) \
+ { HIDMAP_FINAL_CB(&cb) }
+
+/* Customized to match usbhid's XBox 360 descriptor */
+static const struct hidmap_item xb360gp_map[] = {
+ XB360GP_MAP_BUT(1, BTN_SOUTH),
+ XB360GP_MAP_BUT(2, BTN_EAST),
+ XB360GP_MAP_BUT(3, BTN_WEST),
+ XB360GP_MAP_BUT(4, BTN_NORTH),
+ XB360GP_MAP_BUT(5, BTN_TL),
+ XB360GP_MAP_BUT(6, BTN_TR),
+ XB360GP_MAP_BUT(7, BTN_SELECT),
+ XB360GP_MAP_BUT(8, BTN_START),
+ XB360GP_MAP_BUT(9, BTN_THUMBL),
+ XB360GP_MAP_BUT(10, BTN_THUMBR),
+ XB360GP_MAP_BUT(11, BTN_MODE),
+ XB360GP_MAP_CRG(D_PAD_UP, D_PAD_LEFT, hgame_dpad_cb),
+ XB360GP_MAP_ABS_FLT(X, ABS_X),
+ XB360GP_MAP_ABS_INV(Y, ABS_Y),
+ XB360GP_MAP_ABS(Z, ABS_Z),
+ XB360GP_MAP_ABS_FLT(RX, ABS_RX),
+ XB360GP_MAP_ABS_INV(RY, ABS_RY),
+ XB360GP_MAP_ABS(RZ, ABS_RZ),
+ XB360GP_FINALCB( hgame_final_cb),
+};
+
+static const STRUCT_USB_HOST_ID xb360gp_devs[] = {
+ /* the Xbox 360 gamepad doesn't use the HID class */
+ {USB_IFACE_CLASS(UICLASS_VENDOR),
+ USB_IFACE_SUBCLASS(UISUBCLASS_XBOX360_CONTROLLER),
+ USB_IFACE_PROTOCOL(UIPROTO_XBOX360_GAMEPAD),},
+};
+
+static void
+xb360gp_identify(driver_t *driver, device_t parent)
+{
+ const struct hid_device_info *hw = hid_get_device_info(parent);
+
+ /* the Xbox 360 gamepad has no report descriptor */
+ if (hid_test_quirk(hw, HQ_IS_XBOX360GP))
+ hid_set_report_descr(parent, xb360gp_rdesc,
+ sizeof(xb360gp_rdesc));
+}
+
+static int
+xb360gp_probe(device_t dev)
+{
+ struct hgame_softc *sc = device_get_softc(dev);
+ const struct hid_device_info *hw = hid_get_device_info(dev);
+ int error;
+
+ if (!hid_test_quirk(hw, HQ_IS_XBOX360GP))
+ return (ENXIO);
+
+ hidmap_set_dev(&sc->hm, dev);
+
+ error = HIDMAP_ADD_MAP(&sc->hm, xb360gp_map, NULL);
+ if (error != 0)
+ return (error);
+
+ device_set_desc(dev, "XBox 360 Gamepad");
+
+ return (BUS_PROBE_DEFAULT);
+}
+
+static int
+xb360gp_attach(device_t dev)
+{
+ struct hgame_softc *sc = device_get_softc(dev);
+ int error;
+
+ /*
+ * Turn off the four LEDs on the gamepad which
+ * are blinking by default:
+ */
+ static const uint8_t reportbuf[3] = {1, 3, 0};
+ error = hid_set_report(dev, reportbuf, sizeof(reportbuf),
+ HID_OUTPUT_REPORT, 0);
+ if (error)
+ device_printf(dev, "set output report failed, error=%d "
+ "(ignored)\n", error);
+
+ return (hidmap_attach(&sc->hm));
+}
+
+static int
+xb360gp_detach(device_t dev)
+{
+ struct hgame_softc *sc = device_get_softc(dev);
+
+ return (hidmap_detach(&sc->hm));
+}
+
+static devclass_t xb360gp_devclass;
+static device_method_t xb360gp_methods[] = {
+ DEVMETHOD(device_identify, xb360gp_identify),
+ DEVMETHOD(device_probe, xb360gp_probe),
+ DEVMETHOD(device_attach, xb360gp_attach),
+ DEVMETHOD(device_detach, xb360gp_detach),
+ DEVMETHOD_END
+};
+
+DEFINE_CLASS_0(xb360gp, xb360gp_driver, xb360gp_methods,
+ sizeof(struct hgame_softc));
+DRIVER_MODULE(xb360gp, hidbus, xb360gp_driver, xb360gp_devclass, NULL, 0);
+MODULE_DEPEND(xb360gp, hid, 1, 1, 1);
+MODULE_DEPEND(xb360gp, hidbus, 1, 1, 1);
+MODULE_DEPEND(xb360gp, hidmap, 1, 1, 1);
+MODULE_DEPEND(xb360gp, hgame, 1, 1, 1);
+MODULE_DEPEND(xb360gp, evdev, 1, 1, 1);
+MODULE_VERSION(xb360gp, 1);
+USB_PNP_HOST_INFO(xb360gp_devs);
diff --git a/sys/dev/iicbus/iichid.c b/sys/dev/iicbus/iichid.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/iicbus/iichid.c
@@ -0,0 +1,1252 @@
+/*-
+ * Copyright (c) 2018-2019 Marc Priggemeyer <marc.priggemeyer@gmail.com>
+ * Copyright (c) 2019-2020 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.
+ */
+
+/*
+ * I2C HID transport backend.
+ */
+
+#include <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include "opt_hid.h"
+
+#include <sys/param.h>
+#include <sys/bus.h>
+#include <sys/callout.h>
+#include <sys/endian.h>
+#include <sys/kernel.h>
+#include <sys/lock.h>
+#include <sys/malloc.h>
+#include <sys/module.h>
+#include <sys/rman.h>
+#include <sys/sysctl.h>
+#include <sys/systm.h>
+#include <sys/taskqueue.h>
+
+#include <machine/resource.h>
+
+#include <contrib/dev/acpica/include/acpi.h>
+#include <contrib/dev/acpica/include/accommon.h>
+#include <dev/acpica/acpivar.h>
+
+#include <dev/evdev/input.h>
+
+#include <dev/hid/hid.h>
+#include <dev/hid/hidquirk.h>
+
+#include <dev/iicbus/iic.h>
+#include <dev/iicbus/iicbus.h>
+#include <dev/iicbus/iiconf.h>
+
+#include "hid_if.h"
+
+#ifdef IICHID_DEBUG
+static int iichid_debug = 1;
+
+static SYSCTL_NODE(_hw, OID_AUTO, iichid, CTLFLAG_RW, 0, "I2C HID");
+SYSCTL_INT(_hw_iichid, OID_AUTO, debug, CTLFLAG_RWTUN,
+ &iichid_debug, 1, "Debug level");
+
+#define DPRINTFN(sc, n, ...) do { \
+ if (iichid_debug >= (n)) \
+ device_printf((sc)->dev, __VA_ARGS__); \
+} while (0)
+#define DPRINTF(sc, ...) DPRINTFN((sc), 1, __VA_ARGS__)
+#else
+#define DPRINTFN(...)
+#define DPRINTF(...)
+#endif
+
+typedef hid_size_t iichid_size_t;
+#define IICHID_SIZE_MAX (UINT16_MAX - 2)
+
+/* 7.2 */
+enum {
+ I2C_HID_CMD_DESCR = 0x0,
+ I2C_HID_CMD_RESET = 0x1,
+ I2C_HID_CMD_GET_REPORT = 0x2,
+ I2C_HID_CMD_SET_REPORT = 0x3,
+ I2C_HID_CMD_GET_IDLE = 0x4,
+ I2C_HID_CMD_SET_IDLE = 0x5,
+ I2C_HID_CMD_GET_PROTO = 0x6,
+ I2C_HID_CMD_SET_PROTO = 0x7,
+ I2C_HID_CMD_SET_POWER = 0x8,
+};
+
+#define I2C_HID_POWER_ON 0x0
+#define I2C_HID_POWER_OFF 0x1
+
+/*
+ * Since interrupt resource acquisition is not always possible (in case of GPIO
+ * interrupts) iichid now supports a sampling_mode.
+ * Set dev.iichid.<unit>.sampling_rate_slow to a value greater then 0
+ * to activate sampling. A value of 0 is possible but will not reset the
+ * callout and, thereby, disable further report requests. Do not set the
+ * sampling_rate_fast value too high as it may result in periodical lags of
+ * cursor motion.
+ */
+#define IICHID_SAMPLING_RATE_FAST 60
+#define IICHID_SAMPLING_RATE_SLOW 10
+#define IICHID_SAMPLING_HYSTERESIS 1
+
+/* 5.1.1 - HID Descriptor Format */
+struct i2c_hid_desc {
+ uint16_t wHIDDescLength;
+ uint16_t bcdVersion;
+ uint16_t wReportDescLength;
+ uint16_t wReportDescRegister;
+ uint16_t wInputRegister;
+ uint16_t wMaxInputLength;
+ uint16_t wOutputRegister;
+ uint16_t wMaxOutputLength;
+ uint16_t wCommandRegister;
+ uint16_t wDataRegister;
+ uint16_t wVendorID;
+ uint16_t wProductID;
+ uint16_t wVersionID;
+ uint32_t reserved;
+} __packed;
+
+static char *iichid_ids[] = {
+ "PNP0C50",
+ "ACPI0C50",
+ NULL
+};
+
+enum iichid_powerstate_how {
+ IICHID_PS_NULL,
+ IICHID_PS_ON,
+ IICHID_PS_OFF,
+};
+
+/*
+ * Locking: no internal locks are used. To serialize access to shared members,
+ * external iicbus lock should be taken. That allows to make locking greatly
+ * simple at the cost of running front interrupt handlers with locked bus.
+ */
+struct iichid_softc {
+ device_t dev;
+
+ bool probe_done;
+ int probe_result;
+
+ struct hid_device_info hw;
+ uint16_t addr; /* Shifted left by 1 */
+ struct i2c_hid_desc desc;
+
+ hid_intr_t *intr_handler;
+ void *intr_ctx;
+ uint8_t *intr_buf;
+ iichid_size_t intr_bufsize;
+
+ int irq_rid;
+ struct resource *irq_res;
+ void *irq_cookie;
+
+#ifdef IICHID_SAMPLING
+ int sampling_rate_slow; /* iicbus lock */
+ int sampling_rate_fast;
+ int sampling_hysteresis;
+ int missing_samples; /* iicbus lock */
+ struct timeout_task periodic_task; /* iicbus lock */
+ bool callout_setup; /* iicbus lock */
+ struct taskqueue *taskqueue;
+ struct task event_task;
+#endif
+
+ bool open; /* iicbus lock */
+ bool suspend; /* iicbus lock */
+ bool power_on; /* iicbus lock */
+};
+
+static device_probe_t iichid_probe;
+static device_attach_t iichid_attach;
+static device_detach_t iichid_detach;
+static device_resume_t iichid_resume;
+static device_suspend_t iichid_suspend;
+
+#ifdef IICHID_SAMPLING
+static int iichid_setup_callout(struct iichid_softc *);
+static int iichid_reset_callout(struct iichid_softc *);
+static void iichid_teardown_callout(struct iichid_softc *);
+#endif
+
+static __inline bool
+acpi_is_iichid(ACPI_HANDLE handle)
+{
+ char **ids;
+ UINT32 sta;
+
+ for (ids = iichid_ids; *ids != NULL; ids++) {
+ if (acpi_MatchHid(handle, *ids))
+ break;
+ }
+ if (*ids == NULL)
+ return (false);
+
+ /*
+ * If no _STA method or if it failed, then assume that
+ * the device is present.
+ */
+ if (ACPI_FAILURE(acpi_GetInteger(handle, "_STA", &sta)) ||
+ ACPI_DEVICE_PRESENT(sta))
+ return (true);
+
+ return (false);
+}
+
+static ACPI_STATUS
+iichid_get_config_reg(ACPI_HANDLE handle, uint16_t *config_reg)
+{
+ ACPI_OBJECT *result;
+ ACPI_BUFFER acpi_buf;
+ ACPI_STATUS status;
+
+ /*
+ * function (_DSM) to be evaluated to retrieve the address of
+ * the configuration register of the HID device.
+ */
+ /* 3cdff6f7-4267-4555-ad05-b30a3d8938de */
+ static uint8_t dsm_guid[ACPI_UUID_LENGTH] = {
+ 0xF7, 0xF6, 0xDF, 0x3C, 0x67, 0x42, 0x55, 0x45,
+ 0xAD, 0x05, 0xB3, 0x0A, 0x3D, 0x89, 0x38, 0xDE,
+ };
+
+ status = acpi_EvaluateDSMTyped(handle, dsm_guid, 1, 1, NULL, &acpi_buf,
+ ACPI_TYPE_INTEGER);
+ if (ACPI_FAILURE(status)) {
+ printf("%s: error evaluating _DSM\n", __func__);
+ return (status);
+ }
+ result = (ACPI_OBJECT *) acpi_buf.Pointer;
+ *config_reg = result->Integer.Value & 0xFFFF;
+
+ AcpiOsFree(result);
+ return (status);
+}
+
+static int
+iichid_cmd_read(struct iichid_softc* sc, void *buf, iichid_size_t maxlen,
+ iichid_size_t *actual_len)
+{
+ /*
+ * 6.1.3 - Retrieval of Input Reports
+ * DEVICE returns the length (2 Bytes) and the entire Input Report.
+ */
+ uint8_t actbuf[2] = { 0, 0 };
+ /* Read actual input report length. */
+ struct iic_msg msgs[] = {
+ { sc->addr, IIC_M_RD | IIC_M_NOSTOP, sizeof(actbuf), actbuf },
+ };
+ uint16_t actlen;
+ int error;
+
+ error = iicbus_transfer(sc->dev, msgs, nitems(msgs));
+ if (error != 0)
+ return (error);
+
+ actlen = actbuf[0] | actbuf[1] << 8;
+ if (actlen <= 2 || actlen == 0xFFFF || maxlen == 0) {
+ /* Read and discard 1 byte to send I2C STOP condition. */
+ msgs[0] = (struct iic_msg)
+ { sc->addr, IIC_M_RD | IIC_M_NOSTART, 1, actbuf };
+ actlen = 0;
+ } else {
+ actlen -= 2;
+ if (actlen > maxlen) {
+ DPRINTF(sc, "input report too big. requested=%d "
+ "received=%d\n", maxlen, actlen);
+ actlen = maxlen;
+ }
+ /* Read input report itself. */
+ msgs[0] = (struct iic_msg)
+ { sc->addr, IIC_M_RD | IIC_M_NOSTART, actlen, buf };
+ }
+
+ error = iicbus_transfer(sc->dev, msgs, 1);
+ if (error == 0 && actual_len != NULL)
+ *actual_len = actlen;
+
+ DPRINTFN(sc, 5,
+ "%*D - %*D\n", 2, actbuf, " ", msgs[0].len, msgs[0].buf, " ");
+
+ return (error);
+}
+
+static int
+iichid_cmd_write(struct iichid_softc *sc, const void *buf, iichid_size_t len)
+{
+ /* 6.2.3 - Sending Output Reports. */
+ uint8_t *cmdreg = (uint8_t *)&sc->desc.wOutputRegister;
+ uint16_t replen = 2 + len;
+ uint8_t cmd[4] = { cmdreg[0], cmdreg[1], replen & 0xFF, replen >> 8 };
+ struct iic_msg msgs[] = {
+ {sc->addr, IIC_M_WR | IIC_M_NOSTOP, sizeof(cmd), cmd},
+ {sc->addr, IIC_M_WR | IIC_M_NOSTART, len, __DECONST(void *, buf)},
+ };
+
+ if (le16toh(sc->desc.wMaxOutputLength) == 0)
+ return (IIC_ENOTSUPP);
+ if (len < 2)
+ return (IIC_ENOTSUPP);
+
+ DPRINTF(sc, "HID command I2C_HID_CMD_WRITE (len %d): "
+ "%*D\n", len, len, buf, " ");
+
+ return (iicbus_transfer(sc->dev, msgs, nitems(msgs)));
+}
+
+static int
+iichid_cmd_get_hid_desc(struct iichid_softc *sc, uint16_t config_reg,
+ struct i2c_hid_desc *hid_desc)
+{
+ /*
+ * 5.2.2 - HID Descriptor Retrieval
+ * register is passed from the controller.
+ */
+ uint16_t cmd = htole16(config_reg);
+ struct iic_msg msgs[] = {
+ { sc->addr, IIC_M_WR | IIC_M_NOSTOP, 2, (uint8_t *)&cmd },
+ { sc->addr, IIC_M_RD, sizeof(*hid_desc), (uint8_t *)hid_desc },
+ };
+ int error;
+
+ DPRINTF(sc, "HID command I2C_HID_CMD_DESCR at 0x%x\n", config_reg);
+
+ error = iicbus_transfer(sc->dev, msgs, nitems(msgs));
+ if (error != 0)
+ return (error);
+
+ DPRINTF(sc, "HID descriptor: %*D\n",
+ (int)sizeof(struct i2c_hid_desc), hid_desc, " ");
+
+ return (0);
+}
+
+static int
+iichid_set_power(struct iichid_softc *sc, uint8_t param)
+{
+ uint8_t *cmdreg = (uint8_t *)&sc->desc.wCommandRegister;
+ uint8_t cmd[] = { cmdreg[0], cmdreg[1], param, I2C_HID_CMD_SET_POWER };
+ struct iic_msg msgs[] = {
+ { sc->addr, IIC_M_WR, sizeof(cmd), cmd },
+ };
+
+ DPRINTF(sc, "HID command I2C_HID_CMD_SET_POWER(%d)\n", param);
+
+ return (iicbus_transfer(sc->dev, msgs, nitems(msgs)));
+}
+
+static int
+iichid_reset(struct iichid_softc *sc)
+{
+ uint8_t *cmdreg = (uint8_t *)&sc->desc.wCommandRegister;
+ uint8_t cmd[] = { cmdreg[0], cmdreg[1], 0, I2C_HID_CMD_RESET };
+ struct iic_msg msgs[] = {
+ { sc->addr, IIC_M_WR, sizeof(cmd), cmd },
+ };
+
+ DPRINTF(sc, "HID command I2C_HID_CMD_RESET\n");
+
+ return (iicbus_transfer(sc->dev, msgs, nitems(msgs)));
+}
+
+static int
+iichid_cmd_get_report_desc(struct iichid_softc* sc, void *buf,
+ iichid_size_t len)
+{
+ uint16_t cmd = sc->desc.wReportDescRegister;
+ struct iic_msg msgs[] = {
+ { sc->addr, IIC_M_WR | IIC_M_NOSTOP, 2, (uint8_t *)&cmd },
+ { sc->addr, IIC_M_RD, len, buf },
+ };
+ int error;
+
+ DPRINTF(sc, "HID command I2C_HID_REPORT_DESCR at 0x%x with size %d\n",
+ le16toh(cmd), len);
+
+ error = iicbus_transfer(sc->dev, msgs, nitems(msgs));
+ if (error != 0)
+ return (error);
+
+ DPRINTF(sc, "HID report descriptor: %*D\n", len, buf, " ");
+
+ return (0);
+}
+
+static int
+iichid_cmd_get_report(struct iichid_softc* sc, void *buf, iichid_size_t maxlen,
+ iichid_size_t *actual_len, uint8_t type, uint8_t id)
+{
+ /*
+ * 7.2.2.4 - "The protocol is optimized for Report < 15. If a
+ * report ID >= 15 is necessary, then the Report ID in the Low Byte
+ * must be set to 1111 and a Third Byte is appended to the protocol.
+ * This Third Byte contains the entire/actual report ID."
+ */
+ uint8_t *dtareg = (uint8_t *)&sc->desc.wDataRegister;
+ uint8_t *cmdreg = (uint8_t *)&sc->desc.wCommandRegister;
+ uint8_t cmd[] = { /*________|______id>=15_____|______id<15______*/
+ cmdreg[0] ,
+ cmdreg[1] ,
+ (id >= 15 ? 15 | (type << 4): id | (type << 4)),
+ I2C_HID_CMD_GET_REPORT ,
+ (id >= 15 ? id : dtareg[0] ),
+ (id >= 15 ? dtareg[0] : dtareg[1] ),
+ (id >= 15 ? dtareg[1] : 0 ),
+ };
+ int cmdlen = (id >= 15 ? 7 : 6 );
+ uint8_t actbuf[2] = { 0, 0 };
+ uint16_t actlen;
+ int d, error;
+ struct iic_msg msgs[] = {
+ { sc->addr, IIC_M_WR | IIC_M_NOSTOP, cmdlen, cmd },
+ { sc->addr, IIC_M_RD | IIC_M_NOSTOP, 2, actbuf },
+ { sc->addr, IIC_M_RD | IIC_M_NOSTART, maxlen, buf },
+ };
+
+ if (maxlen == 0)
+ return (EINVAL);
+
+ DPRINTF(sc, "HID command I2C_HID_CMD_GET_REPORT %d "
+ "(type %d, len %d)\n", id, type, maxlen);
+
+ /*
+ * 7.2.2.2 - Response will be a 2-byte length value, the report
+ * id (1 byte, if defined in Report Descriptor), and then the report.
+ */
+ error = iicbus_transfer(sc->dev, msgs, nitems(msgs));
+ if (error != 0)
+ return (error);
+
+ actlen = actbuf[0] | actbuf[1] << 8;
+ if (actlen != maxlen + 2)
+ DPRINTF(sc, "response size %d != expected length %d\n",
+ actlen, maxlen + 2);
+
+ if (actlen <= 2 || actlen == 0xFFFF)
+ return (ENOMSG);
+
+ d = id != 0 ? *(uint8_t *)buf : 0;
+ if (d != id) {
+ DPRINTF(sc, "response report id %d != %d\n", d, id);
+ return (EBADMSG);
+ }
+
+ actlen -= 2;
+ if (actlen > maxlen)
+ actlen = maxlen;
+ if (actual_len != NULL)
+ *actual_len = actlen;
+
+ DPRINTF(sc, "response: %*D %*D\n", 2, actbuf, " ", actlen, buf, " ");
+
+ return (0);
+}
+
+static int
+iichid_cmd_set_report(struct iichid_softc* sc, const void *buf,
+ iichid_size_t len, uint8_t type, uint8_t id)
+{
+ /*
+ * 7.2.2.4 - "The protocol is optimized for Report < 15. If a
+ * report ID >= 15 is necessary, then the Report ID in the Low Byte
+ * must be set to 1111 and a Third Byte is appended to the protocol.
+ * This Third Byte contains the entire/actual report ID."
+ */
+ uint8_t *dtareg = (uint8_t *)&sc->desc.wDataRegister;
+ uint8_t *cmdreg = (uint8_t *)&sc->desc.wCommandRegister;
+ uint16_t replen = 2 + len;
+ uint8_t cmd[] = { /*________|______id>=15_____|______id<15______*/
+ cmdreg[0] ,
+ cmdreg[1] ,
+ (id >= 15 ? 15 | (type << 4): id | (type << 4)),
+ I2C_HID_CMD_SET_REPORT ,
+ (id >= 15 ? id : dtareg[0] ),
+ (id >= 15 ? dtareg[0] : dtareg[1] ),
+ (id >= 15 ? dtareg[1] : replen & 0xff ),
+ (id >= 15 ? replen & 0xff : replen >> 8 ),
+ (id >= 15 ? replen >> 8 : 0 ),
+ };
+ int cmdlen = (id >= 15 ? 9 : 8 );
+ struct iic_msg msgs[] = {
+ {sc->addr, IIC_M_WR | IIC_M_NOSTOP, cmdlen, cmd},
+ {sc->addr, IIC_M_WR | IIC_M_NOSTART, len, __DECONST(void *, buf)},
+ };
+
+ DPRINTF(sc, "HID command I2C_HID_CMD_SET_REPORT %d (type %d, len %d): "
+ "%*D\n", id, type, len, len, buf, " ");
+
+ return (iicbus_transfer(sc->dev, msgs, nitems(msgs)));
+}
+
+#ifdef IICHID_SAMPLING
+static void
+iichid_event_task(void *context, int pending)
+{
+ struct iichid_softc *sc;
+ device_t parent;
+ iichid_size_t actual;
+ bool bus_requested;
+ int error;
+
+ sc = context;
+ parent = device_get_parent(sc->dev);
+
+ bus_requested = false;
+ if (iicbus_request_bus(parent, sc->dev, IIC_WAIT) != 0)
+ goto rearm;
+ bus_requested = true;
+
+ if (!sc->power_on)
+ goto out;
+
+ error = iichid_cmd_read(sc, sc->intr_buf, sc->intr_bufsize, &actual);
+ if (error == 0) {
+ if (actual > 0) {
+ sc->intr_handler(sc->intr_ctx, sc->intr_buf, actual);
+ sc->missing_samples = 0;
+ } else
+ ++sc->missing_samples;
+ } else
+ DPRINTF(sc, "read error occured: %d\n", error);
+
+rearm:
+ if (sc->callout_setup && sc->sampling_rate_slow > 0) {
+ if (sc->missing_samples == sc->sampling_hysteresis)
+ sc->intr_handler(sc->intr_ctx, sc->intr_buf, 0);
+ taskqueue_enqueue_timeout(sc->taskqueue, &sc->periodic_task,
+ hz / MAX(sc->missing_samples >= sc->sampling_hysteresis ?
+ sc->sampling_rate_slow : sc->sampling_rate_fast, 1));
+ }
+out:
+ if (bus_requested)
+ iicbus_release_bus(parent, sc->dev);
+}
+#endif /* IICHID_SAMPLING */
+
+static void
+iichid_intr(void *context)
+{
+ struct iichid_softc *sc;
+ device_t parent;
+ iichid_size_t maxlen, actual;
+ int error;
+
+ sc = context;
+ parent = device_get_parent(sc->dev);
+
+ /*
+ * Designware(IG4) driver-specific hack.
+ * Requesting of an I2C bus with IIC_DONTWAIT parameter enables polled
+ * mode in the driver, making possible iicbus_transfer execution from
+ * interrupt handlers and callouts.
+ */
+ if (iicbus_request_bus(parent, sc->dev, IIC_DONTWAIT) != 0)
+ return;
+
+ /*
+ * Reading of input reports of I2C devices residing in SLEEP state is
+ * not allowed and often returns a garbage. If a HOST needs to
+ * communicate with the DEVICE it MUST issue a SET POWER command
+ * (to ON) before any other command. As some hardware requires reads to
+ * acknoledge interrupts we fetch only length header and discard it.
+ */
+ maxlen = sc->power_on ? sc->intr_bufsize : 0;
+ error = iichid_cmd_read(sc, sc->intr_buf, maxlen, &actual);
+ if (error == 0) {
+ if (sc->power_on) {
+ if (actual != 0)
+ sc->intr_handler(sc->intr_ctx, sc->intr_buf,
+ actual);
+ else
+ DPRINTF(sc, "no data received\n");
+ }
+ } else
+ DPRINTF(sc, "read error occured: %d\n", error);
+
+ iicbus_release_bus(parent, sc->dev);
+}
+
+static int
+iichid_set_power_state(struct iichid_softc *sc,
+ enum iichid_powerstate_how how_open,
+ enum iichid_powerstate_how how_suspend)
+{
+ device_t parent;
+ int error;
+ int how_request;
+ bool power_on;
+
+ /*
+ * Request iicbus early as sc->suspend and sc->power_on
+ * are protected by iicbus internal lock.
+ */
+ parent = device_get_parent(sc->dev);
+ /* Allow to interrupt open()/close() handlers by SIGINT */
+ how_request = how_open == IICHID_PS_NULL ? IIC_WAIT : IIC_INTRWAIT;
+ error = iicbus_request_bus(parent, sc->dev, how_request);
+ if (error != 0)
+ return (error);
+
+ switch (how_open) {
+ case IICHID_PS_ON:
+ sc->open = true;
+ break;
+ case IICHID_PS_OFF:
+ sc->open = false;
+ break;
+ case IICHID_PS_NULL:
+ default:
+ break;
+ }
+
+ switch (how_suspend) {
+ case IICHID_PS_ON:
+ sc->suspend = false;
+ break;
+ case IICHID_PS_OFF:
+ sc->suspend = true;
+ break;
+ case IICHID_PS_NULL:
+ default:
+ break;
+ }
+
+ power_on = sc->open & !sc->suspend;
+
+ if (power_on != sc->power_on) {
+ error = iichid_set_power(sc,
+ power_on ? I2C_HID_POWER_ON : I2C_HID_POWER_OFF);
+
+ sc->power_on = power_on;
+#ifdef IICHID_SAMPLING
+ if (sc->sampling_rate_slow >= 0 && sc->intr_handler != NULL) {
+ if (power_on) {
+ iichid_setup_callout(sc);
+ iichid_reset_callout(sc);
+ } else
+ iichid_teardown_callout(sc);
+ }
+#endif
+ }
+
+ iicbus_release_bus(parent, sc->dev);
+
+ return (error);
+}
+
+static int
+iichid_setup_interrupt(struct iichid_softc *sc)
+{
+ sc->irq_cookie = 0;
+
+ int error = bus_setup_intr(sc->dev, sc->irq_res,
+ INTR_TYPE_TTY|INTR_MPSAFE, NULL, iichid_intr, sc, &sc->irq_cookie);
+ if (error != 0)
+ DPRINTF(sc, "Could not setup interrupt handler\n");
+ else
+ DPRINTF(sc, "successfully setup interrupt\n");
+
+ return (error);
+}
+
+static void
+iichid_teardown_interrupt(struct iichid_softc *sc)
+{
+ if (sc->irq_cookie)
+ bus_teardown_intr(sc->dev, sc->irq_res, sc->irq_cookie);
+
+ sc->irq_cookie = 0;
+}
+
+#ifdef IICHID_SAMPLING
+static int
+iichid_setup_callout(struct iichid_softc *sc)
+{
+
+ if (sc->sampling_rate_slow < 0) {
+ DPRINTF(sc, "sampling_rate is below 0, can't setup callout\n");
+ return (EINVAL);
+ }
+
+ sc->callout_setup = true;
+ DPRINTF(sc, "successfully setup callout\n");
+ return (0);
+}
+
+static int
+iichid_reset_callout(struct iichid_softc *sc)
+{
+
+ if (sc->sampling_rate_slow <= 0) {
+ DPRINTF(sc, "sampling_rate is below or equal to 0, "
+ "can't reset callout\n");
+ return (EINVAL);
+ }
+
+ if (!sc->callout_setup)
+ return (EINVAL);
+
+ /* Start with slow sampling. */
+ sc->missing_samples = sc->sampling_hysteresis;
+ taskqueue_enqueue(sc->taskqueue, &sc->event_task);
+
+ return (0);
+}
+
+static void
+iichid_teardown_callout(struct iichid_softc *sc)
+{
+
+ sc->callout_setup = false;
+ taskqueue_cancel_timeout(sc->taskqueue, &sc->periodic_task, NULL);
+ DPRINTF(sc, "tore callout down\n");
+}
+
+static int
+iichid_sysctl_sampling_rate_handler(SYSCTL_HANDLER_ARGS)
+{
+ struct iichid_softc *sc;
+ device_t parent;
+ int error, oldval, value;
+
+ sc = arg1;
+
+ value = sc->sampling_rate_slow;
+ error = sysctl_handle_int(oidp, &value, 0, req);
+
+ if (error != 0 || req->newptr == NULL ||
+ value == sc->sampling_rate_slow)
+ return (error);
+
+ /* Can't switch to interrupt mode if it is not supported. */
+ if (sc->irq_res == NULL && value < 0)
+ return (EINVAL);
+
+ parent = device_get_parent(sc->dev);
+ error = iicbus_request_bus(parent, sc->dev, IIC_WAIT);
+ if (error != 0)
+ return (iic2errno(error));
+
+ oldval = sc->sampling_rate_slow;
+ sc->sampling_rate_slow = value;
+
+ if (oldval < 0 && value >= 0) {
+ iichid_teardown_interrupt(sc);
+ if (sc->power_on)
+ iichid_setup_callout(sc);
+ } else if (oldval >= 0 && value < 0) {
+ if (sc->power_on)
+ iichid_teardown_callout(sc);
+ iichid_setup_interrupt(sc);
+ }
+
+ if (sc->power_on && value > 0)
+ iichid_reset_callout(sc);
+
+ iicbus_release_bus(parent, sc->dev);
+
+ DPRINTF(sc, "new sampling_rate value: %d\n", value);
+
+ return (0);
+}
+#endif /* IICHID_SAMPLING */
+
+static void
+iichid_intr_setup(device_t dev, hid_intr_t intr, void *context,
+ struct hid_rdesc_info *rdesc)
+{
+ struct iichid_softc *sc;
+
+ sc = device_get_softc(dev);
+ /*
+ * Do not rely on wMaxInputLength, as some devices may set it to
+ * a wrong length. Find the longest input report in report descriptor.
+ */
+ rdesc->rdsize = rdesc->isize;
+ /* Write and get/set_report sizes are limited by I2C-HID protocol. */
+ rdesc->grsize = rdesc->srsize = IICHID_SIZE_MAX;
+ rdesc->wrsize = IICHID_SIZE_MAX;
+
+ sc->intr_handler = intr;
+ sc->intr_ctx = context;
+ sc->intr_buf = malloc(rdesc->rdsize, M_DEVBUF, M_WAITOK | M_ZERO);
+ sc->intr_bufsize = rdesc->rdsize;
+#ifdef IICHID_SAMPLING
+ taskqueue_start_threads(&sc->taskqueue, 1, PI_TTY,
+ "%s taskq", device_get_nameunit(sc->dev));
+#endif
+}
+
+static void
+iichid_intr_unsetup(device_t dev)
+{
+ struct iichid_softc *sc;
+
+ sc = device_get_softc(dev);
+#ifdef IICHID_SAMPLING
+ taskqueue_drain_all(sc->taskqueue);
+#endif
+ free(sc->intr_buf, M_DEVBUF);
+}
+
+static int
+iichid_intr_start(device_t dev)
+{
+ struct iichid_softc *sc;
+
+ sc = device_get_softc(dev);
+ DPRINTF(sc, "iichid device open\n");
+ iichid_set_power_state(sc, IICHID_PS_ON, IICHID_PS_NULL);
+
+ return (0);
+}
+
+static int
+iichid_intr_stop(device_t dev)
+{
+ struct iichid_softc *sc;
+
+ sc = device_get_softc(dev);
+ DPRINTF(sc, "iichid device close\n");
+ /*
+ * 8.2 - The HOST determines that there are no active applications
+ * that are currently using the specific HID DEVICE. The HOST
+ * is recommended to issue a HIPO command to the DEVICE to force
+ * the DEVICE in to a lower power state.
+ */
+ iichid_set_power_state(sc, IICHID_PS_OFF, IICHID_PS_NULL);
+
+ return (0);
+}
+
+static void
+iichid_intr_poll(device_t dev)
+{
+ struct iichid_softc *sc;
+ iichid_size_t actual;
+ int error;
+
+ sc = device_get_softc(dev);
+ error = iichid_cmd_read(sc, sc->intr_buf, sc->intr_bufsize, &actual);
+ if (error == 0 && actual != 0)
+ sc->intr_handler(sc->intr_ctx, sc->intr_buf, actual);
+}
+
+/*
+ * HID interface
+ */
+static int
+iichid_get_rdesc(device_t dev, void *buf, hid_size_t len)
+{
+ struct iichid_softc *sc;
+ int error;
+
+ sc = device_get_softc(dev);
+ error = iichid_cmd_get_report_desc(sc, buf, len);
+ if (error)
+ DPRINTF(sc, "failed to fetch report descriptor: %d\n", error);
+
+ return (iic2errno(error));
+}
+
+static int
+iichid_read(device_t dev, void *buf, hid_size_t maxlen, hid_size_t *actlen)
+{
+ struct iichid_softc *sc;
+ device_t parent;
+ int error;
+
+ if (maxlen > IICHID_SIZE_MAX)
+ return (EMSGSIZE);
+ sc = device_get_softc(dev);
+ parent = device_get_parent(sc->dev);
+ error = iicbus_request_bus(parent, sc->dev, IIC_WAIT);
+ if (error == 0) {
+ error = iichid_cmd_read(sc, buf, maxlen, actlen);
+ iicbus_release_bus(parent, sc->dev);
+ }
+ return (iic2errno(error));
+}
+
+static int
+iichid_write(device_t dev, const void *buf, hid_size_t len)
+{
+ struct iichid_softc *sc;
+
+ if (len > IICHID_SIZE_MAX)
+ return (EMSGSIZE);
+ sc = device_get_softc(dev);
+ return (iic2errno(iichid_cmd_write(sc, buf, len)));
+}
+
+static int
+iichid_get_report(device_t dev, void *buf, hid_size_t maxlen,
+ hid_size_t *actlen, uint8_t type, uint8_t id)
+{
+ struct iichid_softc *sc;
+
+ if (maxlen > IICHID_SIZE_MAX)
+ return (EMSGSIZE);
+ sc = device_get_softc(dev);
+ return (iic2errno(
+ iichid_cmd_get_report(sc, buf, maxlen, actlen, type, id)));
+}
+
+static int
+iichid_set_report(device_t dev, const void *buf, hid_size_t len, uint8_t type,
+ uint8_t id)
+{
+ struct iichid_softc *sc;
+
+ if (len > IICHID_SIZE_MAX)
+ return (EMSGSIZE);
+ sc = device_get_softc(dev);
+ return (iic2errno(iichid_cmd_set_report(sc, buf, len, type, id)));
+}
+
+static int
+iichid_set_idle(device_t dev, uint16_t duration, uint8_t id)
+{
+ return (ENOTSUP);
+}
+
+static int
+iichid_set_protocol(device_t dev, uint16_t protocol)
+{
+ return (ENOTSUP);
+}
+
+static int
+iichid_fill_device_info(struct i2c_hid_desc *desc, ACPI_HANDLE handle,
+ struct hid_device_info *hw)
+{
+ ACPI_DEVICE_INFO *device_info;
+
+ hw->idBus = BUS_I2C;
+ hw->idVendor = le16toh(desc->wVendorID);
+ hw->idProduct = le16toh(desc->wProductID);
+ hw->idVersion = le16toh(desc->wVersionID);
+
+ /* get ACPI HID. It is a base part of the device name. */
+ if (ACPI_FAILURE(AcpiGetObjectInfo(handle, &device_info)))
+ return (ENXIO);
+
+ if (device_info->Valid & ACPI_VALID_HID)
+ strlcpy(hw->idPnP, device_info->HardwareId.String,
+ HID_PNP_ID_SIZE);
+ snprintf(hw->name, sizeof(hw->name), "%s:%02lX %04X:%04X",
+ (device_info->Valid & ACPI_VALID_HID) ?
+ device_info->HardwareId.String : "Unknown",
+ (device_info->Valid & ACPI_VALID_UID) ?
+ strtoul(device_info->UniqueId.String, NULL, 10) : 0UL,
+ le16toh(desc->wVendorID), le16toh(desc->wProductID));
+
+ AcpiOsFree(device_info);
+
+ strlcpy(hw->serial, "", sizeof(hw->serial));
+ hw->rdescsize = le16toh(desc->wReportDescLength);
+ if (desc->wOutputRegister == 0 || desc->wMaxOutputLength == 0)
+ hid_add_dynamic_quirk(hw, HQ_NOWRITE);
+
+ return (0);
+}
+
+static int
+iichid_probe(device_t dev)
+{
+ struct iichid_softc *sc;
+ ACPI_HANDLE handle;
+ char buf[80];
+ uint16_t config_reg;
+ int error;
+
+ sc = device_get_softc(dev);
+ sc->dev = dev;
+ if (sc->probe_done)
+ goto done;
+
+ sc->probe_done = true;
+ sc->probe_result = ENXIO;
+
+ if (acpi_disabled("iichid"))
+ return (ENXIO);
+
+ sc->addr = iicbus_get_addr(dev) << 1;
+ if (sc->addr == 0)
+ return (ENXIO);
+
+ handle = acpi_get_handle(dev);
+ if (handle == NULL)
+ return (ENXIO);
+
+ if (!acpi_is_iichid(handle))
+ return (ENXIO);
+
+ if (ACPI_FAILURE(iichid_get_config_reg(handle, &config_reg)))
+ return (ENXIO);
+
+ DPRINTF(sc, " IICbus addr : 0x%02X\n", sc->addr >> 1);
+ DPRINTF(sc, " HID descriptor reg: 0x%02X\n", config_reg);
+
+ error = iichid_cmd_get_hid_desc(sc, config_reg, &sc->desc);
+ if (error) {
+ DPRINTF(sc, "could not retrieve HID descriptor from the "
+ "device: %d\n", error);
+ return (ENXIO);
+ }
+
+ if (le16toh(sc->desc.wHIDDescLength) != 30 ||
+ le16toh(sc->desc.bcdVersion) != 0x100) {
+ DPRINTF(sc, "HID descriptor is broken\n");
+ return (ENXIO);
+ }
+
+ /* Setup hid_device_info so we can figure out quirks for the device. */
+ if (iichid_fill_device_info(&sc->desc, handle, &sc->hw) != 0) {
+ DPRINTF(sc, "error evaluating AcpiGetObjectInfo\n");
+ return (ENXIO);
+ }
+
+ if (hid_test_quirk(&sc->hw, HQ_HID_IGNORE))
+ return (ENXIO);
+
+ sc->probe_result = BUS_PROBE_DEFAULT;
+done:
+ if (sc->probe_result <= BUS_PROBE_SPECIFIC) {
+ snprintf(buf, sizeof(buf), "%s I2C HID device", sc->hw.name);
+ device_set_desc_copy(dev, buf);
+ }
+ return (sc->probe_result);
+}
+
+static int
+iichid_attach(device_t dev)
+{
+ struct iichid_softc *sc;
+ device_t child;
+ int error;
+
+ sc = device_get_softc(dev);
+ error = iichid_set_power(sc, I2C_HID_POWER_ON);
+ if (error) {
+ device_printf(dev, "failed to power on: %d\n", error);
+ return (ENXIO);
+ }
+ /*
+ * Windows driver sleeps for 1ms between the SET_POWER and RESET
+ * commands. So we too as some devices may depend on this.
+ */
+ pause("iichid", (hz + 999) / 1000);
+
+ error = iichid_reset(sc);
+ if (error) {
+ device_printf(dev, "failed to reset hardware: %d\n", error);
+ return (ENXIO);
+ }
+
+ sc->power_on = false;
+#ifdef IICHID_SAMPLING
+ TASK_INIT(&sc->event_task, 0, iichid_event_task, sc);
+ /* taskqueue_create can't fail with M_WAITOK mflag passed. */
+ sc->taskqueue = taskqueue_create("hmt_tq", M_WAITOK | M_ZERO,
+ taskqueue_thread_enqueue, &sc->taskqueue);
+ TIMEOUT_TASK_INIT(sc->taskqueue, &sc->periodic_task, 0,
+ iichid_event_task, sc);
+
+ sc->sampling_rate_slow = -1;
+ sc->sampling_rate_fast = IICHID_SAMPLING_RATE_FAST;
+ sc->sampling_hysteresis = IICHID_SAMPLING_HYSTERESIS;
+#endif
+
+ sc->irq_rid = 0;
+ sc->irq_res = bus_alloc_resource_any(sc->dev, SYS_RES_IRQ,
+ &sc->irq_rid, RF_ACTIVE);
+
+ if (sc->irq_res != NULL) {
+ DPRINTF(sc, "allocated irq at %p and rid %d\n",
+ sc->irq_res, sc->irq_rid);
+ error = iichid_setup_interrupt(sc);
+ }
+
+ if (sc->irq_res == NULL || error != 0) {
+#ifdef IICHID_SAMPLING
+ device_printf(sc->dev,
+ "Interrupt setup failed. Fallback to sampling\n");
+ sc->sampling_rate_slow = IICHID_SAMPLING_RATE_SLOW;
+#else
+ device_printf(sc->dev, "Interrupt setup failed\n");
+ if (sc->irq_res != NULL)
+ bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid,
+ sc->irq_res);
+ error = ENXIO;
+ goto done;
+#endif
+ }
+
+#ifdef IICHID_SAMPLING
+ SYSCTL_ADD_PROC(device_get_sysctl_ctx(sc->dev),
+ SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)),
+ OID_AUTO, "sampling_rate_slow", CTLTYPE_INT | CTLFLAG_RWTUN,
+ sc, 0, iichid_sysctl_sampling_rate_handler, "I",
+ "idle sampling rate in num/second");
+ SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->dev),
+ SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)),
+ OID_AUTO, "sampling_rate_fast", CTLTYPE_INT | CTLFLAG_RWTUN,
+ &sc->sampling_rate_fast, 0,
+ "active sampling rate in num/second");
+ SYSCTL_ADD_INT(device_get_sysctl_ctx(sc->dev),
+ SYSCTL_CHILDREN(device_get_sysctl_tree(sc->dev)),
+ OID_AUTO, "sampling_hysteresis", CTLTYPE_INT | CTLFLAG_RWTUN,
+ &sc->sampling_hysteresis, 0,
+ "number of missing samples before enabling of slow mode");
+ hid_add_dynamic_quirk(&sc->hw, HQ_IICHID_SAMPLING);
+#endif /* IICHID_SAMPLING */
+
+ child = device_add_child(dev, "hidbus", -1);
+ if (child == NULL) {
+ device_printf(sc->dev, "Could not add I2C device\n");
+ iichid_detach(dev);
+ error = ENOMEM;
+ goto done;
+ }
+
+ device_set_ivars(child, &sc->hw);
+ error = bus_generic_attach(dev);
+ if (error) {
+ device_printf(dev, "failed to attach child: error %d\n", error);
+ iichid_detach(dev);
+ }
+done:
+ (void)iichid_set_power(sc, I2C_HID_POWER_OFF);
+ return (error);
+}
+
+static int
+iichid_detach(device_t dev)
+{
+ struct iichid_softc *sc;
+ int error;
+
+ sc = device_get_softc(dev);
+ error = device_delete_children(dev);
+ if (error)
+ return (error);
+ iichid_teardown_interrupt(sc);
+ if (sc->irq_res != NULL)
+ bus_release_resource(dev, SYS_RES_IRQ, sc->irq_rid,
+ sc->irq_res);
+#ifdef IICHID_SAMPLING
+ if (sc->taskqueue != NULL)
+ taskqueue_free(sc->taskqueue);
+ sc->taskqueue = NULL;
+#endif
+ return (0);
+}
+
+static int
+iichid_suspend(device_t dev)
+{
+ struct iichid_softc *sc;
+ int error;
+
+ sc = device_get_softc(dev);
+ DPRINTF(sc, "Suspend called, setting device to power_state 1\n");
+ (void)bus_generic_suspend(dev);
+ /*
+ * 8.2 - The HOST is going into a deep power optimized state and wishes
+ * to put all the devices into a low power state also. The HOST
+ * is recommended to issue a HIPO command to the DEVICE to force
+ * the DEVICE in to a lower power state.
+ */
+ error = iichid_set_power_state(sc, IICHID_PS_NULL, IICHID_PS_OFF);
+ if (error != 0)
+ DPRINTF(sc, "Could not set power_state, error: %d\n", error);
+ else
+ DPRINTF(sc, "Successfully set power_state\n");
+
+ return (0);
+}
+
+static int
+iichid_resume(device_t dev)
+{
+ struct iichid_softc *sc;
+ int error;
+
+ sc = device_get_softc(dev);
+ DPRINTF(sc, "Resume called, setting device to power_state 0\n");
+ error = iichid_set_power_state(sc, IICHID_PS_NULL, IICHID_PS_ON);
+ if (error != 0)
+ DPRINTF(sc, "Could not set power_state, error: %d\n", error);
+ else
+ DPRINTF(sc, "Successfully set power_state\n");
+ (void)bus_generic_resume(dev);
+
+ return (0);
+}
+
+static devclass_t iichid_devclass;
+
+static device_method_t iichid_methods[] = {
+ DEVMETHOD(device_probe, iichid_probe),
+ DEVMETHOD(device_attach, iichid_attach),
+ DEVMETHOD(device_detach, iichid_detach),
+ DEVMETHOD(device_suspend, iichid_suspend),
+ DEVMETHOD(device_resume, iichid_resume),
+
+ DEVMETHOD(hid_intr_setup, iichid_intr_setup),
+ DEVMETHOD(hid_intr_unsetup, iichid_intr_unsetup),
+ DEVMETHOD(hid_intr_start, iichid_intr_start),
+ DEVMETHOD(hid_intr_stop, iichid_intr_stop),
+ DEVMETHOD(hid_intr_poll, iichid_intr_poll),
+
+ /* HID interface */
+ DEVMETHOD(hid_get_rdesc, iichid_get_rdesc),
+ DEVMETHOD(hid_read, iichid_read),
+ DEVMETHOD(hid_write, iichid_write),
+ DEVMETHOD(hid_get_report, iichid_get_report),
+ DEVMETHOD(hid_set_report, iichid_set_report),
+ DEVMETHOD(hid_set_idle, iichid_set_idle),
+ DEVMETHOD(hid_set_protocol, iichid_set_protocol),
+
+ DEVMETHOD_END
+};
+
+static driver_t iichid_driver = {
+ .name = "iichid",
+ .methods = iichid_methods,
+ .size = sizeof(struct iichid_softc),
+};
+
+DRIVER_MODULE(iichid, iicbus, iichid_driver, iichid_devclass, NULL, 0);
+MODULE_DEPEND(iichid, iicbus, IICBUS_MINVER, IICBUS_PREFVER, IICBUS_MAXVER);
+MODULE_DEPEND(iichid, acpi, 1, 1, 1);
+MODULE_DEPEND(iichid, hid, 1, 1, 1);
+MODULE_DEPEND(iichid, hidbus, 1, 1, 1);
+MODULE_VERSION(iichid, 1);
+IICBUS_ACPI_PNP_INFO(iichid_ids);
diff --git a/sys/dev/sound/usb/uaudio.c b/sys/dev/sound/usb/uaudio.c
--- a/sys/dev/sound/usb/uaudio.c
+++ b/sys/dev/sound/usb/uaudio.c
@@ -6210,6 +6210,7 @@
DRIVER_MODULE_ORDERED(uaudio, uhub, uaudio_driver, uaudio_devclass, NULL, 0, SI_ORDER_ANY);
MODULE_DEPEND(uaudio, usb, 1, 1, 1);
MODULE_DEPEND(uaudio, sound, SOUND_MINVER, SOUND_PREFVER, SOUND_MAXVER);
+MODULE_DEPEND(uaudio, hid, 1, 1, 1);
MODULE_VERSION(uaudio, 1);
USB_PNP_HOST_INFO(uaudio_devs);
USB_PNP_HOST_INFO(uaudio_vendor_midi);
diff --git a/sys/dev/usb/input/atp.c b/sys/dev/usb/input/atp.c
--- a/sys/dev/usb/input/atp.c
+++ b/sys/dev/usb/input/atp.c
@@ -2633,6 +2633,7 @@
DRIVER_MODULE(atp, uhub, atp_driver, atp_devclass, NULL, 0);
MODULE_DEPEND(atp, usb, 1, 1, 1);
+MODULE_DEPEND(atp, hid, 1, 1, 1);
MODULE_VERSION(atp, 1);
USB_PNP_HOST_INFO(fg_devs);
USB_PNP_HOST_INFO(wsp_devs);
diff --git a/sys/dev/usb/input/uep.c b/sys/dev/usb/input/uep.c
--- a/sys/dev/usb/input/uep.c
+++ b/sys/dev/usb/input/uep.c
@@ -381,8 +381,8 @@
evdev_support_event(sc->evdev, EV_ABS);
evdev_support_event(sc->evdev, EV_KEY);
evdev_support_key(sc->evdev, BTN_TOUCH);
- evdev_support_abs(sc->evdev, ABS_X, 0, 0, UEP_MAX_X, 0, 0, 0);
- evdev_support_abs(sc->evdev, ABS_Y, 0, 0, UEP_MAX_Y, 0, 0, 0);
+ evdev_support_abs(sc->evdev, ABS_X, 0, UEP_MAX_X, 0, 0, 0);
+ evdev_support_abs(sc->evdev, ABS_Y, 0, UEP_MAX_Y, 0, 0, 0);
error = evdev_register_mtx(sc->evdev, &sc->mtx);
if (error) {
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
@@ -43,6 +43,8 @@
* 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>
@@ -889,7 +891,9 @@
return (0);
}
+#ifndef HIDRAW_MAKE_UHID_ALIAS
static devclass_t uhid_devclass;
+#endif
static device_method_t uhid_methods[] = {
DEVMETHOD(device_probe, uhid_probe),
@@ -900,12 +904,23 @@
};
static driver_t uhid_driver = {
+#ifdef HIDRAW_MAKE_UHID_ALIAS
+ .name = "hidraw",
+#else
.name = "uhid",
+#endif
.methods = uhid_methods,
.size = sizeof(struct uhid_softc),
};
+#ifdef HIDRAW_MAKE_UHID_ALIAS
+DRIVER_MODULE(uhid, uhub, uhid_driver, hidraw_devclass, NULL, 0);
+#else
DRIVER_MODULE(uhid, uhub, uhid_driver, uhid_devclass, NULL, 0);
+#endif
MODULE_DEPEND(uhid, usb, 1, 1, 1);
+MODULE_DEPEND(uhid, hid, 1, 1, 1);
MODULE_VERSION(uhid, 1);
+#ifndef USBHID_ENABLED
USB_PNP_HOST_INFO(uhid_devs);
+#endif
diff --git a/sys/dev/usb/input/ukbd.c b/sys/dev/usb/input/ukbd.c
--- a/sys/dev/usb/input/ukbd.c
+++ b/sys/dev/usb/input/ukbd.c
@@ -2185,8 +2185,11 @@
DRIVER_MODULE(ukbd, uhub, ukbd_driver, ukbd_devclass, ukbd_driver_load, 0);
MODULE_DEPEND(ukbd, usb, 1, 1, 1);
+MODULE_DEPEND(ukbd, hid, 1, 1, 1);
#ifdef EVDEV_SUPPORT
MODULE_DEPEND(ukbd, evdev, 1, 1, 1);
#endif
MODULE_VERSION(ukbd, 1);
+#ifndef USBHID_ENABLED
USB_PNP_HOST_INFO(ukbd_devs);
+#endif
diff --git a/sys/dev/usb/input/ums.c b/sys/dev/usb/input/ums.c
--- a/sys/dev/usb/input/ums.c
+++ b/sys/dev/usb/input/ums.c
@@ -1213,8 +1213,11 @@
DRIVER_MODULE(ums, uhub, ums_driver, ums_devclass, NULL, 0);
MODULE_DEPEND(ums, usb, 1, 1, 1);
+MODULE_DEPEND(ums, hid, 1, 1, 1);
#ifdef EVDEV_SUPPORT
MODULE_DEPEND(ums, evdev, 1, 1, 1);
#endif
MODULE_VERSION(ums, 1);
+#ifndef USBHID_ENABLED
USB_PNP_HOST_INFO(ums_devs);
+#endif
diff --git a/sys/dev/usb/input/usb_rdesc.h b/sys/dev/usb/input/usb_rdesc.h
--- a/sys/dev/usb/input/usb_rdesc.h
+++ b/sys/dev/usb/input/usb_rdesc.h
@@ -1,11 +1,7 @@
/*-
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
*
- * Copyright (c) 2000 Nick Hibma <n_hibma@FreeBSD.org>
- * All rights reserved.
- *
- * Copyright (c) 2005 Ed Schouten <ed@FreeBSD.org>
- * All rights reserved.
+ * Copyright (c) 2020 Vladimir Kondratyev <wulf@FreeBSD.org>
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
@@ -30,277 +26,14 @@
*
* $FreeBSD$
*
- * This file contains replacements for broken HID report descriptors.
+ * This a proxy file for replacements for broken HID report descriptors.
*/
-#define UHID_GRAPHIRE_REPORT_DESCR(...) \
- 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
- 0x09, 0x01, /* USAGE (Digitizer) */\
- 0xa1, 0x01, /* COLLECTION (Application) */\
- 0x85, 0x02, /* REPORT_ID (2) */\
- 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
- 0x09, 0x01, /* USAGE (Digitizer) */\
- 0xa1, 0x00, /* COLLECTION (Physical) */\
- 0x15, 0x00, /* LOGICAL_MINIMUM (0) */\
- 0x25, 0x01, /* LOGICAL_MAXIMUM (1) */\
- 0x09, 0x33, /* USAGE (Touch) */\
- 0x95, 0x01, /* REPORT_COUNT (1) */\
- 0x75, 0x01, /* REPORT_SIZE (1) */\
- 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
- 0x09, 0x44, /* USAGE (Barrel Switch) */\
- 0x95, 0x02, /* REPORT_COUNT (2) */\
- 0x75, 0x01, /* REPORT_SIZE (1) */\
- 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
- 0x09, 0x00, /* USAGE (Undefined) */\
- 0x95, 0x02, /* REPORT_COUNT (2) */\
- 0x75, 0x01, /* REPORT_SIZE (1) */\
- 0x81, 0x03, /* INPUT (Cnst,Var,Abs) */\
- 0x09, 0x3c, /* USAGE (Invert) */\
- 0x95, 0x01, /* REPORT_COUNT (1) */\
- 0x75, 0x01, /* REPORT_SIZE (1) */\
- 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
- 0x09, 0x38, /* USAGE (Transducer Index) */\
- 0x95, 0x01, /* REPORT_COUNT (1) */\
- 0x75, 0x01, /* REPORT_SIZE (1) */\
- 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
- 0x09, 0x32, /* USAGE (In Range) */\
- 0x95, 0x01, /* REPORT_COUNT (1) */\
- 0x75, 0x01, /* REPORT_SIZE (1) */\
- 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
- 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */\
- 0x09, 0x30, /* USAGE (X) */\
- 0x15, 0x00, /* LOGICAL_MINIMUM (0) */\
- 0x26, 0xde, 0x27, /* LOGICAL_MAXIMUM (10206) */\
- 0x95, 0x01, /* REPORT_COUNT (1) */\
- 0x75, 0x10, /* REPORT_SIZE (16) */\
- 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
- 0x09, 0x31, /* USAGE (Y) */\
- 0x26, 0xfe, 0x1c, /* LOGICAL_MAXIMUM (7422) */\
- 0x95, 0x01, /* REPORT_COUNT (1) */\
- 0x75, 0x10, /* REPORT_SIZE (16) */\
- 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
- 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
- 0x09, 0x30, /* USAGE (Tip Pressure) */\
- 0x26, 0xff, 0x01, /* LOGICAL_MAXIMUM (511) */\
- 0x95, 0x01, /* REPORT_COUNT (1) */\
- 0x75, 0x10, /* REPORT_SIZE (16) */\
- 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
- 0xc0, /* END_COLLECTION */\
- 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
- 0x09, 0x00, /* USAGE (Undefined) */\
- 0x85, 0x02, /* REPORT_ID (2) */\
- 0x95, 0x01, /* REPORT_COUNT (1) */\
- 0xb1, 0x02, /* FEATURE (Data,Var,Abs) */\
- 0x09, 0x00, /* USAGE (Undefined) */\
- 0x85, 0x03, /* REPORT_ID (3) */\
- 0x95, 0x01, /* REPORT_COUNT (1) */\
- 0xb1, 0x02, /* FEATURE (Data,Var,Abs) */\
- 0xc0, /* END_COLLECTION */\
-
-#define UHID_GRAPHIRE3_4X5_REPORT_DESCR(...) \
- 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */\
- 0x09, 0x02, /* USAGE (Mouse) */\
- 0xa1, 0x01, /* COLLECTION (Application) */\
- 0x85, 0x01, /* REPORT_ID (1) */\
- 0x09, 0x01, /* USAGE (Pointer) */\
- 0xa1, 0x00, /* COLLECTION (Physical) */\
- 0x05, 0x09, /* USAGE_PAGE (Button) */\
- 0x19, 0x01, /* USAGE_MINIMUM (Button 1) */\
- 0x29, 0x03, /* USAGE_MAXIMUM (Button 3) */\
- 0x15, 0x00, /* LOGICAL_MINIMUM (0) */\
- 0x25, 0x01, /* LOGICAL_MAXIMUM (1) */\
- 0x95, 0x03, /* REPORT_COUNT (3) */\
- 0x75, 0x01, /* REPORT_SIZE (1) */\
- 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
- 0x95, 0x01, /* REPORT_COUNT (1) */\
- 0x75, 0x05, /* REPORT_SIZE (5) */\
- 0x81, 0x01, /* INPUT (Cnst,Ary,Abs) */\
- 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */\
- 0x09, 0x30, /* USAGE (X) */\
- 0x09, 0x31, /* USAGE (Y) */\
- 0x09, 0x38, /* USAGE (Wheel) */\
- 0x15, 0x81, /* LOGICAL_MINIMUM (-127) */\
- 0x25, 0x7f, /* LOGICAL_MAXIMUM (127) */\
- 0x75, 0x08, /* REPORT_SIZE (8) */\
- 0x95, 0x03, /* REPORT_COUNT (3) */\
- 0x81, 0x06, /* INPUT (Data,Var,Rel) */\
- 0xc0, /* END_COLLECTION */\
- 0xc0, /* END_COLLECTION */\
- 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
- 0x09, 0x01, /* USAGE (Pointer) */\
- 0xa1, 0x01, /* COLLECTION (Applicaption) */\
- 0x85, 0x02, /* REPORT_ID (2) */\
- 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
- 0x09, 0x01, /* USAGE (Digitizer) */\
- 0xa1, 0x00, /* COLLECTION (Physical) */\
- 0x09, 0x33, /* USAGE (Touch) */\
- 0x09, 0x44, /* USAGE (Barrel Switch) */\
- 0x09, 0x44, /* USAGE (Barrel Switch) */\
- 0x15, 0x00, /* LOGICAL_MINIMUM (0) */\
- 0x25, 0x01, /* LOGICAL_MAXIMUM (1) */\
- 0x75, 0x01, /* REPORT_SIZE (1) */\
- 0x95, 0x03, /* REPORT_COUNT (3) */\
- 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
- 0x75, 0x01, /* REPORT_SIZE (1) */\
- 0x95, 0x02, /* REPORT_COUNT (2) */\
- 0x81, 0x01, /* INPUT (Cnst,Ary,Abs) */\
- 0x09, 0x3c, /* USAGE (Invert) */\
- 0x09, 0x38, /* USAGE (Transducer Index) */\
- 0x09, 0x32, /* USAGE (In Range) */\
- 0x75, 0x01, /* REPORT_SIZE (1) */\
- 0x95, 0x03, /* REPORT_COUNT (3) */\
- 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
- 0x05, 0x01, /* USAGE_PAGE (Generic Desktop) */\
- 0x09, 0x30, /* USAGE (X) */\
- 0x15, 0x00, /* LOGICAL_MINIMUM (0) */\
- 0x26, 0xde, 0x27, /* LOGICAL_MAXIMUM (10206) */\
- 0x75, 0x10, /* REPORT_SIZE (16) */\
- 0x95, 0x01, /* REPORT_COUNT (1) */\
- 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
- 0x09, 0x31, /* USAGE (Y) */\
- 0x26, 0xfe, 0x1c, /* LOGICAL_MAXIMUM (7422) */\
- 0x75, 0x10, /* REPORT_SIZE (16) */\
- 0x95, 0x01, /* REPORT_COUNT (1) */\
- 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
- 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
- 0x09, 0x30, /* USAGE (Tip Pressure) */\
- 0x26, 0xff, 0x01, /* LOGICAL_MAXIMUM (511) */\
- 0x75, 0x10, /* REPORT_SIZE (16) */\
- 0x95, 0x01, /* REPORT_COUNT (1) */\
- 0x81, 0x02, /* INPUT (Data,Var,Abs) */\
- 0xc0, /* END_COLLECTION */\
- 0x05, 0x0d, /* USAGE_PAGE (Digitizers) */\
- 0x09, 0x00, /* USAGE (Undefined) */\
- 0x85, 0x02, /* REPORT_ID (2) */\
- 0x95, 0x01, /* REPORT_COUNT (1) */\
- 0xb1, 0x02, /* FEATURE (Data,Var,Abs) */\
- 0x09, 0x00, /* USAGE (Undefined) */\
- 0x85, 0x03, /* REPORT_ID (3) */\
- 0x95, 0x01, /* REPORT_COUNT (1) */\
- 0xb1, 0x02, /* FEATURE (Data,Var,Abs) */\
- 0xc0 /* END_COLLECTION */\
-
-/*
- * The descriptor has no output report format, thus preventing you from
- * controlling the LEDs and the built-in rumblers.
- */
-#define UHID_XB360GP_REPORT_DESCR(...) \
- 0x05, 0x01, /* USAGE PAGE (Generic Desktop) */\
- 0x09, 0x05, /* USAGE (Gamepad) */\
- 0xa1, 0x01, /* COLLECTION (Application) */\
- /* Unused */\
- 0x75, 0x08, /* REPORT SIZE (8) */\
- 0x95, 0x01, /* REPORT COUNT (1) */\
- 0x81, 0x01, /* INPUT (Constant) */\
- /* Byte count */\
- 0x75, 0x08, /* REPORT SIZE (8) */\
- 0x95, 0x01, /* REPORT COUNT (1) */\
- 0x05, 0x01, /* USAGE PAGE (Generic Desktop) */\
- 0x09, 0x3b, /* USAGE (Byte Count) */\
- 0x81, 0x01, /* INPUT (Constant) */\
- /* D-Pad */\
- 0x05, 0x01, /* USAGE PAGE (Generic Desktop) */\
- 0x09, 0x01, /* USAGE (Pointer) */\
- 0xa1, 0x00, /* COLLECTION (Physical) */\
- 0x75, 0x01, /* REPORT SIZE (1) */\
- 0x15, 0x00, /* LOGICAL MINIMUM (0) */\
- 0x25, 0x01, /* LOGICAL MAXIMUM (1) */\
- 0x35, 0x00, /* PHYSICAL MINIMUM (0) */\
- 0x45, 0x01, /* PHYSICAL MAXIMUM (1) */\
- 0x95, 0x04, /* REPORT COUNT (4) */\
- 0x05, 0x01, /* USAGE PAGE (Generic Desktop) */\
- 0x09, 0x90, /* USAGE (D-Pad Up) */\
- 0x09, 0x91, /* USAGE (D-Pad Down) */\
- 0x09, 0x93, /* USAGE (D-Pad Left) */\
- 0x09, 0x92, /* USAGE (D-Pad Right) */\
- 0x81, 0x02, /* INPUT (Data, Variable, Absolute) */\
- 0xc0, /* END COLLECTION */\
- /* Buttons 5-11 */\
- 0x75, 0x01, /* REPORT SIZE (1) */\
- 0x15, 0x00, /* LOGICAL MINIMUM (0) */\
- 0x25, 0x01, /* LOGICAL MAXIMUM (1) */\
- 0x35, 0x00, /* PHYSICAL MINIMUM (0) */\
- 0x45, 0x01, /* PHYSICAL MAXIMUM (1) */\
- 0x95, 0x07, /* REPORT COUNT (7) */\
- 0x05, 0x09, /* USAGE PAGE (Button) */\
- 0x09, 0x08, /* USAGE (Button 8) */\
- 0x09, 0x07, /* USAGE (Button 7) */\
- 0x09, 0x09, /* USAGE (Button 9) */\
- 0x09, 0x0a, /* USAGE (Button 10) */\
- 0x09, 0x05, /* USAGE (Button 5) */\
- 0x09, 0x06, /* USAGE (Button 6) */\
- 0x09, 0x0b, /* USAGE (Button 11) */\
- 0x81, 0x02, /* INPUT (Data, Variable, Absolute) */\
- /* Unused */\
- 0x75, 0x01, /* REPORT SIZE (1) */\
- 0x95, 0x01, /* REPORT COUNT (1) */\
- 0x81, 0x01, /* INPUT (Constant) */\
- /* Buttons 1-4 */\
- 0x75, 0x01, /* REPORT SIZE (1) */\
- 0x15, 0x00, /* LOGICAL MINIMUM (0) */\
- 0x25, 0x01, /* LOGICAL MAXIMUM (1) */\
- 0x35, 0x00, /* PHYSICAL MINIMUM (0) */\
- 0x45, 0x01, /* PHYSICAL MAXIMUM (1) */\
- 0x95, 0x04, /* REPORT COUNT (4) */\
- 0x05, 0x09, /* USAGE PAGE (Button) */\
- 0x19, 0x01, /* USAGE MINIMUM (Button 1) */\
- 0x29, 0x04, /* USAGE MAXIMUM (Button 4) */\
- 0x81, 0x02, /* INPUT (Data, Variable, Absolute) */\
- /* Triggers */\
- 0x75, 0x08, /* REPORT SIZE (8) */\
- 0x15, 0x00, /* LOGICAL MINIMUM (0) */\
- 0x26, 0xff, 0x00, /* LOGICAL MAXIMUM (255) */\
- 0x35, 0x00, /* PHYSICAL MINIMUM (0) */\
- 0x46, 0xff, 0x00, /* PHYSICAL MAXIMUM (255) */\
- 0x95, 0x02, /* REPORT SIZE (2) */\
- 0x05, 0x01, /* USAGE PAGE (Generic Desktop) */\
- 0x09, 0x32, /* USAGE (Z) */\
- 0x09, 0x35, /* USAGE (Rz) */\
- 0x81, 0x02, /* INPUT (Data, Variable, Absolute) */\
- /* Sticks */\
- 0x75, 0x10, /* REPORT SIZE (16) */\
- 0x16, 0x00, 0x80, /* LOGICAL MINIMUM (-32768) */\
- 0x26, 0xff, 0x7f, /* LOGICAL MAXIMUM (32767) */\
- 0x36, 0x00, 0x80, /* PHYSICAL MINIMUM (-32768) */\
- 0x46, 0xff, 0x7f, /* PHYSICAL MAXIMUM (32767) */\
- 0x95, 0x04, /* REPORT COUNT (4) */\
- 0x05, 0x01, /* USAGE PAGE (Generic Desktop) */\
- 0x09, 0x30, /* USAGE (X) */\
- 0x09, 0x31, /* USAGE (Y) */\
- 0x09, 0x33, /* USAGE (Rx) */\
- 0x09, 0x34, /* USAGE (Ry) */\
- 0x81, 0x02, /* INPUT (Data, Variable, Absolute) */\
- /* Unused */\
- 0x75, 0x30, /* REPORT SIZE (48) */\
- 0x95, 0x01, /* REPORT COUNT (1) */\
- 0x81, 0x01, /* INPUT (Constant) */\
- 0xc0 /* END COLLECTION */\
+#include <dev/hid/hidrdesc.h>
-/* Fixed report descriptor for Super Nintendo gamepads */
-#define UHID_SNES_REPORT_DESCR(...) \
- 0x05, 0x01, /* Usage Page (Desktop), */\
- 0x09, 0x04, /* Usage (Joystik), */\
- 0xA1, 0x01, /* Collection (Application), */\
- 0xA1, 0x02, /* Collection (Logical), */\
- 0x14, /* Logical Minimum (0), */\
- 0x75, 0x08, /* Report Size (8), */\
- 0x95, 0x03, /* Report Count (3), */\
- 0x81, 0x01, /* Input (Constant), */\
- 0x26, 0xFF, 0x00, /* Logical Maximum (255), */\
- 0x95, 0x02, /* Report Count (2), */\
- 0x09, 0x30, /* Usage (X), */\
- 0x09, 0x31, /* Usage (Y), */\
- 0x81, 0x02, /* Input (Variable), */\
- 0x75, 0x01, /* Report Size (1), */\
- 0x95, 0x04, /* Report Count (4), */\
- 0x81, 0x01, /* Input (Constant), */\
- 0x25, 0x01, /* Logical Maximum (1), */\
- 0x95, 0x0A, /* Report Count (10), */\
- 0x05, 0x09, /* Usage Page (Button), */\
- 0x19, 0x01, /* Usage Minimum (01h), */\
- 0x29, 0x0A, /* Usage Maximum (0Ah), */\
- 0x81, 0x02, /* Input (Variable), */\
- 0x95, 0x0A, /* Report Count (10), */\
- 0x81, 0x01, /* Input (Constant), */\
- 0xC0, /* End Collection, */\
- 0xC0 /* End Collection */
+#define UHID_GRAPHIRE_REPORT_DESCR HID_GRAPHIRE_REPORT_DESCR
+#define UHID_GRAPHIRE3_4X5_REPORT_DESCR HID_GRAPHIRE3_4X5_REPORT_DESCR
+#define UHID_XB360GP_REPORT_DESCR HID_XB360GP_REPORT_DESCR
+#define UHID_SNES_REPORT_DESCR HID_SNES_REPORT_DESCR
+#define UHID_MOUSE_BOOTPROTO_DESCR HID_MOUSE_BOOTPROTO_DESCR
+#define UHID_KBD_BOOTPROTO_DESCR HID_KBD_BOOTPROTO_DESCR
diff --git a/sys/dev/usb/input/usbhid.c b/sys/dev/usb/input/usbhid.c
new file mode 100644
--- /dev/null
+++ b/sys/dev/usb/input/usbhid.c
@@ -0,0 +1,789 @@
+/*-
+ * SPDX-License-Identifier: BSD-2-Clause-NetBSD
+ *
+ * Copyright (c) 1998 The NetBSD Foundation, Inc.
+ * Copyright (c) 2019 Vladimir Kondratyev <wulf@FreeBSD.org>
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by Lennart Augustsson (lennart@augustsson.net) at
+ * Carlstedt Research & Technology.
+ *
+ * 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 NETBSD FOUNDATION, INC. 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 FOUNDATION 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 <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+/*
+ * HID spec: https://www.usb.org/sites/default/files/documents/hid1_11.pdf
+ */
+
+#include <sys/stdint.h>
+#include <sys/stddef.h>
+#include <sys/param.h>
+#include <sys/queue.h>
+#include <sys/types.h>
+#include <sys/systm.h>
+#include <sys/kernel.h>
+#include <sys/bus.h>
+#include <sys/module.h>
+#include <sys/lock.h>
+#include <sys/mutex.h>
+#include <sys/condvar.h>
+#include <sys/sysctl.h>
+#include <sys/sx.h>
+#include <sys/unistd.h>
+#include <sys/callout.h>
+#include <sys/malloc.h>
+#include <sys/priv.h>
+#include <sys/conf.h>
+#include <sys/fcntl.h>
+
+#include <dev/evdev/input.h>
+
+#include <dev/hid/hid.h>
+#include <dev/hid/hidquirk.h>
+
+#include <dev/usb/usb.h>
+#include <dev/usb/usbdi.h>
+#include <dev/usb/usbdi_util.h>
+#include <dev/usb/usbhid.h>
+
+#define USB_DEBUG_VAR usbhid_debug
+#include <dev/usb/usb_debug.h>
+
+#include <dev/usb/quirk/usb_quirk.h>
+
+#include "hid_if.h"
+
+#ifdef USB_DEBUG
+static int usbhid_debug = 0;
+
+static SYSCTL_NODE(_hw_usb, OID_AUTO, usbhid, CTLFLAG_RW, 0, "USB usbhid");
+SYSCTL_INT(_hw_usb_usbhid, OID_AUTO, debug, CTLFLAG_RWTUN,
+ &usbhid_debug, 0, "Debug level");
+#endif
+
+enum {
+ USBHID_INTR_OUT_DT,
+ USBHID_INTR_IN_DT,
+ USBHID_CTRL_DT,
+ USBHID_N_TRANSFER,
+};
+
+struct usbhid_xfer_ctx;
+typedef int usbhid_callback_t(struct usbhid_xfer_ctx *xfer_ctx);
+
+union usbhid_device_request {
+ struct { /* INTR xfers */
+ uint16_t maxlen;
+ uint16_t actlen;
+ } intr;
+ struct usb_device_request ctrl; /* CTRL xfers */
+};
+
+/* Syncronous USB transfer context */
+struct usbhid_xfer_ctx {
+ union usbhid_device_request req;
+ uint8_t *buf;
+ int error;
+ usbhid_callback_t *cb;
+ void *cb_ctx;
+ int waiters;
+ bool influx;
+};
+
+struct usbhid_softc {
+ hid_intr_t *sc_intr_handler;
+ void *sc_intr_ctx;
+ void *sc_intr_buf;
+
+ struct hid_device_info sc_hw;
+
+ struct mtx sc_mtx;
+ struct usb_config sc_config[USBHID_N_TRANSFER];
+ struct usb_xfer *sc_xfer[USBHID_N_TRANSFER];
+ struct usbhid_xfer_ctx sc_xfer_ctx[USBHID_N_TRANSFER];
+
+ struct usb_device *sc_udev;
+ uint8_t sc_iface_no;
+ uint8_t sc_iface_index;
+};
+
+/* prototypes */
+
+static device_probe_t usbhid_probe;
+static device_attach_t usbhid_attach;
+static device_detach_t usbhid_detach;
+
+static usb_callback_t usbhid_intr_out_callback;
+static usb_callback_t usbhid_intr_in_callback;
+static usb_callback_t usbhid_ctrl_callback;
+
+static usbhid_callback_t usbhid_intr_handler_cb;
+static usbhid_callback_t usbhid_sync_wakeup_cb;
+
+static void
+usbhid_intr_out_callback(struct usb_xfer *xfer, usb_error_t error)
+{
+ struct usbhid_xfer_ctx *xfer_ctx = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int len;
+
+ switch (USB_GET_STATE(xfer)) {
+ case USB_ST_TRANSFERRED:
+ case USB_ST_SETUP:
+tr_setup:
+ len = xfer_ctx->req.intr.maxlen;
+ if (len == 0) {
+ if (USB_IN_POLLING_MODE_FUNC())
+ xfer_ctx->error = 0;
+ else
+ usbd_transfer_stop(xfer);
+ return;
+ }
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_in(pc, 0, xfer_ctx->buf, len);
+ usbd_xfer_set_frame_len(xfer, 0, len);
+ usbd_transfer_submit(xfer);
+ xfer_ctx->req.intr.maxlen = 0;
+ if (USB_IN_POLLING_MODE_FUNC())
+ return;
+ xfer_ctx->error = 0;
+ goto tr_exit;
+
+ default: /* Error */
+ if (error != USB_ERR_CANCELLED) {
+ /* try to clear stall first */
+ usbd_xfer_set_stall(xfer);
+ goto tr_setup;
+ }
+ xfer_ctx->error = EIO;
+tr_exit:
+ (void)xfer_ctx->cb(xfer_ctx);
+ return;
+ }
+}
+
+static void
+usbhid_intr_in_callback(struct usb_xfer *xfer, usb_error_t error)
+{
+ struct usbhid_xfer_ctx *xfer_ctx = usbd_xfer_softc(xfer);
+ struct usb_page_cache *pc;
+ int actlen;
+
+ switch (USB_GET_STATE(xfer)) {
+ case USB_ST_TRANSFERRED:
+ DPRINTF("transferred!\n");
+
+ usbd_xfer_status(xfer, &actlen, NULL, NULL, NULL);
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_out(pc, 0, xfer_ctx->buf, actlen);
+ xfer_ctx->req.intr.actlen = actlen;
+ if (xfer_ctx->cb(xfer_ctx) != 0)
+ return;
+
+ case USB_ST_SETUP:
+re_submit:
+ usbd_xfer_set_frame_len(xfer, 0, xfer_ctx->req.intr.maxlen);
+ usbd_transfer_submit(xfer);
+ return;
+
+ default: /* Error */
+ if (error != USB_ERR_CANCELLED) {
+ /* try to clear stall first */
+ usbd_xfer_set_stall(xfer);
+ goto re_submit;
+ }
+ return;
+ }
+}
+
+static void
+usbhid_ctrl_callback(struct usb_xfer *xfer, usb_error_t error)
+{
+ struct usbhid_xfer_ctx *xfer_ctx = usbd_xfer_softc(xfer);
+ struct usb_device_request *req = &xfer_ctx->req.ctrl;
+ struct usb_page_cache *pc;
+ int len = UGETW(req->wLength);
+ bool is_rd = (req->bmRequestType & UT_READ) != 0;
+
+ switch (USB_GET_STATE(xfer)) {
+ case USB_ST_SETUP:
+ if (!is_rd && len != 0) {
+ pc = usbd_xfer_get_frame(xfer, 1);
+ usbd_copy_in(pc, 0, xfer_ctx->buf, len);
+ }
+
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_in(pc, 0, req, sizeof(*req));
+ usbd_xfer_set_frame_len(xfer, 0, sizeof(*req));
+ if (len != 0)
+ usbd_xfer_set_frame_len(xfer, 1, len);
+ usbd_xfer_set_frames(xfer, len != 0 ? 2 : 1);
+ usbd_transfer_submit(xfer);
+ return;
+
+ case USB_ST_TRANSFERRED:
+ if (is_rd && len != 0) {
+ pc = usbd_xfer_get_frame(xfer, 0);
+ usbd_copy_out(pc, sizeof(*req), xfer_ctx->buf, len);
+ }
+ xfer_ctx->error = 0;
+ goto tr_exit;
+
+ default: /* Error */
+ /* bomb out */
+ DPRINTFN(1, "error=%s\n", usbd_errstr(error));
+ xfer_ctx->error = EIO;
+tr_exit:
+ (void)xfer_ctx->cb(xfer_ctx);
+ return;
+ }
+}
+
+static int
+usbhid_intr_handler_cb(struct usbhid_xfer_ctx *xfer_ctx)
+{
+ struct usbhid_softc *sc = xfer_ctx->cb_ctx;
+
+ sc->sc_intr_handler(sc->sc_intr_ctx, xfer_ctx->buf,
+ xfer_ctx->req.intr.actlen);
+
+ return (0);
+}
+
+static int
+usbhid_sync_wakeup_cb(struct usbhid_xfer_ctx *xfer_ctx)
+{
+
+ if (!USB_IN_POLLING_MODE_FUNC())
+ wakeup(xfer_ctx->cb_ctx);
+
+ return (ECANCELED);
+}
+
+static const struct usb_config usbhid_config[USBHID_N_TRANSFER] = {
+
+ [USBHID_INTR_OUT_DT] = {
+ .type = UE_INTERRUPT,
+ .endpoint = UE_ADDR_ANY,
+ .direction = UE_DIR_OUT,
+ .flags = {.pipe_bof = 1,.proxy_buffer = 1},
+ .callback = &usbhid_intr_out_callback,
+ },
+ [USBHID_INTR_IN_DT] = {
+ .type = UE_INTERRUPT,
+ .endpoint = UE_ADDR_ANY,
+ .direction = UE_DIR_IN,
+ .flags = {.pipe_bof = 1,.short_xfer_ok = 1,.proxy_buffer = 1},
+ .callback = &usbhid_intr_in_callback,
+ },
+ [USBHID_CTRL_DT] = {
+ .type = UE_CONTROL,
+ .endpoint = 0x00, /* Control pipe */
+ .direction = UE_DIR_ANY,
+ .flags = {.proxy_buffer = 1},
+ .callback = &usbhid_ctrl_callback,
+ .timeout = 1000, /* 1 second */
+ },
+};
+
+static void
+usbhid_intr_setup(device_t dev, hid_intr_t intr, void *context,
+ struct hid_rdesc_info *rdesc)
+{
+ struct usbhid_softc* sc = device_get_softc(dev);
+ uint16_t n;
+ bool nowrite;
+ int error;
+
+ sc->sc_intr_handler = intr;
+ sc->sc_intr_ctx = context;
+ bcopy(usbhid_config, sc->sc_config, sizeof(usbhid_config));
+
+ /* Set buffer sizes to match HID report sizes */
+ sc->sc_config[USBHID_INTR_OUT_DT].bufsize = rdesc->osize;
+ sc->sc_config[USBHID_INTR_IN_DT].bufsize = rdesc->isize;
+ sc->sc_config[USBHID_CTRL_DT].bufsize =
+ MAX(rdesc->isize, MAX(rdesc->osize, rdesc->fsize));
+
+ nowrite = hid_test_quirk(&sc->sc_hw, HQ_NOWRITE);
+
+ /*
+ * Setup the USB transfers one by one, so they are memory independent
+ * which allows for handling panics triggered by the HID drivers
+ * itself, typically by hkbd via CTRL+ALT+ESC sequences. Or if the HID
+ * keyboard driver was processing a key at the moment of panic.
+ */
+ for (n = 0; n != USBHID_N_TRANSFER; n++) {
+ if (nowrite && n == USBHID_INTR_OUT_DT)
+ continue;
+ error = usbd_transfer_setup(sc->sc_udev, &sc->sc_iface_index,
+ sc->sc_xfer + n, sc->sc_config + n, 1,
+ (void *)(sc->sc_xfer_ctx + n), &sc->sc_mtx);
+ if (error)
+ break;
+ }
+
+ if (error)
+ DPRINTF("error=%s\n", usbd_errstr(error));
+
+ rdesc->rdsize = usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_IN_DT]);
+ rdesc->grsize = usbd_xfer_max_len(sc->sc_xfer[USBHID_CTRL_DT]);
+ rdesc->srsize = rdesc->grsize;
+ rdesc->wrsize = nowrite ? rdesc->srsize :
+ usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_OUT_DT]);
+
+ sc->sc_intr_buf = malloc(rdesc->rdsize, M_USBDEV, M_ZERO | M_WAITOK);
+}
+
+static void
+usbhid_intr_unsetup(device_t dev)
+{
+ struct usbhid_softc* sc = device_get_softc(dev);
+
+ usbd_transfer_unsetup(sc->sc_xfer, USBHID_N_TRANSFER);
+ free(sc->sc_intr_buf, M_USBDEV);
+}
+
+static int
+usbhid_intr_start(device_t dev)
+{
+ struct usbhid_softc* sc = device_get_softc(dev);
+
+ mtx_lock(&sc->sc_mtx);
+ sc->sc_xfer_ctx[USBHID_INTR_IN_DT] = (struct usbhid_xfer_ctx) {
+ .req.intr.maxlen =
+ usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_IN_DT]),
+ .cb = usbhid_intr_handler_cb,
+ .cb_ctx = sc,
+ .buf = sc->sc_intr_buf,
+ };
+ usbd_transfer_start(sc->sc_xfer[USBHID_INTR_IN_DT]);
+ mtx_unlock(&sc->sc_mtx);
+
+ return (0);
+}
+
+static int
+usbhid_intr_stop(device_t dev)
+{
+ struct usbhid_softc* sc = device_get_softc(dev);
+
+ mtx_lock(&sc->sc_mtx);
+ usbd_transfer_stop(sc->sc_xfer[USBHID_INTR_IN_DT]);
+ mtx_unlock(&sc->sc_mtx);
+
+ return (0);
+}
+
+static void
+usbhid_intr_poll(device_t dev)
+{
+ struct usbhid_softc* sc = device_get_softc(dev);
+
+ usbd_transfer_poll(sc->sc_xfer + USBHID_INTR_IN_DT, 1);
+}
+
+/*
+ * HID interface
+ */
+static int
+usbhid_sync_xfer(struct usbhid_softc* sc, int xfer_idx,
+ union usbhid_device_request *req, void *buf)
+{
+ int error, timeout;
+ struct usbhid_xfer_ctx *xfer_ctx, save;
+
+ xfer_ctx = sc->sc_xfer_ctx + xfer_idx;
+
+ if (USB_IN_POLLING_MODE_FUNC()) {
+ save = *xfer_ctx;
+ } else {
+ mtx_lock(&sc->sc_mtx);
+ ++xfer_ctx->waiters;
+ while (xfer_ctx->influx)
+ mtx_sleep(&xfer_ctx->waiters, &sc->sc_mtx, 0,
+ "usbhid wt", 0);
+ --xfer_ctx->waiters;
+ xfer_ctx->influx = true;
+ }
+
+ xfer_ctx->buf = buf;
+ xfer_ctx->req = *req;
+ xfer_ctx->error = ETIMEDOUT;
+ xfer_ctx->cb = &usbhid_sync_wakeup_cb;
+ xfer_ctx->cb_ctx = xfer_ctx;
+ timeout = USB_DEFAULT_TIMEOUT;
+ usbd_transfer_start(sc->sc_xfer[xfer_idx]);
+
+ if (USB_IN_POLLING_MODE_FUNC())
+ while (timeout > 0 && xfer_ctx->error == ETIMEDOUT) {
+ usbd_transfer_poll(sc->sc_xfer + xfer_idx, 1);
+ DELAY(1000);
+ timeout--;
+ }
+ else
+ msleep_sbt(xfer_ctx, &sc->sc_mtx, 0, "usbhid io",
+ SBT_1MS * timeout, 0, C_HARDCLOCK);
+
+ /* Perform usbhid_write() asyncronously to improve queueing */
+ if (USB_IN_POLLING_MODE_FUNC() ||
+ sc->sc_config[xfer_idx].type != UE_INTERRUPT ||
+ sc->sc_config[xfer_idx].direction != UE_DIR_OUT)
+ usbd_transfer_stop(sc->sc_xfer[xfer_idx]);
+ error = xfer_ctx->error;
+ if (error == 0)
+ *req = xfer_ctx->req;
+
+ if (USB_IN_POLLING_MODE_FUNC()) {
+ *xfer_ctx = save;
+ } else {
+ xfer_ctx->influx = false;
+ if (xfer_ctx->waiters != 0)
+ wakeup_one(&xfer_ctx->waiters);
+ mtx_unlock(&sc->sc_mtx);
+ }
+
+ if (error)
+ DPRINTF("USB IO error:%d\n", error);
+
+ return (error);
+}
+
+static int
+usbhid_get_rdesc(device_t dev, void *buf, hid_size_t len)
+{
+ struct usbhid_softc* sc = device_get_softc(dev);
+ int error;
+
+ error = usbd_req_get_report_descriptor(sc->sc_udev, NULL,
+ buf, len, sc->sc_iface_index);
+
+ if (error)
+ DPRINTF("no report descriptor: %s\n", usbd_errstr(error));
+
+ return (error == 0 ? 0 : ENXIO);
+}
+
+static int
+usbhid_get_report(device_t dev, void *buf, hid_size_t maxlen,
+ hid_size_t *actlen, uint8_t type, uint8_t id)
+{
+ struct usbhid_softc* sc = device_get_softc(dev);
+ union usbhid_device_request req;
+ int error;
+
+ if (maxlen > usbd_xfer_max_len(sc->sc_xfer[USBHID_CTRL_DT]))
+ return (ENOBUFS);
+
+ req.ctrl.bmRequestType = UT_READ_CLASS_INTERFACE;
+ req.ctrl.bRequest = UR_GET_REPORT;
+ USETW2(req.ctrl.wValue, type, id);
+ req.ctrl.wIndex[0] = sc->sc_iface_no;
+ req.ctrl.wIndex[1] = 0;
+ USETW(req.ctrl.wLength, maxlen);
+
+ error = usbhid_sync_xfer(sc, USBHID_CTRL_DT, &req, buf);
+ if (!error && actlen != NULL)
+ *actlen = maxlen;
+
+ return (error);
+}
+
+static int
+usbhid_set_report(device_t dev, const void *buf, hid_size_t len, uint8_t type,
+ uint8_t id)
+{
+ struct usbhid_softc* sc = device_get_softc(dev);
+ union usbhid_device_request req;
+
+ if (len > usbd_xfer_max_len(sc->sc_xfer[USBHID_CTRL_DT]))
+ return (ENOBUFS);
+
+ req.ctrl.bmRequestType = UT_WRITE_CLASS_INTERFACE;
+ req.ctrl.bRequest = UR_SET_REPORT;
+ USETW2(req.ctrl.wValue, type, id);
+ req.ctrl.wIndex[0] = sc->sc_iface_no;
+ req.ctrl.wIndex[1] = 0;
+ USETW(req.ctrl.wLength, len);
+
+ return (usbhid_sync_xfer(sc, USBHID_CTRL_DT, &req,
+ __DECONST(void *, buf)));
+}
+
+static int
+usbhid_read(device_t dev, void *buf, hid_size_t maxlen, hid_size_t *actlen)
+{
+ struct usbhid_softc* sc = device_get_softc(dev);
+ union usbhid_device_request req;
+ int error;
+
+ if (maxlen > usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_IN_DT]))
+ return (ENOBUFS);
+
+ req.intr.maxlen = maxlen;
+ error = usbhid_sync_xfer(sc, USBHID_INTR_IN_DT, &req, buf);
+ if (error == 0 && actlen != NULL)
+ *actlen = req.intr.actlen;
+
+ return (error);
+}
+
+static int
+usbhid_write(device_t dev, const void *buf, hid_size_t len)
+{
+ struct usbhid_softc* sc = device_get_softc(dev);
+ union usbhid_device_request req;
+
+ if (len > usbd_xfer_max_len(sc->sc_xfer[USBHID_INTR_OUT_DT]))
+ return (ENOBUFS);
+
+ req.intr.maxlen = len;
+ return (usbhid_sync_xfer(sc, USBHID_INTR_OUT_DT, &req,
+ __DECONST(void *, buf)));
+}
+
+static int
+usbhid_set_idle(device_t dev, uint16_t duration, uint8_t id)
+{
+ struct usbhid_softc* sc = device_get_softc(dev);
+ union usbhid_device_request req;
+
+ /* Duration is measured in 4 milliseconds per unit. */
+ req.ctrl.bmRequestType = UT_WRITE_CLASS_INTERFACE;
+ req.ctrl.bRequest = UR_SET_IDLE;
+ USETW2(req.ctrl.wValue, (duration + 3) / 4, id);
+ req.ctrl.wIndex[0] = sc->sc_iface_no;
+ req.ctrl.wIndex[1] = 0;
+ USETW(req.ctrl.wLength, 0);
+
+ return (usbhid_sync_xfer(sc, USBHID_CTRL_DT, &req, NULL));
+}
+
+static int
+usbhid_set_protocol(device_t dev, uint16_t protocol)
+{
+ struct usbhid_softc* sc = device_get_softc(dev);
+ union usbhid_device_request req;
+
+ req.ctrl.bmRequestType = UT_WRITE_CLASS_INTERFACE;
+ req.ctrl.bRequest = UR_SET_PROTOCOL;
+ USETW(req.ctrl.wValue, protocol);
+ req.ctrl.wIndex[0] = sc->sc_iface_no;
+ req.ctrl.wIndex[1] = 0;
+ USETW(req.ctrl.wLength, 0);
+
+ return (usbhid_sync_xfer(sc, USBHID_CTRL_DT, &req, NULL));
+}
+
+static void
+usbhid_init_device_info(struct usb_attach_arg *uaa, struct hid_device_info *hw)
+{
+
+ hw->idBus = BUS_USB;
+ hw->idVendor = uaa->info.idVendor;
+ hw->idProduct = uaa->info.idProduct;
+ hw->idVersion = uaa->info.bcdDevice;
+
+ /* Set various quirks based on usb_attach_arg */
+ hid_add_dynamic_quirk(hw, USB_GET_DRIVER_INFO(uaa));
+}
+
+static void
+usbhid_fill_device_info(struct usb_attach_arg *uaa, struct hid_device_info *hw)
+{
+ struct usb_device *udev = uaa->device;
+ struct usb_interface *iface = uaa->iface;
+ struct usb_hid_descriptor *hid;
+ struct usb_endpoint *ep;
+
+ snprintf(hw->name, sizeof(hw->name), "%s %s",
+ usb_get_manufacturer(udev), usb_get_product(udev));
+ strlcpy(hw->serial, usb_get_serial(udev), sizeof(hw->serial));
+
+ if (uaa->info.bInterfaceClass == UICLASS_HID &&
+ iface != NULL && iface->idesc != NULL) {
+ hid = hid_get_descriptor_from_usb(
+ usbd_get_config_descriptor(udev), iface->idesc);
+ if (hid != NULL)
+ hw->rdescsize =
+ UGETW(hid->descrs[0].wDescriptorLength);
+ }
+
+ /* See if there is a interrupt out endpoint. */
+ ep = usbd_get_endpoint(udev, uaa->info.bIfaceIndex,
+ usbhid_config + USBHID_INTR_OUT_DT);
+ if (ep == NULL || ep->methods == NULL)
+ hid_add_dynamic_quirk(hw, HQ_NOWRITE);
+}
+
+static const STRUCT_USB_HOST_ID usbhid_devs[] = {
+ /* the Xbox 360 gamepad doesn't use the HID class */
+ {USB_IFACE_CLASS(UICLASS_VENDOR),
+ USB_IFACE_SUBCLASS(UISUBCLASS_XBOX360_CONTROLLER),
+ USB_IFACE_PROTOCOL(UIPROTO_XBOX360_GAMEPAD),
+ USB_DRIVER_INFO(HQ_IS_XBOX360GP)},
+ /* HID keyboard with boot protocol support */
+ {USB_IFACE_CLASS(UICLASS_HID),
+ USB_IFACE_SUBCLASS(UISUBCLASS_BOOT),
+ USB_IFACE_PROTOCOL(UIPROTO_BOOT_KEYBOARD),
+ USB_DRIVER_INFO(HQ_HAS_KBD_BOOTPROTO)},
+ /* HID mouse with boot protocol support */
+ {USB_IFACE_CLASS(UICLASS_HID),
+ USB_IFACE_SUBCLASS(UISUBCLASS_BOOT),
+ USB_IFACE_PROTOCOL(UIPROTO_MOUSE),
+ USB_DRIVER_INFO(HQ_HAS_MS_BOOTPROTO)},
+ /* generic HID class */
+ {USB_IFACE_CLASS(UICLASS_HID), USB_DRIVER_INFO(HQ_NONE)},
+};
+
+static int
+usbhid_probe(device_t dev)
+{
+ struct usb_attach_arg *uaa = device_get_ivars(dev);
+ struct usbhid_softc *sc = device_get_softc(dev);
+ int error;
+
+ DPRINTFN(11, "\n");
+
+ if (uaa->usb_mode != USB_MODE_HOST)
+ return (ENXIO);
+
+ error = usbd_lookup_id_by_uaa(usbhid_devs, sizeof(usbhid_devs), uaa);
+ if (error)
+ return (error);
+
+ if (usb_test_quirk(uaa, UQ_HID_IGNORE))
+ return (ENXIO);
+
+ /*
+ * Setup temporary hid_device_info so that we can figure out some
+ * basic quirks for this device.
+ */
+ usbhid_init_device_info(uaa, &sc->sc_hw);
+
+ if (hid_test_quirk(&sc->sc_hw, HQ_HID_IGNORE))
+ return (ENXIO);
+
+#ifdef USBHID_ENABLED
+ return (BUS_PROBE_GENERIC + 1);
+#else
+ return (BUS_PROBE_GENERIC - 1);
+#endif
+}
+
+static int
+usbhid_attach(device_t dev)
+{
+ struct usb_attach_arg *uaa = device_get_ivars(dev);
+ struct usbhid_softc *sc = device_get_softc(dev);
+ device_t child;
+ int error = 0;
+
+ DPRINTFN(10, "sc=%p\n", sc);
+
+ device_set_usb_desc(dev);
+
+ sc->sc_udev = uaa->device;
+ sc->sc_iface_no = uaa->info.bIfaceNum;
+ sc->sc_iface_index = uaa->info.bIfaceIndex;
+
+ usbhid_fill_device_info(uaa, &sc->sc_hw);
+
+ error = usbd_req_set_idle(uaa->device, NULL,
+ uaa->info.bIfaceIndex, 0, 0);
+ if (error)
+ DPRINTF("set idle failed, error=%s (ignored)\n",
+ usbd_errstr(error));
+
+ mtx_init(&sc->sc_mtx, "usbhid lock", NULL, MTX_DEF);
+
+ child = device_add_child(dev, "hidbus", -1);
+ if (child == NULL) {
+ device_printf(dev, "Could not add hidbus device\n");
+ usbhid_detach(dev);
+ return (ENOMEM);
+ }
+
+ device_set_ivars(child, &sc->sc_hw);
+ error = bus_generic_attach(dev);
+ if (error) {
+ device_printf(dev, "failed to attach child: %d\n", error);
+ usbhid_detach(dev);
+ return (error);
+ }
+
+ return (0); /* success */
+}
+
+static int
+usbhid_detach(device_t dev)
+{
+ struct usbhid_softc *sc = device_get_softc(dev);
+
+ device_delete_children(dev);
+ mtx_destroy(&sc->sc_mtx);
+
+ return (0);
+}
+
+static devclass_t usbhid_devclass;
+
+static device_method_t usbhid_methods[] = {
+ DEVMETHOD(device_probe, usbhid_probe),
+ DEVMETHOD(device_attach, usbhid_attach),
+ DEVMETHOD(device_detach, usbhid_detach),
+
+ DEVMETHOD(hid_intr_setup, usbhid_intr_setup),
+ DEVMETHOD(hid_intr_unsetup, usbhid_intr_unsetup),
+ DEVMETHOD(hid_intr_start, usbhid_intr_start),
+ DEVMETHOD(hid_intr_stop, usbhid_intr_stop),
+ DEVMETHOD(hid_intr_poll, usbhid_intr_poll),
+
+ /* HID interface */
+ DEVMETHOD(hid_get_rdesc, usbhid_get_rdesc),
+ DEVMETHOD(hid_read, usbhid_read),
+ DEVMETHOD(hid_write, usbhid_write),
+ DEVMETHOD(hid_get_report, usbhid_get_report),
+ DEVMETHOD(hid_set_report, usbhid_set_report),
+ DEVMETHOD(hid_set_idle, usbhid_set_idle),
+ DEVMETHOD(hid_set_protocol, usbhid_set_protocol),
+
+ DEVMETHOD_END
+};
+
+static driver_t usbhid_driver = {
+ .name = "usbhid",
+ .methods = usbhid_methods,
+ .size = sizeof(struct usbhid_softc),
+};
+
+DRIVER_MODULE(usbhid, uhub, usbhid_driver, usbhid_devclass, NULL, 0);
+MODULE_DEPEND(usbhid, usb, 1, 1, 1);
+MODULE_DEPEND(usbhid, hid, 1, 1, 1);
+MODULE_DEPEND(usbhid, hidbus, 1, 1, 1);
+MODULE_VERSION(usbhid, 1);
+#ifdef USBHID_ENABLED
+USB_PNP_HOST_INFO(usbhid_devs);
+#endif
diff --git a/sys/dev/usb/input/wmt.c b/sys/dev/usb/input/wmt.c
--- a/sys/dev/usb/input/wmt.c
+++ b/sys/dev/usb/input/wmt.c
@@ -456,7 +456,7 @@
}
WMT_FOREACH_USAGE(sc->caps, i) {
if (wmt_hid_map[i].code != WMT_NO_CODE)
- evdev_support_abs(sc->evdev, wmt_hid_map[i].code, 0,
+ evdev_support_abs(sc->evdev, wmt_hid_map[i].code,
sc->ai[i].min, sc->ai[i].max, 0, 0, sc->ai[i].res);
}
@@ -1048,11 +1048,13 @@
return (err);
}
+#ifndef USBHID_ENABLED
static const STRUCT_USB_HOST_ID wmt_devs[] = {
/* generic HID class w/o boot interface */
{USB_IFACE_CLASS(UICLASS_HID),
USB_IFACE_SUBCLASS(0),},
};
+#endif
static devclass_t wmt_devclass;
@@ -1072,6 +1074,9 @@
DRIVER_MODULE(wmt, uhub, wmt_driver, wmt_devclass, NULL, 0);
MODULE_DEPEND(wmt, usb, 1, 1, 1);
+MODULE_DEPEND(wmt, hid, 1, 1, 1);
MODULE_DEPEND(wmt, evdev, 1, 1, 1);
MODULE_VERSION(wmt, 1);
+#ifndef USBHID_ENABLED
USB_PNP_HOST_INFO(wmt_devs);
+#endif
diff --git a/sys/dev/usb/input/wsp.c b/sys/dev/usb/input/wsp.c
--- a/sys/dev/usb/input/wsp.c
+++ b/sys/dev/usb/input/wsp.c
@@ -1403,5 +1403,6 @@
DRIVER_MODULE(wsp, uhub, wsp_driver, wsp_devclass, NULL, 0);
MODULE_DEPEND(wsp, usb, 1, 1, 1);
+MODULE_DEPEND(wsp, hid, 1, 1, 1);
MODULE_VERSION(wsp, 1);
USB_PNP_HOST_INFO(wsp_devs);
diff --git a/sys/dev/usb/misc/ugold.c b/sys/dev/usb/misc/ugold.c
--- a/sys/dev/usb/misc/ugold.c
+++ b/sys/dev/usb/misc/ugold.c
@@ -142,6 +142,7 @@
DRIVER_MODULE(ugold, uhub, ugold_driver, ugold_devclass, NULL, NULL);
MODULE_DEPEND(ugold, usb, 1, 1, 1);
+MODULE_DEPEND(ugold, hid, 1, 1, 1);
MODULE_VERSION(ugold, 1);
USB_PNP_HOST_INFO(ugold_devs);
diff --git a/sys/dev/usb/serial/ucycom.c b/sys/dev/usb/serial/ucycom.c
--- a/sys/dev/usb/serial/ucycom.c
+++ b/sys/dev/usb/serial/ucycom.c
@@ -185,6 +185,7 @@
DRIVER_MODULE(ucycom, uhub, ucycom_driver, ucycom_devclass, NULL, 0);
MODULE_DEPEND(ucycom, ucom, 1, 1, 1);
MODULE_DEPEND(ucycom, usb, 1, 1, 1);
+MODULE_DEPEND(ucycom, hid, 1, 1, 1);
MODULE_VERSION(ucycom, 1);
USB_PNP_HOST_INFO(ucycom_devs);
diff --git a/sys/dev/usb/usb_hid.c b/sys/dev/usb/usb_hid.c
--- a/sys/dev/usb/usb_hid.c
+++ b/sys/dev/usb/usb_hid.c
@@ -68,703 +68,6 @@
#include <dev/usb/usb_request.h>
#endif /* USB_GLOBAL_INCLUDE_FILE */
-static void hid_clear_local(struct hid_item *);
-static uint8_t hid_get_byte(struct hid_data *s, const uint16_t wSize);
-
-#define MAXUSAGE 64
-#define MAXPUSH 4
-#define MAXID 16
-#define MAXLOCCNT 2048
-
-struct hid_pos_data {
- int32_t rid;
- uint32_t pos;
-};
-
-struct hid_data {
- const uint8_t *start;
- const uint8_t *end;
- const uint8_t *p;
- struct hid_item cur[MAXPUSH];
- struct hid_pos_data last_pos[MAXID];
- int32_t usages_min[MAXUSAGE];
- int32_t usages_max[MAXUSAGE];
- int32_t usage_last; /* last seen usage */
- uint32_t loc_size; /* last seen size */
- uint32_t loc_count; /* last seen count */
- uint32_t ncount; /* end usage item count */
- uint32_t icount; /* current usage item count */
- uint8_t kindset; /* we have 5 kinds so 8 bits are enough */
- uint8_t pushlevel; /* current pushlevel */
- uint8_t nusage; /* end "usages_min/max" index */
- uint8_t iusage; /* current "usages_min/max" index */
- uint8_t ousage; /* current "usages_min/max" offset */
- uint8_t susage; /* usage set flags */
-};
-
-/*------------------------------------------------------------------------*
- * hid_clear_local
- *------------------------------------------------------------------------*/
-static void
-hid_clear_local(struct hid_item *c)
-{
-
- c->loc.count = 0;
- c->loc.size = 0;
- c->usage = 0;
- c->usage_minimum = 0;
- c->usage_maximum = 0;
- c->designator_index = 0;
- c->designator_minimum = 0;
- c->designator_maximum = 0;
- c->string_index = 0;
- c->string_minimum = 0;
- c->string_maximum = 0;
- c->set_delimiter = 0;
-}
-
-static void
-hid_switch_rid(struct hid_data *s, struct hid_item *c, int32_t next_rID)
-{
- uint8_t i;
-
- /* check for same report ID - optimise */
-
- if (c->report_ID == next_rID)
- return;
-
- /* save current position for current rID */
-
- if (c->report_ID == 0) {
- i = 0;
- } else {
- for (i = 1; i != MAXID; i++) {
- if (s->last_pos[i].rid == c->report_ID)
- break;
- if (s->last_pos[i].rid == 0)
- break;
- }
- }
- if (i != MAXID) {
- s->last_pos[i].rid = c->report_ID;
- s->last_pos[i].pos = c->loc.pos;
- }
-
- /* store next report ID */
-
- c->report_ID = next_rID;
-
- /* lookup last position for next rID */
-
- if (next_rID == 0) {
- i = 0;
- } else {
- for (i = 1; i != MAXID; i++) {
- if (s->last_pos[i].rid == next_rID)
- break;
- if (s->last_pos[i].rid == 0)
- break;
- }
- }
- if (i != MAXID) {
- s->last_pos[i].rid = next_rID;
- c->loc.pos = s->last_pos[i].pos;
- } else {
- DPRINTF("Out of RID entries, position is set to zero!\n");
- c->loc.pos = 0;
- }
-}
-
-/*------------------------------------------------------------------------*
- * hid_start_parse
- *------------------------------------------------------------------------*/
-struct hid_data *
-hid_start_parse(const void *d, usb_size_t len, int kindset)
-{
- struct hid_data *s;
-
- if ((kindset-1) & kindset) {
- DPRINTFN(0, "Only one bit can be "
- "set in the kindset\n");
- return (NULL);
- }
-
- s = malloc(sizeof *s, M_TEMP, M_WAITOK | M_ZERO);
- s->start = s->p = d;
- s->end = ((const uint8_t *)d) + len;
- s->kindset = kindset;
- return (s);
-}
-
-/*------------------------------------------------------------------------*
- * hid_end_parse
- *------------------------------------------------------------------------*/
-void
-hid_end_parse(struct hid_data *s)
-{
- if (s == NULL)
- return;
-
- free(s, M_TEMP);
-}
-
-/*------------------------------------------------------------------------*
- * get byte from HID descriptor
- *------------------------------------------------------------------------*/
-static uint8_t
-hid_get_byte(struct hid_data *s, const uint16_t wSize)
-{
- const uint8_t *ptr;
- uint8_t retval;
-
- ptr = s->p;
-
- /* check if end is reached */
- if (ptr == s->end)
- return (0);
-
- /* read out a byte */
- retval = *ptr;
-
- /* check if data pointer can be advanced by "wSize" bytes */
- if ((s->end - ptr) < wSize)
- ptr = s->end;
- else
- ptr += wSize;
-
- /* update pointer */
- s->p = ptr;
-
- return (retval);
-}
-
-/*------------------------------------------------------------------------*
- * hid_get_item
- *------------------------------------------------------------------------*/
-int
-hid_get_item(struct hid_data *s, struct hid_item *h)
-{
- struct hid_item *c;
- unsigned int bTag, bType, bSize;
- uint32_t oldpos;
- int32_t mask;
- int32_t dval;
-
- if (s == NULL)
- return (0);
-
- c = &s->cur[s->pushlevel];
-
- top:
- /* check if there is an array of items */
- if (s->icount < s->ncount) {
- /* get current usage */
- if (s->iusage < s->nusage) {
- dval = s->usages_min[s->iusage] + s->ousage;
- c->usage = dval;
- s->usage_last = dval;
- if (dval == s->usages_max[s->iusage]) {
- if (s->iusage < MAXUSAGE - 1)
- s->iusage ++;
- s->ousage = 0;
- } else {
- s->ousage ++;
- }
- } else {
- DPRINTFN(1, "Using last usage\n");
- dval = s->usage_last;
- }
- s->icount ++;
- /*
- * Only copy HID item, increment position and return
- * if correct kindset!
- */
- if (s->kindset & (1 << c->kind)) {
- *h = *c;
- DPRINTFN(1, "%u,%u,%u\n", h->loc.pos,
- h->loc.size, h->loc.count);
- c->loc.pos += c->loc.size * c->loc.count;
- return (1);
- }
- }
-
- /* reset state variables */
- s->icount = 0;
- s->ncount = 0;
- s->iusage = 0;
- s->nusage = 0;
- s->susage = 0;
- s->ousage = 0;
- hid_clear_local(c);
-
- /* get next item */
- while (s->p != s->end) {
- bSize = hid_get_byte(s, 1);
- if (bSize == 0xfe) {
- /* long item */
- bSize = hid_get_byte(s, 1);
- bSize |= hid_get_byte(s, 1) << 8;
- bTag = hid_get_byte(s, 1);
- bType = 0xff; /* XXX what should it be */
- } else {
- /* short item */
- bTag = bSize >> 4;
- bType = (bSize >> 2) & 3;
- bSize &= 3;
- if (bSize == 3)
- bSize = 4;
- }
- switch (bSize) {
- case 0:
- dval = 0;
- mask = 0;
- break;
- case 1:
- dval = (int8_t)hid_get_byte(s, 1);
- mask = 0xFF;
- break;
- case 2:
- dval = hid_get_byte(s, 1);
- dval |= hid_get_byte(s, 1) << 8;
- dval = (int16_t)dval;
- mask = 0xFFFF;
- break;
- case 4:
- dval = hid_get_byte(s, 1);
- dval |= hid_get_byte(s, 1) << 8;
- dval |= hid_get_byte(s, 1) << 16;
- dval |= hid_get_byte(s, 1) << 24;
- mask = 0xFFFFFFFF;
- break;
- default:
- dval = hid_get_byte(s, bSize);
- DPRINTFN(0, "bad length %u (data=0x%02x)\n",
- bSize, dval);
- continue;
- }
-
- switch (bType) {
- case 0: /* Main */
- switch (bTag) {
- case 8: /* Input */
- c->kind = hid_input;
- ret:
- c->flags = dval;
- c->loc.count = s->loc_count;
- c->loc.size = s->loc_size;
-
- if (c->flags & HIO_VARIABLE) {
- /* range check usage count */
- if (c->loc.count > MAXLOCCNT) {
- DPRINTFN(0, "Number of "
- "items(%u) truncated to %u\n",
- (unsigned)(c->loc.count),
- MAXLOCCNT);
- s->ncount = MAXLOCCNT;
- } else
- s->ncount = c->loc.count;
-
- /*
- * The "top" loop will return
- * one and one item:
- */
- c->loc.count = 1;
- } else {
- s->ncount = 1;
- }
- goto top;
-
- case 9: /* Output */
- c->kind = hid_output;
- goto ret;
- case 10: /* Collection */
- c->kind = hid_collection;
- c->collection = dval;
- c->collevel++;
- c->usage = s->usage_last;
- *h = *c;
- return (1);
- case 11: /* Feature */
- c->kind = hid_feature;
- goto ret;
- case 12: /* End collection */
- c->kind = hid_endcollection;
- if (c->collevel == 0) {
- DPRINTFN(0, "invalid end collection\n");
- return (0);
- }
- c->collevel--;
- *h = *c;
- return (1);
- default:
- DPRINTFN(0, "Main bTag=%d\n", bTag);
- break;
- }
- break;
- case 1: /* Global */
- switch (bTag) {
- case 0:
- c->_usage_page = dval << 16;
- break;
- case 1:
- c->logical_minimum = dval;
- break;
- case 2:
- c->logical_maximum = dval;
- break;
- case 3:
- c->physical_minimum = dval;
- break;
- case 4:
- c->physical_maximum = dval;
- break;
- case 5:
- c->unit_exponent = dval;
- break;
- case 6:
- c->unit = dval;
- break;
- case 7:
- /* mask because value is unsigned */
- s->loc_size = dval & mask;
- break;
- case 8:
- hid_switch_rid(s, c, dval & mask);
- break;
- case 9:
- /* mask because value is unsigned */
- s->loc_count = dval & mask;
- break;
- case 10: /* Push */
- /* stop parsing, if invalid push level */
- if ((s->pushlevel + 1) >= MAXPUSH) {
- DPRINTFN(0, "Cannot push item @ %d\n", s->pushlevel);
- return (0);
- }
- s->pushlevel ++;
- s->cur[s->pushlevel] = *c;
- /* store size and count */
- c->loc.size = s->loc_size;
- c->loc.count = s->loc_count;
- /* update current item pointer */
- c = &s->cur[s->pushlevel];
- break;
- case 11: /* Pop */
- /* stop parsing, if invalid push level */
- if (s->pushlevel == 0) {
- DPRINTFN(0, "Cannot pop item @ 0\n");
- return (0);
- }
- s->pushlevel --;
- /* preserve position */
- oldpos = c->loc.pos;
- c = &s->cur[s->pushlevel];
- /* restore size and count */
- s->loc_size = c->loc.size;
- s->loc_count = c->loc.count;
- /* set default item location */
- c->loc.pos = oldpos;
- c->loc.size = 0;
- c->loc.count = 0;
- break;
- default:
- DPRINTFN(0, "Global bTag=%d\n", bTag);
- break;
- }
- break;
- case 2: /* Local */
- switch (bTag) {
- case 0:
- if (bSize != 4)
- dval = (dval & mask) | c->_usage_page;
-
- /* set last usage, in case of a collection */
- s->usage_last = dval;
-
- if (s->nusage < MAXUSAGE) {
- s->usages_min[s->nusage] = dval;
- s->usages_max[s->nusage] = dval;
- s->nusage ++;
- } else {
- DPRINTFN(0, "max usage reached\n");
- }
-
- /* clear any pending usage sets */
- s->susage = 0;
- break;
- case 1:
- s->susage |= 1;
-
- if (bSize != 4)
- dval = (dval & mask) | c->_usage_page;
- c->usage_minimum = dval;
-
- goto check_set;
- case 2:
- s->susage |= 2;
-
- if (bSize != 4)
- dval = (dval & mask) | c->_usage_page;
- c->usage_maximum = dval;
-
- check_set:
- if (s->susage != 3)
- break;
-
- /* sanity check */
- if ((s->nusage < MAXUSAGE) &&
- (c->usage_minimum <= c->usage_maximum)) {
- /* add usage range */
- s->usages_min[s->nusage] =
- c->usage_minimum;
- s->usages_max[s->nusage] =
- c->usage_maximum;
- s->nusage ++;
- } else {
- DPRINTFN(0, "Usage set dropped\n");
- }
- s->susage = 0;
- break;
- case 3:
- c->designator_index = dval;
- break;
- case 4:
- c->designator_minimum = dval;
- break;
- case 5:
- c->designator_maximum = dval;
- break;
- case 7:
- c->string_index = dval;
- break;
- case 8:
- c->string_minimum = dval;
- break;
- case 9:
- c->string_maximum = dval;
- break;
- case 10:
- c->set_delimiter = dval;
- break;
- default:
- DPRINTFN(0, "Local bTag=%d\n", bTag);
- break;
- }
- break;
- default:
- DPRINTFN(0, "default bType=%d\n", bType);
- break;
- }
- }
- return (0);
-}
-
-/*------------------------------------------------------------------------*
- * hid_report_size
- *------------------------------------------------------------------------*/
-int
-hid_report_size(const void *buf, usb_size_t len, enum hid_kind k, uint8_t *id)
-{
- struct hid_data *d;
- struct hid_item h;
- uint32_t temp;
- uint32_t hpos;
- uint32_t lpos;
- uint8_t any_id;
-
- any_id = 0;
- hpos = 0;
- lpos = 0xFFFFFFFF;
-
- for (d = hid_start_parse(buf, len, 1 << k); hid_get_item(d, &h);) {
- if (h.kind == k) {
- /* check for ID-byte presence */
- if ((h.report_ID != 0) && !any_id) {
- if (id != NULL)
- *id = h.report_ID;
- any_id = 1;
- }
- /* compute minimum */
- if (lpos > h.loc.pos)
- lpos = h.loc.pos;
- /* compute end position */
- temp = h.loc.pos + (h.loc.size * h.loc.count);
- /* compute maximum */
- if (hpos < temp)
- hpos = temp;
- }
- }
- hid_end_parse(d);
-
- /* safety check - can happen in case of currupt descriptors */
- if (lpos > hpos)
- temp = 0;
- else
- temp = hpos - lpos;
-
- /* check for ID byte */
- if (any_id)
- temp += 8;
- else if (id != NULL)
- *id = 0;
-
- /* return length in bytes rounded up */
- return ((temp + 7) / 8);
-}
-
-/*------------------------------------------------------------------------*
- * hid_locate
- *------------------------------------------------------------------------*/
-int
-hid_locate(const void *desc, usb_size_t size, int32_t u, enum hid_kind k,
- uint8_t index, struct hid_location *loc, uint32_t *flags, uint8_t *id)
-{
- struct hid_data *d;
- struct hid_item h;
-
- for (d = hid_start_parse(desc, size, 1 << k); hid_get_item(d, &h);) {
- if (h.kind == k && !(h.flags & HIO_CONST) && h.usage == u) {
- if (index--)
- continue;
- if (loc != NULL)
- *loc = h.loc;
- if (flags != NULL)
- *flags = h.flags;
- if (id != NULL)
- *id = h.report_ID;
- hid_end_parse(d);
- return (1);
- }
- }
- if (loc != NULL)
- loc->size = 0;
- if (flags != NULL)
- *flags = 0;
- if (id != NULL)
- *id = 0;
- hid_end_parse(d);
- return (0);
-}
-
-/*------------------------------------------------------------------------*
- * hid_get_data
- *------------------------------------------------------------------------*/
-static uint32_t
-hid_get_data_sub(const uint8_t *buf, usb_size_t len, struct hid_location *loc,
- int is_signed)
-{
- uint32_t hpos = loc->pos;
- uint32_t hsize = loc->size;
- uint32_t data;
- uint32_t rpos;
- uint8_t n;
-
- DPRINTFN(11, "hid_get_data: loc %d/%d\n", hpos, hsize);
-
- /* Range check and limit */
- if (hsize == 0)
- return (0);
- if (hsize > 32)
- hsize = 32;
-
- /* Get data in a safe way */
- data = 0;
- rpos = (hpos / 8);
- n = (hsize + 7) / 8;
- rpos += n;
- while (n--) {
- rpos--;
- if (rpos < len)
- data |= buf[rpos] << (8 * n);
- }
-
- /* Correctly shift down data */
- data = (data >> (hpos % 8));
- n = 32 - hsize;
-
- /* Mask and sign extend in one */
- if (is_signed != 0)
- data = (int32_t)((int32_t)data << n) >> n;
- else
- data = (uint32_t)((uint32_t)data << n) >> n;
-
- DPRINTFN(11, "hid_get_data: loc %d/%d = %lu\n",
- loc->pos, loc->size, (long)data);
- return (data);
-}
-
-int32_t
-hid_get_data(const uint8_t *buf, usb_size_t len, struct hid_location *loc)
-{
- return (hid_get_data_sub(buf, len, loc, 1));
-}
-
-uint32_t
-hid_get_data_unsigned(const uint8_t *buf, usb_size_t len, struct hid_location *loc)
-{
- return (hid_get_data_sub(buf, len, loc, 0));
-}
-
-/*------------------------------------------------------------------------*
- * hid_put_data
- *------------------------------------------------------------------------*/
-void
-hid_put_data_unsigned(uint8_t *buf, usb_size_t len,
- struct hid_location *loc, unsigned int value)
-{
- uint32_t hpos = loc->pos;
- uint32_t hsize = loc->size;
- uint64_t data;
- uint64_t mask;
- uint32_t rpos;
- uint8_t n;
-
- DPRINTFN(11, "hid_put_data: loc %d/%d = %u\n", hpos, hsize, value);
-
- /* Range check and limit */
- if (hsize == 0)
- return;
- if (hsize > 32)
- hsize = 32;
-
- /* Put data in a safe way */
- rpos = (hpos / 8);
- n = (hsize + 7) / 8;
- data = ((uint64_t)value) << (hpos % 8);
- mask = ((1ULL << hsize) - 1ULL) << (hpos % 8);
- rpos += n;
- while (n--) {
- rpos--;
- if (rpos < len) {
- buf[rpos] &= ~(mask >> (8 * n));
- buf[rpos] |= (data >> (8 * n));
- }
- }
-}
-
-/*------------------------------------------------------------------------*
- * hid_is_collection
- *------------------------------------------------------------------------*/
-int
-hid_is_collection(const void *desc, usb_size_t size, int32_t usage)
-{
- struct hid_data *hd;
- struct hid_item hi;
- int err;
-
- hd = hid_start_parse(desc, size, hid_input);
- if (hd == NULL)
- return (0);
-
- while ((err = hid_get_item(hd, &hi))) {
- if (hi.kind == hid_collection &&
- hi.usage == usage)
- break;
- }
- hid_end_parse(hd);
- return (err);
-}
-
/*------------------------------------------------------------------------*
* hid_get_descriptor_from_usb
*
@@ -849,153 +152,3 @@
}
return (USB_ERR_NORMAL_COMPLETION);
}
-
-/*------------------------------------------------------------------------*
- * calculate HID item resolution. unit/mm for distances, unit/rad for angles
- *------------------------------------------------------------------------*/
-int32_t
-hid_item_resolution(struct hid_item *hi)
-{
- /*
- * hid unit scaling table according to HID Usage Table Review
- * Request 39 Tbl 17 http://www.usb.org/developers/hidpage/HUTRR39b.pdf
- */
- static const int64_t scale[0x10][2] = {
- [0x00] = { 1, 1 },
- [0x01] = { 1, 10 },
- [0x02] = { 1, 100 },
- [0x03] = { 1, 1000 },
- [0x04] = { 1, 10000 },
- [0x05] = { 1, 100000 },
- [0x06] = { 1, 1000000 },
- [0x07] = { 1, 10000000 },
- [0x08] = { 100000000, 1 },
- [0x09] = { 10000000, 1 },
- [0x0A] = { 1000000, 1 },
- [0x0B] = { 100000, 1 },
- [0x0C] = { 10000, 1 },
- [0x0D] = { 1000, 1 },
- [0x0E] = { 100, 1 },
- [0x0F] = { 10, 1 },
- };
- int64_t logical_size;
- int64_t physical_size;
- int64_t multiplier;
- int64_t divisor;
- int64_t resolution;
-
- switch (hi->unit) {
- case HUM_CENTIMETER:
- multiplier = 1;
- divisor = 10;
- break;
- case HUM_INCH:
- multiplier = 10;
- divisor = 254;
- break;
- case HUM_RADIAN:
- multiplier = 1;
- divisor = 1;
- break;
- case HUM_DEGREE:
- multiplier = 573;
- divisor = 10;
- break;
- default:
- return (0);
- }
-
- if ((hi->logical_maximum <= hi->logical_minimum) ||
- (hi->physical_maximum <= hi->physical_minimum) ||
- (hi->unit_exponent < 0) || (hi->unit_exponent >= nitems(scale)))
- return (0);
-
- logical_size = (int64_t)hi->logical_maximum -
- (int64_t)hi->logical_minimum;
- physical_size = (int64_t)hi->physical_maximum -
- (int64_t)hi->physical_minimum;
- /* Round to ceiling */
- resolution = logical_size * multiplier * scale[hi->unit_exponent][0] /
- (physical_size * divisor * scale[hi->unit_exponent][1]);
-
- if (resolution > INT32_MAX)
- return (0);
-
- return (resolution);
-}
-
-/*------------------------------------------------------------------------*
- * hid_is_mouse
- *
- * This function will decide if a USB descriptor belongs to a USB mouse.
- *
- * Return values:
- * Zero: Not a USB mouse.
- * Else: Is a USB mouse.
- *------------------------------------------------------------------------*/
-int
-hid_is_mouse(const void *d_ptr, uint16_t d_len)
-{
- struct hid_data *hd;
- struct hid_item hi;
- int mdepth;
- int found;
-
- hd = hid_start_parse(d_ptr, d_len, 1 << hid_input);
- if (hd == NULL)
- return (0);
-
- mdepth = 0;
- found = 0;
-
- while (hid_get_item(hd, &hi)) {
- switch (hi.kind) {
- case hid_collection:
- if (mdepth != 0)
- mdepth++;
- else if (hi.collection == 1 &&
- hi.usage ==
- HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_MOUSE))
- mdepth++;
- break;
- case hid_endcollection:
- if (mdepth != 0)
- mdepth--;
- break;
- case hid_input:
- if (mdepth == 0)
- break;
- if (hi.usage ==
- HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_X) &&
- (hi.flags & (HIO_CONST|HIO_RELATIVE)) == HIO_RELATIVE)
- found++;
- if (hi.usage ==
- HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_Y) &&
- (hi.flags & (HIO_CONST|HIO_RELATIVE)) == HIO_RELATIVE)
- found++;
- break;
- default:
- break;
- }
- }
- hid_end_parse(hd);
- return (found);
-}
-
-/*------------------------------------------------------------------------*
- * hid_is_keyboard
- *
- * This function will decide if a USB descriptor belongs to a USB keyboard.
- *
- * Return values:
- * Zero: Not a USB keyboard.
- * Else: Is a USB keyboard.
- *------------------------------------------------------------------------*/
-int
-hid_is_keyboard(const void *d_ptr, uint16_t d_len)
-{
- if (hid_is_collection(d_ptr, d_len,
- HID_USAGE2(HUP_GENERIC_DESKTOP, HUG_KEYBOARD)))
- return (1);
- return (0);
-}
diff --git a/sys/dev/usb/usb_ioctl.h b/sys/dev/usb/usb_ioctl.h
--- a/sys/dev/usb/usb_ioctl.h
+++ b/sys/dev/usb/usb_ioctl.h
@@ -270,7 +270,7 @@
#define USB_DEVICESTATS _IOR ('U', 5, struct usb_device_stats)
#define USB_DEVICEENUMERATE _IOW ('U', 6, int)
-/* Generic HID device */
+/* Generic HID device. Numbers 26 and 30-39 are occupied by hidraw. */
#define USB_GET_REPORT_DESC _IOWR('U', 21, struct usb_gen_descriptor)
#define USB_SET_IMMED _IOW ('U', 22, int)
#define USB_GET_REPORT _IOWR('U', 23, struct usb_gen_descriptor)
diff --git a/sys/dev/usb/usbhid.h b/sys/dev/usb/usbhid.h
--- a/sys/dev/usb/usbhid.h
+++ b/sys/dev/usb/usbhid.h
@@ -31,6 +31,8 @@
#ifndef _USB_HID_H_
#define _USB_HID_H_
+#include <dev/hid/hid.h>
+
#ifndef USB_GLOBAL_INCLUDE_FILE
#include <dev/usb/usb_endian.h>
#endif
@@ -61,218 +63,28 @@
#define USB_HID_DESCRIPTOR_SIZE(n) (9+((n)*3))
-/* Usage pages */
-#define HUP_UNDEFINED 0x0000
-#define HUP_GENERIC_DESKTOP 0x0001
-#define HUP_SIMULATION 0x0002
-#define HUP_VR_CONTROLS 0x0003
-#define HUP_SPORTS_CONTROLS 0x0004
-#define HUP_GAMING_CONTROLS 0x0005
-#define HUP_KEYBOARD 0x0007
-#define HUP_LEDS 0x0008
-#define HUP_BUTTON 0x0009
-#define HUP_ORDINALS 0x000a
-#define HUP_TELEPHONY 0x000b
-#define HUP_CONSUMER 0x000c
-#define HUP_DIGITIZERS 0x000d
-#define HUP_PHYSICAL_IFACE 0x000e
-#define HUP_UNICODE 0x0010
-#define HUP_ALPHANUM_DISPLAY 0x0014
-#define HUP_MONITOR 0x0080
-#define HUP_MONITOR_ENUM_VAL 0x0081
-#define HUP_VESA_VC 0x0082
-#define HUP_VESA_CMD 0x0083
-#define HUP_POWER 0x0084
-#define HUP_BATTERY_SYSTEM 0x0085
-#define HUP_BARCODE_SCANNER 0x008b
-#define HUP_SCALE 0x008c
-#define HUP_CAMERA_CONTROL 0x0090
-#define HUP_ARCADE 0x0091
-#define HUP_MICROSOFT 0xff00
-
-/* Usages, generic desktop */
-#define HUG_POINTER 0x0001
-#define HUG_MOUSE 0x0002
-#define HUG_JOYSTICK 0x0004
-#define HUG_GAME_PAD 0x0005
-#define HUG_KEYBOARD 0x0006
-#define HUG_KEYPAD 0x0007
-#define HUG_X 0x0030
-#define HUG_Y 0x0031
-#define HUG_Z 0x0032
-#define HUG_RX 0x0033
-#define HUG_RY 0x0034
-#define HUG_RZ 0x0035
-#define HUG_SLIDER 0x0036
-#define HUG_DIAL 0x0037
-#define HUG_WHEEL 0x0038
-#define HUG_HAT_SWITCH 0x0039
-#define HUG_COUNTED_BUFFER 0x003a
-#define HUG_BYTE_COUNT 0x003b
-#define HUG_MOTION_WAKEUP 0x003c
-#define HUG_VX 0x0040
-#define HUG_VY 0x0041
-#define HUG_VZ 0x0042
-#define HUG_VBRX 0x0043
-#define HUG_VBRY 0x0044
-#define HUG_VBRZ 0x0045
-#define HUG_VNO 0x0046
-#define HUG_TWHEEL 0x0048 /* M$ Wireless Intellimouse Wheel */
-#define HUG_SYSTEM_CONTROL 0x0080
-#define HUG_SYSTEM_POWER_DOWN 0x0081
-#define HUG_SYSTEM_SLEEP 0x0082
-#define HUG_SYSTEM_WAKEUP 0x0083
-#define HUG_SYSTEM_CONTEXT_MENU 0x0084
-#define HUG_SYSTEM_MAIN_MENU 0x0085
-#define HUG_SYSTEM_APP_MENU 0x0086
-#define HUG_SYSTEM_MENU_HELP 0x0087
-#define HUG_SYSTEM_MENU_EXIT 0x0088
-#define HUG_SYSTEM_MENU_SELECT 0x0089
-#define HUG_SYSTEM_MENU_RIGHT 0x008a
-#define HUG_SYSTEM_MENU_LEFT 0x008b
-#define HUG_SYSTEM_MENU_UP 0x008c
-#define HUG_SYSTEM_MENU_DOWN 0x008d
-#define HUG_APPLE_EJECT 0x00b8
-
-/* Usages Digitizers */
-#define HUD_UNDEFINED 0x0000
-#define HUD_DIGITIZER 0x0001
-#define HUD_PEN 0x0002
-#define HUD_TOUCHSCREEN 0x0004
-#define HUD_TOUCHPAD 0x0005
-#define HUD_CONFIG 0x000e
-#define HUD_FINGER 0x0022
-#define HUD_TIP_PRESSURE 0x0030
-#define HUD_BARREL_PRESSURE 0x0031
-#define HUD_IN_RANGE 0x0032
-#define HUD_TOUCH 0x0033
-#define HUD_UNTOUCH 0x0034
-#define HUD_TAP 0x0035
-#define HUD_QUALITY 0x0036
-#define HUD_DATA_VALID 0x0037
-#define HUD_TRANSDUCER_INDEX 0x0038
-#define HUD_TABLET_FKEYS 0x0039
-#define HUD_PROGRAM_CHANGE_KEYS 0x003a
-#define HUD_BATTERY_STRENGTH 0x003b
-#define HUD_INVERT 0x003c
-#define HUD_X_TILT 0x003d
-#define HUD_Y_TILT 0x003e
-#define HUD_AZIMUTH 0x003f
-#define HUD_ALTITUDE 0x0040
-#define HUD_TWIST 0x0041
-#define HUD_TIP_SWITCH 0x0042
-#define HUD_SEC_TIP_SWITCH 0x0043
-#define HUD_BARREL_SWITCH 0x0044
-#define HUD_ERASER 0x0045
-#define HUD_TABLET_PICK 0x0046
-#define HUD_CONFIDENCE 0x0047
-#define HUD_WIDTH 0x0048
-#define HUD_HEIGHT 0x0049
-#define HUD_CONTACTID 0x0051
-#define HUD_INPUT_MODE 0x0052
-#define HUD_DEVICE_INDEX 0x0053
-#define HUD_CONTACTCOUNT 0x0054
-#define HUD_CONTACT_MAX 0x0055
-#define HUD_SCAN_TIME 0x0056
-#define HUD_SURFACE_SWITCH 0x0057
-#define HUD_BUTTONS_SWITCH 0x0058
-#define HUD_BUTTON_TYPE 0x0059
-#define HUD_LATENCY_MODE 0x0060
-
-/* Usages, Consumer */
-#define HUC_AC_PAN 0x0238
-
-#define HID_USAGE2(p,u) (((p) << 16) | (u))
-
-#define UHID_INPUT_REPORT 0x01
-#define UHID_OUTPUT_REPORT 0x02
-#define UHID_FEATURE_REPORT 0x03
-
-/* Bits in the input/output/feature items */
-#define HIO_CONST 0x001
-#define HIO_VARIABLE 0x002
-#define HIO_RELATIVE 0x004
-#define HIO_WRAP 0x008
-#define HIO_NONLINEAR 0x010
-#define HIO_NOPREF 0x020
-#define HIO_NULLSTATE 0x040
-#define HIO_VOLATILE 0x080
-#define HIO_BUFBYTES 0x100
-
-/* Units of Measure */
-#define HUM_CENTIMETER 0x11
-#define HUM_RADIAN 0x12
-#define HUM_INCH 0x13
-#define HUM_DEGREE 0x14
+#define UHID_INPUT_REPORT HID_INPUT_REPORT
+#define UHID_OUTPUT_REPORT HID_OUTPUT_REPORT
+#define UHID_FEATURE_REPORT HID_FEATURE_REPORT
#if defined(_KERNEL) || defined(_STANDALONE)
struct usb_config_descriptor;
-enum hid_kind {
- hid_input, hid_output, hid_feature, hid_collection, hid_endcollection
-};
-
-struct hid_location {
- uint32_t size;
- uint32_t count;
- uint32_t pos;
-};
-
-struct hid_item {
- /* Global */
- int32_t _usage_page;
- int32_t logical_minimum;
- int32_t logical_maximum;
- int32_t physical_minimum;
- int32_t physical_maximum;
- int32_t unit_exponent;
- int32_t unit;
- int32_t report_ID;
- /* Local */
- int32_t usage;
- int32_t usage_minimum;
- int32_t usage_maximum;
- int32_t designator_index;
- int32_t designator_minimum;
- int32_t designator_maximum;
- int32_t string_index;
- int32_t string_minimum;
- int32_t string_maximum;
- int32_t set_delimiter;
- /* Misc */
- int32_t collection;
- int collevel;
- enum hid_kind kind;
- uint32_t flags;
- /* Location */
- struct hid_location loc;
-};
-
-/* prototypes from "usb_hid.c" */
+/* FreeBSD <= 12 compat shims */
+#define hid_report_size(buf, len, kind, id) \
+ hid_report_size_max(buf, len, kind, id)
+static __inline uint32_t
+hid_get_data_unsigned(const uint8_t *buf, hid_size_t len,
+ struct hid_location *loc)
+{
+ return (hid_get_udata(buf, len, loc));
+}
-struct hid_data *hid_start_parse(const void *d, usb_size_t len, int kindset);
-void hid_end_parse(struct hid_data *s);
-int hid_get_item(struct hid_data *s, struct hid_item *h);
-int hid_report_size(const void *buf, usb_size_t len, enum hid_kind k,
- uint8_t *id);
-int hid_locate(const void *desc, usb_size_t size, int32_t usage,
- enum hid_kind kind, uint8_t index, struct hid_location *loc,
- uint32_t *flags, uint8_t *id);
-int32_t hid_get_data(const uint8_t *buf, usb_size_t len,
- struct hid_location *loc);
-uint32_t hid_get_data_unsigned(const uint8_t *buf, usb_size_t len,
- struct hid_location *loc);
-void hid_put_data_unsigned(uint8_t *buf, usb_size_t len,
- struct hid_location *loc, unsigned int value);
-int hid_is_collection(const void *desc, usb_size_t size, int32_t usage);
struct usb_hid_descriptor *hid_get_descriptor_from_usb(
struct usb_config_descriptor *cd,
struct usb_interface_descriptor *id);
usb_error_t usbd_req_get_hid_desc(struct usb_device *udev, struct mtx *mtx,
void **descp, uint16_t *sizep, struct malloc_type *mem,
uint8_t iface_index);
-int32_t hid_item_resolution(struct hid_item *hi);
-int hid_is_mouse(const void *d_ptr, uint16_t d_len);
-int hid_is_keyboard(const void *d_ptr, uint16_t d_len);
#endif /* _KERNEL || _STANDALONE */
#endif /* _USB_HID_H_ */
diff --git a/sys/i386/conf/GENERIC b/sys/i386/conf/GENERIC
--- a/sys/i386/conf/GENERIC
+++ b/sys/i386/conf/GENERIC
@@ -348,3 +348,12 @@
options EVDEV_SUPPORT # evdev support in legacy drivers
device evdev # input event device support
device uinput # install /dev/uinput cdev
+
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
+options IICHID_DEBUG # enable debug msgs for I2C transport
+options IICHID_SAMPLING # Workaround missing GPIO INTR support
+#device usbhid # USB transport support.
+#device hidbus # HID bus (required by usbhid/iichid)
+#options USBHID_ENABLED # Prefer usbhid to other USB drivers
diff --git a/sys/libkern/strcasestr.c b/sys/libkern/strcasestr.c
new file mode 100644
--- /dev/null
+++ b/sys/libkern/strcasestr.c
@@ -0,0 +1,68 @@
+/*-
+ * SPDX-License-Identifier: BSD-3-Clause
+ *
+ * Copyright (c) 1990, 1993
+ * The Regents of the University of California. All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Chris Torek.
+ *
+ * Copyright (c) 2011 The FreeBSD Foundation
+ * All rights reserved.
+ * Portions of this software were developed by David Chisnall
+ * under sponsorship from the FreeBSD Foundation.
+ *
+ * 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.
+ * 3. Neither the name of the University nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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 <sys/cdefs.h>
+__FBSDID("$FreeBSD$");
+
+#include <sys/param.h>
+#include <sys/ctype.h>
+#include <sys/libkern.h>
+
+/*
+ * Find the first occurrence of find in s, ignore case.
+ */
+char *
+strcasestr(const char *s, const char *find)
+{
+ char c, sc;
+ size_t len;
+
+ if ((c = *find++) != 0) {
+ c = tolower((unsigned char)c);
+ len = strlen(find);
+ do {
+ do {
+ if ((sc = *s++) == 0)
+ return (NULL);
+ } while ((char)tolower((unsigned char)sc) != c);
+ } while (strncasecmp(s, find, len) != 0);
+ s--;
+ }
+ return (__DECONST(char *, s));
+}
diff --git a/sys/mips/conf/ERL b/sys/mips/conf/ERL
--- a/sys/mips/conf/ERL
+++ b/sys/mips/conf/ERL
@@ -212,3 +212,7 @@
# PMC support
#device hwpmc
+
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
diff --git a/sys/mips/conf/JZ4780 b/sys/mips/conf/JZ4780
--- a/sys/mips/conf/JZ4780
+++ b/sys/mips/conf/JZ4780
@@ -109,5 +109,9 @@
device umass # Disks/Mass storage - Requires scbus and da
device ums # Mouse
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
+
# FDT support
options FDT
diff --git a/sys/mips/conf/OCTEON1 b/sys/mips/conf/OCTEON1
--- a/sys/mips/conf/OCTEON1
+++ b/sys/mips/conf/OCTEON1
@@ -237,3 +237,7 @@
# PMC support
#device hwpmc
+
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
diff --git a/sys/modules/Makefile b/sys/modules/Makefile
--- a/sys/modules/Makefile
+++ b/sys/modules/Makefile
@@ -129,6 +129,7 @@
${_glxiic} \
${_glxsb} \
gpio \
+ hid \
hifn \
${_hpt27xx} \
${_hptiop} \
diff --git a/sys/modules/hid/Makefile b/sys/modules/hid/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/Makefile
@@ -0,0 +1,22 @@
+# $FreeBSD$
+
+SUBDIR = \
+ hid \
+ hidbus \
+ hidmap \
+ hidquirk \
+ hidraw
+
+SUBDIR += \
+ hconf \
+ hcons \
+ hgame \
+ hkbd \
+ hms \
+ hmt \
+ hpen \
+ hsctrl \
+ ps4dshock \
+ xb360gp
+
+.include <bsd.subdir.mk>
diff --git a/sys/modules/hid/hconf/Makefile b/sys/modules/hid/hconf/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/hconf/Makefile
@@ -0,0 +1,9 @@
+# $FreeBSD$
+
+.PATH: ${SRCTOP}/sys/dev/hid
+
+KMOD= hconf
+SRCS= hconf.c
+SRCS+= bus_if.h device_if.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/hid/hcons/Makefile b/sys/modules/hid/hcons/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/hcons/Makefile
@@ -0,0 +1,9 @@
+# $FreeBSD$
+
+.PATH: ${SRCTOP}/sys/dev/hid
+
+KMOD= hcons
+SRCS= hcons.c
+SRCS+= bus_if.h device_if.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/hid/hgame/Makefile b/sys/modules/hid/hgame/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/hgame/Makefile
@@ -0,0 +1,9 @@
+# $FreeBSD$
+
+.PATH: ${SRCTOP}/sys/dev/hid
+
+KMOD= hgame
+SRCS= hgame.c
+SRCS+= bus_if.h device_if.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/hid/hid/Makefile b/sys/modules/hid/hid/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/hid/Makefile
@@ -0,0 +1,10 @@
+# $FreeBSD$
+
+.PATH: ${SRCTOP}/sys/dev/hid
+
+KMOD= hid
+SRCS= hid.c hid_if.c
+SRCS+= opt_hid.h
+SRCS+= bus_if.h device_if.h hid_if.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/hid/hidbus/Makefile b/sys/modules/hid/hidbus/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/hidbus/Makefile
@@ -0,0 +1,9 @@
+# $FreeBSD$
+
+.PATH: ${SRCTOP}/sys/dev/hid
+
+KMOD= hidbus
+SRCS= hidbus.c
+SRCS+= bus_if.h device_if.h hid_if.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/hid/hidmap/Makefile b/sys/modules/hid/hidmap/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/hidmap/Makefile
@@ -0,0 +1,9 @@
+# $FreeBSD$
+
+.PATH: ${SRCTOP}/sys/dev/hid
+
+KMOD= hidmap
+SRCS= hidmap.c
+SRCS+= bus_if.h device_if.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/hid/hidquirk/Makefile b/sys/modules/hid/hidquirk/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/hidquirk/Makefile
@@ -0,0 +1,34 @@
+#
+# Copyright (c) 2020 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.
+#
+# $FreeBSD$
+#
+
+.PATH: ${SRCTOP}/sys/dev/hid
+
+KMOD= hidquirk
+SRCS= hidquirk.c
+SRCS+= bus_if.h device_if.h usbdevs.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/hid/hidraw/Makefile b/sys/modules/hid/hidraw/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/hidraw/Makefile
@@ -0,0 +1,9 @@
+# $FreeBSD$
+
+.PATH: ${SRCTOP}/sys/dev/hid
+
+KMOD= hidraw
+SRCS= hidraw.c
+SRCS+= opt_hid.h bus_if.h device_if.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/hid/hkbd/Makefile b/sys/modules/hid/hkbd/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/hkbd/Makefile
@@ -0,0 +1,10 @@
+# $FreeBSD$
+
+.PATH: ${SRCTOP}/sys/dev/hid
+
+KMOD= hkbd
+SRCS= hkbd.c
+SRCS+= opt_evdev.h opt_kbd.h opt_hkbd.h
+SRCS+= bus_if.h device_if.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/hid/hms/Makefile b/sys/modules/hid/hms/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/hms/Makefile
@@ -0,0 +1,9 @@
+# $FreeBSD$
+
+.PATH: ${SRCTOP}/sys/dev/hid
+
+KMOD= hms
+SRCS= hms.c
+SRCS+= bus_if.h device_if.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/hid/hmt/Makefile b/sys/modules/hid/hmt/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/hmt/Makefile
@@ -0,0 +1,9 @@
+# $FreeBSD$
+
+.PATH: ${SRCTOP}/sys/dev/hid
+
+KMOD= hmt
+SRCS= hmt.c
+SRCS+= bus_if.h device_if.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/hid/hpen/Makefile b/sys/modules/hid/hpen/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/hpen/Makefile
@@ -0,0 +1,9 @@
+# $FreeBSD$
+
+.PATH: ${SRCTOP}/sys/dev/hid
+
+KMOD= hpen
+SRCS= hpen.c
+SRCS+= bus_if.h device_if.h usbdevs.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/hid/hsctrl/Makefile b/sys/modules/hid/hsctrl/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/hsctrl/Makefile
@@ -0,0 +1,9 @@
+# $FreeBSD$
+
+.PATH: ${SRCTOP}/sys/dev/hid
+
+KMOD= hsctrl
+SRCS= hsctrl.c
+SRCS+= bus_if.h device_if.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/hid/ps4dshock/Makefile b/sys/modules/hid/ps4dshock/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/ps4dshock/Makefile
@@ -0,0 +1,9 @@
+# $FreeBSD$
+
+.PATH: ${SRCTOP}/sys/dev/hid
+
+KMOD= ps4dshock
+SRCS= ps4dshock.c
+SRCS+= bus_if.h device_if.h usbdevs.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/hid/xb360gp/Makefile b/sys/modules/hid/xb360gp/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/hid/xb360gp/Makefile
@@ -0,0 +1,9 @@
+# $FreeBSD$
+
+.PATH: ${SRCTOP}/sys/dev/hid
+
+KMOD= xb360gp
+SRCS= xb360gp.c
+SRCS+= bus_if.h device_if.h opt_usb.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/i2c/Makefile b/sys/modules/i2c/Makefile
--- a/sys/modules/i2c/Makefile
+++ b/sys/modules/i2c/Makefile
@@ -29,4 +29,9 @@
rx8803
.endif
+.if ${MACHINE_CPUARCH} == "aarch64" || ${MACHINE_CPUARCH} == "amd64" || \
+ ${MACHINE_CPUARCH} == "i386"
+SUBDIR += iichid
+.endif
+
.include <bsd.subdir.mk>
diff --git a/sys/modules/i2c/iichid/Makefile b/sys/modules/i2c/iichid/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/i2c/iichid/Makefile
@@ -0,0 +1,8 @@
+# $FreeBSD$
+
+.PATH: ${SRCTOP}/sys/dev/iicbus
+KMOD = iichid
+SRCS = iichid.c
+SRCS += acpi_if.h bus_if.h device_if.h hid_if.h iicbus_if.h opt_hid.h
+
+.include <bsd.kmod.mk>
diff --git a/sys/modules/usb/Makefile b/sys/modules/usb/Makefile
--- a/sys/modules/usb/Makefile
+++ b/sys/modules/usb/Makefile
@@ -47,7 +47,8 @@
SUBDIR += ${_dwc_otg} ehci ${_musb} ohci uhci xhci ${_uss820dci} \
${_atmegadci} ${_avr32dci} ${_rsu} ${_rsufw} ${_saf1761otg}
SUBDIR += ${_rum} ${_run} ${_runfw} ${_uath} upgt usie ural ${_zyd} ${_urtw}
-SUBDIR += atp cfumass uhid uhid_snes ukbd ums udbp uep wmt wsp ugold uled
+SUBDIR += atp cfumass uhid uhid_snes ukbd ums udbp uep wmt wsp ugold uled \
+ usbhid
SUBDIR += ucom u3g uark ubsa ubser uchcom ucycom ufoma uftdi ugensa uipaq ulpt \
umct umcs umodem umoscom uplcom uslcom uvisor uvscom
SUBDIR += cp2112
diff --git a/sys/modules/usb/uhid/Makefile b/sys/modules/usb/uhid/Makefile
--- a/sys/modules/usb/uhid/Makefile
+++ b/sys/modules/usb/uhid/Makefile
@@ -30,7 +30,7 @@
.PATH: $S/dev/usb/input
KMOD= uhid
-SRCS= opt_bus.h opt_usb.h device_if.h bus_if.h usb_if.h vnode_if.h usbdevs.h \
- uhid.c
+SRCS= opt_bus.h opt_hid.h opt_usb.h device_if.h bus_if.h usb_if.h \
+ vnode_if.h usbdevs.h uhid.c
.include <bsd.kmod.mk>
diff --git a/sys/modules/usb/usbhid/Makefile b/sys/modules/usb/usbhid/Makefile
new file mode 100644
--- /dev/null
+++ b/sys/modules/usb/usbhid/Makefile
@@ -0,0 +1,10 @@
+# $FreeBSD$
+
+S= ${SRCTOP}/sys
+
+.PATH: $S/dev/usb/input
+
+KMOD= usbhid
+SRCS= opt_usb.h bus_if.h device_if.h hid_if.h usb_if.h usbhid.c
+
+.include <bsd.kmod.mk>
diff --git a/sys/powerpc/conf/GENERIC b/sys/powerpc/conf/GENERIC
--- a/sys/powerpc/conf/GENERIC
+++ b/sys/powerpc/conf/GENERIC
@@ -240,3 +240,6 @@
device virtio_scsi # VirtIO SCSI device
device virtio_balloon # VirtIO Memory Balloon device
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
diff --git a/sys/powerpc/conf/GENERIC64 b/sys/powerpc/conf/GENERIC64
--- a/sys/powerpc/conf/GENERIC64
+++ b/sys/powerpc/conf/GENERIC64
@@ -270,3 +270,6 @@
device virtio_scsi # VirtIO SCSI device
device virtio_balloon # VirtIO Memory Balloon device
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
diff --git a/sys/powerpc/conf/GENERIC64LE b/sys/powerpc/conf/GENERIC64LE
--- a/sys/powerpc/conf/GENERIC64LE
+++ b/sys/powerpc/conf/GENERIC64LE
@@ -251,3 +251,6 @@
device virtio_scsi # VirtIO SCSI device
device virtio_balloon # VirtIO Memory Balloon device
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
diff --git a/sys/powerpc/conf/MPC85XX b/sys/powerpc/conf/MPC85XX
--- a/sys/powerpc/conf/MPC85XX
+++ b/sys/powerpc/conf/MPC85XX
@@ -117,3 +117,7 @@
device videomode
device vt
device fbd
+
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
diff --git a/sys/powerpc/conf/MPC85XXSPE b/sys/powerpc/conf/MPC85XXSPE
--- a/sys/powerpc/conf/MPC85XXSPE
+++ b/sys/powerpc/conf/MPC85XXSPE
@@ -118,3 +118,7 @@
device videomode
device vt
device fbd
+
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
diff --git a/sys/powerpc/conf/QORIQ64 b/sys/powerpc/conf/QORIQ64
--- a/sys/powerpc/conf/QORIQ64
+++ b/sys/powerpc/conf/QORIQ64
@@ -120,3 +120,7 @@
options KBD_INSTALL_CDEV
device ukbd
device ums
+
+# HID support
+options HID_DEBUG # enable debug msgs
+device hid # Generic HID support
diff --git a/sys/sys/libkern.h b/sys/sys/libkern.h
--- a/sys/sys/libkern.h
+++ b/sys/sys/libkern.h
@@ -168,6 +168,7 @@
u_long random(void);
int scanc(u_int, const u_char *, const u_char *, int);
int strcasecmp(const char *, const char *);
+char *strcasestr(const char *, const char *);
char *strcat(char * __restrict, const char * __restrict);
char *strchr(const char *, int);
char *strchrnul(const char *, int);

File Metadata

Mime Type
text/plain
Expires
Sat, Feb 22, 11:10 AM (1 h, 59 m)
Storage Engine
blob
Storage Format
Raw Data
Storage Handle
16770177
Default Alt Text
D27777.id81194.diff (548 KB)

Event Timeline