drivers/usb/core/sysfs.c

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