1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39#include <linux/fs.h>
40#include <linux/mm.h>
41#include <linux/gfp.h>
42#include <linux/usb.h>
43#include <linux/usbdevice_fs.h>
44#include <linux/usb/hcd.h>
45#include <linux/mutex.h>
46#include <linux/uaccess.h>
47
48#include "usb.h"
49
50
51#define ALLOW_SERIAL_NUMBER
52
53static const char format_topo[] =
54
55"\nT: Bus=%2.2d Lev=%2.2d Prnt=%2.2d Port=%2.2d Cnt=%2.2d Dev#=%3d Spd=%-4s MxCh=%2d\n";
56
57static const char format_string_manufacturer[] =
58
59 "S: Manufacturer=%.100s\n";
60
61static const char format_string_product[] =
62
63 "S: Product=%.100s\n";
64
65#ifdef ALLOW_SERIAL_NUMBER
66static const char format_string_serialnumber[] =
67
68 "S: SerialNumber=%.100s\n";
69#endif
70
71static const char format_bandwidth[] =
72
73 "B: Alloc=%3d/%3d us (%2d%%), #Int=%3d, #Iso=%3d\n";
74
75static const char format_device1[] =
76
77 "D: Ver=%2x.%02x Cls=%02x(%-5s) Sub=%02x Prot=%02x MxPS=%2d #Cfgs=%3d\n";
78
79static const char format_device2[] =
80
81 "P: Vendor=%04x ProdID=%04x Rev=%2x.%02x\n";
82
83static const char format_config[] =
84
85 "C:%c #Ifs=%2d Cfg#=%2d Atr=%02x MxPwr=%3dmA\n";
86
87static const char format_iad[] =
88
89 "A: FirstIf#=%2d IfCount=%2d Cls=%02x(%-5s) Sub=%02x Prot=%02x\n";
90
91static const char format_iface[] =
92
93 "I:%c If#=%2d Alt=%2d #EPs=%2d Cls=%02x(%-5s) Sub=%02x Prot=%02x Driver=%s\n";
94
95static const char format_endpt[] =
96
97 "E: Ad=%02x(%c) Atr=%02x(%-4s) MxPS=%4d Ivl=%d%cs\n";
98
99struct class_info {
100 int class;
101 char *class_name;
102};
103
104static const struct class_info clas_info[] = {
105
106 {USB_CLASS_PER_INTERFACE, ">ifc"},
107 {USB_CLASS_AUDIO, "audio"},
108 {USB_CLASS_COMM, "comm."},
109 {USB_CLASS_HID, "HID"},
110 {USB_CLASS_PHYSICAL, "PID"},
111 {USB_CLASS_STILL_IMAGE, "still"},
112 {USB_CLASS_PRINTER, "print"},
113 {USB_CLASS_MASS_STORAGE, "stor."},
114 {USB_CLASS_HUB, "hub"},
115 {USB_CLASS_CDC_DATA, "data"},
116 {USB_CLASS_CSCID, "scard"},
117 {USB_CLASS_CONTENT_SEC, "c-sec"},
118 {USB_CLASS_VIDEO, "video"},
119 {USB_CLASS_PERSONAL_HEALTHCARE, "perhc"},
120 {USB_CLASS_AUDIO_VIDEO, "av"},
121 {USB_CLASS_BILLBOARD, "blbrd"},
122 {USB_CLASS_USB_TYPE_C_BRIDGE, "bridg"},
123 {USB_CLASS_WIRELESS_CONTROLLER, "wlcon"},
124 {USB_CLASS_MISC, "misc"},
125 {USB_CLASS_APP_SPEC, "app."},
126 {USB_CLASS_VENDOR_SPEC, "vend."},
127 {-1, "unk."}
128};
129
130
131
132static const char *class_decode(const int class)
133{
134 int ix;
135
136 for (ix = 0; clas_info[ix].class != -1; ix++)
137 if (clas_info[ix].class == class)
138 break;
139 return clas_info[ix].class_name;
140}
141
142static char *usb_dump_endpoint_descriptor(int speed, char *start, char *end,
143 const struct usb_endpoint_descriptor *desc)
144{
145 char dir, unit, *type;
146 unsigned interval, bandwidth = 1;
147
148 if (start > end)
149 return start;
150
151 dir = usb_endpoint_dir_in(desc) ? 'I' : 'O';
152
153 if (speed == USB_SPEED_HIGH)
154 bandwidth = usb_endpoint_maxp_mult(desc);
155
156
157 switch (usb_endpoint_type(desc)) {
158 case USB_ENDPOINT_XFER_CONTROL:
159 type = "Ctrl";
160 dir = 'B';
161 break;
162 case USB_ENDPOINT_XFER_ISOC:
163 type = "Isoc";
164 break;
165 case USB_ENDPOINT_XFER_BULK:
166 type = "Bulk";
167 break;
168 case USB_ENDPOINT_XFER_INT:
169 type = "Int.";
170 break;
171 default:
172 return start;
173 }
174
175 interval = usb_decode_interval(desc, speed);
176 if (interval % 1000) {
177 unit = 'u';
178 } else {
179 unit = 'm';
180 interval /= 1000;
181 }
182
183 start += sprintf(start, format_endpt, desc->bEndpointAddress, dir,
184 desc->bmAttributes, type,
185 usb_endpoint_maxp(desc) *
186 bandwidth,
187 interval, unit);
188 return start;
189}
190
191static char *usb_dump_interface_descriptor(char *start, char *end,
192 const struct usb_interface_cache *intfc,
193 const struct usb_interface *iface,
194 int setno)
195{
196 const struct usb_interface_descriptor *desc;
197 const char *driver_name = "";
198 int active = 0;
199
200 if (start > end)
201 return start;
202 desc = &intfc->altsetting[setno].desc;
203 if (iface) {
204 driver_name = (iface->dev.driver
205 ? iface->dev.driver->name
206 : "(none)");
207 active = (desc == &iface->cur_altsetting->desc);
208 }
209 start += sprintf(start, format_iface,
210 active ? '*' : ' ',
211 desc->bInterfaceNumber,
212 desc->bAlternateSetting,
213 desc->bNumEndpoints,
214 desc->bInterfaceClass,
215 class_decode(desc->bInterfaceClass),
216 desc->bInterfaceSubClass,
217 desc->bInterfaceProtocol,
218 driver_name);
219 return start;
220}
221
222static char *usb_dump_interface(int speed, char *start, char *end,
223 const struct usb_interface_cache *intfc,
224 const struct usb_interface *iface, int setno)
225{
226 const struct usb_host_interface *desc = &intfc->altsetting[setno];
227 int i;
228
229 start = usb_dump_interface_descriptor(start, end, intfc, iface, setno);
230 for (i = 0; i < desc->desc.bNumEndpoints; i++) {
231 if (start > end)
232 return start;
233 start = usb_dump_endpoint_descriptor(speed,
234 start, end, &desc->endpoint[i].desc);
235 }
236 return start;
237}
238
239static char *usb_dump_iad_descriptor(char *start, char *end,
240 const struct usb_interface_assoc_descriptor *iad)
241{
242 if (start > end)
243 return start;
244 start += sprintf(start, format_iad,
245 iad->bFirstInterface,
246 iad->bInterfaceCount,
247 iad->bFunctionClass,
248 class_decode(iad->bFunctionClass),
249 iad->bFunctionSubClass,
250 iad->bFunctionProtocol);
251 return start;
252}
253
254
255
256
257
258
259static char *usb_dump_config_descriptor(char *start, char *end,
260 const struct usb_config_descriptor *desc,
261 int active, int speed)
262{
263 int mul;
264
265 if (start > end)
266 return start;
267 if (speed >= USB_SPEED_SUPER)
268 mul = 8;
269 else
270 mul = 2;
271 start += sprintf(start, format_config,
272
273 active ? '*' : ' ',
274 desc->bNumInterfaces,
275 desc->bConfigurationValue,
276 desc->bmAttributes,
277 desc->bMaxPower * mul);
278 return start;
279}
280
281static char *usb_dump_config(int speed, char *start, char *end,
282 const struct usb_host_config *config, int active)
283{
284 int i, j;
285 struct usb_interface_cache *intfc;
286 struct usb_interface *interface;
287
288 if (start > end)
289 return start;
290 if (!config)
291
292 return start + sprintf(start, "(null Cfg. desc.)\n");
293 start = usb_dump_config_descriptor(start, end, &config->desc, active,
294 speed);
295 for (i = 0; i < USB_MAXIADS; i++) {
296 if (config->intf_assoc[i] == NULL)
297 break;
298 start = usb_dump_iad_descriptor(start, end,
299 config->intf_assoc[i]);
300 }
301 for (i = 0; i < config->desc.bNumInterfaces; i++) {
302 intfc = config->intf_cache[i];
303 interface = config->interface[i];
304 for (j = 0; j < intfc->num_altsetting; j++) {
305 if (start > end)
306 return start;
307 start = usb_dump_interface(speed,
308 start, end, intfc, interface, j);
309 }
310 }
311 return start;
312}
313
314
315
316
317static char *usb_dump_device_descriptor(char *start, char *end,
318 const struct usb_device_descriptor *desc)
319{
320 u16 bcdUSB = le16_to_cpu(desc->bcdUSB);
321 u16 bcdDevice = le16_to_cpu(desc->bcdDevice);
322
323 if (start > end)
324 return start;
325 start += sprintf(start, format_device1,
326 bcdUSB >> 8, bcdUSB & 0xff,
327 desc->bDeviceClass,
328 class_decode(desc->bDeviceClass),
329 desc->bDeviceSubClass,
330 desc->bDeviceProtocol,
331 desc->bMaxPacketSize0,
332 desc->bNumConfigurations);
333 if (start > end)
334 return start;
335 start += sprintf(start, format_device2,
336 le16_to_cpu(desc->idVendor),
337 le16_to_cpu(desc->idProduct),
338 bcdDevice >> 8, bcdDevice & 0xff);
339 return start;
340}
341
342
343
344
345static char *usb_dump_device_strings(char *start, char *end,
346 struct usb_device *dev)
347{
348 if (start > end)
349 return start;
350 if (dev->manufacturer)
351 start += sprintf(start, format_string_manufacturer,
352 dev->manufacturer);
353 if (start > end)
354 goto out;
355 if (dev->product)
356 start += sprintf(start, format_string_product, dev->product);
357 if (start > end)
358 goto out;
359#ifdef ALLOW_SERIAL_NUMBER
360 if (dev->serial)
361 start += sprintf(start, format_string_serialnumber,
362 dev->serial);
363#endif
364 out:
365 return start;
366}
367
368static char *usb_dump_desc(char *start, char *end, struct usb_device *dev)
369{
370 int i;
371
372 if (start > end)
373 return start;
374
375 start = usb_dump_device_descriptor(start, end, &dev->descriptor);
376
377 if (start > end)
378 return start;
379
380 start = usb_dump_device_strings(start, end, dev);
381
382 for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
383 if (start > end)
384 return start;
385 start = usb_dump_config(dev->speed,
386 start, end, dev->config + i,
387
388 (dev->config + i) == dev->actconfig);
389 }
390 return start;
391}
392
393
394#ifdef PROC_EXTRA
395
396static char *usb_dump_hub_descriptor(char *start, char *end,
397 const struct usb_hub_descriptor *desc)
398{
399 int leng = USB_DT_HUB_NONVAR_SIZE;
400 unsigned char *ptr = (unsigned char *)desc;
401
402 if (start > end)
403 return start;
404 start += sprintf(start, "Interface:");
405 while (leng && start <= end) {
406 start += sprintf(start, " %02x", *ptr);
407 ptr++; leng--;
408 }
409 *start++ = '\n';
410 return start;
411}
412
413static char *usb_dump_string(char *start, char *end,
414 const struct usb_device *dev, char *id, int index)
415{
416 if (start > end)
417 return start;
418 start += sprintf(start, "Interface:");
419 if (index <= dev->maxstring && dev->stringindex &&
420 dev->stringindex[index])
421 start += sprintf(start, "%s: %.100s ", id,
422 dev->stringindex[index]);
423 return start;
424}
425
426#endif
427
428
429
430
431
432
433
434
435
436
437static ssize_t usb_device_dump(char __user **buffer, size_t *nbytes,
438 loff_t *skip_bytes, loff_t *file_offset,
439 struct usb_device *usbdev, struct usb_bus *bus,
440 int level, int index, int count)
441{
442 int chix;
443 int ret, cnt = 0;
444 int parent_devnum = 0;
445 char *pages_start, *data_end, *speed;
446 unsigned int length;
447 ssize_t total_written = 0;
448 struct usb_device *childdev = NULL;
449
450
451 if (*nbytes <= 0)
452 return 0;
453
454 if (level > MAX_TOPO_LEVEL)
455 return 0;
456
457
458 pages_start = (char *)__get_free_pages(GFP_NOIO, 1);
459 if (!pages_start)
460 return -ENOMEM;
461
462 if (usbdev->parent && usbdev->parent->devnum != -1)
463 parent_devnum = usbdev->parent->devnum;
464
465
466
467
468 switch (usbdev->speed) {
469 case USB_SPEED_LOW:
470 speed = "1.5"; break;
471 case USB_SPEED_UNKNOWN:
472 case USB_SPEED_FULL:
473 speed = "12"; break;
474 case USB_SPEED_WIRELESS:
475 case USB_SPEED_HIGH:
476 speed = "480"; break;
477 case USB_SPEED_SUPER:
478 speed = "5000"; break;
479 case USB_SPEED_SUPER_PLUS:
480 speed = "10000"; break;
481 default:
482 speed = "??";
483 }
484 data_end = pages_start + sprintf(pages_start, format_topo,
485 bus->busnum, level, parent_devnum,
486 index, count, usbdev->devnum,
487 speed, usbdev->maxchild);
488
489
490
491
492
493
494
495 if (level == 0) {
496 int max;
497
498
499 if (usbdev->speed == USB_SPEED_HIGH ||
500 usbdev->speed >= USB_SPEED_SUPER)
501 max = 800;
502 else
503 max = FRAME_TIME_MAX_USECS_ALLOC;
504
505
506
507
508
509 data_end += sprintf(data_end, format_bandwidth,
510 bus->bandwidth_allocated, max,
511 (100 * bus->bandwidth_allocated + max / 2)
512 / max,
513 bus->bandwidth_int_reqs,
514 bus->bandwidth_isoc_reqs);
515
516 }
517 data_end = usb_dump_desc(data_end, pages_start + (2 * PAGE_SIZE) - 256,
518 usbdev);
519
520 if (data_end > (pages_start + (2 * PAGE_SIZE) - 256))
521 data_end += sprintf(data_end, "(truncated)\n");
522
523 length = data_end - pages_start;
524
525 if (length > *skip_bytes) {
526 length -= *skip_bytes;
527 if (length > *nbytes)
528 length = *nbytes;
529 if (copy_to_user(*buffer, pages_start + *skip_bytes, length)) {
530 free_pages((unsigned long)pages_start, 1);
531 return -EFAULT;
532 }
533 *nbytes -= length;
534 *file_offset += length;
535 total_written += length;
536 *buffer += length;
537 *skip_bytes = 0;
538 } else
539 *skip_bytes -= length;
540
541 free_pages((unsigned long)pages_start, 1);
542
543
544 usb_hub_for_each_child(usbdev, chix, childdev) {
545 usb_lock_device(childdev);
546 ret = usb_device_dump(buffer, nbytes, skip_bytes,
547 file_offset, childdev, bus,
548 level + 1, chix - 1, ++cnt);
549 usb_unlock_device(childdev);
550 if (ret == -EFAULT)
551 return total_written;
552 total_written += ret;
553 }
554 return total_written;
555}
556
557static ssize_t usb_device_read(struct file *file, char __user *buf,
558 size_t nbytes, loff_t *ppos)
559{
560 struct usb_bus *bus;
561 ssize_t ret, total_written = 0;
562 loff_t skip_bytes = *ppos;
563 int id;
564
565 if (*ppos < 0)
566 return -EINVAL;
567 if (nbytes <= 0)
568 return 0;
569
570 mutex_lock(&usb_bus_idr_lock);
571
572 idr_for_each_entry(&usb_bus_idr, bus, id) {
573
574 if (!bus_to_hcd(bus)->rh_registered)
575 continue;
576 usb_lock_device(bus->root_hub);
577 ret = usb_device_dump(&buf, &nbytes, &skip_bytes, ppos,
578 bus->root_hub, bus, 0, 0, 0);
579 usb_unlock_device(bus->root_hub);
580 if (ret < 0) {
581 mutex_unlock(&usb_bus_idr_lock);
582 return ret;
583 }
584 total_written += ret;
585 }
586 mutex_unlock(&usb_bus_idr_lock);
587 return total_written;
588}
589
590const struct file_operations usbfs_devices_fops = {
591 .llseek = no_seek_end_llseek,
592 .read = usb_device_read,
593};
594