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