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 #ifdef CONFIG_USB_SUSPEND 162 163 static ssize_t 164 show_autosuspend(struct device *dev, struct device_attribute *attr, char *buf) 165 { 166 struct usb_device *udev = to_usb_device(dev); 167 168 return sprintf(buf, "%d\n", udev->autosuspend_delay / HZ); 169 } 170 171 static ssize_t 172 set_autosuspend(struct device *dev, struct device_attribute *attr, 173 const char *buf, size_t count) 174 { 175 struct usb_device *udev = to_usb_device(dev); 176 int value; 177 178 if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/HZ || 179 value <= - INT_MAX/HZ) 180 return -EINVAL; 181 value *= HZ; 182 183 udev->autosuspend_delay = value; 184 if (value >= 0) 185 usb_try_autosuspend_device(udev); 186 else { 187 usb_lock_device(udev); 188 usb_external_resume_device(udev); 189 usb_unlock_device(udev); 190 } 191 return count; 192 } 193 194 static DEVICE_ATTR(autosuspend, S_IRUGO | S_IWUSR, 195 show_autosuspend, set_autosuspend); 196 197 static char power_group[] = "power"; 198 199 static int add_power_attributes(struct device *dev) 200 { 201 int rc = 0; 202 203 if (is_usb_device(dev)) 204 rc = sysfs_add_file_to_group(&dev->kobj, 205 &dev_attr_autosuspend.attr, 206 power_group); 207 return rc; 208 } 209 210 static void remove_power_attributes(struct device *dev) 211 { 212 sysfs_remove_file_from_group(&dev->kobj, 213 &dev_attr_autosuspend.attr, 214 power_group); 215 } 216 217 #else 218 219 #define add_power_attributes(dev) 0 220 #define remove_power_attributes(dev) do {} while (0) 221 222 #endif /* CONFIG_USB_SUSPEND */ 223 224 /* Descriptor fields */ 225 #define usb_descriptor_attr_le16(field, format_string) \ 226 static ssize_t \ 227 show_##field(struct device *dev, struct device_attribute *attr, \ 228 char *buf) \ 229 { \ 230 struct usb_device *udev; \ 231 \ 232 udev = to_usb_device(dev); \ 233 return sprintf(buf, format_string, \ 234 le16_to_cpu(udev->descriptor.field)); \ 235 } \ 236 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL); 237 238 usb_descriptor_attr_le16(idVendor, "%04x\n") 239 usb_descriptor_attr_le16(idProduct, "%04x\n") 240 usb_descriptor_attr_le16(bcdDevice, "%04x\n") 241 242 #define usb_descriptor_attr(field, format_string) \ 243 static ssize_t \ 244 show_##field(struct device *dev, struct device_attribute *attr, \ 245 char *buf) \ 246 { \ 247 struct usb_device *udev; \ 248 \ 249 udev = to_usb_device(dev); \ 250 return sprintf(buf, format_string, udev->descriptor.field); \ 251 } \ 252 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL); 253 254 usb_descriptor_attr(bDeviceClass, "%02x\n") 255 usb_descriptor_attr(bDeviceSubClass, "%02x\n") 256 usb_descriptor_attr(bDeviceProtocol, "%02x\n") 257 usb_descriptor_attr(bNumConfigurations, "%d\n") 258 usb_descriptor_attr(bMaxPacketSize0, "%d\n") 259 260 static struct attribute *dev_attrs[] = { 261 /* current configuration's attributes */ 262 &dev_attr_configuration.attr, 263 &dev_attr_bNumInterfaces.attr, 264 &dev_attr_bConfigurationValue.attr, 265 &dev_attr_bmAttributes.attr, 266 &dev_attr_bMaxPower.attr, 267 /* device attributes */ 268 &dev_attr_idVendor.attr, 269 &dev_attr_idProduct.attr, 270 &dev_attr_bcdDevice.attr, 271 &dev_attr_bDeviceClass.attr, 272 &dev_attr_bDeviceSubClass.attr, 273 &dev_attr_bDeviceProtocol.attr, 274 &dev_attr_bNumConfigurations.attr, 275 &dev_attr_bMaxPacketSize0.attr, 276 &dev_attr_speed.attr, 277 &dev_attr_devnum.attr, 278 &dev_attr_version.attr, 279 &dev_attr_maxchild.attr, 280 &dev_attr_quirks.attr, 281 NULL, 282 }; 283 static struct attribute_group dev_attr_grp = { 284 .attrs = dev_attrs, 285 }; 286 287 int usb_create_sysfs_dev_files(struct usb_device *udev) 288 { 289 struct device *dev = &udev->dev; 290 int retval; 291 292 retval = sysfs_create_group(&dev->kobj, &dev_attr_grp); 293 if (retval) 294 return retval; 295 296 retval = add_power_attributes(dev); 297 if (retval) 298 goto error; 299 300 if (udev->manufacturer) { 301 retval = device_create_file(dev, &dev_attr_manufacturer); 302 if (retval) 303 goto error; 304 } 305 if (udev->product) { 306 retval = device_create_file(dev, &dev_attr_product); 307 if (retval) 308 goto error; 309 } 310 if (udev->serial) { 311 retval = device_create_file(dev, &dev_attr_serial); 312 if (retval) 313 goto error; 314 } 315 retval = usb_create_ep_files(dev, &udev->ep0, udev); 316 if (retval) 317 goto error; 318 return 0; 319 error: 320 usb_remove_sysfs_dev_files(udev); 321 return retval; 322 } 323 324 void usb_remove_sysfs_dev_files(struct usb_device *udev) 325 { 326 struct device *dev = &udev->dev; 327 328 usb_remove_ep_files(&udev->ep0); 329 device_remove_file(dev, &dev_attr_manufacturer); 330 device_remove_file(dev, &dev_attr_product); 331 device_remove_file(dev, &dev_attr_serial); 332 remove_power_attributes(dev); 333 sysfs_remove_group(&dev->kobj, &dev_attr_grp); 334 } 335 336 /* Interface fields */ 337 #define usb_intf_attr(field, format_string) \ 338 static ssize_t \ 339 show_##field(struct device *dev, struct device_attribute *attr, \ 340 char *buf) \ 341 { \ 342 struct usb_interface *intf = to_usb_interface(dev); \ 343 \ 344 return sprintf(buf, format_string, \ 345 intf->cur_altsetting->desc.field); \ 346 } \ 347 static DEVICE_ATTR(field, S_IRUGO, show_##field, NULL); 348 349 usb_intf_attr(bInterfaceNumber, "%02x\n") 350 usb_intf_attr(bAlternateSetting, "%2d\n") 351 usb_intf_attr(bNumEndpoints, "%02x\n") 352 usb_intf_attr(bInterfaceClass, "%02x\n") 353 usb_intf_attr(bInterfaceSubClass, "%02x\n") 354 usb_intf_attr(bInterfaceProtocol, "%02x\n") 355 356 static ssize_t show_interface_string(struct device *dev, 357 struct device_attribute *attr, char *buf) 358 { 359 struct usb_interface *intf; 360 struct usb_device *udev; 361 int len; 362 363 intf = to_usb_interface(dev); 364 udev = interface_to_usbdev(intf); 365 len = snprintf(buf, 256, "%s", intf->cur_altsetting->string); 366 if (len < 0) 367 return 0; 368 buf[len] = '\n'; 369 buf[len+1] = 0; 370 return len+1; 371 } 372 static DEVICE_ATTR(interface, S_IRUGO, show_interface_string, NULL); 373 374 static ssize_t show_modalias(struct device *dev, 375 struct device_attribute *attr, char *buf) 376 { 377 struct usb_interface *intf; 378 struct usb_device *udev; 379 struct usb_host_interface *alt; 380 381 intf = to_usb_interface(dev); 382 udev = interface_to_usbdev(intf); 383 alt = intf->cur_altsetting; 384 385 return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X" 386 "ic%02Xisc%02Xip%02X\n", 387 le16_to_cpu(udev->descriptor.idVendor), 388 le16_to_cpu(udev->descriptor.idProduct), 389 le16_to_cpu(udev->descriptor.bcdDevice), 390 udev->descriptor.bDeviceClass, 391 udev->descriptor.bDeviceSubClass, 392 udev->descriptor.bDeviceProtocol, 393 alt->desc.bInterfaceClass, 394 alt->desc.bInterfaceSubClass, 395 alt->desc.bInterfaceProtocol); 396 } 397 static DEVICE_ATTR(modalias, S_IRUGO, show_modalias, NULL); 398 399 static struct attribute *intf_attrs[] = { 400 &dev_attr_bInterfaceNumber.attr, 401 &dev_attr_bAlternateSetting.attr, 402 &dev_attr_bNumEndpoints.attr, 403 &dev_attr_bInterfaceClass.attr, 404 &dev_attr_bInterfaceSubClass.attr, 405 &dev_attr_bInterfaceProtocol.attr, 406 &dev_attr_modalias.attr, 407 NULL, 408 }; 409 static struct attribute_group intf_attr_grp = { 410 .attrs = intf_attrs, 411 }; 412 413 static inline void usb_create_intf_ep_files(struct usb_interface *intf, 414 struct usb_device *udev) 415 { 416 struct usb_host_interface *iface_desc; 417 int i; 418 419 iface_desc = intf->cur_altsetting; 420 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) 421 usb_create_ep_files(&intf->dev, &iface_desc->endpoint[i], 422 udev); 423 } 424 425 static inline void usb_remove_intf_ep_files(struct usb_interface *intf) 426 { 427 struct usb_host_interface *iface_desc; 428 int i; 429 430 iface_desc = intf->cur_altsetting; 431 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) 432 usb_remove_ep_files(&iface_desc->endpoint[i]); 433 } 434 435 int usb_create_sysfs_intf_files(struct usb_interface *intf) 436 { 437 struct device *dev = &intf->dev; 438 struct usb_device *udev = interface_to_usbdev(intf); 439 struct usb_host_interface *alt = intf->cur_altsetting; 440 int retval; 441 442 retval = sysfs_create_group(&dev->kobj, &intf_attr_grp); 443 if (retval) 444 return retval; 445 446 if (alt->string == NULL) 447 alt->string = usb_cache_string(udev, alt->desc.iInterface); 448 if (alt->string) 449 retval = device_create_file(dev, &dev_attr_interface); 450 usb_create_intf_ep_files(intf, udev); 451 return 0; 452 } 453 454 void usb_remove_sysfs_intf_files(struct usb_interface *intf) 455 { 456 struct device *dev = &intf->dev; 457 458 usb_remove_intf_ep_files(intf); 459 device_remove_file(dev, &dev_attr_interface); 460 sysfs_remove_group(&dev->kobj, &intf_attr_grp); 461 } 462