1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * drivers/usb/core/generic.c - generic driver for USB devices (not interfaces) |
4 | * |
5 | * (C) Copyright 2005 Greg Kroah-Hartman <gregkh@suse.de> |
6 | * |
7 | * based on drivers/usb/usb.c which had the following copyrights: |
8 | * (C) Copyright Linus Torvalds 1999 |
9 | * (C) Copyright Johannes Erdfelt 1999-2001 |
10 | * (C) Copyright Andreas Gal 1999 |
11 | * (C) Copyright Gregory P. Smith 1999 |
12 | * (C) Copyright Deti Fliegl 1999 (new USB architecture) |
13 | * (C) Copyright Randy Dunlap 2000 |
14 | * (C) Copyright David Brownell 2000-2004 |
15 | * (C) Copyright Yggdrasil Computing, Inc. 2000 |
16 | * (usb_device_id matching changes by Adam J. Richter) |
17 | * (C) Copyright Greg Kroah-Hartman 2002-2003 |
18 | * |
19 | * Released under the GPLv2 only. |
20 | */ |
21 | |
22 | #include <linux/usb.h> |
23 | #include <linux/usb/hcd.h> |
24 | #include <uapi/linux/usb/audio.h> |
25 | #include "usb.h" |
26 | |
27 | static inline const char *plural(int n) |
28 | { |
29 | return (n == 1 ? "" : "s" ); |
30 | } |
31 | |
32 | static int is_rndis(struct usb_interface_descriptor *desc) |
33 | { |
34 | return desc->bInterfaceClass == USB_CLASS_COMM |
35 | && desc->bInterfaceSubClass == 2 |
36 | && desc->bInterfaceProtocol == 0xff; |
37 | } |
38 | |
39 | static int is_activesync(struct usb_interface_descriptor *desc) |
40 | { |
41 | return desc->bInterfaceClass == USB_CLASS_MISC |
42 | && desc->bInterfaceSubClass == 1 |
43 | && desc->bInterfaceProtocol == 1; |
44 | } |
45 | |
46 | static bool is_audio(struct usb_interface_descriptor *desc) |
47 | { |
48 | return desc->bInterfaceClass == USB_CLASS_AUDIO; |
49 | } |
50 | |
51 | static bool is_uac3_config(struct usb_interface_descriptor *desc) |
52 | { |
53 | return desc->bInterfaceProtocol == UAC_VERSION_3; |
54 | } |
55 | |
56 | int usb_choose_configuration(struct usb_device *udev) |
57 | { |
58 | int i; |
59 | int num_configs; |
60 | int insufficient_power = 0; |
61 | struct usb_host_config *c, *best; |
62 | struct usb_device_driver *udriver; |
63 | |
64 | /* |
65 | * If a USB device (not an interface) doesn't have a driver then the |
66 | * kernel has no business trying to select or install a configuration |
67 | * for it. |
68 | */ |
69 | if (!udev->dev.driver) |
70 | return -1; |
71 | udriver = to_usb_device_driver(udev->dev.driver); |
72 | |
73 | if (usb_device_is_owned(udev)) |
74 | return 0; |
75 | |
76 | if (udriver->choose_configuration) { |
77 | i = udriver->choose_configuration(udev); |
78 | if (i >= 0) |
79 | return i; |
80 | } |
81 | |
82 | best = NULL; |
83 | c = udev->config; |
84 | num_configs = udev->descriptor.bNumConfigurations; |
85 | for (i = 0; i < num_configs; (i++, c++)) { |
86 | struct usb_interface_descriptor *desc = NULL; |
87 | |
88 | /* It's possible that a config has no interfaces! */ |
89 | if (c->desc.bNumInterfaces > 0) |
90 | desc = &c->intf_cache[0]->altsetting->desc; |
91 | |
92 | /* |
93 | * HP's USB bus-powered keyboard has only one configuration |
94 | * and it claims to be self-powered; other devices may have |
95 | * similar errors in their descriptors. If the next test |
96 | * were allowed to execute, such configurations would always |
97 | * be rejected and the devices would not work as expected. |
98 | * In the meantime, we run the risk of selecting a config |
99 | * that requires external power at a time when that power |
100 | * isn't available. It seems to be the lesser of two evils. |
101 | * |
102 | * Bugzilla #6448 reports a device that appears to crash |
103 | * when it receives a GET_DEVICE_STATUS request! We don't |
104 | * have any other way to tell whether a device is self-powered, |
105 | * but since we don't use that information anywhere but here, |
106 | * the call has been removed. |
107 | * |
108 | * Maybe the GET_DEVICE_STATUS call and the test below can |
109 | * be reinstated when device firmwares become more reliable. |
110 | * Don't hold your breath. |
111 | */ |
112 | #if 0 |
113 | /* Rule out self-powered configs for a bus-powered device */ |
114 | if (bus_powered && (c->desc.bmAttributes & |
115 | USB_CONFIG_ATT_SELFPOWER)) |
116 | continue; |
117 | #endif |
118 | |
119 | /* |
120 | * The next test may not be as effective as it should be. |
121 | * Some hubs have errors in their descriptor, claiming |
122 | * to be self-powered when they are really bus-powered. |
123 | * We will overestimate the amount of current such hubs |
124 | * make available for each port. |
125 | * |
126 | * This is a fairly benign sort of failure. It won't |
127 | * cause us to reject configurations that we should have |
128 | * accepted. |
129 | */ |
130 | |
131 | /* Rule out configs that draw too much bus current */ |
132 | if (usb_get_max_power(udev, c) > udev->bus_mA) { |
133 | insufficient_power++; |
134 | continue; |
135 | } |
136 | |
137 | /* |
138 | * Select first configuration as default for audio so that |
139 | * devices that don't comply with UAC3 protocol are supported. |
140 | * But, still iterate through other configurations and |
141 | * select UAC3 compliant config if present. |
142 | */ |
143 | if (desc && is_audio(desc)) { |
144 | /* Always prefer the first found UAC3 config */ |
145 | if (is_uac3_config(desc)) { |
146 | best = c; |
147 | break; |
148 | } |
149 | |
150 | /* If there is no UAC3 config, prefer the first config */ |
151 | else if (i == 0) |
152 | best = c; |
153 | |
154 | /* Unconditional continue, because the rest of the code |
155 | * in the loop is irrelevant for audio devices, and |
156 | * because it can reassign best, which for audio devices |
157 | * we don't want. |
158 | */ |
159 | continue; |
160 | } |
161 | |
162 | /* When the first config's first interface is one of Microsoft's |
163 | * pet nonstandard Ethernet-over-USB protocols, ignore it unless |
164 | * this kernel has enabled the necessary host side driver. |
165 | * But: Don't ignore it if it's the only config. |
166 | */ |
167 | if (i == 0 && num_configs > 1 && desc && |
168 | (is_rndis(desc) || is_activesync(desc))) { |
169 | #if !defined(CONFIG_USB_NET_RNDIS_HOST) && !defined(CONFIG_USB_NET_RNDIS_HOST_MODULE) |
170 | continue; |
171 | #else |
172 | best = c; |
173 | #endif |
174 | } |
175 | |
176 | /* From the remaining configs, choose the first one whose |
177 | * first interface is for a non-vendor-specific class. |
178 | * Reason: Linux is more likely to have a class driver |
179 | * than a vendor-specific driver. */ |
180 | else if (udev->descriptor.bDeviceClass != |
181 | USB_CLASS_VENDOR_SPEC && |
182 | (desc && desc->bInterfaceClass != |
183 | USB_CLASS_VENDOR_SPEC)) { |
184 | best = c; |
185 | break; |
186 | } |
187 | |
188 | /* If all the remaining configs are vendor-specific, |
189 | * choose the first one. */ |
190 | else if (!best) |
191 | best = c; |
192 | } |
193 | |
194 | if (insufficient_power > 0) |
195 | dev_info(&udev->dev, "rejected %d configuration%s " |
196 | "due to insufficient available bus power\n" , |
197 | insufficient_power, plural(insufficient_power)); |
198 | |
199 | if (best) { |
200 | i = best->desc.bConfigurationValue; |
201 | dev_dbg(&udev->dev, |
202 | "configuration #%d chosen from %d choice%s\n" , |
203 | i, num_configs, plural(num_configs)); |
204 | } else { |
205 | i = -1; |
206 | dev_warn(&udev->dev, |
207 | "no configuration chosen from %d choice%s\n" , |
208 | num_configs, plural(num_configs)); |
209 | } |
210 | return i; |
211 | } |
212 | EXPORT_SYMBOL_GPL(usb_choose_configuration); |
213 | |
214 | static int __check_for_non_generic_match(struct device_driver *drv, void *data) |
215 | { |
216 | struct usb_device *udev = data; |
217 | struct usb_device_driver *udrv; |
218 | |
219 | if (!is_usb_device_driver(drv)) |
220 | return 0; |
221 | udrv = to_usb_device_driver(drv); |
222 | if (udrv == &usb_generic_driver) |
223 | return 0; |
224 | return usb_driver_applicable(udev, udrv); |
225 | } |
226 | |
227 | static bool usb_generic_driver_match(struct usb_device *udev) |
228 | { |
229 | if (udev->use_generic_driver) |
230 | return true; |
231 | |
232 | /* |
233 | * If any other driver wants the device, leave the device to this other |
234 | * driver. |
235 | */ |
236 | if (bus_for_each_drv(bus: &usb_bus_type, NULL, data: udev, fn: __check_for_non_generic_match)) |
237 | return false; |
238 | |
239 | return true; |
240 | } |
241 | |
242 | int usb_generic_driver_probe(struct usb_device *udev) |
243 | { |
244 | int err, c; |
245 | |
246 | /* Choose and set the configuration. This registers the interfaces |
247 | * with the driver core and lets interface drivers bind to them. |
248 | */ |
249 | if (udev->authorized == 0) |
250 | dev_err(&udev->dev, "Device is not authorized for usage\n" ); |
251 | else { |
252 | c = usb_choose_configuration(udev); |
253 | if (c >= 0) { |
254 | err = usb_set_configuration(dev: udev, configuration: c); |
255 | if (err && err != -ENODEV) { |
256 | dev_err(&udev->dev, "can't set config #%d, error %d\n" , |
257 | c, err); |
258 | /* This need not be fatal. The user can try to |
259 | * set other configurations. */ |
260 | } |
261 | } |
262 | } |
263 | /* USB device state == configured ... usable */ |
264 | usb_notify_add_device(udev); |
265 | |
266 | return 0; |
267 | } |
268 | |
269 | void usb_generic_driver_disconnect(struct usb_device *udev) |
270 | { |
271 | usb_notify_remove_device(udev); |
272 | |
273 | /* if this is only an unbind, not a physical disconnect, then |
274 | * unconfigure the device */ |
275 | if (udev->actconfig) |
276 | usb_set_configuration(dev: udev, configuration: -1); |
277 | } |
278 | |
279 | #ifdef CONFIG_PM |
280 | |
281 | int usb_generic_driver_suspend(struct usb_device *udev, pm_message_t msg) |
282 | { |
283 | int rc; |
284 | |
285 | /* Normal USB devices suspend through their upstream port. |
286 | * Root hubs don't have upstream ports to suspend, |
287 | * so we have to shut down their downstream HC-to-USB |
288 | * interfaces manually by doing a bus (or "global") suspend. |
289 | */ |
290 | if (!udev->parent) |
291 | rc = hcd_bus_suspend(rhdev: udev, msg); |
292 | |
293 | /* |
294 | * Non-root USB2 devices don't need to do anything for FREEZE |
295 | * or PRETHAW. USB3 devices don't support global suspend and |
296 | * needs to be selectively suspended. |
297 | */ |
298 | else if ((msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_PRETHAW) |
299 | && (udev->speed < USB_SPEED_SUPER)) |
300 | rc = 0; |
301 | else |
302 | rc = usb_port_suspend(dev: udev, msg); |
303 | |
304 | if (rc == 0) |
305 | usbfs_notify_suspend(udev); |
306 | return rc; |
307 | } |
308 | |
309 | int usb_generic_driver_resume(struct usb_device *udev, pm_message_t msg) |
310 | { |
311 | int rc; |
312 | |
313 | /* Normal USB devices resume/reset through their upstream port. |
314 | * Root hubs don't have upstream ports to resume or reset, |
315 | * so we have to start up their downstream HC-to-USB |
316 | * interfaces manually by doing a bus (or "global") resume. |
317 | */ |
318 | if (!udev->parent) |
319 | rc = hcd_bus_resume(rhdev: udev, msg); |
320 | else |
321 | rc = usb_port_resume(dev: udev, msg); |
322 | |
323 | if (rc == 0) |
324 | usbfs_notify_resume(udev); |
325 | return rc; |
326 | } |
327 | |
328 | #endif /* CONFIG_PM */ |
329 | |
330 | struct usb_device_driver usb_generic_driver = { |
331 | .name = "usb" , |
332 | .match = usb_generic_driver_match, |
333 | .probe = usb_generic_driver_probe, |
334 | .disconnect = usb_generic_driver_disconnect, |
335 | #ifdef CONFIG_PM |
336 | .suspend = usb_generic_driver_suspend, |
337 | .resume = usb_generic_driver_resume, |
338 | #endif |
339 | .supports_autosuspend = 1, |
340 | }; |
341 | |