blob: 96f11715cd269b4cb8594c12c4c027ae50350af8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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
Linus Torvalds1da177e2005-04-16 15:20:36 -070049 */
50
51#include <linux/fs.h>
52#include <linux/mm.h>
53#include <linux/slab.h>
54#include <linux/poll.h>
55#include <linux/usb.h>
56#include <linux/smp_lock.h>
57#include <linux/usbdevice_fs.h>
Arjan van de Ven4186ecf2006-01-11 15:55:29 +010058#include <linux/mutex.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070059#include <asm/uaccess.h>
60
Greg KH6d5e8252005-04-18 17:39:24 -070061#include "usb.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070062#include "hcd.h"
63
Linus Torvalds1da177e2005-04-16 15:20:36 -070064/* Define ALLOW_SERIAL_NUMBER if you want to see the serial number of devices */
65#define ALLOW_SERIAL_NUMBER
66
Arjan van de Ven4c4c9432005-11-29 09:43:42 +010067static const char *format_topo =
Linus Torvalds1da177e2005-04-16 15:20:36 -070068/* T: Bus=dd Lev=dd Prnt=dd Port=dd Cnt=dd Dev#=ddd Spd=ddd MxCh=dd */
69"\nT: Bus=%2.2d Lev=%2.2d Prnt=%2.2d Port=%2.2d Cnt=%2.2d Dev#=%3d Spd=%3s MxCh=%2d\n";
70
Arjan van de Ven4c4c9432005-11-29 09:43:42 +010071static const char *format_string_manufacturer =
Linus Torvalds1da177e2005-04-16 15:20:36 -070072/* S: Manufacturer=xxxx */
73 "S: Manufacturer=%.100s\n";
74
Arjan van de Ven4c4c9432005-11-29 09:43:42 +010075static const char *format_string_product =
Linus Torvalds1da177e2005-04-16 15:20:36 -070076/* S: Product=xxxx */
77 "S: Product=%.100s\n";
78
79#ifdef ALLOW_SERIAL_NUMBER
Arjan van de Ven4c4c9432005-11-29 09:43:42 +010080static const char *format_string_serialnumber =
Linus Torvalds1da177e2005-04-16 15:20:36 -070081/* S: SerialNumber=xxxx */
82 "S: SerialNumber=%.100s\n";
83#endif
84
Arjan van de Ven4c4c9432005-11-29 09:43:42 +010085static const char *format_bandwidth =
Linus Torvalds1da177e2005-04-16 15:20:36 -070086/* B: Alloc=ddd/ddd us (xx%), #Int=ddd, #Iso=ddd */
87 "B: Alloc=%3d/%3d us (%2d%%), #Int=%3d, #Iso=%3d\n";
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -080088
Arjan van de Ven4c4c9432005-11-29 09:43:42 +010089static const char *format_device1 =
Linus Torvalds1da177e2005-04-16 15:20:36 -070090/* D: Ver=xx.xx Cls=xx(sssss) Sub=xx Prot=xx MxPS=dd #Cfgs=dd */
91 "D: Ver=%2x.%02x Cls=%02x(%-5s) Sub=%02x Prot=%02x MxPS=%2d #Cfgs=%3d\n";
92
Arjan van de Ven4c4c9432005-11-29 09:43:42 +010093static const char *format_device2 =
Linus Torvalds1da177e2005-04-16 15:20:36 -070094/* P: Vendor=xxxx ProdID=xxxx Rev=xx.xx */
95 "P: Vendor=%04x ProdID=%04x Rev=%2x.%02x\n";
96
Arjan van de Ven4c4c9432005-11-29 09:43:42 +010097static const char *format_config =
Linus Torvalds1da177e2005-04-16 15:20:36 -070098/* C: #Ifs=dd Cfg#=dd Atr=xx MPwr=dddmA */
99 "C:%c #Ifs=%2d Cfg#=%2d Atr=%02x MxPwr=%3dmA\n";
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800100
Craig W. Nadler165fe972007-06-15 23:14:35 -0400101static const char *format_iad =
102/* A: FirstIf#=dd IfCount=dd Cls=xx(sssss) Sub=xx Prot=xx */
103 "A: FirstIf#=%2d IfCount=%2d Cls=%02x(%-5s) Sub=%02x Prot=%02x\n";
104
Arjan van de Ven4c4c9432005-11-29 09:43:42 +0100105static const char *format_iface =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700106/* I: If#=dd Alt=dd #EPs=dd Cls=xx(sssss) Sub=xx Prot=xx Driver=xxxx*/
David Brownell2360e4a2006-12-13 13:07:10 -0800107 "I:%c If#=%2d Alt=%2d #EPs=%2d Cls=%02x(%-5s) Sub=%02x Prot=%02x Driver=%s\n";
Linus Torvalds1da177e2005-04-16 15:20:36 -0700108
Arjan van de Ven4c4c9432005-11-29 09:43:42 +0100109static const char *format_endpt =
Linus Torvalds1da177e2005-04-16 15:20:36 -0700110/* 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";
112
113
114/*
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.
118 */
119
120static DECLARE_WAIT_QUEUE_HEAD(deviceconndiscwq);
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800121static unsigned int conndiscevcnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122
123/* this struct stores the poll state for <mountpoint>/devices pollers */
124struct usb_device_status {
125 unsigned int lastev;
126};
127
128struct class_info {
129 int class;
130 char *class_name;
131};
132
133static 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"},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 {USB_CLASS_PHYSICAL, "PID"},
Frans Popbf7fbb02009-06-26 16:10:19 +0200140 {USB_CLASS_STILL_IMAGE, "still"},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700141 {USB_CLASS_PRINTER, "print"},
142 {USB_CLASS_MASS_STORAGE, "stor."},
Frans Popbf7fbb02009-06-26 16:10:19 +0200143 {USB_CLASS_HUB, "hub"},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700144 {USB_CLASS_CDC_DATA, "data"},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700145 {USB_CLASS_CSCID, "scard"},
146 {USB_CLASS_CONTENT_SEC, "c-sec"},
Craig W. Nadler165fe972007-06-15 23:14:35 -0400147 {USB_CLASS_VIDEO, "video"},
Frans Popbf7fbb02009-06-26 16:10:19 +0200148 {USB_CLASS_WIRELESS_CONTROLLER, "wlcon"},
149 {USB_CLASS_MISC, "misc"},
150 {USB_CLASS_APP_SPEC, "app."},
151 {USB_CLASS_VENDOR_SPEC, "vend."},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 {-1, "unk."} /* leave as last */
153};
154
155/*****************************************************************/
156
157void usbfs_conn_disc_event(void)
158{
159 conndiscevcnt++;
160 wake_up(&deviceconndiscwq);
161}
162
163static const char *class_decode(const int class)
164{
165 int ix;
166
167 for (ix = 0; clas_info[ix].class != -1; ix++)
168 if (clas_info[ix].class == class)
169 break;
Oliver Neukum1a68f712007-01-25 11:17:41 +0100170 return clas_info[ix].class_name;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700171}
172
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800173static char *usb_dump_endpoint_descriptor(int speed, char *start, char *end,
174 const struct usb_endpoint_descriptor *desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700175{
176 char dir, unit, *type;
Luiz Fernando N. Capitulino87ad46c2006-10-26 13:02:49 -0300177 unsigned interval, bandwidth = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700178
179 if (start > end)
180 return start;
Luiz Fernando N. Capitulino87ad46c2006-10-26 13:02:49 -0300181
182 dir = usb_endpoint_dir_in(desc) ? 'I' : 'O';
183
Linus Torvalds1da177e2005-04-16 15:20:36 -0700184 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;
188 }
189 }
190
191 /* this isn't checking for illegal values */
Julia Lawall2e0fe702008-12-29 11:22:14 +0100192 switch (usb_endpoint_type(desc)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700193 case USB_ENDPOINT_XFER_CONTROL:
194 type = "Ctrl";
195 if (speed == USB_SPEED_HIGH) /* uframes per NAK */
196 interval = desc->bInterval;
197 else
198 interval = 0;
199 dir = 'B'; /* ctrl is bidirectional */
200 break;
201 case USB_ENDPOINT_XFER_ISOC:
202 type = "Isoc";
203 interval = 1 << (desc->bInterval - 1);
204 break;
205 case USB_ENDPOINT_XFER_BULK:
206 type = "Bulk";
Luiz Fernando N. Capitulino87ad46c2006-10-26 13:02:49 -0300207 if (speed == USB_SPEED_HIGH && dir == 'O') /* uframes per NAK */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700208 interval = desc->bInterval;
209 else
210 interval = 0;
211 break;
212 case USB_ENDPOINT_XFER_INT:
213 type = "Int.";
Oliver Neukum1a68f712007-01-25 11:17:41 +0100214 if (speed == USB_SPEED_HIGH)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215 interval = 1 << (desc->bInterval - 1);
Oliver Neukum1a68f712007-01-25 11:17:41 +0100216 else
Linus Torvalds1da177e2005-04-16 15:20:36 -0700217 interval = desc->bInterval;
218 break;
219 default: /* "can't happen" */
220 return start;
221 }
222 interval *= (speed == USB_SPEED_HIGH) ? 125 : 1000;
223 if (interval % 1000)
224 unit = 'u';
225 else {
226 unit = 'm';
227 interval /= 1000;
228 }
229
230 start += sprintf(start, format_endpt, desc->bEndpointAddress, dir,
231 desc->bmAttributes, type,
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800232 (le16_to_cpu(desc->wMaxPacketSize) & 0x07ff) *
233 bandwidth,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700234 interval, unit);
235 return start;
236}
237
238static char *usb_dump_interface_descriptor(char *start, char *end,
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800239 const struct usb_interface_cache *intfc,
240 const struct usb_interface *iface,
241 int setno)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700242{
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800243 const struct usb_interface_descriptor *desc;
Dmitry Torokhov8d790d72005-04-26 02:34:05 -0500244 const char *driver_name = "";
David Brownell2360e4a2006-12-13 13:07:10 -0800245 int active = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700246
247 if (start > end)
248 return start;
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800249 desc = &intfc->altsetting[setno].desc;
David Brownell2360e4a2006-12-13 13:07:10 -0800250 if (iface) {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700251 driver_name = (iface->dev.driver
252 ? iface->dev.driver->name
253 : "(none)");
David Brownell2360e4a2006-12-13 13:07:10 -0800254 active = (desc == &iface->cur_altsetting->desc);
255 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700256 start += sprintf(start, format_iface,
David Brownell2360e4a2006-12-13 13:07:10 -0800257 active ? '*' : ' ', /* mark active altsetting */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700258 desc->bInterfaceNumber,
259 desc->bAlternateSetting,
260 desc->bNumEndpoints,
261 desc->bInterfaceClass,
262 class_decode(desc->bInterfaceClass),
263 desc->bInterfaceSubClass,
264 desc->bInterfaceProtocol,
265 driver_name);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 return start;
267}
268
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800269static char *usb_dump_interface(int speed, char *start, char *end,
270 const struct usb_interface_cache *intfc,
271 const struct usb_interface *iface, int setno)
272{
Linus Torvalds1da177e2005-04-16 15:20:36 -0700273 const struct usb_host_interface *desc = &intfc->altsetting[setno];
274 int i;
275
276 start = usb_dump_interface_descriptor(start, end, intfc, iface, setno);
277 for (i = 0; i < desc->desc.bNumEndpoints; i++) {
278 if (start > end)
279 return start;
280 start = usb_dump_endpoint_descriptor(speed,
281 start, end, &desc->endpoint[i].desc);
282 }
283 return start;
284}
285
Craig W. Nadler165fe972007-06-15 23:14:35 -0400286static char *usb_dump_iad_descriptor(char *start, char *end,
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800287 const struct usb_interface_assoc_descriptor *iad)
Craig W. Nadler165fe972007-06-15 23:14:35 -0400288{
289 if (start > end)
290 return start;
291 start += sprintf(start, format_iad,
292 iad->bFirstInterface,
293 iad->bInterfaceCount,
294 iad->bFunctionClass,
295 class_decode(iad->bFunctionClass),
296 iad->bFunctionSubClass,
297 iad->bFunctionProtocol);
298 return start;
299}
300
Linus Torvalds1da177e2005-04-16 15:20:36 -0700301/* TBD:
302 * 0. TBDs
303 * 1. marking active interface altsettings (code lists all, but should mark
304 * which ones are active, if any)
305 */
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800306static char *usb_dump_config_descriptor(char *start, char *end,
307 const struct usb_config_descriptor *desc,
308 int active)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700309{
310 if (start > end)
311 return start;
312 start += sprintf(start, format_config,
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800313 /* mark active/actual/current cfg. */
314 active ? '*' : ' ',
Linus Torvalds1da177e2005-04-16 15:20:36 -0700315 desc->bNumInterfaces,
316 desc->bConfigurationValue,
317 desc->bmAttributes,
318 desc->bMaxPower * 2);
319 return start;
320}
321
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800322static char *usb_dump_config(int speed, char *start, char *end,
323 const struct usb_host_config *config, int active)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700324{
325 int i, j;
326 struct usb_interface_cache *intfc;
327 struct usb_interface *interface;
328
329 if (start > end)
330 return start;
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800331 if (!config)
332 /* getting these some in 2.3.7; none in 2.3.6 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333 return start + sprintf(start, "(null Cfg. desc.)\n");
334 start = usb_dump_config_descriptor(start, end, &config->desc, active);
Craig W. Nadler165fe972007-06-15 23:14:35 -0400335 for (i = 0; i < USB_MAXIADS; i++) {
336 if (config->intf_assoc[i] == NULL)
337 break;
338 start = usb_dump_iad_descriptor(start, end,
339 config->intf_assoc[i]);
340 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341 for (i = 0; i < config->desc.bNumInterfaces; i++) {
342 intfc = config->intf_cache[i];
343 interface = config->interface[i];
344 for (j = 0; j < intfc->num_altsetting; j++) {
345 if (start > end)
346 return start;
347 start = usb_dump_interface(speed,
348 start, end, intfc, interface, j);
349 }
350 }
351 return start;
352}
353
354/*
355 * Dump the different USB descriptors.
356 */
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800357static char *usb_dump_device_descriptor(char *start, char *end,
358 const struct usb_device_descriptor *desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700359{
360 u16 bcdUSB = le16_to_cpu(desc->bcdUSB);
361 u16 bcdDevice = le16_to_cpu(desc->bcdDevice);
362
363 if (start > end)
364 return start;
Oliver Neukum1a68f712007-01-25 11:17:41 +0100365 start += sprintf(start, format_device1,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700366 bcdUSB >> 8, bcdUSB & 0xff,
367 desc->bDeviceClass,
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800368 class_decode(desc->bDeviceClass),
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369 desc->bDeviceSubClass,
370 desc->bDeviceProtocol,
371 desc->bMaxPacketSize0,
372 desc->bNumConfigurations);
373 if (start > end)
374 return start;
375 start += sprintf(start, format_device2,
376 le16_to_cpu(desc->idVendor),
377 le16_to_cpu(desc->idProduct),
378 bcdDevice >> 8, bcdDevice & 0xff);
379 return start;
380}
381
382/*
383 * Dump the different strings that this device holds.
384 */
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800385static char *usb_dump_device_strings(char *start, char *end,
386 struct usb_device *dev)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700387{
388 if (start > end)
389 return start;
390 if (dev->manufacturer)
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800391 start += sprintf(start, format_string_manufacturer,
392 dev->manufacturer);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393 if (start > end)
394 goto out;
395 if (dev->product)
396 start += sprintf(start, format_string_product, dev->product);
397 if (start > end)
398 goto out;
399#ifdef ALLOW_SERIAL_NUMBER
400 if (dev->serial)
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800401 start += sprintf(start, format_string_serialnumber,
402 dev->serial);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700403#endif
404 out:
405 return start;
406}
407
408static char *usb_dump_desc(char *start, char *end, struct usb_device *dev)
409{
410 int i;
411
412 if (start > end)
413 return start;
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800414
Linus Torvalds1da177e2005-04-16 15:20:36 -0700415 start = usb_dump_device_descriptor(start, end, &dev->descriptor);
416
417 if (start > end)
418 return start;
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800419
Oliver Neukum1a68f712007-01-25 11:17:41 +0100420 start = usb_dump_device_strings(start, end, dev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700421
422 for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
423 if (start > end)
424 return start;
425 start = usb_dump_config(dev->speed,
426 start, end, dev->config + i,
427 /* active ? */
428 (dev->config + i) == dev->actconfig);
429 }
430 return start;
431}
432
433
434#ifdef PROC_EXTRA /* TBD: may want to add this code later */
435
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800436static char *usb_dump_hub_descriptor(char *start, char *end,
437 const struct usb_hub_descriptor *desc)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700438{
439 int leng = USB_DT_HUB_NONVAR_SIZE;
440 unsigned char *ptr = (unsigned char *)desc;
441
442 if (start > end)
443 return start;
444 start += sprintf(start, "Interface:");
445 while (leng && start <= end) {
446 start += sprintf(start, " %02x", *ptr);
447 ptr++; leng--;
448 }
449 *start++ = '\n';
450 return start;
451}
452
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800453static char *usb_dump_string(char *start, char *end,
454 const struct usb_device *dev, char *id, int index)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700455{
456 if (start > end)
457 return start;
458 start += sprintf(start, "Interface:");
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800459 if (index <= dev->maxstring && dev->stringindex &&
460 dev->stringindex[index])
461 start += sprintf(start, "%s: %.100s ", id,
462 dev->stringindex[index]);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700463 return start;
464}
465
466#endif /* PROC_EXTRA */
467
468/*****************************************************************/
469
470/* This is a recursive function. Parameters:
471 * buffer - the user-space buffer to write data into
472 * nbytes - the maximum number of bytes to write
473 * skip_bytes - the number of bytes to skip before writing anything
474 * file_offset - the offset into the devices file on completion
475 * The caller must own the device lock.
476 */
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800477static ssize_t usb_device_dump(char __user **buffer, size_t *nbytes,
478 loff_t *skip_bytes, loff_t *file_offset,
479 struct usb_device *usbdev, struct usb_bus *bus,
480 int level, int index, int count)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700481{
482 int chix;
483 int ret, cnt = 0;
484 int parent_devnum = 0;
485 char *pages_start, *data_end, *speed;
486 unsigned int length;
487 ssize_t total_written = 0;
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800488
Linus Torvalds1da177e2005-04-16 15:20:36 -0700489 /* don't bother with anything else if we're not writing any data */
490 if (*nbytes <= 0)
491 return 0;
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800492
Linus Torvalds1da177e2005-04-16 15:20:36 -0700493 if (level > MAX_TOPO_LEVEL)
494 return 0;
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800495 /* allocate 2^1 pages = 8K (on i386);
496 * should be more than enough for one device */
497 pages_start = (char *)__get_free_pages(GFP_KERNEL, 1);
498 if (!pages_start)
499 return -ENOMEM;
500
Linus Torvalds1da177e2005-04-16 15:20:36 -0700501 if (usbdev->parent && usbdev->parent->devnum != -1)
502 parent_devnum = usbdev->parent->devnum;
503 /*
504 * So the root hub's parent is 0 and any device that is
505 * plugged into the root hub has a parent of 0.
506 */
507 switch (usbdev->speed) {
508 case USB_SPEED_LOW:
509 speed = "1.5"; break;
510 case USB_SPEED_UNKNOWN: /* usb 1.1 root hub code */
511 case USB_SPEED_FULL:
512 speed = "12 "; break;
513 case USB_SPEED_HIGH:
514 speed = "480"; break;
515 default:
516 speed = "?? ";
517 }
518 data_end = pages_start + sprintf(pages_start, format_topo,
519 bus->busnum, level, parent_devnum,
520 index, count, usbdev->devnum,
521 speed, usbdev->maxchild);
522 /*
523 * level = topology-tier level;
524 * parent_devnum = parent device number;
525 * index = parent's connector number;
526 * count = device count at this level
527 */
528 /* If this is the root hub, display the bandwidth information */
529 if (level == 0) {
530 int max;
531
532 /* high speed reserves 80%, full/low reserves 90% */
533 if (usbdev->speed == USB_SPEED_HIGH)
534 max = 800;
535 else
536 max = FRAME_TIME_MAX_USECS_ALLOC;
537
538 /* report "average" periodic allocation over a microsecond.
539 * the schedules are actually bursty, HCDs need to deal with
540 * that and just compute/report this average.
541 */
542 data_end += sprintf(data_end, format_bandwidth,
543 bus->bandwidth_allocated, max,
544 (100 * bus->bandwidth_allocated + max / 2)
545 / max,
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800546 bus->bandwidth_int_reqs,
547 bus->bandwidth_isoc_reqs);
548
Linus Torvalds1da177e2005-04-16 15:20:36 -0700549 }
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800550 data_end = usb_dump_desc(data_end, pages_start + (2 * PAGE_SIZE) - 256,
551 usbdev);
552
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 if (data_end > (pages_start + (2 * PAGE_SIZE) - 256))
554 data_end += sprintf(data_end, "(truncated)\n");
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800555
Linus Torvalds1da177e2005-04-16 15:20:36 -0700556 length = data_end - pages_start;
557 /* if we can start copying some data to the user */
558 if (length > *skip_bytes) {
559 length -= *skip_bytes;
560 if (length > *nbytes)
561 length = *nbytes;
562 if (copy_to_user(*buffer, pages_start + *skip_bytes, length)) {
563 free_pages((unsigned long)pages_start, 1);
564 return -EFAULT;
565 }
566 *nbytes -= length;
567 *file_offset += length;
568 total_written += length;
569 *buffer += length;
570 *skip_bytes = 0;
571 } else
572 *skip_bytes -= length;
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800573
Linus Torvalds1da177e2005-04-16 15:20:36 -0700574 free_pages((unsigned long)pages_start, 1);
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800575
Linus Torvalds1da177e2005-04-16 15:20:36 -0700576 /* Now look at all of this device's children. */
577 for (chix = 0; chix < usbdev->maxchild; chix++) {
578 struct usb_device *childdev = usbdev->children[chix];
579
580 if (childdev) {
Alan Stern9ad3d6c2005-11-17 17:10:32 -0500581 usb_lock_device(childdev);
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800582 ret = usb_device_dump(buffer, nbytes, skip_bytes,
583 file_offset, childdev, bus,
584 level + 1, chix, ++cnt);
Alan Stern9ad3d6c2005-11-17 17:10:32 -0500585 usb_unlock_device(childdev);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700586 if (ret == -EFAULT)
587 return total_written;
588 total_written += ret;
589 }
590 }
591 return total_written;
592}
593
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800594static ssize_t usb_device_read(struct file *file, char __user *buf,
595 size_t nbytes, loff_t *ppos)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700596{
597 struct usb_bus *bus;
598 ssize_t ret, total_written = 0;
599 loff_t skip_bytes = *ppos;
600
601 if (*ppos < 0)
602 return -EINVAL;
603 if (nbytes <= 0)
604 return 0;
605 if (!access_ok(VERIFY_WRITE, buf, nbytes))
606 return -EFAULT;
607
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100608 mutex_lock(&usb_bus_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700609 /* print devices for all busses */
610 list_for_each_entry(bus, &usb_bus_list, bus_list) {
611 /* recurse through all children of the root hub */
612 if (!bus->root_hub)
613 continue;
614 usb_lock_device(bus->root_hub);
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800615 ret = usb_device_dump(&buf, &nbytes, &skip_bytes, ppos,
616 bus->root_hub, bus, 0, 0, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700617 usb_unlock_device(bus->root_hub);
618 if (ret < 0) {
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100619 mutex_unlock(&usb_bus_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700620 return ret;
621 }
622 total_written += ret;
623 }
Arjan van de Ven4186ecf2006-01-11 15:55:29 +0100624 mutex_unlock(&usb_bus_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700625 return total_written;
626}
627
628/* Kernel lock for "lastev" protection */
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800629static unsigned int usb_device_poll(struct file *file,
630 struct poll_table_struct *wait)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700631{
Tobias Klauserec17cf12006-09-13 21:38:41 +0200632 struct usb_device_status *st = file->private_data;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700633 unsigned int mask = 0;
634
635 lock_kernel();
636 if (!st) {
637 st = kmalloc(sizeof(struct usb_device_status), GFP_KERNEL);
Tobias Klauserec17cf12006-09-13 21:38:41 +0200638
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800639 /* we may have dropped BKL -
640 * need to check for having lost the race */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700641 if (file->private_data) {
642 kfree(st);
643 st = file->private_data;
644 goto lost_race;
645 }
Oliver Neukum6957e1a2007-01-25 11:22:24 +0100646 /* we haven't lost - check for allocation failure now */
647 if (!st) {
648 unlock_kernel();
649 return POLLIN;
650 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700651
652 /*
653 * need to prevent the module from being unloaded, since
654 * proc_unregister does not call the release method and
655 * we would have a memory leak
656 */
657 st->lastev = conndiscevcnt;
658 file->private_data = st;
659 mask = POLLIN;
660 }
661lost_race:
662 if (file->f_mode & FMODE_READ)
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800663 poll_wait(file, &deviceconndiscwq, wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700664 if (st->lastev != conndiscevcnt)
665 mask |= POLLIN;
666 st->lastev = conndiscevcnt;
667 unlock_kernel();
668 return mask;
669}
670
671static int usb_device_open(struct inode *inode, struct file *file)
672{
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800673 file->private_data = NULL;
674 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675}
676
677static int usb_device_release(struct inode *inode, struct file *file)
678{
Jesper Juhl1bc3c9e2005-04-18 17:39:34 -0700679 kfree(file->private_data);
680 file->private_data = NULL;
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800681 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700682}
683
Greg Kroah-Hartman376c0d32008-01-30 15:21:33 -0800684static loff_t usb_device_lseek(struct file *file, loff_t offset, int orig)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700685{
686 loff_t ret;
687
688 lock_kernel();
689
690 switch (orig) {
691 case 0:
692 file->f_pos = offset;
693 ret = file->f_pos;
694 break;
695 case 1:
696 file->f_pos += offset;
697 ret = file->f_pos;
698 break;
699 case 2:
700 default:
701 ret = -EINVAL;
702 }
703
704 unlock_kernel();
705 return ret;
706}
707
Luiz Fernando N. Capitulino066202d2006-08-05 20:37:11 -0300708const struct file_operations usbfs_devices_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 .llseek = usb_device_lseek,
710 .read = usb_device_read,
711 .poll = usb_device_poll,
712 .open = usb_device_open,
713 .release = usb_device_release,
714};