Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1 | /* |
| 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 |
| 49 | * |
| 50 | * $Id: devices.c,v 1.5 2000/01/11 13:58:21 tom Exp $ |
| 51 | */ |
| 52 | |
| 53 | #include <linux/fs.h> |
| 54 | #include <linux/mm.h> |
| 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> |
Arjan van de Ven | 4186ecf | 2006-01-11 15:55:29 +0100 | [diff] [blame] | 60 | #include <linux/mutex.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | #include <asm/uaccess.h> |
| 62 | |
Greg KH | 6d5e825 | 2005-04-18 17:39:24 -0700 | [diff] [blame] | 63 | #include "usb.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 64 | #include "hcd.h" |
| 65 | |
| 66 | #define MAX_TOPO_LEVEL 6 |
| 67 | |
| 68 | /* Define ALLOW_SERIAL_NUMBER if you want to see the serial number of devices */ |
| 69 | #define ALLOW_SERIAL_NUMBER |
| 70 | |
Arjan van de Ven | 4c4c943 | 2005-11-29 09:43:42 +0100 | [diff] [blame] | 71 | static const char *format_topo = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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"; |
| 74 | |
Arjan van de Ven | 4c4c943 | 2005-11-29 09:43:42 +0100 | [diff] [blame] | 75 | static const char *format_string_manufacturer = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | /* S: Manufacturer=xxxx */ |
| 77 | "S: Manufacturer=%.100s\n"; |
| 78 | |
Arjan van de Ven | 4c4c943 | 2005-11-29 09:43:42 +0100 | [diff] [blame] | 79 | static const char *format_string_product = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 80 | /* S: Product=xxxx */ |
| 81 | "S: Product=%.100s\n"; |
| 82 | |
| 83 | #ifdef ALLOW_SERIAL_NUMBER |
Arjan van de Ven | 4c4c943 | 2005-11-29 09:43:42 +0100 | [diff] [blame] | 84 | static const char *format_string_serialnumber = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | /* S: SerialNumber=xxxx */ |
| 86 | "S: SerialNumber=%.100s\n"; |
| 87 | #endif |
| 88 | |
Arjan van de Ven | 4c4c943 | 2005-11-29 09:43:42 +0100 | [diff] [blame] | 89 | static const char *format_bandwidth = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | /* B: Alloc=ddd/ddd us (xx%), #Int=ddd, #Iso=ddd */ |
| 91 | "B: Alloc=%3d/%3d us (%2d%%), #Int=%3d, #Iso=%3d\n"; |
| 92 | |
Arjan van de Ven | 4c4c943 | 2005-11-29 09:43:42 +0100 | [diff] [blame] | 93 | static const char *format_device1 = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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"; |
| 96 | |
Arjan van de Ven | 4c4c943 | 2005-11-29 09:43:42 +0100 | [diff] [blame] | 97 | static const char *format_device2 = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | /* P: Vendor=xxxx ProdID=xxxx Rev=xx.xx */ |
| 99 | "P: Vendor=%04x ProdID=%04x Rev=%2x.%02x\n"; |
| 100 | |
Arjan van de Ven | 4c4c943 | 2005-11-29 09:43:42 +0100 | [diff] [blame] | 101 | static const char *format_config = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 102 | /* C: #Ifs=dd Cfg#=dd Atr=xx MPwr=dddmA */ |
| 103 | "C:%c #Ifs=%2d Cfg#=%2d Atr=%02x MxPwr=%3dmA\n"; |
| 104 | |
Arjan van de Ven | 4c4c943 | 2005-11-29 09:43:42 +0100 | [diff] [blame] | 105 | static const char *format_iface = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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"; |
| 108 | |
Arjan van de Ven | 4c4c943 | 2005-11-29 09:43:42 +0100 | [diff] [blame] | 109 | static const char *format_endpt = |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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"; |
| 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 | |
| 120 | static DECLARE_WAIT_QUEUE_HEAD(deviceconndiscwq); |
| 121 | static unsigned int conndiscevcnt = 0; |
| 122 | |
| 123 | /* this struct stores the poll state for <mountpoint>/devices pollers */ |
| 124 | struct usb_device_status { |
| 125 | unsigned int lastev; |
| 126 | }; |
| 127 | |
| 128 | struct class_info { |
| 129 | int class; |
| 130 | char *class_name; |
| 131 | }; |
| 132 | |
| 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 */ |
| 150 | }; |
| 151 | |
| 152 | /*****************************************************************/ |
| 153 | |
| 154 | void usbfs_conn_disc_event(void) |
| 155 | { |
| 156 | conndiscevcnt++; |
| 157 | wake_up(&deviceconndiscwq); |
| 158 | } |
| 159 | |
| 160 | static const char *class_decode(const int class) |
| 161 | { |
| 162 | int ix; |
| 163 | |
| 164 | for (ix = 0; clas_info[ix].class != -1; ix++) |
| 165 | if (clas_info[ix].class == class) |
| 166 | break; |
| 167 | return (clas_info[ix].class_name); |
| 168 | } |
| 169 | |
| 170 | static char *usb_dump_endpoint_descriptor ( |
| 171 | int speed, |
| 172 | char *start, |
| 173 | char *end, |
| 174 | const struct usb_endpoint_descriptor *desc |
| 175 | ) |
| 176 | { |
| 177 | char dir, unit, *type; |
| 178 | unsigned interval, in, bandwidth = 1; |
| 179 | |
| 180 | if (start > end) |
| 181 | return start; |
| 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; |
| 188 | } |
| 189 | } |
| 190 | |
| 191 | /* this isn't checking for illegal values */ |
| 192 | switch (desc->bmAttributes & USB_ENDPOINT_XFERTYPE_MASK) { |
| 193 | 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"; |
| 207 | if (speed == USB_SPEED_HIGH && !in) /* uframes per NAK */ |
| 208 | interval = desc->bInterval; |
| 209 | else |
| 210 | interval = 0; |
| 211 | break; |
| 212 | case USB_ENDPOINT_XFER_INT: |
| 213 | type = "Int."; |
| 214 | if (speed == USB_SPEED_HIGH) { |
| 215 | interval = 1 << (desc->bInterval - 1); |
| 216 | } else |
| 217 | 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, |
| 232 | (le16_to_cpu(desc->wMaxPacketSize) & 0x07ff) * bandwidth, |
| 233 | interval, unit); |
| 234 | return start; |
| 235 | } |
| 236 | |
| 237 | static char *usb_dump_interface_descriptor(char *start, char *end, |
| 238 | const struct usb_interface_cache *intfc, |
| 239 | const struct usb_interface *iface, |
| 240 | int setno) |
| 241 | { |
| 242 | const struct usb_interface_descriptor *desc = &intfc->altsetting[setno].desc; |
Dmitry Torokhov | 8d790d7 | 2005-04-26 02:34:05 -0500 | [diff] [blame] | 243 | const char *driver_name = ""; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 244 | |
| 245 | if (start > end) |
| 246 | return start; |
| 247 | down_read(&usb_bus_type.subsys.rwsem); |
| 248 | if (iface) |
| 249 | driver_name = (iface->dev.driver |
| 250 | ? iface->dev.driver->name |
| 251 | : "(none)"); |
| 252 | start += sprintf(start, format_iface, |
| 253 | desc->bInterfaceNumber, |
| 254 | desc->bAlternateSetting, |
| 255 | desc->bNumEndpoints, |
| 256 | desc->bInterfaceClass, |
| 257 | class_decode(desc->bInterfaceClass), |
| 258 | desc->bInterfaceSubClass, |
| 259 | desc->bInterfaceProtocol, |
| 260 | driver_name); |
| 261 | up_read(&usb_bus_type.subsys.rwsem); |
| 262 | return start; |
| 263 | } |
| 264 | |
| 265 | static char *usb_dump_interface( |
| 266 | int speed, |
| 267 | char *start, |
| 268 | char *end, |
| 269 | const struct usb_interface_cache *intfc, |
| 270 | const struct usb_interface *iface, |
| 271 | int setno |
| 272 | ) { |
| 273 | 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 | |
| 286 | /* TBD: |
| 287 | * 0. TBDs |
| 288 | * 1. marking active interface altsettings (code lists all, but should mark |
| 289 | * which ones are active, if any) |
| 290 | */ |
| 291 | |
| 292 | static char *usb_dump_config_descriptor(char *start, char *end, const struct usb_config_descriptor *desc, int active) |
| 293 | { |
| 294 | if (start > end) |
| 295 | return start; |
| 296 | start += sprintf(start, format_config, |
| 297 | active ? '*' : ' ', /* mark active/actual/current cfg. */ |
| 298 | desc->bNumInterfaces, |
| 299 | desc->bConfigurationValue, |
| 300 | desc->bmAttributes, |
| 301 | desc->bMaxPower * 2); |
| 302 | return start; |
| 303 | } |
| 304 | |
| 305 | static char *usb_dump_config ( |
| 306 | int speed, |
| 307 | char *start, |
| 308 | char *end, |
| 309 | const struct usb_host_config *config, |
| 310 | int active |
| 311 | ) |
| 312 | { |
| 313 | int i, j; |
| 314 | struct usb_interface_cache *intfc; |
| 315 | struct usb_interface *interface; |
| 316 | |
| 317 | if (start > end) |
| 318 | return start; |
| 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++) { |
| 326 | if (start > end) |
| 327 | return start; |
| 328 | start = usb_dump_interface(speed, |
| 329 | start, end, intfc, interface, j); |
| 330 | } |
| 331 | } |
| 332 | return start; |
| 333 | } |
| 334 | |
| 335 | /* |
| 336 | * Dump the different USB descriptors. |
| 337 | */ |
| 338 | static char *usb_dump_device_descriptor(char *start, char *end, const struct usb_device_descriptor *desc) |
| 339 | { |
| 340 | u16 bcdUSB = le16_to_cpu(desc->bcdUSB); |
| 341 | u16 bcdDevice = le16_to_cpu(desc->bcdDevice); |
| 342 | |
| 343 | if (start > end) |
| 344 | return start; |
| 345 | start += sprintf (start, format_device1, |
| 346 | bcdUSB >> 8, bcdUSB & 0xff, |
| 347 | desc->bDeviceClass, |
| 348 | class_decode (desc->bDeviceClass), |
| 349 | desc->bDeviceSubClass, |
| 350 | desc->bDeviceProtocol, |
| 351 | desc->bMaxPacketSize0, |
| 352 | desc->bNumConfigurations); |
| 353 | if (start > end) |
| 354 | return start; |
| 355 | start += sprintf(start, format_device2, |
| 356 | le16_to_cpu(desc->idVendor), |
| 357 | le16_to_cpu(desc->idProduct), |
| 358 | bcdDevice >> 8, bcdDevice & 0xff); |
| 359 | return start; |
| 360 | } |
| 361 | |
| 362 | /* |
| 363 | * Dump the different strings that this device holds. |
| 364 | */ |
| 365 | static char *usb_dump_device_strings (char *start, char *end, struct usb_device *dev) |
| 366 | { |
| 367 | if (start > end) |
| 368 | return start; |
| 369 | if (dev->manufacturer) |
| 370 | start += sprintf(start, format_string_manufacturer, dev->manufacturer); |
| 371 | if (start > end) |
| 372 | goto out; |
| 373 | if (dev->product) |
| 374 | start += sprintf(start, format_string_product, dev->product); |
| 375 | if (start > end) |
| 376 | goto out; |
| 377 | #ifdef ALLOW_SERIAL_NUMBER |
| 378 | if (dev->serial) |
| 379 | start += sprintf(start, format_string_serialnumber, dev->serial); |
| 380 | #endif |
| 381 | out: |
| 382 | return start; |
| 383 | } |
| 384 | |
| 385 | static char *usb_dump_desc(char *start, char *end, struct usb_device *dev) |
| 386 | { |
| 387 | int i; |
| 388 | |
| 389 | if (start > end) |
| 390 | return start; |
| 391 | |
| 392 | start = usb_dump_device_descriptor(start, end, &dev->descriptor); |
| 393 | |
| 394 | if (start > end) |
| 395 | return start; |
| 396 | |
| 397 | start = usb_dump_device_strings (start, end, dev); |
| 398 | |
| 399 | for (i = 0; i < dev->descriptor.bNumConfigurations; i++) { |
| 400 | if (start > end) |
| 401 | return start; |
| 402 | start = usb_dump_config(dev->speed, |
| 403 | start, end, dev->config + i, |
| 404 | /* active ? */ |
| 405 | (dev->config + i) == dev->actconfig); |
| 406 | } |
| 407 | return start; |
| 408 | } |
| 409 | |
| 410 | |
| 411 | #ifdef PROC_EXTRA /* TBD: may want to add this code later */ |
| 412 | |
| 413 | static char *usb_dump_hub_descriptor(char *start, char *end, const struct usb_hub_descriptor * desc) |
| 414 | { |
| 415 | int leng = USB_DT_HUB_NONVAR_SIZE; |
| 416 | unsigned char *ptr = (unsigned char *)desc; |
| 417 | |
| 418 | if (start > end) |
| 419 | return start; |
| 420 | start += sprintf(start, "Interface:"); |
| 421 | while (leng && start <= end) { |
| 422 | start += sprintf(start, " %02x", *ptr); |
| 423 | ptr++; leng--; |
| 424 | } |
| 425 | *start++ = '\n'; |
| 426 | return start; |
| 427 | } |
| 428 | |
| 429 | static char *usb_dump_string(char *start, char *end, const struct usb_device *dev, char *id, int index) |
| 430 | { |
| 431 | if (start > end) |
| 432 | return start; |
| 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]); |
| 436 | return start; |
| 437 | } |
| 438 | |
| 439 | #endif /* PROC_EXTRA */ |
| 440 | |
| 441 | /*****************************************************************/ |
| 442 | |
| 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. |
| 449 | */ |
| 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) |
| 452 | { |
| 453 | int chix; |
| 454 | int ret, cnt = 0; |
| 455 | int parent_devnum = 0; |
| 456 | char *pages_start, *data_end, *speed; |
| 457 | unsigned int length; |
| 458 | ssize_t total_written = 0; |
| 459 | |
| 460 | /* don't bother with anything else if we're not writing any data */ |
| 461 | if (*nbytes <= 0) |
| 462 | return 0; |
| 463 | |
| 464 | if (level > MAX_TOPO_LEVEL) |
| 465 | return 0; |
| 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))) |
| 468 | return -ENOMEM; |
| 469 | |
| 470 | if (usbdev->parent && usbdev->parent->devnum != -1) |
| 471 | parent_devnum = usbdev->parent->devnum; |
| 472 | /* |
| 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. |
| 475 | */ |
| 476 | switch (usbdev->speed) { |
| 477 | case USB_SPEED_LOW: |
| 478 | speed = "1.5"; break; |
| 479 | case USB_SPEED_UNKNOWN: /* usb 1.1 root hub code */ |
| 480 | case USB_SPEED_FULL: |
| 481 | speed = "12 "; break; |
| 482 | case USB_SPEED_HIGH: |
| 483 | speed = "480"; break; |
| 484 | default: |
| 485 | speed = "?? "; |
| 486 | } |
| 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); |
| 491 | /* |
| 492 | * level = topology-tier level; |
| 493 | * parent_devnum = parent device number; |
| 494 | * index = parent's connector number; |
| 495 | * count = device count at this level |
| 496 | */ |
| 497 | /* If this is the root hub, display the bandwidth information */ |
| 498 | if (level == 0) { |
| 499 | int max; |
| 500 | |
| 501 | /* high speed reserves 80%, full/low reserves 90% */ |
| 502 | if (usbdev->speed == USB_SPEED_HIGH) |
| 503 | max = 800; |
| 504 | else |
| 505 | max = FRAME_TIME_MAX_USECS_ALLOC; |
| 506 | |
| 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. |
| 510 | */ |
| 511 | data_end += sprintf(data_end, format_bandwidth, |
| 512 | bus->bandwidth_allocated, max, |
| 513 | (100 * bus->bandwidth_allocated + max / 2) |
| 514 | / max, |
| 515 | bus->bandwidth_int_reqs, |
| 516 | bus->bandwidth_isoc_reqs); |
| 517 | |
| 518 | } |
| 519 | data_end = usb_dump_desc(data_end, pages_start + (2 * PAGE_SIZE) - 256, usbdev); |
| 520 | |
| 521 | if (data_end > (pages_start + (2 * PAGE_SIZE) - 256)) |
| 522 | data_end += sprintf(data_end, "(truncated)\n"); |
| 523 | |
| 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) |
| 529 | length = *nbytes; |
| 530 | if (copy_to_user(*buffer, pages_start + *skip_bytes, length)) { |
| 531 | free_pages((unsigned long)pages_start, 1); |
| 532 | return -EFAULT; |
| 533 | } |
| 534 | *nbytes -= length; |
| 535 | *file_offset += length; |
| 536 | total_written += length; |
| 537 | *buffer += length; |
| 538 | *skip_bytes = 0; |
| 539 | } else |
| 540 | *skip_bytes -= length; |
| 541 | |
| 542 | free_pages((unsigned long)pages_start, 1); |
| 543 | |
| 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]; |
| 547 | |
| 548 | if (childdev) { |
Alan Stern | 9ad3d6c | 2005-11-17 17:10:32 -0500 | [diff] [blame] | 549 | usb_lock_device(childdev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 550 | ret = usb_device_dump(buffer, nbytes, skip_bytes, file_offset, childdev, |
| 551 | bus, level + 1, chix, ++cnt); |
Alan Stern | 9ad3d6c | 2005-11-17 17:10:32 -0500 | [diff] [blame] | 552 | usb_unlock_device(childdev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 553 | if (ret == -EFAULT) |
| 554 | return total_written; |
| 555 | total_written += ret; |
| 556 | } |
| 557 | } |
| 558 | return total_written; |
| 559 | } |
| 560 | |
| 561 | static ssize_t usb_device_read(struct file *file, char __user *buf, size_t nbytes, loff_t *ppos) |
| 562 | { |
| 563 | struct usb_bus *bus; |
| 564 | ssize_t ret, total_written = 0; |
| 565 | loff_t skip_bytes = *ppos; |
| 566 | |
| 567 | if (*ppos < 0) |
| 568 | return -EINVAL; |
| 569 | if (nbytes <= 0) |
| 570 | return 0; |
| 571 | if (!access_ok(VERIFY_WRITE, buf, nbytes)) |
| 572 | return -EFAULT; |
| 573 | |
Arjan van de Ven | 4186ecf | 2006-01-11 15:55:29 +0100 | [diff] [blame] | 574 | mutex_lock(&usb_bus_list_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 */ |
| 578 | if (!bus->root_hub) |
| 579 | continue; |
| 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); |
| 583 | if (ret < 0) { |
Arjan van de Ven | 4186ecf | 2006-01-11 15:55:29 +0100 | [diff] [blame] | 584 | mutex_unlock(&usb_bus_list_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 585 | return ret; |
| 586 | } |
| 587 | total_written += ret; |
| 588 | } |
Arjan van de Ven | 4186ecf | 2006-01-11 15:55:29 +0100 | [diff] [blame] | 589 | mutex_unlock(&usb_bus_list_lock); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 590 | return total_written; |
| 591 | } |
| 592 | |
| 593 | /* Kernel lock for "lastev" protection */ |
| 594 | static unsigned int usb_device_poll(struct file *file, struct poll_table_struct *wait) |
| 595 | { |
Tobias Klauser | ec17cf1 | 2006-09-13 21:38:41 +0200 | [diff] [blame^] | 596 | struct usb_device_status *st = file->private_data; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 597 | unsigned int mask = 0; |
| 598 | |
| 599 | lock_kernel(); |
| 600 | if (!st) { |
| 601 | st = kmalloc(sizeof(struct usb_device_status), GFP_KERNEL); |
| 602 | if (!st) { |
| 603 | unlock_kernel(); |
| 604 | return POLLIN; |
| 605 | } |
Tobias Klauser | ec17cf1 | 2006-09-13 21:38:41 +0200 | [diff] [blame^] | 606 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 607 | /* we may have dropped BKL - need to check for having lost the race */ |
| 608 | if (file->private_data) { |
| 609 | kfree(st); |
| 610 | st = file->private_data; |
| 611 | goto lost_race; |
| 612 | } |
| 613 | |
| 614 | /* |
| 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 |
| 618 | */ |
| 619 | st->lastev = conndiscevcnt; |
| 620 | file->private_data = st; |
| 621 | mask = POLLIN; |
| 622 | } |
| 623 | lost_race: |
| 624 | if (file->f_mode & FMODE_READ) |
| 625 | poll_wait(file, &deviceconndiscwq, wait); |
| 626 | if (st->lastev != conndiscevcnt) |
| 627 | mask |= POLLIN; |
| 628 | st->lastev = conndiscevcnt; |
| 629 | unlock_kernel(); |
| 630 | return mask; |
| 631 | } |
| 632 | |
| 633 | static int usb_device_open(struct inode *inode, struct file *file) |
| 634 | { |
| 635 | file->private_data = NULL; |
| 636 | return 0; |
| 637 | } |
| 638 | |
| 639 | static int usb_device_release(struct inode *inode, struct file *file) |
| 640 | { |
Jesper Juhl | 1bc3c9e | 2005-04-18 17:39:34 -0700 | [diff] [blame] | 641 | kfree(file->private_data); |
| 642 | file->private_data = NULL; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 643 | return 0; |
| 644 | } |
| 645 | |
| 646 | static loff_t usb_device_lseek(struct file * file, loff_t offset, int orig) |
| 647 | { |
| 648 | loff_t ret; |
| 649 | |
| 650 | lock_kernel(); |
| 651 | |
| 652 | switch (orig) { |
| 653 | case 0: |
| 654 | file->f_pos = offset; |
| 655 | ret = file->f_pos; |
| 656 | break; |
| 657 | case 1: |
| 658 | file->f_pos += offset; |
| 659 | ret = file->f_pos; |
| 660 | break; |
| 661 | case 2: |
| 662 | default: |
| 663 | ret = -EINVAL; |
| 664 | } |
| 665 | |
| 666 | unlock_kernel(); |
| 667 | return ret; |
| 668 | } |
| 669 | |
Luiz Fernando N. Capitulino | 066202d | 2006-08-05 20:37:11 -0300 | [diff] [blame] | 670 | const struct file_operations usbfs_devices_fops = { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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, |
| 676 | }; |