1ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman/* 2ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * drivers/usb/driver.c - most of the driver model stuff for usb 3ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 4ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * (C) Copyright 2005 Greg Kroah-Hartman <gregkh@suse.de> 5ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 6ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * based on drivers/usb/usb.c which had the following copyrights: 7ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * (C) Copyright Linus Torvalds 1999 8ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * (C) Copyright Johannes Erdfelt 1999-2001 9ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * (C) Copyright Andreas Gal 1999 10ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * (C) Copyright Gregory P. Smith 1999 11ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * (C) Copyright Deti Fliegl 1999 (new USB architecture) 12ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * (C) Copyright Randy Dunlap 2000 13ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * (C) Copyright David Brownell 2000-2004 14ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * (C) Copyright Yggdrasil Computing, Inc. 2000 15ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * (usb_device_id matching changes by Adam J. Richter) 16ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * (C) Copyright Greg Kroah-Hartman 2002-2003 17ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 18ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * NOTE! This is not actually a driver at all, rather this is 19ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * just a collection of helper routines that implement the 2036e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * matching, probing, releasing, suspending and resuming for 2136e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * real drivers. 22ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 23ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman */ 24ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 25ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman#include <linux/device.h> 265a0e3ad6af8660be21ca98a971cd00f331318c05Tejun Heo#include <linux/slab.h> 27f940fcd8eadfe5b909a1474b57de7755edeee62bPaul Gortmaker#include <linux/export.h> 28ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman#include <linux/usb.h> 296bc6cff52e0c4c4c876b1b8a5750041da61ad42bAlan Stern#include <linux/usb/quirks.h> 3027729aadd31dafddaaf64c24f8ef6d0ff750f3aaEric Lescouet#include <linux/usb/hcd.h> 3127729aadd31dafddaaf64c24f8ef6d0ff750f3aaEric Lescouet 32ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman#include "usb.h" 33ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 3420dfdad74a2baabeecc2896c770efcbf698b9b8dAlan Stern 35733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman#ifdef CONFIG_HOTPLUG 36733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 37733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman/* 38733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman * Adds a new dynamic USBdevice ID to this driver, 39733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman * and cause the driver to probe for all devices again. 40733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman */ 4193bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-Hartmanssize_t usb_store_new_id(struct usb_dynids *dynids, 4293bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-Hartman struct device_driver *driver, 4393bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-Hartman const char *buf, size_t count) 44733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman{ 45733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman struct usb_dynid *dynid; 46733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman u32 idVendor = 0; 47733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman u32 idProduct = 0; 48ff231db811803ef3292532d1d87eaf6882a26cc4Josua Dietze unsigned int bInterfaceClass = 0; 49733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman int fields = 0; 501b21d5e166e104f8914441ef52e2cd50ce65b479Greg Kroah-Hartman int retval = 0; 51733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 52ff231db811803ef3292532d1d87eaf6882a26cc4Josua Dietze fields = sscanf(buf, "%x %x %x", &idVendor, &idProduct, 53ff231db811803ef3292532d1d87eaf6882a26cc4Josua Dietze &bInterfaceClass); 54733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman if (fields < 2) 55733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return -EINVAL; 56733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 57733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman dynid = kzalloc(sizeof(*dynid), GFP_KERNEL); 58733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman if (!dynid) 59733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return -ENOMEM; 60733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 61733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman INIT_LIST_HEAD(&dynid->node); 62733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman dynid->id.idVendor = idVendor; 63733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman dynid->id.idProduct = idProduct; 64733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman dynid->id.match_flags = USB_DEVICE_ID_MATCH_DEVICE; 65ff231db811803ef3292532d1d87eaf6882a26cc4Josua Dietze if (fields == 3) { 66ff231db811803ef3292532d1d87eaf6882a26cc4Josua Dietze dynid->id.bInterfaceClass = (u8)bInterfaceClass; 67ff231db811803ef3292532d1d87eaf6882a26cc4Josua Dietze dynid->id.match_flags |= USB_DEVICE_ID_MATCH_INT_CLASS; 68ff231db811803ef3292532d1d87eaf6882a26cc4Josua Dietze } 69733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 7093bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-Hartman spin_lock(&dynids->lock); 71e5dd01154c1e9ca2400f4682602d1a4fa54c25ddNathael Pajani list_add_tail(&dynid->node, &dynids->list); 7293bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-Hartman spin_unlock(&dynids->lock); 73733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 74cef9bc56e1e944afd11f96de569657117a138c6dAlan Stern retval = driver_attach(driver); 75733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 761b21d5e166e104f8914441ef52e2cd50ce65b479Greg Kroah-Hartman if (retval) 771b21d5e166e104f8914441ef52e2cd50ce65b479Greg Kroah-Hartman return retval; 78733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return count; 79733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman} 8093bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-HartmanEXPORT_SYMBOL_GPL(usb_store_new_id); 8193bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-Hartman 8293bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-Hartmanstatic ssize_t store_new_id(struct device_driver *driver, 8393bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-Hartman const char *buf, size_t count) 8493bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-Hartman{ 8593bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-Hartman struct usb_driver *usb_drv = to_usb_driver(driver); 8693bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-Hartman 8793bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-Hartman return usb_store_new_id(&usb_drv->dynids, driver, buf, count); 8893bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-Hartman} 89733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartmanstatic DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id); 90733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 910c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan/** 920c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan * store_remove_id - remove a USB device ID from this driver 930c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan * @driver: target device driver 940c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan * @buf: buffer for scanning device ID data 950c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan * @count: input size 960c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan * 970c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan * Removes a dynamic usb device ID from this driver. 980c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan */ 990c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquanstatic ssize_t 1000c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquanstore_remove_id(struct device_driver *driver, const char *buf, size_t count) 1010c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan{ 1020c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan struct usb_dynid *dynid, *n; 1030c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan struct usb_driver *usb_driver = to_usb_driver(driver); 1040c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan u32 idVendor = 0; 1050c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan u32 idProduct = 0; 1060c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan int fields = 0; 1070c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan int retval = 0; 1080c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan 1090c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan fields = sscanf(buf, "%x %x", &idVendor, &idProduct); 1100c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan if (fields < 2) 1110c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan return -EINVAL; 1120c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan 1130c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan spin_lock(&usb_driver->dynids.lock); 1140c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan list_for_each_entry_safe(dynid, n, &usb_driver->dynids.list, node) { 1150c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan struct usb_device_id *id = &dynid->id; 1160c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan if ((id->idVendor == idVendor) && 1170c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan (id->idProduct == idProduct)) { 1180c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan list_del(&dynid->node); 1190c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan kfree(dynid); 1200c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan retval = 0; 1210c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan break; 1220c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan } 1230c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan } 1240c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan spin_unlock(&usb_driver->dynids.lock); 1250c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan 1260c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan if (retval) 1270c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan return retval; 1280c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan return count; 1290c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan} 1300c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquanstatic DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id); 1310c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan 132ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Sternstatic int usb_create_newid_files(struct usb_driver *usb_drv) 133733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman{ 134733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman int error = 0; 135733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 136ba9dc657af86d05d2971633e57d1f6f94ed60472Greg Kroah-Hartman if (usb_drv->no_dynamic_id) 137ba9dc657af86d05d2971633e57d1f6f94ed60472Greg Kroah-Hartman goto exit; 138ba9dc657af86d05d2971633e57d1f6f94ed60472Greg Kroah-Hartman 139ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern if (usb_drv->probe != NULL) { 14015147ffd57576fc00a23ad8a020ff46493a4f924Greg Kroah-Hartman error = driver_create_file(&usb_drv->drvwrap.driver, 14115147ffd57576fc00a23ad8a020ff46493a4f924Greg Kroah-Hartman &driver_attr_new_id); 142ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern if (error == 0) { 143ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern error = driver_create_file(&usb_drv->drvwrap.driver, 144ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern &driver_attr_remove_id); 145ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern if (error) 146ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern driver_remove_file(&usb_drv->drvwrap.driver, 147ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern &driver_attr_new_id); 148ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern } 149ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern } 150ba9dc657af86d05d2971633e57d1f6f94ed60472Greg Kroah-Hartmanexit: 151733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return error; 152733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman} 153733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 154ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Sternstatic void usb_remove_newid_files(struct usb_driver *usb_drv) 155ba9dc657af86d05d2971633e57d1f6f94ed60472Greg Kroah-Hartman{ 156ba9dc657af86d05d2971633e57d1f6f94ed60472Greg Kroah-Hartman if (usb_drv->no_dynamic_id) 157ba9dc657af86d05d2971633e57d1f6f94ed60472Greg Kroah-Hartman return; 158ba9dc657af86d05d2971633e57d1f6f94ed60472Greg Kroah-Hartman 159ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern if (usb_drv->probe != NULL) { 16015147ffd57576fc00a23ad8a020ff46493a4f924Greg Kroah-Hartman driver_remove_file(&usb_drv->drvwrap.driver, 1610c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan &driver_attr_remove_id); 162ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern driver_remove_file(&usb_drv->drvwrap.driver, 163ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern &driver_attr_new_id); 164ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern } 1650c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan} 1660c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan 167733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartmanstatic void usb_free_dynids(struct usb_driver *usb_drv) 168733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman{ 169733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman struct usb_dynid *dynid, *n; 170733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 171733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman spin_lock(&usb_drv->dynids.lock); 172733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman list_for_each_entry_safe(dynid, n, &usb_drv->dynids.list, node) { 173733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman list_del(&dynid->node); 174733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman kfree(dynid); 175733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman } 176733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman spin_unlock(&usb_drv->dynids.lock); 177733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman} 178733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman#else 179ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Sternstatic inline int usb_create_newid_files(struct usb_driver *usb_drv) 1800c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan{ 1810c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan return 0; 1820c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan} 1830c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan 184ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Sternstatic void usb_remove_newid_files(struct usb_driver *usb_drv) 1850c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan{ 1860c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan} 1870c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan 188733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartmanstatic inline void usb_free_dynids(struct usb_driver *usb_drv) 189733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman{ 190733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman} 191733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman#endif 192733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 193733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartmanstatic const struct usb_device_id *usb_match_dynamic_id(struct usb_interface *intf, 194733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman struct usb_driver *drv) 195733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman{ 196733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman struct usb_dynid *dynid; 197733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 198733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman spin_lock(&drv->dynids.lock); 199733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman list_for_each_entry(dynid, &drv->dynids.list, node) { 200733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman if (usb_match_one_id(intf, &dynid->id)) { 201733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman spin_unlock(&drv->dynids.lock); 202733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return &dynid->id; 203733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman } 204733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman } 205733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman spin_unlock(&drv->dynids.lock); 206733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return NULL; 207733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman} 208733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 209733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 2108bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern/* called from driver core with dev locked */ 2118bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Sternstatic int usb_probe_device(struct device *dev) 2128bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern{ 2138bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern struct usb_device_driver *udriver = to_usb_device_driver(dev->driver); 2145512966643adb17483efc5f61481a38fc33088bbKay Sievers struct usb_device *udev = to_usb_device(dev); 2159bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern int error = 0; 2168bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 217441b62c1edb986827154768d89bbac0ba779984fHarvey Harrison dev_dbg(dev, "%s\n", __func__); 2188bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 2198bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern /* TODO: Add real matching code */ 2208bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 221645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern /* The device should always appear to be in use 222645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * unless the driver suports autosuspend. 223645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern */ 2249bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (!udriver->supports_autosuspend) 2259bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern error = usb_autoresume_device(udev); 226645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 2279bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (!error) 2289bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern error = udriver->probe(udev); 2298bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern return error; 2308bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern} 2318bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 2328bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern/* called from driver core with dev locked */ 2338bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Sternstatic int usb_unbind_device(struct device *dev) 2348bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern{ 2359bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern struct usb_device *udev = to_usb_device(dev); 2368bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern struct usb_device_driver *udriver = to_usb_device_driver(dev->driver); 2378bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 2389bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern udriver->disconnect(udev); 2399bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (!udriver->supports_autosuspend) 2409bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern usb_autosuspend_device(udev); 2418bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern return 0; 2428bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern} 2438bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 244dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalez/* 245dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalez * Cancel any pending scheduled resets 246dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalez * 247dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalez * [see usb_queue_reset_device()] 248dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalez * 249dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalez * Called after unconfiguring / when releasing interfaces. See 250dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalez * comments in __usb_queue_reset_device() regarding 251dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalez * udev->reset_running. 252dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalez */ 253dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalezstatic void usb_cancel_queued_reset(struct usb_interface *iface) 254dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalez{ 255dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalez if (iface->reset_running == 0) 256dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalez cancel_work_sync(&iface->reset_ws); 257dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalez} 2588bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 2598bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern/* called from driver core with dev locked */ 260ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartmanstatic int usb_probe_interface(struct device *dev) 261ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman{ 2628bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern struct usb_driver *driver = to_usb_driver(dev->driver); 2635512966643adb17483efc5f61481a38fc33088bbKay Sievers struct usb_interface *intf = to_usb_interface(dev); 2645512966643adb17483efc5f61481a38fc33088bbKay Sievers struct usb_device *udev = interface_to_usbdev(intf); 265ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman const struct usb_device_id *id; 266ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman int error = -ENODEV; 267ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 268441b62c1edb986827154768d89bbac0ba779984fHarvey Harrison dev_dbg(dev, "%s\n", __func__); 269ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 27078d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern intf->needs_binding = 0; 271ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 2727cbe5dca399a50ce8aa74314b1d276e2fb904e1bAlan Stern if (usb_device_is_owned(udev)) 2730f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern return error; 2747cbe5dca399a50ce8aa74314b1d276e2fb904e1bAlan Stern 2752c044a4803804708984931bcbd03314732e995d5Greg Kroah-Hartman if (udev->authorized == 0) { 2762c044a4803804708984931bcbd03314732e995d5Greg Kroah-Hartman dev_err(&intf->dev, "Device is not authorized for usage\n"); 2770f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern return error; 2782c044a4803804708984931bcbd03314732e995d5Greg Kroah-Hartman } 27972230abb21349cda54d6cce0d6fd325c023b958eInaky Perez-Gonzalez 280ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman id = usb_match_id(intf, driver->id_table); 281733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman if (!id) 282733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman id = usb_match_dynamic_id(intf, driver); 2830f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern if (!id) 2840f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern return error; 28555151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern 2860f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern dev_dbg(dev, "%s - got id\n", __func__); 2870f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern 2880f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern error = usb_autoresume_device(udev); 2890f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern if (error) 2900f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern return error; 2910f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern 2920f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern intf->condition = USB_INTERFACE_BINDING; 293645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 294571dc79d62a163fd043de47d7d39bae58831e81eAlan Stern /* Probed interfaces are initially active. They are 2959bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * runtime-PM-enabled only if the driver has autosuspend support. 2969bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * They are sensitive to their children's power states. 2970f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern */ 2989bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern pm_runtime_set_active(dev); 2999bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern pm_suspend_ignore_children(dev, false); 3009bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (driver->supports_autosuspend) 3019bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern pm_runtime_enable(dev); 3020f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern 3030f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern /* Carry out a deferred switch to altsetting 0 */ 3040f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern if (intf->needs_altsetting0) { 3050f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern error = usb_set_interface(udev, intf->altsetting[0]. 3060f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern desc.bInterfaceNumber, 0); 3070f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern if (error < 0) 3080f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern goto err; 3090f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern intf->needs_altsetting0 = 0; 310ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman } 311ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 3120f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern error = driver->probe(intf, id); 3130f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern if (error) 3140f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern goto err; 3150f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern 3160f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern intf->condition = USB_INTERFACE_BOUND; 3170f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern usb_autosuspend_device(udev); 318ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman return error; 3191e5ea5e32043094d96ca1e501110c1fbb631f693Oliver Neukum 3200f3dda9f7ff2db8dbf4d6fbab4d4438251446002Alan Stern err: 3211e5ea5e32043094d96ca1e501110c1fbb631f693Oliver Neukum intf->needs_remote_wakeup = 0; 3221e5ea5e32043094d96ca1e501110c1fbb631f693Oliver Neukum intf->condition = USB_INTERFACE_UNBOUND; 3231e5ea5e32043094d96ca1e501110c1fbb631f693Oliver Neukum usb_cancel_queued_reset(intf); 3249bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 3259bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern /* Unbound interfaces are always runtime-PM-disabled and -suspended */ 32689842ae6515c49405e20c0629a6442b6885ad49dAlan Stern if (driver->supports_autosuspend) 32789842ae6515c49405e20c0629a6442b6885ad49dAlan Stern pm_runtime_disable(dev); 3289bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern pm_runtime_set_suspended(dev); 3299bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 3301e5ea5e32043094d96ca1e501110c1fbb631f693Oliver Neukum usb_autosuspend_device(udev); 3311e5ea5e32043094d96ca1e501110c1fbb631f693Oliver Neukum return error; 332ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman} 333ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 3348bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern/* called from driver core with dev locked */ 335ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartmanstatic int usb_unbind_interface(struct device *dev) 336ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman{ 3378bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern struct usb_driver *driver = to_usb_driver(dev->driver); 338ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman struct usb_interface *intf = to_usb_interface(dev); 339645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern struct usb_device *udev; 3401e5ea5e32043094d96ca1e501110c1fbb631f693Oliver Neukum int error, r; 341ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 342ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman intf->condition = USB_INTERFACE_UNBINDING; 343ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 344645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern /* Autoresume for set_interface call below */ 345645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern udev = interface_to_usbdev(intf); 34694fcda1f8ab5e0cacc381c5ca1cc9aa6ad523576Alan Stern error = usb_autoresume_device(udev); 347645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 3489da82bd4649334817ef0e752a69eb99051645dadAlan Stern /* Terminate all URBs for this interface unless the driver 3499da82bd4649334817ef0e752a69eb99051645dadAlan Stern * supports "soft" unbinding. 3509da82bd4649334817ef0e752a69eb99051645dadAlan Stern */ 3519da82bd4649334817ef0e752a69eb99051645dadAlan Stern if (!driver->soft_unbind) 352ddeac4e75f2527a340f9dc655bde49bb2429b39bAlan Stern usb_disable_interface(udev, intf, false); 353ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 3548bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern driver->disconnect(intf); 355dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalez usb_cancel_queued_reset(intf); 356ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 35755151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern /* Reset other interface state. 35855151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern * We cannot do a Set-Interface if the device is suspended or 35955151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern * if it is prepared for a system sleep (since installing a new 36055151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern * altsetting means creating new endpoint device entries). 36155151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern * When either of these happens, defer the Set-Interface. 36255151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern */ 3632caf7fcdb8532045680f06b67b9e63f0c9613aaaAlan Stern if (intf->cur_altsetting->desc.bAlternateSetting == 0) { 3642caf7fcdb8532045680f06b67b9e63f0c9613aaaAlan Stern /* Already in altsetting 0 so skip Set-Interface. 3652caf7fcdb8532045680f06b67b9e63f0c9613aaaAlan Stern * Just re-enable it without affecting the endpoint toggles. 3662caf7fcdb8532045680f06b67b9e63f0c9613aaaAlan Stern */ 3672caf7fcdb8532045680f06b67b9e63f0c9613aaaAlan Stern usb_enable_interface(udev, intf, false); 368f76b168b6f117a49d36307053e1acbe30580ea5bAlan Stern } else if (!error && !intf->dev.power.is_prepared) { 3691e5ea5e32043094d96ca1e501110c1fbb631f693Oliver Neukum r = usb_set_interface(udev, intf->altsetting[0]. 37055151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern desc.bInterfaceNumber, 0); 3711e5ea5e32043094d96ca1e501110c1fbb631f693Oliver Neukum if (r < 0) 3721e5ea5e32043094d96ca1e501110c1fbb631f693Oliver Neukum intf->needs_altsetting0 = 1; 3731e5ea5e32043094d96ca1e501110c1fbb631f693Oliver Neukum } else { 37455151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern intf->needs_altsetting0 = 1; 3751e5ea5e32043094d96ca1e501110c1fbb631f693Oliver Neukum } 376ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman usb_set_intfdata(intf, NULL); 377645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 378ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman intf->condition = USB_INTERFACE_UNBOUND; 379645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern intf->needs_remote_wakeup = 0; 380645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 3819bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern /* Unbound interfaces are always runtime-PM-disabled and -suspended */ 38289842ae6515c49405e20c0629a6442b6885ad49dAlan Stern if (driver->supports_autosuspend) 38389842ae6515c49405e20c0629a6442b6885ad49dAlan Stern pm_runtime_disable(dev); 3849bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern pm_runtime_set_suspended(dev); 3859bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 3869bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern /* Undo any residual pm_autopm_get_interface_* calls */ 3879bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern for (r = atomic_read(&intf->pm_usage_cnt); r > 0; --r) 3889bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern usb_autopm_put_interface_no_suspend(intf); 3899bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern atomic_set(&intf->pm_usage_cnt, 0); 3909bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 391645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern if (!error) 39294fcda1f8ab5e0cacc381c5ca1cc9aa6ad523576Alan Stern usb_autosuspend_device(udev); 393ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 394ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman return 0; 395ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman} 396ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 39736e56a34586783c7986ce09d39db80b27c95ce24Alan Stern/** 39836e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * usb_driver_claim_interface - bind a driver to an interface 39936e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * @driver: the driver to be bound 40036e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * @iface: the interface to which it will be bound; must be in the 40136e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * usb device's active configuration 40236e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * @priv: driver data associated with that interface 40336e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * 40436e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * This is used by usb device drivers that need to claim more than one 40536e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * interface on a device when probing (audio and acm are current examples). 40636e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * No device driver should directly modify internal usb_interface or 40736e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * usb_device structure members. 40836e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * 40936e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * Few drivers should need to use this routine, since the most natural 41036e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * way to bind to an interface is to return the private data from 41136e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * the driver's probe() method. 41236e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * 413341487a837c02cbd674d4751061e7d098b0b8e98Greg Kroah-Hartman * Callers must own the device lock, so driver probe() entries don't need 414341487a837c02cbd674d4751061e7d098b0b8e98Greg Kroah-Hartman * extra locking, but other call contexts may need to explicitly claim that 415341487a837c02cbd674d4751061e7d098b0b8e98Greg Kroah-Hartman * lock. 41636e56a34586783c7986ce09d39db80b27c95ce24Alan Stern */ 41736e56a34586783c7986ce09d39db80b27c95ce24Alan Sternint usb_driver_claim_interface(struct usb_driver *driver, 4182c044a4803804708984931bcbd03314732e995d5Greg Kroah-Hartman struct usb_interface *iface, void *priv) 41936e56a34586783c7986ce09d39db80b27c95ce24Alan Stern{ 42036e56a34586783c7986ce09d39db80b27c95ce24Alan Stern struct device *dev = &iface->dev; 4211b21d5e166e104f8914441ef52e2cd50ce65b479Greg Kroah-Hartman int retval = 0; 42236e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 42336e56a34586783c7986ce09d39db80b27c95ce24Alan Stern if (dev->driver) 42436e56a34586783c7986ce09d39db80b27c95ce24Alan Stern return -EBUSY; 42536e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 4268bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern dev->driver = &driver->drvwrap.driver; 42736e56a34586783c7986ce09d39db80b27c95ce24Alan Stern usb_set_intfdata(iface, priv); 42878d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern iface->needs_binding = 0; 429645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 43036e56a34586783c7986ce09d39db80b27c95ce24Alan Stern iface->condition = USB_INTERFACE_BOUND; 4319bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 43289842ae6515c49405e20c0629a6442b6885ad49dAlan Stern /* Claimed interfaces are initially inactive (suspended) and 43389842ae6515c49405e20c0629a6442b6885ad49dAlan Stern * runtime-PM-enabled, but only if the driver has autosuspend 43489842ae6515c49405e20c0629a6442b6885ad49dAlan Stern * support. Otherwise they are marked active, to prevent the 43589842ae6515c49405e20c0629a6442b6885ad49dAlan Stern * device from being autosuspended, but left disabled. In either 43689842ae6515c49405e20c0629a6442b6885ad49dAlan Stern * case they are sensitive to their children's power states. 4379bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern */ 4389bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern pm_suspend_ignore_children(dev, false); 4399bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (driver->supports_autosuspend) 4409bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern pm_runtime_enable(dev); 44189842ae6515c49405e20c0629a6442b6885ad49dAlan Stern else 44289842ae6515c49405e20c0629a6442b6885ad49dAlan Stern pm_runtime_set_active(dev); 44336e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 44436e56a34586783c7986ce09d39db80b27c95ce24Alan Stern /* if interface was already added, bind now; else let 44536e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * the future device_add() bind it, bypassing probe() 44636e56a34586783c7986ce09d39db80b27c95ce24Alan Stern */ 44736e56a34586783c7986ce09d39db80b27c95ce24Alan Stern if (device_is_registered(dev)) 4481b21d5e166e104f8914441ef52e2cd50ce65b479Greg Kroah-Hartman retval = device_bind_driver(dev); 44936e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 4501b21d5e166e104f8914441ef52e2cd50ce65b479Greg Kroah-Hartman return retval; 45136e56a34586783c7986ce09d39db80b27c95ce24Alan Stern} 452782e70c6fc2290a0395850e8e02583b8b62264d8Greg Kroah-HartmanEXPORT_SYMBOL_GPL(usb_driver_claim_interface); 45336e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 45436e56a34586783c7986ce09d39db80b27c95ce24Alan Stern/** 45536e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * usb_driver_release_interface - unbind a driver from an interface 45636e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * @driver: the driver to be unbound 45736e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * @iface: the interface from which it will be unbound 45836e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * 45936e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * This can be used by drivers to release an interface without waiting 46036e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * for their disconnect() methods to be called. In typical cases this 46136e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * also causes the driver disconnect() method to be called. 46236e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * 46336e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * This call is synchronous, and may not be used in an interrupt context. 464341487a837c02cbd674d4751061e7d098b0b8e98Greg Kroah-Hartman * Callers must own the device lock, so driver disconnect() entries don't 465341487a837c02cbd674d4751061e7d098b0b8e98Greg Kroah-Hartman * need extra locking, but other call contexts may need to explicitly claim 466341487a837c02cbd674d4751061e7d098b0b8e98Greg Kroah-Hartman * that lock. 46736e56a34586783c7986ce09d39db80b27c95ce24Alan Stern */ 46836e56a34586783c7986ce09d39db80b27c95ce24Alan Sternvoid usb_driver_release_interface(struct usb_driver *driver, 46936e56a34586783c7986ce09d39db80b27c95ce24Alan Stern struct usb_interface *iface) 47036e56a34586783c7986ce09d39db80b27c95ce24Alan Stern{ 47136e56a34586783c7986ce09d39db80b27c95ce24Alan Stern struct device *dev = &iface->dev; 47236e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 47336e56a34586783c7986ce09d39db80b27c95ce24Alan Stern /* this should never happen, don't release something that's not ours */ 4748bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern if (!dev->driver || dev->driver != &driver->drvwrap.driver) 47536e56a34586783c7986ce09d39db80b27c95ce24Alan Stern return; 47636e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 47736e56a34586783c7986ce09d39db80b27c95ce24Alan Stern /* don't release from within disconnect() */ 47836e56a34586783c7986ce09d39db80b27c95ce24Alan Stern if (iface->condition != USB_INTERFACE_BOUND) 47936e56a34586783c7986ce09d39db80b27c95ce24Alan Stern return; 48091f8d063d30358fcb76831c238071f7d4b13c35eAlan Stern iface->condition = USB_INTERFACE_UNBINDING; 48136e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 48291f8d063d30358fcb76831c238071f7d4b13c35eAlan Stern /* Release via the driver core only if the interface 48391f8d063d30358fcb76831c238071f7d4b13c35eAlan Stern * has already been registered 48491f8d063d30358fcb76831c238071f7d4b13c35eAlan Stern */ 48536e56a34586783c7986ce09d39db80b27c95ce24Alan Stern if (device_is_registered(dev)) { 48636e56a34586783c7986ce09d39db80b27c95ce24Alan Stern device_release_driver(dev); 487dc023dceec861c60bc1d1a17a2c6496ddac26ee7Inaky Perez-Gonzalez } else { 4888e9394ce2412254ec69fd2a4f3e44a66eade2297Greg Kroah-Hartman device_lock(dev); 48991f8d063d30358fcb76831c238071f7d4b13c35eAlan Stern usb_unbind_interface(dev); 49091f8d063d30358fcb76831c238071f7d4b13c35eAlan Stern dev->driver = NULL; 4918e9394ce2412254ec69fd2a4f3e44a66eade2297Greg Kroah-Hartman device_unlock(dev); 49236e56a34586783c7986ce09d39db80b27c95ce24Alan Stern } 49336e56a34586783c7986ce09d39db80b27c95ce24Alan Stern} 494782e70c6fc2290a0395850e8e02583b8b62264d8Greg Kroah-HartmanEXPORT_SYMBOL_GPL(usb_driver_release_interface); 49536e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 496733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman/* returns 0 if no match, 1 if match */ 497bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartmanint usb_match_device(struct usb_device *dev, const struct usb_device_id *id) 498733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman{ 499733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) && 500733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman id->idVendor != le16_to_cpu(dev->descriptor.idVendor)) 501733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return 0; 502733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 503733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) && 504733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman id->idProduct != le16_to_cpu(dev->descriptor.idProduct)) 505733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return 0; 506733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 507733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman /* No need to test id->bcdDevice_lo != 0, since 0 is never 508733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman greater than any unsigned number. */ 509733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) && 510733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice))) 511733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return 0; 512733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 513733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) && 514733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice))) 515733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return 0; 516733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 517733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) && 518733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman (id->bDeviceClass != dev->descriptor.bDeviceClass)) 519733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return 0; 520733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 521733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) && 5222c044a4803804708984931bcbd03314732e995d5Greg Kroah-Hartman (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass)) 523733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return 0; 524733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 525733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) && 526733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol)) 527733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return 0; 528733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 529bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman return 1; 530bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman} 531bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman 532bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman/* returns 0 if no match, 1 if match */ 533bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartmanint usb_match_one_id(struct usb_interface *interface, 534bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman const struct usb_device_id *id) 535bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman{ 536bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman struct usb_host_interface *intf; 537bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman struct usb_device *dev; 538bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman 539bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman /* proc_connectinfo in devio.c may call us with id == NULL. */ 540bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman if (id == NULL) 541bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman return 0; 542bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman 543bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman intf = interface->cur_altsetting; 544bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman dev = interface_to_usbdev(interface); 545bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman 546bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman if (!usb_match_device(dev, id)) 547bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman return 0; 548bb417020ba8c559eb52f57379ba17f669f8f72cdGreg Kroah-Hartman 54993c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern /* The interface class, subclass, and protocol should never be 55093c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern * checked for a match if the device class is Vendor Specific, 55193c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern * unless the match record specifies the Vendor ID. */ 55293c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC && 55393c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern !(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) && 55493c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern (id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS | 55593c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern USB_DEVICE_ID_MATCH_INT_SUBCLASS | 55693c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern USB_DEVICE_ID_MATCH_INT_PROTOCOL))) 55793c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern return 0; 55893c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern 559733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) && 560733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman (id->bInterfaceClass != intf->desc.bInterfaceClass)) 561733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return 0; 562733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 563733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) && 564733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass)) 565733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return 0; 566733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 567733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) && 568733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol)) 569733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return 0; 570733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman 571733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return 1; 572733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman} 57393bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-HartmanEXPORT_SYMBOL_GPL(usb_match_one_id); 57493bacefc4cc0b53e1cb6a336d43847154fdf6886Greg Kroah-Hartman 575ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman/** 576ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * usb_match_id - find first usb_device_id matching device or interface 577ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * @interface: the interface of interest 578ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * @id: array of usb_device_id structures, terminated by zero entry 579ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 580ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * usb_match_id searches an array of usb_device_id's and returns 581ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * the first one matching the device or interface, or null. 582ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * This is used when binding (or rebinding) a driver to an interface. 583ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * Most USB device drivers will use this indirectly, through the usb core, 584ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * but some layered driver frameworks use it directly. 585ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * These device tables are exported with MODULE_DEVICE_TABLE, through 586ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * modutils, to support the driver loading functionality of USB hotplugging. 587ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 588ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * What Matches: 589ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 590ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * The "match_flags" element in a usb_device_id controls which 591ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * members are used. If the corresponding bit is set, the 592ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * value in the device_id must match its corresponding member 593ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * in the device or interface descriptor, or else the device_id 594ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * does not match. 595ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 596ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * "driver_info" is normally used only by device drivers, 597ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * but you can create a wildcard "matches anything" usb_device_id 598ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * as a driver's "modules.usbmap" entry if you provide an id with 599ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * only a nonzero "driver_info" field. If you do this, the USB device 600ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * driver's probe() routine should use additional intelligence to 601ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * decide whether to bind to the specified interface. 602ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 603ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * What Makes Good usb_device_id Tables: 604ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 605ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * The match algorithm is very simple, so that intelligence in 606ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * driver selection must come from smart driver id records. 607ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * Unless you have good reasons to use another selection policy, 608ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * provide match elements only in related groups, and order match 609ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * specifiers from specific to general. Use the macros provided 610ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * for that purpose if you can. 611ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 612ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * The most specific match specifiers use device descriptor 613ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * data. These are commonly used with product-specific matches; 614ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * the USB_DEVICE macro lets you provide vendor and product IDs, 615ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * and you can also match against ranges of product revisions. 616ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * These are widely used for devices with application or vendor 617ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * specific bDeviceClass values. 618ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 619ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * Matches based on device class/subclass/protocol specifications 620ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * are slightly more general; use the USB_DEVICE_INFO macro, or 621ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * its siblings. These are used with single-function devices 622ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * where bDeviceClass doesn't specify that each interface has 623ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * its own class. 624ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 625ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * Matches based on interface class/subclass/protocol are the 626ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * most general; they let drivers bind to any interface on a 627ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * multiple-function device. Use the USB_INTERFACE_INFO 628ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * macro, or its siblings, to match class-per-interface style 62993c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern * devices (as recorded in bInterfaceClass). 63093c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern * 63193c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern * Note that an entry created by USB_INTERFACE_INFO won't match 63293c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern * any interface if the device class is set to Vendor-Specific. 63393c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern * This is deliberate; according to the USB spec the meanings of 63493c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern * the interface class/subclass/protocol for these devices are also 63593c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern * vendor-specific, and hence matching against a standard product 63693c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern * class wouldn't work anyway. If you really want to use an 63793c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern * interface-based match for such a device, create a match record 63893c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern * that also specifies the vendor ID. (Unforunately there isn't a 63993c8bf45e083b89dffe3a708363c15c1b220c723Alan Stern * standard macro for creating records like this.) 640ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 641ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * Within those groups, remember that not all combinations are 642ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * meaningful. For example, don't give a product version range 643ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * without vendor and product IDs; or specify a protocol without 644ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * its associated class and subclass. 645ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman */ 646ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartmanconst struct usb_device_id *usb_match_id(struct usb_interface *interface, 647ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman const struct usb_device_id *id) 648ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman{ 649ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman /* proc_connectinfo in devio.c may call us with id == NULL. */ 650ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman if (id == NULL) 651ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman return NULL; 652ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 653ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman /* It is important to check that id->driver_info is nonzero, 654ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman since an entry that is all zeroes except for a nonzero 655ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman id->driver_info is the way to create an entry that 656ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman indicates that the driver want to examine every 657ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman device and interface. */ 658de6f92b9ee00e9f841fb1a63d0bd60593ec55dbeGreg Kroah-Hartman for (; id->idVendor || id->idProduct || id->bDeviceClass || 659de6f92b9ee00e9f841fb1a63d0bd60593ec55dbeGreg Kroah-Hartman id->bInterfaceClass || id->driver_info; id++) { 660733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman if (usb_match_one_id(interface, id)) 661733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman return id; 662ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman } 663ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 664ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman return NULL; 665ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman} 666782e70c6fc2290a0395850e8e02583b8b62264d8Greg Kroah-HartmanEXPORT_SYMBOL_GPL(usb_match_id); 667ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 6688bb22d2bdaac415965e7be1af8da2b8f3ee35f31Adrian Bunkstatic int usb_device_match(struct device *dev, struct device_driver *drv) 669ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman{ 6708bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern /* devices and interfaces are handled separately */ 6718bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern if (is_usb_device(dev)) { 672ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 6738bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern /* interface drivers never match devices */ 6748bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern if (!is_usb_device_driver(drv)) 6758bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern return 0; 676ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 6778bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern /* TODO: Add real matching code */ 678ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman return 1; 679ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 6805512966643adb17483efc5f61481a38fc33088bbKay Sievers } else if (is_usb_interface(dev)) { 6818bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern struct usb_interface *intf; 6828bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern struct usb_driver *usb_drv; 6838bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern const struct usb_device_id *id; 6848bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 6858bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern /* device drivers never match interfaces */ 6868bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern if (is_usb_device_driver(drv)) 6878bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern return 0; 6888bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 6898bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern intf = to_usb_interface(dev); 6908bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern usb_drv = to_usb_driver(drv); 6918bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 6928bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern id = usb_match_id(intf, usb_drv->id_table); 6938bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern if (id) 6948bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern return 1; 6958bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 6968bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern id = usb_match_dynamic_id(intf, usb_drv); 6978bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern if (id) 6988bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern return 1; 6998bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern } 7008bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 701ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman return 0; 702ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman} 703ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 70436e56a34586783c7986ce09d39db80b27c95ce24Alan Stern#ifdef CONFIG_HOTPLUG 7057eff2e7a8b65c25920207324e56611150eb1cd9aKay Sieversstatic int usb_uevent(struct device *dev, struct kobj_uevent_env *env) 70636e56a34586783c7986ce09d39db80b27c95ce24Alan Stern{ 70736e56a34586783c7986ce09d39db80b27c95ce24Alan Stern struct usb_device *usb_dev; 70836e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 7095512966643adb17483efc5f61481a38fc33088bbKay Sievers if (is_usb_device(dev)) { 710782da727b0d59e93c84a627948b1535a3db90392Alan Stern usb_dev = to_usb_device(dev); 7115512966643adb17483efc5f61481a38fc33088bbKay Sievers } else if (is_usb_interface(dev)) { 7129f8b17e643fe6aa505629658445849397bda4e4fKay Sievers struct usb_interface *intf = to_usb_interface(dev); 7135512966643adb17483efc5f61481a38fc33088bbKay Sievers 7148bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern usb_dev = interface_to_usbdev(intf); 7155512966643adb17483efc5f61481a38fc33088bbKay Sievers } else { 7165512966643adb17483efc5f61481a38fc33088bbKay Sievers return 0; 7178bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern } 71836e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 71936e56a34586783c7986ce09d39db80b27c95ce24Alan Stern if (usb_dev->devnum < 0) { 720cceffe9348f93188d7811bda95924d4bd3040d0fAlan Stern /* driver is often null here; dev_dbg() would oops */ 7217071a3ce0ca058ad2a9e3e8c33f30fb0bce62005Kay Sievers pr_debug("usb %s: already deleted?\n", dev_name(dev)); 72236e56a34586783c7986ce09d39db80b27c95ce24Alan Stern return -ENODEV; 72336e56a34586783c7986ce09d39db80b27c95ce24Alan Stern } 72436e56a34586783c7986ce09d39db80b27c95ce24Alan Stern if (!usb_dev->bus) { 7257071a3ce0ca058ad2a9e3e8c33f30fb0bce62005Kay Sievers pr_debug("usb %s: bus removed?\n", dev_name(dev)); 72636e56a34586783c7986ce09d39db80b27c95ce24Alan Stern return -ENODEV; 72736e56a34586783c7986ce09d39db80b27c95ce24Alan Stern } 72836e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 72936e56a34586783c7986ce09d39db80b27c95ce24Alan Stern#ifdef CONFIG_USB_DEVICEFS 73036e56a34586783c7986ce09d39db80b27c95ce24Alan Stern /* If this is available, userspace programs can directly read 73136e56a34586783c7986ce09d39db80b27c95ce24Alan Stern * all the device descriptors we don't tell them about. Or 7329f8b17e643fe6aa505629658445849397bda4e4fKay Sievers * act as usermode drivers. 73336e56a34586783c7986ce09d39db80b27c95ce24Alan Stern */ 7347eff2e7a8b65c25920207324e56611150eb1cd9aKay Sievers if (add_uevent_var(env, "DEVICE=/proc/bus/usb/%03d/%03d", 73536e56a34586783c7986ce09d39db80b27c95ce24Alan Stern usb_dev->bus->busnum, usb_dev->devnum)) 73636e56a34586783c7986ce09d39db80b27c95ce24Alan Stern return -ENOMEM; 73736e56a34586783c7986ce09d39db80b27c95ce24Alan Stern#endif 73836e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 73936e56a34586783c7986ce09d39db80b27c95ce24Alan Stern /* per-device configurations are common */ 7407eff2e7a8b65c25920207324e56611150eb1cd9aKay Sievers if (add_uevent_var(env, "PRODUCT=%x/%x/%x", 74136e56a34586783c7986ce09d39db80b27c95ce24Alan Stern le16_to_cpu(usb_dev->descriptor.idVendor), 74236e56a34586783c7986ce09d39db80b27c95ce24Alan Stern le16_to_cpu(usb_dev->descriptor.idProduct), 74336e56a34586783c7986ce09d39db80b27c95ce24Alan Stern le16_to_cpu(usb_dev->descriptor.bcdDevice))) 74436e56a34586783c7986ce09d39db80b27c95ce24Alan Stern return -ENOMEM; 74536e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 74636e56a34586783c7986ce09d39db80b27c95ce24Alan Stern /* class-based driver binding models */ 7477eff2e7a8b65c25920207324e56611150eb1cd9aKay Sievers if (add_uevent_var(env, "TYPE=%d/%d/%d", 74836e56a34586783c7986ce09d39db80b27c95ce24Alan Stern usb_dev->descriptor.bDeviceClass, 74936e56a34586783c7986ce09d39db80b27c95ce24Alan Stern usb_dev->descriptor.bDeviceSubClass, 75036e56a34586783c7986ce09d39db80b27c95ce24Alan Stern usb_dev->descriptor.bDeviceProtocol)) 75136e56a34586783c7986ce09d39db80b27c95ce24Alan Stern return -ENOMEM; 75236e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 75336e56a34586783c7986ce09d39db80b27c95ce24Alan Stern return 0; 75436e56a34586783c7986ce09d39db80b27c95ce24Alan Stern} 75536e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 75636e56a34586783c7986ce09d39db80b27c95ce24Alan Stern#else 75736e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 7587eff2e7a8b65c25920207324e56611150eb1cd9aKay Sieversstatic int usb_uevent(struct device *dev, struct kobj_uevent_env *env) 75936e56a34586783c7986ce09d39db80b27c95ce24Alan Stern{ 76036e56a34586783c7986ce09d39db80b27c95ce24Alan Stern return -ENODEV; 76136e56a34586783c7986ce09d39db80b27c95ce24Alan Stern} 76236e56a34586783c7986ce09d39db80b27c95ce24Alan Stern#endif /* CONFIG_HOTPLUG */ 76336e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 764ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman/** 7658bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * usb_register_device_driver - register a USB device (not interface) driver 7668bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * @new_udriver: USB operations for the device driver 7672143acc6dc79bdbff812f02a7dc5ab9d4fc81fc8Greg Kroah-Hartman * @owner: module owner of this driver. 768ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 7698bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * Registers a USB device driver with the USB core. The list of 7708bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * unattached devices will be rescanned whenever a new driver is 7718bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * added, allowing the new driver to attach to any recognized devices. 7728bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * Returns a negative error code on failure and 0 on success. 7738bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern */ 7748bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Sternint usb_register_device_driver(struct usb_device_driver *new_udriver, 7758bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern struct module *owner) 7768bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern{ 7778bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern int retval = 0; 7788bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 7798bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern if (usb_disabled()) 7808bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern return -ENODEV; 7818bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 7828bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern new_udriver->drvwrap.for_devices = 1; 7838bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern new_udriver->drvwrap.driver.name = (char *) new_udriver->name; 7848bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern new_udriver->drvwrap.driver.bus = &usb_bus_type; 7858bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern new_udriver->drvwrap.driver.probe = usb_probe_device; 7868bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern new_udriver->drvwrap.driver.remove = usb_unbind_device; 7878bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern new_udriver->drvwrap.driver.owner = owner; 7888bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 7898bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern retval = driver_register(&new_udriver->drvwrap.driver); 7908bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 7918bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern if (!retval) { 7928bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern pr_info("%s: registered new device driver %s\n", 7938bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern usbcore_name, new_udriver->name); 7948bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern usbfs_update_special(); 7958bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern } else { 7968bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern printk(KERN_ERR "%s: error %d registering device " 7978bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern " driver %s\n", 7988bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern usbcore_name, retval, new_udriver->name); 7998bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern } 8008bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 8018bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern return retval; 8028bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern} 8038bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan SternEXPORT_SYMBOL_GPL(usb_register_device_driver); 8048bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 8058bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern/** 8068bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * usb_deregister_device_driver - unregister a USB device (not interface) driver 8078bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * @udriver: USB operations of the device driver to unregister 8088bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * Context: must be able to sleep 8098bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * 8108bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * Unlinks the specified driver from the internal USB driver list. 8118bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern */ 8128bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Sternvoid usb_deregister_device_driver(struct usb_device_driver *udriver) 8138bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern{ 8148bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern pr_info("%s: deregistering device driver %s\n", 8158bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern usbcore_name, udriver->name); 8168bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 8178bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern driver_unregister(&udriver->drvwrap.driver); 8188bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern usbfs_update_special(); 8198bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern} 8208bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan SternEXPORT_SYMBOL_GPL(usb_deregister_device_driver); 8218bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern 8228bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern/** 8238bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * usb_register_driver - register a USB interface driver 8248bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * @new_driver: USB operations for the interface driver 8258bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * @owner: module owner of this driver. 826892705a1e1b4d0f9f6c5ac57f777b8055525bf68Randy Dunlap * @mod_name: module name string 8278bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * 8288bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * Registers a USB interface driver with the USB core. The list of 8298bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * unattached interfaces will be rescanned whenever a new driver is 8308bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * added, allowing the new driver to attach to any recognized interfaces. 831ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * Returns a negative error code on failure and 0 on success. 832ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 833ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * NOTE: if you want your driver to use the USB major number, you must call 834ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * usb_register_dev() to enable that functionality. This function no longer 835ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * takes care of that. 836ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman */ 83780f745fb1b0fb11383cbb8df2c36aaaa0399b6e6Greg Kroah-Hartmanint usb_register_driver(struct usb_driver *new_driver, struct module *owner, 83880f745fb1b0fb11383cbb8df2c36aaaa0399b6e6Greg Kroah-Hartman const char *mod_name) 839ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman{ 840ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman int retval = 0; 841ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 842ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman if (usb_disabled()) 843ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman return -ENODEV; 844ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 8458bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern new_driver->drvwrap.for_devices = 0; 8468bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern new_driver->drvwrap.driver.name = (char *) new_driver->name; 8478bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern new_driver->drvwrap.driver.bus = &usb_bus_type; 8488bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern new_driver->drvwrap.driver.probe = usb_probe_interface; 8498bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern new_driver->drvwrap.driver.remove = usb_unbind_interface; 8508bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern new_driver->drvwrap.driver.owner = owner; 85180f745fb1b0fb11383cbb8df2c36aaaa0399b6e6Greg Kroah-Hartman new_driver->drvwrap.driver.mod_name = mod_name; 852733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman spin_lock_init(&new_driver->dynids.lock); 853733260ff9c45bd4db60f45d17e8560a4a68dff4dGreg Kroah-Hartman INIT_LIST_HEAD(&new_driver->dynids.list); 854ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 8558bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern retval = driver_register(&new_driver->drvwrap.driver); 8560c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan if (retval) 8570c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan goto out; 858ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 8590c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan usbfs_update_special(); 8600c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan 861ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern retval = usb_create_newid_files(new_driver); 8620c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan if (retval) 8630c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan goto out_newid; 8640c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan 8650c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan pr_info("%s: registered new interface driver %s\n", 866ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman usbcore_name, new_driver->name); 867ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 8680c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquanout: 869ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman return retval; 8700c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan 8710c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquanout_newid: 8720c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan driver_unregister(&new_driver->drvwrap.driver); 8730c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan 8740c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan printk(KERN_ERR "%s: error %d registering interface " 8750c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan " driver %s\n", 8760c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan usbcore_name, retval, new_driver->name); 8770c7a2b72746a96f999fd2728520d03d94879be69CHENG Renquan goto out; 878ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman} 879782e70c6fc2290a0395850e8e02583b8b62264d8Greg Kroah-HartmanEXPORT_SYMBOL_GPL(usb_register_driver); 880ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 881ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman/** 8828bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * usb_deregister - unregister a USB interface driver 8838bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern * @driver: USB operations of the interface driver to unregister 884ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * Context: must be able to sleep 885ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 886ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * Unlinks the specified driver from the internal USB driver list. 887ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * 888ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * NOTE: If you called usb_register_dev(), you still need to call 889ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * usb_deregister_dev() to clean up your driver's allocated minor numbers, 890ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman * this * call will no longer do it for you. 891ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman */ 892ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartmanvoid usb_deregister(struct usb_driver *driver) 893ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman{ 8948bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern pr_info("%s: deregistering interface driver %s\n", 8958bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern usbcore_name, driver->name); 896ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 897ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern usb_remove_newid_files(driver); 8988bb54ab573ecd1b4fe2ed66416a8d99a86e65316Alan Stern driver_unregister(&driver->drvwrap.driver); 899ed283e9f0a2cc0541870828c76c6c6997c51a318Alan Stern usb_free_dynids(driver); 900ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman 901ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman usbfs_update_special(); 902ddae41be6145f5f9cb4e6df35661a09121b90672Greg Kroah-Hartman} 903782e70c6fc2290a0395850e8e02583b8b62264d8Greg Kroah-HartmanEXPORT_SYMBOL_GPL(usb_deregister); 90436e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 90578d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern/* Forced unbinding of a USB interface driver, either because 90678d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern * it doesn't support pre_reset/post_reset/reset_resume or 90778d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern * because it doesn't support suspend/resume. 90878d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern * 90978d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern * The caller must hold @intf's device's lock, but not its pm_mutex 91078d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern * and not @intf->dev.sem. 91178d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern */ 91278d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Sternvoid usb_forced_unbind_intf(struct usb_interface *intf) 91378d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern{ 91478d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern struct usb_driver *driver = to_usb_driver(intf->dev.driver); 91578d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern 91678d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern dev_dbg(&intf->dev, "forced unbind\n"); 91778d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern usb_driver_release_interface(driver, intf); 91878d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern 91978d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern /* Mark the interface for later rebinding */ 92078d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern intf->needs_binding = 1; 92178d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern} 92278d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern 92378d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern/* Delayed forced unbinding of a USB interface driver and scan 92478d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern * for rebinding. 92578d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern * 92678d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern * The caller must hold @intf's device's lock, but not its pm_mutex 92778d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern * and not @intf->dev.sem. 92878d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern * 9295096aedcd2eb70fbea83f09281f97f9ec973d9deAlan Stern * Note: Rebinds will be skipped if a system sleep transition is in 9305096aedcd2eb70fbea83f09281f97f9ec973d9deAlan Stern * progress and the PM "complete" callback hasn't occurred yet. 93178d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern */ 93278d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Sternvoid usb_rebind_intf(struct usb_interface *intf) 93378d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern{ 93478d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern int rc; 93578d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern 93678d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern /* Delayed unbind of an existing driver */ 9371493138af1463112e42eebcdab5db61452821e97Oliver Neukum if (intf->dev.driver) 9381493138af1463112e42eebcdab5db61452821e97Oliver Neukum usb_forced_unbind_intf(intf); 93978d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern 94078d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern /* Try to rebind the interface */ 941f76b168b6f117a49d36307053e1acbe30580ea5bAlan Stern if (!intf->dev.power.is_prepared) { 9425096aedcd2eb70fbea83f09281f97f9ec973d9deAlan Stern intf->needs_binding = 0; 9435096aedcd2eb70fbea83f09281f97f9ec973d9deAlan Stern rc = device_attach(&intf->dev); 9445096aedcd2eb70fbea83f09281f97f9ec973d9deAlan Stern if (rc < 0) 9455096aedcd2eb70fbea83f09281f97f9ec973d9deAlan Stern dev_warn(&intf->dev, "rebind failed: %d\n", rc); 9465096aedcd2eb70fbea83f09281f97f9ec973d9deAlan Stern } 94778d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern} 94878d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern 9499ff78433f0aeb1f731a22a90206b685df4eaf52eAlan Stern#ifdef CONFIG_PM 9509ff78433f0aeb1f731a22a90206b685df4eaf52eAlan Stern 9511493138af1463112e42eebcdab5db61452821e97Oliver Neukum/* Unbind drivers for @udev's interfaces that don't support suspend/resume 9521493138af1463112e42eebcdab5db61452821e97Oliver Neukum * There is no check for reset_resume here because it can be determined 9531493138af1463112e42eebcdab5db61452821e97Oliver Neukum * only during resume whether reset_resume is needed. 95478d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern * 95578d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern * The caller must hold @udev's device lock. 95678d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern */ 9571493138af1463112e42eebcdab5db61452821e97Oliver Neukumstatic void unbind_no_pm_drivers_interfaces(struct usb_device *udev) 95878d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern{ 95978d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern struct usb_host_config *config; 96078d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern int i; 96178d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern struct usb_interface *intf; 96278d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern struct usb_driver *drv; 96378d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern 96478d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern config = udev->actconfig; 96578d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern if (config) { 96678d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern for (i = 0; i < config->desc.bNumInterfaces; ++i) { 96778d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern intf = config->interface[i]; 9681493138af1463112e42eebcdab5db61452821e97Oliver Neukum 9691493138af1463112e42eebcdab5db61452821e97Oliver Neukum if (intf->dev.driver) { 9701493138af1463112e42eebcdab5db61452821e97Oliver Neukum drv = to_usb_driver(intf->dev.driver); 9711493138af1463112e42eebcdab5db61452821e97Oliver Neukum if (!drv->suspend || !drv->resume) 9721493138af1463112e42eebcdab5db61452821e97Oliver Neukum usb_forced_unbind_intf(intf); 97378d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern } 97478d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern } 97578d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern } 97678d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern} 97778d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern 9781493138af1463112e42eebcdab5db61452821e97Oliver Neukum/* Unbind drivers for @udev's interfaces that failed to support reset-resume. 9791493138af1463112e42eebcdab5db61452821e97Oliver Neukum * These interfaces have the needs_binding flag set by usb_resume_interface(). 9801493138af1463112e42eebcdab5db61452821e97Oliver Neukum * 9811493138af1463112e42eebcdab5db61452821e97Oliver Neukum * The caller must hold @udev's device lock. 9821493138af1463112e42eebcdab5db61452821e97Oliver Neukum */ 9831493138af1463112e42eebcdab5db61452821e97Oliver Neukumstatic void unbind_no_reset_resume_drivers_interfaces(struct usb_device *udev) 9841493138af1463112e42eebcdab5db61452821e97Oliver Neukum{ 9851493138af1463112e42eebcdab5db61452821e97Oliver Neukum struct usb_host_config *config; 9861493138af1463112e42eebcdab5db61452821e97Oliver Neukum int i; 9871493138af1463112e42eebcdab5db61452821e97Oliver Neukum struct usb_interface *intf; 9881493138af1463112e42eebcdab5db61452821e97Oliver Neukum 9891493138af1463112e42eebcdab5db61452821e97Oliver Neukum config = udev->actconfig; 9901493138af1463112e42eebcdab5db61452821e97Oliver Neukum if (config) { 9911493138af1463112e42eebcdab5db61452821e97Oliver Neukum for (i = 0; i < config->desc.bNumInterfaces; ++i) { 9921493138af1463112e42eebcdab5db61452821e97Oliver Neukum intf = config->interface[i]; 9931493138af1463112e42eebcdab5db61452821e97Oliver Neukum if (intf->dev.driver && intf->needs_binding) 9941493138af1463112e42eebcdab5db61452821e97Oliver Neukum usb_forced_unbind_intf(intf); 9951493138af1463112e42eebcdab5db61452821e97Oliver Neukum } 9961493138af1463112e42eebcdab5db61452821e97Oliver Neukum } 9971493138af1463112e42eebcdab5db61452821e97Oliver Neukum} 9981493138af1463112e42eebcdab5db61452821e97Oliver Neukum 9991493138af1463112e42eebcdab5db61452821e97Oliver Neukumstatic void do_rebind_interfaces(struct usb_device *udev) 10001493138af1463112e42eebcdab5db61452821e97Oliver Neukum{ 10011493138af1463112e42eebcdab5db61452821e97Oliver Neukum struct usb_host_config *config; 10021493138af1463112e42eebcdab5db61452821e97Oliver Neukum int i; 10031493138af1463112e42eebcdab5db61452821e97Oliver Neukum struct usb_interface *intf; 10041493138af1463112e42eebcdab5db61452821e97Oliver Neukum 10051493138af1463112e42eebcdab5db61452821e97Oliver Neukum config = udev->actconfig; 10061493138af1463112e42eebcdab5db61452821e97Oliver Neukum if (config) { 10071493138af1463112e42eebcdab5db61452821e97Oliver Neukum for (i = 0; i < config->desc.bNumInterfaces; ++i) { 10081493138af1463112e42eebcdab5db61452821e97Oliver Neukum intf = config->interface[i]; 10091493138af1463112e42eebcdab5db61452821e97Oliver Neukum if (intf->needs_binding) 10101493138af1463112e42eebcdab5db61452821e97Oliver Neukum usb_rebind_intf(intf); 10111493138af1463112e42eebcdab5db61452821e97Oliver Neukum } 10121493138af1463112e42eebcdab5db61452821e97Oliver Neukum } 10131493138af1463112e42eebcdab5db61452821e97Oliver Neukum} 10141493138af1463112e42eebcdab5db61452821e97Oliver Neukum 1015d5ec1686ba96eb75e132196c486cc0521b00f12cStephen Hemmingerstatic int usb_suspend_device(struct usb_device *udev, pm_message_t msg) 101636e56a34586783c7986ce09d39db80b27c95ce24Alan Stern{ 1017782da727b0d59e93c84a627948b1535a3db90392Alan Stern struct usb_device_driver *udriver; 10182bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern int status = 0; 101936e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 1020114b368c07964caa3f4e1fa575b16e87fa11936cAlan Stern if (udev->state == USB_STATE_NOTATTACHED || 1021114b368c07964caa3f4e1fa575b16e87fa11936cAlan Stern udev->state == USB_STATE_SUSPENDED) 1022114b368c07964caa3f4e1fa575b16e87fa11936cAlan Stern goto done; 1023114b368c07964caa3f4e1fa575b16e87fa11936cAlan Stern 1024b6f6436da0c6853eedad86f5075b139c1a3bcb5dAlan Stern /* For devices that don't have a driver, we do a generic suspend. */ 1025b6f6436da0c6853eedad86f5075b139c1a3bcb5dAlan Stern if (udev->dev.driver) 1026b6f6436da0c6853eedad86f5075b139c1a3bcb5dAlan Stern udriver = to_usb_device_driver(udev->dev.driver); 1027b6f6436da0c6853eedad86f5075b139c1a3bcb5dAlan Stern else { 1028645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern udev->do_remote_wakeup = 0; 1029b6f6436da0c6853eedad86f5075b139c1a3bcb5dAlan Stern udriver = &usb_generic_driver; 10301c5df7e705671f11a71112eb3a1f9765cd1719f9Alan Stern } 10312bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern status = udriver->suspend(udev, msg); 10322bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern 103320dfdad74a2baabeecc2896c770efcbf698b9b8dAlan Stern done: 1034441b62c1edb986827154768d89bbac0ba779984fHarvey Harrison dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status); 10352bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern return status; 10361cc8a25d5b680ff656927ffa9b66fae6b415b1d3Alan Stern} 10371cc8a25d5b680ff656927ffa9b66fae6b415b1d3Alan Stern 103865bfd2967c906ca322a4bb69a285fe0de8916ac6Alan Sternstatic int usb_resume_device(struct usb_device *udev, pm_message_t msg) 10391cc8a25d5b680ff656927ffa9b66fae6b415b1d3Alan Stern{ 10401cc8a25d5b680ff656927ffa9b66fae6b415b1d3Alan Stern struct usb_device_driver *udriver; 10412bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern int status = 0; 104236e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 10430458d5b4c9cc4ca0f62625d0144ddc4b4bc97a3cAlan Stern if (udev->state == USB_STATE_NOTATTACHED) 10440458d5b4c9cc4ca0f62625d0144ddc4b4bc97a3cAlan Stern goto done; 10451cc8a25d5b680ff656927ffa9b66fae6b415b1d3Alan Stern 10461c5df7e705671f11a71112eb3a1f9765cd1719f9Alan Stern /* Can't resume it if it doesn't have a driver. */ 10471c5df7e705671f11a71112eb3a1f9765cd1719f9Alan Stern if (udev->dev.driver == NULL) { 10481c5df7e705671f11a71112eb3a1f9765cd1719f9Alan Stern status = -ENOTCONN; 10492bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern goto done; 10501c5df7e705671f11a71112eb3a1f9765cd1719f9Alan Stern } 10511c5df7e705671f11a71112eb3a1f9765cd1719f9Alan Stern 10526d19c009cc780c63de25a046509ebc9473809fd6Alan Stern /* Non-root devices on a full/low-speed bus must wait for their 10536d19c009cc780c63de25a046509ebc9473809fd6Alan Stern * companion high-speed root hub, in case a handoff is needed. 10546d19c009cc780c63de25a046509ebc9473809fd6Alan Stern */ 10555b1b0b812a7b1a5b968c5d06d90d1cb88621b941Alan Stern if (!PMSG_IS_AUTO(msg) && udev->parent && udev->bus->hs_companion) 10566d19c009cc780c63de25a046509ebc9473809fd6Alan Stern device_pm_wait_for_dev(&udev->dev, 10576d19c009cc780c63de25a046509ebc9473809fd6Alan Stern &udev->bus->hs_companion->root_hub->dev); 10586d19c009cc780c63de25a046509ebc9473809fd6Alan Stern 10596bc6cff52e0c4c4c876b1b8a5750041da61ad42bAlan Stern if (udev->quirks & USB_QUIRK_RESET_RESUME) 10606bc6cff52e0c4c4c876b1b8a5750041da61ad42bAlan Stern udev->reset_resume = 1; 10616bc6cff52e0c4c4c876b1b8a5750041da61ad42bAlan Stern 10621cc8a25d5b680ff656927ffa9b66fae6b415b1d3Alan Stern udriver = to_usb_device_driver(udev->dev.driver); 106365bfd2967c906ca322a4bb69a285fe0de8916ac6Alan Stern status = udriver->resume(udev, msg); 10642bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern 106520dfdad74a2baabeecc2896c770efcbf698b9b8dAlan Stern done: 1066441b62c1edb986827154768d89bbac0ba779984fHarvey Harrison dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status); 10672bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern return status; 10681cc8a25d5b680ff656927ffa9b66fae6b415b1d3Alan Stern} 10691cc8a25d5b680ff656927ffa9b66fae6b415b1d3Alan Stern 107065605ae8e587d714f73e674369bc4cd5a1e53a9bAlan Sternstatic int usb_suspend_interface(struct usb_device *udev, 107165605ae8e587d714f73e674369bc4cd5a1e53a9bAlan Stern struct usb_interface *intf, pm_message_t msg) 10721cc8a25d5b680ff656927ffa9b66fae6b415b1d3Alan Stern{ 10731cc8a25d5b680ff656927ffa9b66fae6b415b1d3Alan Stern struct usb_driver *driver; 10742bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern int status = 0; 10751cc8a25d5b680ff656927ffa9b66fae6b415b1d3Alan Stern 10769bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (udev->state == USB_STATE_NOTATTACHED || 10779bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern intf->condition == USB_INTERFACE_UNBOUND) 10782bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern goto done; 1079114b368c07964caa3f4e1fa575b16e87fa11936cAlan Stern driver = to_usb_driver(intf->dev.driver); 108036e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 1081e78832cdca2ddd23c15abaed642cad1a39b3e122Oliver Neukum /* at this time we know the driver supports suspend */ 1082e78832cdca2ddd23c15abaed642cad1a39b3e122Oliver Neukum status = driver->suspend(intf, msg); 1083e78832cdca2ddd23c15abaed642cad1a39b3e122Oliver Neukum if (status && !PMSG_IS_AUTO(msg)) 1084e78832cdca2ddd23c15abaed642cad1a39b3e122Oliver Neukum dev_err(&intf->dev, "suspend error %d\n", status); 10852bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern 108620dfdad74a2baabeecc2896c770efcbf698b9b8dAlan Stern done: 1087441b62c1edb986827154768d89bbac0ba779984fHarvey Harrison dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status); 108836e56a34586783c7986ce09d39db80b27c95ce24Alan Stern return status; 108936e56a34586783c7986ce09d39db80b27c95ce24Alan Stern} 109036e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 109165605ae8e587d714f73e674369bc4cd5a1e53a9bAlan Sternstatic int usb_resume_interface(struct usb_device *udev, 109265bfd2967c906ca322a4bb69a285fe0de8916ac6Alan Stern struct usb_interface *intf, pm_message_t msg, int reset_resume) 109336e56a34586783c7986ce09d39db80b27c95ce24Alan Stern{ 10941cc8a25d5b680ff656927ffa9b66fae6b415b1d3Alan Stern struct usb_driver *driver; 10952bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern int status = 0; 109636e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 10979bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (udev->state == USB_STATE_NOTATTACHED) 10982bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern goto done; 109936e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 1100645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern /* Don't let autoresume interfere with unbinding */ 1101645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern if (intf->condition == USB_INTERFACE_UNBINDING) 1102645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern goto done; 1103645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 11041c5df7e705671f11a71112eb3a1f9765cd1719f9Alan Stern /* Can't resume it if it doesn't have a driver. */ 110555151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern if (intf->condition == USB_INTERFACE_UNBOUND) { 110655151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern 110755151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern /* Carry out a deferred switch to altsetting 0 */ 1108f76b168b6f117a49d36307053e1acbe30580ea5bAlan Stern if (intf->needs_altsetting0 && !intf->dev.power.is_prepared) { 110955151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern usb_set_interface(udev, intf->altsetting[0]. 111055151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern desc.bInterfaceNumber, 0); 111155151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern intf->needs_altsetting0 = 0; 111255151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern } 111378d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern goto done; 111455151d7daba185f94e9dc561a5a2ba36b5f647ddAlan Stern } 111578d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern 111678d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern /* Don't resume if the interface is marked for rebinding */ 111778d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern if (intf->needs_binding) 11182bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern goto done; 11191cc8a25d5b680ff656927ffa9b66fae6b415b1d3Alan Stern driver = to_usb_driver(intf->dev.driver); 112036e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 1121f07600cf9eb3ee92777b2001e564faa413144a99Alan Stern if (reset_resume) { 1122f07600cf9eb3ee92777b2001e564faa413144a99Alan Stern if (driver->reset_resume) { 1123f07600cf9eb3ee92777b2001e564faa413144a99Alan Stern status = driver->reset_resume(intf); 1124f07600cf9eb3ee92777b2001e564faa413144a99Alan Stern if (status) 1125f07600cf9eb3ee92777b2001e564faa413144a99Alan Stern dev_err(&intf->dev, "%s error %d\n", 1126f07600cf9eb3ee92777b2001e564faa413144a99Alan Stern "reset_resume", status); 1127f07600cf9eb3ee92777b2001e564faa413144a99Alan Stern } else { 112878d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern intf->needs_binding = 1; 1129f07600cf9eb3ee92777b2001e564faa413144a99Alan Stern dev_warn(&intf->dev, "no %s for driver %s?\n", 1130f07600cf9eb3ee92777b2001e564faa413144a99Alan Stern "reset_resume", driver->name); 1131f07600cf9eb3ee92777b2001e564faa413144a99Alan Stern } 1132f07600cf9eb3ee92777b2001e564faa413144a99Alan Stern } else { 1133e78832cdca2ddd23c15abaed642cad1a39b3e122Oliver Neukum status = driver->resume(intf); 1134e78832cdca2ddd23c15abaed642cad1a39b3e122Oliver Neukum if (status) 1135e78832cdca2ddd23c15abaed642cad1a39b3e122Oliver Neukum dev_err(&intf->dev, "resume error %d\n", status); 1136f07600cf9eb3ee92777b2001e564faa413144a99Alan Stern } 11372bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern 11382bf4086d7a7722b470aa24e1be725cc58619c6feAlan Sterndone: 1139441b62c1edb986827154768d89bbac0ba779984fHarvey Harrison dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status); 1140f07600cf9eb3ee92777b2001e564faa413144a99Alan Stern 114178d9a487ee961c356e1a934d9a92eca38ffb3a70Alan Stern /* Later we will unbind the driver and/or reprobe, if necessary */ 11422bf4086d7a7722b470aa24e1be725cc58619c6feAlan Stern return status; 114336e56a34586783c7986ce09d39db80b27c95ce24Alan Stern} 114436e56a34586783c7986ce09d39db80b27c95ce24Alan Stern 1145645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern/** 1146645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * usb_suspend_both - suspend a USB device and its interfaces 1147645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * @udev: the usb_device to suspend 1148645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * @msg: Power Management message describing this state transition 1149645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 1150645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * This is the central routine for suspending USB devices. It calls the 1151645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * suspend methods for all the interface drivers in @udev and then calls 1152645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * the suspend method for @udev itself. If an error occurs at any stage, 1153645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * all the interfaces which were suspended are resumed so that they remain 1154645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * in the same state as the device. 1155645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 11569bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * Autosuspend requests originating from a child device or an interface 11579bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * driver may be made without the protection of @udev's device lock, but 11589bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * all other suspend calls will hold the lock. Usbcore will insure that 11599bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * method calls do not arrive during bind, unbind, or reset operations. 11609bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * However drivers must be prepared to handle suspend calls arriving at 11619bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * unpredictable times. 1162645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 1163645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * This routine can run only in process context. 1164645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern */ 1165718efa64e30a5e9db0351d70c5a91969306a12d1Alan Sternstatic int usb_suspend_both(struct usb_device *udev, pm_message_t msg) 1166a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern{ 1167a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern int status = 0; 1168571dc79d62a163fd043de47d7d39bae58831e81eAlan Stern int i = 0, n = 0; 1169a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern struct usb_interface *intf; 1170645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 11711941044aa9632aa8debbb94a3c8a5ed0ebddade8Alan Stern if (udev->state == USB_STATE_NOTATTACHED || 11721941044aa9632aa8debbb94a3c8a5ed0ebddade8Alan Stern udev->state == USB_STATE_SUSPENDED) 11731941044aa9632aa8debbb94a3c8a5ed0ebddade8Alan Stern goto done; 1174a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern 1175645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern /* Suspend all the interfaces and then udev itself */ 1176a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern if (udev->actconfig) { 1177571dc79d62a163fd043de47d7d39bae58831e81eAlan Stern n = udev->actconfig->desc.bNumInterfaces; 1178571dc79d62a163fd043de47d7d39bae58831e81eAlan Stern for (i = n - 1; i >= 0; --i) { 1179a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern intf = udev->actconfig->interface[i]; 118065605ae8e587d714f73e674369bc4cd5a1e53a9bAlan Stern status = usb_suspend_interface(udev, intf, msg); 11810af212ba8f123c2eba151af7726c34a50b127962Alan Stern 11820af212ba8f123c2eba151af7726c34a50b127962Alan Stern /* Ignore errors during system sleep transitions */ 11835b1b0b812a7b1a5b968c5d06d90d1cb88621b941Alan Stern if (!PMSG_IS_AUTO(msg)) 11840af212ba8f123c2eba151af7726c34a50b127962Alan Stern status = 0; 1185a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern if (status != 0) 1186a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern break; 1187a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern } 1188a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern } 11890af212ba8f123c2eba151af7726c34a50b127962Alan Stern if (status == 0) { 1190d5ec1686ba96eb75e132196c486cc0521b00f12cStephen Hemminger status = usb_suspend_device(udev, msg); 1191a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern 1192cd4376e23a59a2adf3084cb5f4a523e6d5fd4e49Alan Stern /* 1193cd4376e23a59a2adf3084cb5f4a523e6d5fd4e49Alan Stern * Ignore errors from non-root-hub devices during 1194cd4376e23a59a2adf3084cb5f4a523e6d5fd4e49Alan Stern * system sleep transitions. For the most part, 1195cd4376e23a59a2adf3084cb5f4a523e6d5fd4e49Alan Stern * these devices should go to low power anyway when 1196cd4376e23a59a2adf3084cb5f4a523e6d5fd4e49Alan Stern * the entire bus is suspended. 1197cd4376e23a59a2adf3084cb5f4a523e6d5fd4e49Alan Stern */ 1198cd4376e23a59a2adf3084cb5f4a523e6d5fd4e49Alan Stern if (udev->parent && !PMSG_IS_AUTO(msg)) 11990af212ba8f123c2eba151af7726c34a50b127962Alan Stern status = 0; 12000af212ba8f123c2eba151af7726c34a50b127962Alan Stern } 12010af212ba8f123c2eba151af7726c34a50b127962Alan Stern 1202a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern /* If the suspend failed, resume interfaces that did get suspended */ 1203a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern if (status != 0) { 12049bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern msg.event ^= (PM_EVENT_SUSPEND | PM_EVENT_RESUME); 1205571dc79d62a163fd043de47d7d39bae58831e81eAlan Stern while (++i < n) { 1206a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern intf = udev->actconfig->interface[i]; 12079bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern usb_resume_interface(udev, intf, msg, 0); 1208a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern } 1209645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 12109bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern /* If the suspend succeeded then prevent any more URB submissions 12119bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * and flush any outstanding URBs. 12126840d2555afd66290be7a39b400b5e66a840b82dAlan Stern */ 1213ef7f6c7084b333c7524dcd297e0578d43733a2a2Alan Stern } else { 12146840d2555afd66290be7a39b400b5e66a840b82dAlan Stern udev->can_submit = 0; 12156840d2555afd66290be7a39b400b5e66a840b82dAlan Stern for (i = 0; i < 16; ++i) { 12166840d2555afd66290be7a39b400b5e66a840b82dAlan Stern usb_hcd_flush_endpoint(udev, udev->ep_out[i]); 12176840d2555afd66290be7a39b400b5e66a840b82dAlan Stern usb_hcd_flush_endpoint(udev, udev->ep_in[i]); 12186840d2555afd66290be7a39b400b5e66a840b82dAlan Stern } 1219ef7f6c7084b333c7524dcd297e0578d43733a2a2Alan Stern } 1220645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 12211941044aa9632aa8debbb94a3c8a5ed0ebddade8Alan Stern done: 1222441b62c1edb986827154768d89bbac0ba779984fHarvey Harrison dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status); 1223a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern return status; 1224a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern} 1225a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern 1226645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern/** 1227645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * usb_resume_both - resume a USB device and its interfaces 1228645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * @udev: the usb_device to resume 122965bfd2967c906ca322a4bb69a285fe0de8916ac6Alan Stern * @msg: Power Management message describing this state transition 1230645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 1231645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * This is the central routine for resuming USB devices. It calls the 1232645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * the resume method for @udev and then calls the resume methods for all 1233645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * the interface drivers in @udev. 1234645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 12359bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * Autoresume requests originating from a child device or an interface 12369bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * driver may be made without the protection of @udev's device lock, but 12379bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * all other resume calls will hold the lock. Usbcore will insure that 12389bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * method calls do not arrive during bind, unbind, or reset operations. 12399bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * However drivers must be prepared to handle resume calls arriving at 12409bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * unpredictable times. 1241645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 1242645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * This routine can run only in process context. 1243645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern */ 124465bfd2967c906ca322a4bb69a285fe0de8916ac6Alan Sternstatic int usb_resume_both(struct usb_device *udev, pm_message_t msg) 1245a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern{ 1246645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern int status = 0; 1247a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern int i; 1248a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern struct usb_interface *intf; 1249645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 12501941044aa9632aa8debbb94a3c8a5ed0ebddade8Alan Stern if (udev->state == USB_STATE_NOTATTACHED) { 12511941044aa9632aa8debbb94a3c8a5ed0ebddade8Alan Stern status = -ENODEV; 12521941044aa9632aa8debbb94a3c8a5ed0ebddade8Alan Stern goto done; 12531941044aa9632aa8debbb94a3c8a5ed0ebddade8Alan Stern } 12546840d2555afd66290be7a39b400b5e66a840b82dAlan Stern udev->can_submit = 1; 1255a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern 12569bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern /* Resume the device */ 12579bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (udev->state == USB_STATE_SUSPENDED || udev->reset_resume) 125865bfd2967c906ca322a4bb69a285fe0de8916ac6Alan Stern status = usb_resume_device(udev, msg); 1259114b368c07964caa3f4e1fa575b16e87fa11936cAlan Stern 12609bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern /* Resume the interfaces */ 1261a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern if (status == 0 && udev->actconfig) { 1262a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) { 1263a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern intf = udev->actconfig->interface[i]; 126465bfd2967c906ca322a4bb69a285fe0de8916ac6Alan Stern usb_resume_interface(udev, intf, msg, 126565bfd2967c906ca322a4bb69a285fe0de8916ac6Alan Stern udev->reset_resume); 1266a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern } 1267a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern } 1268c08512c761e7b9eaaab0e9167a389393f268e93cAlan Stern usb_mark_last_busy(udev); 1269645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 12701941044aa9632aa8debbb94a3c8a5ed0ebddade8Alan Stern done: 1271441b62c1edb986827154768d89bbac0ba779984fHarvey Harrison dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status); 127270a1c9e086c2e267fbc4533cb870f34999b531d6Alan Stern if (!status) 127370a1c9e086c2e267fbc4533cb870f34999b531d6Alan Stern udev->reset_resume = 0; 1274645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern return status; 1275645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern} 1276645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 12775f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Sternstatic void choose_wakeup(struct usb_device *udev, pm_message_t msg) 12785f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern{ 127948826626263d4a61d06fd8c5805da31f925aefa0Alan Stern int w; 12805f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern 12815f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern /* Remote wakeup is needed only when we actually go to sleep. 12825f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern * For things like FREEZE and QUIESCE, if the device is already 12835f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern * autosuspended then its current wakeup setting is okay. 12845f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern */ 12855f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_QUIESCE) { 12865f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern if (udev->state != USB_STATE_SUSPENDED) 12875f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern udev->do_remote_wakeup = 0; 12885f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern return; 12895f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern } 12905f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern 129148826626263d4a61d06fd8c5805da31f925aefa0Alan Stern /* Enable remote wakeup if it is allowed, even if no interface drivers 12925f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern * actually want it. 12935f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern */ 129448826626263d4a61d06fd8c5805da31f925aefa0Alan Stern w = device_may_wakeup(&udev->dev); 12955f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern 12965f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern /* If the device is autosuspended with the wrong wakeup setting, 12975f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern * autoresume now so the setting can be changed. 12985f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern */ 12995f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern if (udev->state == USB_STATE_SUSPENDED && w != udev->do_remote_wakeup) 13005f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern pm_runtime_resume(&udev->dev); 13015f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern udev->do_remote_wakeup = w; 13025f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern} 13035f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern 13049bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern/* The device lock is held by the PM core */ 13050c590e2361511997430130e10e372217c1128da6Alan Sternint usb_suspend(struct device *dev, pm_message_t msg) 13060c590e2361511997430130e10e372217c1128da6Alan Stern{ 13079bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern struct usb_device *udev = to_usb_device(dev); 13080c590e2361511997430130e10e372217c1128da6Alan Stern 13091493138af1463112e42eebcdab5db61452821e97Oliver Neukum unbind_no_pm_drivers_interfaces(udev); 13101493138af1463112e42eebcdab5db61452821e97Oliver Neukum 13111493138af1463112e42eebcdab5db61452821e97Oliver Neukum /* From now on we are sure all drivers support suspend/resume 13121493138af1463112e42eebcdab5db61452821e97Oliver Neukum * but not necessarily reset_resume() 13131493138af1463112e42eebcdab5db61452821e97Oliver Neukum * so we may still need to unbind and rebind upon resume 13141493138af1463112e42eebcdab5db61452821e97Oliver Neukum */ 13155f677f1d45b2bf08085bbba7394392dfa586fa8eAlan Stern choose_wakeup(udev, msg); 13169bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern return usb_suspend_both(udev, msg); 13170c590e2361511997430130e10e372217c1128da6Alan Stern} 13180c590e2361511997430130e10e372217c1128da6Alan Stern 13199bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern/* The device lock is held by the PM core */ 132098d9a82e5f753a2483d7b4638802d60e94e5d2e4Oliver Neukumint usb_resume_complete(struct device *dev) 13210c590e2361511997430130e10e372217c1128da6Alan Stern{ 132298d9a82e5f753a2483d7b4638802d60e94e5d2e4Oliver Neukum struct usb_device *udev = to_usb_device(dev); 13230c590e2361511997430130e10e372217c1128da6Alan Stern 13241493138af1463112e42eebcdab5db61452821e97Oliver Neukum /* For PM complete calls, all we do is rebind interfaces 13251493138af1463112e42eebcdab5db61452821e97Oliver Neukum * whose needs_binding flag is set 13261493138af1463112e42eebcdab5db61452821e97Oliver Neukum */ 132798d9a82e5f753a2483d7b4638802d60e94e5d2e4Oliver Neukum if (udev->state != USB_STATE_NOTATTACHED) 132898d9a82e5f753a2483d7b4638802d60e94e5d2e4Oliver Neukum do_rebind_interfaces(udev); 132998d9a82e5f753a2483d7b4638802d60e94e5d2e4Oliver Neukum return 0; 133098d9a82e5f753a2483d7b4638802d60e94e5d2e4Oliver Neukum} 13310c590e2361511997430130e10e372217c1128da6Alan Stern 133298d9a82e5f753a2483d7b4638802d60e94e5d2e4Oliver Neukum/* The device lock is held by the PM core */ 13330c590e2361511997430130e10e372217c1128da6Alan Sternint usb_resume(struct device *dev, pm_message_t msg) 13340c590e2361511997430130e10e372217c1128da6Alan Stern{ 13359bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern struct usb_device *udev = to_usb_device(dev); 13360c590e2361511997430130e10e372217c1128da6Alan Stern int status; 13370c590e2361511997430130e10e372217c1128da6Alan Stern 133898d9a82e5f753a2483d7b4638802d60e94e5d2e4Oliver Neukum /* For all calls, take the device back to full power and 13399bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * tell the PM core in case it was autosuspended previously. 13401493138af1463112e42eebcdab5db61452821e97Oliver Neukum * Unbind the interfaces that will need rebinding later, 13411493138af1463112e42eebcdab5db61452821e97Oliver Neukum * because they fail to support reset_resume. 13421493138af1463112e42eebcdab5db61452821e97Oliver Neukum * (This can't be done in usb_resume_interface() 134398d9a82e5f753a2483d7b4638802d60e94e5d2e4Oliver Neukum * above because it doesn't own the right set of locks.) 13440c590e2361511997430130e10e372217c1128da6Alan Stern */ 134598d9a82e5f753a2483d7b4638802d60e94e5d2e4Oliver Neukum status = usb_resume_both(udev, msg); 134698d9a82e5f753a2483d7b4638802d60e94e5d2e4Oliver Neukum if (status == 0) { 134798d9a82e5f753a2483d7b4638802d60e94e5d2e4Oliver Neukum pm_runtime_disable(dev); 134898d9a82e5f753a2483d7b4638802d60e94e5d2e4Oliver Neukum pm_runtime_set_active(dev); 134998d9a82e5f753a2483d7b4638802d60e94e5d2e4Oliver Neukum pm_runtime_enable(dev); 135098d9a82e5f753a2483d7b4638802d60e94e5d2e4Oliver Neukum unbind_no_reset_resume_drivers_interfaces(udev); 13519bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern } 13520c590e2361511997430130e10e372217c1128da6Alan Stern 13530c590e2361511997430130e10e372217c1128da6Alan Stern /* Avoid PM error messages for devices disconnected while suspended 13540c590e2361511997430130e10e372217c1128da6Alan Stern * as we'll display regular disconnect messages just a bit later. 13550c590e2361511997430130e10e372217c1128da6Alan Stern */ 13567491f13367919d97525b73b1fd38801ac83aac06Peter Chen if (status == -ENODEV || status == -ESHUTDOWN) 13579bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern status = 0; 13580c590e2361511997430130e10e372217c1128da6Alan Stern return status; 13590c590e2361511997430130e10e372217c1128da6Alan Stern} 13600c590e2361511997430130e10e372217c1128da6Alan Stern 13610c590e2361511997430130e10e372217c1128da6Alan Stern#endif /* CONFIG_PM */ 13620c590e2361511997430130e10e372217c1128da6Alan Stern 1363645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern#ifdef CONFIG_USB_SUSPEND 1364645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 1365088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern/** 1366088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern * usb_enable_autosuspend - allow a USB device to be autosuspended 1367088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern * @udev: the USB device which may be autosuspended 1368088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern * 1369088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern * This routine allows @udev to be autosuspended. An autosuspend won't 1370088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern * take place until the autosuspend_delay has elapsed and all the other 1371088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern * necessary conditions are satisfied. 1372088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern * 1373088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern * The caller must hold @udev's device lock. 1374088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern */ 13759e18c821659d836bd63f88df3c19729327728496Alan Sternvoid usb_enable_autosuspend(struct usb_device *udev) 1376088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern{ 13779e18c821659d836bd63f88df3c19729327728496Alan Stern pm_runtime_allow(&udev->dev); 1378088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern} 1379088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan SternEXPORT_SYMBOL_GPL(usb_enable_autosuspend); 1380088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern 1381088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern/** 1382088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern * usb_disable_autosuspend - prevent a USB device from being autosuspended 1383088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern * @udev: the USB device which may not be autosuspended 1384088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern * 1385088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern * This routine prevents @udev from being autosuspended and wakes it up 1386088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern * if it is already autosuspended. 1387088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern * 1388088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern * The caller must hold @udev's device lock. 1389088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern */ 13909e18c821659d836bd63f88df3c19729327728496Alan Sternvoid usb_disable_autosuspend(struct usb_device *udev) 1391088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern{ 13929e18c821659d836bd63f88df3c19729327728496Alan Stern pm_runtime_forbid(&udev->dev); 1393088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern} 1394088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan SternEXPORT_SYMBOL_GPL(usb_disable_autosuspend); 1395088f7fec8a0e683db72fd8826c5d3ab914e197b1Alan Stern 1396645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern/** 1397645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces 1398701f35af282e3955159bd30d3fb3f6ebafe8bff2Henrik Kretzschmar * @udev: the usb_device to autosuspend 1399645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 1400645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * This routine should be called when a core subsystem is finished using 1401645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * @udev and wants to allow it to autosuspend. Examples would be when 1402645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * @udev's device file in usbfs is closed or after a configuration change. 1403645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 14049bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * @udev's usage counter is decremented; if it drops to 0 and all the 14059bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * interfaces are inactive then a delayed autosuspend will be attempted. 14069bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * The attempt may fail (see autosuspend_check()). 1407645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 140862e299e61a6ffe8131fa85a984c3058b68586f5dAlan Stern * The caller must hold @udev's device lock. 1409645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 1410645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * This routine can run only in process context. 1411645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern */ 141294fcda1f8ab5e0cacc381c5ca1cc9aa6ad523576Alan Sternvoid usb_autosuspend_device(struct usb_device *udev) 1413645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern{ 141494fcda1f8ab5e0cacc381c5ca1cc9aa6ad523576Alan Stern int status; 141594fcda1f8ab5e0cacc381c5ca1cc9aa6ad523576Alan Stern 14166ddf27cdbc218a412d7e993fdc08e30eec2042ceMing Lei usb_mark_last_busy(udev); 1417fcc4a01eb8661226e80632327673f67bf6a5840bAlan Stern status = pm_runtime_put_sync_autosuspend(&udev->dev); 14189bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n", 14199bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern __func__, atomic_read(&udev->dev.power.usage_count), 14209bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern status); 1421645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern} 1422645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 1423645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern/** 1424645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * usb_autoresume_device - immediately autoresume a USB device and its interfaces 1425701f35af282e3955159bd30d3fb3f6ebafe8bff2Henrik Kretzschmar * @udev: the usb_device to autoresume 1426645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 1427645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * This routine should be called when a core subsystem wants to use @udev 142894fcda1f8ab5e0cacc381c5ca1cc9aa6ad523576Alan Stern * and needs to guarantee that it is not suspended. No autosuspend will 14299bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * occur until usb_autosuspend_device() is called. (Note that this will 14309bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * not prevent suspend events originating in the PM core.) Examples would 14319bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * be when @udev's device file in usbfs is opened or when a remote-wakeup 143294fcda1f8ab5e0cacc381c5ca1cc9aa6ad523576Alan Stern * request is received. 1433645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 143494fcda1f8ab5e0cacc381c5ca1cc9aa6ad523576Alan Stern * @udev's usage counter is incremented to prevent subsequent autosuspends. 143594fcda1f8ab5e0cacc381c5ca1cc9aa6ad523576Alan Stern * However if the autoresume fails then the usage counter is re-decremented. 1436645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 143762e299e61a6ffe8131fa85a984c3058b68586f5dAlan Stern * The caller must hold @udev's device lock. 1438645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 1439645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * This routine can run only in process context. 1440645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern */ 144194fcda1f8ab5e0cacc381c5ca1cc9aa6ad523576Alan Sternint usb_autoresume_device(struct usb_device *udev) 1442645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern{ 1443645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern int status; 1444645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 14459bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern status = pm_runtime_get_sync(&udev->dev); 14469bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (status < 0) 14479bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern pm_runtime_put_sync(&udev->dev); 14489bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n", 14499bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern __func__, atomic_read(&udev->dev.power.usage_count), 14509bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern status); 14519bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (status > 0) 14529bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern status = 0; 1453af4f76066d0fcb215ae389b8839d7ae37ce0e28bAlan Stern return status; 1454af4f76066d0fcb215ae389b8839d7ae37ce0e28bAlan Stern} 1455af4f76066d0fcb215ae389b8839d7ae37ce0e28bAlan Stern 1456645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern/** 1457645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * usb_autopm_put_interface - decrement a USB interface's PM-usage counter 1458701f35af282e3955159bd30d3fb3f6ebafe8bff2Henrik Kretzschmar * @intf: the usb_interface whose counter should be decremented 1459645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 1460645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * This routine should be called by an interface driver when it is 1461645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * finished using @intf and wants to allow it to autosuspend. A typical 1462645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * example would be a character-device driver when its device file is 1463645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * closed. 1464645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 1465645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * The routine decrements @intf's usage counter. When the counter reaches 14669bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * 0, a delayed autosuspend request for @intf's device is attempted. The 14679bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * attempt may fail (see autosuspend_check()). 1468645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 1469645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * This routine can run only in process context. 1470645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern */ 1471645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Sternvoid usb_autopm_put_interface(struct usb_interface *intf) 1472645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern{ 14739bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern struct usb_device *udev = interface_to_usbdev(intf); 14749bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern int status; 1475645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 14766ddf27cdbc218a412d7e993fdc08e30eec2042ceMing Lei usb_mark_last_busy(udev); 14779bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern atomic_dec(&intf->pm_usage_cnt); 14789bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern status = pm_runtime_put_sync(&intf->dev); 14799bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n", 14809bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern __func__, atomic_read(&intf->dev.power.usage_count), 14819bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern status); 1482645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern} 1483645daaab0b6adc35c1838df2a82f9d729fdb1767Alan SternEXPORT_SYMBOL_GPL(usb_autopm_put_interface); 1484645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 1485645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern/** 14869ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern * usb_autopm_put_interface_async - decrement a USB interface's PM-usage counter 14879ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern * @intf: the usb_interface whose counter should be decremented 14889ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern * 14899bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * This routine does much the same thing as usb_autopm_put_interface(): 14909bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * It decrements @intf's usage counter and schedules a delayed 14919bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * autosuspend request if the counter is <= 0. The difference is that it 14929bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * does not perform any synchronization; callers should hold a private 14939bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * lock and handle all synchronization issues themselves. 14949ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern * 14959ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern * Typically a driver would call this routine during an URB's completion 14969ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern * handler, if no more URBs were pending. 14979ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern * 14989ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern * This routine can run in atomic context. 14999ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern */ 15009ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Sternvoid usb_autopm_put_interface_async(struct usb_interface *intf) 15019ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern{ 15029ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern struct usb_device *udev = interface_to_usbdev(intf); 1503fcc4a01eb8661226e80632327673f67bf6a5840bAlan Stern int status; 15049ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern 15056ddf27cdbc218a412d7e993fdc08e30eec2042ceMing Lei usb_mark_last_busy(udev); 15069bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern atomic_dec(&intf->pm_usage_cnt); 1507fcc4a01eb8661226e80632327673f67bf6a5840bAlan Stern status = pm_runtime_put(&intf->dev); 15089bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n", 15099bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern __func__, atomic_read(&intf->dev.power.usage_count), 15109bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern status); 15119ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern} 15129ac39f28b5237a629e41ccfc1f73d3a55723045cAlan SternEXPORT_SYMBOL_GPL(usb_autopm_put_interface_async); 15139ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern 15149ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern/** 15159bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * usb_autopm_put_interface_no_suspend - decrement a USB interface's PM-usage counter 15169bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * @intf: the usb_interface whose counter should be decremented 15179bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * 15189bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * This routine decrements @intf's usage counter but does not carry out an 15199bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * autosuspend. 15209bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * 15219bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * This routine can run in atomic context. 15229bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern */ 15239bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Sternvoid usb_autopm_put_interface_no_suspend(struct usb_interface *intf) 15249bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern{ 15259bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern struct usb_device *udev = interface_to_usbdev(intf); 15269bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 15276ddf27cdbc218a412d7e993fdc08e30eec2042ceMing Lei usb_mark_last_busy(udev); 15289bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern atomic_dec(&intf->pm_usage_cnt); 15299bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern pm_runtime_put_noidle(&intf->dev); 15309bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern} 15319bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan SternEXPORT_SYMBOL_GPL(usb_autopm_put_interface_no_suspend); 15329bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 15339bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern/** 1534645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * usb_autopm_get_interface - increment a USB interface's PM-usage counter 1535701f35af282e3955159bd30d3fb3f6ebafe8bff2Henrik Kretzschmar * @intf: the usb_interface whose counter should be incremented 1536645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 1537645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * This routine should be called by an interface driver when it wants to 1538645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * use @intf and needs to guarantee that it is not suspended. In addition, 1539645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * the routine prevents @intf from being autosuspended subsequently. (Note 1540645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * that this will not prevent suspend events originating in the PM core.) 1541645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * This prevention will persist until usb_autopm_put_interface() is called 1542645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * or @intf is unbound. A typical example would be a character-device 1543645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * driver when its device file is opened. 1544645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 15459bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * @intf's usage counter is incremented to prevent subsequent autosuspends. 15469bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * However if the autoresume fails then the counter is re-decremented. 1547645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * 1548645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern * This routine can run only in process context. 1549645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern */ 1550645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Sternint usb_autopm_get_interface(struct usb_interface *intf) 1551645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern{ 1552af4f76066d0fcb215ae389b8839d7ae37ce0e28bAlan Stern int status; 1553645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 15549bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern status = pm_runtime_get_sync(&intf->dev); 15559bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (status < 0) 15569bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern pm_runtime_put_sync(&intf->dev); 15579bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern else 15589bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern atomic_inc(&intf->pm_usage_cnt); 15599bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n", 15609bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern __func__, atomic_read(&intf->dev.power.usage_count), 15619bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern status); 15629bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (status > 0) 15639bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern status = 0; 1564a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern return status; 1565a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern} 1566645daaab0b6adc35c1838df2a82f9d729fdb1767Alan SternEXPORT_SYMBOL_GPL(usb_autopm_get_interface); 1567645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern 1568692a186c9d5f12d43cef28d40c25247dc4f302f0Alan Stern/** 15699ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern * usb_autopm_get_interface_async - increment a USB interface's PM-usage counter 15709ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern * @intf: the usb_interface whose counter should be incremented 15719ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern * 15729ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern * This routine does much the same thing as 15739bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * usb_autopm_get_interface(): It increments @intf's usage counter and 15749bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * queues an autoresume request if the device is suspended. The 15759bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * differences are that it does not perform any synchronization (callers 15769bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * should hold a private lock and handle all synchronization issues 15779bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * themselves), and it does not autoresume the device directly (it only 15789bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * queues a request). After a successful call, the device may not yet be 15799bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * resumed. 15809ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern * 15819ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern * This routine can run in atomic context. 15829ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern */ 15839ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Sternint usb_autopm_get_interface_async(struct usb_interface *intf) 15849ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern{ 158563defa73c8c1193c1273474440c30d34c2524597Ming Lei int status; 15869bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 158763defa73c8c1193c1273474440c30d34c2524597Ming Lei status = pm_runtime_get(&intf->dev); 15889bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (status < 0 && status != -EINPROGRESS) 15899bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern pm_runtime_put_noidle(&intf->dev); 15909bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern else 1591ccf5b801cef4f9e2d708d3b87e91e2bc6abd5206Alan Stern atomic_inc(&intf->pm_usage_cnt); 15929bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n", 15939bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern __func__, atomic_read(&intf->dev.power.usage_count), 15949bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern status); 1595c5a48592d874ddef8c7880311581eccf0eb30c3bJim Wylder if (status > 0 || status == -EINPROGRESS) 15969bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern status = 0; 15979ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern return status; 15989ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern} 15999ac39f28b5237a629e41ccfc1f73d3a55723045cAlan SternEXPORT_SYMBOL_GPL(usb_autopm_get_interface_async); 16009ac39f28b5237a629e41ccfc1f73d3a55723045cAlan Stern 16019bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern/** 16029bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * usb_autopm_get_interface_no_resume - increment a USB interface's PM-usage counter 16039bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * @intf: the usb_interface whose counter should be incremented 16049bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * 16059bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * This routine increments @intf's usage counter but does not carry out an 16069bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * autoresume. 16079bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * 16089bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * This routine can run in atomic context. 16099bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern */ 16109bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Sternvoid usb_autopm_get_interface_no_resume(struct usb_interface *intf) 16119bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern{ 16129bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern struct usb_device *udev = interface_to_usbdev(intf); 16139bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 16146ddf27cdbc218a412d7e993fdc08e30eec2042ceMing Lei usb_mark_last_busy(udev); 16159bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern atomic_inc(&intf->pm_usage_cnt); 16169bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern pm_runtime_get_noresume(&intf->dev); 16179bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern} 16189bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan SternEXPORT_SYMBOL_GPL(usb_autopm_get_interface_no_resume); 16199bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 16209bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern/* Internal routine to check whether we may autosuspend a device. */ 16219bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Sternstatic int autosuspend_check(struct usb_device *udev) 16229bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern{ 16237560d32ec70508a71f537a88e40f7717f15389acAlan Stern int w, i; 16249bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern struct usb_interface *intf; 16259bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 16269bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern /* Fail if autosuspend is disabled, or any interfaces are in use, or 16279bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * any interface drivers require remote wakeup but it isn't available. 16289bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern */ 16297560d32ec70508a71f537a88e40f7717f15389acAlan Stern w = 0; 16309bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (udev->actconfig) { 16319bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) { 16329bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern intf = udev->actconfig->interface[i]; 16339bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 16349bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern /* We don't need to check interfaces that are 16359bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * disabled for runtime PM. Either they are unbound 16369bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * or else their drivers don't support autosuspend 16379bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * and so they are permanently active. 16389bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern */ 16399bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (intf->dev.power.disable_depth) 16409bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern continue; 16419bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (atomic_read(&intf->dev.power.usage_count) > 0) 16429bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern return -EBUSY; 16437560d32ec70508a71f537a88e40f7717f15389acAlan Stern w |= intf->needs_remote_wakeup; 16449bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 16459bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern /* Don't allow autosuspend if the device will need 16469bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * a reset-resume and any of its interface drivers 16479bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * doesn't include support or needs remote wakeup. 16489bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern */ 16499bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (udev->quirks & USB_QUIRK_RESET_RESUME) { 16509bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern struct usb_driver *driver; 16519bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 16529bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern driver = to_usb_driver(intf->dev.driver); 16539bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern if (!driver->reset_resume || 16549bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern intf->needs_remote_wakeup) 16559bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern return -EOPNOTSUPP; 16569bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern } 16579bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern } 16589bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern } 16597560d32ec70508a71f537a88e40f7717f15389acAlan Stern if (w && !device_can_wakeup(&udev->dev)) { 16607560d32ec70508a71f537a88e40f7717f15389acAlan Stern dev_dbg(&udev->dev, "remote wakeup needed for autosuspend\n"); 16617560d32ec70508a71f537a88e40f7717f15389acAlan Stern return -EOPNOTSUPP; 16627560d32ec70508a71f537a88e40f7717f15389acAlan Stern } 16637560d32ec70508a71f537a88e40f7717f15389acAlan Stern udev->do_remote_wakeup = w; 16649bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern return 0; 16659bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern} 16669bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 1667e1620d591a75a10b15cf61dbf8243a0b7e6731a2Rafael J. Wysockiint usb_runtime_suspend(struct device *dev) 16689bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern{ 166963defa73c8c1193c1273474440c30d34c2524597Ming Lei struct usb_device *udev = to_usb_device(dev); 167063defa73c8c1193c1273474440c30d34c2524597Ming Lei int status; 1671718efa64e30a5e9db0351d70c5a91969306a12d1Alan Stern 16729bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern /* A USB device can be suspended if it passes the various autosuspend 16739bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * checks. Runtime suspend for a USB device means suspending all the 16749bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * interfaces and then the device itself. 16759bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern */ 167663defa73c8c1193c1273474440c30d34c2524597Ming Lei if (autosuspend_check(udev) != 0) 167763defa73c8c1193c1273474440c30d34c2524597Ming Lei return -EAGAIN; 16789bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 167963defa73c8c1193c1273474440c30d34c2524597Ming Lei status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND); 1680b2c0a863e14676fa5760c6d828fd373288e2f64aAlan Stern 1681b2c0a863e14676fa5760c6d828fd373288e2f64aAlan Stern /* Allow a retry if autosuspend failed temporarily */ 1682b2c0a863e14676fa5760c6d828fd373288e2f64aAlan Stern if (status == -EAGAIN || status == -EBUSY) 1683b2c0a863e14676fa5760c6d828fd373288e2f64aAlan Stern usb_mark_last_busy(udev); 1684b2c0a863e14676fa5760c6d828fd373288e2f64aAlan Stern 1685db7c7c0aeef51dba12d877875b8deb78d9886647Sarah Sharp /* The PM core reacts badly unless the return code is 0, 1686db7c7c0aeef51dba12d877875b8deb78d9886647Sarah Sharp * -EAGAIN, or -EBUSY, so always return -EBUSY on an error. 1687db7c7c0aeef51dba12d877875b8deb78d9886647Sarah Sharp */ 1688db7c7c0aeef51dba12d877875b8deb78d9886647Sarah Sharp if (status != 0) 1689db7c7c0aeef51dba12d877875b8deb78d9886647Sarah Sharp return -EBUSY; 16909bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern return status; 16919bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern} 16929bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 1693e1620d591a75a10b15cf61dbf8243a0b7e6731a2Rafael J. Wysockiint usb_runtime_resume(struct device *dev) 16949bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern{ 169563defa73c8c1193c1273474440c30d34c2524597Ming Lei struct usb_device *udev = to_usb_device(dev); 169663defa73c8c1193c1273474440c30d34c2524597Ming Lei int status; 169763defa73c8c1193c1273474440c30d34c2524597Ming Lei 16989bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern /* Runtime resume for a USB device means resuming both the device 16999bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern * and all its interfaces. 17009bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern */ 170163defa73c8c1193c1273474440c30d34c2524597Ming Lei status = usb_resume_both(udev, PMSG_AUTO_RESUME); 170263defa73c8c1193c1273474440c30d34c2524597Ming Lei return status; 17039bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern} 17049bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 1705e1620d591a75a10b15cf61dbf8243a0b7e6731a2Rafael J. Wysockiint usb_runtime_idle(struct device *dev) 17069bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern{ 170763defa73c8c1193c1273474440c30d34c2524597Ming Lei struct usb_device *udev = to_usb_device(dev); 170863defa73c8c1193c1273474440c30d34c2524597Ming Lei 17099bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern /* An idle USB device can be suspended if it passes the various 171063defa73c8c1193c1273474440c30d34c2524597Ming Lei * autosuspend checks. 17119bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern */ 171263defa73c8c1193c1273474440c30d34c2524597Ming Lei if (autosuspend_check(udev) == 0) 1713fcc4a01eb8661226e80632327673f67bf6a5840bAlan Stern pm_runtime_autosuspend(dev); 17149bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern return 0; 17159bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern} 17169bbdf1e0afe771ca7650f9f476769310bee9d8f3Alan Stern 171765580b4321eb36f16ae8b5987bfa1bb948fc5112Andiry Xuint usb_set_usb2_hardware_lpm(struct usb_device *udev, int enable) 171865580b4321eb36f16ae8b5987bfa1bb948fc5112Andiry Xu{ 171965580b4321eb36f16ae8b5987bfa1bb948fc5112Andiry Xu struct usb_hcd *hcd = bus_to_hcd(udev->bus); 172065580b4321eb36f16ae8b5987bfa1bb948fc5112Andiry Xu int ret = -EPERM; 172165580b4321eb36f16ae8b5987bfa1bb948fc5112Andiry Xu 172265580b4321eb36f16ae8b5987bfa1bb948fc5112Andiry Xu if (hcd->driver->set_usb2_hw_lpm) { 172365580b4321eb36f16ae8b5987bfa1bb948fc5112Andiry Xu ret = hcd->driver->set_usb2_hw_lpm(hcd, udev, enable); 172465580b4321eb36f16ae8b5987bfa1bb948fc5112Andiry Xu if (!ret) 172565580b4321eb36f16ae8b5987bfa1bb948fc5112Andiry Xu udev->usb2_hw_lpm_enabled = enable; 172665580b4321eb36f16ae8b5987bfa1bb948fc5112Andiry Xu } 172765580b4321eb36f16ae8b5987bfa1bb948fc5112Andiry Xu 172865580b4321eb36f16ae8b5987bfa1bb948fc5112Andiry Xu return ret; 172965580b4321eb36f16ae8b5987bfa1bb948fc5112Andiry Xu} 173065580b4321eb36f16ae8b5987bfa1bb948fc5112Andiry Xu 1731645daaab0b6adc35c1838df2a82f9d729fdb1767Alan Stern#endif /* CONFIG_USB_SUSPEND */ 1732a8e7c5653562f88c0f5f53eac0a890c012655789Alan Stern 173336e56a34586783c7986ce09d39db80b27c95ce24Alan Sternstruct bus_type usb_bus_type = { 173436e56a34586783c7986ce09d39db80b27c95ce24Alan Stern .name = "usb", 173536e56a34586783c7986ce09d39db80b27c95ce24Alan Stern .match = usb_device_match, 173636e56a34586783c7986ce09d39db80b27c95ce24Alan Stern .uevent = usb_uevent, 173736e56a34586783c7986ce09d39db80b27c95ce24Alan Stern}; 1738