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)
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.
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.
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
21 *************************************************************
23 * <mountpoint>/devices contains USB topology, device, config, class,
24 * interface, & endpoint data.
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.)
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
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
50 * $Id: devices.c,v 1.5 2000/01/11 13:58:21 tom Exp $
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>
66 #define MAX_TOPO_LEVEL 6
68 /* Define ALLOW_SERIAL_NUMBER if you want to see the serial number of devices */
69 #define ALLOW_SERIAL_NUMBER
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";
75 static const char *format_string_manufacturer
=
76 /* S: Manufacturer=xxxx */
77 "S: Manufacturer=%.100s\n";
79 static const char *format_string_product
=
81 "S: Product=%.100s\n";
83 #ifdef ALLOW_SERIAL_NUMBER
84 static const char *format_string_serialnumber
=
85 /* S: SerialNumber=xxxx */
86 "S: SerialNumber=%.100s\n";
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";
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";
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";
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";
105 static const char *format_iface
=
106 /* I: If#=dd Alt=dd #EPs=dd Cls=xx(sssss) Sub=xx Prot=xx Driver=xxxx*/
107 "I:%c If#=%2d Alt=%2d #EPs=%2d Cls=%02x(%-5s) Sub=%02x Prot=%02x Driver=%s\n";
109 static const char *format_endpt
=
110 /* E: Ad=xx(s) Atr=xx(ssss) MxPS=dddd Ivl=D?s */
111 "E: Ad=%02x(%c) Atr=%02x(%-4s) MxPS=%4d Ivl=%d%cs\n";
115 * Need access to the driver and USB bus lists.
116 * extern struct list_head usb_bus_list;
117 * However, these will come from functions that return ptrs to each of them.
120 static DECLARE_WAIT_QUEUE_HEAD(deviceconndiscwq
);
121 static unsigned int conndiscevcnt
= 0;
123 /* this struct stores the poll state for <mountpoint>/devices pollers */
124 struct usb_device_status
{
133 static const struct class_info clas_info
[] =
134 { /* max. 5 chars. per name string */
135 {USB_CLASS_PER_INTERFACE
, ">ifc"},
136 {USB_CLASS_AUDIO
, "audio"},
137 {USB_CLASS_COMM
, "comm."},
138 {USB_CLASS_HID
, "HID"},
139 {USB_CLASS_HUB
, "hub"},
140 {USB_CLASS_PHYSICAL
, "PID"},
141 {USB_CLASS_PRINTER
, "print"},
142 {USB_CLASS_MASS_STORAGE
, "stor."},
143 {USB_CLASS_CDC_DATA
, "data"},
144 {USB_CLASS_APP_SPEC
, "app."},
145 {USB_CLASS_VENDOR_SPEC
, "vend."},
146 {USB_CLASS_STILL_IMAGE
, "still"},
147 {USB_CLASS_CSCID
, "scard"},
148 {USB_CLASS_CONTENT_SEC
, "c-sec"},
149 {-1, "unk."} /* leave as last */
152 /*****************************************************************/
154 void usbfs_conn_disc_event(void)
157 wake_up(&deviceconndiscwq
);
160 static const char *class_decode(const int class)
164 for (ix
= 0; clas_info
[ix
].class != -1; ix
++)
165 if (clas_info
[ix
].class == class)
167 return clas_info
[ix
].class_name
;
170 static char *usb_dump_endpoint_descriptor(
174 const struct usb_endpoint_descriptor
*desc
177 char dir
, unit
, *type
;
178 unsigned interval
, bandwidth
= 1;
183 dir
= usb_endpoint_dir_in(desc
) ? 'I' : 'O';
185 if (speed
== USB_SPEED_HIGH
) {
186 switch (le16_to_cpu(desc
->wMaxPacketSize
) & (0x03 << 11)) {
187 case 1 << 11: bandwidth
= 2; break;
188 case 2 << 11: bandwidth
= 3; break;
192 /* this isn't checking for illegal values */
193 switch (desc
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) {
194 case USB_ENDPOINT_XFER_CONTROL
:
196 if (speed
== USB_SPEED_HIGH
) /* uframes per NAK */
197 interval
= desc
->bInterval
;
200 dir
= 'B'; /* ctrl is bidirectional */
202 case USB_ENDPOINT_XFER_ISOC
:
204 interval
= 1 << (desc
->bInterval
- 1);
206 case USB_ENDPOINT_XFER_BULK
:
208 if (speed
== USB_SPEED_HIGH
&& dir
== 'O') /* uframes per NAK */
209 interval
= desc
->bInterval
;
213 case USB_ENDPOINT_XFER_INT
:
215 if (speed
== USB_SPEED_HIGH
)
216 interval
= 1 << (desc
->bInterval
- 1);
218 interval
= desc
->bInterval
;
220 default: /* "can't happen" */
223 interval
*= (speed
== USB_SPEED_HIGH
) ? 125 : 1000;
231 start
+= sprintf(start
, format_endpt
, desc
->bEndpointAddress
, dir
,
232 desc
->bmAttributes
, type
,
233 (le16_to_cpu(desc
->wMaxPacketSize
) & 0x07ff) * bandwidth
,
238 static char *usb_dump_interface_descriptor(char *start
, char *end
,
239 const struct usb_interface_cache
*intfc
,
240 const struct usb_interface
*iface
,
243 const struct usb_interface_descriptor
*desc
= &intfc
->altsetting
[setno
].desc
;
244 const char *driver_name
= "";
249 down_read(&usb_bus_type
.subsys
.rwsem
);
251 driver_name
= (iface
->dev
.driver
252 ? iface
->dev
.driver
->name
254 active
= (desc
== &iface
->cur_altsetting
->desc
);
256 start
+= sprintf(start
, format_iface
,
257 active
? '*' : ' ', /* mark active altsetting */
258 desc
->bInterfaceNumber
,
259 desc
->bAlternateSetting
,
261 desc
->bInterfaceClass
,
262 class_decode(desc
->bInterfaceClass
),
263 desc
->bInterfaceSubClass
,
264 desc
->bInterfaceProtocol
,
266 up_read(&usb_bus_type
.subsys
.rwsem
);
270 static char *usb_dump_interface(
274 const struct usb_interface_cache
*intfc
,
275 const struct usb_interface
*iface
,
278 const struct usb_host_interface
*desc
= &intfc
->altsetting
[setno
];
281 start
= usb_dump_interface_descriptor(start
, end
, intfc
, iface
, setno
);
282 for (i
= 0; i
< desc
->desc
.bNumEndpoints
; i
++) {
285 start
= usb_dump_endpoint_descriptor(speed
,
286 start
, end
, &desc
->endpoint
[i
].desc
);
293 * 1. marking active interface altsettings (code lists all, but should mark
294 * which ones are active, if any)
297 static char *usb_dump_config_descriptor(char *start
, char *end
, const struct usb_config_descriptor
*desc
, int active
)
301 start
+= sprintf(start
, format_config
,
302 active
? '*' : ' ', /* mark active/actual/current cfg. */
303 desc
->bNumInterfaces
,
304 desc
->bConfigurationValue
,
306 desc
->bMaxPower
* 2);
310 static char *usb_dump_config (
314 const struct usb_host_config
*config
,
319 struct usb_interface_cache
*intfc
;
320 struct usb_interface
*interface
;
324 if (!config
) /* getting these some in 2.3.7; none in 2.3.6 */
325 return start
+ sprintf(start
, "(null Cfg. desc.)\n");
326 start
= usb_dump_config_descriptor(start
, end
, &config
->desc
, active
);
327 for (i
= 0; i
< config
->desc
.bNumInterfaces
; i
++) {
328 intfc
= config
->intf_cache
[i
];
329 interface
= config
->interface
[i
];
330 for (j
= 0; j
< intfc
->num_altsetting
; j
++) {
333 start
= usb_dump_interface(speed
,
334 start
, end
, intfc
, interface
, j
);
341 * Dump the different USB descriptors.
343 static char *usb_dump_device_descriptor(char *start
, char *end
, const struct usb_device_descriptor
*desc
)
345 u16 bcdUSB
= le16_to_cpu(desc
->bcdUSB
);
346 u16 bcdDevice
= le16_to_cpu(desc
->bcdDevice
);
350 start
+= sprintf(start
, format_device1
,
351 bcdUSB
>> 8, bcdUSB
& 0xff,
353 class_decode (desc
->bDeviceClass
),
354 desc
->bDeviceSubClass
,
355 desc
->bDeviceProtocol
,
356 desc
->bMaxPacketSize0
,
357 desc
->bNumConfigurations
);
360 start
+= sprintf(start
, format_device2
,
361 le16_to_cpu(desc
->idVendor
),
362 le16_to_cpu(desc
->idProduct
),
363 bcdDevice
>> 8, bcdDevice
& 0xff);
368 * Dump the different strings that this device holds.
370 static char *usb_dump_device_strings(char *start
, char *end
, struct usb_device
*dev
)
374 if (dev
->manufacturer
)
375 start
+= sprintf(start
, format_string_manufacturer
, dev
->manufacturer
);
379 start
+= sprintf(start
, format_string_product
, dev
->product
);
382 #ifdef ALLOW_SERIAL_NUMBER
384 start
+= sprintf(start
, format_string_serialnumber
, dev
->serial
);
390 static char *usb_dump_desc(char *start
, char *end
, struct usb_device
*dev
)
397 start
= usb_dump_device_descriptor(start
, end
, &dev
->descriptor
);
402 start
= usb_dump_device_strings(start
, end
, dev
);
404 for (i
= 0; i
< dev
->descriptor
.bNumConfigurations
; i
++) {
407 start
= usb_dump_config(dev
->speed
,
408 start
, end
, dev
->config
+ i
,
410 (dev
->config
+ i
) == dev
->actconfig
);
416 #ifdef PROC_EXTRA /* TBD: may want to add this code later */
418 static char *usb_dump_hub_descriptor(char *start
, char *end
, const struct usb_hub_descriptor
* desc
)
420 int leng
= USB_DT_HUB_NONVAR_SIZE
;
421 unsigned char *ptr
= (unsigned char *)desc
;
425 start
+= sprintf(start
, "Interface:");
426 while (leng
&& start
<= end
) {
427 start
+= sprintf(start
, " %02x", *ptr
);
434 static char *usb_dump_string(char *start
, char *end
, const struct usb_device
*dev
, char *id
, int index
)
438 start
+= sprintf(start
, "Interface:");
439 if (index
<= dev
->maxstring
&& dev
->stringindex
&& dev
->stringindex
[index
])
440 start
+= sprintf(start
, "%s: %.100s ", id
, dev
->stringindex
[index
]);
444 #endif /* PROC_EXTRA */
446 /*****************************************************************/
448 /* This is a recursive function. Parameters:
449 * buffer - the user-space buffer to write data into
450 * nbytes - the maximum number of bytes to write
451 * skip_bytes - the number of bytes to skip before writing anything
452 * file_offset - the offset into the devices file on completion
453 * The caller must own the device lock.
455 static ssize_t
usb_device_dump(char __user
**buffer
, size_t *nbytes
, loff_t
*skip_bytes
, loff_t
*file_offset
,
456 struct usb_device
*usbdev
, struct usb_bus
*bus
, int level
, int index
, int count
)
460 int parent_devnum
= 0;
461 char *pages_start
, *data_end
, *speed
;
463 ssize_t total_written
= 0;
465 /* don't bother with anything else if we're not writing any data */
469 if (level
> MAX_TOPO_LEVEL
)
471 /* allocate 2^1 pages = 8K (on i386); should be more than enough for one device */
472 if (!(pages_start
= (char*) __get_free_pages(GFP_KERNEL
,1)))
475 if (usbdev
->parent
&& usbdev
->parent
->devnum
!= -1)
476 parent_devnum
= usbdev
->parent
->devnum
;
478 * So the root hub's parent is 0 and any device that is
479 * plugged into the root hub has a parent of 0.
481 switch (usbdev
->speed
) {
483 speed
= "1.5"; break;
484 case USB_SPEED_UNKNOWN
: /* usb 1.1 root hub code */
486 speed
= "12 "; break;
488 speed
= "480"; break;
492 data_end
= pages_start
+ sprintf(pages_start
, format_topo
,
493 bus
->busnum
, level
, parent_devnum
,
494 index
, count
, usbdev
->devnum
,
495 speed
, usbdev
->maxchild
);
497 * level = topology-tier level;
498 * parent_devnum = parent device number;
499 * index = parent's connector number;
500 * count = device count at this level
502 /* If this is the root hub, display the bandwidth information */
506 /* high speed reserves 80%, full/low reserves 90% */
507 if (usbdev
->speed
== USB_SPEED_HIGH
)
510 max
= FRAME_TIME_MAX_USECS_ALLOC
;
512 /* report "average" periodic allocation over a microsecond.
513 * the schedules are actually bursty, HCDs need to deal with
514 * that and just compute/report this average.
516 data_end
+= sprintf(data_end
, format_bandwidth
,
517 bus
->bandwidth_allocated
, max
,
518 (100 * bus
->bandwidth_allocated
+ max
/ 2)
520 bus
->bandwidth_int_reqs
,
521 bus
->bandwidth_isoc_reqs
);
524 data_end
= usb_dump_desc(data_end
, pages_start
+ (2 * PAGE_SIZE
) - 256, usbdev
);
526 if (data_end
> (pages_start
+ (2 * PAGE_SIZE
) - 256))
527 data_end
+= sprintf(data_end
, "(truncated)\n");
529 length
= data_end
- pages_start
;
530 /* if we can start copying some data to the user */
531 if (length
> *skip_bytes
) {
532 length
-= *skip_bytes
;
533 if (length
> *nbytes
)
535 if (copy_to_user(*buffer
, pages_start
+ *skip_bytes
, length
)) {
536 free_pages((unsigned long)pages_start
, 1);
540 *file_offset
+= length
;
541 total_written
+= length
;
545 *skip_bytes
-= length
;
547 free_pages((unsigned long)pages_start
, 1);
549 /* Now look at all of this device's children. */
550 for (chix
= 0; chix
< usbdev
->maxchild
; chix
++) {
551 struct usb_device
*childdev
= usbdev
->children
[chix
];
554 usb_lock_device(childdev
);
555 ret
= usb_device_dump(buffer
, nbytes
, skip_bytes
, file_offset
, childdev
,
556 bus
, level
+ 1, chix
, ++cnt
);
557 usb_unlock_device(childdev
);
559 return total_written
;
560 total_written
+= ret
;
563 return total_written
;
566 static ssize_t
usb_device_read(struct file
*file
, char __user
*buf
, size_t nbytes
, loff_t
*ppos
)
569 ssize_t ret
, total_written
= 0;
570 loff_t skip_bytes
= *ppos
;
576 if (!access_ok(VERIFY_WRITE
, buf
, nbytes
))
579 mutex_lock(&usb_bus_list_lock
);
580 /* print devices for all busses */
581 list_for_each_entry(bus
, &usb_bus_list
, bus_list
) {
582 /* recurse through all children of the root hub */
585 usb_lock_device(bus
->root_hub
);
586 ret
= usb_device_dump(&buf
, &nbytes
, &skip_bytes
, ppos
, bus
->root_hub
, bus
, 0, 0, 0);
587 usb_unlock_device(bus
->root_hub
);
589 mutex_unlock(&usb_bus_list_lock
);
592 total_written
+= ret
;
594 mutex_unlock(&usb_bus_list_lock
);
595 return total_written
;
598 /* Kernel lock for "lastev" protection */
599 static unsigned int usb_device_poll(struct file
*file
, struct poll_table_struct
*wait
)
601 struct usb_device_status
*st
= file
->private_data
;
602 unsigned int mask
= 0;
606 st
= kmalloc(sizeof(struct usb_device_status
), GFP_KERNEL
);
612 /* we may have dropped BKL - need to check for having lost the race */
613 if (file
->private_data
) {
615 st
= file
->private_data
;
620 * need to prevent the module from being unloaded, since
621 * proc_unregister does not call the release method and
622 * we would have a memory leak
624 st
->lastev
= conndiscevcnt
;
625 file
->private_data
= st
;
629 if (file
->f_mode
& FMODE_READ
)
630 poll_wait(file
, &deviceconndiscwq
, wait
);
631 if (st
->lastev
!= conndiscevcnt
)
633 st
->lastev
= conndiscevcnt
;
638 static int usb_device_open(struct inode
*inode
, struct file
*file
)
640 file
->private_data
= NULL
;
644 static int usb_device_release(struct inode
*inode
, struct file
*file
)
646 kfree(file
->private_data
);
647 file
->private_data
= NULL
;
651 static loff_t
usb_device_lseek(struct file
* file
, loff_t offset
, int orig
)
659 file
->f_pos
= offset
;
663 file
->f_pos
+= offset
;
675 const struct file_operations usbfs_devices_fops
= {
676 .llseek
= usb_device_lseek
,
677 .read
= usb_device_read
,
678 .poll
= usb_device_poll
,
679 .open
= usb_device_open
,
680 .release
= usb_device_release
,