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 = udev = to_usb_device (dev);
  64         int                     config, value;
  65
  66         if (sscanf (buf, "%u", &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 /* Descriptor fields */
 152 #define usb_descriptor_attr_le16(field, format_string)                  \
 153 static ssize_t                                                          \
 154 show_##field (struct device *dev, struct device_attribute *attr,        \
 155                 char *buf)                                              \
 156 {                                                                       \
 157         struct usb_device *udev;                                        \
 158                                                                         \
 159         udev = to_usb_device (dev);                                     \
 160         return sprintf (buf, format_string,                             \
 161                         le16_to_cpu(udev->descriptor.field));           \
 162 }                                                                       \
 163 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
 164
 165 usb_descriptor_attr_le16(idVendor, "%04x\n")
 166 usb_descriptor_attr_le16(idProduct, "%04x\n")
 167 usb_descriptor_attr_le16(bcdDevice, "%04x\n")
 168
 169 #define usb_descriptor_attr(field, format_string)                       \
 170 static ssize_t                                                          \
 171 show_##field (struct device *dev, struct device_attribute *attr,        \
 172                 char *buf)                                              \
 173 {                                                                       \
 174         struct usb_device *udev;                                        \
 175                                                                         \
 176         udev = to_usb_device (dev);                                     \
 177         return sprintf (buf, format_string, udev->descriptor.field);    \
 178 }                                                                       \
 179 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
 180
 181 usb_descriptor_attr (bDeviceClass, "%02x\n")
 182 usb_descriptor_attr (bDeviceSubClass, "%02x\n")
 183 usb_descriptor_attr (bDeviceProtocol, "%02x\n")
 184 usb_descriptor_attr (bNumConfigurations, "%d\n")
 185 usb_descriptor_attr (bMaxPacketSize0, "%d\n")
 186
 187 static struct attribute *dev_attrs[] = {
 188         /* current configuration's attributes */
 189         &dev_attr_bNumInterfaces.attr,
 190         &dev_attr_bConfigurationValue.attr,
 191         &dev_attr_bmAttributes.attr,
 192         &dev_attr_bMaxPower.attr,
 193         /* device attributes */
 194         &dev_attr_idVendor.attr,
 195         &dev_attr_idProduct.attr,
 196         &dev_attr_bcdDevice.attr,
 197         &dev_attr_bDeviceClass.attr,
 198         &dev_attr_bDeviceSubClass.attr,
 199         &dev_attr_bDeviceProtocol.attr,
 200         &dev_attr_bNumConfigurations.attr,
 201         &dev_attr_bMaxPacketSize0.attr,
 202         &dev_attr_speed.attr,
 203         &dev_attr_devnum.attr,
 204         &dev_attr_version.attr,
 205         &dev_attr_maxchild.attr,
 206         NULL,
 207 };
 208 static struct attribute_group dev_attr_grp = {
 209         .attrs = dev_attrs,
 210 };
 211
 212 void usb_create_sysfs_dev_files (struct usb_device *udev)
 213 {
 214         struct device *dev = &udev->dev;
 215
 216         sysfs_create_group(&dev->kobj, &dev_attr_grp);
 217
 218         if (udev->manufacturer)
 219                 device_create_file (dev, &dev_attr_manufacturer);
 220         if (udev->product)
 221                 device_create_file (dev, &dev_attr_product);
 222         if (udev->serial)
 223                 device_create_file (dev, &dev_attr_serial);
 224         device_create_file (dev, &dev_attr_configuration);
 225         usb_create_ep_files(dev, &udev->ep0, udev);
 226 }
 227
 228 void usb_remove_sysfs_dev_files (struct usb_device *udev)
 229 {
 230         struct device *dev = &udev->dev;
 231
 232         usb_remove_ep_files(&udev->ep0);
 233         sysfs_remove_group(&dev->kobj, &dev_attr_grp);
 234
 235         if (udev->manufacturer)
 236                 device_remove_file(dev, &dev_attr_manufacturer);
 237         if (udev->product)
 238                 device_remove_file(dev, &dev_attr_product);
 239         if (udev->serial)
 240                 device_remove_file(dev, &dev_attr_serial);
 241         device_remove_file (dev, &dev_attr_configuration);
 242 }
 243
 244 /* Interface fields */
 245 #define usb_intf_attr(field, format_string)                             \
 246 static ssize_t                                                          \
 247 show_##field (struct device *dev, struct device_attribute *attr,        \
 248                 char *buf)                                              \
 249 {                                                                       \
 250         struct usb_interface *intf = to_usb_interface (dev);            \
 251                                                                         \
 252         return sprintf (buf, format_string,                             \
 253                         intf->cur_altsetting->desc.field);              \
 254 }                                                                       \
 255 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL);
 256
 257 usb_intf_attr (bInterfaceNumber, "%02x\n")
 258 usb_intf_attr (bAlternateSetting, "%2d\n")
 259 usb_intf_attr (bNumEndpoints, "%02x\n")
 260 usb_intf_attr (bInterfaceClass, "%02x\n")
 261 usb_intf_attr (bInterfaceSubClass, "%02x\n")
 262 usb_intf_attr (bInterfaceProtocol, "%02x\n")
 263
 264 static ssize_t show_interface_string(struct device *dev,
 265                 struct device_attribute *attr, char *buf)
 266 {
 267         struct usb_interface *intf;
 268         struct usb_device *udev;
 269         int len;
 270
 271         intf = to_usb_interface (dev);
 272         udev = interface_to_usbdev (intf);
 273         len = snprintf(buf, 256, "%s", intf->cur_altsetting->string);
 274         if (len < 0)
 275                 return 0;
 276         buf[len] = '\n';
 277         buf[len+1] = 0;
 278         return len+1;
 279 }
 280 static DEVICE_ATTR(interface, S_IRUGO, show_interface_string, NULL);
 281
 282 static ssize_t show_modalias(struct device *dev,
 283                 struct device_attribute *attr, char *buf)
 284 {
 285         struct usb_interface *intf;
 286         struct usb_device *udev;
 287         struct usb_host_interface *alt;
 288
 289         intf = to_usb_interface(dev);
 290         udev = interface_to_usbdev(intf);
 291         alt = intf->cur_altsetting;
 292
 293         return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X"
 294                         "ic%02Xisc%02Xip%02X\n",
 295                         le16_to_cpu(udev->descriptor.idVendor),
 296                         le16_to_cpu(udev->descriptor.idProduct),
 297                         le16_to_cpu(udev->descriptor.bcdDevice),
 298                         udev->descriptor.bDeviceClass,
 299                         udev->descriptor.bDeviceSubClass,
 300                         udev->descriptor.bDeviceProtocol,
 301                         alt->desc.bInterfaceClass,
 302                         alt->desc.bInterfaceSubClass,
 303                         alt->desc.bInterfaceProtocol);
 304 }
 305 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL);
 306
 307 static struct attribute *intf_attrs[] = {
 308         &dev_attr_bInterfaceNumber.attr,
 309         &dev_attr_bAlternateSetting.attr,
 310         &dev_attr_bNumEndpoints.attr,
 311         &dev_attr_bInterfaceClass.attr,
 312         &dev_attr_bInterfaceSubClass.attr,
 313         &dev_attr_bInterfaceProtocol.attr,
 314         &dev_attr_modalias.attr,
 315         NULL,
 316 };
 317 static struct attribute_group intf_attr_grp = {
 318         .attrs = intf_attrs,
 319 };
 320
 321 static inline void usb_create_intf_ep_files(struct usb_interface *intf,
 322                 struct usb_device *udev)
 323 {
 324         struct usb_host_interface *iface_desc;
 325         int i;
 326
 327         iface_desc = intf->cur_altsetting;
 328         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i)
 329                 usb_create_ep_files(&intf->dev, &iface_desc->endpoint[i],
 330                                 udev);
 331 }
 332
 333 static inline void usb_remove_intf_ep_files(struct usb_interface *intf)
 334 {
 335         struct usb_host_interface *iface_desc;
 336         int i;
 337
 338         iface_desc = intf->cur_altsetting;
 339         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i)
 340                 usb_remove_ep_files(&iface_desc->endpoint[i]);
 341 }
 342
 343 void usb_create_sysfs_intf_files (struct usb_interface *intf)
 344 {
 345         struct usb_device *udev = interface_to_usbdev(intf);
 346         struct usb_host_interface *alt = intf->cur_altsetting;
 347
 348         sysfs_create_group(&intf->dev.kobj, &intf_attr_grp);
 349
 350         if (alt->string == NULL)
 351                 alt->string = usb_cache_string(udev, alt->desc.iInterface);
 352         if (alt->string)
 353                 device_create_file(&intf->dev, &dev_attr_interface);
 354         usb_create_intf_ep_files(intf, udev);
 355 }
 356
 357 void usb_remove_sysfs_intf_files (struct usb_interface *intf)
 358 {
 359         usb_remove_intf_ep_files(intf);
 360         sysfs_remove_group(&intf->dev.kobj, &intf_attr_grp);
 361
 362         if (intf->cur_altsetting->string)
 363                 device_remove_file(&intf->dev, &dev_attr_interface);
 364 }