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