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=ddd MxCh=dd */
70 "\nT: Bus=%2.2d Lev=%2.2d Prnt=%2.2d Port=%2.2d Cnt=%2.2d Dev#=%3d Spd=%3s MxCh=%2d\n";
72 static const char *format_string_manufacturer
=
73 "S: Manufacturer=%.100s\n";
75 static const char *format_string_product
=
76 "S: Product=%.100s\n";
78 #ifdef ALLOW_SERIAL_NUMBER
79 static const char *format_string_serialnumber
=
80 "S: SerialNumber=%.100s\n";
83 static const char *format_bandwidth
=
84 /* B: Alloc=ddd/ddd us (xx%), #Int=ddd, #Iso=ddd */
85 "B: Alloc=%3d/%3d us (%2d%%), #Int=%3d, #Iso=%3d\n";
87 static const char *format_device1
=
88 /* D: Ver=xx.xx Cls=xx(sssss) Sub=xx Prot=xx MxPS=dd #Cfgs=dd */
89 "D: Ver=%2x.%02x Cls=%02x(%-5s) Sub=%02x Prot=%02x MxPS=%2d #Cfgs=%3d\n";
91 static const char *format_device2
=
92 "P: Vendor=%04x ProdID=%04x Rev=%2x.%02x\n";
94 static const char *format_config
=
95 /* C: #Ifs=dd Cfg#=dd Atr=xx MPwr=dddmA */
96 "C:%c #Ifs=%2d Cfg#=%2d Atr=%02x MxPwr=%3dmA\n";
98 static const char *format_iad
=
99 /* A: FirstIf#=dd IfCount=dd Cls=xx(sssss) Sub=xx Prot=xx */
100 "A: FirstIf#=%2d IfCount=%2d Cls=%02x(%-5s) Sub=%02x Prot=%02x\n";
102 static const char *format_iface
=
103 "I:%c If#=%2d Alt=%2d #EPs=%2d Cls=%02x(%-5s) Sub=%02x Prot=%02x Driver=%s\n";
105 static const char *format_endpt
=
106 /* E: Ad=xx(s) Atr=xx(ssss) MxPS=dddd Ivl=D?s */
107 "E: Ad=%02x(%c) Atr=%02x(%-4s) MxPS=%4d Ivl=%d%cs\n";
111 * Need access to the driver and USB bus lists.
112 * extern struct list_head usb_bus_list;
113 * However, these will come from functions that return ptrs to each of them.
117 * Wait for an connect/disconnect event to happen. We initialize
118 * the event counter with an odd number, and each event will increment
119 * the event counter by two, so it will always _stay_ odd. That means
120 * that it will never be zero, so "event 0" will never match a current
121 * event, and thus 'poll' will always trigger as readable for the first
122 * time it gets called.
124 static struct device_connect_event
{
126 wait_queue_head_t wait
;
128 .count
= ATOMIC_INIT(1),
129 .wait
= __WAIT_QUEUE_HEAD_INITIALIZER(device_event
.wait
)
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_PHYSICAL
, "PID"},
144 {USB_CLASS_STILL_IMAGE
, "still"},
145 {USB_CLASS_PRINTER
, "print"},
146 {USB_CLASS_MASS_STORAGE
, "stor."},
147 {USB_CLASS_HUB
, "hub"},
148 {USB_CLASS_CDC_DATA
, "data"},
149 {USB_CLASS_CSCID
, "scard"},
150 {USB_CLASS_CONTENT_SEC
, "c-sec"},
151 {USB_CLASS_VIDEO
, "video"},
152 {USB_CLASS_WIRELESS_CONTROLLER
, "wlcon"},
153 {USB_CLASS_MISC
, "misc"},
154 {USB_CLASS_APP_SPEC
, "app."},
155 {USB_CLASS_VENDOR_SPEC
, "vend."},
156 {-1, "unk."} /* leave as last */
159 /*****************************************************************/
161 void usbfs_conn_disc_event(void)
163 atomic_add(2, &device_event
.count
);
164 wake_up(&device_event
.wait
);
167 static const char *class_decode(const int class)
171 for (ix
= 0; clas_info
[ix
].class != -1; ix
++)
172 if (clas_info
[ix
].class == class)
174 return clas_info
[ix
].class_name
;
177 static char *usb_dump_endpoint_descriptor(int speed
, char *start
, char *end
,
178 const struct usb_endpoint_descriptor
*desc
)
180 char dir
, unit
, *type
;
181 unsigned interval
, bandwidth
= 1;
186 dir
= usb_endpoint_dir_in(desc
) ? 'I' : 'O';
188 if (speed
== USB_SPEED_HIGH
) {
189 switch (le16_to_cpu(desc
->wMaxPacketSize
) & (0x03 << 11)) {
191 bandwidth
= 2; break;
193 bandwidth
= 3; break;
197 /* this isn't checking for illegal values */
198 switch (usb_endpoint_type(desc
)) {
199 case USB_ENDPOINT_XFER_CONTROL
:
201 if (speed
== USB_SPEED_HIGH
) /* uframes per NAK */
202 interval
= desc
->bInterval
;
205 dir
= 'B'; /* ctrl is bidirectional */
207 case USB_ENDPOINT_XFER_ISOC
:
209 interval
= 1 << (desc
->bInterval
- 1);
211 case USB_ENDPOINT_XFER_BULK
:
213 if (speed
== USB_SPEED_HIGH
&& dir
== 'O') /* uframes per NAK */
214 interval
= desc
->bInterval
;
218 case USB_ENDPOINT_XFER_INT
:
220 if (speed
== USB_SPEED_HIGH
)
221 interval
= 1 << (desc
->bInterval
- 1);
223 interval
= desc
->bInterval
;
225 default: /* "can't happen" */
228 interval
*= (speed
== USB_SPEED_HIGH
) ? 125 : 1000;
236 start
+= sprintf(start
, format_endpt
, desc
->bEndpointAddress
, dir
,
237 desc
->bmAttributes
, type
,
238 (le16_to_cpu(desc
->wMaxPacketSize
) & 0x07ff) *
244 static char *usb_dump_interface_descriptor(char *start
, char *end
,
245 const struct usb_interface_cache
*intfc
,
246 const struct usb_interface
*iface
,
249 const struct usb_interface_descriptor
*desc
;
250 const char *driver_name
= "";
255 desc
= &intfc
->altsetting
[setno
].desc
;
257 driver_name
= (iface
->dev
.driver
258 ? iface
->dev
.driver
->name
260 active
= (desc
== &iface
->cur_altsetting
->desc
);
262 start
+= sprintf(start
, format_iface
,
263 active
? '*' : ' ', /* mark active altsetting */
264 desc
->bInterfaceNumber
,
265 desc
->bAlternateSetting
,
267 desc
->bInterfaceClass
,
268 class_decode(desc
->bInterfaceClass
),
269 desc
->bInterfaceSubClass
,
270 desc
->bInterfaceProtocol
,
275 static char *usb_dump_interface(int speed
, char *start
, char *end
,
276 const struct usb_interface_cache
*intfc
,
277 const struct usb_interface
*iface
, int setno
)
279 const struct usb_host_interface
*desc
= &intfc
->altsetting
[setno
];
282 start
= usb_dump_interface_descriptor(start
, end
, intfc
, iface
, setno
);
283 for (i
= 0; i
< desc
->desc
.bNumEndpoints
; i
++) {
286 start
= usb_dump_endpoint_descriptor(speed
,
287 start
, end
, &desc
->endpoint
[i
].desc
);
292 static char *usb_dump_iad_descriptor(char *start
, char *end
,
293 const struct usb_interface_assoc_descriptor
*iad
)
297 start
+= sprintf(start
, format_iad
,
298 iad
->bFirstInterface
,
299 iad
->bInterfaceCount
,
301 class_decode(iad
->bFunctionClass
),
302 iad
->bFunctionSubClass
,
303 iad
->bFunctionProtocol
);
309 * 1. marking active interface altsettings (code lists all, but should mark
310 * which ones are active, if any)
312 static char *usb_dump_config_descriptor(char *start
, char *end
,
313 const struct usb_config_descriptor
*desc
,
318 start
+= sprintf(start
, format_config
,
319 /* mark active/actual/current cfg. */
321 desc
->bNumInterfaces
,
322 desc
->bConfigurationValue
,
324 desc
->bMaxPower
* 2);
328 static char *usb_dump_config(int speed
, char *start
, char *end
,
329 const struct usb_host_config
*config
, int active
)
332 struct usb_interface_cache
*intfc
;
333 struct usb_interface
*interface
;
338 /* getting these some in 2.3.7; none in 2.3.6 */
339 return start
+ sprintf(start
, "(null Cfg. desc.)\n");
340 start
= usb_dump_config_descriptor(start
, end
, &config
->desc
, active
);
341 for (i
= 0; i
< USB_MAXIADS
; i
++) {
342 if (config
->intf_assoc
[i
] == NULL
)
344 start
= usb_dump_iad_descriptor(start
, end
,
345 config
->intf_assoc
[i
]);
347 for (i
= 0; i
< config
->desc
.bNumInterfaces
; i
++) {
348 intfc
= config
->intf_cache
[i
];
349 interface
= config
->interface
[i
];
350 for (j
= 0; j
< intfc
->num_altsetting
; j
++) {
353 start
= usb_dump_interface(speed
,
354 start
, end
, intfc
, interface
, j
);
361 * Dump the different USB descriptors.
363 static char *usb_dump_device_descriptor(char *start
, char *end
,
364 const struct usb_device_descriptor
*desc
)
366 u16 bcdUSB
= le16_to_cpu(desc
->bcdUSB
);
367 u16 bcdDevice
= le16_to_cpu(desc
->bcdDevice
);
371 start
+= sprintf(start
, format_device1
,
372 bcdUSB
>> 8, bcdUSB
& 0xff,
374 class_decode(desc
->bDeviceClass
),
375 desc
->bDeviceSubClass
,
376 desc
->bDeviceProtocol
,
377 desc
->bMaxPacketSize0
,
378 desc
->bNumConfigurations
);
381 start
+= sprintf(start
, format_device2
,
382 le16_to_cpu(desc
->idVendor
),
383 le16_to_cpu(desc
->idProduct
),
384 bcdDevice
>> 8, bcdDevice
& 0xff);
389 * Dump the different strings that this device holds.
391 static char *usb_dump_device_strings(char *start
, char *end
,
392 struct usb_device
*dev
)
396 if (dev
->manufacturer
)
397 start
+= sprintf(start
, format_string_manufacturer
,
402 start
+= sprintf(start
, format_string_product
, dev
->product
);
405 #ifdef ALLOW_SERIAL_NUMBER
407 start
+= sprintf(start
, format_string_serialnumber
,
414 static char *usb_dump_desc(char *start
, char *end
, struct usb_device
*dev
)
421 start
= usb_dump_device_descriptor(start
, end
, &dev
->descriptor
);
426 start
= usb_dump_device_strings(start
, end
, dev
);
428 for (i
= 0; i
< dev
->descriptor
.bNumConfigurations
; i
++) {
431 start
= usb_dump_config(dev
->speed
,
432 start
, end
, dev
->config
+ i
,
434 (dev
->config
+ i
) == dev
->actconfig
);
440 #ifdef PROC_EXTRA /* TBD: may want to add this code later */
442 static char *usb_dump_hub_descriptor(char *start
, char *end
,
443 const struct usb_hub_descriptor
*desc
)
445 int leng
= USB_DT_HUB_NONVAR_SIZE
;
446 unsigned char *ptr
= (unsigned char *)desc
;
450 start
+= sprintf(start
, "Interface:");
451 while (leng
&& start
<= end
) {
452 start
+= sprintf(start
, " %02x", *ptr
);
459 static char *usb_dump_string(char *start
, char *end
,
460 const struct usb_device
*dev
, char *id
, int index
)
464 start
+= sprintf(start
, "Interface:");
465 if (index
<= dev
->maxstring
&& dev
->stringindex
&&
466 dev
->stringindex
[index
])
467 start
+= sprintf(start
, "%s: %.100s ", id
,
468 dev
->stringindex
[index
]);
472 #endif /* PROC_EXTRA */
474 /*****************************************************************/
476 /* This is a recursive function. Parameters:
477 * buffer - the user-space buffer to write data into
478 * nbytes - the maximum number of bytes to write
479 * skip_bytes - the number of bytes to skip before writing anything
480 * file_offset - the offset into the devices file on completion
481 * The caller must own the device lock.
483 static ssize_t
usb_device_dump(char __user
**buffer
, size_t *nbytes
,
484 loff_t
*skip_bytes
, loff_t
*file_offset
,
485 struct usb_device
*usbdev
, struct usb_bus
*bus
,
486 int level
, int index
, int count
)
490 int parent_devnum
= 0;
491 char *pages_start
, *data_end
, *speed
;
493 ssize_t total_written
= 0;
495 /* don't bother with anything else if we're not writing any data */
499 if (level
> MAX_TOPO_LEVEL
)
501 /* allocate 2^1 pages = 8K (on i386);
502 * should be more than enough for one device */
503 pages_start
= (char *)__get_free_pages(GFP_NOIO
, 1);
507 if (usbdev
->parent
&& usbdev
->parent
->devnum
!= -1)
508 parent_devnum
= usbdev
->parent
->devnum
;
510 * So the root hub's parent is 0 and any device that is
511 * plugged into the root hub has a parent of 0.
513 switch (usbdev
->speed
) {
515 speed
= "1.5"; break;
516 case USB_SPEED_UNKNOWN
: /* usb 1.1 root hub code */
518 speed
= "12 "; break;
520 speed
= "480"; break;
524 data_end
= pages_start
+ sprintf(pages_start
, format_topo
,
525 bus
->busnum
, level
, parent_devnum
,
526 index
, count
, usbdev
->devnum
,
527 speed
, usbdev
->maxchild
);
529 * level = topology-tier level;
530 * parent_devnum = parent device number;
531 * index = parent's connector number;
532 * count = device count at this level
534 /* If this is the root hub, display the bandwidth information */
538 /* high speed reserves 80%, full/low reserves 90% */
539 if (usbdev
->speed
== USB_SPEED_HIGH
)
542 max
= FRAME_TIME_MAX_USECS_ALLOC
;
544 /* report "average" periodic allocation over a microsecond.
545 * the schedules are actually bursty, HCDs need to deal with
546 * that and just compute/report this average.
548 data_end
+= sprintf(data_end
, format_bandwidth
,
549 bus
->bandwidth_allocated
, max
,
550 (100 * bus
->bandwidth_allocated
+ max
/ 2)
552 bus
->bandwidth_int_reqs
,
553 bus
->bandwidth_isoc_reqs
);
556 data_end
= usb_dump_desc(data_end
, pages_start
+ (2 * PAGE_SIZE
) - 256,
559 if (data_end
> (pages_start
+ (2 * PAGE_SIZE
) - 256))
560 data_end
+= sprintf(data_end
, "(truncated)\n");
562 length
= data_end
- pages_start
;
563 /* if we can start copying some data to the user */
564 if (length
> *skip_bytes
) {
565 length
-= *skip_bytes
;
566 if (length
> *nbytes
)
568 if (copy_to_user(*buffer
, pages_start
+ *skip_bytes
, length
)) {
569 free_pages((unsigned long)pages_start
, 1);
573 *file_offset
+= length
;
574 total_written
+= length
;
578 *skip_bytes
-= length
;
580 free_pages((unsigned long)pages_start
, 1);
582 /* Now look at all of this device's children. */
583 for (chix
= 0; chix
< usbdev
->maxchild
; chix
++) {
584 struct usb_device
*childdev
= usbdev
->children
[chix
];
587 usb_lock_device(childdev
);
588 ret
= usb_device_dump(buffer
, nbytes
, skip_bytes
,
589 file_offset
, childdev
, bus
,
590 level
+ 1, chix
, ++cnt
);
591 usb_unlock_device(childdev
);
593 return total_written
;
594 total_written
+= ret
;
597 return total_written
;
600 static ssize_t
usb_device_read(struct file
*file
, char __user
*buf
,
601 size_t nbytes
, loff_t
*ppos
)
604 ssize_t ret
, total_written
= 0;
605 loff_t skip_bytes
= *ppos
;
611 if (!access_ok(VERIFY_WRITE
, buf
, nbytes
))
614 mutex_lock(&usb_bus_list_lock
);
615 /* print devices for all busses */
616 list_for_each_entry(bus
, &usb_bus_list
, bus_list
) {
617 /* recurse through all children of the root hub */
620 usb_lock_device(bus
->root_hub
);
621 ret
= usb_device_dump(&buf
, &nbytes
, &skip_bytes
, ppos
,
622 bus
->root_hub
, bus
, 0, 0, 0);
623 usb_unlock_device(bus
->root_hub
);
625 mutex_unlock(&usb_bus_list_lock
);
628 total_written
+= ret
;
630 mutex_unlock(&usb_bus_list_lock
);
631 return total_written
;
634 /* Kernel lock for "lastev" protection */
635 static unsigned int usb_device_poll(struct file
*file
,
636 struct poll_table_struct
*wait
)
638 unsigned int event_count
;
640 poll_wait(file
, &device_event
.wait
, wait
);
642 event_count
= atomic_read(&device_event
.count
);
643 if (file
->f_version
!= event_count
) {
644 file
->f_version
= event_count
;
645 return POLLIN
| POLLRDNORM
;
651 static loff_t
usb_device_lseek(struct file
*file
, loff_t offset
, int orig
)
655 mutex_lock(&file
->f_dentry
->d_inode
->i_mutex
);
659 file
->f_pos
= offset
;
663 file
->f_pos
+= offset
;
671 mutex_unlock(&file
->f_dentry
->d_inode
->i_mutex
);
675 const struct file_operations usbfs_devices_fops
= {
676 .llseek
= usb_device_lseek
,
677 .read
= usb_device_read
,
678 .poll
= usb_device_poll
,