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 if (speed == USB_SPEED_HIGH)
161 interval = desc->bInterval;
162 else
163 interval = 0;
164 dir = 'B';
165 break;
166 case USB_ENDPOINT_XFER_ISOC:
167 type = "Isoc";
168 interval = 1 << (desc->bInterval - 1);
169 break;
170 case USB_ENDPOINT_XFER_BULK:
171 type = "Bulk";
172 if (speed == USB_SPEED_HIGH && dir == 'O')
173 interval = desc->bInterval;
174 else
175 interval = 0;
176 break;
177 case USB_ENDPOINT_XFER_INT:
178 type = "Int.";
179 if (speed == USB_SPEED_HIGH || speed >= USB_SPEED_SUPER)
180 interval = 1 << (desc->bInterval - 1);
181 else
182 interval = desc->bInterval;
183 break;
184 default:
185 return start;
186 }
187 interval *= (speed == USB_SPEED_HIGH ||
188 speed >= USB_SPEED_SUPER) ? 125 : 1000;
189 if (interval % 1000)
190 unit = 'u';
191 else {
192 unit = 'm';
193 interval /= 1000;
194 }
195
196 start += sprintf(start, format_endpt, desc->bEndpointAddress, dir,
197 desc->bmAttributes, type,
198 usb_endpoint_maxp(desc) *
199 bandwidth,
200 interval, unit);
201 return start;
202}
203
204static char *usb_dump_interface_descriptor(char *start, char *end,
205 const struct usb_interface_cache *intfc,
206 const struct usb_interface *iface,
207 int setno)
208{
209 const struct usb_interface_descriptor *desc;
210 const char *driver_name = "";
211 int active = 0;
212
213 if (start > end)
214 return start;
215 desc = &intfc->altsetting[setno].desc;
216 if (iface) {
217 driver_name = (iface->dev.driver
218 ? iface->dev.driver->name
219 : "(none)");
220 active = (desc == &iface->cur_altsetting->desc);
221 }
222 start += sprintf(start, format_iface,
223 active ? '*' : ' ',
224 desc->bInterfaceNumber,
225 desc->bAlternateSetting,
226 desc->bNumEndpoints,
227 desc->bInterfaceClass,
228 class_decode(desc->bInterfaceClass),
229 desc->bInterfaceSubClass,
230 desc->bInterfaceProtocol,
231 driver_name);
232 return start;
233}
234
235static char *usb_dump_interface(int speed, char *start, char *end,
236 const struct usb_interface_cache *intfc,
237 const struct usb_interface *iface, int setno)
238{
239 const struct usb_host_interface *desc = &intfc->altsetting[setno];
240 int i;
241
242 start = usb_dump_interface_descriptor(start, end, intfc, iface, setno);
243 for (i = 0; i < desc->desc.bNumEndpoints; i++) {
244 if (start > end)
245 return start;
246 start = usb_dump_endpoint_descriptor(speed,
247 start, end, &desc->endpoint[i].desc);
248 }
249 return start;
250}
251
252static char *usb_dump_iad_descriptor(char *start, char *end,
253 const struct usb_interface_assoc_descriptor *iad)
254{
255 if (start > end)
256 return start;
257 start += sprintf(start, format_iad,
258 iad->bFirstInterface,
259 iad->bInterfaceCount,
260 iad->bFunctionClass,
261 class_decode(iad->bFunctionClass),
262 iad->bFunctionSubClass,
263 iad->bFunctionProtocol);
264 return start;
265}
266
267
268
269
270
271
272static char *usb_dump_config_descriptor(char *start, char *end,
273 const struct usb_config_descriptor *desc,
274 int active, int speed)
275{
276 int mul;
277
278 if (start > end)
279 return start;
280 if (speed >= USB_SPEED_SUPER)
281 mul = 8;
282 else
283 mul = 2;
284 start += sprintf(start, format_config,
285
286 active ? '*' : ' ',
287 desc->bNumInterfaces,
288 desc->bConfigurationValue,
289 desc->bmAttributes,
290 desc->bMaxPower * mul);
291 return start;
292}
293
294static char *usb_dump_config(int speed, char *start, char *end,
295 const struct usb_host_config *config, int active)
296{
297 int i, j;
298 struct usb_interface_cache *intfc;
299 struct usb_interface *interface;
300
301 if (start > end)
302 return start;
303 if (!config)
304
305 return start + sprintf(start, "(null Cfg. desc.)\n");
306 start = usb_dump_config_descriptor(start, end, &config->desc, active,
307 speed);
308 for (i = 0; i < USB_MAXIADS; i++) {
309 if (config->intf_assoc[i] == NULL)
310 break;
311 start = usb_dump_iad_descriptor(start, end,
312 config->intf_assoc[i]);
313 }
314 for (i = 0; i < config->desc.bNumInterfaces; i++) {
315 intfc = config->intf_cache[i];
316 interface = config->interface[i];
317 for (j = 0; j < intfc->num_altsetting; j++) {
318 if (start > end)
319 return start;
320 start = usb_dump_interface(speed,
321 start, end, intfc, interface, j);
322 }
323 }
324 return start;
325}
326
327
328
329
330static char *usb_dump_device_descriptor(char *start, char *end,
331 const struct usb_device_descriptor *desc)
332{
333 u16 bcdUSB = le16_to_cpu(desc->bcdUSB);
334 u16 bcdDevice = le16_to_cpu(desc->bcdDevice);
335
336 if (start > end)
337 return start;
338 start += sprintf(start, format_device1,
339 bcdUSB >> 8, bcdUSB & 0xff,
340 desc->bDeviceClass,
341 class_decode(desc->bDeviceClass),
342 desc->bDeviceSubClass,
343 desc->bDeviceProtocol,
344 desc->bMaxPacketSize0,
345 desc->bNumConfigurations);
346 if (start > end)
347 return start;
348 start += sprintf(start, format_device2,
349 le16_to_cpu(desc->idVendor),
350 le16_to_cpu(desc->idProduct),
351 bcdDevice >> 8, bcdDevice & 0xff);
352 return start;
353}
354
355
356
357
358static char *usb_dump_device_strings(char *start, char *end,
359 struct usb_device *dev)
360{
361 if (start > end)
362 return start;
363 if (dev->manufacturer)
364 start += sprintf(start, format_string_manufacturer,
365 dev->manufacturer);
366 if (start > end)
367 goto out;
368 if (dev->product)
369 start += sprintf(start, format_string_product, dev->product);
370 if (start > end)
371 goto out;
372#ifdef ALLOW_SERIAL_NUMBER
373 if (dev->serial)
374 start += sprintf(start, format_string_serialnumber,
375 dev->serial);
376#endif
377 out:
378 return start;
379}
380
381static char *usb_dump_desc(char *start, char *end, struct usb_device *dev)
382{
383 int i;
384
385 if (start > end)
386 return start;
387
388 start = usb_dump_device_descriptor(start, end, &dev->descriptor);
389
390 if (start > end)
391 return start;
392
393 start = usb_dump_device_strings(start, end, dev);
394
395 for (i = 0; i < dev->descriptor.bNumConfigurations; i++) {
396 if (start > end)
397 return start;
398 start = usb_dump_config(dev->speed,
399 start, end, dev->config + i,
400
401 (dev->config + i) == dev->actconfig);
402 }
403 return start;
404}
405
406
407#ifdef PROC_EXTRA
408
409static char *usb_dump_hub_descriptor(char *start, char *end,
410 const struct usb_hub_descriptor *desc)
411{
412 int leng = USB_DT_HUB_NONVAR_SIZE;
413 unsigned char *ptr = (unsigned char *)desc;
414
415 if (start > end)
416 return start;
417 start += sprintf(start, "Interface:");
418 while (leng && start <= end) {
419 start += sprintf(start, " %02x", *ptr);
420 ptr++; leng--;
421 }
422 *start++ = '\n';
423 return start;
424}
425
426static char *usb_dump_string(char *start, char *end,
427 const struct usb_device *dev, char *id, int index)
428{
429 if (start > end)
430 return start;
431 start += sprintf(start, "Interface:");
432 if (index <= dev->maxstring && dev->stringindex &&
433 dev->stringindex[index])
434 start += sprintf(start, "%s: %.100s ", id,
435 dev->stringindex[index]);
436 return start;
437}
438
439#endif
440
441
442
443
444
445
446
447
448
449
450static ssize_t usb_device_dump(char __user **buffer, size_t *nbytes,
451 loff_t *skip_bytes, loff_t *file_offset,
452 struct usb_device *usbdev, struct usb_bus *bus,
453 int level, int index, int count)
454{
455 int chix;
456 int ret, cnt = 0;
457 int parent_devnum = 0;
458 char *pages_start, *data_end, *speed;
459 unsigned int length;
460 ssize_t total_written = 0;
461 struct usb_device *childdev = NULL;
462
463
464 if (*nbytes <= 0)
465 return 0;
466
467 if (level > MAX_TOPO_LEVEL)
468 return 0;
469
470
471 pages_start = (char *)__get_free_pages(GFP_NOIO, 1);
472 if (!pages_start)
473 return -ENOMEM;
474
475 if (usbdev->parent && usbdev->parent->devnum != -1)
476 parent_devnum = usbdev->parent->devnum;
477
478
479
480
481 switch (usbdev->speed) {
482 case USB_SPEED_LOW:
483 speed = "1.5"; break;
484 case USB_SPEED_UNKNOWN:
485 case USB_SPEED_FULL:
486 speed = "12"; break;
487 case USB_SPEED_WIRELESS:
488 case USB_SPEED_HIGH:
489 speed = "480"; break;
490 case USB_SPEED_SUPER:
491 speed = "5000"; break;
492 case USB_SPEED_SUPER_PLUS:
493 speed = "10000"; break;
494 default:
495 speed = "??";
496 }
497 data_end = pages_start + sprintf(pages_start, format_topo,
498 bus->busnum, level, parent_devnum,
499 index, count, usbdev->devnum,
500 speed, usbdev->maxchild);
501
502
503
504
505
506
507
508 if (level == 0) {
509 int max;
510
511
512 if (usbdev->speed == USB_SPEED_HIGH ||
513 usbdev->speed >= USB_SPEED_SUPER)
514 max = 800;
515 else
516 max = FRAME_TIME_MAX_USECS_ALLOC;
517
518
519
520
521
522 data_end += sprintf(data_end, format_bandwidth,
523 bus->bandwidth_allocated, max,
524 (100 * bus->bandwidth_allocated + max / 2)
525 / max,
526 bus->bandwidth_int_reqs,
527 bus->bandwidth_isoc_reqs);
528
529 }
530 data_end = usb_dump_desc(data_end, pages_start + (2 * PAGE_SIZE) - 256,
531 usbdev);
532
533 if (data_end > (pages_start + (2 * PAGE_SIZE) - 256))
534 data_end += sprintf(data_end, "(truncated)\n");
535
536 length = data_end - pages_start;
537
538 if (length > *skip_bytes) {
539 length -= *skip_bytes;
540 if (length > *nbytes)
541 length = *nbytes;
542 if (copy_to_user(*buffer, pages_start + *skip_bytes, length)) {
543 free_pages((unsigned long)pages_start, 1);
544 return -EFAULT;
545 }
546 *nbytes -= length;
547 *file_offset += length;
548 total_written += length;
549 *buffer += length;
550 *skip_bytes = 0;
551 } else
552 *skip_bytes -= length;
553
554 free_pages((unsigned long)pages_start, 1);
555
556
557 usb_hub_for_each_child(usbdev, chix, childdev) {
558 usb_lock_device(childdev);
559 ret = usb_device_dump(buffer, nbytes, skip_bytes,
560 file_offset, childdev, bus,
561 level + 1, chix - 1, ++cnt);
562 usb_unlock_device(childdev);
563 if (ret == -EFAULT)
564 return total_written;
565 total_written += ret;
566 }
567 return total_written;
568}
569
570static ssize_t usb_device_read(struct file *file, char __user *buf,
571 size_t nbytes, loff_t *ppos)
572{
573 struct usb_bus *bus;
574 ssize_t ret, total_written = 0;
575 loff_t skip_bytes = *ppos;
576 int id;
577
578 if (*ppos < 0)
579 return -EINVAL;
580 if (nbytes <= 0)
581 return 0;
582
583 mutex_lock(&usb_bus_idr_lock);
584
585 idr_for_each_entry(&usb_bus_idr, bus, id) {
586
587 if (!bus_to_hcd(bus)->rh_registered)
588 continue;
589 usb_lock_device(bus->root_hub);
590 ret = usb_device_dump(&buf, &nbytes, &skip_bytes, ppos,
591 bus->root_hub, bus, 0, 0, 0);
592 usb_unlock_device(bus->root_hub);
593 if (ret < 0) {
594 mutex_unlock(&usb_bus_idr_lock);
595 return ret;
596 }
597 total_written += ret;
598 }
599 mutex_unlock(&usb_bus_idr_lock);
600 return total_written;
601}
602
603const struct file_operations usbfs_devices_fops = {
604 .llseek = no_seek_end_llseek,
605 .read = usb_device_read,
606};
607