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