1 /*
2 * drivers/usb/core/sysfs.c
3 *
4 * (C) Copyright 2002 David Brownell
5 * (C) Copyright 2002,2004 Greg Kroah-Hartman
6 * (C) Copyright 2002,2004 IBM Corp.
7 *
8 * All of the sysfs file attributes for usb devices and interfaces.
9 *
10 */
11
12
13 #include <linux/kernel.h>
14 #include <linux/string.h>
15 #include <linux/usb.h>
16 #include <linux/usb/quirks.h>
17 #include "usb.h"
18
19 /* Active configuration fields */
20 #define usb_actconfig_show(field, format_string) \
21 static ssize_t field##_show(struct device *dev, \
22 struct device_attribute *attr, char *buf) \
23 { \
24 struct usb_device *udev; \
25 struct usb_host_config *actconfig; \
26 ssize_t rc = 0; \
27 \
28 udev = to_usb_device(dev); \
29 usb_lock_device(udev); \
30 actconfig = udev->actconfig; \
31 if (actconfig) \
32 rc = sprintf(buf, format_string, \
33 actconfig->desc.field); \
34 usb_unlock_device(udev); \
35 return rc; \
36 } \
37
38 #define usb_actconfig_attr(field, format_string) \
39 usb_actconfig_show(field, format_string) \
40 static DEVICE_ATTR_RO(field)
41
42 usb_actconfig_attr(bNumInterfaces, "%2d\n");
43 usb_actconfig_attr(bmAttributes, "%2x\n");
44
bMaxPower_show(struct device * dev,struct device_attribute * attr,char * buf)45 static ssize_t bMaxPower_show(struct device *dev,
46 struct device_attribute *attr, char *buf)
47 {
48 struct usb_device *udev;
49 struct usb_host_config *actconfig;
50 ssize_t rc = 0;
51
52 udev = to_usb_device(dev);
53 usb_lock_device(udev);
54 actconfig = udev->actconfig;
55 if (actconfig)
56 rc = sprintf(buf, "%dmA\n", usb_get_max_power(udev, actconfig));
57 usb_unlock_device(udev);
58 return rc;
59 }
60 static DEVICE_ATTR_RO(bMaxPower);
61
configuration_show(struct device * dev,struct device_attribute * attr,char * buf)62 static ssize_t configuration_show(struct device *dev,
63 struct device_attribute *attr, char *buf)
64 {
65 struct usb_device *udev;
66 struct usb_host_config *actconfig;
67 ssize_t rc = 0;
68
69 udev = to_usb_device(dev);
70 usb_lock_device(udev);
71 actconfig = udev->actconfig;
72 if (actconfig && actconfig->string)
73 rc = sprintf(buf, "%s\n", actconfig->string);
74 usb_unlock_device(udev);
75 return rc;
76 }
77 static DEVICE_ATTR_RO(configuration);
78
79 /* configuration value is always present, and r/w */
80 usb_actconfig_show(bConfigurationValue, "%u\n");
81
bConfigurationValue_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)82 static ssize_t bConfigurationValue_store(struct device *dev,
83 struct device_attribute *attr,
84 const char *buf, size_t count)
85 {
86 struct usb_device *udev = to_usb_device(dev);
87 int config, value;
88
89 if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255)
90 return -EINVAL;
91 usb_lock_device(udev);
92 value = usb_set_configuration(udev, config);
93 usb_unlock_device(udev);
94 return (value < 0) ? value : count;
95 }
96 static DEVICE_ATTR_IGNORE_LOCKDEP(bConfigurationValue, S_IRUGO | S_IWUSR,
97 bConfigurationValue_show, bConfigurationValue_store);
98
99 /* String fields */
100 #define usb_string_attr(name) \
101 static ssize_t name##_show(struct device *dev, \
102 struct device_attribute *attr, char *buf) \
103 { \
104 struct usb_device *udev; \
105 int retval; \
106 \
107 udev = to_usb_device(dev); \
108 usb_lock_device(udev); \
109 retval = sprintf(buf, "%s\n", udev->name); \
110 usb_unlock_device(udev); \
111 return retval; \
112 } \
113 static DEVICE_ATTR_RO(name)
114
115 usb_string_attr(product);
116 usb_string_attr(manufacturer);
117 usb_string_attr(serial);
118
speed_show(struct device * dev,struct device_attribute * attr,char * buf)119 static ssize_t speed_show(struct device *dev, struct device_attribute *attr,
120 char *buf)
121 {
122 struct usb_device *udev;
123 char *speed;
124
125 udev = to_usb_device(dev);
126
127 switch (udev->speed) {
128 case USB_SPEED_LOW:
129 speed = "1.5";
130 break;
131 case USB_SPEED_UNKNOWN:
132 case USB_SPEED_FULL:
133 speed = "12";
134 break;
135 case USB_SPEED_HIGH:
136 speed = "480";
137 break;
138 case USB_SPEED_WIRELESS:
139 speed = "480";
140 break;
141 case USB_SPEED_SUPER:
142 speed = "5000";
143 break;
144 default:
145 speed = "unknown";
146 }
147 return sprintf(buf, "%s\n", speed);
148 }
149 static DEVICE_ATTR_RO(speed);
150
busnum_show(struct device * dev,struct device_attribute * attr,char * buf)151 static ssize_t busnum_show(struct device *dev, struct device_attribute *attr,
152 char *buf)
153 {
154 struct usb_device *udev;
155
156 udev = to_usb_device(dev);
157 return sprintf(buf, "%d\n", udev->bus->busnum);
158 }
159 static DEVICE_ATTR_RO(busnum);
160
devnum_show(struct device * dev,struct device_attribute * attr,char * buf)161 static ssize_t devnum_show(struct device *dev, struct device_attribute *attr,
162 char *buf)
163 {
164 struct usb_device *udev;
165
166 udev = to_usb_device(dev);
167 return sprintf(buf, "%d\n", udev->devnum);
168 }
169 static DEVICE_ATTR_RO(devnum);
170
devpath_show(struct device * dev,struct device_attribute * attr,char * buf)171 static ssize_t devpath_show(struct device *dev, struct device_attribute *attr,
172 char *buf)
173 {
174 struct usb_device *udev;
175
176 udev = to_usb_device(dev);
177 return sprintf(buf, "%s\n", udev->devpath);
178 }
179 static DEVICE_ATTR_RO(devpath);
180
version_show(struct device * dev,struct device_attribute * attr,char * buf)181 static ssize_t version_show(struct device *dev, struct device_attribute *attr,
182 char *buf)
183 {
184 struct usb_device *udev;
185 u16 bcdUSB;
186
187 udev = to_usb_device(dev);
188 bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB);
189 return sprintf(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff);
190 }
191 static DEVICE_ATTR_RO(version);
192
maxchild_show(struct device * dev,struct device_attribute * attr,char * buf)193 static ssize_t maxchild_show(struct device *dev, struct device_attribute *attr,
194 char *buf)
195 {
196 struct usb_device *udev;
197
198 udev = to_usb_device(dev);
199 return sprintf(buf, "%d\n", udev->maxchild);
200 }
201 static DEVICE_ATTR_RO(maxchild);
202
quirks_show(struct device * dev,struct device_attribute * attr,char * buf)203 static ssize_t quirks_show(struct device *dev, struct device_attribute *attr,
204 char *buf)
205 {
206 struct usb_device *udev;
207
208 udev = to_usb_device(dev);
209 return sprintf(buf, "0x%x\n", udev->quirks);
210 }
211 static DEVICE_ATTR_RO(quirks);
212
avoid_reset_quirk_show(struct device * dev,struct device_attribute * attr,char * buf)213 static ssize_t avoid_reset_quirk_show(struct device *dev,
214 struct device_attribute *attr, char *buf)
215 {
216 struct usb_device *udev;
217
218 udev = to_usb_device(dev);
219 return sprintf(buf, "%d\n", !!(udev->quirks & USB_QUIRK_RESET));
220 }
221
avoid_reset_quirk_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)222 static ssize_t avoid_reset_quirk_store(struct device *dev,
223 struct device_attribute *attr,
224 const char *buf, size_t count)
225 {
226 struct usb_device *udev = to_usb_device(dev);
227 int val;
228
229 if (sscanf(buf, "%d", &val) != 1 || val < 0 || val > 1)
230 return -EINVAL;
231 usb_lock_device(udev);
232 if (val)
233 udev->quirks |= USB_QUIRK_RESET;
234 else
235 udev->quirks &= ~USB_QUIRK_RESET;
236 usb_unlock_device(udev);
237 return count;
238 }
239 static DEVICE_ATTR_RW(avoid_reset_quirk);
240
urbnum_show(struct device * dev,struct device_attribute * attr,char * buf)241 static ssize_t urbnum_show(struct device *dev, struct device_attribute *attr,
242 char *buf)
243 {
244 struct usb_device *udev;
245
246 udev = to_usb_device(dev);
247 return sprintf(buf, "%d\n", atomic_read(&udev->urbnum));
248 }
249 static DEVICE_ATTR_RO(urbnum);
250
removable_show(struct device * dev,struct device_attribute * attr,char * buf)251 static ssize_t removable_show(struct device *dev, struct device_attribute *attr,
252 char *buf)
253 {
254 struct usb_device *udev;
255 char *state;
256
257 udev = to_usb_device(dev);
258
259 switch (udev->removable) {
260 case USB_DEVICE_REMOVABLE:
261 state = "removable";
262 break;
263 case USB_DEVICE_FIXED:
264 state = "fixed";
265 break;
266 default:
267 state = "unknown";
268 }
269
270 return sprintf(buf, "%s\n", state);
271 }
272 static DEVICE_ATTR_RO(removable);
273
ltm_capable_show(struct device * dev,struct device_attribute * attr,char * buf)274 static ssize_t ltm_capable_show(struct device *dev,
275 struct device_attribute *attr, char *buf)
276 {
277 if (usb_device_supports_ltm(to_usb_device(dev)))
278 return sprintf(buf, "%s\n", "yes");
279 return sprintf(buf, "%s\n", "no");
280 }
281 static DEVICE_ATTR_RO(ltm_capable);
282
283 #ifdef CONFIG_PM
284
persist_show(struct device * dev,struct device_attribute * attr,char * buf)285 static ssize_t persist_show(struct device *dev, struct device_attribute *attr,
286 char *buf)
287 {
288 struct usb_device *udev = to_usb_device(dev);
289
290 return sprintf(buf, "%d\n", udev->persist_enabled);
291 }
292
persist_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)293 static ssize_t persist_store(struct device *dev, struct device_attribute *attr,
294 const char *buf, size_t count)
295 {
296 struct usb_device *udev = to_usb_device(dev);
297 int value;
298
299 /* Hubs are always enabled for USB_PERSIST */
300 if (udev->descriptor.bDeviceClass == USB_CLASS_HUB)
301 return -EPERM;
302
303 if (sscanf(buf, "%d", &value) != 1)
304 return -EINVAL;
305
306 usb_lock_device(udev);
307 udev->persist_enabled = !!value;
308 usb_unlock_device(udev);
309 return count;
310 }
311 static DEVICE_ATTR_RW(persist);
312
add_persist_attributes(struct device * dev)313 static int add_persist_attributes(struct device *dev)
314 {
315 int rc = 0;
316
317 if (is_usb_device(dev)) {
318 struct usb_device *udev = to_usb_device(dev);
319
320 /* Hubs are automatically enabled for USB_PERSIST,
321 * no point in creating the attribute file.
322 */
323 if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
324 rc = sysfs_add_file_to_group(&dev->kobj,
325 &dev_attr_persist.attr,
326 power_group_name);
327 }
328 return rc;
329 }
330
remove_persist_attributes(struct device * dev)331 static void remove_persist_attributes(struct device *dev)
332 {
333 sysfs_remove_file_from_group(&dev->kobj,
334 &dev_attr_persist.attr,
335 power_group_name);
336 }
337
connected_duration_show(struct device * dev,struct device_attribute * attr,char * buf)338 static ssize_t connected_duration_show(struct device *dev,
339 struct device_attribute *attr, char *buf)
340 {
341 struct usb_device *udev = to_usb_device(dev);
342
343 return sprintf(buf, "%u\n",
344 jiffies_to_msecs(jiffies - udev->connect_time));
345 }
346 static DEVICE_ATTR_RO(connected_duration);
347
348 /*
349 * If the device is resumed, the last time the device was suspended has
350 * been pre-subtracted from active_duration. We add the current time to
351 * get the duration that the device was actually active.
352 *
353 * If the device is suspended, the active_duration is up-to-date.
354 */
active_duration_show(struct device * dev,struct device_attribute * attr,char * buf)355 static ssize_t active_duration_show(struct device *dev,
356 struct device_attribute *attr, char *buf)
357 {
358 struct usb_device *udev = to_usb_device(dev);
359 int duration;
360
361 if (udev->state != USB_STATE_SUSPENDED)
362 duration = jiffies_to_msecs(jiffies + udev->active_duration);
363 else
364 duration = jiffies_to_msecs(udev->active_duration);
365 return sprintf(buf, "%u\n", duration);
366 }
367 static DEVICE_ATTR_RO(active_duration);
368
autosuspend_show(struct device * dev,struct device_attribute * attr,char * buf)369 static ssize_t autosuspend_show(struct device *dev,
370 struct device_attribute *attr, char *buf)
371 {
372 return sprintf(buf, "%d\n", dev->power.autosuspend_delay / 1000);
373 }
374
autosuspend_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)375 static ssize_t autosuspend_store(struct device *dev,
376 struct device_attribute *attr, const char *buf,
377 size_t count)
378 {
379 int value;
380
381 if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/1000 ||
382 value <= -INT_MAX/1000)
383 return -EINVAL;
384
385 pm_runtime_set_autosuspend_delay(dev, value * 1000);
386 return count;
387 }
388 static DEVICE_ATTR_RW(autosuspend);
389
390 static const char on_string[] = "on";
391 static const char auto_string[] = "auto";
392
warn_level(void)393 static void warn_level(void)
394 {
395 static int level_warned;
396
397 if (!level_warned) {
398 level_warned = 1;
399 printk(KERN_WARNING "WARNING! power/level is deprecated; "
400 "use power/control instead\n");
401 }
402 }
403
level_show(struct device * dev,struct device_attribute * attr,char * buf)404 static ssize_t level_show(struct device *dev, struct device_attribute *attr,
405 char *buf)
406 {
407 struct usb_device *udev = to_usb_device(dev);
408 const char *p = auto_string;
409
410 warn_level();
411 if (udev->state != USB_STATE_SUSPENDED && !udev->dev.power.runtime_auto)
412 p = on_string;
413 return sprintf(buf, "%s\n", p);
414 }
415
level_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)416 static ssize_t level_store(struct device *dev, struct device_attribute *attr,
417 const char *buf, size_t count)
418 {
419 struct usb_device *udev = to_usb_device(dev);
420 int len = count;
421 char *cp;
422 int rc = count;
423
424 warn_level();
425 cp = memchr(buf, '\n', count);
426 if (cp)
427 len = cp - buf;
428
429 usb_lock_device(udev);
430
431 if (len == sizeof on_string - 1 &&
432 strncmp(buf, on_string, len) == 0)
433 usb_disable_autosuspend(udev);
434
435 else if (len == sizeof auto_string - 1 &&
436 strncmp(buf, auto_string, len) == 0)
437 usb_enable_autosuspend(udev);
438
439 else
440 rc = -EINVAL;
441
442 usb_unlock_device(udev);
443 return rc;
444 }
445 static DEVICE_ATTR_RW(level);
446
usb2_hardware_lpm_show(struct device * dev,struct device_attribute * attr,char * buf)447 static ssize_t usb2_hardware_lpm_show(struct device *dev,
448 struct device_attribute *attr, char *buf)
449 {
450 struct usb_device *udev = to_usb_device(dev);
451 const char *p;
452
453 if (udev->usb2_hw_lpm_allowed == 1)
454 p = "enabled";
455 else
456 p = "disabled";
457
458 return sprintf(buf, "%s\n", p);
459 }
460
usb2_hardware_lpm_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)461 static ssize_t usb2_hardware_lpm_store(struct device *dev,
462 struct device_attribute *attr,
463 const char *buf, size_t count)
464 {
465 struct usb_device *udev = to_usb_device(dev);
466 bool value;
467 int ret;
468
469 usb_lock_device(udev);
470
471 ret = strtobool(buf, &value);
472
473 if (!ret) {
474 udev->usb2_hw_lpm_allowed = value;
475 if (value)
476 ret = usb_enable_usb2_hardware_lpm(udev);
477 else
478 ret = usb_disable_usb2_hardware_lpm(udev);
479 }
480
481 usb_unlock_device(udev);
482
483 if (!ret)
484 return count;
485
486 return ret;
487 }
488 static DEVICE_ATTR_RW(usb2_hardware_lpm);
489
usb2_lpm_l1_timeout_show(struct device * dev,struct device_attribute * attr,char * buf)490 static ssize_t usb2_lpm_l1_timeout_show(struct device *dev,
491 struct device_attribute *attr,
492 char *buf)
493 {
494 struct usb_device *udev = to_usb_device(dev);
495 return sprintf(buf, "%d\n", udev->l1_params.timeout);
496 }
497
usb2_lpm_l1_timeout_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)498 static ssize_t usb2_lpm_l1_timeout_store(struct device *dev,
499 struct device_attribute *attr,
500 const char *buf, size_t count)
501 {
502 struct usb_device *udev = to_usb_device(dev);
503 u16 timeout;
504
505 if (kstrtou16(buf, 0, &timeout))
506 return -EINVAL;
507
508 udev->l1_params.timeout = timeout;
509
510 return count;
511 }
512 static DEVICE_ATTR_RW(usb2_lpm_l1_timeout);
513
usb2_lpm_besl_show(struct device * dev,struct device_attribute * attr,char * buf)514 static ssize_t usb2_lpm_besl_show(struct device *dev,
515 struct device_attribute *attr, char *buf)
516 {
517 struct usb_device *udev = to_usb_device(dev);
518 return sprintf(buf, "%d\n", udev->l1_params.besl);
519 }
520
usb2_lpm_besl_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)521 static ssize_t usb2_lpm_besl_store(struct device *dev,
522 struct device_attribute *attr,
523 const char *buf, size_t count)
524 {
525 struct usb_device *udev = to_usb_device(dev);
526 u8 besl;
527
528 if (kstrtou8(buf, 0, &besl) || besl > 15)
529 return -EINVAL;
530
531 udev->l1_params.besl = besl;
532
533 return count;
534 }
535 static DEVICE_ATTR_RW(usb2_lpm_besl);
536
usb3_hardware_lpm_u1_show(struct device * dev,struct device_attribute * attr,char * buf)537 static ssize_t usb3_hardware_lpm_u1_show(struct device *dev,
538 struct device_attribute *attr, char *buf)
539 {
540 struct usb_device *udev = to_usb_device(dev);
541 const char *p;
542
543 usb_lock_device(udev);
544
545 if (udev->usb3_lpm_u1_enabled)
546 p = "enabled";
547 else
548 p = "disabled";
549
550 usb_unlock_device(udev);
551
552 return sprintf(buf, "%s\n", p);
553 }
554 static DEVICE_ATTR_RO(usb3_hardware_lpm_u1);
555
usb3_hardware_lpm_u2_show(struct device * dev,struct device_attribute * attr,char * buf)556 static ssize_t usb3_hardware_lpm_u2_show(struct device *dev,
557 struct device_attribute *attr, char *buf)
558 {
559 struct usb_device *udev = to_usb_device(dev);
560 const char *p;
561
562 usb_lock_device(udev);
563
564 if (udev->usb3_lpm_u2_enabled)
565 p = "enabled";
566 else
567 p = "disabled";
568
569 usb_unlock_device(udev);
570
571 return sprintf(buf, "%s\n", p);
572 }
573 static DEVICE_ATTR_RO(usb3_hardware_lpm_u2);
574
575 static struct attribute *usb2_hardware_lpm_attr[] = {
576 &dev_attr_usb2_hardware_lpm.attr,
577 &dev_attr_usb2_lpm_l1_timeout.attr,
578 &dev_attr_usb2_lpm_besl.attr,
579 NULL,
580 };
581 static struct attribute_group usb2_hardware_lpm_attr_group = {
582 .name = power_group_name,
583 .attrs = usb2_hardware_lpm_attr,
584 };
585
586 static struct attribute *usb3_hardware_lpm_attr[] = {
587 &dev_attr_usb3_hardware_lpm_u1.attr,
588 &dev_attr_usb3_hardware_lpm_u2.attr,
589 NULL,
590 };
591 static struct attribute_group usb3_hardware_lpm_attr_group = {
592 .name = power_group_name,
593 .attrs = usb3_hardware_lpm_attr,
594 };
595
596 static struct attribute *power_attrs[] = {
597 &dev_attr_autosuspend.attr,
598 &dev_attr_level.attr,
599 &dev_attr_connected_duration.attr,
600 &dev_attr_active_duration.attr,
601 NULL,
602 };
603 static struct attribute_group power_attr_group = {
604 .name = power_group_name,
605 .attrs = power_attrs,
606 };
607
add_power_attributes(struct device * dev)608 static int add_power_attributes(struct device *dev)
609 {
610 int rc = 0;
611
612 if (is_usb_device(dev)) {
613 struct usb_device *udev = to_usb_device(dev);
614 rc = sysfs_merge_group(&dev->kobj, &power_attr_group);
615 if (udev->usb2_hw_lpm_capable == 1)
616 rc = sysfs_merge_group(&dev->kobj,
617 &usb2_hardware_lpm_attr_group);
618 if (udev->speed == USB_SPEED_SUPER &&
619 udev->lpm_capable == 1)
620 rc = sysfs_merge_group(&dev->kobj,
621 &usb3_hardware_lpm_attr_group);
622 }
623
624 return rc;
625 }
626
remove_power_attributes(struct device * dev)627 static void remove_power_attributes(struct device *dev)
628 {
629 sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group);
630 sysfs_unmerge_group(&dev->kobj, &power_attr_group);
631 }
632
633 #else
634
635 #define add_persist_attributes(dev) 0
636 #define remove_persist_attributes(dev) do {} while (0)
637
638 #define add_power_attributes(dev) 0
639 #define remove_power_attributes(dev) do {} while (0)
640
641 #endif /* CONFIG_PM */
642
643
644 /* Descriptor fields */
645 #define usb_descriptor_attr_le16(field, format_string) \
646 static ssize_t \
647 field##_show(struct device *dev, struct device_attribute *attr, \
648 char *buf) \
649 { \
650 struct usb_device *udev; \
651 \
652 udev = to_usb_device(dev); \
653 return sprintf(buf, format_string, \
654 le16_to_cpu(udev->descriptor.field)); \
655 } \
656 static DEVICE_ATTR_RO(field)
657
658 usb_descriptor_attr_le16(idVendor, "%04x\n");
659 usb_descriptor_attr_le16(idProduct, "%04x\n");
660 usb_descriptor_attr_le16(bcdDevice, "%04x\n");
661
662 #define usb_descriptor_attr(field, format_string) \
663 static ssize_t \
664 field##_show(struct device *dev, struct device_attribute *attr, \
665 char *buf) \
666 { \
667 struct usb_device *udev; \
668 \
669 udev = to_usb_device(dev); \
670 return sprintf(buf, format_string, udev->descriptor.field); \
671 } \
672 static DEVICE_ATTR_RO(field)
673
674 usb_descriptor_attr(bDeviceClass, "%02x\n");
675 usb_descriptor_attr(bDeviceSubClass, "%02x\n");
676 usb_descriptor_attr(bDeviceProtocol, "%02x\n");
677 usb_descriptor_attr(bNumConfigurations, "%d\n");
678 usb_descriptor_attr(bMaxPacketSize0, "%d\n");
679
680
681 /* show if the device is authorized (1) or not (0) */
authorized_show(struct device * dev,struct device_attribute * attr,char * buf)682 static ssize_t authorized_show(struct device *dev,
683 struct device_attribute *attr, char *buf)
684 {
685 struct usb_device *usb_dev = to_usb_device(dev);
686 return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized);
687 }
688
689 /*
690 * Authorize a device to be used in the system
691 *
692 * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
693 */
authorized_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t size)694 static ssize_t authorized_store(struct device *dev,
695 struct device_attribute *attr, const char *buf,
696 size_t size)
697 {
698 ssize_t result;
699 struct usb_device *usb_dev = to_usb_device(dev);
700 unsigned val;
701 result = sscanf(buf, "%u\n", &val);
702 if (result != 1)
703 result = -EINVAL;
704 else if (val == 0)
705 result = usb_deauthorize_device(usb_dev);
706 else
707 result = usb_authorize_device(usb_dev);
708 return result < 0 ? result : size;
709 }
710 static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR,
711 authorized_show, authorized_store);
712
713 /* "Safely remove a device" */
remove_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)714 static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
715 const char *buf, size_t count)
716 {
717 struct usb_device *udev = to_usb_device(dev);
718 int rc = 0;
719
720 usb_lock_device(udev);
721 if (udev->state != USB_STATE_NOTATTACHED) {
722
723 /* To avoid races, first unconfigure and then remove */
724 usb_set_configuration(udev, -1);
725 rc = usb_remove_device(udev);
726 }
727 if (rc == 0)
728 rc = count;
729 usb_unlock_device(udev);
730 return rc;
731 }
732 static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store);
733
734
735 static struct attribute *dev_attrs[] = {
736 /* current configuration's attributes */
737 &dev_attr_configuration.attr,
738 &dev_attr_bNumInterfaces.attr,
739 &dev_attr_bConfigurationValue.attr,
740 &dev_attr_bmAttributes.attr,
741 &dev_attr_bMaxPower.attr,
742 /* device attributes */
743 &dev_attr_urbnum.attr,
744 &dev_attr_idVendor.attr,
745 &dev_attr_idProduct.attr,
746 &dev_attr_bcdDevice.attr,
747 &dev_attr_bDeviceClass.attr,
748 &dev_attr_bDeviceSubClass.attr,
749 &dev_attr_bDeviceProtocol.attr,
750 &dev_attr_bNumConfigurations.attr,
751 &dev_attr_bMaxPacketSize0.attr,
752 &dev_attr_speed.attr,
753 &dev_attr_busnum.attr,
754 &dev_attr_devnum.attr,
755 &dev_attr_devpath.attr,
756 &dev_attr_version.attr,
757 &dev_attr_maxchild.attr,
758 &dev_attr_quirks.attr,
759 &dev_attr_avoid_reset_quirk.attr,
760 &dev_attr_authorized.attr,
761 &dev_attr_remove.attr,
762 &dev_attr_removable.attr,
763 &dev_attr_ltm_capable.attr,
764 NULL,
765 };
766 static struct attribute_group dev_attr_grp = {
767 .attrs = dev_attrs,
768 };
769
770 /* When modifying this list, be sure to modify dev_string_attrs_are_visible()
771 * accordingly.
772 */
773 static struct attribute *dev_string_attrs[] = {
774 &dev_attr_manufacturer.attr,
775 &dev_attr_product.attr,
776 &dev_attr_serial.attr,
777 NULL
778 };
779
dev_string_attrs_are_visible(struct kobject * kobj,struct attribute * a,int n)780 static umode_t dev_string_attrs_are_visible(struct kobject *kobj,
781 struct attribute *a, int n)
782 {
783 struct device *dev = container_of(kobj, struct device, kobj);
784 struct usb_device *udev = to_usb_device(dev);
785
786 if (a == &dev_attr_manufacturer.attr) {
787 if (udev->manufacturer == NULL)
788 return 0;
789 } else if (a == &dev_attr_product.attr) {
790 if (udev->product == NULL)
791 return 0;
792 } else if (a == &dev_attr_serial.attr) {
793 if (udev->serial == NULL)
794 return 0;
795 }
796 return a->mode;
797 }
798
799 static struct attribute_group dev_string_attr_grp = {
800 .attrs = dev_string_attrs,
801 .is_visible = dev_string_attrs_are_visible,
802 };
803
804 const struct attribute_group *usb_device_groups[] = {
805 &dev_attr_grp,
806 &dev_string_attr_grp,
807 NULL
808 };
809
810 /* Binary descriptors */
811
812 static ssize_t
read_descriptors(struct file * filp,struct kobject * kobj,struct bin_attribute * attr,char * buf,loff_t off,size_t count)813 read_descriptors(struct file *filp, struct kobject *kobj,
814 struct bin_attribute *attr,
815 char *buf, loff_t off, size_t count)
816 {
817 struct device *dev = container_of(kobj, struct device, kobj);
818 struct usb_device *udev = to_usb_device(dev);
819 size_t nleft = count;
820 size_t srclen, n;
821 int cfgno;
822 void *src;
823
824 /* The binary attribute begins with the device descriptor.
825 * Following that are the raw descriptor entries for all the
826 * configurations (config plus subsidiary descriptors).
827 */
828 usb_lock_device(udev);
829 for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations &&
830 nleft > 0; ++cfgno) {
831 if (cfgno < 0) {
832 src = &udev->descriptor;
833 srclen = sizeof(struct usb_device_descriptor);
834 } else {
835 src = udev->rawdescriptors[cfgno];
836 srclen = __le16_to_cpu(udev->config[cfgno].desc.
837 wTotalLength);
838 }
839 if (off < srclen) {
840 n = min(nleft, srclen - (size_t) off);
841 memcpy(buf, src + off, n);
842 nleft -= n;
843 buf += n;
844 off = 0;
845 } else {
846 off -= srclen;
847 }
848 }
849 usb_unlock_device(udev);
850 return count - nleft;
851 }
852
853 static struct bin_attribute dev_bin_attr_descriptors = {
854 .attr = {.name = "descriptors", .mode = 0444},
855 .read = read_descriptors,
856 .size = 18 + 65535, /* dev descr + max-size raw descriptor */
857 };
858
usb_create_sysfs_dev_files(struct usb_device * udev)859 int usb_create_sysfs_dev_files(struct usb_device *udev)
860 {
861 struct device *dev = &udev->dev;
862 int retval;
863
864 retval = device_create_bin_file(dev, &dev_bin_attr_descriptors);
865 if (retval)
866 goto error;
867
868 retval = add_persist_attributes(dev);
869 if (retval)
870 goto error;
871
872 retval = add_power_attributes(dev);
873 if (retval)
874 goto error;
875 return retval;
876 error:
877 usb_remove_sysfs_dev_files(udev);
878 return retval;
879 }
880
usb_remove_sysfs_dev_files(struct usb_device * udev)881 void usb_remove_sysfs_dev_files(struct usb_device *udev)
882 {
883 struct device *dev = &udev->dev;
884
885 remove_power_attributes(dev);
886 remove_persist_attributes(dev);
887 device_remove_bin_file(dev, &dev_bin_attr_descriptors);
888 }
889
890 /* Interface Association Descriptor fields */
891 #define usb_intf_assoc_attr(field, format_string) \
892 static ssize_t \
893 iad_##field##_show(struct device *dev, struct device_attribute *attr, \
894 char *buf) \
895 { \
896 struct usb_interface *intf = to_usb_interface(dev); \
897 \
898 return sprintf(buf, format_string, \
899 intf->intf_assoc->field); \
900 } \
901 static DEVICE_ATTR_RO(iad_##field)
902
903 usb_intf_assoc_attr(bFirstInterface, "%02x\n");
904 usb_intf_assoc_attr(bInterfaceCount, "%02d\n");
905 usb_intf_assoc_attr(bFunctionClass, "%02x\n");
906 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n");
907 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n");
908
909 /* Interface fields */
910 #define usb_intf_attr(field, format_string) \
911 static ssize_t \
912 field##_show(struct device *dev, struct device_attribute *attr, \
913 char *buf) \
914 { \
915 struct usb_interface *intf = to_usb_interface(dev); \
916 \
917 return sprintf(buf, format_string, \
918 intf->cur_altsetting->desc.field); \
919 } \
920 static DEVICE_ATTR_RO(field)
921
922 usb_intf_attr(bInterfaceNumber, "%02x\n");
923 usb_intf_attr(bAlternateSetting, "%2d\n");
924 usb_intf_attr(bNumEndpoints, "%02x\n");
925 usb_intf_attr(bInterfaceClass, "%02x\n");
926 usb_intf_attr(bInterfaceSubClass, "%02x\n");
927 usb_intf_attr(bInterfaceProtocol, "%02x\n");
928
interface_show(struct device * dev,struct device_attribute * attr,char * buf)929 static ssize_t interface_show(struct device *dev, struct device_attribute *attr,
930 char *buf)
931 {
932 struct usb_interface *intf;
933 char *string;
934
935 intf = to_usb_interface(dev);
936 string = ACCESS_ONCE(intf->cur_altsetting->string);
937 if (!string)
938 return 0;
939 return sprintf(buf, "%s\n", string);
940 }
941 static DEVICE_ATTR_RO(interface);
942
modalias_show(struct device * dev,struct device_attribute * attr,char * buf)943 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
944 char *buf)
945 {
946 struct usb_interface *intf;
947 struct usb_device *udev;
948 struct usb_host_interface *alt;
949
950 intf = to_usb_interface(dev);
951 udev = interface_to_usbdev(intf);
952 alt = ACCESS_ONCE(intf->cur_altsetting);
953
954 return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
955 "ic%02Xisc%02Xip%02Xin%02X\n",
956 le16_to_cpu(udev->descriptor.idVendor),
957 le16_to_cpu(udev->descriptor.idProduct),
958 le16_to_cpu(udev->descriptor.bcdDevice),
959 udev->descriptor.bDeviceClass,
960 udev->descriptor.bDeviceSubClass,
961 udev->descriptor.bDeviceProtocol,
962 alt->desc.bInterfaceClass,
963 alt->desc.bInterfaceSubClass,
964 alt->desc.bInterfaceProtocol,
965 alt->desc.bInterfaceNumber);
966 }
967 static DEVICE_ATTR_RO(modalias);
968
supports_autosuspend_show(struct device * dev,struct device_attribute * attr,char * buf)969 static ssize_t supports_autosuspend_show(struct device *dev,
970 struct device_attribute *attr,
971 char *buf)
972 {
973 int s;
974
975 device_lock(dev);
976 /* Devices will be autosuspended even when an interface isn't claimed */
977 s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend);
978 device_unlock(dev);
979
980 return sprintf(buf, "%u\n", s);
981 }
982 static DEVICE_ATTR_RO(supports_autosuspend);
983
984 /*
985 * interface_authorized_show - show authorization status of an USB interface
986 * 1 is authorized, 0 is deauthorized
987 */
interface_authorized_show(struct device * dev,struct device_attribute * attr,char * buf)988 static ssize_t interface_authorized_show(struct device *dev,
989 struct device_attribute *attr, char *buf)
990 {
991 struct usb_interface *intf = to_usb_interface(dev);
992
993 return sprintf(buf, "%u\n", intf->authorized);
994 }
995
996 /*
997 * interface_authorized_store - authorize or deauthorize an USB interface
998 */
interface_authorized_store(struct device * dev,struct device_attribute * attr,const char * buf,size_t count)999 static ssize_t interface_authorized_store(struct device *dev,
1000 struct device_attribute *attr, const char *buf, size_t count)
1001 {
1002 struct usb_interface *intf = to_usb_interface(dev);
1003 bool val;
1004
1005 if (strtobool(buf, &val) != 0)
1006 return -EINVAL;
1007
1008 if (val)
1009 usb_authorize_interface(intf);
1010 else
1011 usb_deauthorize_interface(intf);
1012
1013 return count;
1014 }
1015 static struct device_attribute dev_attr_interface_authorized =
1016 __ATTR(authorized, S_IRUGO | S_IWUSR,
1017 interface_authorized_show, interface_authorized_store);
1018
1019 static struct attribute *intf_attrs[] = {
1020 &dev_attr_bInterfaceNumber.attr,
1021 &dev_attr_bAlternateSetting.attr,
1022 &dev_attr_bNumEndpoints.attr,
1023 &dev_attr_bInterfaceClass.attr,
1024 &dev_attr_bInterfaceSubClass.attr,
1025 &dev_attr_bInterfaceProtocol.attr,
1026 &dev_attr_modalias.attr,
1027 &dev_attr_supports_autosuspend.attr,
1028 &dev_attr_interface_authorized.attr,
1029 NULL,
1030 };
1031 static struct attribute_group intf_attr_grp = {
1032 .attrs = intf_attrs,
1033 };
1034
1035 static struct attribute *intf_assoc_attrs[] = {
1036 &dev_attr_iad_bFirstInterface.attr,
1037 &dev_attr_iad_bInterfaceCount.attr,
1038 &dev_attr_iad_bFunctionClass.attr,
1039 &dev_attr_iad_bFunctionSubClass.attr,
1040 &dev_attr_iad_bFunctionProtocol.attr,
1041 NULL,
1042 };
1043
intf_assoc_attrs_are_visible(struct kobject * kobj,struct attribute * a,int n)1044 static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj,
1045 struct attribute *a, int n)
1046 {
1047 struct device *dev = container_of(kobj, struct device, kobj);
1048 struct usb_interface *intf = to_usb_interface(dev);
1049
1050 if (intf->intf_assoc == NULL)
1051 return 0;
1052 return a->mode;
1053 }
1054
1055 static struct attribute_group intf_assoc_attr_grp = {
1056 .attrs = intf_assoc_attrs,
1057 .is_visible = intf_assoc_attrs_are_visible,
1058 };
1059
1060 const struct attribute_group *usb_interface_groups[] = {
1061 &intf_attr_grp,
1062 &intf_assoc_attr_grp,
1063 NULL
1064 };
1065
usb_create_sysfs_intf_files(struct usb_interface * intf)1066 void usb_create_sysfs_intf_files(struct usb_interface *intf)
1067 {
1068 struct usb_device *udev = interface_to_usbdev(intf);
1069 struct usb_host_interface *alt = intf->cur_altsetting;
1070
1071 if (intf->sysfs_files_created || intf->unregistering)
1072 return;
1073
1074 if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
1075 alt->string = usb_cache_string(udev, alt->desc.iInterface);
1076 if (alt->string && device_create_file(&intf->dev, &dev_attr_interface))
1077 ; /* We don't actually care if the function fails. */
1078 intf->sysfs_files_created = 1;
1079 }
1080
usb_remove_sysfs_intf_files(struct usb_interface * intf)1081 void usb_remove_sysfs_intf_files(struct usb_interface *intf)
1082 {
1083 if (!intf->sysfs_files_created)
1084 return;
1085
1086 device_remove_file(&intf->dev, &dev_attr_interface);
1087 intf->sysfs_files_created = 0;
1088 }
1089