drivers/base/power/main.c

   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
  42 LIST_HEAD(dpm_list);
  43
  44 static 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  */
  50 static 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  */
  56 void 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  */
  65 void 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  */
  73 void 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  */
  82 void 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  */
 109 void 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  */
 125 void 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  */
 141 void 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  */
 156 void 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  */
 170 static 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  */
 234 static 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
 289 static 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
 313 static 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
 320 static 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  */
 337 static 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  */
 363 void 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 }
 381 EXPORT_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  */
 388 static 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  */
 441 static 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  */
 479 static 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  */
 508 static 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  */
 543 void dpm_resume_end(pm_message_t state)
 544 {
 545         might_sleep();
 546         dpm_resume(state);
 547         dpm_complete(state);
 548 }
 549 EXPORT_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  */
 561 static 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  */
 583 static 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  */
 604 int 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 }
 624 EXPORT_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  */
 631 static 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  */
 679 static 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  */
 718 static 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  */
 757 static 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  */
 812 int 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 }
 822 EXPORT_SYMBOL_GPL(dpm_suspend_start);
 823
 824 void __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 }
 829 EXPORT_SYMBOL_GPL(__suspend_report_result);