main.c revision 728f08934b087b96aacb00467f5551e0a5593fca
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 intialize 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/mutex.h> 23#include <linux/pm.h> 24#include <linux/resume-trace.h> 25#include <linux/rwsem.h> 26 27#include "../base.h" 28#include "power.h" 29 30/* 31 * The entries in the dpm_list list are in a depth first order, simply 32 * because children are guaranteed to be discovered after parents, and 33 * are inserted at the back of the list on discovery. 34 * 35 * Since device_pm_add() may be called with a device semaphore held, 36 * we must never try to acquire a device semaphore while holding 37 * dpm_list_mutex. 38 */ 39 40LIST_HEAD(dpm_list); 41 42static DEFINE_MUTEX(dpm_list_mtx); 43 44/* 45 * Set once the preparation of devices for a PM transition has started, reset 46 * before starting to resume devices. Protected by dpm_list_mtx. 47 */ 48static bool transition_started; 49 50/** 51 * device_pm_lock - lock the list of active devices used by the PM core 52 */ 53void device_pm_lock(void) 54{ 55 mutex_lock(&dpm_list_mtx); 56} 57 58/** 59 * device_pm_unlock - unlock the list of active devices used by the PM core 60 */ 61void device_pm_unlock(void) 62{ 63 mutex_unlock(&dpm_list_mtx); 64} 65 66/** 67 * device_pm_add - add a device to the list of active devices 68 * @dev: Device to be added to the list 69 */ 70void device_pm_add(struct device *dev) 71{ 72 pr_debug("PM: Adding info for %s:%s\n", 73 dev->bus ? dev->bus->name : "No Bus", 74 kobject_name(&dev->kobj)); 75 mutex_lock(&dpm_list_mtx); 76 if (dev->parent) { 77 if (dev->parent->power.status >= DPM_SUSPENDING) 78 dev_warn(dev, "parent %s should not be sleeping\n", 79 dev->parent->bus_id); 80 } else if (transition_started) { 81 /* 82 * We refuse to register parentless devices while a PM 83 * transition is in progress in order to avoid leaving them 84 * unhandled down the road 85 */ 86 dev_WARN(dev, "Parentless device registered during a PM transaction\n"); 87 } 88 89 list_add_tail(&dev->power.entry, &dpm_list); 90 mutex_unlock(&dpm_list_mtx); 91} 92 93/** 94 * device_pm_remove - remove a device from the list of active devices 95 * @dev: Device to be removed from the list 96 * 97 * This function also removes the device's PM-related sysfs attributes. 98 */ 99void device_pm_remove(struct device *dev) 100{ 101 pr_debug("PM: Removing info for %s:%s\n", 102 dev->bus ? dev->bus->name : "No Bus", 103 kobject_name(&dev->kobj)); 104 mutex_lock(&dpm_list_mtx); 105 list_del_init(&dev->power.entry); 106 mutex_unlock(&dpm_list_mtx); 107} 108 109/** 110 * pm_op - execute the PM operation appropiate for given PM event 111 * @dev: Device. 112 * @ops: PM operations to choose from. 113 * @state: PM transition of the system being carried out. 114 */ 115static int pm_op(struct device *dev, struct pm_ops *ops, pm_message_t state) 116{ 117 int error = 0; 118 119 switch (state.event) { 120#ifdef CONFIG_SUSPEND 121 case PM_EVENT_SUSPEND: 122 if (ops->suspend) { 123 error = ops->suspend(dev); 124 suspend_report_result(ops->suspend, error); 125 } 126 break; 127 case PM_EVENT_RESUME: 128 if (ops->resume) { 129 error = ops->resume(dev); 130 suspend_report_result(ops->resume, error); 131 } 132 break; 133#endif /* CONFIG_SUSPEND */ 134#ifdef CONFIG_HIBERNATION 135 case PM_EVENT_FREEZE: 136 case PM_EVENT_QUIESCE: 137 if (ops->freeze) { 138 error = ops->freeze(dev); 139 suspend_report_result(ops->freeze, error); 140 } 141 break; 142 case PM_EVENT_HIBERNATE: 143 if (ops->poweroff) { 144 error = ops->poweroff(dev); 145 suspend_report_result(ops->poweroff, error); 146 } 147 break; 148 case PM_EVENT_THAW: 149 case PM_EVENT_RECOVER: 150 if (ops->thaw) { 151 error = ops->thaw(dev); 152 suspend_report_result(ops->thaw, error); 153 } 154 break; 155 case PM_EVENT_RESTORE: 156 if (ops->restore) { 157 error = ops->restore(dev); 158 suspend_report_result(ops->restore, error); 159 } 160 break; 161#endif /* CONFIG_HIBERNATION */ 162 default: 163 error = -EINVAL; 164 } 165 return error; 166} 167 168/** 169 * pm_noirq_op - execute the PM operation appropiate for given PM event 170 * @dev: Device. 171 * @ops: PM operations to choose from. 172 * @state: PM transition of the system being carried out. 173 * 174 * The operation is executed with interrupts disabled by the only remaining 175 * functional CPU in the system. 176 */ 177static int pm_noirq_op(struct device *dev, struct pm_ext_ops *ops, 178 pm_message_t state) 179{ 180 int error = 0; 181 182 switch (state.event) { 183#ifdef CONFIG_SUSPEND 184 case PM_EVENT_SUSPEND: 185 if (ops->suspend_noirq) { 186 error = ops->suspend_noirq(dev); 187 suspend_report_result(ops->suspend_noirq, error); 188 } 189 break; 190 case PM_EVENT_RESUME: 191 if (ops->resume_noirq) { 192 error = ops->resume_noirq(dev); 193 suspend_report_result(ops->resume_noirq, error); 194 } 195 break; 196#endif /* CONFIG_SUSPEND */ 197#ifdef CONFIG_HIBERNATION 198 case PM_EVENT_FREEZE: 199 case PM_EVENT_QUIESCE: 200 if (ops->freeze_noirq) { 201 error = ops->freeze_noirq(dev); 202 suspend_report_result(ops->freeze_noirq, error); 203 } 204 break; 205 case PM_EVENT_HIBERNATE: 206 if (ops->poweroff_noirq) { 207 error = ops->poweroff_noirq(dev); 208 suspend_report_result(ops->poweroff_noirq, error); 209 } 210 break; 211 case PM_EVENT_THAW: 212 case PM_EVENT_RECOVER: 213 if (ops->thaw_noirq) { 214 error = ops->thaw_noirq(dev); 215 suspend_report_result(ops->thaw_noirq, error); 216 } 217 break; 218 case PM_EVENT_RESTORE: 219 if (ops->restore_noirq) { 220 error = ops->restore_noirq(dev); 221 suspend_report_result(ops->restore_noirq, error); 222 } 223 break; 224#endif /* CONFIG_HIBERNATION */ 225 default: 226 error = -EINVAL; 227 } 228 return error; 229} 230 231static char *pm_verb(int event) 232{ 233 switch (event) { 234 case PM_EVENT_SUSPEND: 235 return "suspend"; 236 case PM_EVENT_RESUME: 237 return "resume"; 238 case PM_EVENT_FREEZE: 239 return "freeze"; 240 case PM_EVENT_QUIESCE: 241 return "quiesce"; 242 case PM_EVENT_HIBERNATE: 243 return "hibernate"; 244 case PM_EVENT_THAW: 245 return "thaw"; 246 case PM_EVENT_RESTORE: 247 return "restore"; 248 case PM_EVENT_RECOVER: 249 return "recover"; 250 default: 251 return "(unknown PM event)"; 252 } 253} 254 255static void pm_dev_dbg(struct device *dev, pm_message_t state, char *info) 256{ 257 dev_dbg(dev, "%s%s%s\n", info, pm_verb(state.event), 258 ((state.event & PM_EVENT_SLEEP) && device_may_wakeup(dev)) ? 259 ", may wakeup" : ""); 260} 261 262static void pm_dev_err(struct device *dev, pm_message_t state, char *info, 263 int error) 264{ 265 printk(KERN_ERR "PM: Device %s failed to %s%s: error %d\n", 266 kobject_name(&dev->kobj), pm_verb(state.event), info, error); 267} 268 269/*------------------------- Resume routines -------------------------*/ 270 271/** 272 * resume_device_noirq - Power on one device (early resume). 273 * @dev: Device. 274 * @state: PM transition of the system being carried out. 275 * 276 * Must be called with interrupts disabled. 277 */ 278static int resume_device_noirq(struct device *dev, pm_message_t state) 279{ 280 int error = 0; 281 282 TRACE_DEVICE(dev); 283 TRACE_RESUME(0); 284 285 if (!dev->bus) 286 goto End; 287 288 if (dev->bus->pm) { 289 pm_dev_dbg(dev, state, "EARLY "); 290 error = pm_noirq_op(dev, dev->bus->pm, state); 291 } else if (dev->bus->resume_early) { 292 pm_dev_dbg(dev, state, "legacy EARLY "); 293 error = dev->bus->resume_early(dev); 294 } 295 End: 296 TRACE_RESUME(error); 297 return error; 298} 299 300/** 301 * dpm_power_up - Power on all regular (non-sysdev) devices. 302 * @state: PM transition of the system being carried out. 303 * 304 * Execute the appropriate "noirq resume" callback for all devices marked 305 * as DPM_OFF_IRQ. 306 * 307 * Must be called with interrupts disabled and only one CPU running. 308 */ 309static void dpm_power_up(pm_message_t state) 310{ 311 struct device *dev; 312 313 list_for_each_entry(dev, &dpm_list, power.entry) 314 if (dev->power.status > DPM_OFF) { 315 int error; 316 317 dev->power.status = DPM_OFF; 318 error = resume_device_noirq(dev, state); 319 if (error) 320 pm_dev_err(dev, state, " early", error); 321 } 322} 323 324/** 325 * device_power_up - Turn on all devices that need special attention. 326 * @state: PM transition of the system being carried out. 327 * 328 * Power on system devices, then devices that required we shut them down 329 * with interrupts disabled. 330 * 331 * Must be called with interrupts disabled. 332 */ 333void device_power_up(pm_message_t state) 334{ 335 sysdev_resume(); 336 dpm_power_up(state); 337} 338EXPORT_SYMBOL_GPL(device_power_up); 339 340/** 341 * resume_device - Restore state for one device. 342 * @dev: Device. 343 * @state: PM transition of the system being carried out. 344 */ 345static int resume_device(struct device *dev, pm_message_t state) 346{ 347 int error = 0; 348 349 TRACE_DEVICE(dev); 350 TRACE_RESUME(0); 351 352 down(&dev->sem); 353 354 if (dev->bus) { 355 if (dev->bus->pm) { 356 pm_dev_dbg(dev, state, ""); 357 error = pm_op(dev, &dev->bus->pm->base, state); 358 } else if (dev->bus->resume) { 359 pm_dev_dbg(dev, state, "legacy "); 360 error = dev->bus->resume(dev); 361 } 362 if (error) 363 goto End; 364 } 365 366 if (dev->type) { 367 if (dev->type->pm) { 368 pm_dev_dbg(dev, state, "type "); 369 error = pm_op(dev, dev->type->pm, state); 370 } else if (dev->type->resume) { 371 pm_dev_dbg(dev, state, "legacy type "); 372 error = dev->type->resume(dev); 373 } 374 if (error) 375 goto End; 376 } 377 378 if (dev->class) { 379 if (dev->class->pm) { 380 pm_dev_dbg(dev, state, "class "); 381 error = pm_op(dev, dev->class->pm, state); 382 } else if (dev->class->resume) { 383 pm_dev_dbg(dev, state, "legacy class "); 384 error = dev->class->resume(dev); 385 } 386 } 387 End: 388 up(&dev->sem); 389 390 TRACE_RESUME(error); 391 return error; 392} 393 394/** 395 * dpm_resume - Resume every device. 396 * @state: PM transition of the system being carried out. 397 * 398 * Execute the appropriate "resume" callback for all devices the status of 399 * which indicates that they are inactive. 400 */ 401static void dpm_resume(pm_message_t state) 402{ 403 struct list_head list; 404 405 INIT_LIST_HEAD(&list); 406 mutex_lock(&dpm_list_mtx); 407 transition_started = false; 408 while (!list_empty(&dpm_list)) { 409 struct device *dev = to_device(dpm_list.next); 410 411 get_device(dev); 412 if (dev->power.status >= DPM_OFF) { 413 int error; 414 415 dev->power.status = DPM_RESUMING; 416 mutex_unlock(&dpm_list_mtx); 417 418 error = resume_device(dev, state); 419 420 mutex_lock(&dpm_list_mtx); 421 if (error) 422 pm_dev_err(dev, state, "", error); 423 } else if (dev->power.status == DPM_SUSPENDING) { 424 /* Allow new children of the device to be registered */ 425 dev->power.status = DPM_RESUMING; 426 } 427 if (!list_empty(&dev->power.entry)) 428 list_move_tail(&dev->power.entry, &list); 429 put_device(dev); 430 } 431 list_splice(&list, &dpm_list); 432 mutex_unlock(&dpm_list_mtx); 433} 434 435/** 436 * complete_device - Complete a PM transition for given device 437 * @dev: Device. 438 * @state: PM transition of the system being carried out. 439 */ 440static void complete_device(struct device *dev, pm_message_t state) 441{ 442 down(&dev->sem); 443 444 if (dev->class && dev->class->pm && dev->class->pm->complete) { 445 pm_dev_dbg(dev, state, "completing class "); 446 dev->class->pm->complete(dev); 447 } 448 449 if (dev->type && dev->type->pm && dev->type->pm->complete) { 450 pm_dev_dbg(dev, state, "completing type "); 451 dev->type->pm->complete(dev); 452 } 453 454 if (dev->bus && dev->bus->pm && dev->bus->pm->base.complete) { 455 pm_dev_dbg(dev, state, "completing "); 456 dev->bus->pm->base.complete(dev); 457 } 458 459 up(&dev->sem); 460} 461 462/** 463 * dpm_complete - Complete a PM transition for all devices. 464 * @state: PM transition of the system being carried out. 465 * 466 * Execute the ->complete() callbacks for all devices that are not marked 467 * as DPM_ON. 468 */ 469static void dpm_complete(pm_message_t state) 470{ 471 struct list_head list; 472 473 INIT_LIST_HEAD(&list); 474 mutex_lock(&dpm_list_mtx); 475 while (!list_empty(&dpm_list)) { 476 struct device *dev = to_device(dpm_list.prev); 477 478 get_device(dev); 479 if (dev->power.status > DPM_ON) { 480 dev->power.status = DPM_ON; 481 mutex_unlock(&dpm_list_mtx); 482 483 complete_device(dev, state); 484 485 mutex_lock(&dpm_list_mtx); 486 } 487 if (!list_empty(&dev->power.entry)) 488 list_move(&dev->power.entry, &list); 489 put_device(dev); 490 } 491 list_splice(&list, &dpm_list); 492 mutex_unlock(&dpm_list_mtx); 493} 494 495/** 496 * device_resume - Restore state of each device in system. 497 * @state: PM transition of the system being carried out. 498 * 499 * Resume all the devices, unlock them all, and allow new 500 * devices to be registered once again. 501 */ 502void device_resume(pm_message_t state) 503{ 504 might_sleep(); 505 dpm_resume(state); 506 dpm_complete(state); 507} 508EXPORT_SYMBOL_GPL(device_resume); 509 510 511/*------------------------- Suspend routines -------------------------*/ 512 513/** 514 * resume_event - return a PM message representing the resume event 515 * corresponding to given sleep state. 516 * @sleep_state: PM message representing a sleep state. 517 */ 518static pm_message_t resume_event(pm_message_t sleep_state) 519{ 520 switch (sleep_state.event) { 521 case PM_EVENT_SUSPEND: 522 return PMSG_RESUME; 523 case PM_EVENT_FREEZE: 524 case PM_EVENT_QUIESCE: 525 return PMSG_RECOVER; 526 case PM_EVENT_HIBERNATE: 527 return PMSG_RESTORE; 528 } 529 return PMSG_ON; 530} 531 532/** 533 * suspend_device_noirq - Shut down one device (late suspend). 534 * @dev: Device. 535 * @state: PM transition of the system being carried out. 536 * 537 * This is called with interrupts off and only a single CPU running. 538 */ 539static int suspend_device_noirq(struct device *dev, pm_message_t state) 540{ 541 int error = 0; 542 543 if (!dev->bus) 544 return 0; 545 546 if (dev->bus->pm) { 547 pm_dev_dbg(dev, state, "LATE "); 548 error = pm_noirq_op(dev, dev->bus->pm, state); 549 } else if (dev->bus->suspend_late) { 550 pm_dev_dbg(dev, state, "legacy LATE "); 551 error = dev->bus->suspend_late(dev, state); 552 suspend_report_result(dev->bus->suspend_late, error); 553 } 554 return error; 555} 556 557/** 558 * device_power_down - Shut down special devices. 559 * @state: PM transition of the system being carried out. 560 * 561 * Power down devices that require interrupts to be disabled. 562 * Then power down system devices. 563 * 564 * Must be called with interrupts disabled and only one CPU running. 565 */ 566int device_power_down(pm_message_t state) 567{ 568 struct device *dev; 569 int error = 0; 570 571 list_for_each_entry_reverse(dev, &dpm_list, power.entry) { 572 error = suspend_device_noirq(dev, state); 573 if (error) { 574 pm_dev_err(dev, state, " late", error); 575 break; 576 } 577 dev->power.status = DPM_OFF_IRQ; 578 } 579 if (!error) 580 error = sysdev_suspend(state); 581 if (error) 582 dpm_power_up(resume_event(state)); 583 return error; 584} 585EXPORT_SYMBOL_GPL(device_power_down); 586 587/** 588 * suspend_device - Save state of one device. 589 * @dev: Device. 590 * @state: PM transition of the system being carried out. 591 */ 592static int suspend_device(struct device *dev, pm_message_t state) 593{ 594 int error = 0; 595 596 down(&dev->sem); 597 598 if (dev->class) { 599 if (dev->class->pm) { 600 pm_dev_dbg(dev, state, "class "); 601 error = pm_op(dev, dev->class->pm, state); 602 } else if (dev->class->suspend) { 603 pm_dev_dbg(dev, state, "legacy class "); 604 error = dev->class->suspend(dev, state); 605 suspend_report_result(dev->class->suspend, error); 606 } 607 if (error) 608 goto End; 609 } 610 611 if (dev->type) { 612 if (dev->type->pm) { 613 pm_dev_dbg(dev, state, "type "); 614 error = pm_op(dev, dev->type->pm, state); 615 } else if (dev->type->suspend) { 616 pm_dev_dbg(dev, state, "legacy type "); 617 error = dev->type->suspend(dev, state); 618 suspend_report_result(dev->type->suspend, error); 619 } 620 if (error) 621 goto End; 622 } 623 624 if (dev->bus) { 625 if (dev->bus->pm) { 626 pm_dev_dbg(dev, state, ""); 627 error = pm_op(dev, &dev->bus->pm->base, state); 628 } else if (dev->bus->suspend) { 629 pm_dev_dbg(dev, state, "legacy "); 630 error = dev->bus->suspend(dev, state); 631 suspend_report_result(dev->bus->suspend, error); 632 } 633 } 634 End: 635 up(&dev->sem); 636 637 return error; 638} 639 640/** 641 * dpm_suspend - Suspend every device. 642 * @state: PM transition of the system being carried out. 643 * 644 * Execute the appropriate "suspend" callbacks for all devices. 645 */ 646static int dpm_suspend(pm_message_t state) 647{ 648 struct list_head list; 649 int error = 0; 650 651 INIT_LIST_HEAD(&list); 652 mutex_lock(&dpm_list_mtx); 653 while (!list_empty(&dpm_list)) { 654 struct device *dev = to_device(dpm_list.prev); 655 656 get_device(dev); 657 mutex_unlock(&dpm_list_mtx); 658 659 error = suspend_device(dev, state); 660 661 mutex_lock(&dpm_list_mtx); 662 if (error) { 663 pm_dev_err(dev, state, "", error); 664 put_device(dev); 665 break; 666 } 667 dev->power.status = DPM_OFF; 668 if (!list_empty(&dev->power.entry)) 669 list_move(&dev->power.entry, &list); 670 put_device(dev); 671 } 672 list_splice(&list, dpm_list.prev); 673 mutex_unlock(&dpm_list_mtx); 674 return error; 675} 676 677/** 678 * prepare_device - Execute the ->prepare() callback(s) for given device. 679 * @dev: Device. 680 * @state: PM transition of the system being carried out. 681 */ 682static int prepare_device(struct device *dev, pm_message_t state) 683{ 684 int error = 0; 685 686 down(&dev->sem); 687 688 if (dev->bus && dev->bus->pm && dev->bus->pm->base.prepare) { 689 pm_dev_dbg(dev, state, "preparing "); 690 error = dev->bus->pm->base.prepare(dev); 691 suspend_report_result(dev->bus->pm->base.prepare, error); 692 if (error) 693 goto End; 694 } 695 696 if (dev->type && dev->type->pm && dev->type->pm->prepare) { 697 pm_dev_dbg(dev, state, "preparing type "); 698 error = dev->type->pm->prepare(dev); 699 suspend_report_result(dev->type->pm->prepare, error); 700 if (error) 701 goto End; 702 } 703 704 if (dev->class && dev->class->pm && dev->class->pm->prepare) { 705 pm_dev_dbg(dev, state, "preparing class "); 706 error = dev->class->pm->prepare(dev); 707 suspend_report_result(dev->class->pm->prepare, error); 708 } 709 End: 710 up(&dev->sem); 711 712 return error; 713} 714 715/** 716 * dpm_prepare - Prepare all devices for a PM transition. 717 * @state: PM transition of the system being carried out. 718 * 719 * Execute the ->prepare() callback for all devices. 720 */ 721static int dpm_prepare(pm_message_t state) 722{ 723 struct list_head list; 724 int error = 0; 725 726 INIT_LIST_HEAD(&list); 727 mutex_lock(&dpm_list_mtx); 728 transition_started = true; 729 while (!list_empty(&dpm_list)) { 730 struct device *dev = to_device(dpm_list.next); 731 732 get_device(dev); 733 dev->power.status = DPM_PREPARING; 734 mutex_unlock(&dpm_list_mtx); 735 736 error = prepare_device(dev, state); 737 738 mutex_lock(&dpm_list_mtx); 739 if (error) { 740 dev->power.status = DPM_ON; 741 if (error == -EAGAIN) { 742 put_device(dev); 743 continue; 744 } 745 printk(KERN_ERR "PM: Failed to prepare device %s " 746 "for power transition: error %d\n", 747 kobject_name(&dev->kobj), error); 748 put_device(dev); 749 break; 750 } 751 dev->power.status = DPM_SUSPENDING; 752 if (!list_empty(&dev->power.entry)) 753 list_move_tail(&dev->power.entry, &list); 754 put_device(dev); 755 } 756 list_splice(&list, &dpm_list); 757 mutex_unlock(&dpm_list_mtx); 758 return error; 759} 760 761/** 762 * device_suspend - Save state and stop all devices in system. 763 * @state: PM transition of the system being carried out. 764 * 765 * Prepare and suspend all devices. 766 */ 767int device_suspend(pm_message_t state) 768{ 769 int error; 770 771 might_sleep(); 772 error = dpm_prepare(state); 773 if (!error) 774 error = dpm_suspend(state); 775 return error; 776} 777EXPORT_SYMBOL_GPL(device_suspend); 778 779void __suspend_report_result(const char *function, void *fn, int ret) 780{ 781 if (ret) { 782 printk(KERN_ERR "%s(): ", function); 783 print_fn_descriptor_symbol("%s returns ", fn); 784 printk("%d\n", ret); 785 } 786} 787EXPORT_SYMBOL_GPL(__suspend_report_result); 788