Commit | Line | Data |
---|---|---|
36e56a34 AS |
1 | /* |
2 | * drivers/usb/generic.c - generic driver for USB devices (not interfaces) | |
3 | * | |
4 | * (C) Copyright 2005 Greg Kroah-Hartman <gregkh@suse.de> | |
5 | * | |
6 | * based on drivers/usb/usb.c which had the following copyrights: | |
7 | * (C) Copyright Linus Torvalds 1999 | |
8 | * (C) Copyright Johannes Erdfelt 1999-2001 | |
9 | * (C) Copyright Andreas Gal 1999 | |
10 | * (C) Copyright Gregory P. Smith 1999 | |
11 | * (C) Copyright Deti Fliegl 1999 (new USB architecture) | |
12 | * (C) Copyright Randy Dunlap 2000 | |
13 | * (C) Copyright David Brownell 2000-2004 | |
14 | * (C) Copyright Yggdrasil Computing, Inc. 2000 | |
15 | * (usb_device_id matching changes by Adam J. Richter) | |
16 | * (C) Copyright Greg Kroah-Hartman 2002-2003 | |
17 | * | |
18 | */ | |
19 | ||
36e56a34 | 20 | #include <linux/usb.h> |
27729aad | 21 | #include <linux/usb/hcd.h> |
36e56a34 AS |
22 | #include "usb.h" |
23 | ||
782da727 AS |
24 | static inline const char *plural(int n) |
25 | { | |
26 | return (n == 1 ? "" : "s"); | |
27 | } | |
28 | ||
ad55d71a OAVR |
29 | static int is_rndis(struct usb_interface_descriptor *desc) |
30 | { | |
31 | return desc->bInterfaceClass == USB_CLASS_COMM | |
32 | && desc->bInterfaceSubClass == 2 | |
33 | && desc->bInterfaceProtocol == 0xff; | |
34 | } | |
35 | ||
36 | static int is_activesync(struct usb_interface_descriptor *desc) | |
37 | { | |
38 | return desc->bInterfaceClass == USB_CLASS_MISC | |
39 | && desc->bInterfaceSubClass == 1 | |
40 | && desc->bInterfaceProtocol == 1; | |
41 | } | |
42 | ||
b5ea060f | 43 | int usb_choose_configuration(struct usb_device *udev) |
782da727 AS |
44 | { |
45 | int i; | |
46 | int num_configs; | |
47 | int insufficient_power = 0; | |
48 | struct usb_host_config *c, *best; | |
49 | ||
c13b86a3 HJ |
50 | if (usb_device_is_owned(udev)) |
51 | return 0; | |
52 | ||
782da727 AS |
53 | best = NULL; |
54 | c = udev->config; | |
55 | num_configs = udev->descriptor.bNumConfigurations; | |
56 | for (i = 0; i < num_configs; (i++, c++)) { | |
57 | struct usb_interface_descriptor *desc = NULL; | |
58 | ||
59 | /* It's possible that a config has no interfaces! */ | |
60 | if (c->desc.bNumInterfaces > 0) | |
61 | desc = &c->intf_cache[0]->altsetting->desc; | |
62 | ||
63 | /* | |
64 | * HP's USB bus-powered keyboard has only one configuration | |
65 | * and it claims to be self-powered; other devices may have | |
66 | * similar errors in their descriptors. If the next test | |
67 | * were allowed to execute, such configurations would always | |
68 | * be rejected and the devices would not work as expected. | |
69 | * In the meantime, we run the risk of selecting a config | |
70 | * that requires external power at a time when that power | |
71 | * isn't available. It seems to be the lesser of two evils. | |
72 | * | |
73 | * Bugzilla #6448 reports a device that appears to crash | |
74 | * when it receives a GET_DEVICE_STATUS request! We don't | |
75 | * have any other way to tell whether a device is self-powered, | |
76 | * but since we don't use that information anywhere but here, | |
77 | * the call has been removed. | |
78 | * | |
79 | * Maybe the GET_DEVICE_STATUS call and the test below can | |
80 | * be reinstated when device firmwares become more reliable. | |
81 | * Don't hold your breath. | |
82 | */ | |
83 | #if 0 | |
84 | /* Rule out self-powered configs for a bus-powered device */ | |
85 | if (bus_powered && (c->desc.bmAttributes & | |
86 | USB_CONFIG_ATT_SELFPOWER)) | |
87 | continue; | |
88 | #endif | |
89 | ||
90 | /* | |
91 | * The next test may not be as effective as it should be. | |
92 | * Some hubs have errors in their descriptor, claiming | |
93 | * to be self-powered when they are really bus-powered. | |
94 | * We will overestimate the amount of current such hubs | |
95 | * make available for each port. | |
96 | * | |
97 | * This is a fairly benign sort of failure. It won't | |
98 | * cause us to reject configurations that we should have | |
99 | * accepted. | |
100 | */ | |
101 | ||
102 | /* Rule out configs that draw too much bus current */ | |
8d8479db | 103 | if (usb_get_max_power(udev, c) > udev->bus_mA) { |
782da727 AS |
104 | insufficient_power++; |
105 | continue; | |
106 | } | |
107 | ||
ad55d71a OAVR |
108 | /* When the first config's first interface is one of Microsoft's |
109 | * pet nonstandard Ethernet-over-USB protocols, ignore it unless | |
110 | * this kernel has enabled the necessary host side driver. | |
c4e0b508 | 111 | * But: Don't ignore it if it's the only config. |
ad55d71a | 112 | */ |
c4e0b508 AS |
113 | if (i == 0 && num_configs > 1 && desc && |
114 | (is_rndis(desc) || is_activesync(desc))) { | |
ad55d71a | 115 | #if !defined(CONFIG_USB_NET_RNDIS_HOST) && !defined(CONFIG_USB_NET_RNDIS_HOST_MODULE) |
782da727 AS |
116 | continue; |
117 | #else | |
118 | best = c; | |
119 | #endif | |
120 | } | |
121 | ||
122 | /* From the remaining configs, choose the first one whose | |
123 | * first interface is for a non-vendor-specific class. | |
124 | * Reason: Linux is more likely to have a class driver | |
125 | * than a vendor-specific driver. */ | |
126 | else if (udev->descriptor.bDeviceClass != | |
127 | USB_CLASS_VENDOR_SPEC && | |
62f9cfa3 | 128 | (desc && desc->bInterfaceClass != |
782da727 AS |
129 | USB_CLASS_VENDOR_SPEC)) { |
130 | best = c; | |
131 | break; | |
132 | } | |
133 | ||
134 | /* If all the remaining configs are vendor-specific, | |
135 | * choose the first one. */ | |
136 | else if (!best) | |
137 | best = c; | |
138 | } | |
139 | ||
140 | if (insufficient_power > 0) | |
141 | dev_info(&udev->dev, "rejected %d configuration%s " | |
142 | "due to insufficient available bus power\n", | |
143 | insufficient_power, plural(insufficient_power)); | |
144 | ||
145 | if (best) { | |
146 | i = best->desc.bConfigurationValue; | |
b1f0a34c | 147 | dev_dbg(&udev->dev, |
782da727 AS |
148 | "configuration #%d chosen from %d choice%s\n", |
149 | i, num_configs, plural(num_configs)); | |
150 | } else { | |
151 | i = -1; | |
152 | dev_warn(&udev->dev, | |
153 | "no configuration chosen from %d choice%s\n", | |
154 | num_configs, plural(num_configs)); | |
155 | } | |
156 | return i; | |
157 | } | |
b7945b77 | 158 | EXPORT_SYMBOL_GPL(usb_choose_configuration); |
782da727 | 159 | |
8bb54ab5 | 160 | static int generic_probe(struct usb_device *udev) |
36e56a34 | 161 | { |
782da727 AS |
162 | int err, c; |
163 | ||
782da727 AS |
164 | /* Choose and set the configuration. This registers the interfaces |
165 | * with the driver core and lets interface drivers bind to them. | |
166 | */ | |
c13b86a3 | 167 | if (udev->authorized == 0) |
f8a37464 IPG |
168 | dev_err(&udev->dev, "Device is not authorized for usage\n"); |
169 | else { | |
b5ea060f | 170 | c = usb_choose_configuration(udev); |
f8a37464 IPG |
171 | if (c >= 0) { |
172 | err = usb_set_configuration(udev, c); | |
e9e88fb7 | 173 | if (err && err != -ENODEV) { |
f8a37464 | 174 | dev_err(&udev->dev, "can't set config #%d, error %d\n", |
782da727 | 175 | c, err); |
f8a37464 IPG |
176 | /* This need not be fatal. The user can try to |
177 | * set other configurations. */ | |
178 | } | |
782da727 AS |
179 | } |
180 | } | |
782da727 AS |
181 | /* USB device state == configured ... usable */ |
182 | usb_notify_add_device(udev); | |
183 | ||
36e56a34 AS |
184 | return 0; |
185 | } | |
782da727 | 186 | |
8bb54ab5 | 187 | static void generic_disconnect(struct usb_device *udev) |
36e56a34 | 188 | { |
782da727 AS |
189 | usb_notify_remove_device(udev); |
190 | ||
36e56a34 AS |
191 | /* if this is only an unbind, not a physical disconnect, then |
192 | * unconfigure the device */ | |
01d883d4 | 193 | if (udev->actconfig) |
3f141e2a | 194 | usb_set_configuration(udev, -1); |
36e56a34 AS |
195 | } |
196 | ||
782da727 AS |
197 | #ifdef CONFIG_PM |
198 | ||
782da727 AS |
199 | static int generic_suspend(struct usb_device *udev, pm_message_t msg) |
200 | { | |
b6f6436d AS |
201 | int rc; |
202 | ||
686314cf AS |
203 | /* Normal USB devices suspend through their upstream port. |
204 | * Root hubs don't have upstream ports to suspend, | |
205 | * so we have to shut down their downstream HC-to-USB | |
206 | * interfaces manually by doing a bus (or "global") suspend. | |
b6f6436d | 207 | */ |
686314cf | 208 | if (!udev->parent) |
65bfd296 | 209 | rc = hcd_bus_suspend(udev, msg); |
5ad4f71e AS |
210 | |
211 | /* Non-root devices don't need to do anything for FREEZE or PRETHAW */ | |
212 | else if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_PRETHAW) | |
213 | rc = 0; | |
686314cf | 214 | else |
65bfd296 | 215 | rc = usb_port_suspend(udev, msg); |
5ad4f71e | 216 | |
b6f6436d | 217 | return rc; |
782da727 AS |
218 | } |
219 | ||
65bfd296 | 220 | static int generic_resume(struct usb_device *udev, pm_message_t msg) |
782da727 | 221 | { |
b6f6436d AS |
222 | int rc; |
223 | ||
686314cf AS |
224 | /* Normal USB devices resume/reset through their upstream port. |
225 | * Root hubs don't have upstream ports to resume or reset, | |
226 | * so we have to start up their downstream HC-to-USB | |
227 | * interfaces manually by doing a bus (or "global") resume. | |
228 | */ | |
229 | if (!udev->parent) | |
65bfd296 | 230 | rc = hcd_bus_resume(udev, msg); |
0458d5b4 | 231 | else |
65bfd296 | 232 | rc = usb_port_resume(udev, msg); |
b6f6436d | 233 | return rc; |
782da727 AS |
234 | } |
235 | ||
236 | #endif /* CONFIG_PM */ | |
237 | ||
8bb54ab5 | 238 | struct usb_device_driver usb_generic_driver = { |
36e56a34 | 239 | .name = "usb", |
36e56a34 | 240 | .probe = generic_probe, |
8bb54ab5 | 241 | .disconnect = generic_disconnect, |
782da727 AS |
242 | #ifdef CONFIG_PM |
243 | .suspend = generic_suspend, | |
244 | .resume = generic_resume, | |
245 | #endif | |
01d883d4 | 246 | .supports_autosuspend = 1, |
36e56a34 | 247 | }; |