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