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