/* * drivers/usb/generic.c - generic driver for USB devices (not interfaces) * * (C) Copyright 2005 Greg Kroah-Hartman <gregkh@suse.de> * * based on drivers/usb/usb.c which had the following copyrights: *	(C) Copyright Linus Torvalds 1999 *	(C) Copyright Johannes Erdfelt 1999-2001 *	(C) Copyright Andreas Gal 1999 *	(C) Copyright Gregory P. Smith 1999 *	(C) Copyright Deti Fliegl 1999 (new USB architecture) *	(C) Copyright Randy Dunlap 2000 *	(C) Copyright David Brownell 2000-2004 *	(C) Copyright Yggdrasil Computing, Inc. 2000 *		(usb_device_id matching changes by Adam J. Richter) *	(C) Copyright Greg Kroah-Hartman 2002-2003 * */ #include <linux/usb.h>#include "usb.h" static inline const char *plural(int n){	return (n == 1 ? "" : "s");} static int is_rndis(struct usb_interface_descriptor *desc){	return desc->bInterfaceClass == USB_CLASS_COMM		&& desc->bInterfaceSubClass == 2		&& desc->bInterfaceProtocol == 0xff;} static int is_activesync(struct usb_interface_descriptor *desc){	return desc->bInterfaceClass == USB_CLASS_MISC		&& desc->bInterfaceSubClass == 1		&& desc->bInterfaceProtocol == 1;} static int choose_configuration(struct usb_device *udev){	int i;	int num_configs;	int insufficient_power = 0;	struct usb_host_config *c, *best; 	best = NULL;	c = udev->config;	num_configs = udev->descriptor.bNumConfigurations;	for (i = 0; i < num_configs; (i++, c++)) {		struct usb_interface_descriptor	*desc = NULL; 		/* It's possible that a config has no interfaces! */		if (c->desc.bNumInterfaces > 0)			desc = &c->intf_cache[0]->altsetting->desc; 		/*		 * HP's USB bus-powered keyboard has only one configuration		 * and it claims to be self-powered; other devices may have		 * similar errors in their descriptors.  If the next test		 * were allowed to execute, such configurations would always		 * be rejected and the devices would not work as expected.		 * In the meantime, we run the risk of selecting a config		 * that requires external power at a time when that power		 * isn't available.  It seems to be the lesser of two evils.		 *		 * Bugzilla #6448 reports a device that appears to crash		 * when it receives a GET_DEVICE_STATUS request!  We don't		 * have any other way to tell whether a device is self-powered,		 * but since we don't use that information anywhere but here,		 * the call has been removed.		 *		 * Maybe the GET_DEVICE_STATUS call and the test below can		 * be reinstated when device firmwares become more reliable.		 * Don't hold your breath.		 */#if 0		/* Rule out self-powered configs for a bus-powered device */		if (bus_powered && (c->desc.bmAttributes &					USB_CONFIG_ATT_SELFPOWER))			continue;#endif 		/*		 * The next test may not be as effective as it should be.		 * Some hubs have errors in their descriptor, claiming		 * to be self-powered when they are really bus-powered.		 * We will overestimate the amount of current such hubs		 * make available for each port.		 *		 * This is a fairly benign sort of failure.  It won't		 * cause us to reject configurations that we should have		 * accepted.		 */ 		/* Rule out configs that draw too much bus current */		if (c->desc.bMaxPower * 2 > udev->bus_mA) {			insufficient_power++;			continue;		} 		/* When the first config's first interface is one of Microsoft's		 * pet nonstandard Ethernet-over-USB protocols, ignore it unless		 * this kernel has enabled the necessary host side driver.		 */		if (i == 0 && desc && (is_rndis(desc) || is_activesync(desc))) {#if !defined(CONFIG_USB_NET_RNDIS_HOST) && !defined(CONFIG_USB_NET_RNDIS_HOST_MODULE)			continue;#else			best = c;#endif		} 		/* From the remaining configs, choose the first one whose		 * first interface is for a non-vendor-specific class.		 * Reason: Linux is more likely to have a class driver		 * than a vendor-specific driver. */		else if (udev->descriptor.bDeviceClass !=						USB_CLASS_VENDOR_SPEC &&				(!desc || desc->bInterfaceClass !=						USB_CLASS_VENDOR_SPEC)) {			best = c;			break;		} 		/* If all the remaining configs are vendor-specific,		 * choose the first one. */		else if (!best)			best = c;	} 	if (insufficient_power > 0)		dev_info(&udev->dev, "rejected %d configuration%s "			"due to insufficient available bus power\n",			insufficient_power, plural(insufficient_power)); 	if (best) {		i = best->desc.bConfigurationValue;		dev_info(&udev->dev,			"configuration #%d chosen from %d choice%s\n",			i, num_configs, plural(num_configs));	} else {		i = -1;		dev_warn(&udev->dev,			"no configuration chosen from %d choice%s\n",			num_configs, plural(num_configs));	}	return i;} static int generic_probe(struct usb_device *udev){	int err, c; 	/* put device-specific files into sysfs */	usb_create_sysfs_dev_files(udev); 	/* Choose and set the configuration.  This registers the interfaces	 * with the driver core and lets interface drivers bind to them.	 */	c = choose_configuration(udev);	if (c >= 0) {		err = usb_set_configuration(udev, c);		if (err) {			dev_err(&udev->dev, "can't set config #%d, error %d\n",					c, err);			/* This need not be fatal.  The user can try to			 * set other configurations. */		}	} 	/* USB device state == configured ... usable */	usb_notify_add_device(udev); 	return 0;} static void generic_disconnect(struct usb_device *udev){	usb_notify_remove_device(udev); 	/* if this is only an unbind, not a physical disconnect, then	 * unconfigure the device */	if (udev->actconfig)		usb_set_configuration(udev, -1); 	usb_remove_sysfs_dev_files(udev);} #ifdef	CONFIG_PM static int generic_suspend(struct usb_device *udev, pm_message_t msg){	/* USB devices enter SUSPEND state through their hubs, but can be	 * marked for FREEZE as soon as their children are already idled.	 * But those semantics are useless, so we equate the two (sigh).	 */	return usb_port_suspend(udev);} static int generic_resume(struct usb_device *udev){	return usb_port_resume(udev);} #endif	/* CONFIG_PM */ struct usb_device_driver usb_generic_driver = {	.name =	"usb",	.probe = generic_probe,	.disconnect = generic_disconnect,#ifdef	CONFIG_PM	.suspend = generic_suspend,	.resume = generic_resume,#endif	.supports_autosuspend = 1,};