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: 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
, in
, bandwidth
= 1;
182 in
= (desc
->bEndpointAddress
& USB_DIR_IN
);
183 dir
= in
? 'I' : 'O';
184 if (speed
== USB_SPEED_HIGH
) {
185 switch (le16_to_cpu(desc
->wMaxPacketSize
) & (0x03 << 11)) {
186 case 1 << 11: bandwidth
= 2; break;
187 case 2 << 11: bandwidth
= 3; break;
191 /* this isn't checking for illegal values */
192 switch (desc
->bmAttributes
& USB_ENDPOINT_XFERTYPE_MASK
) {
193 case USB_ENDPOINT_XFER_CONTROL
:
195 if (speed
== USB_SPEED_HIGH
) /* uframes per NAK */
196 interval
= desc
->bInterval
;
199 dir
= 'B'; /* ctrl is bidirectional */
201 case USB_ENDPOINT_XFER_ISOC
:
203 interval
= 1 << (desc
->bInterval
- 1);
205 case USB_ENDPOINT_XFER_BULK
:
207 if (speed
== USB_SPEED_HIGH
&& !in
) /* uframes per NAK */
208 interval
= desc
->bInterval
;
212 case USB_ENDPOINT_XFER_INT
:
214 if (speed
== USB_SPEED_HIGH
) {
215 interval
= 1 << (desc
->bInterval
- 1);
217 interval
= desc
->bInterval
;
219 default: /* "can't happen" */
222 interval
*= (speed
== USB_SPEED_HIGH
) ? 125 : 1000;
230 start
+= sprintf(start
, format_endpt
, desc
->bEndpointAddress
, dir
,
231 desc
->bmAttributes
, type
,
232 (le16_to_cpu(desc
->wMaxPacketSize
) & 0x07ff) * bandwidth
,
237 static char *usb_dump_interface_descriptor(char *start
, char *end
,
238 const struct usb_interface_cache
*intfc
,
239 const struct usb_interface
*iface
,
242 const struct usb_interface_descriptor
*desc
= &intfc
->altsetting
[setno
].desc
;
243 const char *driver_name
= "";
247 down_read(&usb_bus_type
.subsys
.rwsem
);
249 driver_name
= (iface
->dev
.driver
250 ? iface
->dev
.driver
->name
252 start
+= sprintf(start
, format_iface
,
253 desc
->bInterfaceNumber
,
254 desc
->bAlternateSetting
,
256 desc
->bInterfaceClass
,
257 class_decode(desc
->bInterfaceClass
),
258 desc
->bInterfaceSubClass
,
259 desc
->bInterfaceProtocol
,
261 up_read(&usb_bus_type
.subsys
.rwsem
);
265 static char *usb_dump_interface(
269 const struct usb_interface_cache
*intfc
,
270 const struct usb_interface
*iface
,
273 const struct usb_host_interface
*desc
= &intfc
->altsetting
[setno
];
276 start
= usb_dump_interface_descriptor(start
, end
, intfc
, iface
, setno
);
277 for (i
= 0; i
< desc
->desc
.bNumEndpoints
; i
++) {
280 start
= usb_dump_endpoint_descriptor(speed
,
281 start
, end
, &desc
->endpoint
[i
].desc
);
288 * 1. marking active interface altsettings (code lists all, but should mark
289 * which ones are active, if any)
292 static char *usb_dump_config_descriptor(char *start
, char *end
, const struct usb_config_descriptor
*desc
, int active
)
296 start
+= sprintf(start
, format_config
,
297 active
? '*' : ' ', /* mark active/actual/current cfg. */
298 desc
->bNumInterfaces
,
299 desc
->bConfigurationValue
,
301 desc
->bMaxPower
* 2);
305 static char *usb_dump_config (
309 const struct usb_host_config
*config
,
314 struct usb_interface_cache
*intfc
;
315 struct usb_interface
*interface
;
319 if (!config
) /* getting these some in 2.3.7; none in 2.3.6 */
320 return start
+ sprintf(start
, "(null Cfg. desc.)\n");
321 start
= usb_dump_config_descriptor(start
, end
, &config
->desc
, active
);
322 for (i
= 0; i
< config
->desc
.bNumInterfaces
; i
++) {
323 intfc
= config
->intf_cache
[i
];
324 interface
= config
->interface
[i
];
325 for (j
= 0; j
< intfc
->num_altsetting
; j
++) {
328 start
= usb_dump_interface(speed
,
329 start
, end
, intfc
, interface
, j
);
336 * Dump the different USB descriptors.
338 static char *usb_dump_device_descriptor(char *start
, char *end
, const struct usb_device_descriptor
*desc
)
340 u16 bcdUSB
= le16_to_cpu(desc
->bcdUSB
);
341 u16 bcdDevice
= le16_to_cpu(desc
->bcdDevice
);
345 start
+= sprintf (start
, format_device1
,
346 bcdUSB
>> 8, bcdUSB
& 0xff,
348 class_decode (desc
->bDeviceClass
),
349 desc
->bDeviceSubClass
,
350 desc
->bDeviceProtocol
,
351 desc
->bMaxPacketSize0
,
352 desc
->bNumConfigurations
);
355 start
+= sprintf(start
, format_device2
,
356 le16_to_cpu(desc
->idVendor
),
357 le16_to_cpu(desc
->idProduct
),
358 bcdDevice
>> 8, bcdDevice
& 0xff);
363 * Dump the different strings that this device holds.
365 static char *usb_dump_device_strings (char *start
, char *end
, struct usb_device
*dev
)
369 if (dev
->manufacturer
)
370 start
+= sprintf(start
, format_string_manufacturer
, dev
->manufacturer
);
374 start
+= sprintf(start
, format_string_product
, dev
->product
);
377 #ifdef ALLOW_SERIAL_NUMBER
379 start
+= sprintf(start
, format_string_serialnumber
, dev
->serial
);
385 static char *usb_dump_desc(char *start
, char *end
, struct usb_device
*dev
)
392 start
= usb_dump_device_descriptor(start
, end
, &dev
->descriptor
);
397 start
= usb_dump_device_strings (start
, end
, dev
);
399 for (i
= 0; i
< dev
->descriptor
.bNumConfigurations
; i
++) {
402 start
= usb_dump_config(dev
->speed
,
403 start
, end
, dev
->config
+ i
,
405 (dev
->config
+ i
) == dev
->actconfig
);
411 #ifdef PROC_EXTRA /* TBD: may want to add this code later */
413 static char *usb_dump_hub_descriptor(char *start
, char *end
, const struct usb_hub_descriptor
* desc
)
415 int leng
= USB_DT_HUB_NONVAR_SIZE
;
416 unsigned char *ptr
= (unsigned char *)desc
;
420 start
+= sprintf(start
, "Interface:");
421 while (leng
&& start
<= end
) {
422 start
+= sprintf(start
, " %02x", *ptr
);
429 static char *usb_dump_string(char *start
, char *end
, const struct usb_device
*dev
, char *id
, int index
)
433 start
+= sprintf(start
, "Interface:");
434 if (index
<= dev
->maxstring
&& dev
->stringindex
&& dev
->stringindex
[index
])
435 start
+= sprintf(start
, "%s: %.100s ", id
, dev
->stringindex
[index
]);
439 #endif /* PROC_EXTRA */
441 /*****************************************************************/
443 /* This is a recursive function. Parameters:
444 * buffer - the user-space buffer to write data into
445 * nbytes - the maximum number of bytes to write
446 * skip_bytes - the number of bytes to skip before writing anything
447 * file_offset - the offset into the devices file on completion
448 * The caller must own the device lock.
450 static ssize_t
usb_device_dump(char __user
**buffer
, size_t *nbytes
, loff_t
*skip_bytes
, loff_t
*file_offset
,
451 struct usb_device
*usbdev
, struct usb_bus
*bus
, int level
, int index
, int count
)
455 int parent_devnum
= 0;
456 char *pages_start
, *data_end
, *speed
;
458 ssize_t total_written
= 0;
460 /* don't bother with anything else if we're not writing any data */
464 if (level
> MAX_TOPO_LEVEL
)
466 /* allocate 2^1 pages = 8K (on i386); should be more than enough for one device */
467 if (!(pages_start
= (char*) __get_free_pages(GFP_KERNEL
,1)))
470 if (usbdev
->parent
&& usbdev
->parent
->devnum
!= -1)
471 parent_devnum
= usbdev
->parent
->devnum
;
473 * So the root hub's parent is 0 and any device that is
474 * plugged into the root hub has a parent of 0.
476 switch (usbdev
->speed
) {
478 speed
= "1.5"; break;
479 case USB_SPEED_UNKNOWN
: /* usb 1.1 root hub code */
481 speed
= "12 "; break;
483 speed
= "480"; break;
487 data_end
= pages_start
+ sprintf(pages_start
, format_topo
,
488 bus
->busnum
, level
, parent_devnum
,
489 index
, count
, usbdev
->devnum
,
490 speed
, usbdev
->maxchild
);
492 * level = topology-tier level;
493 * parent_devnum = parent device number;
494 * index = parent's connector number;
495 * count = device count at this level
497 /* If this is the root hub, display the bandwidth information */
501 /* high speed reserves 80%, full/low reserves 90% */
502 if (usbdev
->speed
== USB_SPEED_HIGH
)
505 max
= FRAME_TIME_MAX_USECS_ALLOC
;
507 /* report "average" periodic allocation over a microsecond.
508 * the schedules are actually bursty, HCDs need to deal with
509 * that and just compute/report this average.
511 data_end
+= sprintf(data_end
, format_bandwidth
,
512 bus
->bandwidth_allocated
, max
,
513 (100 * bus
->bandwidth_allocated
+ max
/ 2)
515 bus
->bandwidth_int_reqs
,
516 bus
->bandwidth_isoc_reqs
);
519 data_end
= usb_dump_desc(data_end
, pages_start
+ (2 * PAGE_SIZE
) - 256, usbdev
);
521 if (data_end
> (pages_start
+ (2 * PAGE_SIZE
) - 256))
522 data_end
+= sprintf(data_end
, "(truncated)\n");
524 length
= data_end
- pages_start
;
525 /* if we can start copying some data to the user */
526 if (length
> *skip_bytes
) {
527 length
-= *skip_bytes
;
528 if (length
> *nbytes
)
530 if (copy_to_user(*buffer
, pages_start
+ *skip_bytes
, length
)) {
531 free_pages((unsigned long)pages_start
, 1);
535 *file_offset
+= length
;
536 total_written
+= length
;
540 *skip_bytes
-= length
;
542 free_pages((unsigned long)pages_start
, 1);
544 /* Now look at all of this device's children. */
545 for (chix
= 0; chix
< usbdev
->maxchild
; chix
++) {
546 struct usb_device
*childdev
= usbdev
->children
[chix
];
549 usb_lock_device(childdev
);
550 ret
= usb_device_dump(buffer
, nbytes
, skip_bytes
, file_offset
, childdev
,
551 bus
, level
+ 1, chix
, ++cnt
);
552 usb_unlock_device(childdev
);
554 return total_written
;
555 total_written
+= ret
;
558 return total_written
;
561 static ssize_t
usb_device_read(struct file
*file
, char __user
*buf
, size_t nbytes
, loff_t
*ppos
)
564 ssize_t ret
, total_written
= 0;
565 loff_t skip_bytes
= *ppos
;
571 if (!access_ok(VERIFY_WRITE
, buf
, nbytes
))
574 mutex_lock(&usb_bus_list_lock
);
575 /* print devices for all busses */
576 list_for_each_entry(bus
, &usb_bus_list
, bus_list
) {
577 /* recurse through all children of the root hub */
580 usb_lock_device(bus
->root_hub
);
581 ret
= usb_device_dump(&buf
, &nbytes
, &skip_bytes
, ppos
, bus
->root_hub
, bus
, 0, 0, 0);
582 usb_unlock_device(bus
->root_hub
);
584 mutex_unlock(&usb_bus_list_lock
);
587 total_written
+= ret
;
589 mutex_unlock(&usb_bus_list_lock
);
590 return total_written
;
593 /* Kernel lock for "lastev" protection */
594 static unsigned int usb_device_poll(struct file
*file
, struct poll_table_struct
*wait
)
596 struct usb_device_status
*st
= (struct usb_device_status
*)file
->private_data
;
597 unsigned int mask
= 0;
601 st
= kmalloc(sizeof(struct usb_device_status
), GFP_KERNEL
);
607 /* we may have dropped BKL - need to check for having lost the race */
608 if (file
->private_data
) {
610 st
= file
->private_data
;
615 * need to prevent the module from being unloaded, since
616 * proc_unregister does not call the release method and
617 * we would have a memory leak
619 st
->lastev
= conndiscevcnt
;
620 file
->private_data
= st
;
624 if (file
->f_mode
& FMODE_READ
)
625 poll_wait(file
, &deviceconndiscwq
, wait
);
626 if (st
->lastev
!= conndiscevcnt
)
628 st
->lastev
= conndiscevcnt
;
633 static int usb_device_open(struct inode
*inode
, struct file
*file
)
635 file
->private_data
= NULL
;
639 static int usb_device_release(struct inode
*inode
, struct file
*file
)
641 kfree(file
->private_data
);
642 file
->private_data
= NULL
;
646 static loff_t
usb_device_lseek(struct file
* file
, loff_t offset
, int orig
)
654 file
->f_pos
= offset
;
658 file
->f_pos
+= offset
;
670 struct file_operations usbfs_devices_fops
= {
671 .llseek
= usb_device_lseek
,
672 .read
= usb_device_read
,
673 .poll
= usb_device_poll
,
674 .open
= usb_device_open
,
675 .release
= usb_device_release
,