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