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