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_unchecked(&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
 338 static ssize_t connected_duration_show(struct device *dev,
 339                                        struct device_attribute *attr, char *buf)
 340 {
 341         struct usb_device *udev = to_usb_device(dev);
 342
 343         return sprintf(buf, "%u\n",
 344                         jiffies_to_msecs(jiffies - udev->connect_time));
 345 }
 346 static DEVICE_ATTR_RO(connected_duration);
 347
 348 /*
 349  * If the device is resumed, the last time the device was suspended has
 350  * been pre-subtracted from active_duration.  We add the current time to
 351  * get the duration that the device was actually active.
 352  *
 353  * If the device is suspended, the active_duration is up-to-date.
 354  */
 355 static ssize_t active_duration_show(struct device *dev,
 356                                     struct device_attribute *attr, char *buf)
 357 {
 358         struct usb_device *udev = to_usb_device(dev);
 359         int duration;
 360
 361         if (udev->state != USB_STATE_SUSPENDED)
 362                 duration = jiffies_to_msecs(jiffies + udev->active_duration);
 363         else
 364                 duration = jiffies_to_msecs(udev->active_duration);
 365         return sprintf(buf, "%u\n", duration);
 366 }
 367 static DEVICE_ATTR_RO(active_duration);
 368
 369 static ssize_t autosuspend_show(struct device *dev,
 370                                 struct device_attribute *attr, char *buf)
 371 {
 372         return sprintf(buf, "%d\n", dev->power.autosuspend_delay / 1000);
 373 }
 374
 375 static ssize_t autosuspend_store(struct device *dev,
 376                                  struct device_attribute *attr, const char *buf,
 377                                  size_t count)
 378 {
 379         int value;
 380
 381         if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/1000 ||
 382                         value <= -INT_MAX/1000)
 383                 return -EINVAL;
 384
 385         pm_runtime_set_autosuspend_delay(dev, value * 1000);
 386         return count;
 387 }
 388 static DEVICE_ATTR_RW(autosuspend);
 389
 390 static const char on_string[] = "on";
 391 static const char auto_string[] = "auto";
 392
 393 static void warn_level(void)
 394 {
 395         static int level_warned;
 396
 397         if (!level_warned) {
 398                 level_warned = 1;
 399                 printk(KERN_WARNING "WARNING! power/level is deprecated; "
 400                                 "use power/control instead\n");
 401         }
 402 }
 403
 404 static ssize_t level_show(struct device *dev, struct device_attribute *attr,
 405                           char *buf)
 406 {
 407         struct usb_device *udev = to_usb_device(dev);
 408         const char *p = auto_string;
 409
 410         warn_level();
 411         if (udev->state != USB_STATE_SUSPENDED && !udev->dev.power.runtime_auto)
 412                 p = on_string;
 413         return sprintf(buf, "%s\n", p);
 414 }
 415
 416 static ssize_t level_store(struct device *dev, struct device_attribute *attr,
 417                            const char *buf, size_t count)
 418 {
 419         struct usb_device *udev = to_usb_device(dev);
 420         int len = count;
 421         char *cp;
 422         int rc = count;
 423
 424         warn_level();
 425         cp = memchr(buf, '\n', count);
 426         if (cp)
 427                 len = cp - buf;
 428
 429         usb_lock_device(udev);
 430
 431         if (len == sizeof on_string - 1 &&
 432                         strncmp(buf, on_string, len) == 0)
 433                 usb_disable_autosuspend(udev);
 434
 435         else if (len == sizeof auto_string - 1 &&
 436                         strncmp(buf, auto_string, len) == 0)
 437                 usb_enable_autosuspend(udev);
 438
 439         else
 440                 rc = -EINVAL;
 441
 442         usb_unlock_device(udev);
 443         return rc;
 444 }
 445 static DEVICE_ATTR_RW(level);
 446
 447 static ssize_t usb2_hardware_lpm_show(struct device *dev,
 448                                       struct device_attribute *attr, char *buf)
 449 {
 450         struct usb_device *udev = to_usb_device(dev);
 451         const char *p;
 452
 453         if (udev->usb2_hw_lpm_allowed == 1)
 454                 p = "enabled";
 455         else
 456                 p = "disabled";
 457
 458         return sprintf(buf, "%s\n", p);
 459 }
 460
 461 static ssize_t usb2_hardware_lpm_store(struct device *dev,
 462                                        struct device_attribute *attr,
 463                                        const char *buf, size_t count)
 464 {
 465         struct usb_device *udev = to_usb_device(dev);
 466         bool value;
 467         int ret;
 468
 469         usb_lock_device(udev);
 470
 471         ret = strtobool(buf, &value);
 472
 473         if (!ret) {
 474                 udev->usb2_hw_lpm_allowed = value;
 475                 ret = usb_set_usb2_hardware_lpm(udev, value);
 476         }
 477
 478         usb_unlock_device(udev);
 479
 480         if (!ret)
 481                 return count;
 482
 483         return ret;
 484 }
 485 static DEVICE_ATTR_RW(usb2_hardware_lpm);
 486
 487 static ssize_t usb2_lpm_l1_timeout_show(struct device *dev,
 488                                         struct device_attribute *attr,
 489                                         char *buf)
 490 {
 491         struct usb_device *udev = to_usb_device(dev);
 492         return sprintf(buf, "%d\n", udev->l1_params.timeout);
 493 }
 494
 495 static ssize_t usb2_lpm_l1_timeout_store(struct device *dev,
 496                                          struct device_attribute *attr,
 497                                          const char *buf, size_t count)
 498 {
 499         struct usb_device *udev = to_usb_device(dev);
 500         u16 timeout;
 501
 502         if (kstrtou16(buf, 0, &timeout))
 503                 return -EINVAL;
 504
 505         udev->l1_params.timeout = timeout;
 506
 507         return count;
 508 }
 509 static DEVICE_ATTR_RW(usb2_lpm_l1_timeout);
 510
 511 static ssize_t usb2_lpm_besl_show(struct device *dev,
 512                                   struct device_attribute *attr, char *buf)
 513 {
 514         struct usb_device *udev = to_usb_device(dev);
 515         return sprintf(buf, "%d\n", udev->l1_params.besl);
 516 }
 517
 518 static ssize_t usb2_lpm_besl_store(struct device *dev,
 519                                    struct device_attribute *attr,
 520                                    const char *buf, size_t count)
 521 {
 522         struct usb_device *udev = to_usb_device(dev);
 523         u8 besl;
 524
 525         if (kstrtou8(buf, 0, &besl) || besl > 15)
 526                 return -EINVAL;
 527
 528         udev->l1_params.besl = besl;
 529
 530         return count;
 531 }
 532 static DEVICE_ATTR_RW(usb2_lpm_besl);
 533
 534 static struct attribute *usb2_hardware_lpm_attr[] = {
 535         &dev_attr_usb2_hardware_lpm.attr,
 536         &dev_attr_usb2_lpm_l1_timeout.attr,
 537         &dev_attr_usb2_lpm_besl.attr,
 538         NULL,
 539 };
 540 static struct attribute_group usb2_hardware_lpm_attr_group = {
 541         .name   = power_group_name,
 542         .attrs  = usb2_hardware_lpm_attr,
 543 };
 544
 545 static struct attribute *power_attrs[] = {
 546         &dev_attr_autosuspend.attr,
 547         &dev_attr_level.attr,
 548         &dev_attr_connected_duration.attr,
 549         &dev_attr_active_duration.attr,
 550         NULL,
 551 };
 552 static struct attribute_group power_attr_group = {
 553         .name   = power_group_name,
 554         .attrs  = power_attrs,
 555 };
 556
 557 static int add_power_attributes(struct device *dev)
 558 {
 559         int rc = 0;
 560
 561         if (is_usb_device(dev)) {
 562                 struct usb_device *udev = to_usb_device(dev);
 563                 rc = sysfs_merge_group(&dev->kobj, &power_attr_group);
 564                 if (udev->usb2_hw_lpm_capable == 1)
 565                         rc = sysfs_merge_group(&dev->kobj,
 566                                         &usb2_hardware_lpm_attr_group);
 567         }
 568
 569         return rc;
 570 }
 571
 572 static void remove_power_attributes(struct device *dev)
 573 {
 574         sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group);
 575         sysfs_unmerge_group(&dev->kobj, &power_attr_group);
 576 }
 577
 578 #else
 579
 580 #define add_persist_attributes(dev)     0
 581 #define remove_persist_attributes(dev)  do {} while (0)
 582
 583 #define add_power_attributes(dev)       0
 584 #define remove_power_attributes(dev)    do {} while (0)
 585
 586 #endif  /* CONFIG_PM */
 587
 588
 589 /* Descriptor fields */
 590 #define usb_descriptor_attr_le16(field, format_string)                  \
 591 static ssize_t                                                          \
 592 field##_show(struct device *dev, struct device_attribute *attr, \
 593                 char *buf)                                              \
 594 {                                                                       \
 595         struct usb_device *udev;                                        \
 596                                                                         \
 597         udev = to_usb_device(dev);                                      \
 598         return sprintf(buf, format_string,                              \
 599                         le16_to_cpu(udev->descriptor.field));           \
 600 }                                                                       \
 601 static DEVICE_ATTR_RO(field)
 602
 603 usb_descriptor_attr_le16(idVendor, "%04x\n");
 604 usb_descriptor_attr_le16(idProduct, "%04x\n");
 605 usb_descriptor_attr_le16(bcdDevice, "%04x\n");
 606
 607 #define usb_descriptor_attr(field, format_string)                       \
 608 static ssize_t                                                          \
 609 field##_show(struct device *dev, struct device_attribute *attr, \
 610                 char *buf)                                              \
 611 {                                                                       \
 612         struct usb_device *udev;                                        \
 613                                                                         \
 614         udev = to_usb_device(dev);                                      \
 615         return sprintf(buf, format_string, udev->descriptor.field);     \
 616 }                                                                       \
 617 static DEVICE_ATTR_RO(field)
 618
 619 usb_descriptor_attr(bDeviceClass, "%02x\n");
 620 usb_descriptor_attr(bDeviceSubClass, "%02x\n");
 621 usb_descriptor_attr(bDeviceProtocol, "%02x\n");
 622 usb_descriptor_attr(bNumConfigurations, "%d\n");
 623 usb_descriptor_attr(bMaxPacketSize0, "%d\n");
 624
 625
 626 /* show if the device is authorized (1) or not (0) */
 627 static ssize_t authorized_show(struct device *dev,
 628                                struct device_attribute *attr, char *buf)
 629 {
 630         struct usb_device *usb_dev = to_usb_device(dev);
 631         return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized);
 632 }
 633
 634 /*
 635  * Authorize a device to be used in the system
 636  *
 637  * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
 638  */
 639 static ssize_t authorized_store(struct device *dev,
 640                                 struct device_attribute *attr, const char *buf,
 641                                 size_t size)
 642 {
 643         ssize_t result;
 644         struct usb_device *usb_dev = to_usb_device(dev);
 645         unsigned val;
 646         result = sscanf(buf, "%u\n", &val);
 647         if (result != 1)
 648                 result = -EINVAL;
 649         else if (val == 0)
 650                 result = usb_deauthorize_device(usb_dev);
 651         else
 652                 result = usb_authorize_device(usb_dev);
 653         return result < 0 ? result : size;
 654 }
 655 static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR,
 656                                   authorized_show, authorized_store);
 657
 658 /* "Safely remove a device" */
 659 static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
 660                             const char *buf, size_t count)
 661 {
 662         struct usb_device *udev = to_usb_device(dev);
 663         int rc = 0;
 664
 665         usb_lock_device(udev);
 666         if (udev->state != USB_STATE_NOTATTACHED) {
 667
 668                 /* To avoid races, first unconfigure and then remove */
 669                 usb_set_configuration(udev, -1);
 670                 rc = usb_remove_device(udev);
 671         }
 672         if (rc == 0)
 673                 rc = count;
 674         usb_unlock_device(udev);
 675         return rc;
 676 }
 677 static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store);
 678
 679
 680 static struct attribute *dev_attrs[] = {
 681         /* current configuration's attributes */
 682         &dev_attr_configuration.attr,
 683         &dev_attr_bNumInterfaces.attr,
 684         &dev_attr_bConfigurationValue.attr,
 685         &dev_attr_bmAttributes.attr,
 686         &dev_attr_bMaxPower.attr,
 687         /* device attributes */
 688         &dev_attr_urbnum.attr,
 689         &dev_attr_idVendor.attr,
 690         &dev_attr_idProduct.attr,
 691         &dev_attr_bcdDevice.attr,
 692         &dev_attr_bDeviceClass.attr,
 693         &dev_attr_bDeviceSubClass.attr,
 694         &dev_attr_bDeviceProtocol.attr,
 695         &dev_attr_bNumConfigurations.attr,
 696         &dev_attr_bMaxPacketSize0.attr,
 697         &dev_attr_speed.attr,
 698         &dev_attr_busnum.attr,
 699         &dev_attr_devnum.attr,
 700         &dev_attr_devpath.attr,
 701         &dev_attr_version.attr,
 702         &dev_attr_maxchild.attr,
 703         &dev_attr_quirks.attr,
 704         &dev_attr_avoid_reset_quirk.attr,
 705         &dev_attr_authorized.attr,
 706         &dev_attr_remove.attr,
 707         &dev_attr_removable.attr,
 708         &dev_attr_ltm_capable.attr,
 709         NULL,
 710 };
 711 static struct attribute_group dev_attr_grp = {
 712         .attrs = dev_attrs,
 713 };
 714
 715 /* When modifying this list, be sure to modify dev_string_attrs_are_visible()
 716  * accordingly.
 717  */
 718 static struct attribute *dev_string_attrs[] = {
 719         &dev_attr_manufacturer.attr,
 720         &dev_attr_product.attr,
 721         &dev_attr_serial.attr,
 722         NULL
 723 };
 724
 725 static umode_t dev_string_attrs_are_visible(struct kobject *kobj,
 726                 struct attribute *a, int n)
 727 {
 728         struct device *dev = container_of(kobj, struct device, kobj);
 729         struct usb_device *udev = to_usb_device(dev);
 730
 731         if (a == &dev_attr_manufacturer.attr) {
 732                 if (udev->manufacturer == NULL)
 733                         return 0;
 734         } else if (a == &dev_attr_product.attr) {
 735                 if (udev->product == NULL)
 736                         return 0;
 737         } else if (a == &dev_attr_serial.attr) {
 738                 if (udev->serial == NULL)
 739                         return 0;
 740         }
 741         return a->mode;
 742 }
 743
 744 static struct attribute_group dev_string_attr_grp = {
 745         .attrs =        dev_string_attrs,
 746         .is_visible =   dev_string_attrs_are_visible,
 747 };
 748
 749 const struct attribute_group *usb_device_groups[] = {
 750         &dev_attr_grp,
 751         &dev_string_attr_grp,
 752         NULL
 753 };
 754
 755 /* Binary descriptors */
 756
 757 static ssize_t
 758 read_descriptors(struct file *filp, struct kobject *kobj,
 759                 struct bin_attribute *attr,
 760                 char *buf, loff_t off, size_t count)
 761 {
 762         struct device *dev = container_of(kobj, struct device, kobj);
 763         struct usb_device *udev = to_usb_device(dev);
 764         size_t nleft = count;
 765         size_t srclen, n;
 766         int cfgno;
 767         void *src;
 768
 769         /* The binary attribute begins with the device descriptor.
 770          * Following that are the raw descriptor entries for all the
 771          * configurations (config plus subsidiary descriptors).
 772          */
 773         usb_lock_device(udev);
 774         for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations &&
 775                         nleft > 0; ++cfgno) {
 776                 if (cfgno < 0) {
 777                         src = &udev->descriptor;
 778                         srclen = sizeof(struct usb_device_descriptor);
 779                 } else {
 780                         src = udev->rawdescriptors[cfgno];
 781                         srclen = __le16_to_cpu(udev->config[cfgno].desc.
 782                                         wTotalLength);
 783                 }
 784                 if (off < srclen) {
 785                         n = min(nleft, srclen - (size_t) off);
 786                         memcpy(buf, src + off, n);
 787                         nleft -= n;
 788                         buf += n;
 789                         off = 0;
 790                 } else {
 791                         off -= srclen;
 792                 }
 793         }
 794         usb_unlock_device(udev);
 795         return count - nleft;
 796 }
 797
 798 static struct bin_attribute dev_bin_attr_descriptors = {
 799         .attr = {.name = "descriptors", .mode = 0444},
 800         .read = read_descriptors,
 801         .size = 18 + 65535,     /* dev descr + max-size raw descriptor */
 802 };
 803
 804 int usb_create_sysfs_dev_files(struct usb_device *udev)
 805 {
 806         struct device *dev = &udev->dev;
 807         int retval;
 808
 809         retval = device_create_bin_file(dev, &dev_bin_attr_descriptors);
 810         if (retval)
 811                 goto error;
 812
 813         retval = add_persist_attributes(dev);
 814         if (retval)
 815                 goto error;
 816
 817         retval = add_power_attributes(dev);
 818         if (retval)
 819                 goto error;
 820         return retval;
 821 error:
 822         usb_remove_sysfs_dev_files(udev);
 823         return retval;
 824 }
 825
 826 void usb_remove_sysfs_dev_files(struct usb_device *udev)
 827 {
 828         struct device *dev = &udev->dev;
 829
 830         remove_power_attributes(dev);
 831         remove_persist_attributes(dev);
 832         device_remove_bin_file(dev, &dev_bin_attr_descriptors);
 833 }
 834
 835 /* Interface Association Descriptor fields */
 836 #define usb_intf_assoc_attr(field, format_string)                       \
 837 static ssize_t                                                          \
 838 iad_##field##_show(struct device *dev, struct device_attribute *attr,   \
 839                 char *buf)                                              \
 840 {                                                                       \
 841         struct usb_interface *intf = to_usb_interface(dev);             \
 842                                                                         \
 843         return sprintf(buf, format_string,                              \
 844                         intf->intf_assoc->field);                       \
 845 }                                                                       \
 846 static DEVICE_ATTR_RO(iad_##field)
 847
 848 usb_intf_assoc_attr(bFirstInterface, "%02x\n");
 849 usb_intf_assoc_attr(bInterfaceCount, "%02d\n");
 850 usb_intf_assoc_attr(bFunctionClass, "%02x\n");
 851 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n");
 852 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n");
 853
 854 /* Interface fields */
 855 #define usb_intf_attr(field, format_string)                             \
 856 static ssize_t                                                          \
 857 field##_show(struct device *dev, struct device_attribute *attr,         \
 858                 char *buf)                                              \
 859 {                                                                       \
 860         struct usb_interface *intf = to_usb_interface(dev);             \
 861                                                                         \
 862         return sprintf(buf, format_string,                              \
 863                         intf->cur_altsetting->desc.field);              \
 864 }                                                                       \
 865 static DEVICE_ATTR_RO(field)
 866
 867 usb_intf_attr(bInterfaceNumber, "%02x\n");
 868 usb_intf_attr(bAlternateSetting, "%2d\n");
 869 usb_intf_attr(bNumEndpoints, "%02x\n");
 870 usb_intf_attr(bInterfaceClass, "%02x\n");
 871 usb_intf_attr(bInterfaceSubClass, "%02x\n");
 872 usb_intf_attr(bInterfaceProtocol, "%02x\n");
 873
 874 static ssize_t interface_show(struct device *dev, struct device_attribute *attr,
 875                               char *buf)
 876 {
 877         struct usb_interface *intf;
 878         char *string;
 879
 880         intf = to_usb_interface(dev);
 881         string = ACCESS_ONCE(intf->cur_altsetting->string);
 882         if (!string)
 883                 return 0;
 884         return sprintf(buf, "%s\n", string);
 885 }
 886 static DEVICE_ATTR_RO(interface);
 887
 888 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
 889                              char *buf)
 890 {
 891         struct usb_interface *intf;
 892         struct usb_device *udev;
 893         struct usb_host_interface *alt;
 894
 895         intf = to_usb_interface(dev);
 896         udev = interface_to_usbdev(intf);
 897         alt = ACCESS_ONCE(intf->cur_altsetting);
 898
 899         return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
 900                         "ic%02Xisc%02Xip%02Xin%02X\n",
 901                         le16_to_cpu(udev->descriptor.idVendor),
 902                         le16_to_cpu(udev->descriptor.idProduct),
 903                         le16_to_cpu(udev->descriptor.bcdDevice),
 904                         udev->descriptor.bDeviceClass,
 905                         udev->descriptor.bDeviceSubClass,
 906                         udev->descriptor.bDeviceProtocol,
 907                         alt->desc.bInterfaceClass,
 908                         alt->desc.bInterfaceSubClass,
 909                         alt->desc.bInterfaceProtocol,
 910                         alt->desc.bInterfaceNumber);
 911 }
 912 static DEVICE_ATTR_RO(modalias);
 913
 914 static ssize_t supports_autosuspend_show(struct device *dev,
 915                                          struct device_attribute *attr,
 916                                          char *buf)
 917 {
 918         int s;
 919
 920         device_lock(dev);
 921         /* Devices will be autosuspended even when an interface isn't claimed */
 922         s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend);
 923         device_unlock(dev);
 924
 925         return sprintf(buf, "%u\n", s);
 926 }
 927 static DEVICE_ATTR_RO(supports_autosuspend);
 928
 929 static struct attribute *intf_attrs[] = {
 930         &dev_attr_bInterfaceNumber.attr,
 931         &dev_attr_bAlternateSetting.attr,
 932         &dev_attr_bNumEndpoints.attr,
 933         &dev_attr_bInterfaceClass.attr,
 934         &dev_attr_bInterfaceSubClass.attr,
 935         &dev_attr_bInterfaceProtocol.attr,
 936         &dev_attr_modalias.attr,
 937         &dev_attr_supports_autosuspend.attr,
 938         NULL,
 939 };
 940 static struct attribute_group intf_attr_grp = {
 941         .attrs = intf_attrs,
 942 };
 943
 944 static struct attribute *intf_assoc_attrs[] = {
 945         &dev_attr_iad_bFirstInterface.attr,
 946         &dev_attr_iad_bInterfaceCount.attr,
 947         &dev_attr_iad_bFunctionClass.attr,
 948         &dev_attr_iad_bFunctionSubClass.attr,
 949         &dev_attr_iad_bFunctionProtocol.attr,
 950         NULL,
 951 };
 952
 953 static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj,
 954                 struct attribute *a, int n)
 955 {
 956         struct device *dev = container_of(kobj, struct device, kobj);
 957         struct usb_interface *intf = to_usb_interface(dev);
 958
 959         if (intf->intf_assoc == NULL)
 960                 return 0;
 961         return a->mode;
 962 }
 963
 964 static struct attribute_group intf_assoc_attr_grp = {
 965         .attrs =        intf_assoc_attrs,
 966         .is_visible =   intf_assoc_attrs_are_visible,
 967 };
 968
 969 const struct attribute_group *usb_interface_groups[] = {
 970         &intf_attr_grp,
 971         &intf_assoc_attr_grp,
 972         NULL
 973 };
 974
 975 void usb_create_sysfs_intf_files(struct usb_interface *intf)
 976 {
 977         struct usb_device *udev = interface_to_usbdev(intf);
 978         struct usb_host_interface *alt = intf->cur_altsetting;
 979
 980         if (intf->sysfs_files_created || intf->unregistering)
 981                 return;
 982
 983         if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
 984                 alt->string = usb_cache_string(udev, alt->desc.iInterface);
 985         if (alt->string && device_create_file(&intf->dev, &dev_attr_interface))
 986                 ;       /* We don't actually care if the function fails. */
 987         intf->sysfs_files_created = 1;
 988 }
 989
 990 void usb_remove_sysfs_intf_files(struct usb_interface *intf)
 991 {
 992         if (!intf->sysfs_files_created)
 993                 return;
 994
 995         device_remove_file(&intf->dev, &dev_attr_interface);
 996         intf->sysfs_files_created = 0;
 997 }