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 (4.8Gbps)");
  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 ((field[0] != 'i') || (field[1] == 'd')) {
 104                 printf("\n");
 105                 return;
 106         }
 107         if (value == 0) {
 108                 printf(" <no string>\n");
 109                 return;
 110         }
 111         if (libusb20_dev_req_string_simple_sync(pdev, value,
 112             temp_string, sizeof(temp_string))) {
 113                 printf(" <retrieving string failed>\n");
 114                 return;
 115         }
 116         printf(" <%s>\n", temp_string);
 117         return;
 118 }
 119
 120 static void
 121 dump_extra(struct libusb20_me_struct *str, const char *plevel)
 122 {
 123         const uint8_t *ptr;
 124         uint8_t x;
 125
 126         ptr = NULL;
 127
 128         while ((ptr = libusb20_desc_foreach(str, ptr))) {
 129                 printf("\n" "%sAdditional Descriptor\n\n", plevel);
 130                 printf("%sbLength = 0x%02x\n", plevel, ptr[0]);
 131                 printf("%sbDescriptorType = 0x%02x\n", plevel, ptr[1]);
 132                 if (ptr[0] > 1)
 133                         printf("%sbDescriptorSubType = 0x%02x\n",
 134                             plevel, ptr[2]);
 135                 printf("%s RAW dump: ", plevel);
 136                 for (x = 0; x != ptr[0]; x++) {
 137                         if ((x % 8) == 0) {
 138                                 printf("\n%s 0x%02x | ", plevel, x);
 139                         }
 140                         printf("0x%02x%s", ptr[x],
 141                             (x != (ptr[0] - 1)) ? ", " : (x % 8) ? "\n" : "");
 142                 }
 143                 printf("\n");
 144         }
 145         return;
 146 }
 147
 148 static void
 149 dump_endpoint(struct libusb20_device *pdev,
 150     struct libusb20_endpoint *ep)
 151 {
 152         struct LIBUSB20_ENDPOINT_DESC_DECODED *edesc;
 153
 154         edesc = &ep->desc;
 155         LIBUSB20_ENDPOINT_DESC(DUMP3, edesc);
 156         dump_extra(&ep->extra, "  " "  " "  ");
 157         return;
 158 }
 159
 160 static void
 161 dump_iface(struct libusb20_device *pdev,
 162     struct libusb20_interface *iface)
 163 {
 164         struct LIBUSB20_INTERFACE_DESC_DECODED *idesc;
 165         uint8_t z;
 166
 167         idesc = &iface->desc;
 168         LIBUSB20_INTERFACE_DESC(DUMP2, idesc);
 169         dump_extra(&iface->extra, "  " "  " "  ");
 170
 171         for (z = 0; z != iface->num_endpoints; z++) {
 172                 printf("\n     Endpoint %u\n", z);
 173                 dump_endpoint(pdev, iface->endpoints + z);
 174         }
 175         return;
 176 }
 177
 178 void
 179 dump_device_info(struct libusb20_device *pdev, uint8_t show_ifdrv)
 180 {
 181         char buf[128];
 182         uint8_t n;
 183
 184         printf("%s, cfg=%u md=%s spd=%s pwr=%s\n",
 185             libusb20_dev_get_desc(pdev),
 186             libusb20_dev_get_config_index(pdev),
 187             dump_mode(libusb20_dev_get_mode(pdev)),
 188             dump_speed(libusb20_dev_get_speed(pdev)),
 189             dump_power_mode(libusb20_dev_get_power_mode(pdev)));
 190
 191         if (!show_ifdrv)
 192                 return;
 193
 194         for (n = 0; n != 255; n++) {
 195                 if (libusb20_dev_get_iface_desc(pdev, n, buf, sizeof(buf)))
 196                         break;
 197                 if (buf[0] == 0)
 198                         continue;
 199                 printf("ugen%u.%u.%u: %s\n",
 200                     libusb20_dev_get_bus_number(pdev),
 201                     libusb20_dev_get_address(pdev), n, buf);
 202         }
 203 }
 204
 205 void
 206 dump_be_quirk_names(struct libusb20_backend *pbe)
 207 {
 208         struct libusb20_quirk q;
 209         uint16_t x;
 210         int error;
 211
 212         memset(&q, 0, sizeof(q));
 213
 214         printf("\nDumping list of supported quirks:\n\n");
 215
 216         for (x = 0; x != 0xFFFF; x++) {
 217
 218                 error = libusb20_be_get_quirk_name(pbe, x, &q);
 219                 if (error) {
 220                         if (x == 0) {
 221                                 printf("No quirk names - maybe the USB quirk "
 222                                     "module has not been loaded.\n");
 223                         }
 224                         break;
 225                 }
 226                 if (strcmp(q.quirkname, "UQ_NONE"))
 227                         printf("%s\n", q.quirkname);
 228         }
 229         printf("\n");
 230         return;
 231 }
 232
 233 void
 234 dump_be_dev_quirks(struct libusb20_backend *pbe)
 235 {
 236         struct libusb20_quirk q;
 237         uint16_t x;
 238         int error;
 239
 240         memset(&q, 0, sizeof(q));
 241
 242         printf("\nDumping current device quirks:\n\n");
 243
 244         for (x = 0; x != 0xFFFF; x++) {
 245
 246                 error = libusb20_be_get_dev_quirk(pbe, x, &q);
 247                 if (error) {
 248                         if (x == 0) {
 249                                 printf("No device quirks - maybe the USB quirk "
 250                                     "module has not been loaded.\n");
 251                         }
 252                         break;
 253                 }
 254                 if (strcmp(q.quirkname, "UQ_NONE")) {
 255                         printf("VID=0x%04x PID=0x%04x REVLO=0x%04x "
 256                             "REVHI=0x%04x QUIRK=%s\n",
 257                             q.vid, q.pid, q.bcdDeviceLow,
 258                             q.bcdDeviceHigh, q.quirkname);
 259                 }
 260         }
 261         printf("\n");
 262         return;
 263 }
 264
 265 void
 266 dump_device_desc(struct libusb20_device *pdev)
 267 {
 268         struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
 269
 270         ddesc = libusb20_dev_get_device_desc(pdev);
 271         LIBUSB20_DEVICE_DESC(DUMP0, ddesc);
 272         return;
 273 }
 274
 275 void
 276 dump_config(struct libusb20_device *pdev, uint8_t all_cfg)
 277 {
 278         struct LIBUSB20_CONFIG_DESC_DECODED *cdesc;
 279         struct LIBUSB20_DEVICE_DESC_DECODED *ddesc;
 280         struct libusb20_config *pcfg = NULL;
 281         uint8_t cfg_index;
 282         uint8_t cfg_index_end;
 283         uint8_t x;
 284         uint8_t y;
 285
 286         ddesc = libusb20_dev_get_device_desc(pdev);
 287
 288         if (all_cfg) {
 289                 cfg_index = 0;
 290                 cfg_index_end = ddesc->bNumConfigurations;
 291         } else {
 292                 cfg_index = libusb20_dev_get_config_index(pdev);
 293                 cfg_index_end = cfg_index + 1;
 294         }
 295
 296         for (; cfg_index != cfg_index_end; cfg_index++) {
 297
 298                 pcfg = libusb20_dev_alloc_config(pdev, cfg_index);
 299                 if (!pcfg) {
 300                         continue;
 301                 }
 302                 printf("\n Configuration index %u\n\n", cfg_index);
 303                 cdesc = &(pcfg->desc);
 304                 LIBUSB20_CONFIG_DESC(DUMP1, cdesc);
 305                 dump_extra(&(pcfg->extra), "  " "  ");
 306
 307                 for (x = 0; x != pcfg->num_interface; x++) {
 308                         printf("\n    Interface %u\n", x);
 309                         dump_iface(pdev, pcfg->interface + x);
 310                         printf("\n");
 311                         for (y = 0; y != (pcfg->interface + x)->num_altsetting; y++) {
 312                                 printf("\n    Interface %u Alt %u\n", x, y + 1);
 313                                 dump_iface(pdev,
 314                                     (pcfg->interface + x)->altsetting + y);
 315                                 printf("\n");
 316                         }
 317                 }
 318                 printf("\n");
 319                 free(pcfg);
 320         }
 321         return;
 322 }