1 /* $FreeBSD: head/usr.sbin/usbconfig/dump.c 246789 2013-02-14 12:22:40Z 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 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 } 409