usr.sbin/usbconfig/dump.c

   1 /* $FreeBSD$ */
   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
 114                 if (strcmp(field, "bmAttributes") == 0) {
 115                         switch (value & 0x03) {
 116                         case 0:
 117                                 printf(" <CONTROL>\n");
 118                                 break;
 119                         case 1:
 120                                 switch (value & 0x0C) {
 121                                 case 0x00:
 122                                         printf(" <ISOCHRONOUS>\n");
 123                                         break;
 124                                 case 0x04:
 125                                         printf(" <ASYNC-ISOCHRONOUS>\n");
 126                                         break;
 127                                 case 0x08:
 128                                         printf(" <ADAPT-ISOCHRONOUS>\n");
 129                                         break;
 130                                 default:
 131                                         printf(" <SYNC-ISOCHRONOUS>\n");
 132                                         break;
 133                                 }
 134                                 break;
 135                         case 2:
 136                                 printf(" <BULK>\n");
 137                                 break;
 138                         default:
 139                                 printf(" <INTERRUPT>\n");
 140                                 break;
 141                         }
 142                         return;
 143                 }
 144         }
 145
 146         if ((field[0] == 'i') && (field[1] != 'd')) {
 147                 /* Indirect String Descriptor */
 148                 if (value == 0) {
 149                         printf(" <no string>\n");
 150                         return;
 151                 }
 152                 if (libusb20_dev_req_string_simple_sync(pdev, value,
 153                     temp_string, sizeof(temp_string))) {
 154                         printf(" <retrieving string failed>\n");
 155                         return;
 156                 }
 157                 printf(" <%s>\n", temp_string);
 158                 return;
 159         }
 160
 161         /* No additional information */
 162         printf("\n");
 163 }
 164
 165 static void
 166 dump_extra(struct libusb20_me_struct *str, const char *plevel)
 167 {
 168         const uint8_t *ptr;
 169         uint8_t x;
 170
 171         ptr = NULL;
 172
 173         while ((ptr = libusb20_desc_foreach(str, ptr))) {
 174                 printf("\n" "%sAdditional Descriptor\n\n", plevel);
 175                 printf("%sbLength = 0x%02x\n", plevel, ptr[0]);
 176                 printf("%sbDescriptorType = 0x%02x\n", plevel, ptr[1]);
 177                 if (ptr[0] > 1)
 178                         printf("%sbDescriptorSubType = 0x%02x\n",
 179                             plevel, ptr[2]);
 180                 printf("%s RAW dump: ", plevel);
 181                 for (x = 0; x != ptr[0]; x++) {
 182                         if ((x % 8) == 0) {
 183                                 printf("\n%s 0x%02x | ", plevel, x);
 184                         }
 185                         printf("0x%02x%s", ptr[x],
 186                             (x != (ptr[0] - 1)) ? ", " : (x % 8) ? "\n" : "");
 187                 }
 188                 printf("\n");
 189         }
 190         return;
 191 }
 192
 193 static void
 194 dump_endpoint(struct libusb20_device *pdev,
 195     struct libusb20_endpoint *ep)
 196 {
 197         struct LIBUSB20_ENDPOINT_DESC_DECODED *edesc;
 198
 199         edesc = &ep->desc;
 200         LIBUSB20_ENDPOINT_DESC(DUMP3, edesc);
 201         dump_extra(&ep->extra, "  " "  " "  ");
 202         return;
 203 }
 204
 205 static void
 206 dump_iface(struct libusb20_device *pdev,
 207     struct libusb20_interface *iface)
 208 {
 209         struct LIBUSB20_INTERFACE_DESC_DECODED *idesc;
 210         uint8_t z;
 211
 212         idesc = &iface->desc;
 213         LIBUSB20_INTERFACE_DESC(DUMP2, idesc);
 214         dump_extra(&iface->extra, "  " "  " "  ");
 215
 216         for (z = 0; z != iface->num_endpoints; z++) {
 217                 printf("\n     Endpoint %u\n", z);
 218                 dump_endpoint(pdev, iface->endpoints + z);
 219         }
 220         return;
 221 }
 222
 223 void
 224 dump_device_info(struct libusb20_device *pdev, uint8_t show_ifdrv)
 225 {
 226         char buf[128];
 227         uint8_t n;
 228         unsigned int usage;
 229
 230         usage = libusb20_dev_get_power_usage(pdev);
 231
 232         printf("%s, cfg=%u md=%s spd=%s pwr=%s (%umA)\n",
 233             libusb20_dev_get_desc(pdev),
 234             libusb20_dev_get_config_index(pdev),
 235             dump_mode(libusb20_dev_get_mode(pdev)),
 236             dump_speed(libusb20_dev_get_speed(pdev)),
 237             dump_power_mode(libusb20_dev_get_power_mode(pdev)),
 238             usage);
 239
 240         if (!show_ifdrv)
 241                 return;
 242
 243         for (n = 0; n != 255; n++) {
 244                 if (libusb20_dev_get_iface_desc(pdev, n, buf, sizeof(buf)))
 245                         break;
 246                 if (buf[0] == 0)
 247                         continue;
 248                 printf("ugen%u.%u.%u: %s\n",
 249                     libusb20_dev_get_bus_number(pdev),
 250                     libusb20_dev_get_address(pdev), n, buf);
 251         }
 252 }
 253
 254 void
 255 dump_be_quirk_names(struct libusb20_backend *pbe)
 256 {
 257         struct libusb20_quirk q;
 258         uint16_t x;
 259         int error;
 260
 261         memset(&q, 0, sizeof(q));
 262
 263         printf("\nDumping list of supported quirks:\n\n");
 264
 265         for (x = 0; x != 0xFFFF; x++) {
 266
 267                 error = libusb20_be_get_quirk_name(pbe, x, &q);
 268                 if (error) {
 269                         if (x == 0) {
 270                                 printf("No quirk names - maybe the USB quirk "
 271                                     "module has not been loaded.\n");
 272                         }
 273                         break;
 274                 }
 275                 if (strcmp(q.quirkname, "UQ_NONE"))
 276                         printf("%s\n", q.quirkname);
 277         }
 278         printf("\n");
 279         return;
 280 }
 281
 282 void
 283 dump_be_dev_quirks(struct libusb20_backend *pbe)
 284 {
 285         struct libusb20_quirk q;
 286         uint16_t x;
 287         int error;
 288
 289         memset(&q, 0, sizeof(q));
 290
 291         printf("\nDumping current device quirks:\n\n");
 292
 293         for (x = 0; x != 0xFFFF; x++) {
 294
 295                 error = libusb20_be_get_dev_quirk(pbe, x, &q);
 296                 if (error) {
 297                         if (x == 0) {
 298                                 printf("No device quirks - maybe the USB quirk "
 299                                     "module has not been loaded.\n");
 300                         }
 301                         break;
 302                 }
 303                 if (strcmp(q.quirkname, "UQ_NONE")) {
 304                         printf("VID=0x%04x PID=0x%04x REVLO=0x%04x "
 305                             "REVHI=0x%04x QUIRK=%s\n",
 306                             q.vid, q.pid, q.bcdDeviceLow,
 307                             q.bcdDeviceHigh, q.quirkname);
 308                 }
 309         }
 310         printf("\n");
 311         return;
 312 }
 313
 314 void
 315 dump_device_desc(struct libusb20_device *pdev)
 316 {
 317         struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
 318
 319         ddesc = libusb20_dev_get_device_desc(pdev);
 320         LIBUSB20_DEVICE_DESC(DUMP0, ddesc);
 321         return;
 322 }
 323
 324 void
 325 dump_config(struct libusb20_device *pdev, uint8_t all_cfg)
 326 {
 327         struct LIBUSB20_CONFIG_DESC_DECODED *cdesc;
 328         struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
 329         struct libusb20_config *pcfg = NULL;
 330         uint8_t cfg_index;
 331         uint8_t cfg_index_end;
 332         uint8_t x;
 333         uint8_t y;
 334
 335         ddesc = libusb20_dev_get_device_desc(pdev);
 336
 337         if (all_cfg) {
 338                 cfg_index = 0;
 339                 cfg_index_end = ddesc->bNumConfigurations;
 340         } else {
 341                 cfg_index = libusb20_dev_get_config_index(pdev);
 342                 cfg_index_end = cfg_index + 1;
 343         }
 344
 345         for (; cfg_index != cfg_index_end; cfg_index++) {
 346
 347                 pcfg = libusb20_dev_alloc_config(pdev, cfg_index);
 348                 if (!pcfg) {
 349                         continue;
 350                 }
 351                 printf("\n Configuration index %u\n\n", cfg_index);
 352                 cdesc = &(pcfg->desc);
 353                 LIBUSB20_CONFIG_DESC(DUMP1, cdesc);
 354                 dump_extra(&(pcfg->extra), "  " "  ");
 355
 356                 for (x = 0; x != pcfg->num_interface; x++) {
 357                         printf("\n    Interface %u\n", x);
 358                         dump_iface(pdev, pcfg->interface + x);
 359                         printf("\n");
 360                         for (y = 0; y != (pcfg->interface + x)->num_altsetting; y++) {
 361                                 printf("\n    Interface %u Alt %u\n", x, y + 1);
 362                                 dump_iface(pdev,
 363                                     (pcfg->interface + x)->altsetting + y);
 364                                 printf("\n");
 365                         }
 366                 }
 367                 printf("\n");
 368                 free(pcfg);
 369         }
 370         return;
 371 }
 372
 373 void
 374 dump_string_by_index(struct libusb20_device *pdev, uint8_t str_index)
 375 {
 376         char *pbuf;
 377         uint8_t n;
 378         uint8_t len;
 379
 380         pbuf = malloc(256);
 381         if (pbuf == NULL)
 382                 err(1, "out of memory");
 383
 384         if (str_index == 0) {
 385                 /* language table */
 386                 if (libusb20_dev_req_string_sync(pdev,
 387                     str_index, 0, pbuf, 256)) {
 388                         printf("STRING_0x%02x = <read error>\n", str_index);
 389                 } else {
 390                         printf("STRING_0x%02x = ", str_index);
 391                         len = (uint8_t)pbuf[0];
 392                         for (n = 0; n != len; n++) {
 393                                 printf("0x%02x%s", (uint8_t)pbuf[n],
 394                                     (n != (len-1)) ? ", " : "");
 395                         }
 396                         printf("\n");
 397                 }
 398         } else {
 399                 /* ordinary string */
 400                 if (libusb20_dev_req_string_simple_sync(pdev,
 401                     str_index, pbuf, 256)) {
 402                         printf("STRING_0x%02x = <read error>\n", str_index);
 403                 } else {
 404                         printf("STRING_0x%02x = <%s>\n", str_index, pbuf);
 405                 }
 406         }
 407         free(pbuf);
 408 }