1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * devices.c 4 * (C) Copyright 1999 Randy Dunlap. 5 * (C) Copyright 1999,2000 Thomas Sailer <sailer@ife.ee.ethz.ch>. 6 * (proc file per device) 7 * (C) Copyright 1999 Deti Fliegl (new USB architecture) 8 * 9 ************************************************************* 10 * 11 * <mountpoint>/devices contains USB topology, device, config, class, 12 * interface, & endpoint data. 13 * 14 * I considered using /dev/bus/usb/device# for each device 15 * as it is attached or detached, but I didn't like this for some 16 * reason -- maybe it's just too deep of a directory structure. 17 * I also don't like looking in multiple places to gather and view 18 * the data. Having only one file for ./devices also prevents race 19 * conditions that could arise if a program was reading device info 20 * for devices that are being removed (unplugged). (That is, the 21 * program may find a directory for devnum_12 then try to open it, 22 * but it was just unplugged, so the directory is now deleted. 23 * But programs would just have to be prepared for situations like 24 * this in any plug-and-play environment.) 25 * 26 * 1999-12-16: Thomas Sailer <sailer@ife.ee.ethz.ch> 27 * Converted the whole proc stuff to real 28 * read methods. Now not the whole device list needs to fit 29 * into one page, only the device list for one bus. 30 * Added a poll method to /sys/kernel/debug/usb/devices, to wake 31 * up an eventual usbd 32 * 2000-01-04: Thomas Sailer <sailer@ife.ee.ethz.ch> 33 * Turned into its own filesystem 34 * 2000-07-05: Ashley Montanaro <ashley@compsoc.man.ac.uk> 35 * Converted file reading routine to dump to buffer once 36 * per device, not per bus 37 */ 38 39 #include <linux/fs.h> 40 #include <linux/mm.h> 41 #include <linux/gfp.h> 42 #include <linux/poll.h> 43 #include <linux/usb.h> 44 #include <linux/usbdevice_fs.h> 45 #include <linux/usb/hcd.h> 46 #include <linux/mutex.h> 47 #include <linux/uaccess.h> 48 49 #include "usb.h" 50 51 /* Define ALLOW_SERIAL_NUMBER if you want to see the serial number of devices */ 52 #define ALLOW_SERIAL_NUMBER 53 54 static const char format_topo[] = 55 /* T: Bus=dd Lev=dd Prnt=dd Port=dd Cnt=dd Dev#=ddd Spd=dddd MxCh=dd */ 56 "\nT: Bus=%2.2d Lev=%2.2d Prnt=%2.2d Port=%2.2d Cnt=%2.2d Dev#=%3d Spd=%-4s MxCh=%2d\n"; 57 58 static const char format_string_manufacturer[] = 59 /* S: Manufacturer=xxxx */ 60 "S: Manufacturer=%.100s\n"; 61 62 static const char format_string_product[] = 63 /* S: Product=xxxx */ 64 "S: Product=%.100s\n"; 65 66 #ifdef ALLOW_SERIAL_NUMBER 67 static const char format_string_serialnumber[] = 68 /* S: SerialNumber=xxxx */ 69 "S: SerialNumber=%.100s\n"; 70 #endif 71 72 static const char format_bandwidth[] = 73 /* B: Alloc=ddd/ddd us (xx%), #Int=ddd, #Iso=ddd */ 74 "B: Alloc=%3d/%3d us (%2d%%), #Int=%3d, #Iso=%3d\n"; 75 76 static const char format_device1[] = 77 /* D: Ver=xx.xx Cls=xx(sssss) Sub=xx Prot=xx MxPS=dd #Cfgs=dd */ 78 "D: Ver=%2x.%02x Cls=%02x(%-5s) Sub=%02x Prot=%02x MxPS=%2d #Cfgs=%3d\n"; 79 80 static const char format_device2[] = 81 /* P: Vendor=xxxx ProdID=xxxx Rev=xx.xx */ 82 "P: Vendor=%04x ProdID=%04x Rev=%2x.%02x\n"; 83 84 static const char format_config[] = 85 /* C: #Ifs=dd Cfg#=dd Atr=xx MPwr=dddmA */ 86 "C:%c #Ifs=%2d Cfg#=%2d Atr=%02x MxPwr=%3dmA\n"; 87 88 static const char format_iad[] = 89 /* A: FirstIf#=dd IfCount=dd Cls=xx(sssss) Sub=xx Prot=xx */ 90 "A: FirstIf#=%2d IfCount=%2d Cls=%02x(%-5s) Sub=%02x Prot=%02x\n"; 91 92 static const char format_iface[] = 93 /* I: If#=dd Alt=dd #EPs=dd Cls=xx(sssss) Sub=xx Prot=xx Driver=xxxx*/ 94 "I:%c If#=%2d Alt=%2d #EPs=%2d Cls=%02x(%-5s) Sub=%02x Prot=%02x Driver=%s\n"; 95 96 static const char format_endpt[] = 97 /* E: Ad=xx(s) Atr=xx(ssss) MxPS=dddd Ivl=D?s */ 98 "E: Ad=%02x(%c) Atr=%02x(%-4s) MxPS=%4d Ivl=%d%cs\n"; 99 100 /* 101 * Wait for an connect/disconnect event to happen. We initialize 102 * the event counter with an odd number, and each event will increment 103 * the event counter by two, so it will always _stay_ odd. That means 104 * that it will never be zero, so "event 0" will never match a current 105 * event, and thus 'poll' will always trigger as readable for the first 106 * time it gets called. 107 */ 108 static struct device_connect_event { 109 atomic_t count; 110 wait_queue_head_t wait; 111 } device_event = { 112 .count = ATOMIC_INIT(1), 113 .wait = __WAIT_QUEUE_HEAD_INITIALIZER(device_event.wait) 114 }; 115 116 struct class_info { 117 int class; 118 char *class_name; 119 }; 120 121 static const struct class_info clas_info[] = { 122 /* max. 5 chars. per name string */ 123 {USB_CLASS_PER_INTERFACE, ">ifc"}, 124 {USB_CLASS_AUDIO, "audio"}, 125 {USB_CLASS_COMM, "comm."}, 126 {USB_CLASS_HID, "HID"}, 127 {USB_CLASS_PHYSICAL, "PID"}, 128 {USB_CLASS_STILL_IMAGE, "still"}, 129 {USB_CLASS_PRINTER, "print"}, 130 {USB_CLASS_MASS_STORAGE, "stor."}, 131 {USB_CLASS_HUB, "hub"}, 132 {USB_CLASS_CDC_DATA, "data"}, 133 {USB_CLASS_CSCID, "scard"}, 134 {USB_CLASS_CONTENT_SEC, "c-sec"}, 135 {USB_CLASS_VIDEO, "video"}, 136 {USB_CLASS_WIRELESS_CONTROLLER, "wlcon"}, 137 {USB_CLASS_MISC, "misc"}, 138 {USB_CLASS_APP_SPEC, "app."}, 139 {USB_CLASS_VENDOR_SPEC, "vend."}, 140 {-1, "unk."} /* leave as last */ 141 }; 142 143 /*****************************************************************/ 144 145 void usbfs_conn_disc_event(void) 146 { 147 atomic_add(2, &device_event.count); 148 wake_up(&device_event.wait); 149 } 150 151 static const char *class_decode(const int class) 152 { 153 int ix; 154 155 for (ix = 0; clas_info[ix].class != -1; ix++) 156 if (clas_info[ix].class == class) 157 break; 158 return clas_info[ix].class_name; 159 } 160 161 static char *usb_dump_endpoint_descriptor(int speed, char *start, char *end, 162 const struct usb_endpoint_descriptor *desc) 163 { 164 char dir, unit, *type; 165 unsigned interval, bandwidth = 1; 166 167 if (start > end) 168 return start; 169 170 dir = usb_endpoint_dir_in(desc) ? 'I' : 'O'; 171 172 if (speed == USB_SPEED_HIGH) 173 bandwidth = usb_endpoint_maxp_mult(desc); 174 175 /* this isn't checking for illegal values */ 176 switch (usb_endpoint_type(desc)) { 177 case USB_ENDPOINT_XFER_CONTROL: 178 type = "Ctrl"; 179 if (speed == USB_SPEED_HIGH) /* uframes per NAK */ 180 interval = desc->bInterval; 181 else 182 interval = 0; 183 dir = 'B'; /* ctrl is bidirectional */ 184 break; 185 case USB_ENDPOINT_XFER_ISOC: 186 type = "Isoc"; 187 interval = 1 << (desc->bInterval - 1); 188 break; 189 case USB_ENDPOINT_XFER_BULK: 190 type = "Bulk"; 191 if (speed == USB_SPEED_HIGH && dir == 'O') /* uframes per NAK */ 192 interval = desc->bInterval; 193 else 194 interval = 0; 195 break; 196 case USB_ENDPOINT_XFER_INT: 197 type = "Int."; 198 if (speed == USB_SPEED_HIGH || speed >= USB_SPEED_SUPER) 199 interval = 1 << (desc->bInterval - 1); 200 else 201 interval = desc->bInterval; 202 break; 203 default: /* "can't happen" */ 204 return start; 205 } 206 interval *= (speed == USB_SPEED_HIGH || 207 speed >= USB_SPEED_SUPER) ? 125 : 1000; 208 if (interval % 1000) 209 unit = 'u'; 210 else { 211 unit = 'm'; 212 interval /= 1000; 213 } 214 215 start += sprintf(start, format_endpt, desc->bEndpointAddress, dir, 216 desc->bmAttributes, type, 217 usb_endpoint_maxp(desc) * 218 bandwidth, 219 interval, unit); 220 return start; 221 } 222 223 static char *usb_dump_interface_descriptor(char *start, char *end, 224 const struct usb_interface_cache *intfc, 225 const struct usb_interface *iface, 226 int setno) 227 { 228 const struct usb_interface_descriptor *desc; 229 const char *driver_name = ""; 230 int active = 0; 231 232 if (start > end) 233 return start; 234 desc = &intfc->altsetting[setno].desc; 235 if (iface) { 236 driver_name = (iface->dev.driver 237 ? iface->dev.driver->name 238 : "(none)"); 239 active = (desc == &iface->cur_altsetting->desc); 240 } 241 start += sprintf(start, format_iface, 242 active ? '*' : ' ', /* mark active altsetting */ 243 desc->bInterfaceNumber, 244 desc->bAlternateSetting, 245 desc->bNumEndpoints, 246 desc->bInterfaceClass, 247 class_decode(desc->bInterfaceClass), 248 desc->bInterfaceSubClass, 249 desc->bInterfaceProtocol, 250 driver_name); 251 return start; 252 } 253 254 static char *usb_dump_interface(int speed, char *start, char *end, 255 const struct usb_interface_cache *intfc, 256 const struct usb_interface *iface, int setno) 257 { 258 const struct usb_host_interface *desc = &intfc->altsetting[setno]; 259 int i; 260 261 start = usb_dump_interface_descriptor(start, end, intfc, iface, setno); 262 for (i = 0; i < desc->desc.bNumEndpoints; i++) { 263 if (start > end) 264 return start; 265 start = usb_dump_endpoint_descriptor(speed, 266 start, end, &desc->endpoint[i].desc); 267 } 268 return start; 269 } 270 271 static char *usb_dump_iad_descriptor(char *start, char *end, 272 const struct usb_interface_assoc_descriptor *iad) 273 { 274 if (start > end) 275 return start; 276 start += sprintf(start, format_iad, 277 iad->bFirstInterface, 278 iad->bInterfaceCount, 279 iad->bFunctionClass, 280 class_decode(iad->bFunctionClass), 281 iad->bFunctionSubClass, 282 iad->bFunctionProtocol); 283 return start; 284 } 285 286 /* TBD: 287 * 0. TBDs 288 * 1. marking active interface altsettings (code lists all, but should mark 289 * which ones are active, if any) 290 */ 291 static char *usb_dump_config_descriptor(char *start, char *end, 292 const struct usb_config_descriptor *desc, 293 int active, int speed) 294 { 295 int mul; 296 297 if (start > end) 298 return start; 299 if (speed >= USB_SPEED_SUPER) 300 mul = 8; 301 else 302 mul = 2; 303 start += sprintf(start, format_config, 304 /* mark active/actual/current cfg. */ 305 active ? '*' : ' ', 306 desc->bNumInterfaces, 307 desc->bConfigurationValue, 308 desc->bmAttributes, 309 desc->bMaxPower * mul); 310 return start; 311 } 312 313 static char *usb_dump_config(int speed, char *start, char *end, 314 const struct usb_host_config *config, int active) 315 { 316 int i, j; 317 struct usb_interface_cache *intfc; 318 struct usb_interface *interface; 319 320 if (start > end) 321 return start; 322 if (!config) 323 /* getting these some in 2.3.7; none in 2.3.6 */ 324 return start + sprintf(start, "(null Cfg. desc.)\n"); 325 start = usb_dump_config_descriptor(start, end, &config->desc, active, 326 speed); 327 for (i = 0; i < USB_MAXIADS; i++) { 328 if (config->intf_assoc[i] == NULL) 329 break; 330 start = usb_dump_iad_descriptor(start, end, 331 config->intf_assoc[i]); 332 } 333 for (i = 0; i < config->desc.bNumInterfaces; i++) { 334 intfc = config->intf_cache[i]; 335 interface = config->interface[i]; 336 for (j = 0; j < intfc->num_altsetting; j++) { 337 if (start > end) 338 return start; 339 start = usb_dump_interface(speed, 340 start, end, intfc, interface, j); 341 } 342 } 343 return start; 344 } 345 346 /* 347 * Dump the different USB descriptors. 348 */ 349 static char *usb_dump_device_descriptor(char *start, char *end, 350 const struct usb_device_descriptor *desc) 351 { 352 u16 bcdUSB = le16_to_cpu(desc->bcdUSB); 353 u16 bcdDevice = le16_to_cpu(desc->bcdDevice); 354 355 if (start > end) 356 return start; 357 start += sprintf(start, format_device1, 358 bcdUSB >> 8, bcdUSB & 0xff, 359 desc->bDeviceClass, 360 class_decode(desc->bDeviceClass), 361 desc->bDeviceSubClass, 362 desc->bDeviceProtocol, 363 desc->bMaxPacketSize0, 364 desc->bNumConfigurations); 365 if (start > end) 366 return start; 367 start += sprintf(start, format_device2, 368 le16_to_cpu(desc->idVendor), 369 le16_to_cpu(desc->idProduct), 370 bcdDevice >> 8, bcdDevice & 0xff); 371 return start; 372 } 373 374 /* 375 * Dump the different strings that this device holds. 376 */ 377 static char *usb_dump_device_strings(char *start, char *end, 378 struct usb_device *dev) 379 { 380 if (start > end) 381 return start; 382 if (dev->manufacturer) 383 start += sprintf(start, format_string_manufacturer, 384 dev->manufacturer); 385 if (start > end) 386 goto out; 387 if (dev->product) 388 start += sprintf(start, format_string_product, dev->product); 389 if (start > end) 390 goto out; 391 #ifdef ALLOW_SERIAL_NUMBER 392 if (dev->serial) 393 start += sprintf(start, format_string_serialnumber, 394 dev->serial); 395 #endif 396 out: 397 return start; 398 } 399 400 static char *usb_dump_desc(char *start, char *end, struct usb_device *dev) 401 { 402 int i; 403 404 if (start > end) 405 return start; 406 407 start = usb_dump_device_descriptor(start, end, &dev->descriptor); 408 409 if (start > end) 410 return start; 411 412 start = usb_dump_device_strings(start, end, dev); 413 414 for (i = 0; i < dev->descriptor.bNumConfigurations; i++) { 415 if (start > end) 416 return start; 417 start = usb_dump_config(dev->speed, 418 start, end, dev->config + i, 419 /* active ? */ 420 (dev->config + i) == dev->actconfig); 421 } 422 return start; 423 } 424 425 426 #ifdef PROC_EXTRA /* TBD: may want to add this code later */ 427 428 static char *usb_dump_hub_descriptor(char *start, char *end, 429 const struct usb_hub_descriptor *desc) 430 { 431 int leng = USB_DT_HUB_NONVAR_SIZE; 432 unsigned char *ptr = (unsigned char *)desc; 433 434 if (start > end) 435 return start; 436 start += sprintf(start, "Interface:"); 437 while (leng && start <= end) { 438 start += sprintf(start, " %02x", *ptr); 439 ptr++; leng--; 440 } 441 *start++ = '\n'; 442 return start; 443 } 444 445 static char *usb_dump_string(char *start, char *end, 446 const struct usb_device *dev, char *id, int index) 447 { 448 if (start > end) 449 return start; 450 start += sprintf(start, "Interface:"); 451 if (index <= dev->maxstring && dev->stringindex && 452 dev->stringindex[index]) 453 start += sprintf(start, "%s: %.100s ", id, 454 dev->stringindex[index]); 455 return start; 456 } 457 458 #endif /* PROC_EXTRA */ 459 460 /*****************************************************************/ 461 462 /* This is a recursive function. Parameters: 463 * buffer - the user-space buffer to write data into 464 * nbytes - the maximum number of bytes to write 465 * skip_bytes - the number of bytes to skip before writing anything 466 * file_offset - the offset into the devices file on completion 467 * The caller must own the device lock. 468 */ 469 static ssize_t usb_device_dump(char __user **buffer, size_t *nbytes, 470 loff_t *skip_bytes, loff_t *file_offset, 471 struct usb_device *usbdev, struct usb_bus *bus, 472 int level, int index, int count) 473 { 474 int chix; 475 int ret, cnt = 0; 476 int parent_devnum = 0; 477 char *pages_start, *data_end, *speed; 478 unsigned int length; 479 ssize_t total_written = 0; 480 struct usb_device *childdev = NULL; 481 482 /* don't bother with anything else if we're not writing any data */ 483 if (*nbytes <= 0) 484 return 0; 485 486 if (level > MAX_TOPO_LEVEL) 487 return 0; 488 /* allocate 2^1 pages = 8K (on i386); 489 * should be more than enough for one device */ 490 pages_start = (char *)__get_free_pages(GFP_NOIO, 1); 491 if (!pages_start) 492 return -ENOMEM; 493 494 if (usbdev->parent && usbdev->parent->devnum != -1) 495 parent_devnum = usbdev->parent->devnum; 496 /* 497 * So the root hub's parent is 0 and any device that is 498 * plugged into the root hub has a parent of 0. 499 */ 500 switch (usbdev->speed) { 501 case USB_SPEED_LOW: 502 speed = "1.5"; break; 503 case USB_SPEED_UNKNOWN: /* usb 1.1 root hub code */ 504 case USB_SPEED_FULL: 505 speed = "12"; break; 506 case USB_SPEED_WIRELESS: /* Wireless has no real fixed speed */ 507 case USB_SPEED_HIGH: 508 speed = "480"; break; 509 case USB_SPEED_SUPER: 510 speed = "5000"; break; 511 case USB_SPEED_SUPER_PLUS: 512 speed = "10000"; break; 513 default: 514 speed = "??"; 515 } 516 data_end = pages_start + sprintf(pages_start, format_topo, 517 bus->busnum, level, parent_devnum, 518 index, count, usbdev->devnum, 519 speed, usbdev->maxchild); 520 /* 521 * level = topology-tier level; 522 * parent_devnum = parent device number; 523 * index = parent's connector number; 524 * count = device count at this level 525 */ 526 /* If this is the root hub, display the bandwidth information */ 527 if (level == 0) { 528 int max; 529 530 /* super/high speed reserves 80%, full/low reserves 90% */ 531 if (usbdev->speed == USB_SPEED_HIGH || 532 usbdev->speed >= USB_SPEED_SUPER) 533 max = 800; 534 else 535 max = FRAME_TIME_MAX_USECS_ALLOC; 536 537 /* report "average" periodic allocation over a microsecond. 538 * the schedules are actually bursty, HCDs need to deal with 539 * that and just compute/report this average. 540 */ 541 data_end += sprintf(data_end, format_bandwidth, 542 bus->bandwidth_allocated, max, 543 (100 * bus->bandwidth_allocated + max / 2) 544 / max, 545 bus->bandwidth_int_reqs, 546 bus->bandwidth_isoc_reqs); 547 548 } 549 data_end = usb_dump_desc(data_end, pages_start + (2 * PAGE_SIZE) - 256, 550 usbdev); 551 552 if (data_end > (pages_start + (2 * PAGE_SIZE) - 256)) 553 data_end += sprintf(data_end, "(truncated)\n"); 554 555 length = data_end - pages_start; 556 /* if we can start copying some data to the user */ 557 if (length > *skip_bytes) { 558 length -= *skip_bytes; 559 if (length > *nbytes) 560 length = *nbytes; 561 if (copy_to_user(*buffer, pages_start + *skip_bytes, length)) { 562 free_pages((unsigned long)pages_start, 1); 563 return -EFAULT; 564 } 565 *nbytes -= length; 566 *file_offset += length; 567 total_written += length; 568 *buffer += length; 569 *skip_bytes = 0; 570 } else 571 *skip_bytes -= length; 572 573 free_pages((unsigned long)pages_start, 1); 574 575 /* Now look at all of this device's children. */ 576 usb_hub_for_each_child(usbdev, chix, childdev) { 577 usb_lock_device(childdev); 578 ret = usb_device_dump(buffer, nbytes, skip_bytes, 579 file_offset, childdev, bus, 580 level + 1, chix - 1, ++cnt); 581 usb_unlock_device(childdev); 582 if (ret == -EFAULT) 583 return total_written; 584 total_written += ret; 585 } 586 return total_written; 587 } 588 589 static ssize_t usb_device_read(struct file *file, char __user *buf, 590 size_t nbytes, loff_t *ppos) 591 { 592 struct usb_bus *bus; 593 ssize_t ret, total_written = 0; 594 loff_t skip_bytes = *ppos; 595 int id; 596 597 if (*ppos < 0) 598 return -EINVAL; 599 if (nbytes <= 0) 600 return 0; 601 602 mutex_lock(&usb_bus_idr_lock); 603 /* print devices for all busses */ 604 idr_for_each_entry(&usb_bus_idr, bus, id) { 605 /* recurse through all children of the root hub */ 606 if (!bus_to_hcd(bus)->rh_registered) 607 continue; 608 usb_lock_device(bus->root_hub); 609 ret = usb_device_dump(&buf, &nbytes, &skip_bytes, ppos, 610 bus->root_hub, bus, 0, 0, 0); 611 usb_unlock_device(bus->root_hub); 612 if (ret < 0) { 613 mutex_unlock(&usb_bus_idr_lock); 614 return ret; 615 } 616 total_written += ret; 617 } 618 mutex_unlock(&usb_bus_idr_lock); 619 return total_written; 620 } 621 622 /* Kernel lock for "lastev" protection */ 623 static __poll_t usb_device_poll(struct file *file, 624 struct poll_table_struct *wait) 625 { 626 unsigned int event_count; 627 628 poll_wait(file, &device_event.wait, wait); 629 630 event_count = atomic_read(&device_event.count); 631 if (file->f_version != event_count) { 632 file->f_version = event_count; 633 return EPOLLIN | EPOLLRDNORM; 634 } 635 636 return 0; 637 } 638 639 const struct file_operations usbfs_devices_fops = { 640 .llseek = no_seek_end_llseek, 641 .read = usb_device_read, 642 .poll = usb_device_poll, 643 }; 644