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
 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 ssize_t usb3_hardware_lpm_show(struct device *dev,
 535                                       struct device_attribute *attr, char *buf)
 536 {
 537         struct usb_device *udev = to_usb_device(dev);
 538         const char *p;
 539
 540         usb_lock_device(udev);
 541
 542         if (udev->usb3_lpm_enabled)
 543                 p = "enabled";
 544         else
 545                 p = "disabled";
 546
 547         usb_unlock_device(udev);
 548
 549         return sprintf(buf, "%s\n", p);
 550 }
 551 static DEVICE_ATTR_RO(usb3_hardware_lpm);
 552
 553 static struct attribute *usb2_hardware_lpm_attr[] = {
 554         &dev_attr_usb2_hardware_lpm.attr,
 555         &dev_attr_usb2_lpm_l1_timeout.attr,
 556         &dev_attr_usb2_lpm_besl.attr,
 557         NULL,
 558 };
 559 static struct attribute_group usb2_hardware_lpm_attr_group = {
 560         .name   = power_group_name,
 561         .attrs  = usb2_hardware_lpm_attr,
 562 };
 563
 564 static struct attribute *usb3_hardware_lpm_attr[] = {
 565         &dev_attr_usb3_hardware_lpm.attr,
 566         NULL,
 567 };
 568 static struct attribute_group usb3_hardware_lpm_attr_group = {
 569         .name   = power_group_name,
 570         .attrs  = usb3_hardware_lpm_attr,
 571 };
 572
 573 static struct attribute *power_attrs[] = {
 574         &dev_attr_autosuspend.attr,
 575         &dev_attr_level.attr,
 576         &dev_attr_connected_duration.attr,
 577         &dev_attr_active_duration.attr,
 578         NULL,
 579 };
 580 static struct attribute_group power_attr_group = {
 581         .name   = power_group_name,
 582         .attrs  = power_attrs,
 583 };
 584
 585 static int add_power_attributes(struct device *dev)
 586 {
 587         int rc = 0;
 588
 589         if (is_usb_device(dev)) {
 590                 struct usb_device *udev = to_usb_device(dev);
 591                 rc = sysfs_merge_group(&dev->kobj, &power_attr_group);
 592                 if (udev->usb2_hw_lpm_capable == 1)
 593                         rc = sysfs_merge_group(&dev->kobj,
 594                                         &usb2_hardware_lpm_attr_group);
 595                 if (udev->lpm_capable == 1)
 596                         rc = sysfs_merge_group(&dev->kobj,
 597                                         &usb3_hardware_lpm_attr_group);
 598         }
 599
 600         return rc;
 601 }
 602
 603 static void remove_power_attributes(struct device *dev)
 604 {
 605         sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group);
 606         sysfs_unmerge_group(&dev->kobj, &power_attr_group);
 607 }
 608
 609 #else
 610
 611 #define add_persist_attributes(dev)     0
 612 #define remove_persist_attributes(dev)  do {} while (0)
 613
 614 #define add_power_attributes(dev)       0
 615 #define remove_power_attributes(dev)    do {} while (0)
 616
 617 #endif  /* CONFIG_PM */
 618
 619
 620 /* Descriptor fields */
 621 #define usb_descriptor_attr_le16(field, format_string)                  \
 622 static ssize_t                                                          \
 623 field##_show(struct device *dev, struct device_attribute *attr, \
 624                 char *buf)                                              \
 625 {                                                                       \
 626         struct usb_device *udev;                                        \
 627                                                                         \
 628         udev = to_usb_device(dev);                                      \
 629         return sprintf(buf, format_string,                              \
 630                         le16_to_cpu(udev->descriptor.field));           \
 631 }                                                                       \
 632 static DEVICE_ATTR_RO(field)
 633
 634 usb_descriptor_attr_le16(idVendor, "%04x\n");
 635 usb_descriptor_attr_le16(idProduct, "%04x\n");
 636 usb_descriptor_attr_le16(bcdDevice, "%04x\n");
 637
 638 #define usb_descriptor_attr(field, format_string)                       \
 639 static ssize_t                                                          \
 640 field##_show(struct device *dev, struct device_attribute *attr, \
 641                 char *buf)                                              \
 642 {                                                                       \
 643         struct usb_device *udev;                                        \
 644                                                                         \
 645         udev = to_usb_device(dev);                                      \
 646         return sprintf(buf, format_string, udev->descriptor.field);     \
 647 }                                                                       \
 648 static DEVICE_ATTR_RO(field)
 649
 650 usb_descriptor_attr(bDeviceClass, "%02x\n");
 651 usb_descriptor_attr(bDeviceSubClass, "%02x\n");
 652 usb_descriptor_attr(bDeviceProtocol, "%02x\n");
 653 usb_descriptor_attr(bNumConfigurations, "%d\n");
 654 usb_descriptor_attr(bMaxPacketSize0, "%d\n");
 655
 656
 657 /* show if the device is authorized (1) or not (0) */
 658 static ssize_t authorized_show(struct device *dev,
 659                                struct device_attribute *attr, char *buf)
 660 {
 661         struct usb_device *usb_dev = to_usb_device(dev);
 662         return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized);
 663 }
 664
 665 /*
 666  * Authorize a device to be used in the system
 667  *
 668  * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
 669  */
 670 static ssize_t authorized_store(struct device *dev,
 671                                 struct device_attribute *attr, const char *buf,
 672                                 size_t size)
 673 {
 674         ssize_t result;
 675         struct usb_device *usb_dev = to_usb_device(dev);
 676         unsigned val;
 677         result = sscanf(buf, "%u\n", &val);
 678         if (result != 1)
 679                 result = -EINVAL;
 680         else if (val == 0)
 681                 result = usb_deauthorize_device(usb_dev);
 682         else
 683                 result = usb_authorize_device(usb_dev);
 684         return result < 0 ? result : size;
 685 }
 686 static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR,
 687                                   authorized_show, authorized_store);
 688
 689 /* "Safely remove a device" */
 690 static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
 691                             const char *buf, size_t count)
 692 {
 693         struct usb_device *udev = to_usb_device(dev);
 694         int rc = 0;
 695
 696         usb_lock_device(udev);
 697         if (udev->state != USB_STATE_NOTATTACHED) {
 698
 699                 /* To avoid races, first unconfigure and then remove */
 700                 usb_set_configuration(udev, -1);
 701                 rc = usb_remove_device(udev);
 702         }
 703         if (rc == 0)
 704                 rc = count;
 705         usb_unlock_device(udev);
 706         return rc;
 707 }
 708 static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store);
 709
 710
 711 static struct attribute *dev_attrs[] = {
 712         /* current configuration's attributes */
 713         &dev_attr_configuration.attr,
 714         &dev_attr_bNumInterfaces.attr,
 715         &dev_attr_bConfigurationValue.attr,
 716         &dev_attr_bmAttributes.attr,
 717         &dev_attr_bMaxPower.attr,
 718         /* device attributes */
 719         &dev_attr_urbnum.attr,
 720         &dev_attr_idVendor.attr,
 721         &dev_attr_idProduct.attr,
 722         &dev_attr_bcdDevice.attr,
 723         &dev_attr_bDeviceClass.attr,
 724         &dev_attr_bDeviceSubClass.attr,
 725         &dev_attr_bDeviceProtocol.attr,
 726         &dev_attr_bNumConfigurations.attr,
 727         &dev_attr_bMaxPacketSize0.attr,
 728         &dev_attr_speed.attr,
 729         &dev_attr_busnum.attr,
 730         &dev_attr_devnum.attr,
 731         &dev_attr_devpath.attr,
 732         &dev_attr_version.attr,
 733         &dev_attr_maxchild.attr,
 734         &dev_attr_quirks.attr,
 735         &dev_attr_avoid_reset_quirk.attr,
 736         &dev_attr_authorized.attr,
 737         &dev_attr_remove.attr,
 738         &dev_attr_removable.attr,
 739         &dev_attr_ltm_capable.attr,
 740         NULL,
 741 };
 742 static struct attribute_group dev_attr_grp = {
 743         .attrs = dev_attrs,
 744 };
 745
 746 /* When modifying this list, be sure to modify dev_string_attrs_are_visible()
 747  * accordingly.
 748  */
 749 static struct attribute *dev_string_attrs[] = {
 750         &dev_attr_manufacturer.attr,
 751         &dev_attr_product.attr,
 752         &dev_attr_serial.attr,
 753         NULL
 754 };
 755
 756 static umode_t dev_string_attrs_are_visible(struct kobject *kobj,
 757                 struct attribute *a, int n)
 758 {
 759         struct device *dev = container_of(kobj, struct device, kobj);
 760         struct usb_device *udev = to_usb_device(dev);
 761
 762         if (a == &dev_attr_manufacturer.attr) {
 763                 if (udev->manufacturer == NULL)
 764                         return 0;
 765         } else if (a == &dev_attr_product.attr) {
 766                 if (udev->product == NULL)
 767                         return 0;
 768         } else if (a == &dev_attr_serial.attr) {
 769                 if (udev->serial == NULL)
 770                         return 0;
 771         }
 772         return a->mode;
 773 }
 774
 775 static struct attribute_group dev_string_attr_grp = {
 776         .attrs =        dev_string_attrs,
 777         .is_visible =   dev_string_attrs_are_visible,
 778 };
 779
 780 const struct attribute_group *usb_device_groups[] = {
 781         &dev_attr_grp,
 782         &dev_string_attr_grp,
 783         NULL
 784 };
 785
 786 /* Binary descriptors */
 787
 788 static ssize_t
 789 read_descriptors(struct file *filp, struct kobject *kobj,
 790                 struct bin_attribute *attr,
 791                 char *buf, loff_t off, size_t count)
 792 {
 793         struct device *dev = container_of(kobj, struct device, kobj);
 794         struct usb_device *udev = to_usb_device(dev);
 795         size_t nleft = count;
 796         size_t srclen, n;
 797         int cfgno;
 798         void *src;
 799
 800         /* The binary attribute begins with the device descriptor.
 801          * Following that are the raw descriptor entries for all the
 802          * configurations (config plus subsidiary descriptors).
 803          */
 804         usb_lock_device(udev);
 805         for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations &&
 806                         nleft > 0; ++cfgno) {
 807                 if (cfgno < 0) {
 808                         src = &udev->descriptor;
 809                         srclen = sizeof(struct usb_device_descriptor);
 810                 } else {
 811                         src = udev->rawdescriptors[cfgno];
 812                         srclen = __le16_to_cpu(udev->config[cfgno].desc.
 813                                         wTotalLength);
 814                 }
 815                 if (off < srclen) {
 816                         n = min(nleft, srclen - (size_t) off);
 817                         memcpy(buf, src + off, n);
 818                         nleft -= n;
 819                         buf += n;
 820                         off = 0;
 821                 } else {
 822                         off -= srclen;
 823                 }
 824         }
 825         usb_unlock_device(udev);
 826         return count - nleft;
 827 }
 828
 829 static struct bin_attribute dev_bin_attr_descriptors = {
 830         .attr = {.name = "descriptors", .mode = 0444},
 831         .read = read_descriptors,
 832         .size = 18 + 65535,     /* dev descr + max-size raw descriptor */
 833 };
 834
 835 int usb_create_sysfs_dev_files(struct usb_device *udev)
 836 {
 837         struct device *dev = &udev->dev;
 838         int retval;
 839
 840         retval = device_create_bin_file(dev, &dev_bin_attr_descriptors);
 841         if (retval)
 842                 goto error;
 843
 844         retval = add_persist_attributes(dev);
 845         if (retval)
 846                 goto error;
 847
 848         retval = add_power_attributes(dev);
 849         if (retval)
 850                 goto error;
 851         return retval;
 852 error:
 853         usb_remove_sysfs_dev_files(udev);
 854         return retval;
 855 }
 856
 857 void usb_remove_sysfs_dev_files(struct usb_device *udev)
 858 {
 859         struct device *dev = &udev->dev;
 860
 861         remove_power_attributes(dev);
 862         remove_persist_attributes(dev);
 863         device_remove_bin_file(dev, &dev_bin_attr_descriptors);
 864 }
 865
 866 /* Interface Association Descriptor fields */
 867 #define usb_intf_assoc_attr(field, format_string)                       \
 868 static ssize_t                                                          \
 869 iad_##field##_show(struct device *dev, struct device_attribute *attr,   \
 870                 char *buf)                                              \
 871 {                                                                       \
 872         struct usb_interface *intf = to_usb_interface(dev);             \
 873                                                                         \
 874         return sprintf(buf, format_string,                              \
 875                         intf->intf_assoc->field);                       \
 876 }                                                                       \
 877 static DEVICE_ATTR_RO(iad_##field)
 878
 879 usb_intf_assoc_attr(bFirstInterface, "%02x\n");
 880 usb_intf_assoc_attr(bInterfaceCount, "%02d\n");
 881 usb_intf_assoc_attr(bFunctionClass, "%02x\n");
 882 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n");
 883 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n");
 884
 885 /* Interface fields */
 886 #define usb_intf_attr(field, format_string)                             \
 887 static ssize_t                                                          \
 888 field##_show(struct device *dev, struct device_attribute *attr,         \
 889                 char *buf)                                              \
 890 {                                                                       \
 891         struct usb_interface *intf = to_usb_interface(dev);             \
 892                                                                         \
 893         return sprintf(buf, format_string,                              \
 894                         intf->cur_altsetting->desc.field);              \
 895 }                                                                       \
 896 static DEVICE_ATTR_RO(field)
 897
 898 usb_intf_attr(bInterfaceNumber, "%02x\n");
 899 usb_intf_attr(bAlternateSetting, "%2d\n");
 900 usb_intf_attr(bNumEndpoints, "%02x\n");
 901 usb_intf_attr(bInterfaceClass, "%02x\n");
 902 usb_intf_attr(bInterfaceSubClass, "%02x\n");
 903 usb_intf_attr(bInterfaceProtocol, "%02x\n");
 904
 905 static ssize_t interface_show(struct device *dev, struct device_attribute *attr,
 906                               char *buf)
 907 {
 908         struct usb_interface *intf;
 909         char *string;
 910
 911         intf = to_usb_interface(dev);
 912         string = ACCESS_ONCE(intf->cur_altsetting->string);
 913         if (!string)
 914                 return 0;
 915         return sprintf(buf, "%s\n", string);
 916 }
 917 static DEVICE_ATTR_RO(interface);
 918
 919 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
 920                              char *buf)
 921 {
 922         struct usb_interface *intf;
 923         struct usb_device *udev;
 924         struct usb_host_interface *alt;
 925
 926         intf = to_usb_interface(dev);
 927         udev = interface_to_usbdev(intf);
 928         alt = ACCESS_ONCE(intf->cur_altsetting);
 929
 930         return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
 931                         "ic%02Xisc%02Xip%02Xin%02X\n",
 932                         le16_to_cpu(udev->descriptor.idVendor),
 933                         le16_to_cpu(udev->descriptor.idProduct),
 934                         le16_to_cpu(udev->descriptor.bcdDevice),
 935                         udev->descriptor.bDeviceClass,
 936                         udev->descriptor.bDeviceSubClass,
 937                         udev->descriptor.bDeviceProtocol,
 938                         alt->desc.bInterfaceClass,
 939                         alt->desc.bInterfaceSubClass,
 940                         alt->desc.bInterfaceProtocol,
 941                         alt->desc.bInterfaceNumber);
 942 }
 943 static DEVICE_ATTR_RO(modalias);
 944
 945 static ssize_t supports_autosuspend_show(struct device *dev,
 946                                          struct device_attribute *attr,
 947                                          char *buf)
 948 {
 949         int s;
 950
 951         device_lock(dev);
 952         /* Devices will be autosuspended even when an interface isn't claimed */
 953         s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend);
 954         device_unlock(dev);
 955
 956         return sprintf(buf, "%u\n", s);
 957 }
 958 static DEVICE_ATTR_RO(supports_autosuspend);
 959
 960 /*
 961  * interface_authorized_show - show authorization status of an USB interface
 962  * 1 is authorized, 0 is deauthorized
 963  */
 964 static ssize_t interface_authorized_show(struct device *dev,
 965                 struct device_attribute *attr, char *buf)
 966 {
 967         struct usb_interface *intf = to_usb_interface(dev);
 968
 969         return sprintf(buf, "%u\n", intf->authorized);
 970 }
 971
 972 /*
 973  * interface_authorized_store - authorize or deauthorize an USB interface
 974  */
 975 static ssize_t interface_authorized_store(struct device *dev,
 976                 struct device_attribute *attr, const char *buf, size_t count)
 977 {
 978         struct usb_interface *intf = to_usb_interface(dev);
 979         bool val;
 980
 981         if (strtobool(buf, &val) != 0)
 982                 return -EINVAL;
 983
 984         if (val)
 985                 usb_authorize_interface(intf);
 986         else
 987                 usb_deauthorize_interface(intf);
 988
 989         return count;
 990 }
 991 static struct device_attribute dev_attr_interface_authorized =
 992                 __ATTR(authorized, S_IRUGO | S_IWUSR,
 993                 interface_authorized_show, interface_authorized_store);
 994
 995 static struct attribute *intf_attrs[] = {
 996         &dev_attr_bInterfaceNumber.attr,
 997         &dev_attr_bAlternateSetting.attr,
 998         &dev_attr_bNumEndpoints.attr,
 999         &dev_attr_bInterfaceClass.attr,
1000         &dev_attr_bInterfaceSubClass.attr,
1001         &dev_attr_bInterfaceProtocol.attr,
1002         &dev_attr_modalias.attr,
1003         &dev_attr_supports_autosuspend.attr,
1004         &dev_attr_interface_authorized.attr,
1005         NULL,
1006 };
1007 static struct attribute_group intf_attr_grp = {
1008         .attrs = intf_attrs,
1009 };
1010
1011 static struct attribute *intf_assoc_attrs[] = {
1012         &dev_attr_iad_bFirstInterface.attr,
1013         &dev_attr_iad_bInterfaceCount.attr,
1014         &dev_attr_iad_bFunctionClass.attr,
1015         &dev_attr_iad_bFunctionSubClass.attr,
1016         &dev_attr_iad_bFunctionProtocol.attr,
1017         NULL,
1018 };
1019
1020 static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj,
1021                 struct attribute *a, int n)
1022 {
1023         struct device *dev = container_of(kobj, struct device, kobj);
1024         struct usb_interface *intf = to_usb_interface(dev);
1025
1026         if (intf->intf_assoc == NULL)
1027                 return 0;
1028         return a->mode;
1029 }
1030
1031 static struct attribute_group intf_assoc_attr_grp = {
1032         .attrs =        intf_assoc_attrs,
1033         .is_visible =   intf_assoc_attrs_are_visible,
1034 };
1035
1036 const struct attribute_group *usb_interface_groups[] = {
1037         &intf_attr_grp,
1038         &intf_assoc_attr_grp,
1039         NULL
1040 };
1041
1042 void usb_create_sysfs_intf_files(struct usb_interface *intf)
1043 {
1044         struct usb_device *udev = interface_to_usbdev(intf);
1045         struct usb_host_interface *alt = intf->cur_altsetting;
1046
1047         if (intf->sysfs_files_created || intf->unregistering)
1048                 return;
1049
1050         if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
1051                 alt->string = usb_cache_string(udev, alt->desc.iInterface);
1052         if (alt->string && device_create_file(&intf->dev, &dev_attr_interface))
1053                 ;       /* We don't actually care if the function fails. */
1054         intf->sysfs_files_created = 1;
1055 }
1056
1057 void usb_remove_sysfs_intf_files(struct usb_interface *intf)
1058 {
1059         if (!intf->sysfs_files_created)
1060                 return;
1061
1062         device_remove_file(&intf->dev, &dev_attr_interface);
1063         intf->sysfs_files_created = 0;
1064 }