Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 13 | #include <linux/kernel.h> |
Alan Stern | 2add522 | 2007-03-20 14:59:39 -0400 | [diff] [blame] | 14 | #include <linux/string.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 15 | #include <linux/usb.h> |
Alan Stern | 1662e3a | 2009-03-18 14:28:53 -0400 | [diff] [blame] | 16 | #include <linux/usb/quirks.h> |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 17 | #include "usb.h" |
| 18 | |
| 19 | /* Active configuration fields */ |
Sebastian Andrzej Siewior | 8d8479d | 2012-12-18 15:25:46 +0100 | [diff] [blame] | 20 | #define usb_actconfig_show(field, format_string) \ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 21 | static ssize_t field##_show(struct device *dev, \ |
| 22 | struct device_attribute *attr, char *buf) \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 23 | { \ |
| 24 | struct usb_device *udev; \ |
| 25 | struct usb_host_config *actconfig; \ |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 26 | ssize_t rc = 0; \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 27 | \ |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 28 | udev = to_usb_device(dev); \ |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 29 | usb_lock_device(udev); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 30 | actconfig = udev->actconfig; \ |
| 31 | if (actconfig) \ |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 32 | rc = sprintf(buf, format_string, \ |
Sebastian Andrzej Siewior | 8d8479d | 2012-12-18 15:25:46 +0100 | [diff] [blame] | 33 | actconfig->desc.field); \ |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 34 | usb_unlock_device(udev); \ |
| 35 | return rc; \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | } \ |
| 37 | |
Sebastian Andrzej Siewior | 8d8479d | 2012-12-18 15:25:46 +0100 | [diff] [blame] | 38 | #define usb_actconfig_attr(field, format_string) \ |
| 39 | usb_actconfig_show(field, format_string) \ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 40 | static DEVICE_ATTR_RO(field) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 42 | usb_actconfig_attr(bNumInterfaces, "%2d\n"); |
| 43 | usb_actconfig_attr(bmAttributes, "%2x\n"); |
Sebastian Andrzej Siewior | 8d8479d | 2012-12-18 15:25:46 +0100 | [diff] [blame] | 44 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 45 | static ssize_t bMaxPower_show(struct device *dev, |
Sebastian Andrzej Siewior | 8d8479d | 2012-12-18 15:25:46 +0100 | [diff] [blame] | 46 | struct device_attribute *attr, char *buf) |
| 47 | { |
| 48 | struct usb_device *udev; |
| 49 | struct usb_host_config *actconfig; |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 50 | ssize_t rc = 0; |
Sebastian Andrzej Siewior | 8d8479d | 2012-12-18 15:25:46 +0100 | [diff] [blame] | 51 | |
| 52 | udev = to_usb_device(dev); |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 53 | usb_lock_device(udev); |
Sebastian Andrzej Siewior | 8d8479d | 2012-12-18 15:25:46 +0100 | [diff] [blame] | 54 | actconfig = udev->actconfig; |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 55 | if (actconfig) |
| 56 | rc = sprintf(buf, "%dmA\n", usb_get_max_power(udev, actconfig)); |
| 57 | usb_unlock_device(udev); |
| 58 | return rc; |
Sebastian Andrzej Siewior | 8d8479d | 2012-12-18 15:25:46 +0100 | [diff] [blame] | 59 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 60 | static DEVICE_ATTR_RO(bMaxPower); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 61 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 62 | static ssize_t configuration_show(struct device *dev, |
Alan Stern | b724ae7 | 2005-10-24 15:36:00 -0400 | [diff] [blame] | 63 | struct device_attribute *attr, char *buf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 64 | { |
| 65 | struct usb_device *udev; |
| 66 | struct usb_host_config *actconfig; |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 67 | ssize_t rc = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 68 | |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 69 | udev = to_usb_device(dev); |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 70 | usb_lock_device(udev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 71 | actconfig = udev->actconfig; |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 72 | if (actconfig && actconfig->string) |
| 73 | rc = sprintf(buf, "%s\n", actconfig->string); |
| 74 | usb_unlock_device(udev); |
| 75 | return rc; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 76 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 77 | static DEVICE_ATTR_RO(configuration); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 78 | |
| 79 | /* configuration value is always present, and r/w */ |
Sebastian Andrzej Siewior | 8d8479d | 2012-12-18 15:25:46 +0100 | [diff] [blame] | 80 | usb_actconfig_show(bConfigurationValue, "%u\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 81 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 82 | static ssize_t bConfigurationValue_store(struct device *dev, |
| 83 | struct device_attribute *attr, |
| 84 | const char *buf, size_t count) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 85 | { |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 86 | struct usb_device *udev = to_usb_device(dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 87 | int config, value; |
| 88 | |
Alan Stern | 3f141e2 | 2007-02-08 16:40:43 -0500 | [diff] [blame] | 89 | if (sscanf(buf, "%d", &config) != 1 || config < -1 || config > 255) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 90 | return -EINVAL; |
| 91 | usb_lock_device(udev); |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 92 | value = usb_set_configuration(udev, config); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 93 | usb_unlock_device(udev); |
| 94 | return (value < 0) ? value : count; |
| 95 | } |
Alan Stern | 356c05d | 2012-05-14 13:30:03 -0400 | [diff] [blame] | 96 | static DEVICE_ATTR_IGNORE_LOCKDEP(bConfigurationValue, S_IRUGO | S_IWUSR, |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 97 | bConfigurationValue_show, bConfigurationValue_store); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 98 | |
| 99 | /* String fields */ |
| 100 | #define usb_string_attr(name) \ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 101 | static ssize_t name##_show(struct device *dev, \ |
Alan Stern | b724ae7 | 2005-10-24 15:36:00 -0400 | [diff] [blame] | 102 | struct device_attribute *attr, char *buf) \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 103 | { \ |
| 104 | struct usb_device *udev; \ |
Alan Stern | da30712 | 2009-12-08 15:54:44 -0500 | [diff] [blame] | 105 | int retval; \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 106 | \ |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 107 | udev = to_usb_device(dev); \ |
Alan Stern | da30712 | 2009-12-08 15:54:44 -0500 | [diff] [blame] | 108 | usb_lock_device(udev); \ |
| 109 | retval = sprintf(buf, "%s\n", udev->name); \ |
| 110 | usb_unlock_device(udev); \ |
| 111 | return retval; \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 112 | } \ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 113 | static DEVICE_ATTR_RO(name) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 114 | |
| 115 | usb_string_attr(product); |
| 116 | usb_string_attr(manufacturer); |
| 117 | usb_string_attr(serial); |
| 118 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 119 | static ssize_t speed_show(struct device *dev, struct device_attribute *attr, |
| 120 | char *buf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 121 | { |
| 122 | struct usb_device *udev; |
| 123 | char *speed; |
| 124 | |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 125 | udev = to_usb_device(dev); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 126 | |
| 127 | switch (udev->speed) { |
| 128 | case USB_SPEED_LOW: |
| 129 | speed = "1.5"; |
| 130 | break; |
| 131 | case USB_SPEED_UNKNOWN: |
| 132 | case USB_SPEED_FULL: |
| 133 | speed = "12"; |
| 134 | break; |
| 135 | case USB_SPEED_HIGH: |
| 136 | speed = "480"; |
| 137 | break; |
Greg Kroah-Hartman | 551cdbb | 2010-01-14 11:08:04 -0800 | [diff] [blame] | 138 | case USB_SPEED_WIRELESS: |
Greg Kroah-Hartman | b132b04 | 2010-01-14 10:33:19 -0800 | [diff] [blame] | 139 | speed = "480"; |
| 140 | break; |
| 141 | case USB_SPEED_SUPER: |
| 142 | speed = "5000"; |
| 143 | break; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 144 | default: |
| 145 | speed = "unknown"; |
| 146 | } |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 147 | return sprintf(buf, "%s\n", speed); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 148 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 149 | static DEVICE_ATTR_RO(speed); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 150 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 151 | static ssize_t busnum_show(struct device *dev, struct device_attribute *attr, |
| 152 | char *buf) |
Alan Stern | 83f7d95 | 2007-04-25 15:15:43 -0400 | [diff] [blame] | 153 | { |
| 154 | struct usb_device *udev; |
| 155 | |
| 156 | udev = to_usb_device(dev); |
| 157 | return sprintf(buf, "%d\n", udev->bus->busnum); |
| 158 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 159 | static DEVICE_ATTR_RO(busnum); |
Alan Stern | 83f7d95 | 2007-04-25 15:15:43 -0400 | [diff] [blame] | 160 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 161 | static ssize_t devnum_show(struct device *dev, struct device_attribute *attr, |
| 162 | char *buf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 163 | { |
| 164 | struct usb_device *udev; |
| 165 | |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 166 | udev = to_usb_device(dev); |
| 167 | return sprintf(buf, "%d\n", udev->devnum); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 168 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 169 | static DEVICE_ATTR_RO(devnum); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 170 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 171 | static ssize_t devpath_show(struct device *dev, struct device_attribute *attr, |
| 172 | char *buf) |
Greg Kroah-Hartman | 9af2362 | 2009-11-30 11:15:02 -0800 | [diff] [blame] | 173 | { |
| 174 | struct usb_device *udev; |
| 175 | |
| 176 | udev = to_usb_device(dev); |
| 177 | return sprintf(buf, "%s\n", udev->devpath); |
| 178 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 179 | static DEVICE_ATTR_RO(devpath); |
Greg Kroah-Hartman | 9af2362 | 2009-11-30 11:15:02 -0800 | [diff] [blame] | 180 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 181 | static ssize_t version_show(struct device *dev, struct device_attribute *attr, |
| 182 | char *buf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 183 | { |
| 184 | struct usb_device *udev; |
| 185 | u16 bcdUSB; |
| 186 | |
| 187 | udev = to_usb_device(dev); |
| 188 | bcdUSB = le16_to_cpu(udev->descriptor.bcdUSB); |
| 189 | return sprintf(buf, "%2x.%02x\n", bcdUSB >> 8, bcdUSB & 0xff); |
| 190 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 191 | static DEVICE_ATTR_RO(version); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 192 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 193 | static ssize_t maxchild_show(struct device *dev, struct device_attribute *attr, |
| 194 | char *buf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 195 | { |
| 196 | struct usb_device *udev; |
| 197 | |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 198 | udev = to_usb_device(dev); |
| 199 | return sprintf(buf, "%d\n", udev->maxchild); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 200 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 201 | static DEVICE_ATTR_RO(maxchild); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 202 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 203 | static ssize_t quirks_show(struct device *dev, struct device_attribute *attr, |
| 204 | char *buf) |
Oliver Neukum | 7ceec1f | 2007-01-26 14:26:21 +0100 | [diff] [blame] | 205 | { |
| 206 | struct usb_device *udev; |
| 207 | |
| 208 | udev = to_usb_device(dev); |
| 209 | return sprintf(buf, "0x%x\n", udev->quirks); |
| 210 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 211 | static DEVICE_ATTR_RO(quirks); |
Oliver Neukum | 7ceec1f | 2007-01-26 14:26:21 +0100 | [diff] [blame] | 212 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 213 | static ssize_t avoid_reset_quirk_show(struct device *dev, |
| 214 | struct device_attribute *attr, char *buf) |
Oliver Neukum | ef95534 | 2010-01-16 01:33:03 +0100 | [diff] [blame] | 215 | { |
| 216 | struct usb_device *udev; |
| 217 | |
| 218 | udev = to_usb_device(dev); |
Lan Tianyu | 7fda953 | 2012-08-17 16:44:56 +0800 | [diff] [blame] | 219 | return sprintf(buf, "%d\n", !!(udev->quirks & USB_QUIRK_RESET)); |
Oliver Neukum | ef95534 | 2010-01-16 01:33:03 +0100 | [diff] [blame] | 220 | } |
| 221 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 222 | static ssize_t avoid_reset_quirk_store(struct device *dev, |
| 223 | struct device_attribute *attr, |
| 224 | const char *buf, size_t count) |
Oliver Neukum | ef95534 | 2010-01-16 01:33:03 +0100 | [diff] [blame] | 225 | { |
| 226 | struct usb_device *udev = to_usb_device(dev); |
Lan Tianyu | 7fc2cc3 | 2012-08-03 16:30:35 +0800 | [diff] [blame] | 227 | int val; |
Oliver Neukum | ef95534 | 2010-01-16 01:33:03 +0100 | [diff] [blame] | 228 | |
Lan Tianyu | 7fc2cc3 | 2012-08-03 16:30:35 +0800 | [diff] [blame] | 229 | if (sscanf(buf, "%d", &val) != 1 || val < 0 || val > 1) |
Oliver Neukum | ef95534 | 2010-01-16 01:33:03 +0100 | [diff] [blame] | 230 | return -EINVAL; |
| 231 | usb_lock_device(udev); |
Lan Tianyu | 7fc2cc3 | 2012-08-03 16:30:35 +0800 | [diff] [blame] | 232 | if (val) |
Lan Tianyu | 7fda953 | 2012-08-17 16:44:56 +0800 | [diff] [blame] | 233 | udev->quirks |= USB_QUIRK_RESET; |
Oliver Neukum | ef95534 | 2010-01-16 01:33:03 +0100 | [diff] [blame] | 234 | else |
Lan Tianyu | 7fda953 | 2012-08-17 16:44:56 +0800 | [diff] [blame] | 235 | udev->quirks &= ~USB_QUIRK_RESET; |
Oliver Neukum | ef95534 | 2010-01-16 01:33:03 +0100 | [diff] [blame] | 236 | usb_unlock_device(udev); |
| 237 | return count; |
| 238 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 239 | static DEVICE_ATTR_RW(avoid_reset_quirk); |
Oliver Neukum | ef95534 | 2010-01-16 01:33:03 +0100 | [diff] [blame] | 240 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 241 | static ssize_t urbnum_show(struct device *dev, struct device_attribute *attr, |
| 242 | char *buf) |
Sarah Sharp | 4d59d8a | 2007-10-03 14:56:03 -0700 | [diff] [blame] | 243 | { |
| 244 | struct usb_device *udev; |
| 245 | |
| 246 | udev = to_usb_device(dev); |
| 247 | return sprintf(buf, "%d\n", atomic_read(&udev->urbnum)); |
| 248 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 249 | static DEVICE_ATTR_RO(urbnum); |
Sarah Sharp | 4d59d8a | 2007-10-03 14:56:03 -0700 | [diff] [blame] | 250 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 251 | static ssize_t removable_show(struct device *dev, struct device_attribute *attr, |
| 252 | char *buf) |
Matthew Garrett | 0846e7e | 2012-02-03 17:11:54 -0500 | [diff] [blame] | 253 | { |
| 254 | struct usb_device *udev; |
| 255 | char *state; |
| 256 | |
| 257 | udev = to_usb_device(dev); |
| 258 | |
| 259 | switch (udev->removable) { |
| 260 | case USB_DEVICE_REMOVABLE: |
| 261 | state = "removable"; |
| 262 | break; |
| 263 | case USB_DEVICE_FIXED: |
| 264 | state = "fixed"; |
| 265 | break; |
| 266 | default: |
| 267 | state = "unknown"; |
| 268 | } |
| 269 | |
| 270 | return sprintf(buf, "%s\n", state); |
| 271 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 272 | static DEVICE_ATTR_RO(removable); |
Alan Stern | b41a60e | 2007-05-30 15:39:33 -0400 | [diff] [blame] | 273 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 274 | static ssize_t ltm_capable_show(struct device *dev, |
| 275 | struct device_attribute *attr, char *buf) |
Sarah Sharp | 024f117 | 2012-07-05 17:17:24 -0700 | [diff] [blame] | 276 | { |
| 277 | if (usb_device_supports_ltm(to_usb_device(dev))) |
| 278 | return sprintf(buf, "%s\n", "yes"); |
| 279 | return sprintf(buf, "%s\n", "no"); |
| 280 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 281 | static DEVICE_ATTR_RO(ltm_capable); |
Sarah Sharp | 024f117 | 2012-07-05 17:17:24 -0700 | [diff] [blame] | 282 | |
Alan Stern | feccc30 | 2008-03-03 15:15:59 -0500 | [diff] [blame] | 283 | #ifdef CONFIG_PM |
Alan Stern | b41a60e | 2007-05-30 15:39:33 -0400 | [diff] [blame] | 284 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 285 | static ssize_t persist_show(struct device *dev, struct device_attribute *attr, |
| 286 | char *buf) |
Alan Stern | b41a60e | 2007-05-30 15:39:33 -0400 | [diff] [blame] | 287 | { |
| 288 | struct usb_device *udev = to_usb_device(dev); |
| 289 | |
| 290 | return sprintf(buf, "%d\n", udev->persist_enabled); |
| 291 | } |
| 292 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 293 | static ssize_t persist_store(struct device *dev, struct device_attribute *attr, |
| 294 | const char *buf, size_t count) |
Alan Stern | b41a60e | 2007-05-30 15:39:33 -0400 | [diff] [blame] | 295 | { |
| 296 | struct usb_device *udev = to_usb_device(dev); |
| 297 | int value; |
| 298 | |
| 299 | /* Hubs are always enabled for USB_PERSIST */ |
| 300 | if (udev->descriptor.bDeviceClass == USB_CLASS_HUB) |
| 301 | return -EPERM; |
| 302 | |
| 303 | if (sscanf(buf, "%d", &value) != 1) |
| 304 | return -EINVAL; |
Alan Stern | 0c4db6d | 2010-01-08 12:56:42 -0500 | [diff] [blame] | 305 | |
| 306 | usb_lock_device(udev); |
Alan Stern | b41a60e | 2007-05-30 15:39:33 -0400 | [diff] [blame] | 307 | udev->persist_enabled = !!value; |
Alan Stern | 0c4db6d | 2010-01-08 12:56:42 -0500 | [diff] [blame] | 308 | usb_unlock_device(udev); |
Alan Stern | b41a60e | 2007-05-30 15:39:33 -0400 | [diff] [blame] | 309 | return count; |
| 310 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 311 | static DEVICE_ATTR_RW(persist); |
Alan Stern | b41a60e | 2007-05-30 15:39:33 -0400 | [diff] [blame] | 312 | |
| 313 | static int add_persist_attributes(struct device *dev) |
| 314 | { |
| 315 | int rc = 0; |
| 316 | |
| 317 | if (is_usb_device(dev)) { |
| 318 | struct usb_device *udev = to_usb_device(dev); |
| 319 | |
Alan Stern | feccc30 | 2008-03-03 15:15:59 -0500 | [diff] [blame] | 320 | /* Hubs are automatically enabled for USB_PERSIST, |
| 321 | * no point in creating the attribute file. |
| 322 | */ |
| 323 | if (udev->descriptor.bDeviceClass != USB_CLASS_HUB) |
| 324 | rc = sysfs_add_file_to_group(&dev->kobj, |
| 325 | &dev_attr_persist.attr, |
Alan Stern | 045cac6 | 2010-11-15 15:57:07 -0500 | [diff] [blame] | 326 | power_group_name); |
Alan Stern | b41a60e | 2007-05-30 15:39:33 -0400 | [diff] [blame] | 327 | } |
| 328 | return rc; |
| 329 | } |
| 330 | |
| 331 | static void remove_persist_attributes(struct device *dev) |
| 332 | { |
| 333 | sysfs_remove_file_from_group(&dev->kobj, |
| 334 | &dev_attr_persist.attr, |
Alan Stern | 045cac6 | 2010-11-15 15:57:07 -0500 | [diff] [blame] | 335 | power_group_name); |
Alan Stern | b41a60e | 2007-05-30 15:39:33 -0400 | [diff] [blame] | 336 | } |
Alan Stern | b41a60e | 2007-05-30 15:39:33 -0400 | [diff] [blame] | 337 | #else |
| 338 | |
| 339 | #define add_persist_attributes(dev) 0 |
| 340 | #define remove_persist_attributes(dev) do {} while (0) |
| 341 | |
Alan Stern | feccc30 | 2008-03-03 15:15:59 -0500 | [diff] [blame] | 342 | #endif /* CONFIG_PM */ |
Alan Stern | b41a60e | 2007-05-30 15:39:33 -0400 | [diff] [blame] | 343 | |
Alan Stern | 84ebc10 | 2013-03-27 16:14:46 -0400 | [diff] [blame] | 344 | #ifdef CONFIG_PM_RUNTIME |
Alan Stern | 19c2623 | 2007-02-20 15:03:32 -0500 | [diff] [blame] | 345 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 346 | static ssize_t connected_duration_show(struct device *dev, |
| 347 | struct device_attribute *attr, char *buf) |
Sarah Sharp | 1512300 | 2007-12-21 16:54:15 -0800 | [diff] [blame] | 348 | { |
| 349 | struct usb_device *udev = to_usb_device(dev); |
| 350 | |
| 351 | return sprintf(buf, "%u\n", |
| 352 | jiffies_to_msecs(jiffies - udev->connect_time)); |
| 353 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 354 | static DEVICE_ATTR_RO(connected_duration); |
Sarah Sharp | 1512300 | 2007-12-21 16:54:15 -0800 | [diff] [blame] | 355 | |
| 356 | /* |
| 357 | * If the device is resumed, the last time the device was suspended has |
| 358 | * been pre-subtracted from active_duration. We add the current time to |
| 359 | * get the duration that the device was actually active. |
| 360 | * |
| 361 | * If the device is suspended, the active_duration is up-to-date. |
| 362 | */ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 363 | static ssize_t active_duration_show(struct device *dev, |
| 364 | struct device_attribute *attr, char *buf) |
Sarah Sharp | 1512300 | 2007-12-21 16:54:15 -0800 | [diff] [blame] | 365 | { |
| 366 | struct usb_device *udev = to_usb_device(dev); |
| 367 | int duration; |
| 368 | |
| 369 | if (udev->state != USB_STATE_SUSPENDED) |
| 370 | duration = jiffies_to_msecs(jiffies + udev->active_duration); |
| 371 | else |
| 372 | duration = jiffies_to_msecs(udev->active_duration); |
| 373 | return sprintf(buf, "%u\n", duration); |
| 374 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 375 | static DEVICE_ATTR_RO(active_duration); |
Sarah Sharp | 1512300 | 2007-12-21 16:54:15 -0800 | [diff] [blame] | 376 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 377 | static ssize_t autosuspend_show(struct device *dev, |
| 378 | struct device_attribute *attr, char *buf) |
Alan Stern | 19c2623 | 2007-02-20 15:03:32 -0500 | [diff] [blame] | 379 | { |
Alan Stern | fcc4a01 | 2010-11-15 15:57:51 -0500 | [diff] [blame] | 380 | return sprintf(buf, "%d\n", dev->power.autosuspend_delay / 1000); |
Alan Stern | 19c2623 | 2007-02-20 15:03:32 -0500 | [diff] [blame] | 381 | } |
| 382 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 383 | static ssize_t autosuspend_store(struct device *dev, |
| 384 | struct device_attribute *attr, const char *buf, |
| 385 | size_t count) |
Alan Stern | 19c2623 | 2007-02-20 15:03:32 -0500 | [diff] [blame] | 386 | { |
Alan Stern | fcc4a01 | 2010-11-15 15:57:51 -0500 | [diff] [blame] | 387 | int value; |
Alan Stern | 19c2623 | 2007-02-20 15:03:32 -0500 | [diff] [blame] | 388 | |
Alan Stern | fcc4a01 | 2010-11-15 15:57:51 -0500 | [diff] [blame] | 389 | if (sscanf(buf, "%d", &value) != 1 || value >= INT_MAX/1000 || |
| 390 | value <= -INT_MAX/1000) |
Alan Stern | 19c2623 | 2007-02-20 15:03:32 -0500 | [diff] [blame] | 391 | return -EINVAL; |
Alan Stern | 19c2623 | 2007-02-20 15:03:32 -0500 | [diff] [blame] | 392 | |
Alan Stern | fcc4a01 | 2010-11-15 15:57:51 -0500 | [diff] [blame] | 393 | pm_runtime_set_autosuspend_delay(dev, value * 1000); |
Alan Stern | 19c2623 | 2007-02-20 15:03:32 -0500 | [diff] [blame] | 394 | return count; |
| 395 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 396 | static DEVICE_ATTR_RW(autosuspend); |
Alan Stern | 19c2623 | 2007-02-20 15:03:32 -0500 | [diff] [blame] | 397 | |
Alan Stern | 2add522 | 2007-03-20 14:59:39 -0400 | [diff] [blame] | 398 | static const char on_string[] = "on"; |
| 399 | static const char auto_string[] = "auto"; |
Alan Stern | 2add522 | 2007-03-20 14:59:39 -0400 | [diff] [blame] | 400 | |
Matthias Beyer | 469271f | 2013-10-10 23:41:27 +0200 | [diff] [blame] | 401 | static void warn_level(void) |
| 402 | { |
Alan Stern | a903098 | 2010-04-02 13:22:16 -0400 | [diff] [blame] | 403 | static int level_warned; |
| 404 | |
| 405 | if (!level_warned) { |
| 406 | level_warned = 1; |
| 407 | printk(KERN_WARNING "WARNING! power/level is deprecated; " |
| 408 | "use power/control instead\n"); |
| 409 | } |
| 410 | } |
| 411 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 412 | static ssize_t level_show(struct device *dev, struct device_attribute *attr, |
| 413 | char *buf) |
Alan Stern | 2add522 | 2007-03-20 14:59:39 -0400 | [diff] [blame] | 414 | { |
| 415 | struct usb_device *udev = to_usb_device(dev); |
| 416 | const char *p = auto_string; |
| 417 | |
Alan Stern | a903098 | 2010-04-02 13:22:16 -0400 | [diff] [blame] | 418 | warn_level(); |
Alan Stern | 9e18c82 | 2010-04-02 13:22:09 -0400 | [diff] [blame] | 419 | if (udev->state != USB_STATE_SUSPENDED && !udev->dev.power.runtime_auto) |
Alan Stern | 8e4ceb3 | 2009-12-07 13:01:37 -0500 | [diff] [blame] | 420 | p = on_string; |
Alan Stern | 2add522 | 2007-03-20 14:59:39 -0400 | [diff] [blame] | 421 | return sprintf(buf, "%s\n", p); |
| 422 | } |
| 423 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 424 | static ssize_t level_store(struct device *dev, struct device_attribute *attr, |
| 425 | const char *buf, size_t count) |
Alan Stern | 2add522 | 2007-03-20 14:59:39 -0400 | [diff] [blame] | 426 | { |
| 427 | struct usb_device *udev = to_usb_device(dev); |
| 428 | int len = count; |
| 429 | char *cp; |
Alan Stern | 9e18c82 | 2010-04-02 13:22:09 -0400 | [diff] [blame] | 430 | int rc = count; |
Alan Stern | 2add522 | 2007-03-20 14:59:39 -0400 | [diff] [blame] | 431 | |
Alan Stern | a903098 | 2010-04-02 13:22:16 -0400 | [diff] [blame] | 432 | warn_level(); |
Alan Stern | 2add522 | 2007-03-20 14:59:39 -0400 | [diff] [blame] | 433 | cp = memchr(buf, '\n', count); |
| 434 | if (cp) |
| 435 | len = cp - buf; |
| 436 | |
| 437 | usb_lock_device(udev); |
| 438 | |
Alan Stern | 2add522 | 2007-03-20 14:59:39 -0400 | [diff] [blame] | 439 | if (len == sizeof on_string - 1 && |
Alan Stern | 088f7fe | 2010-01-08 12:56:54 -0500 | [diff] [blame] | 440 | strncmp(buf, on_string, len) == 0) |
Alan Stern | 9e18c82 | 2010-04-02 13:22:09 -0400 | [diff] [blame] | 441 | usb_disable_autosuspend(udev); |
Alan Stern | 2add522 | 2007-03-20 14:59:39 -0400 | [diff] [blame] | 442 | |
Alan Stern | 088f7fe | 2010-01-08 12:56:54 -0500 | [diff] [blame] | 443 | else if (len == sizeof auto_string - 1 && |
| 444 | strncmp(buf, auto_string, len) == 0) |
Alan Stern | 9e18c82 | 2010-04-02 13:22:09 -0400 | [diff] [blame] | 445 | usb_enable_autosuspend(udev); |
Alan Stern | 2add522 | 2007-03-20 14:59:39 -0400 | [diff] [blame] | 446 | |
Alan Stern | 088f7fe | 2010-01-08 12:56:54 -0500 | [diff] [blame] | 447 | else |
Alan Stern | 2add522 | 2007-03-20 14:59:39 -0400 | [diff] [blame] | 448 | rc = -EINVAL; |
| 449 | |
| 450 | usb_unlock_device(udev); |
Alan Stern | 9e18c82 | 2010-04-02 13:22:09 -0400 | [diff] [blame] | 451 | return rc; |
Alan Stern | 2add522 | 2007-03-20 14:59:39 -0400 | [diff] [blame] | 452 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 453 | static DEVICE_ATTR_RW(level); |
Alan Stern | 2add522 | 2007-03-20 14:59:39 -0400 | [diff] [blame] | 454 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 455 | static ssize_t usb2_hardware_lpm_show(struct device *dev, |
| 456 | struct device_attribute *attr, char *buf) |
Andiry Xu | c1045e8 | 2011-09-23 14:19:53 -0700 | [diff] [blame] | 457 | { |
| 458 | struct usb_device *udev = to_usb_device(dev); |
| 459 | const char *p; |
| 460 | |
Sarah Sharp | de68bab | 2013-09-30 17:26:28 +0300 | [diff] [blame] | 461 | if (udev->usb2_hw_lpm_allowed == 1) |
Andiry Xu | c1045e8 | 2011-09-23 14:19:53 -0700 | [diff] [blame] | 462 | p = "enabled"; |
| 463 | else |
| 464 | p = "disabled"; |
| 465 | |
| 466 | return sprintf(buf, "%s\n", p); |
| 467 | } |
| 468 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 469 | static ssize_t usb2_hardware_lpm_store(struct device *dev, |
| 470 | struct device_attribute *attr, |
| 471 | const char *buf, size_t count) |
Andiry Xu | c1045e8 | 2011-09-23 14:19:53 -0700 | [diff] [blame] | 472 | { |
| 473 | struct usb_device *udev = to_usb_device(dev); |
| 474 | bool value; |
| 475 | int ret; |
| 476 | |
| 477 | usb_lock_device(udev); |
| 478 | |
| 479 | ret = strtobool(buf, &value); |
| 480 | |
Sarah Sharp | de68bab | 2013-09-30 17:26:28 +0300 | [diff] [blame] | 481 | if (!ret) { |
| 482 | udev->usb2_hw_lpm_allowed = value; |
Andiry Xu | c1045e8 | 2011-09-23 14:19:53 -0700 | [diff] [blame] | 483 | ret = usb_set_usb2_hardware_lpm(udev, value); |
Sarah Sharp | de68bab | 2013-09-30 17:26:28 +0300 | [diff] [blame] | 484 | } |
Andiry Xu | c1045e8 | 2011-09-23 14:19:53 -0700 | [diff] [blame] | 485 | |
| 486 | usb_unlock_device(udev); |
| 487 | |
| 488 | if (!ret) |
| 489 | return count; |
| 490 | |
| 491 | return ret; |
| 492 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 493 | static DEVICE_ATTR_RW(usb2_hardware_lpm); |
Andiry Xu | c1045e8 | 2011-09-23 14:19:53 -0700 | [diff] [blame] | 494 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 495 | static ssize_t usb2_lpm_l1_timeout_show(struct device *dev, |
| 496 | struct device_attribute *attr, |
| 497 | char *buf) |
Mathias Nyman | 17f3486 | 2013-05-23 17:14:31 +0300 | [diff] [blame] | 498 | { |
| 499 | struct usb_device *udev = to_usb_device(dev); |
| 500 | return sprintf(buf, "%d\n", udev->l1_params.timeout); |
| 501 | } |
| 502 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 503 | static ssize_t usb2_lpm_l1_timeout_store(struct device *dev, |
| 504 | struct device_attribute *attr, |
| 505 | const char *buf, size_t count) |
Mathias Nyman | 17f3486 | 2013-05-23 17:14:31 +0300 | [diff] [blame] | 506 | { |
| 507 | struct usb_device *udev = to_usb_device(dev); |
| 508 | u16 timeout; |
| 509 | |
| 510 | if (kstrtou16(buf, 0, &timeout)) |
| 511 | return -EINVAL; |
| 512 | |
| 513 | udev->l1_params.timeout = timeout; |
| 514 | |
| 515 | return count; |
| 516 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 517 | static DEVICE_ATTR_RW(usb2_lpm_l1_timeout); |
Mathias Nyman | 17f3486 | 2013-05-23 17:14:31 +0300 | [diff] [blame] | 518 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 519 | static ssize_t usb2_lpm_besl_show(struct device *dev, |
| 520 | struct device_attribute *attr, char *buf) |
Mathias Nyman | 17f3486 | 2013-05-23 17:14:31 +0300 | [diff] [blame] | 521 | { |
| 522 | struct usb_device *udev = to_usb_device(dev); |
| 523 | return sprintf(buf, "%d\n", udev->l1_params.besl); |
| 524 | } |
| 525 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 526 | static ssize_t usb2_lpm_besl_store(struct device *dev, |
| 527 | struct device_attribute *attr, |
| 528 | const char *buf, size_t count) |
Mathias Nyman | 17f3486 | 2013-05-23 17:14:31 +0300 | [diff] [blame] | 529 | { |
| 530 | struct usb_device *udev = to_usb_device(dev); |
| 531 | u8 besl; |
| 532 | |
| 533 | if (kstrtou8(buf, 0, &besl) || besl > 15) |
| 534 | return -EINVAL; |
| 535 | |
| 536 | udev->l1_params.besl = besl; |
| 537 | |
| 538 | return count; |
| 539 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 540 | static DEVICE_ATTR_RW(usb2_lpm_besl); |
Mathias Nyman | 17f3486 | 2013-05-23 17:14:31 +0300 | [diff] [blame] | 541 | |
Andiry Xu | c1045e8 | 2011-09-23 14:19:53 -0700 | [diff] [blame] | 542 | static struct attribute *usb2_hardware_lpm_attr[] = { |
| 543 | &dev_attr_usb2_hardware_lpm.attr, |
Mathias Nyman | 17f3486 | 2013-05-23 17:14:31 +0300 | [diff] [blame] | 544 | &dev_attr_usb2_lpm_l1_timeout.attr, |
| 545 | &dev_attr_usb2_lpm_besl.attr, |
Andiry Xu | c1045e8 | 2011-09-23 14:19:53 -0700 | [diff] [blame] | 546 | NULL, |
| 547 | }; |
| 548 | static struct attribute_group usb2_hardware_lpm_attr_group = { |
| 549 | .name = power_group_name, |
| 550 | .attrs = usb2_hardware_lpm_attr, |
| 551 | }; |
| 552 | |
Alan Stern | 045cac6 | 2010-11-15 15:57:07 -0500 | [diff] [blame] | 553 | static struct attribute *power_attrs[] = { |
| 554 | &dev_attr_autosuspend.attr, |
| 555 | &dev_attr_level.attr, |
| 556 | &dev_attr_connected_duration.attr, |
| 557 | &dev_attr_active_duration.attr, |
| 558 | NULL, |
| 559 | }; |
| 560 | static struct attribute_group power_attr_group = { |
| 561 | .name = power_group_name, |
| 562 | .attrs = power_attrs, |
| 563 | }; |
| 564 | |
Alan Stern | 19c2623 | 2007-02-20 15:03:32 -0500 | [diff] [blame] | 565 | static int add_power_attributes(struct device *dev) |
| 566 | { |
| 567 | int rc = 0; |
| 568 | |
Andiry Xu | c1045e8 | 2011-09-23 14:19:53 -0700 | [diff] [blame] | 569 | if (is_usb_device(dev)) { |
| 570 | struct usb_device *udev = to_usb_device(dev); |
Alan Stern | 045cac6 | 2010-11-15 15:57:07 -0500 | [diff] [blame] | 571 | rc = sysfs_merge_group(&dev->kobj, &power_attr_group); |
Andiry Xu | c1045e8 | 2011-09-23 14:19:53 -0700 | [diff] [blame] | 572 | if (udev->usb2_hw_lpm_capable == 1) |
| 573 | rc = sysfs_merge_group(&dev->kobj, |
| 574 | &usb2_hardware_lpm_attr_group); |
| 575 | } |
| 576 | |
Alan Stern | 19c2623 | 2007-02-20 15:03:32 -0500 | [diff] [blame] | 577 | return rc; |
| 578 | } |
| 579 | |
| 580 | static void remove_power_attributes(struct device *dev) |
| 581 | { |
Andiry Xu | c1045e8 | 2011-09-23 14:19:53 -0700 | [diff] [blame] | 582 | sysfs_unmerge_group(&dev->kobj, &usb2_hardware_lpm_attr_group); |
Alan Stern | 045cac6 | 2010-11-15 15:57:07 -0500 | [diff] [blame] | 583 | sysfs_unmerge_group(&dev->kobj, &power_attr_group); |
Alan Stern | 19c2623 | 2007-02-20 15:03:32 -0500 | [diff] [blame] | 584 | } |
| 585 | |
| 586 | #else |
| 587 | |
| 588 | #define add_power_attributes(dev) 0 |
| 589 | #define remove_power_attributes(dev) do {} while (0) |
| 590 | |
Alan Stern | 84ebc10 | 2013-03-27 16:14:46 -0400 | [diff] [blame] | 591 | #endif /* CONFIG_PM_RUNTIME */ |
Alan Stern | 19c2623 | 2007-02-20 15:03:32 -0500 | [diff] [blame] | 592 | |
Alan Stern | b41a60e | 2007-05-30 15:39:33 -0400 | [diff] [blame] | 593 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 594 | /* Descriptor fields */ |
| 595 | #define usb_descriptor_attr_le16(field, format_string) \ |
| 596 | static ssize_t \ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 597 | field##_show(struct device *dev, struct device_attribute *attr, \ |
Alan Stern | b724ae7 | 2005-10-24 15:36:00 -0400 | [diff] [blame] | 598 | char *buf) \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 599 | { \ |
| 600 | struct usb_device *udev; \ |
| 601 | \ |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 602 | udev = to_usb_device(dev); \ |
| 603 | return sprintf(buf, format_string, \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 604 | le16_to_cpu(udev->descriptor.field)); \ |
| 605 | } \ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 606 | static DEVICE_ATTR_RO(field) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 607 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 608 | usb_descriptor_attr_le16(idVendor, "%04x\n"); |
| 609 | usb_descriptor_attr_le16(idProduct, "%04x\n"); |
| 610 | usb_descriptor_attr_le16(bcdDevice, "%04x\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 611 | |
| 612 | #define usb_descriptor_attr(field, format_string) \ |
| 613 | static ssize_t \ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 614 | field##_show(struct device *dev, struct device_attribute *attr, \ |
Alan Stern | b724ae7 | 2005-10-24 15:36:00 -0400 | [diff] [blame] | 615 | char *buf) \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 616 | { \ |
| 617 | struct usb_device *udev; \ |
| 618 | \ |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 619 | udev = to_usb_device(dev); \ |
| 620 | return sprintf(buf, format_string, udev->descriptor.field); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 621 | } \ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 622 | static DEVICE_ATTR_RO(field) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 623 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 624 | usb_descriptor_attr(bDeviceClass, "%02x\n"); |
| 625 | usb_descriptor_attr(bDeviceSubClass, "%02x\n"); |
| 626 | usb_descriptor_attr(bDeviceProtocol, "%02x\n"); |
| 627 | usb_descriptor_attr(bNumConfigurations, "%d\n"); |
| 628 | usb_descriptor_attr(bMaxPacketSize0, "%d\n"); |
Inaky Perez-Gonzalez | e03f2e8 | 2007-07-31 20:34:07 -0700 | [diff] [blame] | 629 | |
| 630 | |
| 631 | /* show if the device is authorized (1) or not (0) */ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 632 | static ssize_t authorized_show(struct device *dev, |
| 633 | struct device_attribute *attr, char *buf) |
Inaky Perez-Gonzalez | e03f2e8 | 2007-07-31 20:34:07 -0700 | [diff] [blame] | 634 | { |
| 635 | struct usb_device *usb_dev = to_usb_device(dev); |
| 636 | return snprintf(buf, PAGE_SIZE, "%u\n", usb_dev->authorized); |
| 637 | } |
| 638 | |
Inaky Perez-Gonzalez | e03f2e8 | 2007-07-31 20:34:07 -0700 | [diff] [blame] | 639 | /* |
| 640 | * Authorize a device to be used in the system |
| 641 | * |
| 642 | * Writing a 0 deauthorizes the device, writing a 1 authorizes it. |
| 643 | */ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 644 | static ssize_t authorized_store(struct device *dev, |
| 645 | struct device_attribute *attr, const char *buf, |
| 646 | size_t size) |
Inaky Perez-Gonzalez | e03f2e8 | 2007-07-31 20:34:07 -0700 | [diff] [blame] | 647 | { |
| 648 | ssize_t result; |
| 649 | struct usb_device *usb_dev = to_usb_device(dev); |
| 650 | unsigned val; |
| 651 | result = sscanf(buf, "%u\n", &val); |
| 652 | if (result != 1) |
| 653 | result = -EINVAL; |
| 654 | else if (val == 0) |
| 655 | result = usb_deauthorize_device(usb_dev); |
| 656 | else |
| 657 | result = usb_authorize_device(usb_dev); |
Matthias Beyer | 469271f | 2013-10-10 23:41:27 +0200 | [diff] [blame] | 658 | return result < 0 ? result : size; |
Inaky Perez-Gonzalez | e03f2e8 | 2007-07-31 20:34:07 -0700 | [diff] [blame] | 659 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 660 | static DEVICE_ATTR_IGNORE_LOCKDEP(authorized, S_IRUGO | S_IWUSR, |
| 661 | authorized_show, authorized_store); |
Inaky Perez-Gonzalez | e03f2e8 | 2007-07-31 20:34:07 -0700 | [diff] [blame] | 662 | |
Alan Stern | 253e057 | 2009-10-27 15:20:13 -0400 | [diff] [blame] | 663 | /* "Safely remove a device" */ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 664 | static ssize_t remove_store(struct device *dev, struct device_attribute *attr, |
| 665 | const char *buf, size_t count) |
Alan Stern | 253e057 | 2009-10-27 15:20:13 -0400 | [diff] [blame] | 666 | { |
| 667 | struct usb_device *udev = to_usb_device(dev); |
| 668 | int rc = 0; |
| 669 | |
| 670 | usb_lock_device(udev); |
| 671 | if (udev->state != USB_STATE_NOTATTACHED) { |
| 672 | |
| 673 | /* To avoid races, first unconfigure and then remove */ |
| 674 | usb_set_configuration(udev, -1); |
| 675 | rc = usb_remove_device(udev); |
| 676 | } |
| 677 | if (rc == 0) |
| 678 | rc = count; |
| 679 | usb_unlock_device(udev); |
| 680 | return rc; |
| 681 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 682 | static DEVICE_ATTR_IGNORE_LOCKDEP(remove, S_IWUSR, NULL, remove_store); |
Alan Stern | 253e057 | 2009-10-27 15:20:13 -0400 | [diff] [blame] | 683 | |
Inaky Perez-Gonzalez | e03f2e8 | 2007-07-31 20:34:07 -0700 | [diff] [blame] | 684 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 685 | static struct attribute *dev_attrs[] = { |
| 686 | /* current configuration's attributes */ |
Alan Stern | b6eb2d8 | 2006-07-06 15:37:42 -0400 | [diff] [blame] | 687 | &dev_attr_configuration.attr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 688 | &dev_attr_bNumInterfaces.attr, |
| 689 | &dev_attr_bConfigurationValue.attr, |
| 690 | &dev_attr_bmAttributes.attr, |
| 691 | &dev_attr_bMaxPower.attr, |
| 692 | /* device attributes */ |
Greg Kroah-Hartman | 9af2362 | 2009-11-30 11:15:02 -0800 | [diff] [blame] | 693 | &dev_attr_urbnum.attr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 694 | &dev_attr_idVendor.attr, |
| 695 | &dev_attr_idProduct.attr, |
| 696 | &dev_attr_bcdDevice.attr, |
| 697 | &dev_attr_bDeviceClass.attr, |
| 698 | &dev_attr_bDeviceSubClass.attr, |
| 699 | &dev_attr_bDeviceProtocol.attr, |
| 700 | &dev_attr_bNumConfigurations.attr, |
Greg Kroah-Hartman | cf5910b | 2005-06-29 16:53:29 -0700 | [diff] [blame] | 701 | &dev_attr_bMaxPacketSize0.attr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 702 | &dev_attr_speed.attr, |
Alan Stern | 83f7d95 | 2007-04-25 15:15:43 -0400 | [diff] [blame] | 703 | &dev_attr_busnum.attr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 704 | &dev_attr_devnum.attr, |
Greg Kroah-Hartman | 9af2362 | 2009-11-30 11:15:02 -0800 | [diff] [blame] | 705 | &dev_attr_devpath.attr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 706 | &dev_attr_version.attr, |
| 707 | &dev_attr_maxchild.attr, |
Oliver Neukum | 7ceec1f | 2007-01-26 14:26:21 +0100 | [diff] [blame] | 708 | &dev_attr_quirks.attr, |
Oliver Neukum | ef95534 | 2010-01-16 01:33:03 +0100 | [diff] [blame] | 709 | &dev_attr_avoid_reset_quirk.attr, |
Inaky Perez-Gonzalez | e03f2e8 | 2007-07-31 20:34:07 -0700 | [diff] [blame] | 710 | &dev_attr_authorized.attr, |
Alan Stern | 253e057 | 2009-10-27 15:20:13 -0400 | [diff] [blame] | 711 | &dev_attr_remove.attr, |
Matthew Garrett | 0846e7e | 2012-02-03 17:11:54 -0500 | [diff] [blame] | 712 | &dev_attr_removable.attr, |
Sarah Sharp | 024f117 | 2012-07-05 17:17:24 -0700 | [diff] [blame] | 713 | &dev_attr_ltm_capable.attr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 714 | NULL, |
| 715 | }; |
| 716 | static struct attribute_group dev_attr_grp = { |
| 717 | .attrs = dev_attrs, |
| 718 | }; |
| 719 | |
Alan Stern | 2e5f10e | 2008-04-30 15:37:19 -0400 | [diff] [blame] | 720 | /* When modifying this list, be sure to modify dev_string_attrs_are_visible() |
| 721 | * accordingly. |
| 722 | */ |
| 723 | static struct attribute *dev_string_attrs[] = { |
| 724 | &dev_attr_manufacturer.attr, |
| 725 | &dev_attr_product.attr, |
| 726 | &dev_attr_serial.attr, |
| 727 | NULL |
| 728 | }; |
| 729 | |
Al Viro | 587a1f1 | 2011-07-23 23:11:19 -0400 | [diff] [blame] | 730 | static umode_t dev_string_attrs_are_visible(struct kobject *kobj, |
Alan Stern | 2e5f10e | 2008-04-30 15:37:19 -0400 | [diff] [blame] | 731 | struct attribute *a, int n) |
| 732 | { |
H Hartley Sweeten | a864e3aa5 | 2009-04-15 21:34:40 -0400 | [diff] [blame] | 733 | struct device *dev = container_of(kobj, struct device, kobj); |
| 734 | struct usb_device *udev = to_usb_device(dev); |
Alan Stern | 2e5f10e | 2008-04-30 15:37:19 -0400 | [diff] [blame] | 735 | |
| 736 | if (a == &dev_attr_manufacturer.attr) { |
| 737 | if (udev->manufacturer == NULL) |
| 738 | return 0; |
| 739 | } else if (a == &dev_attr_product.attr) { |
| 740 | if (udev->product == NULL) |
| 741 | return 0; |
| 742 | } else if (a == &dev_attr_serial.attr) { |
| 743 | if (udev->serial == NULL) |
| 744 | return 0; |
| 745 | } |
| 746 | return a->mode; |
| 747 | } |
| 748 | |
| 749 | static struct attribute_group dev_string_attr_grp = { |
| 750 | .attrs = dev_string_attrs, |
| 751 | .is_visible = dev_string_attrs_are_visible, |
| 752 | }; |
| 753 | |
David Brownell | a4dbd67 | 2009-06-24 10:06:31 -0700 | [diff] [blame] | 754 | const struct attribute_group *usb_device_groups[] = { |
Alan Stern | 2e5f10e | 2008-04-30 15:37:19 -0400 | [diff] [blame] | 755 | &dev_attr_grp, |
| 756 | &dev_string_attr_grp, |
| 757 | NULL |
| 758 | }; |
| 759 | |
Alan Stern | 69d42a7 | 2007-07-12 17:06:23 -0400 | [diff] [blame] | 760 | /* Binary descriptors */ |
| 761 | |
| 762 | static ssize_t |
Chris Wright | 2c3c8be | 2010-05-12 18:28:57 -0700 | [diff] [blame] | 763 | read_descriptors(struct file *filp, struct kobject *kobj, |
| 764 | struct bin_attribute *attr, |
Alan Stern | 69d42a7 | 2007-07-12 17:06:23 -0400 | [diff] [blame] | 765 | char *buf, loff_t off, size_t count) |
| 766 | { |
H Hartley Sweeten | a864e3aa5 | 2009-04-15 21:34:40 -0400 | [diff] [blame] | 767 | struct device *dev = container_of(kobj, struct device, kobj); |
| 768 | struct usb_device *udev = to_usb_device(dev); |
Alan Stern | 69d42a7 | 2007-07-12 17:06:23 -0400 | [diff] [blame] | 769 | size_t nleft = count; |
| 770 | size_t srclen, n; |
Alan Stern | 217a908 | 2008-05-20 16:40:42 -0400 | [diff] [blame] | 771 | int cfgno; |
| 772 | void *src; |
Alan Stern | 69d42a7 | 2007-07-12 17:06:23 -0400 | [diff] [blame] | 773 | |
Alan Stern | 217a908 | 2008-05-20 16:40:42 -0400 | [diff] [blame] | 774 | /* The binary attribute begins with the device descriptor. |
| 775 | * Following that are the raw descriptor entries for all the |
| 776 | * configurations (config plus subsidiary descriptors). |
Alan Stern | 69d42a7 | 2007-07-12 17:06:23 -0400 | [diff] [blame] | 777 | */ |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 778 | usb_lock_device(udev); |
Alan Stern | 217a908 | 2008-05-20 16:40:42 -0400 | [diff] [blame] | 779 | for (cfgno = -1; cfgno < udev->descriptor.bNumConfigurations && |
| 780 | nleft > 0; ++cfgno) { |
| 781 | if (cfgno < 0) { |
| 782 | src = &udev->descriptor; |
| 783 | srclen = sizeof(struct usb_device_descriptor); |
| 784 | } else { |
| 785 | src = udev->rawdescriptors[cfgno]; |
| 786 | srclen = __le16_to_cpu(udev->config[cfgno].desc. |
| 787 | wTotalLength); |
| 788 | } |
Alan Stern | 69d42a7 | 2007-07-12 17:06:23 -0400 | [diff] [blame] | 789 | if (off < srclen) { |
Alan Stern | 217a908 | 2008-05-20 16:40:42 -0400 | [diff] [blame] | 790 | n = min(nleft, srclen - (size_t) off); |
| 791 | memcpy(buf, src + off, n); |
Alan Stern | 69d42a7 | 2007-07-12 17:06:23 -0400 | [diff] [blame] | 792 | nleft -= n; |
Alan Stern | 217a908 | 2008-05-20 16:40:42 -0400 | [diff] [blame] | 793 | buf += n; |
| 794 | off = 0; |
| 795 | } else { |
| 796 | off -= srclen; |
Alan Stern | 69d42a7 | 2007-07-12 17:06:23 -0400 | [diff] [blame] | 797 | } |
| 798 | } |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 799 | usb_unlock_device(udev); |
Alan Stern | 69d42a7 | 2007-07-12 17:06:23 -0400 | [diff] [blame] | 800 | return count - nleft; |
| 801 | } |
| 802 | |
| 803 | static struct bin_attribute dev_bin_attr_descriptors = { |
| 804 | .attr = {.name = "descriptors", .mode = 0444}, |
| 805 | .read = read_descriptors, |
| 806 | .size = 18 + 65535, /* dev descr + max-size raw descriptor */ |
| 807 | }; |
| 808 | |
Greg Kroah-Hartman | 1b21d5e | 2006-08-28 11:43:25 -0700 | [diff] [blame] | 809 | int usb_create_sysfs_dev_files(struct usb_device *udev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 810 | { |
| 811 | struct device *dev = &udev->dev; |
Greg Kroah-Hartman | 1b21d5e | 2006-08-28 11:43:25 -0700 | [diff] [blame] | 812 | int retval; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 813 | |
Alan Stern | 69d42a7 | 2007-07-12 17:06:23 -0400 | [diff] [blame] | 814 | retval = device_create_bin_file(dev, &dev_bin_attr_descriptors); |
| 815 | if (retval) |
| 816 | goto error; |
| 817 | |
Alan Stern | b41a60e | 2007-05-30 15:39:33 -0400 | [diff] [blame] | 818 | retval = add_persist_attributes(dev); |
| 819 | if (retval) |
| 820 | goto error; |
| 821 | |
Alan Stern | 19c2623 | 2007-02-20 15:03:32 -0500 | [diff] [blame] | 822 | retval = add_power_attributes(dev); |
| 823 | if (retval) |
| 824 | goto error; |
Alan Stern | 3b23dd6 | 2008-12-05 14:10:34 -0500 | [diff] [blame] | 825 | return retval; |
Greg Kroah-Hartman | 1b21d5e | 2006-08-28 11:43:25 -0700 | [diff] [blame] | 826 | error: |
Alan Stern | aa084f3 | 2007-02-20 14:59:59 -0500 | [diff] [blame] | 827 | usb_remove_sysfs_dev_files(udev); |
Greg Kroah-Hartman | 1b21d5e | 2006-08-28 11:43:25 -0700 | [diff] [blame] | 828 | return retval; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 829 | } |
| 830 | |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 831 | void usb_remove_sysfs_dev_files(struct usb_device *udev) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 832 | { |
| 833 | struct device *dev = &udev->dev; |
| 834 | |
Alan Stern | 19c2623 | 2007-02-20 15:03:32 -0500 | [diff] [blame] | 835 | remove_power_attributes(dev); |
Alan Stern | b41a60e | 2007-05-30 15:39:33 -0400 | [diff] [blame] | 836 | remove_persist_attributes(dev); |
Alan Stern | 69d42a7 | 2007-07-12 17:06:23 -0400 | [diff] [blame] | 837 | device_remove_bin_file(dev, &dev_bin_attr_descriptors); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 838 | } |
| 839 | |
Craig W. Nadler | 165fe97 | 2007-06-15 23:14:35 -0400 | [diff] [blame] | 840 | /* Interface Accociation Descriptor fields */ |
| 841 | #define usb_intf_assoc_attr(field, format_string) \ |
| 842 | static ssize_t \ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 843 | iad_##field##_show(struct device *dev, struct device_attribute *attr, \ |
Craig W. Nadler | 165fe97 | 2007-06-15 23:14:35 -0400 | [diff] [blame] | 844 | char *buf) \ |
| 845 | { \ |
Greg Kroah-Hartman | 2c044a4 | 2008-01-30 15:21:33 -0800 | [diff] [blame] | 846 | struct usb_interface *intf = to_usb_interface(dev); \ |
Craig W. Nadler | 165fe97 | 2007-06-15 23:14:35 -0400 | [diff] [blame] | 847 | \ |
Greg Kroah-Hartman | 2c044a4 | 2008-01-30 15:21:33 -0800 | [diff] [blame] | 848 | return sprintf(buf, format_string, \ |
| 849 | intf->intf_assoc->field); \ |
Craig W. Nadler | 165fe97 | 2007-06-15 23:14:35 -0400 | [diff] [blame] | 850 | } \ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 851 | static DEVICE_ATTR_RO(iad_##field) |
Craig W. Nadler | 165fe97 | 2007-06-15 23:14:35 -0400 | [diff] [blame] | 852 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 853 | usb_intf_assoc_attr(bFirstInterface, "%02x\n"); |
| 854 | usb_intf_assoc_attr(bInterfaceCount, "%02d\n"); |
| 855 | usb_intf_assoc_attr(bFunctionClass, "%02x\n"); |
| 856 | usb_intf_assoc_attr(bFunctionSubClass, "%02x\n"); |
| 857 | usb_intf_assoc_attr(bFunctionProtocol, "%02x\n"); |
Craig W. Nadler | 165fe97 | 2007-06-15 23:14:35 -0400 | [diff] [blame] | 858 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 859 | /* Interface fields */ |
| 860 | #define usb_intf_attr(field, format_string) \ |
| 861 | static ssize_t \ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 862 | field##_show(struct device *dev, struct device_attribute *attr, \ |
Alan Stern | b724ae7 | 2005-10-24 15:36:00 -0400 | [diff] [blame] | 863 | char *buf) \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 864 | { \ |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 865 | struct usb_interface *intf = to_usb_interface(dev); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 866 | \ |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 867 | return sprintf(buf, format_string, \ |
Alan Stern | b724ae7 | 2005-10-24 15:36:00 -0400 | [diff] [blame] | 868 | intf->cur_altsetting->desc.field); \ |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 869 | } \ |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 870 | static DEVICE_ATTR_RO(field) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 871 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 872 | usb_intf_attr(bInterfaceNumber, "%02x\n"); |
| 873 | usb_intf_attr(bAlternateSetting, "%2d\n"); |
| 874 | usb_intf_attr(bNumEndpoints, "%02x\n"); |
| 875 | usb_intf_attr(bInterfaceClass, "%02x\n"); |
| 876 | usb_intf_attr(bInterfaceSubClass, "%02x\n"); |
| 877 | usb_intf_attr(bInterfaceProtocol, "%02x\n"); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 878 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 879 | static ssize_t interface_show(struct device *dev, struct device_attribute *attr, |
| 880 | char *buf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 881 | { |
| 882 | struct usb_interface *intf; |
Alan Stern | 2e5f10e | 2008-04-30 15:37:19 -0400 | [diff] [blame] | 883 | char *string; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 884 | |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 885 | intf = to_usb_interface(dev); |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 886 | string = ACCESS_ONCE(intf->cur_altsetting->string); |
Alan Stern | 2e5f10e | 2008-04-30 15:37:19 -0400 | [diff] [blame] | 887 | if (!string) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 888 | return 0; |
Alan Stern | 2e5f10e | 2008-04-30 15:37:19 -0400 | [diff] [blame] | 889 | return sprintf(buf, "%s\n", string); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 890 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 891 | static DEVICE_ATTR_RO(interface); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 892 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 893 | static ssize_t modalias_show(struct device *dev, struct device_attribute *attr, |
| 894 | char *buf) |
Greg KH | 360b52b | 2005-05-10 06:45:10 -0700 | [diff] [blame] | 895 | { |
| 896 | struct usb_interface *intf; |
| 897 | struct usb_device *udev; |
Greg Kroah-Hartman | 7521803 | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 898 | struct usb_host_interface *alt; |
Greg KH | 360b52b | 2005-05-10 06:45:10 -0700 | [diff] [blame] | 899 | |
| 900 | intf = to_usb_interface(dev); |
| 901 | udev = interface_to_usbdev(intf); |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 902 | alt = ACCESS_ONCE(intf->cur_altsetting); |
Greg KH | 360b52b | 2005-05-10 06:45:10 -0700 | [diff] [blame] | 903 | |
Greg Kroah-Hartman | 7521803 | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 904 | return sprintf(buf, "usb:v%04Xp%04Xd%04Xdc%02Xdsc%02Xdp%02X" |
Bjørn Mork | 81df2d5 | 2012-05-18 21:27:43 +0200 | [diff] [blame] | 905 | "ic%02Xisc%02Xip%02Xin%02X\n", |
Greg Kroah-Hartman | 7521803 | 2005-06-20 21:15:16 -0700 | [diff] [blame] | 906 | le16_to_cpu(udev->descriptor.idVendor), |
| 907 | le16_to_cpu(udev->descriptor.idProduct), |
| 908 | le16_to_cpu(udev->descriptor.bcdDevice), |
| 909 | udev->descriptor.bDeviceClass, |
| 910 | udev->descriptor.bDeviceSubClass, |
| 911 | udev->descriptor.bDeviceProtocol, |
| 912 | alt->desc.bInterfaceClass, |
| 913 | alt->desc.bInterfaceSubClass, |
Bjørn Mork | 81df2d5 | 2012-05-18 21:27:43 +0200 | [diff] [blame] | 914 | alt->desc.bInterfaceProtocol, |
| 915 | alt->desc.bInterfaceNumber); |
Greg KH | 360b52b | 2005-05-10 06:45:10 -0700 | [diff] [blame] | 916 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 917 | static DEVICE_ATTR_RO(modalias); |
Greg KH | 360b52b | 2005-05-10 06:45:10 -0700 | [diff] [blame] | 918 | |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 919 | static ssize_t supports_autosuspend_show(struct device *dev, |
| 920 | struct device_attribute *attr, |
| 921 | char *buf) |
Sarah Sharp | 49e7cc8 | 2008-10-06 14:45:46 -0700 | [diff] [blame] | 922 | { |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 923 | int s; |
Sarah Sharp | 49e7cc8 | 2008-10-06 14:45:46 -0700 | [diff] [blame] | 924 | |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 925 | device_lock(dev); |
Sarah Sharp | 49e7cc8 | 2008-10-06 14:45:46 -0700 | [diff] [blame] | 926 | /* Devices will be autosuspended even when an interface isn't claimed */ |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 927 | s = (!dev->driver || to_usb_driver(dev->driver)->supports_autosuspend); |
| 928 | device_unlock(dev); |
Sarah Sharp | 49e7cc8 | 2008-10-06 14:45:46 -0700 | [diff] [blame] | 929 | |
Alan Stern | 232275a | 2013-09-24 15:43:39 -0400 | [diff] [blame] | 930 | return sprintf(buf, "%u\n", s); |
Sarah Sharp | 49e7cc8 | 2008-10-06 14:45:46 -0700 | [diff] [blame] | 931 | } |
Greg Kroah-Hartman | d03f254 | 2013-08-23 16:05:26 -0700 | [diff] [blame] | 932 | static DEVICE_ATTR_RO(supports_autosuspend); |
Sarah Sharp | 49e7cc8 | 2008-10-06 14:45:46 -0700 | [diff] [blame] | 933 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 934 | static struct attribute *intf_attrs[] = { |
| 935 | &dev_attr_bInterfaceNumber.attr, |
| 936 | &dev_attr_bAlternateSetting.attr, |
| 937 | &dev_attr_bNumEndpoints.attr, |
| 938 | &dev_attr_bInterfaceClass.attr, |
| 939 | &dev_attr_bInterfaceSubClass.attr, |
| 940 | &dev_attr_bInterfaceProtocol.attr, |
Greg KH | 360b52b | 2005-05-10 06:45:10 -0700 | [diff] [blame] | 941 | &dev_attr_modalias.attr, |
Sarah Sharp | 49e7cc8 | 2008-10-06 14:45:46 -0700 | [diff] [blame] | 942 | &dev_attr_supports_autosuspend.attr, |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 943 | NULL, |
| 944 | }; |
| 945 | static struct attribute_group intf_attr_grp = { |
| 946 | .attrs = intf_attrs, |
| 947 | }; |
| 948 | |
Alan Stern | 2e5f10e | 2008-04-30 15:37:19 -0400 | [diff] [blame] | 949 | static struct attribute *intf_assoc_attrs[] = { |
| 950 | &dev_attr_iad_bFirstInterface.attr, |
| 951 | &dev_attr_iad_bInterfaceCount.attr, |
| 952 | &dev_attr_iad_bFunctionClass.attr, |
| 953 | &dev_attr_iad_bFunctionSubClass.attr, |
| 954 | &dev_attr_iad_bFunctionProtocol.attr, |
| 955 | NULL, |
| 956 | }; |
| 957 | |
Al Viro | 587a1f1 | 2011-07-23 23:11:19 -0400 | [diff] [blame] | 958 | static umode_t intf_assoc_attrs_are_visible(struct kobject *kobj, |
Alan Stern | 2e5f10e | 2008-04-30 15:37:19 -0400 | [diff] [blame] | 959 | struct attribute *a, int n) |
| 960 | { |
H Hartley Sweeten | a864e3aa5 | 2009-04-15 21:34:40 -0400 | [diff] [blame] | 961 | struct device *dev = container_of(kobj, struct device, kobj); |
| 962 | struct usb_interface *intf = to_usb_interface(dev); |
Alan Stern | 2e5f10e | 2008-04-30 15:37:19 -0400 | [diff] [blame] | 963 | |
| 964 | if (intf->intf_assoc == NULL) |
| 965 | return 0; |
| 966 | return a->mode; |
| 967 | } |
| 968 | |
| 969 | static struct attribute_group intf_assoc_attr_grp = { |
| 970 | .attrs = intf_assoc_attrs, |
| 971 | .is_visible = intf_assoc_attrs_are_visible, |
| 972 | }; |
| 973 | |
David Brownell | a4dbd67 | 2009-06-24 10:06:31 -0700 | [diff] [blame] | 974 | const struct attribute_group *usb_interface_groups[] = { |
Alan Stern | 2e5f10e | 2008-04-30 15:37:19 -0400 | [diff] [blame] | 975 | &intf_attr_grp, |
| 976 | &intf_assoc_attr_grp, |
| 977 | NULL |
| 978 | }; |
| 979 | |
Michal Nazarewicz | 643de62 | 2011-04-14 17:47:09 +0200 | [diff] [blame] | 980 | void usb_create_sysfs_intf_files(struct usb_interface *intf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 981 | { |
Alan Stern | 4f62efe | 2005-10-24 16:24:14 -0400 | [diff] [blame] | 982 | struct usb_device *udev = interface_to_usbdev(intf); |
| 983 | struct usb_host_interface *alt = intf->cur_altsetting; |
| 984 | |
Alan Stern | 352d026 | 2008-10-29 15:16:58 -0400 | [diff] [blame] | 985 | if (intf->sysfs_files_created || intf->unregistering) |
Michal Nazarewicz | 643de62 | 2011-04-14 17:47:09 +0200 | [diff] [blame] | 986 | return; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 987 | |
Michal Nazarewicz | 643de62 | 2011-04-14 17:47:09 +0200 | [diff] [blame] | 988 | if (!alt->string && !(udev->quirks & USB_QUIRK_CONFIG_INTF_STRINGS)) |
Alan Stern | 4f62efe | 2005-10-24 16:24:14 -0400 | [diff] [blame] | 989 | alt->string = usb_cache_string(udev, alt->desc.iInterface); |
Michal Nazarewicz | 643de62 | 2011-04-14 17:47:09 +0200 | [diff] [blame] | 990 | if (alt->string && device_create_file(&intf->dev, &dev_attr_interface)) |
| 991 | ; /* We don't actually care if the function fails. */ |
Alan Stern | 7e61559 | 2007-11-06 11:43:42 -0500 | [diff] [blame] | 992 | intf->sysfs_files_created = 1; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 993 | } |
| 994 | |
Oliver Neukum | 9251644 | 2007-01-23 15:55:28 -0500 | [diff] [blame] | 995 | void usb_remove_sysfs_intf_files(struct usb_interface *intf) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 996 | { |
Alan Stern | 7e61559 | 2007-11-06 11:43:42 -0500 | [diff] [blame] | 997 | if (!intf->sysfs_files_created) |
| 998 | return; |
Alan Stern | 92b0da1 | 2008-10-29 15:18:50 -0400 | [diff] [blame] | 999 | |
Alan Stern | 92b0da1 | 2008-10-29 15:18:50 -0400 | [diff] [blame] | 1000 | device_remove_file(&intf->dev, &dev_attr_interface); |
Alan Stern | 7e61559 | 2007-11-06 11:43:42 -0500 | [diff] [blame] | 1001 | intf->sysfs_files_created = 0; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 1002 | } |