usr.sbin/usbconfig/dump.c

   1 /* $FreeBSD: head/usr.sbin/usbconfig/dump.c 274435 2014-11-12 14:52:44Z hselasky $ */
   2 /*-
   3  * Copyright (c) 2008 Hans Petter Selasky. All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
  15  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  17  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
  18  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  19  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  20  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  21  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  22  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  23  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  24  * SUCH DAMAGE.
  25  */
  26
  27 #include <stdio.h>
  28 #include <stdlib.h>
  29 #include <stdint.h>
  30 #include <err.h>
  31 #include <string.h>
  32 #include <pwd.h>
  33 #include <grp.h>
  34 #include <ctype.h>
  35
  36 #include <libusb20.h>
  37 #include <libusb20_desc.h>
  38
  39 #include "dump.h"
  40
  41 #define DUMP0(n,type,field,...) dump_field(pdev, "  ", #field, n->field);
  42 #define DUMP1(n,type,field,...) dump_field(pdev, "    ", #field, n->field);
  43 #define DUMP2(n,type,field,...) dump_field(pdev, "      ", #field, n->field);
  44 #define DUMP3(n,type,field,...) dump_field(pdev, "        ", #field, n->field);
  45
  46 const char *
  47 dump_mode(uint8_t value)
  48 {
  49         if (value == LIBUSB20_MODE_HOST)
  50                 return ("HOST");
  51         return ("DEVICE");
  52 }
  53
  54 const char *
  55 dump_speed(uint8_t value)
  56 {
  57         ;                               /* style fix */
  58         switch (value) {
  59         case LIBUSB20_SPEED_LOW:
  60                 return ("LOW (1.5Mbps)");
  61         case LIBUSB20_SPEED_FULL:
  62                 return ("FULL (12Mbps)");
  63         case LIBUSB20_SPEED_HIGH:
  64                 return ("HIGH (480Mbps)");
  65         case LIBUSB20_SPEED_VARIABLE:
  66                 return ("VARIABLE (52-480Mbps)");
  67         case LIBUSB20_SPEED_SUPER:
  68                 return ("SUPER (5.0Gbps)");
  69         default:
  70                 break;
  71         }
  72         return ("UNKNOWN ()");
  73 }
  74
  75 const char *
  76 dump_power_mode(uint8_t value)
  77 {
  78         ;                               /* style fix */
  79         switch (value) {
  80         case LIBUSB20_POWER_OFF:
  81                 return ("OFF");
  82         case LIBUSB20_POWER_ON:
  83                 return ("ON");
  84         case LIBUSB20_POWER_SAVE:
  85                 return ("SAVE");
  86         case LIBUSB20_POWER_SUSPEND:
  87                 return ("SUSPEND");
  88         case LIBUSB20_POWER_RESUME:
  89                 return ("RESUME");
  90         default:
  91                 return ("UNKNOWN");
  92         }
  93 }
  94
  95 static void
  96 dump_field(struct libusb20_device *pdev, const char *plevel,
  97     const char *field, uint32_t value)
  98 {
  99         uint8_t temp_string[256];
 100
 101         printf("%s%s = 0x%04x ", plevel, field, value);
 102
 103         if (strlen(plevel) == 8) {
 104                 /* Endpoint Descriptor */
 105
 106                 if (strcmp(field, "bEndpointAddress") == 0) {
 107                         if (value & 0x80)
 108                                 printf(" <IN>\n");
 109                         else
 110                                 printf(" <OUT>\n");
 111                         return;
 112                 }
 113                 if (strcmp(field, "bmAttributes") == 0) {
 114                         switch (value & 0x03) {
 115                         case 0:
 116                                 printf(" <CONTROL>\n");
 117                                 break;
 118                         case 1:
 119                                 switch (value & 0x0C) {
 120                                 case 0x00:
 121                                         printf(" <ISOCHRONOUS>\n");
 122                                         break;
 123                                 case 0x04:
 124                                         printf(" <ASYNC-ISOCHRONOUS>\n");
 125                                         break;
 126                                 case 0x08:
 127                                         printf(" <ADAPT-ISOCHRONOUS>\n");
 128                                         break;
 129                                 default:
 130                                         printf(" <SYNC-ISOCHRONOUS>\n");
 131                                         break;
 132                                 }
 133                                 break;
 134                         case 2:
 135                                 printf(" <BULK>\n");
 136                                 break;
 137                         default:
 138                                 printf(" <INTERRUPT>\n");
 139                                 break;
 140                         }
 141                         return;
 142                 }
 143         }
 144         if ((field[0] == 'i') && (field[1] != 'd')) {
 145                 /* Indirect String Descriptor */
 146                 if (value == 0) {
 147                         printf(" <no string>\n");
 148                         return;
 149                 }
 150                 if (libusb20_dev_req_string_simple_sync(pdev, value,
 151                     temp_string, sizeof(temp_string))) {
 152                         printf(" <retrieving string failed>\n");
 153                         return;
 154                 }
 155                 printf(" <%s>\n", temp_string);
 156                 return;
 157         }
 158         if (strlen(plevel) == 2 || strlen(plevel) == 6) {
 159
 160                 /* Device and Interface Descriptor class codes */
 161
 162                 if (strcmp(field, "bInterfaceClass") == 0 ||
 163                     strcmp(field, "bDeviceClass") == 0) {
 164
 165                         switch (value) {
 166                         case 0x00:
 167                                 printf(" <Probed by interface class>\n");
 168                                 break;
 169                         case 0x01:
 170                                 printf(" <Audio device>\n");
 171                                 break;
 172                         case 0x02:
 173                                 printf(" <Communication device>\n");
 174                                 break;
 175                         case 0x03:
 176                                 printf(" <HID device>\n");
 177                                 break;
 178                         case 0x05:
 179                                 printf(" <Physical device>\n");
 180                                 break;
 181                         case 0x06:
 182                                 printf(" <Still imaging>\n");
 183                                 break;
 184                         case 0x07:
 185                                 printf(" <Printer device>\n");
 186                                 break;
 187                         case 0x08:
 188                                 printf(" <Mass storage>\n");
 189                                 break;
 190                         case 0x09:
 191                                 printf(" <HUB>\n");
 192                                 break;
 193                         case 0x0A:
 194                                 printf(" <CDC-data>\n");
 195                                 break;
 196                         case 0x0B:
 197                                 printf(" <Smart card>\n");
 198                                 break;
 199                         case 0x0D:
 200                                 printf(" <Content security>\n");
 201                                 break;
 202                         case 0x0E:
 203                                 printf(" <Video device>\n");
 204                                 break;
 205                         case 0x0F:
 206                                 printf(" <Personal healthcare>\n");
 207                                 break;
 208                         case 0x10:
 209                                 printf(" <Audio and video device>\n");
 210                                 break;
 211                         case 0x11:
 212                                 printf(" <Billboard device>\n");
 213                                 break;
 214                         case 0xDC:
 215                                 printf(" <Diagnostic device>\n");
 216                                 break;
 217                         case 0xE0:
 218                                 printf(" <Wireless controller>\n");
 219                                 break;
 220                         case 0xEF:
 221                                 printf(" <Miscellaneous device>\n");
 222                                 break;
 223                         case 0xFE:
 224                                 printf(" <Application specific>\n");
 225                                 break;
 226                         case 0xFF:
 227                                 printf(" <Vendor specific>\n");
 228                                 break;
 229                         default:
 230                                 printf(" <Unknown>\n");
 231                                 break;
 232                         }
 233                         return;
 234                 }
 235         }
 236         /* No additional information */
 237         printf("\n");
 238 }
 239
 240 static void
 241 dump_extra(struct libusb20_me_struct *str, const char *plevel)
 242 {
 243         const uint8_t *ptr;
 244         uint8_t x;
 245
 246         ptr = NULL;
 247
 248         while ((ptr = libusb20_desc_foreach(str, ptr))) {
 249                 printf("\n" "%sAdditional Descriptor\n\n", plevel);
 250                 printf("%sbLength = 0x%02x\n", plevel, ptr[0]);
 251                 printf("%sbDescriptorType = 0x%02x\n", plevel, ptr[1]);
 252                 if (ptr[0] > 1)
 253                         printf("%sbDescriptorSubType = 0x%02x\n",
 254                             plevel, ptr[2]);
 255                 printf("%s RAW dump: ", plevel);
 256                 for (x = 0; x != ptr[0]; x++) {
 257                         if ((x % 8) == 0) {
 258                                 printf("\n%s 0x%02x | ", plevel, x);
 259                         }
 260                         printf("0x%02x%s", ptr[x],
 261                             (x != (ptr[0] - 1)) ? ", " : (x % 8) ? "\n" : "");
 262                 }
 263                 printf("\n");
 264         }
 265         return;
 266 }
 267
 268 static void
 269 dump_endpoint(struct libusb20_device *pdev,
 270     struct libusb20_endpoint *ep)
 271 {
 272         struct LIBUSB20_ENDPOINT_DESC_DECODED *edesc;
 273
 274         edesc = &ep->desc;
 275         LIBUSB20_ENDPOINT_DESC(DUMP3, edesc);
 276         dump_extra(&ep->extra, "  " "  " "  ");
 277         return;
 278 }
 279
 280 static void
 281 dump_iface(struct libusb20_device *pdev,
 282     struct libusb20_interface *iface)
 283 {
 284         struct LIBUSB20_INTERFACE_DESC_DECODED *idesc;
 285         uint8_t z;
 286
 287         idesc = &iface->desc;
 288         LIBUSB20_INTERFACE_DESC(DUMP2, idesc);
 289         dump_extra(&iface->extra, "  " "  " "  ");
 290
 291         for (z = 0; z != iface->num_endpoints; z++) {
 292                 printf("\n     Endpoint %u\n", z);
 293                 dump_endpoint(pdev, iface->endpoints + z);
 294         }
 295         return;
 296 }
 297
 298 void
 299 dump_device_info(struct libusb20_device *pdev, uint8_t show_ifdrv)
 300 {
 301         char buf[128];
 302         uint8_t n;
 303         unsigned int usage;
 304
 305         usage = libusb20_dev_get_power_usage(pdev);
 306
 307         printf("%s, cfg=%u md=%s spd=%s pwr=%s (%umA)\n",
 308             libusb20_dev_get_desc(pdev),
 309             libusb20_dev_get_config_index(pdev),
 310             dump_mode(libusb20_dev_get_mode(pdev)),
 311             dump_speed(libusb20_dev_get_speed(pdev)),
 312             dump_power_mode(libusb20_dev_get_power_mode(pdev)),
 313             usage);
 314
 315         if (!show_ifdrv)
 316                 return;
 317
 318         for (n = 0; n != 255; n++) {
 319                 if (libusb20_dev_get_iface_desc(pdev, n, buf, sizeof(buf)))
 320                         break;
 321                 if (buf[0] == 0)
 322                         continue;
 323                 printf("ugen%u.%u.%u: %s\n",
 324                     libusb20_dev_get_bus_number(pdev),
 325                     libusb20_dev_get_address(pdev), n, buf);
 326         }
 327 }
 328
 329 void
 330 dump_be_quirk_names(struct libusb20_backend *pbe)
 331 {
 332         struct libusb20_quirk q;
 333         uint16_t x;
 334         int error;
 335
 336         memset(&q, 0, sizeof(q));
 337
 338         printf("\nDumping list of supported quirks:\n\n");
 339
 340         for (x = 0; x != 0xFFFF; x++) {
 341
 342                 error = libusb20_be_get_quirk_name(pbe, x, &q);
 343                 if (error) {
 344                         if (x == 0) {
 345                                 printf("No quirk names - maybe the USB quirk "
 346                                     "module has not been loaded.\n");
 347                         }
 348                         break;
 349                 }
 350                 if (strcmp(q.quirkname, "UQ_NONE"))
 351                         printf("%s\n", q.quirkname);
 352         }
 353         printf("\n");
 354         return;
 355 }
 356
 357 void
 358 dump_be_dev_quirks(struct libusb20_backend *pbe)
 359 {
 360         struct libusb20_quirk q;
 361         uint16_t x;
 362         int error;
 363
 364         memset(&q, 0, sizeof(q));
 365
 366         printf("\nDumping current device quirks:\n\n");
 367
 368         for (x = 0; x != 0xFFFF; x++) {
 369
 370                 error = libusb20_be_get_dev_quirk(pbe, x, &q);
 371                 if (error) {
 372                         if (x == 0) {
 373                                 printf("No device quirks - maybe the USB quirk "
 374                                     "module has not been loaded.\n");
 375                         }
 376                         break;
 377                 }
 378                 if (strcmp(q.quirkname, "UQ_NONE")) {
 379                         printf("VID=0x%04x PID=0x%04x REVLO=0x%04x "
 380                             "REVHI=0x%04x QUIRK=%s\n",
 381                             q.vid, q.pid, q.bcdDeviceLow,
 382                             q.bcdDeviceHigh, q.quirkname);
 383                 }
 384         }
 385         printf("\n");
 386         return;
 387 }
 388
 389 void
 390 dump_device_desc(struct libusb20_device *pdev)
 391 {
 392         struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
 393
 394         ddesc = libusb20_dev_get_device_desc(pdev);
 395         LIBUSB20_DEVICE_DESC(DUMP0, ddesc);
 396         return;
 397 }
 398
 399 void
 400 dump_config(struct libusb20_device *pdev, uint8_t all_cfg)
 401 {
 402         struct LIBUSB20_CONFIG_DESC_DECODED *cdesc;
 403         struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
 404         struct libusb20_config *pcfg = NULL;
 405         uint8_t cfg_index;
 406         uint8_t cfg_index_end;
 407         uint8_t x;
 408         uint8_t y;
 409
 410         ddesc = libusb20_dev_get_device_desc(pdev);
 411
 412         if (all_cfg) {
 413                 cfg_index = 0;
 414                 cfg_index_end = ddesc->bNumConfigurations;
 415         } else {
 416                 cfg_index = libusb20_dev_get_config_index(pdev);
 417                 cfg_index_end = cfg_index + 1;
 418         }
 419
 420         for (; cfg_index != cfg_index_end; cfg_index++) {
 421
 422                 pcfg = libusb20_dev_alloc_config(pdev, cfg_index);
 423                 if (!pcfg) {
 424                         continue;
 425                 }
 426                 printf("\n Configuration index %u\n\n", cfg_index);
 427                 cdesc = &(pcfg->desc);
 428                 LIBUSB20_CONFIG_DESC(DUMP1, cdesc);
 429                 dump_extra(&(pcfg->extra), "  " "  ");
 430
 431                 for (x = 0; x != pcfg->num_interface; x++) {
 432                         printf("\n    Interface %u\n", x);
 433                         dump_iface(pdev, pcfg->interface + x);
 434                         printf("\n");
 435                         for (y = 0; y != (pcfg->interface + x)->num_altsetting; y++) {
 436                                 printf("\n    Interface %u Alt %u\n", x, y + 1);
 437                                 dump_iface(pdev,
 438                                     (pcfg->interface + x)->altsetting + y);
 439                                 printf("\n");
 440                         }
 441                 }
 442                 printf("\n");
 443                 free(pcfg);
 444         }
 445         return;
 446 }
 447
 448 void
 449 dump_string_by_index(struct libusb20_device *pdev, uint8_t str_index)
 450 {
 451         char *pbuf;
 452         uint8_t n;
 453         uint8_t len;
 454
 455         pbuf = malloc(256);
 456         if (pbuf == NULL)
 457                 err(1, "out of memory");
 458
 459         if (str_index == 0) {
 460                 /* language table */
 461                 if (libusb20_dev_req_string_sync(pdev,
 462                     str_index, 0, pbuf, 256)) {
 463                         printf("STRING_0x%02x = <read error>\n", str_index);
 464                 } else {
 465                         printf("STRING_0x%02x = ", str_index);
 466                         len = (uint8_t)pbuf[0];
 467                         for (n = 0; n != len; n++) {
 468                                 printf("0x%02x%s", (uint8_t)pbuf[n],
 469                                     (n != (len-1)) ? ", " : "");
 470                         }
 471                         printf("\n");
 472                 }
 473         } else {
 474                 /* ordinary string */
 475                 if (libusb20_dev_req_string_simple_sync(pdev,
 476                     str_index, pbuf, 256)) {
 477                         printf("STRING_0x%02x = <read error>\n", str_index);
 478                 } else {
 479                         printf("STRING_0x%02x = <%s>\n", str_index, pbuf);
 480                 }
 481         }
 482         free(pbuf);
 483 }