1 /* 2 * drivers/base/power/main.c - Where the driver meets power management. 3 * 4 * Copyright (c) 2003 Patrick Mochel 5 * Copyright (c) 2003 Open Source Development Lab 6 * 7 * This file is released under the GPLv2 8 * 9 * 10 * The driver model core calls device_pm_add() when a device is registered. 11 * This will initialize the embedded device_pm_info object in the device 12 * and add it to the list of power-controlled devices. sysfs entries for 13 * controlling device power management will also be added. 14 * 15 * A separate list is used for keeping track of power info, because the power 16 * domain dependencies may differ from the ancestral dependencies that the 17 * subsystem list maintains. 18 */ 19 20 #include <linux/device.h> 21 #include <linux/kallsyms.h> 22 #include <linux/export.h> 23 #include <linux/mutex.h> 24 #include <linux/pm.h> 25 #include <linux/pm_runtime.h> 26 #include <linux/resume-trace.h> 27 #include <linux/interrupt.h> 28 #include <linux/sched.h> 29 #include <linux/async.h> 30 #include <linux/suspend.h> 31 32 #include "../base.h" 33 #include "power.h" 34 35 typedef int (*pm_callback_t)(struct device *); 36 37 /* 38 * The entries in the dpm_list list are in a depth first order, simply 39 * because children are guaranteed to be discovered after parents, and 40 * are inserted at the back of the list on discovery. 41 * 42 * Since device_pm_add() may be called with a device lock held, 43 * we must never try to acquire a device lock while holding 44 * dpm_list_mutex. 45 */ 46 47 LIST_HEAD(dpm_list); 48 LIST_HEAD(dpm_prepared_list); 49 LIST_HEAD(dpm_suspended_list); 50 LIST_HEAD(dpm_noirq_list); 51 52 struct suspend_stats suspend_stats; 53 static DEFINE_MUTEX(dpm_list_mtx); 54 static pm_message_t pm_transition; 55 56 static int async_error; 57 58 /** 59 * device_pm_init - Initialize the PM-related part of a device object. 60 * @dev: Device object being initialized. 61 */ 62 void device_pm_init(struct device *dev) 63 { 64 dev->power.is_prepared = false; 65 dev->power.is_suspended = false; 66 init_completion(&dev->power.completion); 67 complete_all(&dev->power.completion); 68 dev->power.wakeup = NULL; 69 spin_lock_init(&dev->power.lock); 70 pm_runtime_init(dev); 71 INIT_LIST_HEAD(&dev->power.entry); 72 dev->power.power_state = PMSG_INVALID; 73 } 74 75 /** 76 * device_pm_lock - Lock the list of active devices used by the PM core. 77 */ 78 void device_pm_lock(void) 79 { 80 mutex_lock(&dpm_list_mtx); 81 } 82 83 /** 84 * device_pm_unlock - Unlock the list of active devices used by the PM core. 85 */ 86 void device_pm_unlock(void) 87 { 88 mutex_unlock(&dpm_list_mtx); 89 } 90 91 /** 92 * device_pm_add - Add a device to the PM core's list of active devices. 93 * @dev: Device to add to the list. 94 */ 95 void device_pm_add(struct device *dev) 96 { 97 pr_debug("PM: Adding info for %s:%s\n", 98 dev->bus ? dev->bus->name : "No Bus", dev_name(dev)); 99 mutex_lock(&dpm_list_mtx); 100 if (dev->parent && dev->parent->power.is_prepared) 101 dev_warn(dev, "parent %s should not be sleeping\n", 102 dev_name(dev->parent)); 103 list_add_tail(&dev->power.entry, &dpm_list); 104 dev_pm_qos_constraints_init(dev); 105 mutex_unlock(&dpm_list_mtx); 106 } 107 108 /** 109 * device_pm_remove - Remove a device from the PM core's list of active devices. 110 * @dev: Device to be removed from the list. 111 */ 112 void device_pm_remove(struct device *dev) 113 { 114 pr_debug("PM: Removing info for %s:%s\n", 115 dev->bus ? dev->bus->name : "No Bus", dev_name(dev)); 116 complete_all(&dev->power.completion); 117 mutex_lock(&dpm_list_mtx); 118 dev_pm_qos_constraints_destroy(dev); 119 list_del_init(&dev->power.entry); 120 mutex_unlock(&dpm_list_mtx); 121 device_wakeup_disable(dev); 122 pm_runtime_remove(dev); 123 } 124 125 /** 126 * device_pm_move_before - Move device in the PM core's list of active devices. 127 * @deva: Device to move in dpm_list. 128 * @devb: Device @deva should come before. 129 */ 130 void device_pm_move_before(struct device *deva, struct device *devb) 131 { 132 pr_debug("PM: Moving %s:%s before %s:%s\n", 133 deva->bus ? deva->bus->name : "No Bus", dev_name(deva), 134 devb->bus ? devb->bus->name : "No Bus", dev_name(devb)); 135 /* Delete deva from dpm_list and reinsert before devb. */ 136 list_move_tail(&deva->power.entry, &devb->power.entry); 137 } 138 139 /** 140 * device_pm_move_after - Move device in the PM core's list of active devices. 141 * @deva: Device to move in dpm_list. 142 * @devb: Device @deva should come after. 143 */ 144 void device_pm_move_after(struct device *deva, struct device *devb) 145 { 146 pr_debug("PM: Moving %s:%s after %s:%s\n", 147 deva->bus ? deva->bus->name : "No Bus", dev_name(deva), 148 devb->bus ? devb->bus->name : "No Bus", dev_name(devb)); 149 /* Delete deva from dpm_list and reinsert after devb. */ 150 list_move(&deva->power.entry, &devb->power.entry); 151 } 152 153 /** 154 * device_pm_move_last - Move device to end of the PM core's list of devices. 155 * @dev: Device to move in dpm_list. 156 */ 157 void device_pm_move_last(struct device *dev) 158 { 159 pr_debug("PM: Moving %s:%s to end of list\n", 160 dev->bus ? dev->bus->name : "No Bus", dev_name(dev)); 161 list_move_tail(&dev->power.entry, &dpm_list); 162 } 163 164 static ktime_t initcall_debug_start(struct device *dev) 165 { 166 ktime_t calltime = ktime_set(0, 0); 167 168 if (initcall_debug) { 169 pr_info("calling %s+ @ %i, parent: %s\n", 170 dev_name(dev), task_pid_nr(current), 171 dev->parent ? dev_name(dev->parent) : "none"); 172 calltime = ktime_get(); 173 } 174 175 return calltime; 176 } 177 178 static void initcall_debug_report(struct device *dev, ktime_t calltime, 179 int error) 180 { 181 ktime_t delta, rettime; 182 183 if (initcall_debug) { 184 rettime = ktime_get(); 185 delta = ktime_sub(rettime, calltime); 186 pr_info("call %s+ returned %d after %Ld usecs\n", dev_name(dev), 187 error, (unsigned long long)ktime_to_ns(delta) >> 10); 188 } 189 } 190 191 /** 192 * dpm_wait - Wait for a PM operation to complete. 193 * @dev: Device to wait for. 194 * @async: If unset, wait only if the device's power.async_suspend flag is set. 195 */ 196 static void dpm_wait(struct device *dev, bool async) 197 { 198 if (!dev) 199 return; 200 201 if (async || (pm_async_enabled && dev->power.async_suspend)) 202 wait_for_completion(&dev->power.completion); 203 } 204 205 static int dpm_wait_fn(struct device *dev, void *async_ptr) 206 { 207 dpm_wait(dev, *((bool *)async_ptr)); 208 return 0; 209 } 210 211 static void dpm_wait_for_children(struct device *dev, bool async) 212 { 213 device_for_each_child(dev, &async, dpm_wait_fn); 214 } 215 216 /** 217 * pm_op - Return the PM operation appropriate for given PM event. 218 * @ops: PM operations to choose from. 219 * @state: PM transition of the system being carried out. 220 */ 221 static pm_callback_t pm_op(const struct dev_pm_ops *ops, pm_message_t state) 222 { 223 switch (state.event) { 224 #ifdef CONFIG_SUSPEND 225 case PM_EVENT_SUSPEND: 226 return ops->suspend; 227 case PM_EVENT_RESUME: 228 return ops->resume; 229 #endif /* CONFIG_SUSPEND */ 230 #ifdef CONFIG_HIBERNATE_CALLBACKS 231 case PM_EVENT_FREEZE: 232 case PM_EVENT_QUIESCE: 233 return ops->freeze; 234 case PM_EVENT_HIBERNATE: 235 return ops->poweroff; 236 case PM_EVENT_THAW: 237 case PM_EVENT_RECOVER: 238 return ops->thaw; 239 break; 240 case PM_EVENT_RESTORE: 241 return ops->restore; 242 #endif /* CONFIG_HIBERNATE_CALLBACKS */ 243 } 244 245 return NULL; 246 } 247 248 /** 249 * pm_noirq_op - Return the PM operation appropriate for given PM event. 250 * @ops: PM operations to choose from. 251 * @state: PM transition of the system being carried out. 252 * 253 * The driver of @dev will not receive interrupts while this function is being 254 * executed. 255 */ 256 static pm_callback_t pm_noirq_op(const struct dev_pm_ops *ops, pm_message_t state) 257 { 258 switch (state.event) { 259 #ifdef CONFIG_SUSPEND 260 case PM_EVENT_SUSPEND: 261 return ops->suspend_noirq; 262 case PM_EVENT_RESUME: 263 return ops->resume_noirq; 264 #endif /* CONFIG_SUSPEND */ 265 #ifdef CONFIG_HIBERNATE_CALLBACKS 266 case PM_EVENT_FREEZE: 267 case PM_EVENT_QUIESCE: 268 return ops->freeze_noirq; 269 case PM_EVENT_HIBERNATE: 270 return ops->poweroff_noirq; 271 case PM_EVENT_THAW: 272 case PM_EVENT_RECOVER: 273 return ops->thaw_noirq; 274 case PM_EVENT_RESTORE: 275 return ops->restore_noirq; 276 #endif /* CONFIG_HIBERNATE_CALLBACKS */ 277 } 278 279 return NULL; 280 } 281 282 static char *pm_verb(int event) 283 { 284 switch (event) { 285 case PM_EVENT_SUSPEND: 286 return "suspend"; 287 case PM_EVENT_RESUME: 288 return "resume"; 289 case PM_EVENT_FREEZE: 290 return "freeze"; 291 case PM_EVENT_QUIESCE: 292 return "quiesce"; 293 case PM_EVENT_HIBERNATE: 294 return "hibernate"; 295 case PM_EVENT_THAW: 296 return "thaw"; 297 case PM_EVENT_RESTORE: 298 return "restore"; 299 case PM_EVENT_RECOVER: 300 return "recover"; 301 default: 302 return "(unknown PM event)"; 303 } 304 } 305 306 static void pm_dev_dbg(struct device *dev, pm_message_t state, char *info) 307 { 308 dev_dbg(dev, "%s%s%s\n", info, pm_verb(state.event), 309 ((state.event & PM_EVENT_SLEEP) && device_may_wakeup(dev)) ? 310 ", may wakeup" : ""); 311 } 312 313 static void pm_dev_err(struct device *dev, pm_message_t state, char *info, 314 int error) 315 { 316 printk(KERN_ERR "PM: Device %s failed to %s%s: error %d\n", 317 dev_name(dev), pm_verb(state.event), info, error); 318 } 319 320 static void dpm_show_time(ktime_t starttime, pm_message_t state, char *info) 321 { 322 ktime_t calltime; 323 u64 usecs64; 324 int usecs; 325 326 calltime = ktime_get(); 327 usecs64 = ktime_to_ns(ktime_sub(calltime, starttime)); 328 do_div(usecs64, NSEC_PER_USEC); 329 usecs = usecs64; 330 if (usecs == 0) 331 usecs = 1; 332 pr_info("PM: %s%s%s of devices complete after %ld.%03ld msecs\n", 333 info ?: "", info ? " " : "", pm_verb(state.event), 334 usecs / USEC_PER_MSEC, usecs % USEC_PER_MSEC); 335 } 336 337 static int dpm_run_callback(pm_callback_t cb, struct device *dev, 338 pm_message_t state, char *info) 339 { 340 ktime_t calltime; 341 int error; 342 343 if (!cb) 344 return 0; 345 346 calltime = initcall_debug_start(dev); 347 348 pm_dev_dbg(dev, state, info); 349 error = cb(dev); 350 suspend_report_result(cb, error); 351 352 initcall_debug_report(dev, calltime, error); 353 354 return error; 355 } 356 357 /*------------------------- Resume routines -------------------------*/ 358 359 /** 360 * device_resume_noirq - Execute an "early resume" callback for given device. 361 * @dev: Device to handle. 362 * @state: PM transition of the system being carried out. 363 * 364 * The driver of @dev will not receive interrupts while this function is being 365 * executed. 366 */ 367 static int device_resume_noirq(struct device *dev, pm_message_t state) 368 { 369 pm_callback_t callback = NULL; 370 char *info = NULL; 371 int error = 0; 372 373 TRACE_DEVICE(dev); 374 TRACE_RESUME(0); 375 376 if (dev->pm_domain) { 377 info = "EARLY power domain "; 378 callback = pm_noirq_op(&dev->pm_domain->ops, state); 379 } else if (dev->type && dev->type->pm) { 380 info = "EARLY type "; 381 callback = pm_noirq_op(dev->type->pm, state); 382 } else if (dev->class && dev->class->pm) { 383 info = "EARLY class "; 384 callback = pm_noirq_op(dev->class->pm, state); 385 } else if (dev->bus && dev->bus->pm) { 386 info = "EARLY bus "; 387 callback = pm_noirq_op(dev->bus->pm, state); 388 } 389 390 if (!callback && dev->driver && dev->driver->pm) { 391 info = "EARLY driver "; 392 callback = pm_noirq_op(dev->driver->pm, state); 393 } 394 395 error = dpm_run_callback(callback, dev, state, info); 396 397 TRACE_RESUME(error); 398 return error; 399 } 400 401 /** 402 * dpm_resume_noirq - Execute "early resume" callbacks for non-sysdev devices. 403 * @state: PM transition of the system being carried out. 404 * 405 * Call the "noirq" resume handlers for all devices marked as DPM_OFF_IRQ and 406 * enable device drivers to receive interrupts. 407 */ 408 void dpm_resume_noirq(pm_message_t state) 409 { 410 ktime_t starttime = ktime_get(); 411 412 mutex_lock(&dpm_list_mtx); 413 while (!list_empty(&dpm_noirq_list)) { 414 struct device *dev = to_device(dpm_noirq_list.next); 415 int error; 416 417 get_device(dev); 418 list_move_tail(&dev->power.entry, &dpm_suspended_list); 419 mutex_unlock(&dpm_list_mtx); 420 421 error = device_resume_noirq(dev, state); 422 if (error) { 423 suspend_stats.failed_resume_noirq++; 424 dpm_save_failed_step(SUSPEND_RESUME_NOIRQ); 425 dpm_save_failed_dev(dev_name(dev)); 426 pm_dev_err(dev, state, " early", error); 427 } 428 429 mutex_lock(&dpm_list_mtx); 430 put_device(dev); 431 } 432 mutex_unlock(&dpm_list_mtx); 433 dpm_show_time(starttime, state, "early"); 434 resume_device_irqs(); 435 } 436 EXPORT_SYMBOL_GPL(dpm_resume_noirq); 437 438 /** 439 * device_resume - Execute "resume" callbacks for given device. 440 * @dev: Device to handle. 441 * @state: PM transition of the system being carried out. 442 * @async: If true, the device is being resumed asynchronously. 443 */ 444 static int device_resume(struct device *dev, pm_message_t state, bool async) 445 { 446 pm_callback_t callback = NULL; 447 char *info = NULL; 448 int error = 0; 449 bool put = false; 450 451 TRACE_DEVICE(dev); 452 TRACE_RESUME(0); 453 454 dpm_wait(dev->parent, async); 455 device_lock(dev); 456 457 /* 458 * This is a fib. But we'll allow new children to be added below 459 * a resumed device, even if the device hasn't been completed yet. 460 */ 461 dev->power.is_prepared = false; 462 463 if (!dev->power.is_suspended) 464 goto Unlock; 465 466 pm_runtime_enable(dev); 467 put = true; 468 469 if (dev->pm_domain) { 470 info = "power domain "; 471 callback = pm_op(&dev->pm_domain->ops, state); 472 goto Driver; 473 } 474 475 if (dev->type && dev->type->pm) { 476 info = "type "; 477 callback = pm_op(dev->type->pm, state); 478 goto Driver; 479 } 480 481 if (dev->class) { 482 if (dev->class->pm) { 483 info = "class "; 484 callback = pm_op(dev->class->pm, state); 485 goto Driver; 486 } else if (dev->class->resume) { 487 info = "legacy class "; 488 callback = dev->class->resume; 489 goto End; 490 } 491 } 492 493 if (dev->bus) { 494 if (dev->bus->pm) { 495 info = "bus "; 496 callback = pm_op(dev->bus->pm, state); 497 } else if (dev->bus->resume) { 498 info = "legacy bus "; 499 callback = dev->bus->resume; 500 goto End; 501 } 502 } 503 504 Driver: 505 if (!callback && dev->driver && dev->driver->pm) { 506 info = "driver "; 507 callback = pm_op(dev->driver->pm, state); 508 } 509 510 End: 511 error = dpm_run_callback(callback, dev, state, info); 512 dev->power.is_suspended = false; 513 514 Unlock: 515 device_unlock(dev); 516 complete_all(&dev->power.completion); 517 518 TRACE_RESUME(error); 519 520 if (put) 521 pm_runtime_put_sync(dev); 522 523 return error; 524 } 525 526 static void async_resume(void *data, async_cookie_t cookie) 527 { 528 struct device *dev = (struct device *)data; 529 int error; 530 531 error = device_resume(dev, pm_transition, true); 532 if (error) 533 pm_dev_err(dev, pm_transition, " async", error); 534 put_device(dev); 535 } 536 537 static bool is_async(struct device *dev) 538 { 539 return dev->power.async_suspend && pm_async_enabled 540 && !pm_trace_is_enabled(); 541 } 542 543 /** 544 * dpm_resume - Execute "resume" callbacks for non-sysdev devices. 545 * @state: PM transition of the system being carried out. 546 * 547 * Execute the appropriate "resume" callback for all devices whose status 548 * indicates that they are suspended. 549 */ 550 void dpm_resume(pm_message_t state) 551 { 552 struct device *dev; 553 ktime_t starttime = ktime_get(); 554 555 might_sleep(); 556 557 mutex_lock(&dpm_list_mtx); 558 pm_transition = state; 559 async_error = 0; 560 561 list_for_each_entry(dev, &dpm_suspended_list, power.entry) { 562 INIT_COMPLETION(dev->power.completion); 563 if (is_async(dev)) { 564 get_device(dev); 565 async_schedule(async_resume, dev); 566 } 567 } 568 569 while (!list_empty(&dpm_suspended_list)) { 570 dev = to_device(dpm_suspended_list.next); 571 get_device(dev); 572 if (!is_async(dev)) { 573 int error; 574 575 mutex_unlock(&dpm_list_mtx); 576 577 error = device_resume(dev, state, false); 578 if (error) { 579 suspend_stats.failed_resume++; 580 dpm_save_failed_step(SUSPEND_RESUME); 581 dpm_save_failed_dev(dev_name(dev)); 582 pm_dev_err(dev, state, "", error); 583 } 584 585 mutex_lock(&dpm_list_mtx); 586 } 587 if (!list_empty(&dev->power.entry)) 588 list_move_tail(&dev->power.entry, &dpm_prepared_list); 589 put_device(dev); 590 } 591 mutex_unlock(&dpm_list_mtx); 592 async_synchronize_full(); 593 dpm_show_time(starttime, state, NULL); 594 } 595 596 /** 597 * device_complete - Complete a PM transition for given device. 598 * @dev: Device to handle. 599 * @state: PM transition of the system being carried out. 600 */ 601 static void device_complete(struct device *dev, pm_message_t state) 602 { 603 void (*callback)(struct device *) = NULL; 604 char *info = NULL; 605 606 device_lock(dev); 607 608 if (dev->pm_domain) { 609 info = "completing power domain "; 610 callback = dev->pm_domain->ops.complete; 611 } else if (dev->type && dev->type->pm) { 612 info = "completing type "; 613 callback = dev->type->pm->complete; 614 } else if (dev->class && dev->class->pm) { 615 info = "completing class "; 616 callback = dev->class->pm->complete; 617 } else if (dev->bus && dev->bus->pm) { 618 info = "completing bus "; 619 callback = dev->bus->pm->complete; 620 } 621 622 if (!callback && dev->driver && dev->driver->pm) { 623 info = "completing driver "; 624 callback = dev->driver->pm->complete; 625 } 626 627 if (callback) { 628 pm_dev_dbg(dev, state, info); 629 callback(dev); 630 } 631 632 device_unlock(dev); 633 } 634 635 /** 636 * dpm_complete - Complete a PM transition for all non-sysdev devices. 637 * @state: PM transition of the system being carried out. 638 * 639 * Execute the ->complete() callbacks for all devices whose PM status is not 640 * DPM_ON (this allows new devices to be registered). 641 */ 642 void dpm_complete(pm_message_t state) 643 { 644 struct list_head list; 645 646 might_sleep(); 647 648 INIT_LIST_HEAD(&list); 649 mutex_lock(&dpm_list_mtx); 650 while (!list_empty(&dpm_prepared_list)) { 651 struct device *dev = to_device(dpm_prepared_list.prev); 652 653 get_device(dev); 654 dev->power.is_prepared = false; 655 list_move(&dev->power.entry, &list); 656 mutex_unlock(&dpm_list_mtx); 657 658 device_complete(dev, state); 659 660 mutex_lock(&dpm_list_mtx); 661 put_device(dev); 662 } 663 list_splice(&list, &dpm_list); 664 mutex_unlock(&dpm_list_mtx); 665 } 666 667 /** 668 * dpm_resume_end - Execute "resume" callbacks and complete system transition. 669 * @state: PM transition of the system being carried out. 670 * 671 * Execute "resume" callbacks for all devices and complete the PM transition of 672 * the system. 673 */ 674 void dpm_resume_end(pm_message_t state) 675 { 676 dpm_resume(state); 677 dpm_complete(state); 678 } 679 EXPORT_SYMBOL_GPL(dpm_resume_end); 680 681 682 /*------------------------- Suspend routines -------------------------*/ 683 684 /** 685 * resume_event - Return a "resume" message for given "suspend" sleep state. 686 * @sleep_state: PM message representing a sleep state. 687 * 688 * Return a PM message representing the resume event corresponding to given 689 * sleep state. 690 */ 691 static pm_message_t resume_event(pm_message_t sleep_state) 692 { 693 switch (sleep_state.event) { 694 case PM_EVENT_SUSPEND: 695 return PMSG_RESUME; 696 case PM_EVENT_FREEZE: 697 case PM_EVENT_QUIESCE: 698 return PMSG_RECOVER; 699 case PM_EVENT_HIBERNATE: 700 return PMSG_RESTORE; 701 } 702 return PMSG_ON; 703 } 704 705 /** 706 * device_suspend_noirq - Execute a "late suspend" callback for given device. 707 * @dev: Device to handle. 708 * @state: PM transition of the system being carried out. 709 * 710 * The driver of @dev will not receive interrupts while this function is being 711 * executed. 712 */ 713 static int device_suspend_noirq(struct device *dev, pm_message_t state) 714 { 715 pm_callback_t callback = NULL; 716 char *info = NULL; 717 718 if (dev->pm_domain) { 719 info = "LATE power domain "; 720 callback = pm_noirq_op(&dev->pm_domain->ops, state); 721 } else if (dev->type && dev->type->pm) { 722 info = "LATE type "; 723 callback = pm_noirq_op(dev->type->pm, state); 724 } else if (dev->class && dev->class->pm) { 725 info = "LATE class "; 726 callback = pm_noirq_op(dev->class->pm, state); 727 } else if (dev->bus && dev->bus->pm) { 728 info = "LATE bus "; 729 callback = pm_noirq_op(dev->bus->pm, state); 730 } 731 732 if (!callback && dev->driver && dev->driver->pm) { 733 info = "LATE driver "; 734 callback = pm_noirq_op(dev->driver->pm, state); 735 } 736 737 return dpm_run_callback(callback, dev, state, info); 738 } 739 740 /** 741 * dpm_suspend_noirq - Execute "late suspend" callbacks for non-sysdev devices. 742 * @state: PM transition of the system being carried out. 743 * 744 * Prevent device drivers from receiving interrupts and call the "noirq" suspend 745 * handlers for all non-sysdev devices. 746 */ 747 int dpm_suspend_noirq(pm_message_t state) 748 { 749 ktime_t starttime = ktime_get(); 750 int error = 0; 751 752 suspend_device_irqs(); 753 mutex_lock(&dpm_list_mtx); 754 while (!list_empty(&dpm_suspended_list)) { 755 struct device *dev = to_device(dpm_suspended_list.prev); 756 757 get_device(dev); 758 mutex_unlock(&dpm_list_mtx); 759 760 error = device_suspend_noirq(dev, state); 761 762 mutex_lock(&dpm_list_mtx); 763 if (error) { 764 pm_dev_err(dev, state, " late", error); 765 suspend_stats.failed_suspend_noirq++; 766 dpm_save_failed_step(SUSPEND_SUSPEND_NOIRQ); 767 dpm_save_failed_dev(dev_name(dev)); 768 put_device(dev); 769 break; 770 } 771 if (!list_empty(&dev->power.entry)) 772 list_move(&dev->power.entry, &dpm_noirq_list); 773 put_device(dev); 774 } 775 mutex_unlock(&dpm_list_mtx); 776 if (error) 777 dpm_resume_noirq(resume_event(state)); 778 else 779 dpm_show_time(starttime, state, "late"); 780 return error; 781 } 782 EXPORT_SYMBOL_GPL(dpm_suspend_noirq); 783 784 /** 785 * legacy_suspend - Execute a legacy (bus or class) suspend callback for device. 786 * @dev: Device to suspend. 787 * @state: PM transition of the system being carried out. 788 * @cb: Suspend callback to execute. 789 */ 790 static int legacy_suspend(struct device *dev, pm_message_t state, 791 int (*cb)(struct device *dev, pm_message_t state)) 792 { 793 int error; 794 ktime_t calltime; 795 796 calltime = initcall_debug_start(dev); 797 798 error = cb(dev, state); 799 suspend_report_result(cb, error); 800 801 initcall_debug_report(dev, calltime, error); 802 803 return error; 804 } 805 806 /** 807 * device_suspend - Execute "suspend" callbacks for given device. 808 * @dev: Device to handle. 809 * @state: PM transition of the system being carried out. 810 * @async: If true, the device is being suspended asynchronously. 811 */ 812 static int __device_suspend(struct device *dev, pm_message_t state, bool async) 813 { 814 pm_callback_t callback = NULL; 815 char *info = NULL; 816 int error = 0; 817 818 dpm_wait_for_children(dev, async); 819 820 if (async_error) 821 return 0; 822 823 pm_runtime_get_noresume(dev); 824 if (pm_runtime_barrier(dev) && device_may_wakeup(dev)) 825 pm_wakeup_event(dev, 0); 826 827 if (pm_wakeup_pending()) { 828 pm_runtime_put_sync(dev); 829 async_error = -EBUSY; 830 return 0; 831 } 832 833 device_lock(dev); 834 835 if (dev->pm_domain) { 836 info = "power domain "; 837 callback = pm_op(&dev->pm_domain->ops, state); 838 goto Run; 839 } 840 841 if (dev->type && dev->type->pm) { 842 info = "type "; 843 callback = pm_op(dev->type->pm, state); 844 goto Run; 845 } 846 847 if (dev->class) { 848 if (dev->class->pm) { 849 info = "class "; 850 callback = pm_op(dev->class->pm, state); 851 goto Run; 852 } else if (dev->class->suspend) { 853 pm_dev_dbg(dev, state, "legacy class "); 854 error = legacy_suspend(dev, state, dev->class->suspend); 855 goto End; 856 } 857 } 858 859 if (dev->bus) { 860 if (dev->bus->pm) { 861 info = "bus "; 862 callback = pm_op(dev->bus->pm, state); 863 } else if (dev->bus->suspend) { 864 pm_dev_dbg(dev, state, "legacy bus "); 865 error = legacy_suspend(dev, state, dev->bus->suspend); 866 goto End; 867 } 868 } 869 870 Run: 871 if (!callback && dev->driver && dev->driver->pm) { 872 info = "driver "; 873 callback = pm_op(dev->driver->pm, state); 874 } 875 876 error = dpm_run_callback(callback, dev, state, info); 877 878 End: 879 if (!error) { 880 dev->power.is_suspended = true; 881 if (dev->power.wakeup_path 882 && dev->parent && !dev->parent->power.ignore_children) 883 dev->parent->power.wakeup_path = true; 884 } 885 886 device_unlock(dev); 887 complete_all(&dev->power.completion); 888 889 if (error) { 890 pm_runtime_put_sync(dev); 891 async_error = error; 892 } else if (dev->power.is_suspended) { 893 __pm_runtime_disable(dev, false); 894 } 895 896 return error; 897 } 898 899 static void async_suspend(void *data, async_cookie_t cookie) 900 { 901 struct device *dev = (struct device *)data; 902 int error; 903 904 error = __device_suspend(dev, pm_transition, true); 905 if (error) { 906 dpm_save_failed_dev(dev_name(dev)); 907 pm_dev_err(dev, pm_transition, " async", error); 908 } 909 910 put_device(dev); 911 } 912 913 static int device_suspend(struct device *dev) 914 { 915 INIT_COMPLETION(dev->power.completion); 916 917 if (pm_async_enabled && dev->power.async_suspend) { 918 get_device(dev); 919 async_schedule(async_suspend, dev); 920 return 0; 921 } 922 923 return __device_suspend(dev, pm_transition, false); 924 } 925 926 /** 927 * dpm_suspend - Execute "suspend" callbacks for all non-sysdev devices. 928 * @state: PM transition of the system being carried out. 929 */ 930 int dpm_suspend(pm_message_t state) 931 { 932 ktime_t starttime = ktime_get(); 933 int error = 0; 934 935 might_sleep(); 936 937 mutex_lock(&dpm_list_mtx); 938 pm_transition = state; 939 async_error = 0; 940 while (!list_empty(&dpm_prepared_list)) { 941 struct device *dev = to_device(dpm_prepared_list.prev); 942 943 get_device(dev); 944 mutex_unlock(&dpm_list_mtx); 945 946 error = device_suspend(dev); 947 948 mutex_lock(&dpm_list_mtx); 949 if (error) { 950 pm_dev_err(dev, state, "", error); 951 dpm_save_failed_dev(dev_name(dev)); 952 put_device(dev); 953 break; 954 } 955 if (!list_empty(&dev->power.entry)) 956 list_move(&dev->power.entry, &dpm_suspended_list); 957 put_device(dev); 958 if (async_error) 959 break; 960 } 961 mutex_unlock(&dpm_list_mtx); 962 async_synchronize_full(); 963 if (!error) 964 error = async_error; 965 if (error) { 966 suspend_stats.failed_suspend++; 967 dpm_save_failed_step(SUSPEND_SUSPEND); 968 } else 969 dpm_show_time(starttime, state, NULL); 970 return error; 971 } 972 973 /** 974 * device_prepare - Prepare a device for system power transition. 975 * @dev: Device to handle. 976 * @state: PM transition of the system being carried out. 977 * 978 * Execute the ->prepare() callback(s) for given device. No new children of the 979 * device may be registered after this function has returned. 980 */ 981 static int device_prepare(struct device *dev, pm_message_t state) 982 { 983 int (*callback)(struct device *) = NULL; 984 char *info = NULL; 985 int error = 0; 986 987 device_lock(dev); 988 989 dev->power.wakeup_path = device_may_wakeup(dev); 990 991 if (dev->pm_domain) { 992 info = "preparing power domain "; 993 callback = dev->pm_domain->ops.prepare; 994 } else if (dev->type && dev->type->pm) { 995 info = "preparing type "; 996 callback = dev->type->pm->prepare; 997 } else if (dev->class && dev->class->pm) { 998 info = "preparing class "; 999 callback = dev->class->pm->prepare; 1000 } else if (dev->bus && dev->bus->pm) { 1001 info = "preparing bus "; 1002 callback = dev->bus->pm->prepare; 1003 } 1004 1005 if (!callback && dev->driver && dev->driver->pm) { 1006 info = "preparing driver "; 1007 callback = dev->driver->pm->prepare; 1008 } 1009 1010 if (callback) { 1011 error = callback(dev); 1012 suspend_report_result(callback, error); 1013 } 1014 1015 device_unlock(dev); 1016 1017 return error; 1018 } 1019 1020 /** 1021 * dpm_prepare - Prepare all non-sysdev devices for a system PM transition. 1022 * @state: PM transition of the system being carried out. 1023 * 1024 * Execute the ->prepare() callback(s) for all devices. 1025 */ 1026 int dpm_prepare(pm_message_t state) 1027 { 1028 int error = 0; 1029 1030 might_sleep(); 1031 1032 mutex_lock(&dpm_list_mtx); 1033 while (!list_empty(&dpm_list)) { 1034 struct device *dev = to_device(dpm_list.next); 1035 1036 get_device(dev); 1037 mutex_unlock(&dpm_list_mtx); 1038 1039 error = device_prepare(dev, state); 1040 1041 mutex_lock(&dpm_list_mtx); 1042 if (error) { 1043 if (error == -EAGAIN) { 1044 put_device(dev); 1045 error = 0; 1046 continue; 1047 } 1048 printk(KERN_INFO "PM: Device %s not prepared " 1049 "for power transition: code %d\n", 1050 dev_name(dev), error); 1051 put_device(dev); 1052 break; 1053 } 1054 dev->power.is_prepared = true; 1055 if (!list_empty(&dev->power.entry)) 1056 list_move_tail(&dev->power.entry, &dpm_prepared_list); 1057 put_device(dev); 1058 } 1059 mutex_unlock(&dpm_list_mtx); 1060 return error; 1061 } 1062 1063 /** 1064 * dpm_suspend_start - Prepare devices for PM transition and suspend them. 1065 * @state: PM transition of the system being carried out. 1066 * 1067 * Prepare all non-sysdev devices for system PM transition and execute "suspend" 1068 * callbacks for them. 1069 */ 1070 int dpm_suspend_start(pm_message_t state) 1071 { 1072 int error; 1073 1074 error = dpm_prepare(state); 1075 if (error) { 1076 suspend_stats.failed_prepare++; 1077 dpm_save_failed_step(SUSPEND_PREPARE); 1078 } else 1079 error = dpm_suspend(state); 1080 return error; 1081 } 1082 EXPORT_SYMBOL_GPL(dpm_suspend_start); 1083 1084 void __suspend_report_result(const char *function, void *fn, int ret) 1085 { 1086 if (ret) 1087 printk(KERN_ERR "%s(): %pF returns %d\n", function, fn, ret); 1088 } 1089 EXPORT_SYMBOL_GPL(__suspend_report_result); 1090 1091 /** 1092 * device_pm_wait_for_dev - Wait for suspend/resume of a device to complete. 1093 * @dev: Device to wait for. 1094 * @subordinate: Device that needs to wait for @dev. 1095 */ 1096 int device_pm_wait_for_dev(struct device *subordinate, struct device *dev) 1097 { 1098 dpm_wait(dev, subordinate->power.async_suspend); 1099 return async_error; 1100 } 1101 EXPORT_SYMBOL_GPL(device_pm_wait_for_dev); 1102