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