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