1/* 2 * drivers/usb/driver.c - most of the driver model stuff for usb 3 * 4 * (C) Copyright 2005 Greg Kroah-Hartman <gregkh@suse.de> 5 * 6 * based on drivers/usb/usb.c which had the following copyrights: 7 * (C) Copyright Linus Torvalds 1999 8 * (C) Copyright Johannes Erdfelt 1999-2001 9 * (C) Copyright Andreas Gal 1999 10 * (C) Copyright Gregory P. Smith 1999 11 * (C) Copyright Deti Fliegl 1999 (new USB architecture) 12 * (C) Copyright Randy Dunlap 2000 13 * (C) Copyright David Brownell 2000-2004 14 * (C) Copyright Yggdrasil Computing, Inc. 2000 15 * (usb_device_id matching changes by Adam J. Richter) 16 * (C) Copyright Greg Kroah-Hartman 2002-2003 17 * 18 * NOTE! This is not actually a driver at all, rather this is 19 * just a collection of helper routines that implement the 20 * matching, probing, releasing, suspending and resuming for 21 * real drivers. 22 * 23 */ 24 25#include <linux/device.h> 26#include <linux/slab.h> 27#include <linux/usb.h> 28#include <linux/usb/quirks.h> 29#include <linux/usb/hcd.h> 30#include <linux/pm_runtime.h> 31 32#include "usb.h" 33 34 35#ifdef CONFIG_HOTPLUG 36 37/* 38 * Adds a new dynamic USBdevice ID to this driver, 39 * and cause the driver to probe for all devices again. 40 */ 41ssize_t usb_store_new_id(struct usb_dynids *dynids, 42 struct device_driver *driver, 43 const char *buf, size_t count) 44{ 45 struct usb_dynid *dynid; 46 u32 idVendor = 0; 47 u32 idProduct = 0; 48 int fields = 0; 49 int retval = 0; 50 51 fields = sscanf(buf, "%x %x", &idVendor, &idProduct); 52 if (fields < 2) 53 return -EINVAL; 54 55 dynid = kzalloc(sizeof(*dynid), GFP_KERNEL); 56 if (!dynid) 57 return -ENOMEM; 58 59 INIT_LIST_HEAD(&dynid->node); 60 dynid->id.idVendor = idVendor; 61 dynid->id.idProduct = idProduct; 62 dynid->id.match_flags = USB_DEVICE_ID_MATCH_DEVICE; 63 64 spin_lock(&dynids->lock); 65 list_add_tail(&dynid->node, &dynids->list); 66 spin_unlock(&dynids->lock); 67 68 if (get_driver(driver)) { 69 retval = driver_attach(driver); 70 put_driver(driver); 71 } 72 73 if (retval) 74 return retval; 75 return count; 76} 77EXPORT_SYMBOL_GPL(usb_store_new_id); 78 79static ssize_t store_new_id(struct device_driver *driver, 80 const char *buf, size_t count) 81{ 82 struct usb_driver *usb_drv = to_usb_driver(driver); 83 84 return usb_store_new_id(&usb_drv->dynids, driver, buf, count); 85} 86static DRIVER_ATTR(new_id, S_IWUSR, NULL, store_new_id); 87 88/** 89 * store_remove_id - remove a USB device ID from this driver 90 * @driver: target device driver 91 * @buf: buffer for scanning device ID data 92 * @count: input size 93 * 94 * Removes a dynamic usb device ID from this driver. 95 */ 96static ssize_t 97store_remove_id(struct device_driver *driver, const char *buf, size_t count) 98{ 99 struct usb_dynid *dynid, *n; 100 struct usb_driver *usb_driver = to_usb_driver(driver); 101 u32 idVendor = 0; 102 u32 idProduct = 0; 103 int fields = 0; 104 int retval = 0; 105 106 fields = sscanf(buf, "%x %x", &idVendor, &idProduct); 107 if (fields < 2) 108 return -EINVAL; 109 110 spin_lock(&usb_driver->dynids.lock); 111 list_for_each_entry_safe(dynid, n, &usb_driver->dynids.list, node) { 112 struct usb_device_id *id = &dynid->id; 113 if ((id->idVendor == idVendor) && 114 (id->idProduct == idProduct)) { 115 list_del(&dynid->node); 116 kfree(dynid); 117 retval = 0; 118 break; 119 } 120 } 121 spin_unlock(&usb_driver->dynids.lock); 122 123 if (retval) 124 return retval; 125 return count; 126} 127static DRIVER_ATTR(remove_id, S_IWUSR, NULL, store_remove_id); 128 129static int usb_create_newid_file(struct usb_driver *usb_drv) 130{ 131 int error = 0; 132 133 if (usb_drv->no_dynamic_id) 134 goto exit; 135 136 if (usb_drv->probe != NULL) 137 error = driver_create_file(&usb_drv->drvwrap.driver, 138 &driver_attr_new_id); 139exit: 140 return error; 141} 142 143static void usb_remove_newid_file(struct usb_driver *usb_drv) 144{ 145 if (usb_drv->no_dynamic_id) 146 return; 147 148 if (usb_drv->probe != NULL) 149 driver_remove_file(&usb_drv->drvwrap.driver, 150 &driver_attr_new_id); 151} 152 153static int 154usb_create_removeid_file(struct usb_driver *drv) 155{ 156 int error = 0; 157 if (drv->probe != NULL) 158 error = driver_create_file(&drv->drvwrap.driver, 159 &driver_attr_remove_id); 160 return error; 161} 162 163static void usb_remove_removeid_file(struct usb_driver *drv) 164{ 165 driver_remove_file(&drv->drvwrap.driver, &driver_attr_remove_id); 166} 167 168static void usb_free_dynids(struct usb_driver *usb_drv) 169{ 170 struct usb_dynid *dynid, *n; 171 172 spin_lock(&usb_drv->dynids.lock); 173 list_for_each_entry_safe(dynid, n, &usb_drv->dynids.list, node) { 174 list_del(&dynid->node); 175 kfree(dynid); 176 } 177 spin_unlock(&usb_drv->dynids.lock); 178} 179#else 180static inline int usb_create_newid_file(struct usb_driver *usb_drv) 181{ 182 return 0; 183} 184 185static void usb_remove_newid_file(struct usb_driver *usb_drv) 186{ 187} 188 189static int 190usb_create_removeid_file(struct usb_driver *drv) 191{ 192 return 0; 193} 194 195static void usb_remove_removeid_file(struct usb_driver *drv) 196{ 197} 198 199static inline void usb_free_dynids(struct usb_driver *usb_drv) 200{ 201} 202#endif 203 204static const struct usb_device_id *usb_match_dynamic_id(struct usb_interface *intf, 205 struct usb_driver *drv) 206{ 207 struct usb_dynid *dynid; 208 209 spin_lock(&drv->dynids.lock); 210 list_for_each_entry(dynid, &drv->dynids.list, node) { 211 if (usb_match_one_id(intf, &dynid->id)) { 212 spin_unlock(&drv->dynids.lock); 213 return &dynid->id; 214 } 215 } 216 spin_unlock(&drv->dynids.lock); 217 return NULL; 218} 219 220 221/* called from driver core with dev locked */ 222static int usb_probe_device(struct device *dev) 223{ 224 struct usb_device_driver *udriver = to_usb_device_driver(dev->driver); 225 struct usb_device *udev = to_usb_device(dev); 226 int error = 0; 227 228 dev_dbg(dev, "%s\n", __func__); 229 230 /* TODO: Add real matching code */ 231 232 /* The device should always appear to be in use 233 * unless the driver suports autosuspend. 234 */ 235 if (!udriver->supports_autosuspend) 236 error = usb_autoresume_device(udev); 237 238 if (!error) 239 error = udriver->probe(udev); 240 return error; 241} 242 243/* called from driver core with dev locked */ 244static int usb_unbind_device(struct device *dev) 245{ 246 struct usb_device *udev = to_usb_device(dev); 247 struct usb_device_driver *udriver = to_usb_device_driver(dev->driver); 248 249 udriver->disconnect(udev); 250 if (!udriver->supports_autosuspend) 251 usb_autosuspend_device(udev); 252 return 0; 253} 254 255/* 256 * Cancel any pending scheduled resets 257 * 258 * [see usb_queue_reset_device()] 259 * 260 * Called after unconfiguring / when releasing interfaces. See 261 * comments in __usb_queue_reset_device() regarding 262 * udev->reset_running. 263 */ 264static void usb_cancel_queued_reset(struct usb_interface *iface) 265{ 266 if (iface->reset_running == 0) 267 cancel_work_sync(&iface->reset_ws); 268} 269 270/* called from driver core with dev locked */ 271static int usb_probe_interface(struct device *dev) 272{ 273 struct usb_driver *driver = to_usb_driver(dev->driver); 274 struct usb_interface *intf = to_usb_interface(dev); 275 struct usb_device *udev = interface_to_usbdev(intf); 276 const struct usb_device_id *id; 277 int error = -ENODEV; 278 279 dev_dbg(dev, "%s\n", __func__); 280 281 intf->needs_binding = 0; 282 283 if (usb_device_is_owned(udev)) 284 return error; 285 286 if (udev->authorized == 0) { 287 dev_err(&intf->dev, "Device is not authorized for usage\n"); 288 return error; 289 } 290 291 id = usb_match_id(intf, driver->id_table); 292 if (!id) 293 id = usb_match_dynamic_id(intf, driver); 294 if (!id) 295 return error; 296 297 dev_dbg(dev, "%s - got id\n", __func__); 298 299 error = usb_autoresume_device(udev); 300 if (error) 301 return error; 302 303 intf->condition = USB_INTERFACE_BINDING; 304 305 /* Probed interfaces are initially active. They are 306 * runtime-PM-enabled only if the driver has autosuspend support. 307 * They are sensitive to their children's power states. 308 */ 309 pm_runtime_set_active(dev); 310 pm_suspend_ignore_children(dev, false); 311 if (driver->supports_autosuspend) 312 pm_runtime_enable(dev); 313 314 /* Carry out a deferred switch to altsetting 0 */ 315 if (intf->needs_altsetting0) { 316 error = usb_set_interface(udev, intf->altsetting[0]. 317 desc.bInterfaceNumber, 0); 318 if (error < 0) 319 goto err; 320 intf->needs_altsetting0 = 0; 321 } 322 323 error = driver->probe(intf, id); 324 if (error) 325 goto err; 326 327 intf->condition = USB_INTERFACE_BOUND; 328 usb_autosuspend_device(udev); 329 return error; 330 331 err: 332 intf->needs_remote_wakeup = 0; 333 intf->condition = USB_INTERFACE_UNBOUND; 334 usb_cancel_queued_reset(intf); 335 336 /* Unbound interfaces are always runtime-PM-disabled and -suspended */ 337 if (driver->supports_autosuspend) 338 pm_runtime_disable(dev); 339 pm_runtime_set_suspended(dev); 340 341 usb_autosuspend_device(udev); 342 return error; 343} 344 345/* called from driver core with dev locked */ 346static int usb_unbind_interface(struct device *dev) 347{ 348 struct usb_driver *driver = to_usb_driver(dev->driver); 349 struct usb_interface *intf = to_usb_interface(dev); 350 struct usb_device *udev; 351 int error, r; 352 353 intf->condition = USB_INTERFACE_UNBINDING; 354 355 /* Autoresume for set_interface call below */ 356 udev = interface_to_usbdev(intf); 357 error = usb_autoresume_device(udev); 358 359 /* Terminate all URBs for this interface unless the driver 360 * supports "soft" unbinding. 361 */ 362 if (!driver->soft_unbind) 363 usb_disable_interface(udev, intf, false); 364 365 driver->disconnect(intf); 366 usb_cancel_queued_reset(intf); 367 368 /* Reset other interface state. 369 * We cannot do a Set-Interface if the device is suspended or 370 * if it is prepared for a system sleep (since installing a new 371 * altsetting means creating new endpoint device entries). 372 * When either of these happens, defer the Set-Interface. 373 */ 374 if (intf->cur_altsetting->desc.bAlternateSetting == 0) { 375 /* Already in altsetting 0 so skip Set-Interface. 376 * Just re-enable it without affecting the endpoint toggles. 377 */ 378 usb_enable_interface(udev, intf, false); 379 } else if (!error && intf->dev.power.status == DPM_ON) { 380 r = usb_set_interface(udev, intf->altsetting[0]. 381 desc.bInterfaceNumber, 0); 382 if (r < 0) 383 intf->needs_altsetting0 = 1; 384 } else { 385 intf->needs_altsetting0 = 1; 386 } 387 usb_set_intfdata(intf, NULL); 388 389 intf->condition = USB_INTERFACE_UNBOUND; 390 intf->needs_remote_wakeup = 0; 391 392 /* Unbound interfaces are always runtime-PM-disabled and -suspended */ 393 if (driver->supports_autosuspend) 394 pm_runtime_disable(dev); 395 pm_runtime_set_suspended(dev); 396 397 /* Undo any residual pm_autopm_get_interface_* calls */ 398 for (r = atomic_read(&intf->pm_usage_cnt); r > 0; --r) 399 usb_autopm_put_interface_no_suspend(intf); 400 atomic_set(&intf->pm_usage_cnt, 0); 401 402 if (!error) 403 usb_autosuspend_device(udev); 404 405 return 0; 406} 407 408/** 409 * usb_driver_claim_interface - bind a driver to an interface 410 * @driver: the driver to be bound 411 * @iface: the interface to which it will be bound; must be in the 412 * usb device's active configuration 413 * @priv: driver data associated with that interface 414 * 415 * This is used by usb device drivers that need to claim more than one 416 * interface on a device when probing (audio and acm are current examples). 417 * No device driver should directly modify internal usb_interface or 418 * usb_device structure members. 419 * 420 * Few drivers should need to use this routine, since the most natural 421 * way to bind to an interface is to return the private data from 422 * the driver's probe() method. 423 * 424 * Callers must own the device lock, so driver probe() entries don't need 425 * extra locking, but other call contexts may need to explicitly claim that 426 * lock. 427 */ 428int usb_driver_claim_interface(struct usb_driver *driver, 429 struct usb_interface *iface, void *priv) 430{ 431 struct device *dev = &iface->dev; 432 int retval = 0; 433 434 if (dev->driver) 435 return -EBUSY; 436 437 dev->driver = &driver->drvwrap.driver; 438 usb_set_intfdata(iface, priv); 439 iface->needs_binding = 0; 440 441 iface->condition = USB_INTERFACE_BOUND; 442 443 /* Claimed interfaces are initially inactive (suspended) and 444 * runtime-PM-enabled, but only if the driver has autosuspend 445 * support. Otherwise they are marked active, to prevent the 446 * device from being autosuspended, but left disabled. In either 447 * case they are sensitive to their children's power states. 448 */ 449 pm_suspend_ignore_children(dev, false); 450 if (driver->supports_autosuspend) 451 pm_runtime_enable(dev); 452 else 453 pm_runtime_set_active(dev); 454 455 /* if interface was already added, bind now; else let 456 * the future device_add() bind it, bypassing probe() 457 */ 458 if (device_is_registered(dev)) 459 retval = device_bind_driver(dev); 460 461 return retval; 462} 463EXPORT_SYMBOL_GPL(usb_driver_claim_interface); 464 465/** 466 * usb_driver_release_interface - unbind a driver from an interface 467 * @driver: the driver to be unbound 468 * @iface: the interface from which it will be unbound 469 * 470 * This can be used by drivers to release an interface without waiting 471 * for their disconnect() methods to be called. In typical cases this 472 * also causes the driver disconnect() method to be called. 473 * 474 * This call is synchronous, and may not be used in an interrupt context. 475 * Callers must own the device lock, so driver disconnect() entries don't 476 * need extra locking, but other call contexts may need to explicitly claim 477 * that lock. 478 */ 479void usb_driver_release_interface(struct usb_driver *driver, 480 struct usb_interface *iface) 481{ 482 struct device *dev = &iface->dev; 483 484 /* this should never happen, don't release something that's not ours */ 485 if (!dev->driver || dev->driver != &driver->drvwrap.driver) 486 return; 487 488 /* don't release from within disconnect() */ 489 if (iface->condition != USB_INTERFACE_BOUND) 490 return; 491 iface->condition = USB_INTERFACE_UNBINDING; 492 493 /* Release via the driver core only if the interface 494 * has already been registered 495 */ 496 if (device_is_registered(dev)) { 497 device_release_driver(dev); 498 } else { 499 device_lock(dev); 500 usb_unbind_interface(dev); 501 dev->driver = NULL; 502 device_unlock(dev); 503 } 504} 505EXPORT_SYMBOL_GPL(usb_driver_release_interface); 506 507/* returns 0 if no match, 1 if match */ 508int usb_match_device(struct usb_device *dev, const struct usb_device_id *id) 509{ 510 if ((id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) && 511 id->idVendor != le16_to_cpu(dev->descriptor.idVendor)) 512 return 0; 513 514 if ((id->match_flags & USB_DEVICE_ID_MATCH_PRODUCT) && 515 id->idProduct != le16_to_cpu(dev->descriptor.idProduct)) 516 return 0; 517 518 /* No need to test id->bcdDevice_lo != 0, since 0 is never 519 greater than any unsigned number. */ 520 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_LO) && 521 (id->bcdDevice_lo > le16_to_cpu(dev->descriptor.bcdDevice))) 522 return 0; 523 524 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_HI) && 525 (id->bcdDevice_hi < le16_to_cpu(dev->descriptor.bcdDevice))) 526 return 0; 527 528 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_CLASS) && 529 (id->bDeviceClass != dev->descriptor.bDeviceClass)) 530 return 0; 531 532 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_SUBCLASS) && 533 (id->bDeviceSubClass != dev->descriptor.bDeviceSubClass)) 534 return 0; 535 536 if ((id->match_flags & USB_DEVICE_ID_MATCH_DEV_PROTOCOL) && 537 (id->bDeviceProtocol != dev->descriptor.bDeviceProtocol)) 538 return 0; 539 540 return 1; 541} 542 543/* returns 0 if no match, 1 if match */ 544int usb_match_one_id(struct usb_interface *interface, 545 const struct usb_device_id *id) 546{ 547 struct usb_host_interface *intf; 548 struct usb_device *dev; 549 550 /* proc_connectinfo in devio.c may call us with id == NULL. */ 551 if (id == NULL) 552 return 0; 553 554 intf = interface->cur_altsetting; 555 dev = interface_to_usbdev(interface); 556 557 if (!usb_match_device(dev, id)) 558 return 0; 559 560 /* The interface class, subclass, and protocol should never be 561 * checked for a match if the device class is Vendor Specific, 562 * unless the match record specifies the Vendor ID. */ 563 if (dev->descriptor.bDeviceClass == USB_CLASS_VENDOR_SPEC && 564 !(id->match_flags & USB_DEVICE_ID_MATCH_VENDOR) && 565 (id->match_flags & (USB_DEVICE_ID_MATCH_INT_CLASS | 566 USB_DEVICE_ID_MATCH_INT_SUBCLASS | 567 USB_DEVICE_ID_MATCH_INT_PROTOCOL))) 568 return 0; 569 570 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_CLASS) && 571 (id->bInterfaceClass != intf->desc.bInterfaceClass)) 572 return 0; 573 574 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_SUBCLASS) && 575 (id->bInterfaceSubClass != intf->desc.bInterfaceSubClass)) 576 return 0; 577 578 if ((id->match_flags & USB_DEVICE_ID_MATCH_INT_PROTOCOL) && 579 (id->bInterfaceProtocol != intf->desc.bInterfaceProtocol)) 580 return 0; 581 582 return 1; 583} 584EXPORT_SYMBOL_GPL(usb_match_one_id); 585 586/** 587 * usb_match_id - find first usb_device_id matching device or interface 588 * @interface: the interface of interest 589 * @id: array of usb_device_id structures, terminated by zero entry 590 * 591 * usb_match_id searches an array of usb_device_id's and returns 592 * the first one matching the device or interface, or null. 593 * This is used when binding (or rebinding) a driver to an interface. 594 * Most USB device drivers will use this indirectly, through the usb core, 595 * but some layered driver frameworks use it directly. 596 * These device tables are exported with MODULE_DEVICE_TABLE, through 597 * modutils, to support the driver loading functionality of USB hotplugging. 598 * 599 * What Matches: 600 * 601 * The "match_flags" element in a usb_device_id controls which 602 * members are used. If the corresponding bit is set, the 603 * value in the device_id must match its corresponding member 604 * in the device or interface descriptor, or else the device_id 605 * does not match. 606 * 607 * "driver_info" is normally used only by device drivers, 608 * but you can create a wildcard "matches anything" usb_device_id 609 * as a driver's "modules.usbmap" entry if you provide an id with 610 * only a nonzero "driver_info" field. If you do this, the USB device 611 * driver's probe() routine should use additional intelligence to 612 * decide whether to bind to the specified interface. 613 * 614 * What Makes Good usb_device_id Tables: 615 * 616 * The match algorithm is very simple, so that intelligence in 617 * driver selection must come from smart driver id records. 618 * Unless you have good reasons to use another selection policy, 619 * provide match elements only in related groups, and order match 620 * specifiers from specific to general. Use the macros provided 621 * for that purpose if you can. 622 * 623 * The most specific match specifiers use device descriptor 624 * data. These are commonly used with product-specific matches; 625 * the USB_DEVICE macro lets you provide vendor and product IDs, 626 * and you can also match against ranges of product revisions. 627 * These are widely used for devices with application or vendor 628 * specific bDeviceClass values. 629 * 630 * Matches based on device class/subclass/protocol specifications 631 * are slightly more general; use the USB_DEVICE_INFO macro, or 632 * its siblings. These are used with single-function devices 633 * where bDeviceClass doesn't specify that each interface has 634 * its own class. 635 * 636 * Matches based on interface class/subclass/protocol are the 637 * most general; they let drivers bind to any interface on a 638 * multiple-function device. Use the USB_INTERFACE_INFO 639 * macro, or its siblings, to match class-per-interface style 640 * devices (as recorded in bInterfaceClass). 641 * 642 * Note that an entry created by USB_INTERFACE_INFO won't match 643 * any interface if the device class is set to Vendor-Specific. 644 * This is deliberate; according to the USB spec the meanings of 645 * the interface class/subclass/protocol for these devices are also 646 * vendor-specific, and hence matching against a standard product 647 * class wouldn't work anyway. If you really want to use an 648 * interface-based match for such a device, create a match record 649 * that also specifies the vendor ID. (Unforunately there isn't a 650 * standard macro for creating records like this.) 651 * 652 * Within those groups, remember that not all combinations are 653 * meaningful. For example, don't give a product version range 654 * without vendor and product IDs; or specify a protocol without 655 * its associated class and subclass. 656 */ 657const struct usb_device_id *usb_match_id(struct usb_interface *interface, 658 const struct usb_device_id *id) 659{ 660 /* proc_connectinfo in devio.c may call us with id == NULL. */ 661 if (id == NULL) 662 return NULL; 663 664 /* It is important to check that id->driver_info is nonzero, 665 since an entry that is all zeroes except for a nonzero 666 id->driver_info is the way to create an entry that 667 indicates that the driver want to examine every 668 device and interface. */ 669 for (; id->idVendor || id->idProduct || id->bDeviceClass || 670 id->bInterfaceClass || id->driver_info; id++) { 671 if (usb_match_one_id(interface, id)) 672 return id; 673 } 674 675 return NULL; 676} 677EXPORT_SYMBOL_GPL(usb_match_id); 678 679static int usb_device_match(struct device *dev, struct device_driver *drv) 680{ 681 /* devices and interfaces are handled separately */ 682 if (is_usb_device(dev)) { 683 684 /* interface drivers never match devices */ 685 if (!is_usb_device_driver(drv)) 686 return 0; 687 688 /* TODO: Add real matching code */ 689 return 1; 690 691 } else if (is_usb_interface(dev)) { 692 struct usb_interface *intf; 693 struct usb_driver *usb_drv; 694 const struct usb_device_id *id; 695 696 /* device drivers never match interfaces */ 697 if (is_usb_device_driver(drv)) 698 return 0; 699 700 intf = to_usb_interface(dev); 701 usb_drv = to_usb_driver(drv); 702#ifdef HOME_ROUTER_SUPPORT_3G_4G 703#define HUAWEI_VENDOR_ID 0x12D1 704#define TELECOM_CHINA_VENDOR_ID 0x15EB 705 int modem_match=0; 706 struct usb_device *uudev; 707 int uudev_vid=0, uudev_pid=0; 708 int uudev_dev = 0; 709 int uudev_class = 0; 710 int uudev_subclass = 0; 711 int uudev_proto = 0; 712 uudev = interface_to_usbdev(intf); 713 uudev_vid = le16_to_cpu(uudev->descriptor.idVendor); 714 uudev_pid = le16_to_cpu(uudev->descriptor.idProduct); 715 uudev_dev = le16_to_cpu(uudev->descriptor.bcdDevice); 716 uudev_class = le16_to_cpu(uudev->descriptor.bDeviceClass); 717 uudev_subclass = le16_to_cpu(uudev->descriptor.bDeviceSubClass); 718 uudev_proto = le16_to_cpu(uudev->descriptor.bDeviceProtocol); 719 //printk("0x%04X-%04X-%04X-%04X-%04X-%04X drv->name:%s \n", uudev_vid,uudev_pid,uudev_dev,uudev_class,uudev_subclass,uudev_proto, drv->name); 720 if(modem_match != 1 && !strcmp(drv->name, "KC NetUSB General Driver")){ 721 if(uudev_vid == HUAWEI_VENDOR_ID || uudev_vid == TELECOM_CHINA_VENDOR_ID) //|| uudev_vid == ZTE_VENDOR_ID) 722 modem_match = 1; 723 } 724 if(modem_match) 725 { 726 printk("%s %s %d\nmodem_match=1\n",__func__,__FILE__,__LINE__); 727 return 0; 728 } 729#endif 730 731 id = usb_match_id(intf, usb_drv->id_table); 732 if (id) 733 { 734 printk("match id\n"); 735 return 1; 736 } 737 738 id = usb_match_dynamic_id(intf, usb_drv); 739 if (id) 740 { 741 printk("dyn_match id\n"); 742 return 1; 743 } 744 } 745 746 return 0; 747} 748 749#ifdef CONFIG_HOTPLUG 750static int usb_uevent(struct device *dev, struct kobj_uevent_env *env) 751{ 752 struct usb_device *usb_dev; 753 754 if (is_usb_device(dev)) { 755 usb_dev = to_usb_device(dev); 756 } else if (is_usb_interface(dev)) { 757 struct usb_interface *intf = to_usb_interface(dev); 758 759 usb_dev = interface_to_usbdev(intf); 760 } else { 761 return 0; 762 } 763 764 if (usb_dev->devnum < 0) { 765 /* driver is often null here; dev_dbg() would oops */ 766 pr_debug("usb %s: already deleted?\n", dev_name(dev)); 767 return -ENODEV; 768 } 769 if (!usb_dev->bus) { 770 pr_debug("usb %s: bus removed?\n", dev_name(dev)); 771 return -ENODEV; 772 } 773 774#ifdef CONFIG_USB_DEVICEFS 775 /* If this is available, userspace programs can directly read 776 * all the device descriptors we don't tell them about. Or 777 * act as usermode drivers. 778 */ 779 if (add_uevent_var(env, "DEVICE=/proc/bus/usb/%03d/%03d", 780 usb_dev->bus->busnum, usb_dev->devnum)) 781 return -ENOMEM; 782#endif 783 784 /* per-device configurations are common */ 785 if (add_uevent_var(env, "PRODUCT=%x/%x/%x", 786 le16_to_cpu(usb_dev->descriptor.idVendor), 787 le16_to_cpu(usb_dev->descriptor.idProduct), 788 le16_to_cpu(usb_dev->descriptor.bcdDevice))) 789 return -ENOMEM; 790 791 /* class-based driver binding models */ 792 if (add_uevent_var(env, "TYPE=%d/%d/%d", 793 usb_dev->descriptor.bDeviceClass, 794 usb_dev->descriptor.bDeviceSubClass, 795 usb_dev->descriptor.bDeviceProtocol)) 796 return -ENOMEM; 797 798 return 0; 799} 800 801#else 802 803static int usb_uevent(struct device *dev, struct kobj_uevent_env *env) 804{ 805 return -ENODEV; 806} 807#endif /* CONFIG_HOTPLUG */ 808 809/** 810 * usb_register_device_driver - register a USB device (not interface) driver 811 * @new_udriver: USB operations for the device driver 812 * @owner: module owner of this driver. 813 * 814 * Registers a USB device driver with the USB core. The list of 815 * unattached devices will be rescanned whenever a new driver is 816 * added, allowing the new driver to attach to any recognized devices. 817 * Returns a negative error code on failure and 0 on success. 818 */ 819int usb_register_device_driver(struct usb_device_driver *new_udriver, 820 struct module *owner) 821{ 822 int retval = 0; 823 824 if (usb_disabled()) 825 return -ENODEV; 826 827 new_udriver->drvwrap.for_devices = 1; 828 new_udriver->drvwrap.driver.name = (char *) new_udriver->name; 829 new_udriver->drvwrap.driver.bus = &usb_bus_type; 830 new_udriver->drvwrap.driver.probe = usb_probe_device; 831 new_udriver->drvwrap.driver.remove = usb_unbind_device; 832 new_udriver->drvwrap.driver.owner = owner; 833 834 retval = driver_register(&new_udriver->drvwrap.driver); 835 836 if (!retval) { 837 pr_info("%s: registered new device driver %s\n", 838 usbcore_name, new_udriver->name); 839 usbfs_update_special(); 840 } else { 841 printk(KERN_ERR "%s: error %d registering device " 842 " driver %s\n", 843 usbcore_name, retval, new_udriver->name); 844 } 845 846 return retval; 847} 848EXPORT_SYMBOL_GPL(usb_register_device_driver); 849 850/** 851 * usb_deregister_device_driver - unregister a USB device (not interface) driver 852 * @udriver: USB operations of the device driver to unregister 853 * Context: must be able to sleep 854 * 855 * Unlinks the specified driver from the internal USB driver list. 856 */ 857void usb_deregister_device_driver(struct usb_device_driver *udriver) 858{ 859 pr_info("%s: deregistering device driver %s\n", 860 usbcore_name, udriver->name); 861 862 driver_unregister(&udriver->drvwrap.driver); 863 usbfs_update_special(); 864} 865EXPORT_SYMBOL_GPL(usb_deregister_device_driver); 866 867/** 868 * usb_register_driver - register a USB interface driver 869 * @new_driver: USB operations for the interface driver 870 * @owner: module owner of this driver. 871 * @mod_name: module name string 872 * 873 * Registers a USB interface driver with the USB core. The list of 874 * unattached interfaces will be rescanned whenever a new driver is 875 * added, allowing the new driver to attach to any recognized interfaces. 876 * Returns a negative error code on failure and 0 on success. 877 * 878 * NOTE: if you want your driver to use the USB major number, you must call 879 * usb_register_dev() to enable that functionality. This function no longer 880 * takes care of that. 881 */ 882int usb_register_driver(struct usb_driver *new_driver, struct module *owner, 883 const char *mod_name) 884{ 885 int retval = 0; 886 887 if (usb_disabled()) 888 return -ENODEV; 889 890 new_driver->drvwrap.for_devices = 0; 891 new_driver->drvwrap.driver.name = (char *) new_driver->name; 892 new_driver->drvwrap.driver.bus = &usb_bus_type; 893 new_driver->drvwrap.driver.probe = usb_probe_interface; 894 new_driver->drvwrap.driver.remove = usb_unbind_interface; 895 new_driver->drvwrap.driver.owner = owner; 896 new_driver->drvwrap.driver.mod_name = mod_name; 897 spin_lock_init(&new_driver->dynids.lock); 898 INIT_LIST_HEAD(&new_driver->dynids.list); 899 900 retval = driver_register(&new_driver->drvwrap.driver); 901 if (retval) 902 goto out; 903 904 usbfs_update_special(); 905 906 retval = usb_create_newid_file(new_driver); 907 if (retval) 908 goto out_newid; 909 910 retval = usb_create_removeid_file(new_driver); 911 if (retval) 912 goto out_removeid; 913 914 pr_info("%s: registered new interface driver %s\n", 915 usbcore_name, new_driver->name); 916 917out: 918 return retval; 919 920out_removeid: 921 usb_remove_newid_file(new_driver); 922out_newid: 923 driver_unregister(&new_driver->drvwrap.driver); 924 925 printk(KERN_ERR "%s: error %d registering interface " 926 " driver %s\n", 927 usbcore_name, retval, new_driver->name); 928 goto out; 929} 930EXPORT_SYMBOL_GPL(usb_register_driver); 931 932/** 933 * usb_deregister - unregister a USB interface driver 934 * @driver: USB operations of the interface driver to unregister 935 * Context: must be able to sleep 936 * 937 * Unlinks the specified driver from the internal USB driver list. 938 * 939 * NOTE: If you called usb_register_dev(), you still need to call 940 * usb_deregister_dev() to clean up your driver's allocated minor numbers, 941 * this * call will no longer do it for you. 942 */ 943void usb_deregister(struct usb_driver *driver) 944{ 945 pr_info("%s: deregistering interface driver %s\n", 946 usbcore_name, driver->name); 947 948 usb_remove_removeid_file(driver); 949 usb_remove_newid_file(driver); 950 usb_free_dynids(driver); 951 driver_unregister(&driver->drvwrap.driver); 952 953 usbfs_update_special(); 954} 955EXPORT_SYMBOL_GPL(usb_deregister); 956 957/* Forced unbinding of a USB interface driver, either because 958 * it doesn't support pre_reset/post_reset/reset_resume or 959 * because it doesn't support suspend/resume. 960 * 961 * The caller must hold @intf's device's lock, but not its pm_mutex 962 * and not @intf->dev.sem. 963 */ 964void usb_forced_unbind_intf(struct usb_interface *intf) 965{ 966 struct usb_driver *driver = to_usb_driver(intf->dev.driver); 967 968 dev_dbg(&intf->dev, "forced unbind\n"); 969 usb_driver_release_interface(driver, intf); 970 971 /* Mark the interface for later rebinding */ 972 intf->needs_binding = 1; 973} 974 975/* Delayed forced unbinding of a USB interface driver and scan 976 * for rebinding. 977 * 978 * The caller must hold @intf's device's lock, but not its pm_mutex 979 * and not @intf->dev.sem. 980 * 981 * Note: Rebinds will be skipped if a system sleep transition is in 982 * progress and the PM "complete" callback hasn't occurred yet. 983 */ 984void usb_rebind_intf(struct usb_interface *intf) 985{ 986 int rc; 987 988 /* Delayed unbind of an existing driver */ 989 if (intf->dev.driver) { 990 struct usb_driver *driver = 991 to_usb_driver(intf->dev.driver); 992 993 dev_dbg(&intf->dev, "forced unbind\n"); 994 usb_driver_release_interface(driver, intf); 995 } 996 997 /* Try to rebind the interface */ 998 if (intf->dev.power.status == DPM_ON) { 999 intf->needs_binding = 0; 1000 rc = device_attach(&intf->dev); 1001 if (rc < 0) 1002 dev_warn(&intf->dev, "rebind failed: %d\n", rc); 1003 } 1004} 1005 1006#ifdef CONFIG_PM 1007 1008#define DO_UNBIND 0 1009#define DO_REBIND 1 1010 1011/* Unbind drivers for @udev's interfaces that don't support suspend/resume, 1012 * or rebind interfaces that have been unbound, according to @action. 1013 * 1014 * The caller must hold @udev's device lock. 1015 */ 1016static void do_unbind_rebind(struct usb_device *udev, int action) 1017{ 1018 struct usb_host_config *config; 1019 int i; 1020 struct usb_interface *intf; 1021 struct usb_driver *drv; 1022 1023 config = udev->actconfig; 1024 if (config) { 1025 for (i = 0; i < config->desc.bNumInterfaces; ++i) { 1026 intf = config->interface[i]; 1027 switch (action) { 1028 case DO_UNBIND: 1029 if (intf->dev.driver) { 1030 drv = to_usb_driver(intf->dev.driver); 1031 if (!drv->suspend || !drv->resume) 1032 usb_forced_unbind_intf(intf); 1033 } 1034 break; 1035 case DO_REBIND: 1036 if (intf->needs_binding) 1037 usb_rebind_intf(intf); 1038 break; 1039 } 1040 } 1041 } 1042} 1043 1044static int usb_suspend_device(struct usb_device *udev, pm_message_t msg) 1045{ 1046 struct usb_device_driver *udriver; 1047 int status = 0; 1048 1049 if (udev->state == USB_STATE_NOTATTACHED || 1050 udev->state == USB_STATE_SUSPENDED) 1051 goto done; 1052 1053 /* For devices that don't have a driver, we do a generic suspend. */ 1054 if (udev->dev.driver) 1055 udriver = to_usb_device_driver(udev->dev.driver); 1056 else { 1057 udev->do_remote_wakeup = 0; 1058 udriver = &usb_generic_driver; 1059 } 1060 status = udriver->suspend(udev, msg); 1061 1062 done: 1063 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status); 1064 return status; 1065} 1066 1067static int usb_resume_device(struct usb_device *udev, pm_message_t msg) 1068{ 1069 struct usb_device_driver *udriver; 1070 int status = 0; 1071 1072 if (udev->state == USB_STATE_NOTATTACHED) 1073 goto done; 1074 1075 /* Can't resume it if it doesn't have a driver. */ 1076 if (udev->dev.driver == NULL) { 1077 status = -ENOTCONN; 1078 goto done; 1079 } 1080 1081 /* Non-root devices on a full/low-speed bus must wait for their 1082 * companion high-speed root hub, in case a handoff is needed. 1083 */ 1084 if (!(msg.event & PM_EVENT_AUTO) && udev->parent && 1085 udev->bus->hs_companion) 1086 device_pm_wait_for_dev(&udev->dev, 1087 &udev->bus->hs_companion->root_hub->dev); 1088 1089 if (udev->quirks & USB_QUIRK_RESET_RESUME) 1090 udev->reset_resume = 1; 1091 1092 udriver = to_usb_device_driver(udev->dev.driver); 1093 status = udriver->resume(udev, msg); 1094 1095 done: 1096 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status); 1097 return status; 1098} 1099 1100static int usb_suspend_interface(struct usb_device *udev, 1101 struct usb_interface *intf, pm_message_t msg) 1102{ 1103 struct usb_driver *driver; 1104 int status = 0; 1105 1106 if (udev->state == USB_STATE_NOTATTACHED || 1107 intf->condition == USB_INTERFACE_UNBOUND) 1108 goto done; 1109 driver = to_usb_driver(intf->dev.driver); 1110 1111 if (driver->suspend) { 1112 status = driver->suspend(intf, msg); 1113 if (status && !(msg.event & PM_EVENT_AUTO)) 1114 dev_err(&intf->dev, "%s error %d\n", 1115 "suspend", status); 1116 } else { 1117 /* Later we will unbind the driver and reprobe */ 1118 intf->needs_binding = 1; 1119 dev_warn(&intf->dev, "no %s for driver %s?\n", 1120 "suspend", driver->name); 1121 } 1122 1123 done: 1124 dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status); 1125 return status; 1126} 1127 1128static int usb_resume_interface(struct usb_device *udev, 1129 struct usb_interface *intf, pm_message_t msg, int reset_resume) 1130{ 1131 struct usb_driver *driver; 1132 int status = 0; 1133 1134 if (udev->state == USB_STATE_NOTATTACHED) 1135 goto done; 1136 1137 /* Don't let autoresume interfere with unbinding */ 1138 if (intf->condition == USB_INTERFACE_UNBINDING) 1139 goto done; 1140 1141 /* Can't resume it if it doesn't have a driver. */ 1142 if (intf->condition == USB_INTERFACE_UNBOUND) { 1143 1144 /* Carry out a deferred switch to altsetting 0 */ 1145 if (intf->needs_altsetting0 && 1146 intf->dev.power.status == DPM_ON) { 1147 usb_set_interface(udev, intf->altsetting[0]. 1148 desc.bInterfaceNumber, 0); 1149 intf->needs_altsetting0 = 0; 1150 } 1151 goto done; 1152 } 1153 1154 /* Don't resume if the interface is marked for rebinding */ 1155 if (intf->needs_binding) 1156 goto done; 1157 driver = to_usb_driver(intf->dev.driver); 1158 1159 if (reset_resume) { 1160 if (driver->reset_resume) { 1161 status = driver->reset_resume(intf); 1162 if (status) 1163 dev_err(&intf->dev, "%s error %d\n", 1164 "reset_resume", status); 1165 } else { 1166 intf->needs_binding = 1; 1167 dev_warn(&intf->dev, "no %s for driver %s?\n", 1168 "reset_resume", driver->name); 1169 } 1170 } else { 1171 if (driver->resume) { 1172 status = driver->resume(intf); 1173 if (status) 1174 dev_err(&intf->dev, "%s error %d\n", 1175 "resume", status); 1176 } else { 1177 intf->needs_binding = 1; 1178 dev_warn(&intf->dev, "no %s for driver %s?\n", 1179 "resume", driver->name); 1180 } 1181 } 1182 1183done: 1184 dev_vdbg(&intf->dev, "%s: status %d\n", __func__, status); 1185 1186 /* Later we will unbind the driver and/or reprobe, if necessary */ 1187 return status; 1188} 1189 1190/** 1191 * usb_suspend_both - suspend a USB device and its interfaces 1192 * @udev: the usb_device to suspend 1193 * @msg: Power Management message describing this state transition 1194 * 1195 * This is the central routine for suspending USB devices. It calls the 1196 * suspend methods for all the interface drivers in @udev and then calls 1197 * the suspend method for @udev itself. If an error occurs at any stage, 1198 * all the interfaces which were suspended are resumed so that they remain 1199 * in the same state as the device. 1200 * 1201 * Autosuspend requests originating from a child device or an interface 1202 * driver may be made without the protection of @udev's device lock, but 1203 * all other suspend calls will hold the lock. Usbcore will insure that 1204 * method calls do not arrive during bind, unbind, or reset operations. 1205 * However drivers must be prepared to handle suspend calls arriving at 1206 * unpredictable times. 1207 * 1208 * This routine can run only in process context. 1209 */ 1210static int usb_suspend_both(struct usb_device *udev, pm_message_t msg) 1211{ 1212 int status = 0; 1213 int i = 0, n = 0; 1214 struct usb_interface *intf; 1215 1216 if (udev->state == USB_STATE_NOTATTACHED || 1217 udev->state == USB_STATE_SUSPENDED) 1218 goto done; 1219 1220 /* Suspend all the interfaces and then udev itself */ 1221 if (udev->actconfig) { 1222 n = udev->actconfig->desc.bNumInterfaces; 1223 for (i = n - 1; i >= 0; --i) { 1224 intf = udev->actconfig->interface[i]; 1225 status = usb_suspend_interface(udev, intf, msg); 1226 if (status != 0) 1227 break; 1228 } 1229 } 1230 if (status == 0) 1231 status = usb_suspend_device(udev, msg); 1232 1233 /* If the suspend failed, resume interfaces that did get suspended */ 1234 if (status != 0) { 1235 msg.event ^= (PM_EVENT_SUSPEND | PM_EVENT_RESUME); 1236 while (++i < n) { 1237 intf = udev->actconfig->interface[i]; 1238 usb_resume_interface(udev, intf, msg, 0); 1239 } 1240 1241 /* If the suspend succeeded then prevent any more URB submissions 1242 * and flush any outstanding URBs. 1243 */ 1244 } else { 1245 udev->can_submit = 0; 1246 for (i = 0; i < 16; ++i) { 1247 usb_hcd_flush_endpoint(udev, udev->ep_out[i]); 1248 usb_hcd_flush_endpoint(udev, udev->ep_in[i]); 1249 } 1250 } 1251 1252 done: 1253 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status); 1254 return status; 1255} 1256 1257/** 1258 * usb_resume_both - resume a USB device and its interfaces 1259 * @udev: the usb_device to resume 1260 * @msg: Power Management message describing this state transition 1261 * 1262 * This is the central routine for resuming USB devices. It calls the 1263 * the resume method for @udev and then calls the resume methods for all 1264 * the interface drivers in @udev. 1265 * 1266 * Autoresume requests originating from a child device or an interface 1267 * driver may be made without the protection of @udev's device lock, but 1268 * all other resume calls will hold the lock. Usbcore will insure that 1269 * method calls do not arrive during bind, unbind, or reset operations. 1270 * However drivers must be prepared to handle resume calls arriving at 1271 * unpredictable times. 1272 * 1273 * This routine can run only in process context. 1274 */ 1275static int usb_resume_both(struct usb_device *udev, pm_message_t msg) 1276{ 1277 int status = 0; 1278 int i; 1279 struct usb_interface *intf; 1280 1281 if (udev->state == USB_STATE_NOTATTACHED) { 1282 status = -ENODEV; 1283 goto done; 1284 } 1285 udev->can_submit = 1; 1286 1287 /* Resume the device */ 1288 if (udev->state == USB_STATE_SUSPENDED || udev->reset_resume) 1289 status = usb_resume_device(udev, msg); 1290 1291 /* Resume the interfaces */ 1292 if (status == 0 && udev->actconfig) { 1293 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) { 1294 intf = udev->actconfig->interface[i]; 1295 usb_resume_interface(udev, intf, msg, 1296 udev->reset_resume); 1297 } 1298 } 1299 1300 done: 1301 dev_vdbg(&udev->dev, "%s: status %d\n", __func__, status); 1302 if (!status) 1303 udev->reset_resume = 0; 1304 return status; 1305} 1306 1307static void choose_wakeup(struct usb_device *udev, pm_message_t msg) 1308{ 1309 int w; 1310 1311 /* Remote wakeup is needed only when we actually go to sleep. 1312 * For things like FREEZE and QUIESCE, if the device is already 1313 * autosuspended then its current wakeup setting is okay. 1314 */ 1315 if (msg.event == PM_EVENT_FREEZE || msg.event == PM_EVENT_QUIESCE) { 1316 if (udev->state != USB_STATE_SUSPENDED) 1317 udev->do_remote_wakeup = 0; 1318 return; 1319 } 1320 1321 /* Enable remote wakeup if it is allowed, even if no interface drivers 1322 * actually want it. 1323 */ 1324 w = device_may_wakeup(&udev->dev); 1325 1326 /* If the device is autosuspended with the wrong wakeup setting, 1327 * autoresume now so the setting can be changed. 1328 */ 1329 if (udev->state == USB_STATE_SUSPENDED && w != udev->do_remote_wakeup) 1330 pm_runtime_resume(&udev->dev); 1331 udev->do_remote_wakeup = w; 1332} 1333 1334/* The device lock is held by the PM core */ 1335int usb_suspend(struct device *dev, pm_message_t msg) 1336{ 1337 struct usb_device *udev = to_usb_device(dev); 1338 1339 do_unbind_rebind(udev, DO_UNBIND); 1340 choose_wakeup(udev, msg); 1341 return usb_suspend_both(udev, msg); 1342} 1343 1344/* The device lock is held by the PM core */ 1345int usb_resume(struct device *dev, pm_message_t msg) 1346{ 1347 struct usb_device *udev = to_usb_device(dev); 1348 int status; 1349 1350 /* For PM complete calls, all we do is rebind interfaces */ 1351 if (msg.event == PM_EVENT_ON) { 1352 if (udev->state != USB_STATE_NOTATTACHED) 1353 do_unbind_rebind(udev, DO_REBIND); 1354 status = 0; 1355 1356 /* For all other calls, take the device back to full power and 1357 * tell the PM core in case it was autosuspended previously. 1358 * Unbind the interfaces that will need rebinding later. 1359 */ 1360 } else { 1361 status = usb_resume_both(udev, msg); 1362 if (status == 0) { 1363 pm_runtime_disable(dev); 1364 pm_runtime_set_active(dev); 1365 pm_runtime_enable(dev); 1366 udev->last_busy = jiffies; 1367 do_unbind_rebind(udev, DO_REBIND); 1368 } 1369 } 1370 1371 /* Avoid PM error messages for devices disconnected while suspended 1372 * as we'll display regular disconnect messages just a bit later. 1373 */ 1374 if (status == -ENODEV) 1375 status = 0; 1376 return status; 1377} 1378 1379#endif /* CONFIG_PM */ 1380 1381#ifdef CONFIG_USB_SUSPEND 1382 1383/** 1384 * usb_enable_autosuspend - allow a USB device to be autosuspended 1385 * @udev: the USB device which may be autosuspended 1386 * 1387 * This routine allows @udev to be autosuspended. An autosuspend won't 1388 * take place until the autosuspend_delay has elapsed and all the other 1389 * necessary conditions are satisfied. 1390 * 1391 * The caller must hold @udev's device lock. 1392 */ 1393void usb_enable_autosuspend(struct usb_device *udev) 1394{ 1395 pm_runtime_allow(&udev->dev); 1396} 1397EXPORT_SYMBOL_GPL(usb_enable_autosuspend); 1398 1399/** 1400 * usb_disable_autosuspend - prevent a USB device from being autosuspended 1401 * @udev: the USB device which may not be autosuspended 1402 * 1403 * This routine prevents @udev from being autosuspended and wakes it up 1404 * if it is already autosuspended. 1405 * 1406 * The caller must hold @udev's device lock. 1407 */ 1408void usb_disable_autosuspend(struct usb_device *udev) 1409{ 1410 pm_runtime_forbid(&udev->dev); 1411} 1412EXPORT_SYMBOL_GPL(usb_disable_autosuspend); 1413 1414/** 1415 * usb_autosuspend_device - delayed autosuspend of a USB device and its interfaces 1416 * @udev: the usb_device to autosuspend 1417 * 1418 * This routine should be called when a core subsystem is finished using 1419 * @udev and wants to allow it to autosuspend. Examples would be when 1420 * @udev's device file in usbfs is closed or after a configuration change. 1421 * 1422 * @udev's usage counter is decremented; if it drops to 0 and all the 1423 * interfaces are inactive then a delayed autosuspend will be attempted. 1424 * The attempt may fail (see autosuspend_check()). 1425 * 1426 * The caller must hold @udev's device lock. 1427 * 1428 * This routine can run only in process context. 1429 */ 1430void usb_autosuspend_device(struct usb_device *udev) 1431{ 1432 int status; 1433 1434 udev->last_busy = jiffies; 1435 status = pm_runtime_put_sync(&udev->dev); 1436 dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n", 1437 __func__, atomic_read(&udev->dev.power.usage_count), 1438 status); 1439} 1440 1441/** 1442 * usb_try_autosuspend_device - attempt an autosuspend of a USB device and its interfaces 1443 * @udev: the usb_device to autosuspend 1444 * 1445 * This routine should be called when a core subsystem thinks @udev may 1446 * be ready to autosuspend. 1447 * 1448 * @udev's usage counter left unchanged. If it is 0 and all the interfaces 1449 * are inactive then an autosuspend will be attempted. The attempt may 1450 * fail or be delayed. 1451 * 1452 * The caller must hold @udev's device lock. 1453 * 1454 * This routine can run only in process context. 1455 */ 1456void usb_try_autosuspend_device(struct usb_device *udev) 1457{ 1458 int status; 1459 1460 status = pm_runtime_idle(&udev->dev); 1461 dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n", 1462 __func__, atomic_read(&udev->dev.power.usage_count), 1463 status); 1464} 1465 1466/** 1467 * usb_autoresume_device - immediately autoresume a USB device and its interfaces 1468 * @udev: the usb_device to autoresume 1469 * 1470 * This routine should be called when a core subsystem wants to use @udev 1471 * and needs to guarantee that it is not suspended. No autosuspend will 1472 * occur until usb_autosuspend_device() is called. (Note that this will 1473 * not prevent suspend events originating in the PM core.) Examples would 1474 * be when @udev's device file in usbfs is opened or when a remote-wakeup 1475 * request is received. 1476 * 1477 * @udev's usage counter is incremented to prevent subsequent autosuspends. 1478 * However if the autoresume fails then the usage counter is re-decremented. 1479 * 1480 * The caller must hold @udev's device lock. 1481 * 1482 * This routine can run only in process context. 1483 */ 1484int usb_autoresume_device(struct usb_device *udev) 1485{ 1486 int status; 1487 1488 status = pm_runtime_get_sync(&udev->dev); 1489 if (status < 0) 1490 pm_runtime_put_sync(&udev->dev); 1491 dev_vdbg(&udev->dev, "%s: cnt %d -> %d\n", 1492 __func__, atomic_read(&udev->dev.power.usage_count), 1493 status); 1494 if (status > 0) 1495 status = 0; 1496 return status; 1497} 1498 1499/** 1500 * usb_autopm_put_interface - decrement a USB interface's PM-usage counter 1501 * @intf: the usb_interface whose counter should be decremented 1502 * 1503 * This routine should be called by an interface driver when it is 1504 * finished using @intf and wants to allow it to autosuspend. A typical 1505 * example would be a character-device driver when its device file is 1506 * closed. 1507 * 1508 * The routine decrements @intf's usage counter. When the counter reaches 1509 * 0, a delayed autosuspend request for @intf's device is attempted. The 1510 * attempt may fail (see autosuspend_check()). 1511 * 1512 * This routine can run only in process context. 1513 */ 1514void usb_autopm_put_interface(struct usb_interface *intf) 1515{ 1516 struct usb_device *udev = interface_to_usbdev(intf); 1517 int status; 1518 1519 udev->last_busy = jiffies; 1520 atomic_dec(&intf->pm_usage_cnt); 1521 status = pm_runtime_put_sync(&intf->dev); 1522 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n", 1523 __func__, atomic_read(&intf->dev.power.usage_count), 1524 status); 1525} 1526EXPORT_SYMBOL_GPL(usb_autopm_put_interface); 1527 1528/** 1529 * usb_autopm_put_interface_async - decrement a USB interface's PM-usage counter 1530 * @intf: the usb_interface whose counter should be decremented 1531 * 1532 * This routine does much the same thing as usb_autopm_put_interface(): 1533 * It decrements @intf's usage counter and schedules a delayed 1534 * autosuspend request if the counter is <= 0. The difference is that it 1535 * does not perform any synchronization; callers should hold a private 1536 * lock and handle all synchronization issues themselves. 1537 * 1538 * Typically a driver would call this routine during an URB's completion 1539 * handler, if no more URBs were pending. 1540 * 1541 * This routine can run in atomic context. 1542 */ 1543void usb_autopm_put_interface_async(struct usb_interface *intf) 1544{ 1545 struct usb_device *udev = interface_to_usbdev(intf); 1546 unsigned long last_busy; 1547 int status = 0; 1548 1549 last_busy = udev->last_busy; 1550 udev->last_busy = jiffies; 1551 atomic_dec(&intf->pm_usage_cnt); 1552 pm_runtime_put_noidle(&intf->dev); 1553 1554 if (udev->dev.power.runtime_auto) { 1555 /* Optimization: Don't schedule a delayed autosuspend if 1556 * the timer is already running and the expiration time 1557 * wouldn't change. 1558 * 1559 * We have to use the interface's timer. Attempts to 1560 * schedule a suspend for the device would fail because 1561 * the interface is still active. 1562 */ 1563 if (intf->dev.power.timer_expires == 0 || 1564 round_jiffies_up(last_busy) != 1565 round_jiffies_up(jiffies)) { 1566 status = pm_schedule_suspend(&intf->dev, 1567 jiffies_to_msecs( 1568 round_jiffies_up_relative( 1569 udev->autosuspend_delay))); 1570 } 1571 } 1572 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n", 1573 __func__, atomic_read(&intf->dev.power.usage_count), 1574 status); 1575} 1576EXPORT_SYMBOL_GPL(usb_autopm_put_interface_async); 1577 1578/** 1579 * usb_autopm_put_interface_no_suspend - decrement a USB interface's PM-usage counter 1580 * @intf: the usb_interface whose counter should be decremented 1581 * 1582 * This routine decrements @intf's usage counter but does not carry out an 1583 * autosuspend. 1584 * 1585 * This routine can run in atomic context. 1586 */ 1587void usb_autopm_put_interface_no_suspend(struct usb_interface *intf) 1588{ 1589 struct usb_device *udev = interface_to_usbdev(intf); 1590 1591 udev->last_busy = jiffies; 1592 atomic_dec(&intf->pm_usage_cnt); 1593 pm_runtime_put_noidle(&intf->dev); 1594} 1595EXPORT_SYMBOL_GPL(usb_autopm_put_interface_no_suspend); 1596 1597/** 1598 * usb_autopm_get_interface - increment a USB interface's PM-usage counter 1599 * @intf: the usb_interface whose counter should be incremented 1600 * 1601 * This routine should be called by an interface driver when it wants to 1602 * use @intf and needs to guarantee that it is not suspended. In addition, 1603 * the routine prevents @intf from being autosuspended subsequently. (Note 1604 * that this will not prevent suspend events originating in the PM core.) 1605 * This prevention will persist until usb_autopm_put_interface() is called 1606 * or @intf is unbound. A typical example would be a character-device 1607 * driver when its device file is opened. 1608 * 1609 * @intf's usage counter is incremented to prevent subsequent autosuspends. 1610 * However if the autoresume fails then the counter is re-decremented. 1611 * 1612 * This routine can run only in process context. 1613 */ 1614int usb_autopm_get_interface(struct usb_interface *intf) 1615{ 1616 int status; 1617 1618 status = pm_runtime_get_sync(&intf->dev); 1619 if (status < 0) 1620 pm_runtime_put_sync(&intf->dev); 1621 else 1622 atomic_inc(&intf->pm_usage_cnt); 1623 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n", 1624 __func__, atomic_read(&intf->dev.power.usage_count), 1625 status); 1626 if (status > 0) 1627 status = 0; 1628 return status; 1629} 1630EXPORT_SYMBOL_GPL(usb_autopm_get_interface); 1631 1632/** 1633 * usb_autopm_get_interface_async - increment a USB interface's PM-usage counter 1634 * @intf: the usb_interface whose counter should be incremented 1635 * 1636 * This routine does much the same thing as 1637 * usb_autopm_get_interface(): It increments @intf's usage counter and 1638 * queues an autoresume request if the device is suspended. The 1639 * differences are that it does not perform any synchronization (callers 1640 * should hold a private lock and handle all synchronization issues 1641 * themselves), and it does not autoresume the device directly (it only 1642 * queues a request). After a successful call, the device may not yet be 1643 * resumed. 1644 * 1645 * This routine can run in atomic context. 1646 */ 1647int usb_autopm_get_interface_async(struct usb_interface *intf) 1648{ 1649 int status = 0; 1650 enum rpm_status s; 1651 1652 /* Don't request a resume unless the interface is already suspending 1653 * or suspended. Doing so would force a running suspend timer to be 1654 * cancelled. 1655 */ 1656 pm_runtime_get_noresume(&intf->dev); 1657 s = ACCESS_ONCE(intf->dev.power.runtime_status); 1658 if (s == RPM_SUSPENDING || s == RPM_SUSPENDED) 1659 status = pm_request_resume(&intf->dev); 1660 1661 if (status < 0 && status != -EINPROGRESS) 1662 pm_runtime_put_noidle(&intf->dev); 1663 else 1664 atomic_inc(&intf->pm_usage_cnt); 1665 dev_vdbg(&intf->dev, "%s: cnt %d -> %d\n", 1666 __func__, atomic_read(&intf->dev.power.usage_count), 1667 status); 1668 if (status > 0) 1669 status = 0; 1670 return status; 1671} 1672EXPORT_SYMBOL_GPL(usb_autopm_get_interface_async); 1673 1674/** 1675 * usb_autopm_get_interface_no_resume - increment a USB interface's PM-usage counter 1676 * @intf: the usb_interface whose counter should be incremented 1677 * 1678 * This routine increments @intf's usage counter but does not carry out an 1679 * autoresume. 1680 * 1681 * This routine can run in atomic context. 1682 */ 1683void usb_autopm_get_interface_no_resume(struct usb_interface *intf) 1684{ 1685 struct usb_device *udev = interface_to_usbdev(intf); 1686 1687 udev->last_busy = jiffies; 1688 atomic_inc(&intf->pm_usage_cnt); 1689 pm_runtime_get_noresume(&intf->dev); 1690} 1691EXPORT_SYMBOL_GPL(usb_autopm_get_interface_no_resume); 1692 1693/* Internal routine to check whether we may autosuspend a device. */ 1694static int autosuspend_check(struct usb_device *udev) 1695{ 1696 int w, i; 1697 struct usb_interface *intf; 1698 unsigned long suspend_time, j; 1699 1700 /* Fail if autosuspend is disabled, or any interfaces are in use, or 1701 * any interface drivers require remote wakeup but it isn't available. 1702 */ 1703 w = 0; 1704 if (udev->actconfig) { 1705 for (i = 0; i < udev->actconfig->desc.bNumInterfaces; i++) { 1706 intf = udev->actconfig->interface[i]; 1707 1708 /* We don't need to check interfaces that are 1709 * disabled for runtime PM. Either they are unbound 1710 * or else their drivers don't support autosuspend 1711 * and so they are permanently active. 1712 */ 1713 if (intf->dev.power.disable_depth) 1714 continue; 1715 if (atomic_read(&intf->dev.power.usage_count) > 0) 1716 return -EBUSY; 1717 w |= intf->needs_remote_wakeup; 1718 1719 /* Don't allow autosuspend if the device will need 1720 * a reset-resume and any of its interface drivers 1721 * doesn't include support or needs remote wakeup. 1722 */ 1723 if (udev->quirks & USB_QUIRK_RESET_RESUME) { 1724 struct usb_driver *driver; 1725 1726 driver = to_usb_driver(intf->dev.driver); 1727 if (!driver->reset_resume || 1728 intf->needs_remote_wakeup) 1729 return -EOPNOTSUPP; 1730 } 1731 } 1732 } 1733 if (w && !device_can_wakeup(&udev->dev)) { 1734 dev_dbg(&udev->dev, "remote wakeup needed for autosuspend\n"); 1735 return -EOPNOTSUPP; 1736 } 1737 udev->do_remote_wakeup = w; 1738 1739 /* If everything is okay but the device hasn't been idle for long 1740 * enough, queue a delayed autosuspend request. 1741 */ 1742 j = ACCESS_ONCE(jiffies); 1743 suspend_time = udev->last_busy + udev->autosuspend_delay; 1744 if (time_before(j, suspend_time)) { 1745 pm_schedule_suspend(&udev->dev, jiffies_to_msecs( 1746 round_jiffies_up_relative(suspend_time - j))); 1747 return -EAGAIN; 1748 } 1749 return 0; 1750} 1751 1752static int usb_runtime_suspend(struct device *dev) 1753{ 1754 int status = 0; 1755 1756 /* A USB device can be suspended if it passes the various autosuspend 1757 * checks. Runtime suspend for a USB device means suspending all the 1758 * interfaces and then the device itself. 1759 */ 1760 if (is_usb_device(dev)) { 1761 struct usb_device *udev = to_usb_device(dev); 1762 1763 if (autosuspend_check(udev) != 0) 1764 return -EAGAIN; 1765 1766 status = usb_suspend_both(udev, PMSG_AUTO_SUSPEND); 1767 1768 /* If an interface fails the suspend, adjust the last_busy 1769 * time so that we don't get another suspend attempt right 1770 * away. 1771 */ 1772 if (status) { 1773 udev->last_busy = jiffies + 1774 (udev->autosuspend_delay == 0 ? 1775 HZ/2 : 0); 1776 } 1777 1778 /* Prevent the parent from suspending immediately after */ 1779 else if (udev->parent) 1780 udev->parent->last_busy = jiffies; 1781 } 1782 1783 /* Runtime suspend for a USB interface doesn't mean anything. */ 1784 return status; 1785} 1786 1787static int usb_runtime_resume(struct device *dev) 1788{ 1789 /* Runtime resume for a USB device means resuming both the device 1790 * and all its interfaces. 1791 */ 1792 if (is_usb_device(dev)) { 1793 struct usb_device *udev = to_usb_device(dev); 1794 int status; 1795 1796 status = usb_resume_both(udev, PMSG_AUTO_RESUME); 1797 udev->last_busy = jiffies; 1798 return status; 1799 } 1800 1801 /* Runtime resume for a USB interface doesn't mean anything. */ 1802 return 0; 1803} 1804 1805static int usb_runtime_idle(struct device *dev) 1806{ 1807 /* An idle USB device can be suspended if it passes the various 1808 * autosuspend checks. An idle interface can be suspended at 1809 * any time. 1810 */ 1811 if (is_usb_device(dev)) { 1812 struct usb_device *udev = to_usb_device(dev); 1813 1814 if (autosuspend_check(udev) != 0) 1815 return 0; 1816 } 1817 1818 pm_runtime_suspend(dev); 1819 return 0; 1820} 1821 1822static const struct dev_pm_ops usb_bus_pm_ops = { 1823 .runtime_suspend = usb_runtime_suspend, 1824 .runtime_resume = usb_runtime_resume, 1825 .runtime_idle = usb_runtime_idle, 1826}; 1827 1828#endif /* CONFIG_USB_SUSPEND */ 1829 1830struct bus_type usb_bus_type = { 1831 .name = "usb", 1832 .match = usb_device_match, 1833 .uevent = usb_uevent, 1834#ifdef CONFIG_USB_SUSPEND 1835 .pm = &usb_bus_pm_ops, 1836#endif 1837}; 1838