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