drivers/usb/core/sysfs.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * drivers/usb/core/sysfs.c
   4  *
   5  * (C) Copyright 2002 David Brownell
   6  * (C) Copyright 2002,2004 Greg Kroah-Hartman
   7  * (C) Copyright 2002,2004 IBM Corp.
   8  *
   9  * All of the sysfs file attributes for usb devices and interfaces.
  10  *
  11  * Released under the GPLv2 only.
  12  */
  13
  14
  15 #include <linux/kernel.h>
  16 #include <linux/kstrtox.h>
  17 #include <linux/string.h>
  18 #include <linux/usb.h>
  19 #include <linux/usb/hcd.h>
  20 #include <linux/usb/quirks.h>
  21 #include <linux/of.h>
  22 #include "usb.h"
  23
  24 /* Active configuration fields */
  25 #define usb_actconfig_show(field, format_string)                        \
  26 static ssize_t field##_show(struct device *dev,                         \
  27                             struct device_attribute *attr, char *buf)   \
  28 {                                                                       \
  29         struct usb_device *udev;                                        \
  30         struct usb_host_config *actconfig;                              \
  31         ssize_t rc;                                                     \
  32                                                                         \
  33         udev = to_usb_device(dev);                                      \
  34         rc = usb_lock_device_interruptible(udev);                       \
  35         if (rc < 0)                                                     \
  36                 return -EINTR;                                          \
  37         actconfig = udev->actconfig;                                    \
  38         if (actconfig)                                                  \
  39                 rc = sysfs_emit(buf, format_string,                     \
  40                                 actconfig->desc.field);                 \
  41         usb_unlock_device(udev);                                        \
  42         return rc;                                                      \
  43 }                                                                       \
  44
  45 #define usb_actconfig_attr(field, format_string)                \
  46         usb_actconfig_show(field, format_string)                \
  47         static DEVICE_ATTR_RO(field)
  48
  49 usb_actconfig_attr(bNumInterfaces, "%2d\n");
  50 usb_actconfig_attr(bmAttributes, "%2x\n");
  51
  52 static ssize_t bMaxPower_show(struct device *dev,
  53                 struct device_attribute *attr, char *buf)
  54 {
  55         struct usb_device *udev;
  56         struct usb_host_config *actconfig;
  57         ssize_t rc;
  58
  59         udev = to_usb_device(dev);
  60         rc = usb_lock_device_interruptible(udev);
  61         if (rc < 0)
  62                 return -EINTR;
  63         actconfig = udev->actconfig;
  64         if (actconfig)
  65                 rc = sysfs_emit(buf, "%dmA\n", usb_get_max_power(udev, actconfig));
  66         usb_unlock_device(udev);
  67         return rc;
  68 }
  69 static DEVICE_ATTR_RO(bMaxPower);
  70
  71 static ssize_t configuration_show(struct device *dev,
  72                 struct device_attribute *attr, char *buf)
  73 {
  74         struct usb_device *udev;
  75         struct usb_host_config *actconfig;
  76         ssize_t rc;
  77
  78         udev = to_usb_device(dev);
  79         rc = usb_lock_device_interruptible(udev);
  80         if (rc < 0)
  81                 return -EINTR;
  82         actconfig = udev->actconfig;
  83         if (actconfig && actconfig->string)
  84                 rc = sysfs_emit(buf, "%s\n", actconfig->string);
  85         usb_unlock_device(udev);
  86         return rc;
  87 }
  88 static DEVICE_ATTR_RO(configuration);
  89
  90 /* configuration value is always present, and r/w */
  91 usb_actconfig_show(bConfigurationValue, "%u\n");
  92
  93 static ssize_t bConfigurationValue_store(struct device *dev,
  94                                          struct device_attribute *attr,
  95                                          const char *buf, size_t count)
  96 {
  97         struct usb_device       *udev = to_usb_device(dev);
  98         int                     config, value, rc;
  99
 100         if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255)
 101                 return -EINVAL;
 102         rc = usb_lock_device_interruptible(udev);
 103         if (rc < 0)
 104                 return -EINTR;
 105         value = usb_set_configuration(udev, config);
 106         usb_unlock_device(udev);
 107         return (value < 0) ? value : count;
 108 }
 109 static DEVICE_ATTR_IGNORE_LOCKDEP(bConfigurationValue, S_IRUGO | S_IWUSR,
 110                 bConfigurationValue_show, bConfigurationValue_store);
 111
 112 #ifdef CONFIG_OF
 113 static ssize_t devspec_show(struct device *dev, struct device_attribute *attr,
 114                             char *buf)
 115 {
 116         struct device_node *of_node = dev->of_node;
 117
 118         return sysfs_emit(buf, "%pOF\n", of_node);
 119 }
 120 static DEVICE_ATTR_RO(devspec);
 121 #endif
 122
 123 /* String fields */
 124 #define usb_string_attr(name)                                           \
 125 static ssize_t  name##_show(struct device *dev,                         \
 126                 struct device_attribute *attr, char *buf)               \
 127 {                                                                       \
 128         struct usb_device *udev;                                        \
 129         int retval;                                                     \
 130                                                                         \
 131         udev = to_usb_device(dev);                                      \
 132         retval = usb_lock_device_interruptible(udev);                   \
 133         if (retval < 0)                                                 \
 134                 return -EINTR;                                          \
 135         retval = sysfs_emit(buf, "%s\n", udev->name);                   \
 136         usb_unlock_device(udev);                                        \
 137         return retval;                                                  \
 138 }                                                                       \
 139 static DEVICE_ATTR_RO(name)
 140
 141 usb_string_attr(product);
 142 usb_string_attr(manufacturer);
 143 usb_string_attr(serial);
 144
 145 static ssize_t speed_show(struct device *dev, struct device_attribute *attr,
 146                           char *buf)
 147 {
 148         struct usb_device *udev;
 149         char *speed;
 150
 151         udev = to_usb_device(dev);
 152
 153         switch (udev->speed) {
 154         case USB_SPEED_LOW:
 155                 speed = "1.5";
 156                 break;
 157         case USB_SPEED_UNKNOWN:
 158         case USB_SPEED_FULL:
 159                 speed = "12";
 160                 break;
 161         case USB_SPEED_HIGH:
 162                 speed = "480";
 163                 break;
 164         case USB_SPEED_SUPER:
 165                 speed = "5000";
 166                 break;
 167         case USB_SPEED_SUPER_PLUS:
 168                 if (udev->ssp_rate == USB_SSP_GEN_2x2)
 169                         speed = "20000";
 170                 else
 171                         speed = "10000";
 172                 break;
 173         default:
 174                 speed = "unknown";
 175         }
 176         return sysfs_emit(buf, "%s\n", speed);
 177 }
 178 static DEVICE_ATTR_RO(speed);
 179
 180 static ssize_t rx_lanes_show(struct device *dev, struct device_attribute *attr,
 181                           char *buf)
 182 {
 183         struct usb_device *udev;
 184
 185         udev = to_usb_device(dev);
 186         return sysfs_emit(buf, "%d\n", udev->rx_lanes);
 187 }
 188 static DEVICE_ATTR_RO(rx_lanes);
 189
 190 static ssize_t tx_lanes_show(struct device *dev, struct device_attribute *attr,
 191                           char *buf)
 192 {
 193         struct usb_device *udev;
 194
 195         udev = to_usb_device(dev);
 196         return sysfs_emit(buf, "%d\n", udev->tx_lanes);
 197 }
 198 static DEVICE_ATTR_RO(tx_lanes);
 199
 200 static ssize_t busnum_show(struct device *dev, struct device_attribute *attr,
 201                            char *buf)
 202 {
 203         struct usb_device *udev;
 204
 205         udev = to_usb_device(dev);
 206         return sysfs_emit(buf, "%d\n", udev->bus->busnum);
 207 }
 208 static DEVICE_ATTR_RO(busnum);
 209
 210 static ssize_t devnum_show(struct device *dev, struct device_attribute *attr,
 211                            char *buf)
 212 {
 213         struct usb_device *udev;
 214
 215         udev = to_usb_device(dev);
 216         return sysfs_emit(buf, "%d\n", udev->devnum);
 217 }
 218 static DEVICE_ATTR_RO(devnum);
 219
 220 static ssize_t devpath_show(struct device *dev, struct device_attribute *attr,
 221                             char *buf)
 222 {
 223         struct usb_device *udev;
 224
 225         udev = to_usb_device(dev);
 226         return sysfs_emit(buf, "%s\n", udev->devpath);
 227 }
 228 static DEVICE_ATTR_RO(devpath);
 229
 230 static ssize_t version_show(struct device *dev, struct device_attribute *attr,
 231                             char *buf)
 232 {
 233         struct usb_device *udev;
 234         u16 bcdUSB;
 235
 236         udev = to_usb_device(dev);
 237         bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB);
 238         return sysfs_emit(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff);
 239 }
 240 static DEVICE_ATTR_RO(version);
 241
 242 static ssize_t maxchild_show(struct device *dev, struct device_attribute *attr,
 243                              char *buf)
 244 {
 245         struct usb_device *udev;
 246
 247         udev = to_usb_device(dev);
 248         return sysfs_emit(buf, "%d\n", udev->maxchild);
 249 }
 250 static DEVICE_ATTR_RO(maxchild);
 251
 252 static ssize_t quirks_show(struct device *dev, struct device_attribute *attr,
 253                            char *buf)
 254 {
 255         struct usb_device *udev;
 256
 257         udev = to_usb_device(dev);
 258         return sysfs_emit(buf, "0x%x\n", udev->quirks);
 259 }
 260 static DEVICE_ATTR_RO(quirks);
 261
 262 static ssize_t avoid_reset_quirk_show(struct device *dev,
 263                                       struct device_attribute *attr, char *buf)
 264 {
 265         struct usb_device *udev;
 266
 267         udev = to_usb_device(dev);
 268         return sysfs_emit(buf, "%d\n", !!(udev->quirks & USB_QUIRK_RESET));
 269 }
 270
 271 static ssize_t avoid_reset_quirk_store(struct device *dev,
 272                                       struct device_attribute *attr,
 273                                       const char *buf, size_t count)
 274 {
 275         struct usb_device       *udev = to_usb_device(dev);
 276         bool                    val;
 277         int                     rc;
 278
 279         if (kstrtobool(buf, &val) != 0)
 280                 return -EINVAL;
 281         rc = usb_lock_device_interruptible(udev);
 282         if (rc < 0)
 283                 return -EINTR;
 284         if (val)
 285                 udev->quirks |= USB_QUIRK_RESET;
 286         else
 287                 udev->quirks &= ~USB_QUIRK_RESET;
 288         usb_unlock_device(udev);
 289         return count;
 290 }
 291 static DEVICE_ATTR_RW(avoid_reset_quirk);
 292
 293 static ssize_t urbnum_show(struct device *dev, struct device_attribute *attr,
 294                            char *buf)
 295 {
 296         struct usb_device *udev;
 297
 298         udev = to_usb_device(dev);
 299         return sysfs_emit(buf, "%d\n", atomic_read(&udev->urbnum));
 300 }
 301 static DEVICE_ATTR_RO(urbnum);
 302
 303 static ssize_t ltm_capable_show(struct device *dev,
 304                                 struct device_attribute *attr, char *buf)
 305 {
 306         if (usb_device_supports_ltm(to_usb_device(dev)))
 307                 return sysfs_emit(buf, "%s\n", "yes");
 308         return sysfs_emit(buf, "%s\n", "no");
 309 }
 310 static DEVICE_ATTR_RO(ltm_capable);
 311
 312 #ifdef  CONFIG_PM
 313
 314 static ssize_t persist_show(struct device *dev, struct device_attribute *attr,
 315                             char *buf)
 316 {
 317         struct usb_device *udev = to_usb_device(dev);
 318
 319         return sysfs_emit(buf, "%d\n", udev->persist_enabled);
 320 }
 321
 322 static ssize_t persist_store(struct device *dev, struct device_attribute *attr,
 323                              const char *buf, size_t count)
 324 {
 325         struct usb_device *udev = to_usb_device(dev);
 326         bool value;
 327         int rc;
 328
 329         /* Hubs are always enabled for USB_PERSIST */
 330         if (udev->descriptor.bDeviceClass == USB_CLASS_HUB)
 331                 return -EPERM;
 332
 333         if (kstrtobool(buf, &value) != 0)
 334                 return -EINVAL;
 335
 336         rc = usb_lock_device_interruptible(udev);
 337         if (rc < 0)
 338                 return -EINTR;
 339         udev->persist_enabled = !!value;
 340         usb_unlock_device(udev);
 341         return count;
 342 }
 343 static DEVICE_ATTR_RW(persist);
 344
 345 static int add_persist_attributes(struct device *dev)
 346 {
 347         int rc = 0;
 348
 349         if (is_usb_device(dev)) {
 350                 struct usb_device *udev = to_usb_device(dev);
 351
 352                 /* Hubs are automatically enabled for USB_PERSIST,
 353                  * no point in creating the attribute file.
 354                  */
 355                 if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
 356                         rc = sysfs_add_file_to_group(&dev->kobj,
 357                                         &dev_attr_persist.attr,
 358                                         power_group_name);
 359         }
 360         return rc;
 361 }
 362
 363 static void remove_persist_attributes(struct device *dev)
 364 {
 365         sysfs_remove_file_from_group(&dev->kobj,
 366                         &dev_attr_persist.attr,
 367                         power_group_name);
 368 }
 369
 370 static ssize_t connected_duration_show(struct device *dev,
 371                                        struct device_attribute *attr, char *buf)
 372 {
 373         struct usb_device *udev = to_usb_device(dev);
 374
 375         return sysfs_emit(buf, "%u\n",
 376                         jiffies_to_msecs(jiffies - udev->connect_time));
 377 }
 378 static DEVICE_ATTR_RO(connected_duration);
 379
 380 /*
 381  * If the device is resumed, the last time the device was suspended has
 382  * been pre-subtracted from active_duration.  We add the current time to
 383  * get the duration that the device was actually active.
 384  *
 385  * If the device is suspended, the active_duration is up-to-date.
 386  */
 387 static ssize_t active_duration_show(struct device *dev,
 388                                     struct device_attribute *attr, char *buf)
 389 {
 390         struct usb_device *udev = to_usb_device(dev);
 391         int duration;
 392
 393         if (udev->state != USB_STATE_SUSPENDED)
 394                 duration = jiffies_to_msecs(jiffies + udev->active_duration);
 395         else
 396                 duration = jiffies_to_msecs(udev->active_duration);
 397         return sysfs_emit(buf, "%u\n", duration);
 398 }
 399 static DEVICE_ATTR_RO(active_duration);
 400
 401 static ssize_t autosuspend_show(struct device *dev,
 402                                 struct device_attribute *attr, char *buf)
 403 {
 404         return sysfs_emit(buf, "%d\n", dev->power.autosuspend_delay / 1000);
 405 }
 406
 407 static ssize_t autosuspend_store(struct device *dev,
 408                                  struct device_attribute *attr, const char *buf,
 409                                  size_t count)
 410 {
 411         int value;
 412
 413         if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/1000 ||
 414                         value <= -INT_MAX/1000)
 415                 return -EINVAL;
 416
 417         pm_runtime_set_autosuspend_delay(dev, value * 1000);
 418         return count;
 419 }
 420 static DEVICE_ATTR_RW(autosuspend);
 421
 422 static const char on_string[] = "on";
 423 static const char auto_string[] = "auto";
 424
 425 static void warn_level(void)
 426 {
 427         static int level_warned;
 428
 429         if (!level_warned) {
 430                 level_warned = 1;
 431                 printk(KERN_WARNING "WARNING! power/level is deprecated; "
 432                                 "use power/control instead\n");
 433         }
 434 }
 435
 436 static ssize_t level_show(struct device *dev, struct device_attribute *attr,
 437                           char *buf)
 438 {
 439         struct usb_device *udev = to_usb_device(dev);
 440         const char *p = auto_string;
 441
 442         warn_level();
 443         if (udev->state != USB_STATE_SUSPENDED && !udev->dev.power.runtime_auto)
 444                 p = on_string;
 445         return sysfs_emit(buf, "%s\n", p);
 446 }
 447
 448 static ssize_t level_store(struct device *dev, struct device_attribute *attr,
 449                            const char *buf, size_t count)
 450 {
 451         struct usb_device *udev = to_usb_device(dev);
 452         int len = count;
 453         char *cp;
 454         int rc = count;
 455         int rv;
 456
 457         warn_level();
 458         cp = memchr(buf, '\n', count);
 459         if (cp)
 460                 len = cp - buf;
 461
 462         rv = usb_lock_device_interruptible(udev);
 463         if (rv < 0)
 464                 return -EINTR;
 465
 466         if (len == sizeof on_string - 1 &&
 467                         strncmp(buf, on_string, len) == 0)
 468                 usb_disable_autosuspend(udev);
 469
 470         else if (len == sizeof auto_string - 1 &&
 471                         strncmp(buf, auto_string, len) == 0)
 472                 usb_enable_autosuspend(udev);
 473
 474         else
 475                 rc = -EINVAL;
 476
 477         usb_unlock_device(udev);
 478         return rc;
 479 }
 480 static DEVICE_ATTR_RW(level);
 481
 482 static ssize_t usb2_hardware_lpm_show(struct device *dev,
 483                                       struct device_attribute *attr, char *buf)
 484 {
 485         struct usb_device *udev = to_usb_device(dev);
 486         const char *p;
 487
 488         if (udev->usb2_hw_lpm_allowed == 1)
 489                 p = "enabled";
 490         else
 491                 p = "disabled";
 492
 493         return sysfs_emit(buf, "%s\n", p);
 494 }
 495
 496 static ssize_t usb2_hardware_lpm_store(struct device *dev,
 497                                        struct device_attribute *attr,
 498                                        const char *buf, size_t count)
 499 {
 500         struct usb_device *udev = to_usb_device(dev);
 501         bool value;
 502         int ret;
 503
 504         ret = usb_lock_device_interruptible(udev);
 505         if (ret < 0)
 506                 return -EINTR;
 507
 508         ret = kstrtobool(buf, &value);
 509
 510         if (!ret) {
 511                 udev->usb2_hw_lpm_allowed = value;
 512                 if (value)
 513                         ret = usb_enable_usb2_hardware_lpm(udev);
 514                 else
 515                         ret = usb_disable_usb2_hardware_lpm(udev);
 516         }
 517
 518         usb_unlock_device(udev);
 519
 520         if (!ret)
 521                 return count;
 522
 523         return ret;
 524 }
 525 static DEVICE_ATTR_RW(usb2_hardware_lpm);
 526
 527 static ssize_t usb2_lpm_l1_timeout_show(struct device *dev,
 528                                         struct device_attribute *attr,
 529                                         char *buf)
 530 {
 531         struct usb_device *udev = to_usb_device(dev);
 532         return sysfs_emit(buf, "%d\n", udev->l1_params.timeout);
 533 }
 534
 535 static ssize_t usb2_lpm_l1_timeout_store(struct device *dev,
 536                                          struct device_attribute *attr,
 537                                          const char *buf, size_t count)
 538 {
 539         struct usb_device *udev = to_usb_device(dev);
 540         u16 timeout;
 541
 542         if (kstrtou16(buf, 0, &timeout))
 543                 return -EINVAL;
 544
 545         udev->l1_params.timeout = timeout;
 546
 547         return count;
 548 }
 549 static DEVICE_ATTR_RW(usb2_lpm_l1_timeout);
 550
 551 static ssize_t usb2_lpm_besl_show(struct device *dev,
 552                                   struct device_attribute *attr, char *buf)
 553 {
 554         struct usb_device *udev = to_usb_device(dev);
 555         return sysfs_emit(buf, "%d\n", udev->l1_params.besl);
 556 }
 557
 558 static ssize_t usb2_lpm_besl_store(struct device *dev,
 559                                    struct device_attribute *attr,
 560                                    const char *buf, size_t count)
 561 {
 562         struct usb_device *udev = to_usb_device(dev);
 563         u8 besl;
 564
 565         if (kstrtou8(buf, 0, &besl) || besl > 15)
 566                 return -EINVAL;
 567
 568         udev->l1_params.besl = besl;
 569
 570         return count;
 571 }
 572 static DEVICE_ATTR_RW(usb2_lpm_besl);
 573
 574 static ssize_t usb3_hardware_lpm_u1_show(struct device *dev,
 575                                       struct device_attribute *attr, char *buf)
 576 {
 577         struct usb_device *udev = to_usb_device(dev);
 578         const char *p;
 579         int rc;
 580
 581         rc = usb_lock_device_interruptible(udev);
 582         if (rc < 0)
 583                 return -EINTR;
 584
 585         if (udev->usb3_lpm_u1_enabled)
 586                 p = "enabled";
 587         else
 588                 p = "disabled";
 589
 590         usb_unlock_device(udev);
 591
 592         return sysfs_emit(buf, "%s\n", p);
 593 }
 594 static DEVICE_ATTR_RO(usb3_hardware_lpm_u1);
 595
 596 static ssize_t usb3_hardware_lpm_u2_show(struct device *dev,
 597                                       struct device_attribute *attr, char *buf)
 598 {
 599         struct usb_device *udev = to_usb_device(dev);
 600         const char *p;
 601         int rc;
 602
 603         rc = usb_lock_device_interruptible(udev);
 604         if (rc < 0)
 605                 return -EINTR;
 606
 607         if (udev->usb3_lpm_u2_enabled)
 608                 p = "enabled";
 609         else
 610                 p = "disabled";
 611
 612         usb_unlock_device(udev);
 613
 614         return sysfs_emit(buf, "%s\n", p);
 615 }
 616 static DEVICE_ATTR_RO(usb3_hardware_lpm_u2);
 617
 618 static struct attribute *usb2_hardware_lpm_attr[] = {
 619         &dev_attr_usb2_hardware_lpm.attr,
 620         &dev_attr_usb2_lpm_l1_timeout.attr,
 621         &dev_attr_usb2_lpm_besl.attr,
 622         NULL,
 623 };
 624 static const struct attribute_group usb2_hardware_lpm_attr_group = {
 625         .name   = power_group_name,
 626         .attrs  = usb2_hardware_lpm_attr,
 627 };
 628
 629 static struct attribute *usb3_hardware_lpm_attr[] = {
 630         &dev_attr_usb3_hardware_lpm_u1.attr,
 631         &dev_attr_usb3_hardware_lpm_u2.attr,
 632         NULL,
 633 };
 634 static const struct attribute_group usb3_hardware_lpm_attr_group = {
 635         .name   = power_group_name,
 636         .attrs  = usb3_hardware_lpm_attr,
 637 };
 638
 639 static struct attribute *power_attrs[] = {
 640         &dev_attr_autosuspend.attr,
 641         &dev_attr_level.attr,
 642         &dev_attr_connected_duration.attr,
 643         &dev_attr_active_duration.attr,
 644         NULL,
 645 };
 646 static const struct attribute_group power_attr_group = {
 647         .name   = power_group_name,
 648         .attrs  = power_attrs,
 649 };
 650
 651 static int add_power_attributes(struct device *dev)
 652 {
 653         int rc = 0;
 654
 655         if (is_usb_device(dev)) {
 656                 struct usb_device *udev = to_usb_device(dev);
 657                 rc = sysfs_merge_group(&dev->kobj, &power_attr_group);
 658                 if (udev->usb2_hw_lpm_capable == 1)
 659                         rc = sysfs_merge_group(&dev->kobj,
 660                                         &usb2_hardware_lpm_attr_group);
 661                 if ((udev->speed == USB_SPEED_SUPER ||
 662                      udev->speed == USB_SPEED_SUPER_PLUS) &&
 663                                 udev->lpm_capable == 1)
 664                         rc = sysfs_merge_group(&dev->kobj,
 665                                         &usb3_hardware_lpm_attr_group);
 666         }
 667
 668         return rc;
 669 }
 670
 671 static void remove_power_attributes(struct device *dev)
 672 {
 673         sysfs_unmerge_group(&dev->kobj, &usb3_hardware_lpm_attr_group);
 674         sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group);
 675         sysfs_unmerge_group(&dev->kobj, &power_attr_group);
 676 }
 677
 678 #else
 679
 680 #define add_persist_attributes(dev)     0
 681 #define remove_persist_attributes(dev)  do {} while (0)
 682
 683 #define add_power_attributes(dev)       0
 684 #define remove_power_attributes(dev)    do {} while (0)
 685
 686 #endif  /* CONFIG_PM */
 687
 688
 689 /* Descriptor fields */
 690 #define usb_descriptor_attr_le16(field, format_string)                  \
 691 static ssize_t                                                          \
 692 field##_show(struct device *dev, struct device_attribute *attr, \
 693                 char *buf)                                              \
 694 {                                                                       \
 695         struct usb_device *udev;                                        \
 696                                                                         \
 697         udev = to_usb_device(dev);                                      \
 698         return sysfs_emit(buf, format_string,                           \
 699                         le16_to_cpu(udev->descriptor.field));           \
 700 }                                                                       \
 701 static DEVICE_ATTR_RO(field)
 702
 703 usb_descriptor_attr_le16(idVendor, "%04x\n");
 704 usb_descriptor_attr_le16(idProduct, "%04x\n");
 705 usb_descriptor_attr_le16(bcdDevice, "%04x\n");
 706
 707 #define usb_descriptor_attr(field, format_string)                       \
 708 static ssize_t                                                          \
 709 field##_show(struct device *dev, struct device_attribute *attr, \
 710                 char *buf)                                              \
 711 {                                                                       \
 712         struct usb_device *udev;                                        \
 713                                                                         \
 714         udev = to_usb_device(dev);                                      \
 715         return sysfs_emit(buf, format_string, udev->descriptor.field);  \
 716 }                                                                       \
 717 static DEVICE_ATTR_RO(field)
 718
 719 usb_descriptor_attr(bDeviceClass, "%02x\n");
 720 usb_descriptor_attr(bDeviceSubClass, "%02x\n");
 721 usb_descriptor_attr(bDeviceProtocol, "%02x\n");
 722 usb_descriptor_attr(bNumConfigurations, "%d\n");
 723 usb_descriptor_attr(bMaxPacketSize0, "%d\n");
 724
 725
 726 /* show if the device is authorized (1) or not (0) */
 727 static ssize_t authorized_show(struct device *dev,
 728                                struct device_attribute *attr, char *buf)
 729 {
 730         struct usb_device *usb_dev = to_usb_device(dev);
 731         return sysfs_emit(buf, "%u\n", usb_dev->authorized);
 732 }
 733
 734 /*
 735  * Authorize a device to be used in the system
 736  *
 737  * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
 738  */
 739 static ssize_t authorized_store(struct device *dev,
 740                                 struct device_attribute *attr, const char *buf,
 741                                 size_t size)
 742 {
 743         ssize_t result;
 744         struct usb_device *usb_dev = to_usb_device(dev);
 745         bool val;
 746
 747         if (kstrtobool(buf, &val) != 0)
 748                 result = -EINVAL;
 749         else if (val)
 750                 result = usb_authorize_device(usb_dev);
 751         else
 752                 result = usb_deauthorize_device(usb_dev);
 753         return result < 0 ? result : size;
 754 }
 755 static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR,
 756                                   authorized_show, authorized_store);
 757
 758 /* "Safely remove a device" */
 759 static ssize_t remove_store(struct device *dev, struct device_attribute *attr,
 760                             const char *buf, size_t count)
 761 {
 762         struct usb_device *udev = to_usb_device(dev);
 763         int rc = 0;
 764
 765         usb_lock_device(udev);
 766         if (udev->state != USB_STATE_NOTATTACHED) {
 767
 768                 /* To avoid races, first unconfigure and then remove */
 769                 usb_set_configuration(udev, -1);
 770                 rc = usb_remove_device(udev);
 771         }
 772         if (rc == 0)
 773                 rc = count;
 774         usb_unlock_device(udev);
 775         return rc;
 776 }
 777 static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store);
 778
 779
 780 static struct attribute *dev_attrs[] = {
 781         /* current configuration's attributes */
 782         &dev_attr_configuration.attr,
 783         &dev_attr_bNumInterfaces.attr,
 784         &dev_attr_bConfigurationValue.attr,
 785         &dev_attr_bmAttributes.attr,
 786         &dev_attr_bMaxPower.attr,
 787         /* device attributes */
 788         &dev_attr_urbnum.attr,
 789         &dev_attr_idVendor.attr,
 790         &dev_attr_idProduct.attr,
 791         &dev_attr_bcdDevice.attr,
 792         &dev_attr_bDeviceClass.attr,
 793         &dev_attr_bDeviceSubClass.attr,
 794         &dev_attr_bDeviceProtocol.attr,
 795         &dev_attr_bNumConfigurations.attr,
 796         &dev_attr_bMaxPacketSize0.attr,
 797         &dev_attr_speed.attr,
 798         &dev_attr_rx_lanes.attr,
 799         &dev_attr_tx_lanes.attr,
 800         &dev_attr_busnum.attr,
 801         &dev_attr_devnum.attr,
 802         &dev_attr_devpath.attr,
 803         &dev_attr_version.attr,
 804         &dev_attr_maxchild.attr,
 805         &dev_attr_quirks.attr,
 806         &dev_attr_avoid_reset_quirk.attr,
 807         &dev_attr_authorized.attr,
 808         &dev_attr_remove.attr,
 809         &dev_attr_ltm_capable.attr,
 810 #ifdef CONFIG_OF
 811         &dev_attr_devspec.attr,
 812 #endif
 813         NULL,
 814 };
 815 static const struct attribute_group dev_attr_grp = {
 816         .attrs = dev_attrs,
 817 };
 818
 819 /* When modifying this list, be sure to modify dev_string_attrs_are_visible()
 820  * accordingly.
 821  */
 822 static struct attribute *dev_string_attrs[] = {
 823         &dev_attr_manufacturer.attr,
 824         &dev_attr_product.attr,
 825         &dev_attr_serial.attr,
 826         NULL
 827 };
 828
 829 static umode_t dev_string_attrs_are_visible(struct kobject *kobj,
 830                 struct attribute *a, int n)
 831 {
 832         struct device *dev = kobj_to_dev(kobj);
 833         struct usb_device *udev = to_usb_device(dev);
 834
 835         if (a == &dev_attr_manufacturer.attr) {
 836                 if (udev->manufacturer == NULL)
 837                         return 0;
 838         } else if (a == &dev_attr_product.attr) {
 839                 if (udev->product == NULL)
 840                         return 0;
 841         } else if (a == &dev_attr_serial.attr) {
 842                 if (udev->serial == NULL)
 843                         return 0;
 844         }
 845         return a->mode;
 846 }
 847
 848 static const struct attribute_group dev_string_attr_grp = {
 849         .attrs =        dev_string_attrs,
 850         .is_visible =   dev_string_attrs_are_visible,
 851 };
 852
 853 /* Binary descriptors */
 854
 855 static ssize_t
 856 descriptors_read(struct file *filp, struct kobject *kobj,
 857                 struct bin_attribute *attr,
 858                 char *buf, loff_t off, size_t count)
 859 {
 860         struct device *dev = kobj_to_dev(kobj);
 861         struct usb_device *udev = to_usb_device(dev);
 862         size_t nleft = count;
 863         size_t srclen, n;
 864         int cfgno;
 865         void *src;
 866
 867         /* The binary attribute begins with the device descriptor.
 868          * Following that are the raw descriptor entries for all the
 869          * configurations (config plus subsidiary descriptors).
 870          */
 871         for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations &&
 872                         nleft > 0; ++cfgno) {
 873                 if (cfgno < 0) {
 874                         src = &udev->descriptor;
 875                         srclen = sizeof(struct usb_device_descriptor);
 876                 } else {
 877                         src = udev->rawdescriptors[cfgno];
 878                         srclen = le16_to_cpu(udev->config[cfgno].desc.
 879                                         wTotalLength);
 880                 }
 881                 if (off < srclen) {
 882                         n = min(nleft, srclen - (size_t) off);
 883                         memcpy(buf, src + off, n);
 884                         nleft -= n;
 885                         buf += n;
 886                         off = 0;
 887                 } else {
 888                         off -= srclen;
 889                 }
 890         }
 891         return count - nleft;
 892 }
 893 static BIN_ATTR_RO(descriptors, 18 + 65535); /* dev descr + max-size raw descriptor */
 894
 895 static ssize_t
 896 bos_descriptors_read(struct file *filp, struct kobject *kobj,
 897                 struct bin_attribute *attr,
 898                 char *buf, loff_t off, size_t count)
 899 {
 900         struct device *dev = kobj_to_dev(kobj);
 901         struct usb_device *udev = to_usb_device(dev);
 902         struct usb_host_bos *bos = udev->bos;
 903         struct usb_bos_descriptor *desc;
 904         size_t desclen, n = 0;
 905
 906         if (bos) {
 907                 desc = bos->desc;
 908                 desclen = le16_to_cpu(desc->wTotalLength);
 909                 if (off < desclen) {
 910                         n = min(count, desclen - (size_t) off);
 911                         memcpy(buf, (void *) desc + off, n);
 912                 }
 913         }
 914         return n;
 915 }
 916 static BIN_ATTR_RO(bos_descriptors, 65535); /* max-size BOS */
 917
 918 /* When modifying this list, be sure to modify dev_bin_attrs_are_visible()
 919  * accordingly.
 920  */
 921 static struct bin_attribute *dev_bin_attrs[] = {
 922         &bin_attr_descriptors,
 923         &bin_attr_bos_descriptors,
 924         NULL
 925 };
 926
 927 static umode_t dev_bin_attrs_are_visible(struct kobject *kobj,
 928                 struct bin_attribute *a, int n)
 929 {
 930         struct device *dev = kobj_to_dev(kobj);
 931         struct usb_device *udev = to_usb_device(dev);
 932
 933         /*
 934          * There's no need to check if the descriptors attribute should
 935          * be visible because all devices have a device descriptor. The
 936          * bos_descriptors attribute should be visible if and only if
 937          * the device has a BOS, so check if it exists here.
 938          */
 939         if (a == &bin_attr_bos_descriptors) {
 940                 if (udev->bos == NULL)
 941                         return 0;
 942         }
 943         return a->attr.mode;
 944 }
 945
 946 static const struct attribute_group dev_bin_attr_grp = {
 947         .bin_attrs =            dev_bin_attrs,
 948         .is_bin_visible =       dev_bin_attrs_are_visible,
 949 };
 950
 951 const struct attribute_group *usb_device_groups[] = {
 952         &dev_attr_grp,
 953         &dev_string_attr_grp,
 954         &dev_bin_attr_grp,
 955         NULL
 956 };
 957
 958 /*
 959  * Show & store the current value of authorized_default
 960  */
 961 static ssize_t authorized_default_show(struct device *dev,
 962                                        struct device_attribute *attr, char *buf)
 963 {
 964         struct usb_device *rh_usb_dev = to_usb_device(dev);
 965         struct usb_bus *usb_bus = rh_usb_dev->bus;
 966         struct usb_hcd *hcd;
 967
 968         hcd = bus_to_hcd(usb_bus);
 969         return sysfs_emit(buf, "%u\n", hcd->dev_policy);
 970 }
 971
 972 static ssize_t authorized_default_store(struct device *dev,
 973                                         struct device_attribute *attr,
 974                                         const char *buf, size_t size)
 975 {
 976         ssize_t result;
 977         unsigned int val;
 978         struct usb_device *rh_usb_dev = to_usb_device(dev);
 979         struct usb_bus *usb_bus = rh_usb_dev->bus;
 980         struct usb_hcd *hcd;
 981
 982         hcd = bus_to_hcd(usb_bus);
 983         result = sscanf(buf, "%u\n", &val);
 984         if (result == 1) {
 985                 hcd->dev_policy = val <= USB_DEVICE_AUTHORIZE_INTERNAL ?
 986                         val : USB_DEVICE_AUTHORIZE_ALL;
 987                 result = size;
 988         } else {
 989                 result = -EINVAL;
 990         }
 991         return result;
 992 }
 993 static DEVICE_ATTR_RW(authorized_default);
 994
 995 /*
 996  * interface_authorized_default_show - show default authorization status
 997  * for USB interfaces
 998  *
 999  * note: interface_authorized_default is the default value
1000  *       for initializing the authorized attribute of interfaces
1001  */
1002 static ssize_t interface_authorized_default_show(struct device *dev,
1003                 struct device_attribute *attr, char *buf)
1004 {
1005         struct usb_device *usb_dev = to_usb_device(dev);
1006         struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus);
1007
1008         return sysfs_emit(buf, "%u\n", !!HCD_INTF_AUTHORIZED(hcd));
1009 }
1010
1011 /*
1012  * interface_authorized_default_store - store default authorization status
1013  * for USB interfaces
1014  *
1015  * note: interface_authorized_default is the default value
1016  *       for initializing the authorized attribute of interfaces
1017  */
1018 static ssize_t interface_authorized_default_store(struct device *dev,
1019                 struct device_attribute *attr, const char *buf, size_t count)
1020 {
1021         struct usb_device *usb_dev = to_usb_device(dev);
1022         struct usb_hcd *hcd = bus_to_hcd(usb_dev->bus);
1023         int rc = count;
1024         bool val;
1025
1026         if (kstrtobool(buf, &val) != 0)
1027                 return -EINVAL;
1028
1029         if (val)
1030                 set_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags);
1031         else
1032                 clear_bit(HCD_FLAG_INTF_AUTHORIZED, &hcd->flags);
1033
1034         return rc;
1035 }
1036 static DEVICE_ATTR_RW(interface_authorized_default);
1037
1038 /* Group all the USB bus attributes */
1039 static struct attribute *usb_bus_attrs[] = {
1040                 &dev_attr_authorized_default.attr,
1041                 &dev_attr_interface_authorized_default.attr,
1042                 NULL,
1043 };
1044
1045 static const struct attribute_group usb_bus_attr_group = {
1046         .name = NULL,   /* we want them in the same directory */
1047         .attrs = usb_bus_attrs,
1048 };
1049
1050
1051 static int add_default_authorized_attributes(struct device *dev)
1052 {
1053         int rc = 0;
1054
1055         if (is_usb_device(dev))
1056                 rc = sysfs_create_group(&dev->kobj, &usb_bus_attr_group);
1057
1058         return rc;
1059 }
1060
1061 static void remove_default_authorized_attributes(struct device *dev)
1062 {
1063         if (is_usb_device(dev)) {
1064                 sysfs_remove_group(&dev->kobj, &usb_bus_attr_group);
1065         }
1066 }
1067
1068 int usb_create_sysfs_dev_files(struct usb_device *udev)
1069 {
1070         struct device *dev = &udev->dev;
1071         int retval;
1072
1073         retval = add_persist_attributes(dev);
1074         if (retval)
1075                 goto error;
1076
1077         retval = add_power_attributes(dev);
1078         if (retval)
1079                 goto error;
1080
1081         if (is_root_hub(udev)) {
1082                 retval = add_default_authorized_attributes(dev);
1083                 if (retval)
1084                         goto error;
1085         }
1086         return retval;
1087
1088 error:
1089         usb_remove_sysfs_dev_files(udev);
1090         return retval;
1091 }
1092
1093 void usb_remove_sysfs_dev_files(struct usb_device *udev)
1094 {
1095         struct device *dev = &udev->dev;
1096
1097         if (is_root_hub(udev))
1098                 remove_default_authorized_attributes(dev);
1099
1100         remove_power_attributes(dev);
1101         remove_persist_attributes(dev);
1102 }
1103
1104 /* Interface Association Descriptor fields */
1105 #define usb_intf_assoc_attr(field, format_string)                       \
1106 static ssize_t                                                          \
1107 iad_##field##_show(struct device *dev, struct device_attribute *attr,   \
1108                 char *buf)                                              \
1109 {                                                                       \
1110         struct usb_interface *intf = to_usb_interface(dev);             \
1111                                                                         \
1112         return sysfs_emit(buf, format_string,                           \
1113                         intf->intf_assoc->field);                       \
1114 }                                                                       \
1115 static DEVICE_ATTR_RO(iad_##field)
1116
1117 usb_intf_assoc_attr(bFirstInterface, "%02x\n");
1118 usb_intf_assoc_attr(bInterfaceCount, "%02d\n");
1119 usb_intf_assoc_attr(bFunctionClass, "%02x\n");
1120 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n");
1121 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n");
1122
1123 /* Interface fields */
1124 #define usb_intf_attr(field, format_string)                             \
1125 static ssize_t                                                          \
1126 field##_show(struct device *dev, struct device_attribute *attr,         \
1127                 char *buf)                                              \
1128 {                                                                       \
1129         struct usb_interface *intf = to_usb_interface(dev);             \
1130                                                                         \
1131         return sysfs_emit(buf, format_string,                           \
1132                         intf->cur_altsetting->desc.field);              \
1133 }                                                                       \
1134 static DEVICE_ATTR_RO(field)
1135
1136 usb_intf_attr(bInterfaceNumber, "%02x\n");
1137 usb_intf_attr(bAlternateSetting, "%2d\n");
1138 usb_intf_attr(bNumEndpoints, "%02x\n");
1139 usb_intf_attr(bInterfaceClass, "%02x\n");
1140 usb_intf_attr(bInterfaceSubClass, "%02x\n");
1141 usb_intf_attr(bInterfaceProtocol, "%02x\n");
1142
1143 static ssize_t interface_show(struct device *dev, struct device_attribute *attr,
1144                               char *buf)
1145 {
1146         struct usb_interface *intf;
1147         char *string;
1148
1149         intf = to_usb_interface(dev);
1150         string = READ_ONCE(intf->cur_altsetting->string);
1151         if (!string)
1152                 return 0;
1153         return sysfs_emit(buf, "%s\n", string);
1154 }
1155 static DEVICE_ATTR_RO(interface);
1156
1157 static ssize_t modalias_show(struct device *dev, struct device_attribute *attr,
1158                              char *buf)
1159 {
1160         struct usb_interface *intf;
1161         struct usb_device *udev;
1162         struct usb_host_interface *alt;
1163
1164         intf = to_usb_interface(dev);
1165         udev = interface_to_usbdev(intf);
1166         alt = READ_ONCE(intf->cur_altsetting);
1167
1168         return sysfs_emit(buf,
1169                         "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
1170                         "ic%02Xisc%02Xip%02Xin%02X\n",
1171                         le16_to_cpu(udev->descriptor.idVendor),
1172                         le16_to_cpu(udev->descriptor.idProduct),
1173                         le16_to_cpu(udev->descriptor.bcdDevice),
1174                         udev->descriptor.bDeviceClass,
1175                         udev->descriptor.bDeviceSubClass,
1176                         udev->descriptor.bDeviceProtocol,
1177                         alt->desc.bInterfaceClass,
1178                         alt->desc.bInterfaceSubClass,
1179                         alt->desc.bInterfaceProtocol,
1180                         alt->desc.bInterfaceNumber);
1181 }
1182 static DEVICE_ATTR_RO(modalias);
1183
1184 static ssize_t supports_autosuspend_show(struct device *dev,
1185                                          struct device_attribute *attr,
1186                                          char *buf)
1187 {
1188         int s;
1189
1190         s = device_lock_interruptible(dev);
1191         if (s < 0)
1192                 return -EINTR;
1193         /* Devices will be autosuspended even when an interface isn't claimed */
1194         s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend);
1195         device_unlock(dev);
1196
1197         return sysfs_emit(buf, "%u\n", s);
1198 }
1199 static DEVICE_ATTR_RO(supports_autosuspend);
1200
1201 /*
1202  * interface_authorized_show - show authorization status of an USB interface
1203  * 1 is authorized, 0 is deauthorized
1204  */
1205 static ssize_t interface_authorized_show(struct device *dev,
1206                 struct device_attribute *attr, char *buf)
1207 {
1208         struct usb_interface *intf = to_usb_interface(dev);
1209
1210         return sysfs_emit(buf, "%u\n", intf->authorized);
1211 }
1212
1213 /*
1214  * interface_authorized_store - authorize or deauthorize an USB interface
1215  */
1216 static ssize_t interface_authorized_store(struct device *dev,
1217                 struct device_attribute *attr, const char *buf, size_t count)
1218 {
1219         struct usb_interface *intf = to_usb_interface(dev);
1220         bool val;
1221         struct kernfs_node *kn;
1222
1223         if (kstrtobool(buf, &val) != 0)
1224                 return -EINVAL;
1225
1226         if (val) {
1227                 usb_authorize_interface(intf);
1228         } else {
1229                 /*
1230                  * Prevent deadlock if another process is concurrently
1231                  * trying to unregister intf.
1232                  */
1233                 kn = sysfs_break_active_protection(&dev->kobj, &attr->attr);
1234                 if (kn) {
1235                         usb_deauthorize_interface(intf);
1236                         sysfs_unbreak_active_protection(kn);
1237                 }
1238         }
1239
1240         return count;
1241 }
1242 static struct device_attribute dev_attr_interface_authorized =
1243                 __ATTR(authorized, S_IRUGO | S_IWUSR,
1244                 interface_authorized_show, interface_authorized_store);
1245
1246 static struct attribute *intf_attrs[] = {
1247         &dev_attr_bInterfaceNumber.attr,
1248         &dev_attr_bAlternateSetting.attr,
1249         &dev_attr_bNumEndpoints.attr,
1250         &dev_attr_bInterfaceClass.attr,
1251         &dev_attr_bInterfaceSubClass.attr,
1252         &dev_attr_bInterfaceProtocol.attr,
1253         &dev_attr_modalias.attr,
1254         &dev_attr_supports_autosuspend.attr,
1255         &dev_attr_interface_authorized.attr,
1256         NULL,
1257 };
1258 static const struct attribute_group intf_attr_grp = {
1259         .attrs = intf_attrs,
1260 };
1261
1262 static struct attribute *intf_assoc_attrs[] = {
1263         &dev_attr_iad_bFirstInterface.attr,
1264         &dev_attr_iad_bInterfaceCount.attr,
1265         &dev_attr_iad_bFunctionClass.attr,
1266         &dev_attr_iad_bFunctionSubClass.attr,
1267         &dev_attr_iad_bFunctionProtocol.attr,
1268         NULL,
1269 };
1270
1271 static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj,
1272                 struct attribute *a, int n)
1273 {
1274         struct device *dev = kobj_to_dev(kobj);
1275         struct usb_interface *intf = to_usb_interface(dev);
1276
1277         if (intf->intf_assoc == NULL)
1278                 return 0;
1279         return a->mode;
1280 }
1281
1282 static const struct attribute_group intf_assoc_attr_grp = {
1283         .attrs =        intf_assoc_attrs,
1284         .is_visible =   intf_assoc_attrs_are_visible,
1285 };
1286
1287 static ssize_t wireless_status_show(struct device *dev,
1288                                     struct device_attribute *attr, char *buf)
1289 {
1290         struct usb_interface *intf;
1291
1292         intf = to_usb_interface(dev);
1293         if (intf->wireless_status == USB_WIRELESS_STATUS_DISCONNECTED)
1294                 return sysfs_emit(buf, "%s\n", "disconnected");
1295         return sysfs_emit(buf, "%s\n", "connected");
1296 }
1297 static DEVICE_ATTR_RO(wireless_status);
1298
1299 static struct attribute *intf_wireless_status_attrs[] = {
1300         &dev_attr_wireless_status.attr,
1301         NULL
1302 };
1303
1304 static umode_t intf_wireless_status_attr_is_visible(struct kobject *kobj,
1305                 struct attribute *a, int n)
1306 {
1307         struct device *dev = kobj_to_dev(kobj);
1308         struct usb_interface *intf = to_usb_interface(dev);
1309
1310         if (a != &dev_attr_wireless_status.attr ||
1311             intf->wireless_status != USB_WIRELESS_STATUS_NA)
1312                 return a->mode;
1313         return 0;
1314 }
1315
1316 static const struct attribute_group intf_wireless_status_attr_grp = {
1317         .attrs =        intf_wireless_status_attrs,
1318         .is_visible =   intf_wireless_status_attr_is_visible,
1319 };
1320
1321 int usb_update_wireless_status_attr(struct usb_interface *intf)
1322 {
1323         struct device *dev = &intf->dev;
1324         int ret;
1325
1326         ret = sysfs_update_group(&dev->kobj, &intf_wireless_status_attr_grp);
1327         if (ret < 0)
1328                 return ret;
1329
1330         sysfs_notify(&dev->kobj, NULL, "wireless_status");
1331         kobject_uevent(&dev->kobj, KOBJ_CHANGE);
1332
1333         return 0;
1334 }
1335
1336 const struct attribute_group *usb_interface_groups[] = {
1337         &intf_attr_grp,
1338         &intf_assoc_attr_grp,
1339         &intf_wireless_status_attr_grp,
1340         NULL
1341 };
1342
1343 void usb_create_sysfs_intf_files(struct usb_interface *intf)
1344 {
1345         struct usb_device *udev = interface_to_usbdev(intf);
1346         struct usb_host_interface *alt = intf->cur_altsetting;
1347
1348         if (intf->sysfs_files_created || intf->unregistering)
1349                 return;
1350
1351         if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
1352                 alt->string = usb_cache_string(udev, alt->desc.iInterface);
1353         if (alt->string && device_create_file(&intf->dev, &dev_attr_interface)) {
1354                 /* This is not a serious error */
1355                 dev_dbg(&intf->dev, "interface string descriptor file not created\n");
1356         }
1357         intf->sysfs_files_created = 1;
1358 }
1359
1360 void usb_remove_sysfs_intf_files(struct usb_interface *intf)
1361 {
1362         if (!intf->sysfs_files_created)
1363                 return;
1364
1365         device_remove_file(&intf->dev, &dev_attr_interface);
1366         intf->sysfs_files_created = 0;
1367 }