err.no Git - linux-2.6/blob - 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/usb.h>
  15 #include "usb.h"
  16
  17 /* Active configuration fields */
  18 #define usb_actconfig_show(field, multiplier, format_string)            \
  19 static ssize_t  show_##field(struct device *dev,                        \
  20                 struct device_attribute *attr, char *buf)               \
  21 {                                                                       \
  22         struct usb_device *udev;                                        \
  23         struct usb_host_config *actconfig;                              \
  24                                                                         \
  25         udev = to_usb_device(dev);                                      \
  26         actconfig = udev->actconfig;                                    \
  27         if (actconfig)                                                  \
  28                 return sprintf(buf, format_string,                      \
  29                                 actconfig->desc.field * multiplier);    \
  30         else                                                            \
  31                 return 0;                                               \
  32 }                                                                       \
  33
  34 #define usb_actconfig_attr(field, multiplier, format_string)            \
  35 usb_actconfig_show(field, multiplier, format_string)                    \
  36 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
  37
  38 usb_actconfig_attr(bNumInterfaces, 1, "%2d\n")
  39 usb_actconfig_attr(bmAttributes, 1, "%2x\n")
  40 usb_actconfig_attr(bMaxPower, 2, "%3dmA\n")
  41
  42 static ssize_t show_configuration_string(struct device *dev,
  43                 struct device_attribute *attr, char *buf)
  44 {
  45         struct usb_device *udev;
  46         struct usb_host_config *actconfig;
  47
  48         udev = to_usb_device(dev);
  49         actconfig = udev->actconfig;
  50         if ((!actconfig) || (!actconfig->string))
  51                 return 0;
  52         return sprintf(buf, "%s\n", actconfig->string);
  53 }
  54 static DEVICE_ATTR(configuration, S_IRUGO, show_configuration_string, NULL);
  55
  56 /* configuration value is always present, and r/w */
  57 usb_actconfig_show(bConfigurationValue, 1, "%u\n");
  58
  59 static ssize_t
  60 set_bConfigurationValue(struct device *dev, struct device_attribute *attr,
  61                 const char *buf, size_t count)
  62 {
  63         struct usb_device       *udev = to_usb_device(dev);
  64         int                     config, value;
  65
  66         if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255)
  67                 return -EINVAL;
  68         usb_lock_device(udev);
  69         value = usb_set_configuration(udev, config);
  70         usb_unlock_device(udev);
  71         return (value < 0) ? value : count;
  72 }
  73
  74 static DEVICE_ATTR(bConfigurationValue, S_IRUGO | S_IWUSR,
  75                 show_bConfigurationValue, set_bConfigurationValue);
  76
  77 /* String fields */
  78 #define usb_string_attr(name)                                           \
  79 static ssize_t  show_##name(struct device *dev,                         \
  80                 struct device_attribute *attr, char *buf)               \
  81 {                                                                       \
  82         struct usb_device *udev;                                        \
  83                                                                         \
  84         udev = to_usb_device(dev);                                      \
  85         return sprintf(buf, "%s\n", udev->name);                        \
  86 }                                                                       \
  87 static DEVICE_ATTR(name, S_IRUGO, show_##name, NULL);
  88
  89 usb_string_attr(product);
  90 usb_string_attr(manufacturer);
  91 usb_string_attr(serial);
  92
  93 static ssize_t
  94 show_speed(struct device *dev, struct device_attribute *attr, char *buf)
  95 {
  96         struct usb_device *udev;
  97         char *speed;
  98
  99         udev = to_usb_device(dev);
 100
 101         switch (udev->speed) {
 102         case USB_SPEED_LOW:
 103                 speed = "1.5";
 104                 break;
 105         case USB_SPEED_UNKNOWN:
 106         case USB_SPEED_FULL:
 107                 speed = "12";
 108                 break;
 109         case USB_SPEED_HIGH:
 110                 speed = "480";
 111                 break;
 112         default:
 113                 speed = "unknown";
 114         }
 115         return sprintf(buf, "%s\n", speed);
 116 }
 117 static DEVICE_ATTR(speed, S_IRUGO, show_speed, NULL);
 118
 119 static ssize_t
 120 show_devnum(struct device *dev, struct device_attribute *attr, char *buf)
 121 {
 122         struct usb_device *udev;
 123
 124         udev = to_usb_device(dev);
 125         return sprintf(buf, "%d\n", udev->devnum);
 126 }
 127 static DEVICE_ATTR(devnum, S_IRUGO, show_devnum, NULL);
 128
 129 static ssize_t
 130 show_version(struct device *dev, struct device_attribute *attr, char *buf)
 131 {
 132         struct usb_device *udev;
 133         u16 bcdUSB;
 134
 135         udev = to_usb_device(dev);
 136         bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB);
 137         return sprintf(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff);
 138 }
 139 static DEVICE_ATTR(version, S_IRUGO, show_version, NULL);
 140
 141 static ssize_t
 142 show_maxchild(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->maxchild);
 148 }
 149 static DEVICE_ATTR(maxchild, S_IRUGO, show_maxchild, NULL);
 150
 151 static ssize_t
 152 show_quirks(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, "0x%x\n", udev->quirks);
 158 }
 159 static DEVICE_ATTR(quirks, S_IRUGO, show_quirks, NULL);
 160
 161 /* Descriptor fields */
 162 #define usb_descriptor_attr_le16(field, format_string)                  \
 163 static ssize_t                                                          \
 164 show_##field(struct device *dev, struct device_attribute *attr, \
 165                 char *buf)                                              \
 166 {                                                                       \
 167         struct usb_device *udev;                                        \
 168                                                                         \
 169         udev = to_usb_device(dev);                                      \
 170         return sprintf(buf, format_string,                              \
 171                         le16_to_cpu(udev->descriptor.field));           \
 172 }                                                                       \
 173 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
 174
 175 usb_descriptor_attr_le16(idVendor, "%04x\n")
 176 usb_descriptor_attr_le16(idProduct, "%04x\n")
 177 usb_descriptor_attr_le16(bcdDevice, "%04x\n")
 178
 179 #define usb_descriptor_attr(field, format_string)                       \
 180 static ssize_t                                                          \
 181 show_##field(struct device *dev, struct device_attribute *attr, \
 182                 char *buf)                                              \
 183 {                                                                       \
 184         struct usb_device *udev;                                        \
 185                                                                         \
 186         udev = to_usb_device(dev);                                      \
 187         return sprintf(buf, format_string, udev->descriptor.field);     \
 188 }                                                                       \
 189 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
 190
 191 usb_descriptor_attr(bDeviceClass, "%02x\n")
 192 usb_descriptor_attr(bDeviceSubClass, "%02x\n")
 193 usb_descriptor_attr(bDeviceProtocol, "%02x\n")
 194 usb_descriptor_attr(bNumConfigurations, "%d\n")
 195 usb_descriptor_attr(bMaxPacketSize0, "%d\n")
 196
 197 static struct attribute *dev_attrs[] = {
 198         /* current configuration's attributes */
 199         &dev_attr_configuration.attr,
 200         &dev_attr_bNumInterfaces.attr,
 201         &dev_attr_bConfigurationValue.attr,
 202         &dev_attr_bmAttributes.attr,
 203         &dev_attr_bMaxPower.attr,
 204         /* device attributes */
 205         &dev_attr_idVendor.attr,
 206         &dev_attr_idProduct.attr,
 207         &dev_attr_bcdDevice.attr,
 208         &dev_attr_bDeviceClass.attr,
 209         &dev_attr_bDeviceSubClass.attr,
 210         &dev_attr_bDeviceProtocol.attr,
 211         &dev_attr_bNumConfigurations.attr,
 212         &dev_attr_bMaxPacketSize0.attr,
 213         &dev_attr_speed.attr,
 214         &dev_attr_devnum.attr,
 215         &dev_attr_version.attr,
 216         &dev_attr_maxchild.attr,
 217         &dev_attr_quirks.attr,
 218         NULL,
 219 };
 220 static struct attribute_group dev_attr_grp = {
 221         .attrs = dev_attrs,
 222 };
 223
 224 int usb_create_sysfs_dev_files(struct usb_device *udev)
 225 {
 226         struct device *dev = &udev->dev;
 227         int retval;
 228
 229         retval = sysfs_create_group(&dev->kobj, &dev_attr_grp);
 230         if (retval)
 231                 return retval;
 232
 233         if (udev->manufacturer) {
 234                 retval = device_create_file(dev, &dev_attr_manufacturer);
 235                 if (retval)
 236                         goto error;
 237         }
 238         if (udev->product) {
 239                 retval = device_create_file(dev, &dev_attr_product);
 240                 if (retval)
 241                         goto error;
 242         }
 243         if (udev->serial) {
 244                 retval = device_create_file(dev, &dev_attr_serial);
 245                 if (retval)
 246                         goto error;
 247         }
 248         retval = usb_create_ep_files(dev, &udev->ep0, udev);
 249         if (retval)
 250                 goto error;
 251         return 0;
 252 error:
 253         usb_remove_ep_files(&udev->ep0);
 254         device_remove_file(dev, &dev_attr_manufacturer);
 255         device_remove_file(dev, &dev_attr_product);
 256         device_remove_file(dev, &dev_attr_serial);
 257         return retval;
 258 }
 259
 260 void usb_remove_sysfs_dev_files(struct usb_device *udev)
 261 {
 262         struct device *dev = &udev->dev;
 263
 264         usb_remove_ep_files(&udev->ep0);
 265         sysfs_remove_group(&dev->kobj, &dev_attr_grp);
 266
 267         if (udev->manufacturer)
 268                 device_remove_file(dev, &dev_attr_manufacturer);
 269         if (udev->product)
 270                 device_remove_file(dev, &dev_attr_product);
 271         if (udev->serial)
 272                 device_remove_file(dev, &dev_attr_serial);
 273 }
 274
 275 /* Interface fields */
 276 #define usb_intf_attr(field, format_string)                             \
 277 static ssize_t                                                          \
 278 show_##field(struct device *dev, struct device_attribute *attr, \
 279                 char *buf)                                              \
 280 {                                                                       \
 281         struct usb_interface *intf = to_usb_interface(dev);             \
 282                                                                         \
 283         return sprintf(buf, format_string,                              \
 284                         intf->cur_altsetting->desc.field);              \
 285 }                                                                       \
 286 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
 287
 288 usb_intf_attr(bInterfaceNumber, "%02x\n")
 289 usb_intf_attr(bAlternateSetting, "%2d\n")
 290 usb_intf_attr(bNumEndpoints, "%02x\n")
 291 usb_intf_attr(bInterfaceClass, "%02x\n")
 292 usb_intf_attr(bInterfaceSubClass, "%02x\n")
 293 usb_intf_attr(bInterfaceProtocol, "%02x\n")
 294
 295 static ssize_t show_interface_string(struct device *dev,
 296                 struct device_attribute *attr, char *buf)
 297 {
 298         struct usb_interface *intf;
 299         struct usb_device *udev;
 300         int len;
 301
 302         intf = to_usb_interface(dev);
 303         udev = interface_to_usbdev(intf);
 304         len = snprintf(buf, 256, "%s", intf->cur_altsetting->string);
 305         if (len < 0)
 306                 return 0;
 307         buf[len] = '\n';
 308         buf[len+1] = 0;
 309         return len+1;
 310 }
 311 static DEVICE_ATTR(interface, S_IRUGO, show_interface_string, NULL);
 312
 313 static ssize_t show_modalias(struct device *dev,
 314                 struct device_attribute *attr, char *buf)
 315 {
 316         struct usb_interface *intf;
 317         struct usb_device *udev;
 318         struct usb_host_interface *alt;
 319
 320         intf = to_usb_interface(dev);
 321         udev = interface_to_usbdev(intf);
 322         alt = intf->cur_altsetting;
 323
 324         return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
 325                         "ic%02Xisc%02Xip%02X\n",
 326                         le16_to_cpu(udev->descriptor.idVendor),
 327                         le16_to_cpu(udev->descriptor.idProduct),
 328                         le16_to_cpu(udev->descriptor.bcdDevice),
 329                         udev->descriptor.bDeviceClass,
 330                         udev->descriptor.bDeviceSubClass,
 331                         udev->descriptor.bDeviceProtocol,
 332                         alt->desc.bInterfaceClass,
 333                         alt->desc.bInterfaceSubClass,
 334                         alt->desc.bInterfaceProtocol);
 335 }
 336 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
 337
 338 static struct attribute *intf_attrs[] = {
 339         &dev_attr_bInterfaceNumber.attr,
 340         &dev_attr_bAlternateSetting.attr,
 341         &dev_attr_bNumEndpoints.attr,
 342         &dev_attr_bInterfaceClass.attr,
 343         &dev_attr_bInterfaceSubClass.attr,
 344         &dev_attr_bInterfaceProtocol.attr,
 345         &dev_attr_modalias.attr,
 346         NULL,
 347 };
 348 static struct attribute_group intf_attr_grp = {
 349         .attrs = intf_attrs,
 350 };
 351
 352 static inline void usb_create_intf_ep_files(struct usb_interface *intf,
 353                 struct usb_device *udev)
 354 {
 355         struct usb_host_interface *iface_desc;
 356         int i;
 357
 358         iface_desc = intf->cur_altsetting;
 359         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i)
 360                 usb_create_ep_files(&intf->dev, &iface_desc->endpoint[i],
 361                                 udev);
 362 }
 363
 364 static inline void usb_remove_intf_ep_files(struct usb_interface *intf)
 365 {
 366         struct usb_host_interface *iface_desc;
 367         int i;
 368
 369         iface_desc = intf->cur_altsetting;
 370         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i)
 371                 usb_remove_ep_files(&iface_desc->endpoint[i]);
 372 }
 373
 374 int usb_create_sysfs_intf_files(struct usb_interface *intf)
 375 {
 376         struct usb_device *udev = interface_to_usbdev(intf);
 377         struct usb_host_interface *alt = intf->cur_altsetting;
 378         int retval;
 379
 380         retval = sysfs_create_group(&intf->dev.kobj, &intf_attr_grp);
 381         if (retval)
 382                 goto error;
 383
 384         if (alt->string == NULL)
 385                 alt->string = usb_cache_string(udev, alt->desc.iInterface);
 386         if (alt->string)
 387                 retval = device_create_file(&intf->dev, &dev_attr_interface);
 388         usb_create_intf_ep_files(intf, udev);
 389         return 0;
 390 error:
 391         if (alt->string)
 392                 device_remove_file(&intf->dev, &dev_attr_interface);
 393         sysfs_remove_group(&intf->dev.kobj, &intf_attr_grp);
 394         usb_remove_intf_ep_files(intf);
 395         return retval;
 396 }
 397
 398 void usb_remove_sysfs_intf_files(struct usb_interface *intf)
 399 {
 400         usb_remove_intf_ep_files(intf);
 401         sysfs_remove_group(&intf->dev.kobj, &intf_attr_grp);
 402
 403         if (intf->cur_altsetting->string)
 404                 device_remove_file(&intf->dev, &dev_attr_interface);
 405 }