diff options
| -rw-r--r-- | usr.bin/usbhidctl/Makefile | 10 | ||||
| -rw-r--r-- | usr.bin/usbhidctl/usbhid.c | 822 | ||||
| -rw-r--r-- | usr.bin/usbhidctl/usbhidctl.1 | 122 |
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. |