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)
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.
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.
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
22 *************************************************************
24 * <mountpoint>/devices contains USB topology, device, config, class,
25 * interface, & endpoint data.
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.)
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
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
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>
65 /* Define ALLOW_SERIAL_NUMBER if you want to see the serial number of devices */
66 #define ALLOW_SERIAL_NUMBER
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";
72 static const char *format_string_manufacturer
=
73 /* S: Manufacturer=xxxx */
74 "S: Manufacturer=%.100s\n";
76 static const char *format_string_product
=
78 "S: Product=%.100s\n";
80 #ifdef ALLOW_SERIAL_NUMBER
81 static const char *format_string_serialnumber
=
82 /* S: SerialNumber=xxxx */
83 "S: SerialNumber=%.100s\n";
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";
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";
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";
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";
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";
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";
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";
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.
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.
129 static struct device_connect_event
{
131 wait_queue_head_t wait
;
133 .count
= ATOMIC_INIT(1),
134 .wait
= __WAIT_QUEUE_HEAD_INITIALIZER(device_event
.wait
)
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 */
164 /*****************************************************************/
166 void usbfs_conn_disc_event(void)
168 atomic_add(2, &device_event
.count
);
169 wake_up(&device_event
.wait
);
172 static const char *class_decode(const int class)
176 for (ix
= 0; clas_info
[ix
].class != -1; ix
++)
177 if (clas_info
[ix
].class == class)
179 return clas_info
[ix
].class_name
;
182 static char *usb_dump_endpoint_descriptor(int speed
, char *start
, char *end
,
183 const struct usb_endpoint_descriptor
*desc
)
185 char dir
, unit
, *type
;
186 unsigned interval
, bandwidth
= 1;
191 dir
= usb_endpoint_dir_in(desc
) ? 'I' : 'O';
193 if (speed
== USB_SPEED_HIGH
) {
194 switch (le16_to_cpu(desc
->wMaxPacketSize
) & (0x03 << 11)) {
196 bandwidth
= 2; break;
198 bandwidth
= 3; break;
202 /* this isn't checking for illegal values */
203 switch (usb_endpoint_type(desc
)) {
204 case USB_ENDPOINT_XFER_CONTROL
:
206 if (speed
== USB_SPEED_HIGH
) /* uframes per NAK */
207 interval
= desc
->bInterval
;
210 dir
= 'B'; /* ctrl is bidirectional */
212 case USB_ENDPOINT_XFER_ISOC
:
214 interval
= 1 << (desc
->bInterval
- 1);
216 case USB_ENDPOINT_XFER_BULK
:
218 if (speed
== USB_SPEED_HIGH
&& dir
== 'O') /* uframes per NAK */
219 interval
= desc
->bInterval
;
223 case USB_ENDPOINT_XFER_INT
:
225 if (speed
== USB_SPEED_HIGH
)
226 interval
= 1 << (desc
->bInterval
- 1);
228 interval
= desc
->bInterval
;
230 default: /* "can't happen" */
233 interval
*= (speed
== USB_SPEED_HIGH
) ? 125 : 1000;
241 start
+= sprintf(start
, format_endpt
, desc
->bEndpointAddress
, dir
,
242 desc
->bmAttributes
, type
,
243 (le16_to_cpu(desc
->wMaxPacketSize
) & 0x07ff) *
249 static char *usb_dump_interface_descriptor(char *start
, char *end
,
250 const struct usb_interface_cache
*intfc
,
251 const struct usb_interface
*iface
,
254 const struct usb_interface_descriptor
*desc
;
255 const char *driver_name
= "";
260 desc
= &intfc
->altsetting
[setno
].desc
;
262 driver_name
= (iface
->dev
.driver
263 ? iface
->dev
.driver
->name
265 active
= (desc
== &iface
->cur_altsetting
->desc
);
267 start
+= sprintf(start
, format_iface
,
268 active
? '*' : ' ', /* mark active altsetting */
269 desc
->bInterfaceNumber
,
270 desc
->bAlternateSetting
,
272 desc
->bInterfaceClass
,
273 class_decode(desc
->bInterfaceClass
),
274 desc
->bInterfaceSubClass
,
275 desc
->bInterfaceProtocol
,
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
)
284 const struct usb_host_interface
*desc
= &intfc
->altsetting
[setno
];
287 start
= usb_dump_interface_descriptor(start
, end
, intfc
, iface
, setno
);
288 for (i
= 0; i
< desc
->desc
.bNumEndpoints
; i
++) {
291 start
= usb_dump_endpoint_descriptor(speed
,
292 start
, end
, &desc
->endpoint
[i
].desc
);
297 static char *usb_dump_iad_descriptor(char *start
, char *end
,
298 const struct usb_interface_assoc_descriptor
*iad
)
302 start
+= sprintf(start
, format_iad
,
303 iad
->bFirstInterface
,
304 iad
->bInterfaceCount
,
306 class_decode(iad
->bFunctionClass
),
307 iad
->bFunctionSubClass
,
308 iad
->bFunctionProtocol
);
314 * 1. marking active interface altsettings (code lists all, but should mark
315 * which ones are active, if any)
317 static char *usb_dump_config_descriptor(char *start
, char *end
,
318 const struct usb_config_descriptor
*desc
,
323 start
+= sprintf(start
, format_config
,
324 /* mark active/actual/current cfg. */
326 desc
->bNumInterfaces
,
327 desc
->bConfigurationValue
,
329 desc
->bMaxPower
* 2);
333 static char *usb_dump_config(int speed
, char *start
, char *end
,
334 const struct usb_host_config
*config
, int active
)
337 struct usb_interface_cache
*intfc
;
338 struct usb_interface
*interface
;
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
)
349 start
= usb_dump_iad_descriptor(start
, end
,
350 config
->intf_assoc
[i
]);
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
++) {
358 start
= usb_dump_interface(speed
,
359 start
, end
, intfc
, interface
, j
);
366 * Dump the different USB descriptors.
368 static char *usb_dump_device_descriptor(char *start
, char *end
,
369 const struct usb_device_descriptor
*desc
)
371 u16 bcdUSB
= le16_to_cpu(desc
->bcdUSB
);
372 u16 bcdDevice
= le16_to_cpu(desc
->bcdDevice
);
376 start
+= sprintf(start
, format_device1
,
377 bcdUSB
>> 8, bcdUSB
& 0xff,
379 class_decode(desc
->bDeviceClass
),
380 desc
->bDeviceSubClass
,
381 desc
->bDeviceProtocol
,
382 desc
->bMaxPacketSize0
,
383 desc
->bNumConfigurations
);
386 start
+= sprintf(start
, format_device2
,
387 le16_to_cpu(desc
->idVendor
),
388 le16_to_cpu(desc
->idProduct
),
389 bcdDevice
>> 8, bcdDevice
& 0xff);
394 * Dump the different strings that this device holds.
396 static char *usb_dump_device_strings(char *start
, char *end
,
397 struct usb_device
*dev
)
401 if (dev
->manufacturer
)
402 start
+= sprintf(start
, format_string_manufacturer
,
407 start
+= sprintf(start
, format_string_product
, dev
->product
);
410 #ifdef ALLOW_SERIAL_NUMBER
412 start
+= sprintf(start
, format_string_serialnumber
,
419 static char *usb_dump_desc(char *start
, char *end
, struct usb_device
*dev
)
426 start
= usb_dump_device_descriptor(start
, end
, &dev
->descriptor
);
431 start
= usb_dump_device_strings(start
, end
, dev
);
433 for (i
= 0; i
< dev
->descriptor
.bNumConfigurations
; i
++) {
436 start
= usb_dump_config(dev
->speed
,
437 start
, end
, dev
->config
+ i
,
439 (dev
->config
+ i
) == dev
->actconfig
);
445 #ifdef PROC_EXTRA /* TBD: may want to add this code later */
447 static char *usb_dump_hub_descriptor(char *start
, char *end
,
448 const struct usb_hub_descriptor
*desc
)
450 int leng
= USB_DT_HUB_NONVAR_SIZE
;
451 unsigned char *ptr
= (unsigned char *)desc
;
455 start
+= sprintf(start
, "Interface:");
456 while (leng
&& start
<= end
) {
457 start
+= sprintf(start
, " %02x", *ptr
);
464 static char *usb_dump_string(char *start
, char *end
,
465 const struct usb_device
*dev
, char *id
, int index
)
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
]);
477 #endif /* PROC_EXTRA */
479 /*****************************************************************/
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.
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
)
495 int parent_devnum
= 0;
496 char *pages_start
, *data_end
, *speed
;
498 ssize_t total_written
= 0;
500 /* don't bother with anything else if we're not writing any data */
504 if (level
> MAX_TOPO_LEVEL
)
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);
512 if (usbdev
->parent
&& usbdev
->parent
->devnum
!= -1)
513 parent_devnum
= usbdev
->parent
->devnum
;
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.
518 switch (usbdev
->speed
) {
520 speed
= "1.5"; break;
521 case USB_SPEED_UNKNOWN
: /* usb 1.1 root hub code */
524 case USB_SPEED_WIRELESS
: /* Wireless has no real fixed speed */
526 speed
= "480"; break;
527 case USB_SPEED_SUPER
:
528 speed
= "5000"; break;
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
);
537 * level = topology-tier level;
538 * parent_devnum = parent device number;
539 * index = parent's connector number;
540 * count = device count at this level
542 /* If this is the root hub, display the bandwidth information */
546 /* high speed reserves 80%, full/low reserves 90% */
547 if (usbdev
->speed
== USB_SPEED_HIGH
)
550 max
= FRAME_TIME_MAX_USECS_ALLOC
;
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.
556 data_end
+= sprintf(data_end
, format_bandwidth
,
557 bus
->bandwidth_allocated
, max
,
558 (100 * bus
->bandwidth_allocated
+ max
/ 2)
560 bus
->bandwidth_int_reqs
,
561 bus
->bandwidth_isoc_reqs
);
564 data_end
= usb_dump_desc(data_end
, pages_start
+ (2 * PAGE_SIZE
) - 256,
567 if (data_end
> (pages_start
+ (2 * PAGE_SIZE
) - 256))
568 data_end
+= sprintf(data_end
, "(truncated)\n");
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
)
576 if (copy_to_user(*buffer
, pages_start
+ *skip_bytes
, length
)) {
577 free_pages((unsigned long)pages_start
, 1);
581 *file_offset
+= length
;
582 total_written
+= length
;
586 *skip_bytes
-= length
;
588 free_pages((unsigned long)pages_start
, 1);
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
];
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
);
601 return total_written
;
602 total_written
+= ret
;
605 return total_written
;
608 static ssize_t
usb_device_read(struct file
*file
, char __user
*buf
,
609 size_t nbytes
, loff_t
*ppos
)
612 ssize_t ret
, total_written
= 0;
613 loff_t skip_bytes
= *ppos
;
619 if (!access_ok(VERIFY_WRITE
, buf
, nbytes
))
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 */
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
);
633 mutex_unlock(&usb_bus_list_lock
);
636 total_written
+= ret
;
638 mutex_unlock(&usb_bus_list_lock
);
639 return total_written
;
642 /* Kernel lock for "lastev" protection */
643 static unsigned int usb_device_poll(struct file
*file
,
644 struct poll_table_struct
*wait
)
646 unsigned int event_count
;
648 poll_wait(file
, &device_event
.wait
, wait
);
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
;
659 static loff_t
usb_device_lseek(struct file
*file
, loff_t offset
, int orig
)
663 mutex_lock(&file
->f_dentry
->d_inode
->i_mutex
);
667 file
->f_pos
= offset
;
671 file
->f_pos
+= offset
;
679 mutex_unlock(&file
->f_dentry
->d_inode
->i_mutex
);
683 const struct file_operations usbfs_devices_fops
= {
684 .llseek
= usb_device_lseek
,
685 .read
= usb_device_read
,
686 .poll
= usb_device_poll
,