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, multiplier, format_string)            \
  21 static ssize_t  show_##field(struct device *dev,                        \
  22                 struct device_attribute *attr, char *buf)               \
  23 {                                                                       \
  24         struct usb_device *udev;                                        \
  25         struct usb_host_config *actconfig;                              \
  26                                                                         \
  27         udev = to_usb_device(dev);                                      \
  28         actconfig = udev->actconfig;                                    \
  29         if (actconfig)                                                  \
  30                 return sprintf(buf, format_string,                      \
  31                                 actconfig->desc.field * multiplier);    \
  32         else                                                            \
  33                 return 0;                                               \
  34 }                                                                       \
  35
  36 #define usb_actconfig_attr(field, multiplier, format_string)            \
  37 usb_actconfig_show(field, multiplier, format_string)                    \
  38 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
  39
  40 usb_actconfig_attr(bNumInterfaces, 1, "%2d\n")
  41 usb_actconfig_attr(bmAttributes, 1, "%2x\n")
  42 usb_actconfig_attr(bMaxPower, 2, "%3dmA\n")
  43
  44 static ssize_t show_configuration_string(struct device *dev,
  45                 struct device_attribute *attr, char *buf)
  46 {
  47         struct usb_device *udev;
  48         struct usb_host_config *actconfig;
  49
  50         udev = to_usb_device(dev);
  51         actconfig = udev->actconfig;
  52         if ((!actconfig) || (!actconfig->string))
  53                 return 0;
  54         return sprintf(buf, "%s\n", actconfig->string);
  55 }
  56 static DEVICE_ATTR(configuration, S_IRUGO, show_configuration_string, NULL);
  57
  58 /* configuration value is always present, and r/w */
  59 usb_actconfig_show(bConfigurationValue, 1, "%u\n");
  60
  61 static ssize_t
  62 set_bConfigurationValue(struct device *dev, struct device_attribute *attr,
  63                 const char *buf, size_t count)
  64 {
  65         struct usb_device       *udev = to_usb_device(dev);
  66         int                     config, value;
  67
  68         if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255)
  69                 return -EINVAL;
  70         usb_lock_device(udev);
  71         value = usb_set_configuration(udev, config);
  72         usb_unlock_device(udev);
  73         return (value < 0) ? value : count;
  74 }
  75
  76 static DEVICE_ATTR(bConfigurationValue, S_IRUGO | S_IWUSR,
  77                 show_bConfigurationValue, set_bConfigurationValue);
  78
  79 /* String fields */
  80 #define usb_string_attr(name)                                           \
  81 static ssize_t  show_##name(struct device *dev,                         \
  82                 struct device_attribute *attr, char *buf)               \
  83 {                                                                       \
  84         struct usb_device *udev;                                        \
  85         int retval;                                                     \
  86                                                                         \
  87         udev = to_usb_device(dev);                                      \
  88         usb_lock_device(udev);                                          \
  89         retval = sprintf(buf, "%s\n", udev->name);                      \
  90         usb_unlock_device(udev);                                        \
  91         return retval;                                                  \
  92 }                                                                       \
  93 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
  94
  95 usb_string_attr(product);
  96 usb_string_attr(manufacturer);
  97 usb_string_attr(serial);
  98
  99 static ssize_t
 100 show_speed(struct device *dev, struct device_attribute *attr, char *buf)
 101 {
 102         struct usb_device *udev;
 103         char *speed;
 104
 105         udev = to_usb_device(dev);
 106
 107         switch (udev->speed) {
 108         case USB_SPEED_LOW:
 109                 speed = "1.5";
 110                 break;
 111         case USB_SPEED_UNKNOWN:
 112         case USB_SPEED_FULL:
 113                 speed = "12";
 114                 break;
 115         case USB_SPEED_HIGH:
 116                 speed = "480";
 117                 break;
 118         case USB_SPEED_WIRELESS:
 119                 speed = "480";
 120                 break;
 121         case USB_SPEED_SUPER:
 122                 speed = "5000";
 123                 break;
 124         default:
 125                 speed = "unknown";
 126         }
 127         return sprintf(buf, "%s\n", speed);
 128 }
 129 static DEVICE_ATTR(speed, S_IRUGO, show_speed, NULL);
 130
 131 static ssize_t
 132 show_busnum(struct device *dev, struct device_attribute *attr, char *buf)
 133 {
 134         struct usb_device *udev;
 135
 136         udev = to_usb_device(dev);
 137         return sprintf(buf, "%d\n", udev->bus->busnum);
 138 }
 139 static DEVICE_ATTR(busnum, S_IRUGO, show_busnum, NULL);
 140
 141 static ssize_t
 142 show_devnum(struct device *dev, struct device_attribute *attr, char *buf)
 143 {
 144         struct usb_device *udev;
 145
 146         udev = to_usb_device(dev);
 147         return sprintf(buf, "%d\n", udev->devnum);
 148 }
 149 static DEVICE_ATTR(devnum, S_IRUGO, show_devnum, NULL);
 150
 151 static ssize_t
 152 show_devpath(struct device *dev, struct device_attribute *attr, char *buf)
 153 {
 154         struct usb_device *udev;
 155
 156         udev = to_usb_device(dev);
 157         return sprintf(buf, "%s\n", udev->devpath);
 158 }
 159 static DEVICE_ATTR(devpath, S_IRUGO, show_devpath, NULL);
 160
 161 static ssize_t
 162 show_version(struct device *dev, struct device_attribute *attr, char *buf)
 163 {
 164         struct usb_device *udev;
 165         u16 bcdUSB;
 166
 167         udev = to_usb_device(dev);
 168         bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB);
 169         return sprintf(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff);
 170 }
 171 static DEVICE_ATTR(version, S_IRUGO, show_version, NULL);
 172
 173 static ssize_t
 174 show_maxchild(struct device *dev, struct device_attribute *attr, char *buf)
 175 {
 176         struct usb_device *udev;
 177
 178         udev = to_usb_device(dev);
 179         return sprintf(buf, "%d\n", udev->maxchild);
 180 }
 181 static DEVICE_ATTR(maxchild, S_IRUGO, show_maxchild, NULL);
 182
 183 static ssize_t
 184 show_quirks(struct device *dev, struct device_attribute *attr, char *buf)
 185 {
 186         struct usb_device *udev;
 187
 188         udev = to_usb_device(dev);
 189         return sprintf(buf, "0x%x\n", udev->quirks);
 190 }
 191 static DEVICE_ATTR(quirks, S_IRUGO, show_quirks, NULL);
 192
 193 static ssize_t
 194 show_avoid_reset_quirk(struct device *dev, struct device_attribute *attr, char *buf)
 195 {
 196         struct usb_device *udev;
 197
 198         udev = to_usb_device(dev);
 199         return sprintf(buf, "%d\n", !!(udev->quirks & USB_QUIRK_RESET_MORPHS));
 200 }
 201
 202 static ssize_t
 203 set_avoid_reset_quirk(struct device *dev, struct device_attribute *attr,
 204                 const char *buf, size_t count)
 205 {
 206         struct usb_device       *udev = to_usb_device(dev);
 207         int                     config;
 208
 209         if (sscanf(buf, "%d", &config) != 1 || config < 0 || config > 1)
 210                 return -EINVAL;
 211         usb_lock_device(udev);
 212         if (config)
 213                 udev->quirks |= USB_QUIRK_RESET_MORPHS;
 214         else
 215                 udev->quirks &= ~USB_QUIRK_RESET_MORPHS;
 216         usb_unlock_device(udev);
 217         return count;
 218 }
 219
 220 static DEVICE_ATTR(avoid_reset_quirk, S_IRUGO | S_IWUSR,
 221                 show_avoid_reset_quirk, set_avoid_reset_quirk);
 222
 223 static ssize_t
 224 show_urbnum(struct device *dev, struct device_attribute *attr, char *buf)
 225 {
 226         struct usb_device *udev;
 227
 228         udev = to_usb_device(dev);
 229         return sprintf(buf, "%d\n", atomic_read(&udev->urbnum));
 230 }
 231 static DEVICE_ATTR(urbnum, S_IRUGO, show_urbnum, NULL);
 232
 233
 234 #ifdef  CONFIG_PM
 235
 236 static const char power_group[] = "power";
 237
 238 static ssize_t
 239 show_persist(struct device *dev, struct device_attribute *attr, char *buf)
 240 {
 241         struct usb_device *udev = to_usb_device(dev);
 242
 243         return sprintf(buf, "%d\n", udev->persist_enabled);
 244 }
 245
 246 static ssize_t
 247 set_persist(struct device *dev, struct device_attribute *attr,
 248                 const char *buf, size_t count)
 249 {
 250         struct usb_device *udev = to_usb_device(dev);
 251         int value;
 252
 253         /* Hubs are always enabled for USB_PERSIST */
 254         if (udev->descriptor.bDeviceClass == USB_CLASS_HUB)
 255                 return -EPERM;
 256
 257         if (sscanf(buf, "%d", &value) != 1)
 258                 return -EINVAL;
 259
 260         usb_lock_device(udev);
 261         udev->persist_enabled = !!value;
 262         usb_unlock_device(udev);
 263         return count;
 264 }
 265
 266 static DEVICE_ATTR(persist, S_IRUGO | S_IWUSR, show_persist, set_persist);
 267
 268 static int add_persist_attributes(struct device *dev)
 269 {
 270         int rc = 0;
 271
 272         if (is_usb_device(dev)) {
 273                 struct usb_device *udev = to_usb_device(dev);
 274
 275                 /* Hubs are automatically enabled for USB_PERSIST,
 276                  * no point in creating the attribute file.
 277                  */
 278                 if (udev->descriptor.bDeviceClass != USB_CLASS_HUB)
 279                         rc = sysfs_add_file_to_group(&dev->kobj,
 280                                         &dev_attr_persist.attr,
 281                                         power_group);
 282         }
 283         return rc;
 284 }
 285
 286 static void remove_persist_attributes(struct device *dev)
 287 {
 288         sysfs_remove_file_from_group(&dev->kobj,
 289                         &dev_attr_persist.attr,
 290                         power_group);
 291 }
 292 #else
 293
 294 #define add_persist_attributes(dev)     0
 295 #define remove_persist_attributes(dev)  do {} while (0)
 296
 297 #endif  /* CONFIG_PM */
 298
 299 #ifdef  CONFIG_USB_SUSPEND
 300
 301 static ssize_t
 302 show_connected_duration(struct device *dev, struct device_attribute *attr,
 303                 char *buf)
 304 {
 305         struct usb_device *udev = to_usb_device(dev);
 306
 307         return sprintf(buf, "%u\n",
 308                         jiffies_to_msecs(jiffies - udev->connect_time));
 309 }
 310
 311 static DEVICE_ATTR(connected_duration, S_IRUGO, show_connected_duration, NULL);
 312
 313 /*
 314  * If the device is resumed, the last time the device was suspended has
 315  * been pre-subtracted from active_duration.  We add the current time to
 316  * get the duration that the device was actually active.
 317  *
 318  * If the device is suspended, the active_duration is up-to-date.
 319  */
 320 static ssize_t
 321 show_active_duration(struct device *dev, struct device_attribute *attr,
 322                 char *buf)
 323 {
 324         struct usb_device *udev = to_usb_device(dev);
 325         int duration;
 326
 327         if (udev->state != USB_STATE_SUSPENDED)
 328                 duration = jiffies_to_msecs(jiffies + udev->active_duration);
 329         else
 330                 duration = jiffies_to_msecs(udev->active_duration);
 331         return sprintf(buf, "%u\n", duration);
 332 }
 333
 334 static DEVICE_ATTR(active_duration, S_IRUGO, show_active_duration, NULL);
 335
 336 static ssize_t
 337 show_autosuspend(struct device *dev, struct device_attribute *attr, char *buf)
 338 {
 339         struct usb_device *udev = to_usb_device(dev);
 340
 341         return sprintf(buf, "%d\n", udev->autosuspend_delay / HZ);
 342 }
 343
 344 static ssize_t
 345 set_autosuspend(struct device *dev, struct device_attribute *attr,
 346                 const char *buf, size_t count)
 347 {
 348         struct usb_device *udev = to_usb_device(dev);
 349         int value, old_delay;
 350         int rc;
 351
 352         if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/HZ ||
 353                         value <= - INT_MAX/HZ)
 354                 return -EINVAL;
 355         value *= HZ;
 356
 357         usb_lock_device(udev);
 358         old_delay = udev->autosuspend_delay;
 359         udev->autosuspend_delay = value;
 360
 361         if (old_delay < 0) {    /* Autosuspend wasn't allowed */
 362                 if (value >= 0)
 363                         usb_autosuspend_device(udev);
 364         } else {                /* Autosuspend was allowed */
 365                 if (value < 0) {
 366                         rc = usb_autoresume_device(udev);
 367                         if (rc < 0) {
 368                                 count = rc;
 369                                 udev->autosuspend_delay = old_delay;
 370                         }
 371                 } else {
 372                         usb_try_autosuspend_device(udev);
 373                 }
 374         }
 375
 376         usb_unlock_device(udev);
 377         return count;
 378 }
 379
 380 static DEVICE_ATTR(autosuspend, S_IRUGO | S_IWUSR,
 381                 show_autosuspend, set_autosuspend);
 382
 383 static const char on_string[] = "on";
 384 static const char auto_string[] = "auto";
 385
 386 static ssize_t
 387 show_level(struct device *dev, struct device_attribute *attr, char *buf)
 388 {
 389         struct usb_device *udev = to_usb_device(dev);
 390         const char *p = auto_string;
 391
 392         if (udev->state != USB_STATE_SUSPENDED && udev->autosuspend_disabled)
 393                 p = on_string;
 394         return sprintf(buf, "%s\n", p);
 395 }
 396
 397 static ssize_t
 398 set_level(struct device *dev, struct device_attribute *attr,
 399                 const char *buf, size_t count)
 400 {
 401         struct usb_device *udev = to_usb_device(dev);
 402         int len = count;
 403         char *cp;
 404         int rc;
 405
 406         cp = memchr(buf, '\n', count);
 407         if (cp)
 408                 len = cp - buf;
 409
 410         usb_lock_device(udev);
 411
 412         if (len == sizeof on_string - 1 &&
 413                         strncmp(buf, on_string, len) == 0)
 414                 rc = usb_disable_autosuspend(udev);
 415
 416         else if (len == sizeof auto_string - 1 &&
 417                         strncmp(buf, auto_string, len) == 0)
 418                 rc = usb_enable_autosuspend(udev);
 419
 420         else
 421                 rc = -EINVAL;
 422
 423         usb_unlock_device(udev);
 424         return (rc < 0 ? rc : count);
 425 }
 426
 427 static DEVICE_ATTR(level, S_IRUGO | S_IWUSR, show_level, set_level);
 428
 429 static int add_power_attributes(struct device *dev)
 430 {
 431         int rc = 0;
 432
 433         if (is_usb_device(dev)) {
 434                 rc = sysfs_add_file_to_group(&dev->kobj,
 435                                 &dev_attr_autosuspend.attr,
 436                                 power_group);
 437                 if (rc == 0)
 438                         rc = sysfs_add_file_to_group(&dev->kobj,
 439                                         &dev_attr_level.attr,
 440                                         power_group);
 441                 if (rc == 0)
 442                         rc = sysfs_add_file_to_group(&dev->kobj,
 443                                         &dev_attr_connected_duration.attr,
 444                                         power_group);
 445                 if (rc == 0)
 446                         rc = sysfs_add_file_to_group(&dev->kobj,
 447                                         &dev_attr_active_duration.attr,
 448                                         power_group);
 449         }
 450         return rc;
 451 }
 452
 453 static void remove_power_attributes(struct device *dev)
 454 {
 455         sysfs_remove_file_from_group(&dev->kobj,
 456                         &dev_attr_active_duration.attr,
 457                         power_group);
 458         sysfs_remove_file_from_group(&dev->kobj,
 459                         &dev_attr_connected_duration.attr,
 460                         power_group);
 461         sysfs_remove_file_from_group(&dev->kobj,
 462                         &dev_attr_level.attr,
 463                         power_group);
 464         sysfs_remove_file_from_group(&dev->kobj,
 465                         &dev_attr_autosuspend.attr,
 466                         power_group);
 467 }
 468
 469 #else
 470
 471 #define add_power_attributes(dev)       0
 472 #define remove_power_attributes(dev)    do {} while (0)
 473
 474 #endif  /* CONFIG_USB_SUSPEND */
 475
 476
 477 /* Descriptor fields */
 478 #define usb_descriptor_attr_le16(field, format_string)                  \
 479 static ssize_t                                                          \
 480 show_##field(struct device *dev, struct device_attribute *attr, \
 481                 char *buf)                                              \
 482 {                                                                       \
 483         struct usb_device *udev;                                        \
 484                                                                         \
 485         udev = to_usb_device(dev);                                      \
 486         return sprintf(buf, format_string,                              \
 487                         le16_to_cpu(udev->descriptor.field));           \
 488 }                                                                       \
 489 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
 490
 491 usb_descriptor_attr_le16(idVendor, "%04x\n")
 492 usb_descriptor_attr_le16(idProduct, "%04x\n")
 493 usb_descriptor_attr_le16(bcdDevice, "%04x\n")
 494
 495 #define usb_descriptor_attr(field, format_string)                       \
 496 static ssize_t                                                          \
 497 show_##field(struct device *dev, struct device_attribute *attr, \
 498                 char *buf)                                              \
 499 {                                                                       \
 500         struct usb_device *udev;                                        \
 501                                                                         \
 502         udev = to_usb_device(dev);                                      \
 503         return sprintf(buf, format_string, udev->descriptor.field);     \
 504 }                                                                       \
 505 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
 506
 507 usb_descriptor_attr(bDeviceClass, "%02x\n")
 508 usb_descriptor_attr(bDeviceSubClass, "%02x\n")
 509 usb_descriptor_attr(bDeviceProtocol, "%02x\n")
 510 usb_descriptor_attr(bNumConfigurations, "%d\n")
 511 usb_descriptor_attr(bMaxPacketSize0, "%d\n")
 512
 513
 514
 515 /* show if the device is authorized (1) or not (0) */
 516 static ssize_t usb_dev_authorized_show(struct device *dev,
 517                                        struct device_attribute *attr,
 518                                        char *buf)
 519 {
 520         struct usb_device *usb_dev = to_usb_device(dev);
 521         return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized);
 522 }
 523
 524
 525 /*
 526  * Authorize a device to be used in the system
 527  *
 528  * Writing a 0 deauthorizes the device, writing a 1 authorizes it.
 529  */
 530 static ssize_t usb_dev_authorized_store(struct device *dev,
 531                                         struct device_attribute *attr,
 532                                         const char *buf, size_t size)
 533 {
 534         ssize_t result;
 535         struct usb_device *usb_dev = to_usb_device(dev);
 536         unsigned val;
 537         result = sscanf(buf, "%u\n", &val);
 538         if (result != 1)
 539                 result = -EINVAL;
 540         else if (val == 0)
 541                 result = usb_deauthorize_device(usb_dev);
 542         else
 543                 result = usb_authorize_device(usb_dev);
 544         return result < 0? result : size;
 545 }
 546
 547 static DEVICE_ATTR(authorized, 0644,
 548             usb_dev_authorized_show, usb_dev_authorized_store);
 549
 550 /* "Safely remove a device" */
 551 static ssize_t usb_remove_store(struct device *dev,
 552                 struct device_attribute *attr,
 553                 const char *buf, size_t count)
 554 {
 555         struct usb_device *udev = to_usb_device(dev);
 556         int rc = 0;
 557
 558         usb_lock_device(udev);
 559         if (udev->state != USB_STATE_NOTATTACHED) {
 560
 561                 /* To avoid races, first unconfigure and then remove */
 562                 usb_set_configuration(udev, -1);
 563                 rc = usb_remove_device(udev);
 564         }
 565         if (rc == 0)
 566                 rc = count;
 567         usb_unlock_device(udev);
 568         return rc;
 569 }
 570 static DEVICE_ATTR(remove, 0200, NULL, usb_remove_store);
 571
 572
 573 static struct attribute *dev_attrs[] = {
 574         /* current configuration's attributes */
 575         &dev_attr_configuration.attr,
 576         &dev_attr_bNumInterfaces.attr,
 577         &dev_attr_bConfigurationValue.attr,
 578         &dev_attr_bmAttributes.attr,
 579         &dev_attr_bMaxPower.attr,
 580         /* device attributes */
 581         &dev_attr_urbnum.attr,
 582         &dev_attr_idVendor.attr,
 583         &dev_attr_idProduct.attr,
 584         &dev_attr_bcdDevice.attr,
 585         &dev_attr_bDeviceClass.attr,
 586         &dev_attr_bDeviceSubClass.attr,
 587         &dev_attr_bDeviceProtocol.attr,
 588         &dev_attr_bNumConfigurations.attr,
 589         &dev_attr_bMaxPacketSize0.attr,
 590         &dev_attr_speed.attr,
 591         &dev_attr_busnum.attr,
 592         &dev_attr_devnum.attr,
 593         &dev_attr_devpath.attr,
 594         &dev_attr_version.attr,
 595         &dev_attr_maxchild.attr,
 596         &dev_attr_quirks.attr,
 597         &dev_attr_avoid_reset_quirk.attr,
 598         &dev_attr_authorized.attr,
 599         &dev_attr_remove.attr,
 600         NULL,
 601 };
 602 static struct attribute_group dev_attr_grp = {
 603         .attrs = dev_attrs,
 604 };
 605
 606 /* When modifying this list, be sure to modify dev_string_attrs_are_visible()
 607  * accordingly.
 608  */
 609 static struct attribute *dev_string_attrs[] = {
 610         &dev_attr_manufacturer.attr,
 611         &dev_attr_product.attr,
 612         &dev_attr_serial.attr,
 613         NULL
 614 };
 615
 616 static mode_t dev_string_attrs_are_visible(struct kobject *kobj,
 617                 struct attribute *a, int n)
 618 {
 619         struct device *dev = container_of(kobj, struct device, kobj);
 620         struct usb_device *udev = to_usb_device(dev);
 621
 622         if (a == &dev_attr_manufacturer.attr) {
 623                 if (udev->manufacturer == NULL)
 624                         return 0;
 625         } else if (a == &dev_attr_product.attr) {
 626                 if (udev->product == NULL)
 627                         return 0;
 628         } else if (a == &dev_attr_serial.attr) {
 629                 if (udev->serial == NULL)
 630                         return 0;
 631         }
 632         return a->mode;
 633 }
 634
 635 static struct attribute_group dev_string_attr_grp = {
 636         .attrs =        dev_string_attrs,
 637         .is_visible =   dev_string_attrs_are_visible,
 638 };
 639
 640 const struct attribute_group *usb_device_groups[] = {
 641         &dev_attr_grp,
 642         &dev_string_attr_grp,
 643         NULL
 644 };
 645
 646 /* Binary descriptors */
 647
 648 static ssize_t
 649 read_descriptors(struct kobject *kobj, struct bin_attribute *attr,
 650                 char *buf, loff_t off, size_t count)
 651 {
 652         struct device *dev = container_of(kobj, struct device, kobj);
 653         struct usb_device *udev = to_usb_device(dev);
 654         size_t nleft = count;
 655         size_t srclen, n;
 656         int cfgno;
 657         void *src;
 658
 659         /* The binary attribute begins with the device descriptor.
 660          * Following that are the raw descriptor entries for all the
 661          * configurations (config plus subsidiary descriptors).
 662          */
 663         for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations &&
 664                         nleft > 0; ++cfgno) {
 665                 if (cfgno < 0) {
 666                         src = &udev->descriptor;
 667                         srclen = sizeof(struct usb_device_descriptor);
 668                 } else {
 669                         src = udev->rawdescriptors[cfgno];
 670                         srclen = __le16_to_cpu(udev->config[cfgno].desc.
 671                                         wTotalLength);
 672                 }
 673                 if (off < srclen) {
 674                         n = min(nleft, srclen - (size_t) off);
 675                         memcpy(buf, src + off, n);
 676                         nleft -= n;
 677                         buf += n;
 678                         off = 0;
 679                 } else {
 680                         off -= srclen;
 681                 }
 682         }
 683         return count - nleft;
 684 }
 685
 686 static struct bin_attribute dev_bin_attr_descriptors = {
 687         .attr = {.name = "descriptors", .mode = 0444},
 688         .read = read_descriptors,
 689         .size = 18 + 65535,     /* dev descr + max-size raw descriptor */
 690 };
 691
 692 int usb_create_sysfs_dev_files(struct usb_device *udev)
 693 {
 694         struct device *dev = &udev->dev;
 695         int retval;
 696
 697         retval = device_create_bin_file(dev, &dev_bin_attr_descriptors);
 698         if (retval)
 699                 goto error;
 700
 701         retval = add_persist_attributes(dev);
 702         if (retval)
 703                 goto error;
 704
 705         retval = add_power_attributes(dev);
 706         if (retval)
 707                 goto error;
 708         return retval;
 709 error:
 710         usb_remove_sysfs_dev_files(udev);
 711         return retval;
 712 }
 713
 714 void usb_remove_sysfs_dev_files(struct usb_device *udev)
 715 {
 716         struct device *dev = &udev->dev;
 717
 718         remove_power_attributes(dev);
 719         remove_persist_attributes(dev);
 720         device_remove_bin_file(dev, &dev_bin_attr_descriptors);
 721 }
 722
 723 /* Interface Accociation Descriptor fields */
 724 #define usb_intf_assoc_attr(field, format_string)                       \
 725 static ssize_t                                                          \
 726 show_iad_##field(struct device *dev, struct device_attribute *attr,     \
 727                 char *buf)                                              \
 728 {                                                                       \
 729         struct usb_interface *intf = to_usb_interface(dev);             \
 730                                                                         \
 731         return sprintf(buf, format_string,                              \
 732                         intf->intf_assoc->field);                       \
 733 }                                                                       \
 734 static DEVICE_ATTR(iad_##field, S_IRUGO, show_iad_##field, NULL);
 735
 736 usb_intf_assoc_attr(bFirstInterface, "%02x\n")
 737 usb_intf_assoc_attr(bInterfaceCount, "%02d\n")
 738 usb_intf_assoc_attr(bFunctionClass, "%02x\n")
 739 usb_intf_assoc_attr(bFunctionSubClass, "%02x\n")
 740 usb_intf_assoc_attr(bFunctionProtocol, "%02x\n")
 741
 742 /* Interface fields */
 743 #define usb_intf_attr(field, format_string)                             \
 744 static ssize_t                                                          \
 745 show_##field(struct device *dev, struct device_attribute *attr, \
 746                 char *buf)                                              \
 747 {                                                                       \
 748         struct usb_interface *intf = to_usb_interface(dev);             \
 749                                                                         \
 750         return sprintf(buf, format_string,                              \
 751                         intf->cur_altsetting->desc.field);              \
 752 }                                                                       \
 753 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
 754
 755 usb_intf_attr(bInterfaceNumber, "%02x\n")
 756 usb_intf_attr(bAlternateSetting, "%2d\n")
 757 usb_intf_attr(bNumEndpoints, "%02x\n")
 758 usb_intf_attr(bInterfaceClass, "%02x\n")
 759 usb_intf_attr(bInterfaceSubClass, "%02x\n")
 760 usb_intf_attr(bInterfaceProtocol, "%02x\n")
 761
 762 static ssize_t show_interface_string(struct device *dev,
 763                 struct device_attribute *attr, char *buf)
 764 {
 765         struct usb_interface *intf;
 766         char *string;
 767
 768         intf = to_usb_interface(dev);
 769         string = intf->cur_altsetting->string;
 770         barrier();              /* The altsetting might change! */
 771
 772         if (!string)
 773                 return 0;
 774         return sprintf(buf, "%s\n", string);
 775 }
 776 static DEVICE_ATTR(interface, S_IRUGO, show_interface_string, NULL);
 777
 778 static ssize_t show_modalias(struct device *dev,
 779                 struct device_attribute *attr, char *buf)
 780 {
 781         struct usb_interface *intf;
 782         struct usb_device *udev;
 783         struct usb_host_interface *alt;
 784
 785         intf = to_usb_interface(dev);
 786         udev = interface_to_usbdev(intf);
 787         alt = intf->cur_altsetting;
 788
 789         return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
 790                         "ic%02Xisc%02Xip%02X\n",
 791                         le16_to_cpu(udev->descriptor.idVendor),
 792                         le16_to_cpu(udev->descriptor.idProduct),
 793                         le16_to_cpu(udev->descriptor.bcdDevice),
 794                         udev->descriptor.bDeviceClass,
 795                         udev->descriptor.bDeviceSubClass,
 796                         udev->descriptor.bDeviceProtocol,
 797                         alt->desc.bInterfaceClass,
 798                         alt->desc.bInterfaceSubClass,
 799                         alt->desc.bInterfaceProtocol);
 800 }
 801 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
 802
 803 static ssize_t show_supports_autosuspend(struct device *dev,
 804                 struct device_attribute *attr, char *buf)
 805 {
 806         struct usb_interface *intf;
 807         struct usb_device *udev;
 808         int ret;
 809
 810         intf = to_usb_interface(dev);
 811         udev = interface_to_usbdev(intf);
 812
 813         usb_lock_device(udev);
 814         /* Devices will be autosuspended even when an interface isn't claimed */
 815         if (!intf->dev.driver ||
 816                         to_usb_driver(intf->dev.driver)->supports_autosuspend)
 817                 ret = sprintf(buf, "%u\n", 1);
 818         else
 819                 ret = sprintf(buf, "%u\n", 0);
 820         usb_unlock_device(udev);
 821
 822         return ret;
 823 }
 824 static DEVICE_ATTR(supports_autosuspend, S_IRUGO, show_supports_autosuspend, NULL);
 825
 826 static struct attribute *intf_attrs[] = {
 827         &dev_attr_bInterfaceNumber.attr,
 828         &dev_attr_bAlternateSetting.attr,
 829         &dev_attr_bNumEndpoints.attr,
 830         &dev_attr_bInterfaceClass.attr,
 831         &dev_attr_bInterfaceSubClass.attr,
 832         &dev_attr_bInterfaceProtocol.attr,
 833         &dev_attr_modalias.attr,
 834         &dev_attr_supports_autosuspend.attr,
 835         NULL,
 836 };
 837 static struct attribute_group intf_attr_grp = {
 838         .attrs = intf_attrs,
 839 };
 840
 841 static struct attribute *intf_assoc_attrs[] = {
 842         &dev_attr_iad_bFirstInterface.attr,
 843         &dev_attr_iad_bInterfaceCount.attr,
 844         &dev_attr_iad_bFunctionClass.attr,
 845         &dev_attr_iad_bFunctionSubClass.attr,
 846         &dev_attr_iad_bFunctionProtocol.attr,
 847         NULL,
 848 };
 849
 850 static mode_t intf_assoc_attrs_are_visible(struct kobject *kobj,
 851                 struct attribute *a, int n)
 852 {
 853         struct device *dev = container_of(kobj, struct device, kobj);
 854         struct usb_interface *intf = to_usb_interface(dev);
 855
 856         if (intf->intf_assoc == NULL)
 857                 return 0;
 858         return a->mode;
 859 }
 860
 861 static struct attribute_group intf_assoc_attr_grp = {
 862         .attrs =        intf_assoc_attrs,
 863         .is_visible =   intf_assoc_attrs_are_visible,
 864 };
 865
 866 const struct attribute_group *usb_interface_groups[] = {
 867         &intf_attr_grp,
 868         &intf_assoc_attr_grp,
 869         NULL
 870 };
 871
 872 int usb_create_sysfs_intf_files(struct usb_interface *intf)
 873 {
 874         struct usb_device *udev = interface_to_usbdev(intf);
 875         struct usb_host_interface *alt = intf->cur_altsetting;
 876         int retval;
 877
 878         if (intf->sysfs_files_created || intf->unregistering)
 879                 return 0;
 880
 881         if (alt->string == NULL &&
 882                         !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS))
 883                 alt->string = usb_cache_string(udev, alt->desc.iInterface);
 884         if (alt->string)
 885                 retval = device_create_file(&intf->dev, &dev_attr_interface);
 886         intf->sysfs_files_created = 1;
 887         return 0;
 888 }
 889
 890 void usb_remove_sysfs_intf_files(struct usb_interface *intf)
 891 {
 892         if (!intf->sysfs_files_created)
 893                 return;
 894
 895         device_remove_file(&intf->dev, &dev_attr_interface);
 896         intf->sysfs_files_created = 0;
 897 }