usr.bin/usbhidctl/usbhid.c

   1 /* $NetBSD: usbhid.c,v 1.14 2000/07/03 02:51:37 matt Exp $ */
   2 /* $FreeBSD: src/usr.bin/usbhidctl/usbhid.c,v 1.12 2007/12/21 03:40:36 imp Exp $ */
   3 /* $DragonFly: src/usr.bin/usbhidctl/usbhid.c,v 1.4 2008/11/24 17:15:17 hasso Exp $ */
   4
   5 /*
   6  * Copyright (c) 1998 The NetBSD Foundation, Inc.
   7  * All rights reserved.
   8  *
   9  * This code is derived from software contributed to The NetBSD Foundation
  10  * by Lennart Augustsson (augustss@netbsd.org).
  11  *
  12  * Redistribution and use in source and binary forms, with or without
  13  * modification, are permitted provided that the following conditions
  14  * are met:
  15  * 1. Redistributions of source code must retain the above copyright
  16  *    notice, this list of conditions and the following disclaimer.
  17  * 2. Redistributions in binary form must reproduce the above copyright
  18  *    notice, this list of conditions and the following disclaimer in the
  19  *    documentation and/or other materials provided with the distribution.
  20  * 3. All advertising materials mentioning features or use of this software
  21  *    must display the following acknowledgement:
  22  *        This product includes software developed by the NetBSD
  23  *        Foundation, Inc. and its contributors.
  24  * 4. Neither the name of The NetBSD Foundation nor the names of its
  25  *    contributors may be used to endorse or promote products derived
  26  *    from this software without specific prior written permission.
  27  *
  28  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  29  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  30  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  31  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  32  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  33  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  34  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  35  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  36  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  37  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  38  * POSSIBILITY OF SUCH DAMAGE.
  39  */
  40
  41 #include <stdio.h>
  42 #include <stdlib.h>
  43 #include <string.h>
  44 #include <sys/types.h>
  45 #include <fcntl.h>
  46 #include <sys/ioctl.h>
  47 #include <unistd.h>
  48 #include <err.h>
  49 #include <ctype.h>
  50 #include <errno.h>
  51 #include <usbhid.h>
  52 #include <bus/usb/usb.h>
  53 #include <bus/usb/usbhid.h>
  54
  55 int verbose = 0;
  56 int all = 0;
  57 int noname = 0;
  58 int hexdump = 0;
  59 static int reportid;
  60
  61 char **names;
  62 int nnames;
  63
  64 void prbits(int bits, char **strs, int n);
  65 void usage(void);
  66 void dumpitem(const char *label, struct hid_item *h);
  67 void dumpitems(report_desc_t r);
  68 void rev(struct hid_item **p);
  69 void prdata(u_char *buf, struct hid_item *h);
  70 void dumpdata(int f, report_desc_t r, int loop);
  71 int gotname(char *n);
  72
  73 int
  74 gotname(char *n)
  75 {
  76         int i;
  77
  78         for (i = 0; i < nnames; i++)
  79                 if (strcmp(names[i], n) == 0)
  80                         return 1;
  81         return 0;
  82 }
  83
  84 void
  85 prbits(int bits, char **strs, int n)
  86 {
  87         int i;
  88
  89         for(i = 0; i < n; i++, bits >>= 1)
  90                 if (strs[i*2])
  91                         printf("%s%s", i == 0 ? "" : ", ", strs[i*2 + (bits&1)]);
  92 }
  93
  94 void
  95 usage(void)
  96 {
  97         extern char *__progname;
  98
  99         fprintf(stderr,
 100                 "usage: %s -f device "
 101                 "[-l] [-n] [-r] [-t tablefile] [-v] [-x] name ...\n",
 102                 __progname);
 103         fprintf(stderr,
 104                 "       %s -f device "
 105                 "[-l] [-n] [-r] [-t tablefile] [-v] [-x] -a\n",
 106                 __progname);
 107         exit(1);
 108 }
 109
 110 void
 111 dumpitem(const char *label, struct hid_item *h)
 112 {
 113         if ((h->flags & HIO_CONST) && !verbose)
 114                 return;
 115         printf("%s size=%d count=%d page=%s usage=%s%s", label,
 116                h->report_size, h->report_count,
 117                hid_usage_page(HID_PAGE(h->usage)),
 118                hid_usage_in_page(h->usage),
 119                h->flags & HIO_CONST ? " Const" : "");
 120         printf(", logical range %d..%d",
 121                h->logical_minimum, h->logical_maximum);
 122         if (h->physical_minimum != h->physical_maximum)
 123                 printf(", physical range %d..%d",
 124                        h->physical_minimum, h->physical_maximum);
 125         if (h->unit)
 126                 printf(", unit=0x%02x exp=%d", h->unit, h->unit_exponent);
 127         printf("\n");
 128 }
 129
 130 void
 131 dumpitems(report_desc_t r)
 132 {
 133         struct hid_data *d;
 134         struct hid_item h;
 135         int size;
 136
 137         for (d = hid_start_parse(r, ~0, reportid); hid_get_item(d, &h); ) {
 138                 switch (h.kind) {
 139                 case hid_collection:
 140                         printf("Collection page=%s usage=%s\n",
 141                                hid_usage_page(HID_PAGE(h.usage)),
 142                                hid_usage_in_page(h.usage));
 143                         break;
 144                 case hid_endcollection:
 145                         printf("End collection\n");
 146                         break;
 147                 case hid_input:
 148                         dumpitem("Input  ", &h);
 149                         break;
 150                 case hid_output:
 151                         dumpitem("Output ", &h);
 152                         break;
 153                 case hid_feature:
 154                         dumpitem("Feature", &h);
 155                         break;
 156                 }
 157         }
 158         hid_end_parse(d);
 159         size = hid_report_size(r, hid_input, 0);
 160         printf("Total   input size %d bytes\n", size);
 161
 162         size = hid_report_size(r, hid_output, 0);
 163         printf("Total  output size %d bytes\n", size);
 164
 165         size = hid_report_size(r, hid_feature, 0);
 166         printf("Total feature size %d bytes\n", size);
 167 }
 168
 169 void
 170 rev(struct hid_item **p)
 171 {
 172         struct hid_item *cur, *prev, *next;
 173
 174         prev = 0;
 175         cur = *p;
 176         while(cur != 0) {
 177                 next = cur->next;
 178                 cur->next = prev;
 179                 prev = cur;
 180                 cur = next;
 181         }
 182         *p = prev;
 183 }
 184
 185 void
 186 prdata(u_char *buf, struct hid_item *h)
 187 {
 188         u_int data;
 189         int i, pos;
 190
 191         pos = h->pos;
 192         for (i = 0; i < h->report_count; i++) {
 193                 data = hid_get_data(buf, h);
 194                 if (h->logical_minimum < 0)
 195                         printf("%d", (int)data);
 196                 else
 197                         printf("%u", data);
 198                 if (hexdump)
 199                         printf(" [0x%x]", data);
 200                 pos += h->report_size;
 201         }
 202 }
 203
 204 void
 205 dumpdata(int f, report_desc_t rd, int loop)
 206 {
 207         struct hid_data *d;
 208         struct hid_item h, *hids, *n;
 209         int r, dlen;
 210         u_char *dbuf;
 211         static int one = 1;
 212         u_int32_t colls[100];
 213         int sp = 0;
 214         char namebuf[10000], *namep;
 215
 216         hids = 0;
 217         for (d = hid_start_parse(rd, 1<<hid_input, reportid);
 218              hid_get_item(d, &h); ) {
 219                 if (h.kind == hid_collection)
 220                         colls[++sp] = h.usage;
 221                 else if (h.kind == hid_endcollection)
 222                         --sp;
 223                 if (h.kind != hid_input || (h.flags & HIO_CONST))
 224                         continue;
 225                 h.next = hids;
 226                 h.collection = colls[sp];
 227                 hids = malloc(sizeof *hids);
 228                 *hids = h;
 229         }
 230         hid_end_parse(d);
 231         rev(&hids);
 232         dlen = hid_report_size(rd, hid_input, 0);
 233         dbuf = malloc(dlen);
 234         if (!loop)
 235                 if (ioctl(f, USB_SET_IMMED, &one) < 0) {
 236                         if (errno == EOPNOTSUPP)
 237                                 warnx("device does not support immediate mode, only changes reported.");
 238                         else
 239                                 err(1, "USB_SET_IMMED");
 240                 }
 241         do {
 242                 r = read(f, dbuf, dlen);
 243                 if (r != dlen) {
 244                         err(1, "bad read %d != %d", r, dlen);
 245                 }
 246                 for (n = hids; n; n = n->next) {
 247                         namep = namebuf;
 248                         namep += sprintf(namep, "%s:%s.",
 249                                          hid_usage_page(HID_PAGE(n->collection)),
 250                                          hid_usage_in_page(n->collection));
 251                         namep += sprintf(namep, "%s:%s",
 252                                          hid_usage_page(HID_PAGE(n->usage)),
 253                                          hid_usage_in_page(n->usage));
 254                         if (all || gotname(namebuf)) {
 255                                 if (!noname)
 256                                         printf("%s=", namebuf);
 257                                 prdata(dbuf + (reportid != 0), n);
 258                                 printf("\n");
 259                         }
 260                 }
 261                 if (loop)
 262                         printf("\n");
 263         } while (loop);
 264         free(dbuf);
 265 }
 266
 267 int
 268 main(int argc, char **argv)
 269 {
 270         int f;
 271         report_desc_t r;
 272         char devnam[100], *dev = 0;
 273         int ch;
 274         int repdump = 0;
 275         int loop = 0;
 276         char *table = 0;
 277
 278         while ((ch = getopt(argc, argv, "af:lnrt:vx")) != -1) {
 279                 switch(ch) {
 280                 case 'a':
 281                         all++;
 282                         break;
 283                 case 'f':
 284                         dev = optarg;
 285                         break;
 286                 case 'l':
 287                         loop ^= 1;
 288                         break;
 289                 case 'n':
 290                         noname++;
 291                         break;
 292                 case 'r':
 293                         repdump++;
 294                         break;
 295                 case 't':
 296                         table = optarg;
 297                         break;
 298                 case 'v':
 299                         verbose++;
 300                         break;
 301                 case 'x':
 302                         hexdump = 1;
 303                         break;
 304                 case '?':
 305                 default:
 306                         usage();
 307                 }
 308         }
 309         argc -= optind;
 310         argv += optind;
 311         if (dev == 0)
 312                 usage();
 313         names = argv;
 314         nnames = argc;
 315
 316         if (nnames == 0 && !all && !repdump)
 317                 usage();
 318
 319         if (dev[0] != '/') {
 320                 if (isdigit(dev[0]))
 321                         snprintf(devnam, sizeof(devnam), "/dev/uhid%s", dev);
 322                 else
 323                         snprintf(devnam, sizeof(devnam), "/dev/%s", dev);
 324                 dev = devnam;
 325         }
 326
 327         hid_init(table);
 328
 329         f = open(dev, O_RDWR);
 330         if (f < 0)
 331                 err(1, "%s", dev);
 332
 333         r = hid_get_report_desc(f);
 334         if (r == 0)
 335                 errx(1, "USB_GET_REPORT_DESC");
 336
 337         if (repdump) {
 338                 printf("Report descriptor:\n");
 339                 dumpitems(r);
 340         }
 341         if (nnames != 0 || all)
 342                 dumpdata(f, r, loop);
 343
 344         hid_dispose_report_desc(r);
 345         exit(0);
 346 }