drivers/usb/core/sysfs.c

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