program to manipulate USB HID devices

from NetBSD, reviewed by jakob

3 files changed, 954 insertions, 0 deletions

diff --git a/usr.bin/usbhidctl/Makefile b/usr.bin/usbhidctl/Makefile
new file mode 100644
index 00000000000..9fe0245bd5b
--- /dev/null
+++ b/usr.bin/usbhidctl/Makefile
@@ -0,0 +1,10 @@
+#	$OpenBSD: Makefile,v 1.1 2001/09/02 17:55:29 pvalchev Exp $
+#	$NetBSD: Makefile,v 1.4 1999/05/11 21:02:25 augustss Exp $
+
+PROG=	usbhidctl
+SRCS=	usbhid.c
+
+LDADD+=	-lusb
+DPADD+=	${LIBUSB}
+
+.include <bsd.prog.mk>
diff --git a/usr.bin/usbhidctl/usbhid.c b/usr.bin/usbhidctl/usbhid.c
new file mode 100644
index 00000000000..768ce6fa40a
--- /dev/null
+++ b/usr.bin/usbhidctl/usbhid.c
@@ -0,0 +1,822 @@
+/*	$OpenBSD: usbhid.c,v 1.1 2001/09/02 17:55:29 pvalchev Exp $	*/
+/*      $NetBSD: usbhid.c,v 1.17 2001/03/28 03:17:42 simonb Exp $ */
+
+/*
+ * Copyright (c) 2000 The NetBSD Foundation, Inc.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to The NetBSD Foundation
+ * by David Sainty <David.Sainty@dtsp.co.nz>
+ *
+ * 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. All advertising materials mentioning features or use of this software
+ *    must display the following acknowledgement:
+ *        This product includes software developed by the NetBSD
+ *        Foundation, Inc. and its contributors.
+ * 4. Neither the name of The NetBSD Foundation 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 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/types.h>
+
+#include <dev/usb/usb.h>
+#include <dev/usb/usbhid.h>
+
+#include <ctype.h>
+#include <err.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <usb.h>
+
+/* Parser tokens */
+#define DELIM_USAGE '.'
+#define DELIM_PAGE ':'
+#define DELIM_SET '='
+
+/* Zero if not in a verbose mode.  Greater levels of verbosity are
+   indicated by values larger than one. */
+static unsigned int verbose;
+
+struct Susbvar {
+	/* Variable name, not NUL terminated */
+	char const *variable;
+	size_t varlen;
+
+	char const *value; /* Value to set variable to */
+
+#define MATCH_ALL		(1 << 0)
+#define MATCH_COLLECTIONS	(1 << 1)
+#define MATCH_NODATA		(1 << 2)
+#define MATCH_CONSTANTS		(1 << 3)
+#define MATCH_WASMATCHED	(1 << 4)
+#define MATCH_SHOWPAGENAME	(1 << 5)
+#define MATCH_SHOWNUMERIC	(1 << 6)
+#define MATCH_WRITABLE		(1 << 7)
+	unsigned int mflags;
+
+	/* Workspace for hidmatch() */
+	ssize_t matchindex;
+
+	int (*opfunc)(struct hid_item *item, struct Susbvar *var,
+		      u_int32_t const *collist, size_t collen, u_char *buf);
+};
+
+struct Sreport {
+	struct usb_ctl_report *buffer;
+
+	enum {srs_uninit, srs_clean, srs_dirty} status;
+	int report_id;
+	size_t size;
+};
+
+static struct {
+	int uhid_report;
+	hid_kind_t hid_kind;
+	char const *name;
+} const reptoparam[] = {
+#define REPORT_INPUT 0
+	{ UHID_INPUT_REPORT, hid_input, "input" },
+#define REPORT_OUTPUT 1
+	{ UHID_OUTPUT_REPORT, hid_output, "output" },
+#define REPORT_FEATURE 2
+	{ UHID_FEATURE_REPORT, hid_feature, "feature" }
+#define REPORT_MAXVAL 2
+};
+
+static struct Susbvar*
+hidmatch(u_int32_t const *collist, size_t collen, struct hid_item *item,
+	 struct Susbvar *varlist, size_t vlsize)
+{
+	size_t vlind, colind, vlactive;
+	int iscollection;
+
+	/*
+	 * Keep track of how many variables are still "active".  When
+	 * the active count reaches zero, don't bother to continue
+	 * looking for matches.
+	 */
+	vlactive = vlsize;
+
+	iscollection = item->kind == hid_collection ||
+		item->kind == hid_endcollection;
+
+	for (vlind = 0; vlind < vlsize; vlind++) {
+		struct Susbvar *var;
+
+		var = &varlist[vlind];
+
+		var->matchindex = 0;
+
+		if (!(var->mflags & MATCH_COLLECTIONS) && iscollection) {
+			/* Don't match collections for this variable */
+			var->matchindex = -1;
+			vlactive--;
+		} else if (!iscollection && !(var->mflags & MATCH_CONSTANTS) &&
+			   (item->flags & HIO_CONST)) {
+			/*
+			 * Don't match constants for this variable,
+			 * but ignore the constant bit on collections.
+			 */
+			var->matchindex = -1;
+			vlactive--;
+		} else if ((var->mflags & MATCH_WRITABLE) &&
+			   ((item->kind != hid_output &&
+			     item->kind != hid_feature) ||
+			    (item->flags & HIO_CONST))) {
+			/*
+			 * If we are only matching writable items, if
+			 * this is not an output or feature kind, or
+			 * it is a constant, reject it.
+			 */
+			var->matchindex = -1;
+			vlactive--;
+		} else if (var->mflags & MATCH_ALL) {
+			/* Match immediately */
+			return &varlist[vlind];
+		}
+	}
+
+	for (colind = 0; vlactive > 0 && colind <= collen; colind++) {
+		char const *usage_name, *page_name;
+		size_t usage_len, page_len;
+		int final;
+		u_int32_t usage_id;
+
+		final = (colind == collen);
+
+		if (final)
+			usage_id = item->usage;
+		else
+			usage_id = collist[colind];
+
+		usage_name = hid_usage_in_page(usage_id);
+		usage_len = strlen(usage_name);
+
+		page_name = NULL;
+
+		for (vlind = 0; vlind < vlsize; vlind++) {
+			ssize_t matchindex, pagesplit;
+			size_t varlen, strind;
+			char const *varname;
+			struct Susbvar *var;
+
+			var = &varlist[vlind];
+
+			matchindex = var->matchindex;
+			varname = var->variable;
+			varlen = var->varlen;
+
+			if (matchindex < 0)
+				/* Mismatch at a previous level */
+				continue;
+
+			pagesplit = -1;
+			for (strind = matchindex; strind < varlen; strind++) {
+				if (varname[strind] == DELIM_USAGE)
+					break;
+				if (varname[strind] == DELIM_PAGE)
+					pagesplit = strind;
+			}
+
+			if (final && strind != varlen) {
+				/*
+				 * Variable name is too long (hit
+				 * delimiter instead of
+				 * end-of-variable)
+				 */
+				var->matchindex = -1;
+				vlactive--;
+				continue;
+			}
+
+			if (pagesplit >= 0) {
+				if (page_name == NULL) {
+					page_name = hid_usage_page(HID_PAGE(usage_id));
+					page_len = strlen(page_name);
+				}
+				if (page_len !=
+				    (size_t)(pagesplit - matchindex) ||
+				    memcmp(page_name, &varname[matchindex],
+					   page_len) != 0) {
+					/* Mismatch, page name wrong */
+					var->matchindex = -1;
+					vlactive--;
+					continue;
+				}
+
+				/* Page matches, discard page name */
+				matchindex = pagesplit + 1;
+			}
+
+			if (usage_len != strind - matchindex ||
+			    memcmp(usage_name, &varname[matchindex],
+				   usage_len) != 0) {
+				/* Mismatch, usage name wrong */
+				var->matchindex = -1;
+				vlactive--;
+				continue;
+			}
+
+			if (final)
+				/* Match */
+				return var;
+
+			/*
+			 * Partial match: Move index past this usage
+			 * string + delimiter
+			 */
+			var->matchindex = matchindex + usage_len + 1;
+		}
+	}
+
+	return NULL;
+}
+
+static void
+allocreport(struct Sreport *report, report_desc_t rd, int repindex)
+{
+	int reptsize;
+
+	reptsize = hid_report_size(rd, reptoparam[repindex].hid_kind,
+				   &report->report_id);
+	if (reptsize < 0)
+		errx(1, "Negative report size");
+	report->size = reptsize;
+
+	if (report->size > 0) {
+		/*
+		 * Allocate a buffer with enough space for the
+		 * report in the variable-sized data field.
+		 */
+		report->buffer = malloc(sizeof(*report->buffer) -
+					sizeof(report->buffer->data) +
+					report->size);
+		if (report->buffer == NULL)
+			err(1, NULL);
+	} else
+		report->buffer = NULL;
+
+	report->status = srs_clean;
+}
+
+static void
+freereport(struct Sreport *report)
+{
+	if (report->buffer != NULL)
+		free(report->buffer);
+	report->status = srs_uninit;
+}
+
+static void
+getreport(struct Sreport *report, int hidfd, report_desc_t rd, int repindex)
+{
+	if (report->status == srs_uninit) {
+		allocreport(report, rd, repindex);
+		if (report->size == 0)
+			return;
+
+		report->buffer->report = reptoparam[repindex].uhid_report;
+		if (ioctl(hidfd, USB_GET_REPORT, report->buffer) < 0)
+			err(1, "USB_GET_REPORT");
+	}
+}
+
+static void
+setreport(struct Sreport *report, int hidfd, int repindex)
+{
+	if (report->status == srs_dirty) {
+		report->buffer->report = reptoparam[repindex].uhid_report;
+
+		if (ioctl(hidfd, USB_SET_REPORT, report->buffer) < 0)
+			err(1, "USB_SET_REPORT(%s)",
+			    reptoparam[repindex].name);
+
+		report->status = srs_clean;
+	}
+}
+
+/* ARGSUSED1 */
+static int
+varop_value(struct hid_item *item, struct Susbvar *var,
+	    u_int32_t const *collist, size_t collen, u_char *buf)
+{
+	printf("%d\n", hid_get_data(buf, item));
+	return 0;
+}
+
+/* ARGSUSED1 */
+static int
+varop_display(struct hid_item *item, struct Susbvar *var,
+	      u_int32_t const *collist, size_t collen, u_char *buf)
+{
+	size_t colitem;
+
+	for (colitem = 0; colitem < collen; colitem++) {
+		if (var->mflags & MATCH_SHOWPAGENAME)
+			printf("%s:",
+			       hid_usage_page(HID_PAGE(collist[colitem])));
+		printf("%s.", hid_usage_in_page(collist[colitem]));
+	}
+
+	if (var->mflags & MATCH_SHOWPAGENAME)
+		printf("%s:", hid_usage_page(HID_PAGE(item->usage)));
+	printf("%s=%d%s\n", hid_usage_in_page(item->usage),
+	       hid_get_data(buf, item),
+	       (item->flags & HIO_CONST) ? " (const)" : "");
+	return 0;
+}
+
+/* ARGSUSED1 */
+static int
+varop_modify(struct hid_item *item, struct Susbvar *var,
+	     u_int32_t const *collist, size_t collen, u_char *buf)
+{
+	u_int dataval;
+
+	dataval = (u_int)strtol(var->value, NULL, 10);
+
+	hid_set_data(buf, item, dataval);
+
+	if (verbose >= 1)
+		/*
+		 * Allow displaying of set value in verbose mode.
+		 * This isn't particularly useful though, so don't
+		 * bother documenting it.
+		 */
+		varop_display(item, var, collist, collen, buf);
+
+	return 1;
+}
+
+static void
+reportitem(char const *label, struct hid_item const *item, unsigned int mflags)
+{
+	printf("%s size=%d count=%d page=%s usage=%s%s", label,
+	       item->report_size, item->report_count,
+	       hid_usage_page(HID_PAGE(item->usage)),
+	       hid_usage_in_page(item->usage),
+	       item->flags & HIO_CONST ? " Const" : "");
+	if (mflags & MATCH_SHOWNUMERIC)
+		printf(" (%u/0x%x)",
+		       HID_PAGE(item->usage), HID_USAGE(item->usage));
+	printf(", logical range %d..%d",
+	       item->logical_minimum, item->logical_maximum);
+	if (item->physical_minimum != item->physical_maximum)
+		printf(", physical range %d..%d",
+		       item->physical_minimum, item->physical_maximum);
+	if (item->unit)
+		printf(", unit=0x%02x exp=%d", item->unit,
+		       item->unit_exponent);
+	printf("\n");
+}
+
+/* ARGSUSED1 */
+static int
+varop_report(struct hid_item *item, struct Susbvar *var,
+	     u_int32_t const *collist, size_t collen, u_char *buf)
+{
+	switch (item->kind) {
+	case hid_collection:
+		printf("Collection page=%s usage=%s\n",
+		       hid_usage_page(HID_PAGE(item->usage)),
+		       hid_usage_in_page(item->usage));
+		break;
+	case hid_endcollection:
+		printf("End collection\n");
+		break;
+	case hid_input:
+		reportitem("Input  ", item, var->mflags);
+		break;
+	case hid_output:
+		reportitem("Output ", item, var->mflags);
+		break;
+	case hid_feature:
+		reportitem("Feature", item, var->mflags);
+		break;
+	}
+
+	return 0;
+}
+
+static void
+devloop(int hidfd, report_desc_t rd, struct Susbvar *varlist, size_t vlsize)
+{
+	struct hid_data *hdata;
+	struct hid_item hitem;
+	u_int32_t colls[128];
+	struct Sreport inreport;
+	size_t dlen;
+	u_char *dbuf;
+	size_t collind;
+
+	allocreport(&inreport, rd, REPORT_INPUT);
+
+	if (inreport.size <= 0)
+		errx(1, "Input report descriptor invalid length");
+
+	dlen = inreport.size;
+	dbuf = inreport.buffer->data;
+
+	for (;;) {
+		ssize_t readlen;
+
+		readlen = read(hidfd, dbuf, dlen);
+		if (readlen < 0 || dlen != (size_t)readlen)
+			err(1, "bad read %ld != %ld",
+			    (long)readlen, (long)dlen);
+
+		collind = 0;
+		hdata = hid_start_parse(rd, 1 << hid_input);
+		if (hdata == NULL)
+			errx(1, "Failed to start parser");
+
+		while (hid_get_item(hdata, &hitem)) {
+			struct Susbvar *matchvar;
+
+			switch (hitem.kind) {
+			case hid_collection:
+				if (collind >= (sizeof(colls) / sizeof(*colls)))
+					errx(1, "Excessive nested collections");
+				colls[collind++] = hitem.usage;
+				break;
+			case hid_endcollection:
+				if (collind == 0)
+					errx(1, "Excessive collection ends");
+				collind--;
+				break;
+			case hid_input:
+				break;
+			case hid_output:
+			case hid_feature:
+				errx(1, "Unexpected non-input item returned");
+			}
+
+			matchvar = hidmatch(colls, collind, &hitem,
+					    varlist, vlsize);
+
+			if (matchvar != NULL)
+				matchvar->opfunc(&hitem, matchvar,
+						 colls, collind,
+						 inreport.buffer->data);
+		}
+		hid_end_parse(hdata);
+		printf("\n");
+	}
+	/* NOTREACHED */
+}
+
+static void
+devshow(int hidfd, report_desc_t rd, struct Susbvar *varlist, size_t vlsize,
+	int kindset)
+{
+	struct hid_data *hdata;
+	struct hid_item hitem;
+	u_int32_t colls[128];
+	size_t collind, repind, vlind;
+
+	struct Sreport reports[REPORT_MAXVAL + 1];
+
+
+	for (repind = 0; repind < (sizeof(reports) / sizeof(*reports));
+	     repind++) {
+		reports[repind].status = srs_uninit;
+		reports[repind].buffer = NULL;
+	}
+
+	collind = 0;
+	hdata = hid_start_parse(rd, kindset |
+				(1 << hid_collection) |
+				(1 << hid_endcollection));
+	if (hdata == NULL)
+		errx(1, "Failed to start parser");
+
+	while (hid_get_item(hdata, &hitem)) {
+		struct Susbvar *matchvar;
+		int repindex;
+
+		repindex = -1;
+		switch (hitem.kind) {
+		case hid_collection:
+			if (collind >= (sizeof(colls) / sizeof(*colls)))
+				errx(1, "Excessive nested collections");
+			colls[collind++] = hitem.usage;
+			break;
+		case hid_endcollection:
+			if (collind == 0)
+				errx(1, "Excessive collection ends");
+			collind--;
+			break;
+		case hid_input:
+			repindex = REPORT_INPUT;
+			break;
+		case hid_output:
+			repindex = REPORT_OUTPUT;
+			break;
+		case hid_feature:
+			repindex = REPORT_FEATURE;
+			break;
+		}
+
+		matchvar = hidmatch(colls, collind, &hitem, varlist, vlsize);
+
+		if (matchvar != NULL) {
+			u_char *bufdata;
+			struct Sreport *repptr;
+
+			matchvar->mflags |= MATCH_WASMATCHED;
+
+			if (repindex >= 0)
+				repptr = &reports[repindex];
+			else
+				repptr = NULL;
+
+			if (repptr != NULL &&
+			    !(matchvar->mflags & MATCH_NODATA))
+				getreport(repptr, hidfd, rd, repindex);
+
+			bufdata = (repptr == NULL || repptr->buffer == NULL) ?
+				NULL : repptr->buffer->data;
+
+			if (matchvar->opfunc(&hitem, matchvar, colls, collind,
+					     bufdata))
+				repptr->status = srs_dirty;
+		}
+	}
+	hid_end_parse(hdata);
+
+	for (repind = 0; repind < (sizeof(reports) / sizeof(*reports));
+	     repind++) {
+		setreport(&reports[repind], hidfd, repind);
+		freereport(&reports[repind]);
+	}
+
+	/* Warn about any items that we couldn't find a match for */
+	for (vlind = 0; vlind < vlsize; vlind++) {
+		struct Susbvar *var;
+
+		var = &varlist[vlind];
+
+		if (var->variable != NULL &&
+		    !(var->mflags & MATCH_WASMATCHED))
+			warnx("Failed to match: %.*s", (int)var->varlen,
+			      var->variable);
+	}
+}
+
+static void
+usage(void)
+{
+	extern char *__progname;
+
+	fprintf(stderr, "Usage: %s -f device [-t tablefile] [-l] [-v] -a\n",
+	    __progname);
+	fprintf(stderr, "       %s -f device [-t tablefile] [-v] -r\n",
+	    __progname);
+	fprintf(stderr,
+	    "       %s -f device [-t tablefile] [-l] [-n] [-v] name ...\n",
+	    __progname);
+	fprintf(stderr,
+	    "       %s -f device [-t tablefile] -w name=value ...\n",
+	    __progname);
+	exit(1);
+}
+
+int
+main(int argc, char **argv)
+{
+	int hidfd;
+	report_desc_t repdesc;
+	char devnamebuf[PATH_MAX];
+	char const *dev;
+	int ch, wflag, aflag, nflag, rflag, lflag;
+	size_t varnum;
+	char const *table;
+	struct Susbvar variables[128];
+
+	wflag = aflag = nflag = verbose = rflag = lflag = 0;
+	dev = NULL;
+	table = NULL;
+	while ((ch = getopt(argc, argv, "?af:lnrt:vw")) != -1) {
+		switch (ch) {
+		case 'a':
+			aflag = 1;
+			break;
+		case 'f':
+			dev = optarg;
+			break;
+		case 'l':
+			lflag = 1;
+			break;
+		case 'n':
+			nflag = 1;
+			break;
+		case 'r':
+			rflag = 1;
+			break;
+		case 't':
+			table = optarg;
+			break;
+		case 'v':
+			verbose++;
+			break;
+		case 'w':
+			wflag = 1;
+			break;
+		case '?':
+		default:
+			usage();
+			/* NOTREACHED */
+		}
+	}
+	argc -= optind;
+	argv += optind;
+	if (dev == NULL || (lflag && (wflag || rflag))) {
+		/*
+		 * No device specified, or attempting to loop and set
+		 * or dump report at the same time
+		 */
+		usage();
+		/* NOTREACHED */
+	}
+
+	for (varnum = 0; varnum < (size_t)argc; varnum++) {
+		char const *name, *valuesep;
+		struct Susbvar *svar;
+
+		svar = &variables[varnum];
+		name = argv[varnum];
+		valuesep = strchr(name, DELIM_SET);
+
+		svar->variable = name;
+		svar->mflags = 0;
+
+		if (valuesep == NULL) {
+			/* Read variable */
+			if (wflag)
+				errx(1, "Must not specify -w to read variables");
+			svar->value = NULL;
+			svar->varlen = strlen(name);
+
+			if (nflag) {
+				/* Display value of variable only */
+				svar->opfunc = varop_value;
+			} else {
+				/* Display name and value of variable */
+				svar->opfunc = varop_display;
+
+				if (verbose >= 1)
+					/* Show page names in verbose modes */
+					svar->mflags |= MATCH_SHOWPAGENAME;
+			}
+		} else {
+			/* Write variable */
+			if (!wflag)
+				errx(2, "Must specify -w to set variables");
+			svar->mflags |= MATCH_WRITABLE;
+			svar->varlen = valuesep - name;
+			svar->value = valuesep + 1;
+			svar->opfunc = varop_modify;
+		}
+	}
+
+	if (aflag || rflag) {
+		struct Susbvar *svar;
+
+		svar = &variables[varnum++];
+
+		svar->variable = NULL;
+		svar->mflags = MATCH_ALL;
+
+		if (rflag) {
+			/*
+			 * Dump report descriptor.  Do dump collection
+			 * items also, and hint that it won't be
+			 * necessary to get the item status.
+			 */
+			svar->opfunc = varop_report;
+			svar->mflags |= MATCH_COLLECTIONS | MATCH_NODATA;
+
+			switch (verbose) {
+			default:
+				/* Level 2: Show item numerics and constants */
+				svar->mflags |= MATCH_SHOWNUMERIC;
+				/* FALLTHROUGH */
+			case 1:
+				/* Level 1: Just show constants */
+				svar->mflags |= MATCH_CONSTANTS;
+				/* FALLTHROUGH */
+			case 0:
+				break;
+			}
+		} else {
+			/* Display name and value of variable */
+			svar->opfunc = varop_display;
+
+			switch (verbose) {
+			default:
+				/* Level 2: Show constants and page names */
+				svar->mflags |= MATCH_CONSTANTS;
+				/* FALLTHROUGH */
+			case 1:
+				/* Level 1: Just show page names */
+				svar->mflags |= MATCH_SHOWPAGENAME;
+				/* FALLTHROUGH */
+			case 0:
+				break;
+			}
+		}
+	}
+
+	if (varnum == 0) {
+		/* Nothing to do...  Display usage information. */
+		usage();
+		/* NOTREACHED */
+	}
+
+	hid_init(table);
+
+	if (dev[0] != '/') {
+		snprintf(devnamebuf, sizeof(devnamebuf), "/dev/%s%s",
+			 isdigit(dev[0]) ? "uhid" : "", dev);
+		dev = devnamebuf;
+	}
+
+	hidfd = open(dev, O_RDWR);
+	if (hidfd < 0)
+		err(1, "%s", dev);
+
+	repdesc = hid_get_report_desc(hidfd);
+	if (repdesc == 0)
+		errx(1, "USB_GET_REPORT_DESC");
+
+	if (lflag) {
+		devloop(hidfd, repdesc, variables, varnum);
+		/* NOTREACHED */
+	}
+
+	if (rflag)
+		/* Report mode header */
+		printf("Report descriptor:\n");
+
+	devshow(hidfd, repdesc, variables, varnum,
+		1 << hid_input |
+		1 << hid_output |
+		1 << hid_feature);
+
+#if 0
+	{
+		size_t repindex;
+		for (repindex = 0;
+		     repindex < (sizeof(reptoparam) / sizeof(*reptoparam));
+		     repindex++)
+			devshow(hidfd, repdesc, variables, varnum,
+				1 << reptoparam[repindex].hid_kind);
+	}
+#endif
+
+	if (rflag) {
+		/* Report mode trailer */
+		size_t repindex;
+		for (repindex = 0;
+		     repindex < (sizeof(reptoparam) / sizeof(*reptoparam));
+		     repindex++) {
+			int report_id, size;
+			size = hid_report_size(repdesc,
+					       reptoparam[repindex].hid_kind,
+					       &report_id);
+			size -= report_id != 0;
+			printf("Total %7s size %s%d bytes\n",
+			       reptoparam[repindex].name,
+			       report_id && size ? "1+" : "", size);
+		}
+	}
+
+	hid_dispose_report_desc(repdesc);
+	exit(0);
+	/* NOTREACHED */
+}
diff --git a/usr.bin/usbhidctl/usbhidctl.1 b/usr.bin/usbhidctl/usbhidctl.1
new file mode 100644
index 00000000000..68fdee9bdba
--- /dev/null
+++ b/usr.bin/usbhidctl/usbhidctl.1
@@ -0,0 +1,122 @@
+.\" $OpenBSD: usbhidctl.1,v 1.1 2001/09/02 17:55:29 pvalchev Exp $
+.\" $NetBSD: usbhidctl.1,v 1.10 2000/09/24 02:27:12 augustss Exp $
+.\"
+.\" Copyright (c) 2000 The NetBSD Foundation, Inc.
+.\" All rights reserved.
+.\"
+.\" This code is derived from software contributed to The NetBSD Foundation
+.\" by David Sainty <David.Sainty@dtsp.co.nz>
+.\"
+.\" 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. All advertising materials mentioning features or use of this software
+.\"    must display the following acknowledgement:
+.\"        This product includes software developed by the NetBSD
+.\"        Foundation, Inc. and its contributors.
+.\" 4. Neither the name of The NetBSD Foundation 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 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.
+.\"
+.Dd August 27, 2000
+.Dt USBHIDCTL 1
+.Os
+.Sh NAME
+.Nm usbhidctl
+.Nd manipulate USB HID devices
+.Sh SYNOPSIS
+.Nm ""
+.Fl f Ar device
+.Op Fl t Ar table
+.Op Fl l
+.Op Fl v
+.Fl a
+.Nm ""
+.Fl f Ar device
+.Op Fl t Ar table
+.Op Fl v
+.Fl r
+.Nm ""
+.Fl f Ar device
+.Op Fl t Ar table
+.Op Fl l
+.Op Fl n
+.Op Fl v
+.Op Ar item ...
+.Nm ""
+.Fl f Ar device
+.Op Fl t Ar table
+.Fl w
+.Op Ar item=value ...
+.Sh DESCRIPTION
+.Nm
+can be used to dump or modify the state of a USB HID (Human Interface Device).
+If a list of items is present on the command line, then
+.Nm
+prints the current value of those items for the specified device.  If the
+.Fl w
+flag is specified
+.Nm
+attempts to set the specified items to the given values.
+.Pp
+The options are as follows:
+.Bl -tag -width Ds
+.It Fl a
+Show all items and their current values.
+.It Fl f Ar device
+Specify a path name for the device to operate on.  If
+.Ar device
+is numeric, it is taken to be the USB HID device number.  If it is a relative
+path, it is taken to be the name of the device under
+.Pa /dev .
+An absolute path is taken to be the literal device pathname.
+.It Fl l
+Loop and dump the device data every time it changes.  Only 'input' items are
+displayed in this mode.
+.It Fl n
+Suppress printing of the item name when querying specific item values.
+.It Fl r
+Dump the report descriptor.
+.It Fl t Ar table
+Specify a path name for the HID usage table file.
+.It Fl v
+Be verbose.  Repeating this option increases verbosity.
+.It Fl w
+Change item values.  Only 'output' and 'feature' kinds can be set with this
+option.
+.El
+.Sh FILES
+.Pa /usr/share/misc/usb_hid_usages
+The default HID usage table.
+.Sh SEE ALSO
+.Xr usb 3 ,
+.Xr uhid 4 ,
+.Xr usb 4
+.Sh AUTHOR
+David Sainty <David.Sainty@dtsp.co.nz>
+.Sh HISTORY
+The
+.Nm
+command first appeared in
+.Ox 3.0 .
+.Sh BUGS
+Some USB HID devices report multiple items with exactly the same description.
+The current naming scheme does not provide the means to specify which of the
+identically named items you are referring to.