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