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/interrupt.h>
  27 #include <linux/sched.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 static ktime_t initcall_debug_start(struct device *dev)
 165 {
 166         ktime_t calltime = ktime_set(0, 0);
 167
 168         if (initcall_debug) {
 169                 pr_info("calling  %s+ @ %i\n",
 170                                 dev_name(dev), task_pid_nr(current));
 171                 calltime = ktime_get();
 172         }
 173
 174         return calltime;
 175 }
 176
 177 static void initcall_debug_report(struct device *dev, ktime_t calltime,
 178                                   int error)
 179 {
 180         ktime_t delta, rettime;
 181
 182         if (initcall_debug) {
 183                 rettime = ktime_get();
 184                 delta = ktime_sub(rettime, calltime);
 185                 pr_info("call %s+ returned %d after %Ld usecs\n", dev_name(dev),
 186                         error, (unsigned long long)ktime_to_ns(delta) >> 10);
 187         }
 188 }
 189
 190 /**
 191  * pm_op - Execute the PM operation appropriate for given PM event.
 192  * @dev: Device to handle.
 193  * @ops: PM operations to choose from.
 194  * @state: PM transition of the system being carried out.
 195  */
 196 static int pm_op(struct device *dev,
 197                  const struct dev_pm_ops *ops,
 198                  pm_message_t state)
 199 {
 200         int error = 0;
 201         ktime_t calltime;
 202
 203         calltime = initcall_debug_start(dev);
 204
 205         switch (state.event) {
 206 #ifdef CONFIG_SUSPEND
 207         case PM_EVENT_SUSPEND:
 208                 if (ops->suspend) {
 209                         error = ops->suspend(dev);
 210                         suspend_report_result(ops->suspend, error);
 211                 }
 212                 break;
 213         case PM_EVENT_RESUME:
 214                 if (ops->resume) {
 215                         error = ops->resume(dev);
 216                         suspend_report_result(ops->resume, error);
 217                 }
 218                 break;
 219 #endif /* CONFIG_SUSPEND */
 220 #ifdef CONFIG_HIBERNATION
 221         case PM_EVENT_FREEZE:
 222         case PM_EVENT_QUIESCE:
 223                 if (ops->freeze) {
 224                         error = ops->freeze(dev);
 225                         suspend_report_result(ops->freeze, error);
 226                 }
 227                 break;
 228         case PM_EVENT_HIBERNATE:
 229                 if (ops->poweroff) {
 230                         error = ops->poweroff(dev);
 231                         suspend_report_result(ops->poweroff, error);
 232                 }
 233                 break;
 234         case PM_EVENT_THAW:
 235         case PM_EVENT_RECOVER:
 236                 if (ops->thaw) {
 237                         error = ops->thaw(dev);
 238                         suspend_report_result(ops->thaw, error);
 239                 }
 240                 break;
 241         case PM_EVENT_RESTORE:
 242                 if (ops->restore) {
 243                         error = ops->restore(dev);
 244                         suspend_report_result(ops->restore, error);
 245                 }
 246                 break;
 247 #endif /* CONFIG_HIBERNATION */
 248         default:
 249                 error = -EINVAL;
 250         }
 251
 252         initcall_debug_report(dev, calltime, error);
 253
 254         return error;
 255 }
 256
 257 /**
 258  * pm_noirq_op - Execute the PM operation appropriate for given PM event.
 259  * @dev: Device to handle.
 260  * @ops: PM operations to choose from.
 261  * @state: PM transition of the system being carried out.
 262  *
 263  * The driver of @dev will not receive interrupts while this function is being
 264  * executed.
 265  */
 266 static int pm_noirq_op(struct device *dev,
 267                         const struct dev_pm_ops *ops,
 268                         pm_message_t state)
 269 {
 270         int error = 0;
 271         ktime_t calltime, delta, rettime;
 272
 273         if (initcall_debug) {
 274                 pr_info("calling  %s_i+ @ %i\n",
 275                                 dev_name(dev), task_pid_nr(current));
 276                 calltime = ktime_get();
 277         }
 278
 279         switch (state.event) {
 280 #ifdef CONFIG_SUSPEND
 281         case PM_EVENT_SUSPEND:
 282                 if (ops->suspend_noirq) {
 283                         error = ops->suspend_noirq(dev);
 284                         suspend_report_result(ops->suspend_noirq, error);
 285                 }
 286                 break;
 287         case PM_EVENT_RESUME:
 288                 if (ops->resume_noirq) {
 289                         error = ops->resume_noirq(dev);
 290                         suspend_report_result(ops->resume_noirq, error);
 291                 }
 292                 break;
 293 #endif /* CONFIG_SUSPEND */
 294 #ifdef CONFIG_HIBERNATION
 295         case PM_EVENT_FREEZE:
 296         case PM_EVENT_QUIESCE:
 297                 if (ops->freeze_noirq) {
 298                         error = ops->freeze_noirq(dev);
 299                         suspend_report_result(ops->freeze_noirq, error);
 300                 }
 301                 break;
 302         case PM_EVENT_HIBERNATE:
 303                 if (ops->poweroff_noirq) {
 304                         error = ops->poweroff_noirq(dev);
 305                         suspend_report_result(ops->poweroff_noirq, error);
 306                 }
 307                 break;
 308         case PM_EVENT_THAW:
 309         case PM_EVENT_RECOVER:
 310                 if (ops->thaw_noirq) {
 311                         error = ops->thaw_noirq(dev);
 312                         suspend_report_result(ops->thaw_noirq, error);
 313                 }
 314                 break;
 315         case PM_EVENT_RESTORE:
 316                 if (ops->restore_noirq) {
 317                         error = ops->restore_noirq(dev);
 318                         suspend_report_result(ops->restore_noirq, error);
 319                 }
 320                 break;
 321 #endif /* CONFIG_HIBERNATION */
 322         default:
 323                 error = -EINVAL;
 324         }
 325
 326         if (initcall_debug) {
 327                 rettime = ktime_get();
 328                 delta = ktime_sub(rettime, calltime);
 329                 printk("initcall %s_i+ returned %d after %Ld usecs\n",
 330                         dev_name(dev), error,
 331                         (unsigned long long)ktime_to_ns(delta) >> 10);
 332         }
 333
 334         return error;
 335 }
 336
 337 static char *pm_verb(int event)
 338 {
 339         switch (event) {
 340         case PM_EVENT_SUSPEND:
 341                 return "suspend";
 342         case PM_EVENT_RESUME:
 343                 return "resume";
 344         case PM_EVENT_FREEZE:
 345                 return "freeze";
 346         case PM_EVENT_QUIESCE:
 347                 return "quiesce";
 348         case PM_EVENT_HIBERNATE:
 349                 return "hibernate";
 350         case PM_EVENT_THAW:
 351                 return "thaw";
 352         case PM_EVENT_RESTORE:
 353                 return "restore";
 354         case PM_EVENT_RECOVER:
 355                 return "recover";
 356         default:
 357                 return "(unknown PM event)";
 358         }
 359 }
 360
 361 static void pm_dev_dbg(struct device *dev, pm_message_t state, char *info)
 362 {
 363         dev_dbg(dev, "%s%s%s\n", info, pm_verb(state.event),
 364                 ((state.event & PM_EVENT_SLEEP) && device_may_wakeup(dev)) ?
 365                 ", may wakeup" : "");
 366 }
 367
 368 static void pm_dev_err(struct device *dev, pm_message_t state, char *info,
 369                         int error)
 370 {
 371         printk(KERN_ERR "PM: Device %s failed to %s%s: error %d\n",
 372                 kobject_name(&dev->kobj), pm_verb(state.event), info, error);
 373 }
 374
 375 static void dpm_show_time(ktime_t starttime, pm_message_t state, char *info)
 376 {
 377         ktime_t calltime;
 378         s64 usecs64;
 379         int usecs;
 380
 381         calltime = ktime_get();
 382         usecs64 = ktime_to_ns(ktime_sub(calltime, starttime));
 383         do_div(usecs64, NSEC_PER_USEC);
 384         usecs = usecs64;
 385         if (usecs == 0)
 386                 usecs = 1;
 387         pr_info("PM: %s%s%s of devices complete after %ld.%03ld msecs\n",
 388                 info ?: "", info ? " " : "", pm_verb(state.event),
 389                 usecs / USEC_PER_MSEC, usecs % USEC_PER_MSEC);
 390 }
 391
 392 /*------------------------- Resume routines -------------------------*/
 393
 394 /**
 395  * device_resume_noirq - Execute an "early resume" callback for given device.
 396  * @dev: Device to handle.
 397  * @state: PM transition of the system being carried out.
 398  *
 399  * The driver of @dev will not receive interrupts while this function is being
 400  * executed.
 401  */
 402 static int device_resume_noirq(struct device *dev, pm_message_t state)
 403 {
 404         int error = 0;
 405
 406         TRACE_DEVICE(dev);
 407         TRACE_RESUME(0);
 408
 409         if (dev->bus && dev->bus->pm) {
 410                 pm_dev_dbg(dev, state, "EARLY ");
 411                 error = pm_noirq_op(dev, dev->bus->pm, state);
 412         }
 413
 414         TRACE_RESUME(error);
 415         return error;
 416 }
 417
 418 /**
 419  * dpm_resume_noirq - Execute "early resume" callbacks for non-sysdev devices.
 420  * @state: PM transition of the system being carried out.
 421  *
 422  * Call the "noirq" resume handlers for all devices marked as DPM_OFF_IRQ and
 423  * enable device drivers to receive interrupts.
 424  */
 425 void dpm_resume_noirq(pm_message_t state)
 426 {
 427         struct device *dev;
 428         ktime_t starttime = ktime_get();
 429
 430         mutex_lock(&dpm_list_mtx);
 431         transition_started = false;
 432         list_for_each_entry(dev, &dpm_list, power.entry)
 433                 if (dev->power.status > DPM_OFF) {
 434                         int error;
 435
 436                         dev->power.status = DPM_OFF;
 437                         error = device_resume_noirq(dev, state);
 438                         if (error)
 439                                 pm_dev_err(dev, state, " early", error);
 440                 }
 441         mutex_unlock(&dpm_list_mtx);
 442         dpm_show_time(starttime, state, "early");
 443         resume_device_irqs();
 444 }
 445 EXPORT_SYMBOL_GPL(dpm_resume_noirq);
 446
 447 /**
 448  * legacy_resume - Execute a legacy (bus or class) resume callback for device.
 449  * @dev: Device to resume.
 450  * @cb: Resume callback to execute.
 451  */
 452 static int legacy_resume(struct device *dev, int (*cb)(struct device *dev))
 453 {
 454         int error;
 455         ktime_t calltime;
 456
 457         calltime = initcall_debug_start(dev);
 458
 459         error = cb(dev);
 460         suspend_report_result(cb, error);
 461
 462         initcall_debug_report(dev, calltime, error);
 463
 464         return error;
 465 }
 466
 467 /**
 468  * device_resume - Execute "resume" callbacks for given device.
 469  * @dev: Device to handle.
 470  * @state: PM transition of the system being carried out.
 471  */
 472 static int device_resume(struct device *dev, pm_message_t state)
 473 {
 474         int error = 0;
 475
 476         TRACE_DEVICE(dev);
 477         TRACE_RESUME(0);
 478
 479         down(&dev->sem);
 480
 481         if (dev->bus) {
 482                 if (dev->bus->pm) {
 483                         pm_dev_dbg(dev, state, "");
 484                         error = pm_op(dev, dev->bus->pm, state);
 485                 } else if (dev->bus->resume) {
 486                         pm_dev_dbg(dev, state, "legacy ");
 487                         error = legacy_resume(dev, dev->bus->resume);
 488                 }
 489                 if (error)
 490                         goto End;
 491         }
 492
 493         if (dev->type) {
 494                 if (dev->type->pm) {
 495                         pm_dev_dbg(dev, state, "type ");
 496                         error = pm_op(dev, dev->type->pm, state);
 497                 }
 498                 if (error)
 499                         goto End;
 500         }
 501
 502         if (dev->class) {
 503                 if (dev->class->pm) {
 504                         pm_dev_dbg(dev, state, "class ");
 505                         error = pm_op(dev, dev->class->pm, state);
 506                 } else if (dev->class->resume) {
 507                         pm_dev_dbg(dev, state, "legacy class ");
 508                         error = legacy_resume(dev, dev->class->resume);
 509                 }
 510         }
 511  End:
 512         up(&dev->sem);
 513
 514         TRACE_RESUME(error);
 515         return error;
 516 }
 517
 518 /**
 519  * dpm_resume - Execute "resume" callbacks for non-sysdev devices.
 520  * @state: PM transition of the system being carried out.
 521  *
 522  * Execute the appropriate "resume" callback for all devices whose status
 523  * indicates that they are suspended.
 524  */
 525 static void dpm_resume(pm_message_t state)
 526 {
 527         struct list_head list;
 528         ktime_t starttime = ktime_get();
 529
 530         INIT_LIST_HEAD(&list);
 531         mutex_lock(&dpm_list_mtx);
 532         while (!list_empty(&dpm_list)) {
 533                 struct device *dev = to_device(dpm_list.next);
 534
 535                 get_device(dev);
 536                 if (dev->power.status >= DPM_OFF) {
 537                         int error;
 538
 539                         dev->power.status = DPM_RESUMING;
 540                         mutex_unlock(&dpm_list_mtx);
 541
 542                         error = device_resume(dev, state);
 543
 544                         mutex_lock(&dpm_list_mtx);
 545                         if (error)
 546                                 pm_dev_err(dev, state, "", error);
 547                 } else if (dev->power.status == DPM_SUSPENDING) {
 548                         /* Allow new children of the device to be registered */
 549                         dev->power.status = DPM_RESUMING;
 550                 }
 551                 if (!list_empty(&dev->power.entry))
 552                         list_move_tail(&dev->power.entry, &list);
 553                 put_device(dev);
 554         }
 555         list_splice(&list, &dpm_list);
 556         mutex_unlock(&dpm_list_mtx);
 557         dpm_show_time(starttime, state, NULL);
 558 }
 559
 560 /**
 561  * device_complete - Complete a PM transition for given device.
 562  * @dev: Device to handle.
 563  * @state: PM transition of the system being carried out.
 564  */
 565 static void device_complete(struct device *dev, pm_message_t state)
 566 {
 567         down(&dev->sem);
 568
 569         if (dev->class && dev->class->pm && dev->class->pm->complete) {
 570                 pm_dev_dbg(dev, state, "completing class ");
 571                 dev->class->pm->complete(dev);
 572         }
 573
 574         if (dev->type && dev->type->pm && dev->type->pm->complete) {
 575                 pm_dev_dbg(dev, state, "completing type ");
 576                 dev->type->pm->complete(dev);
 577         }
 578
 579         if (dev->bus && dev->bus->pm && dev->bus->pm->complete) {
 580                 pm_dev_dbg(dev, state, "completing ");
 581                 dev->bus->pm->complete(dev);
 582         }
 583
 584         up(&dev->sem);
 585 }
 586
 587 /**
 588  * dpm_complete - Complete a PM transition for all non-sysdev devices.
 589  * @state: PM transition of the system being carried out.
 590  *
 591  * Execute the ->complete() callbacks for all devices whose PM status is not
 592  * DPM_ON (this allows new devices to be registered).
 593  */
 594 static void dpm_complete(pm_message_t state)
 595 {
 596         struct list_head list;
 597
 598         INIT_LIST_HEAD(&list);
 599         mutex_lock(&dpm_list_mtx);
 600         transition_started = false;
 601         while (!list_empty(&dpm_list)) {
 602                 struct device *dev = to_device(dpm_list.prev);
 603
 604                 get_device(dev);
 605                 if (dev->power.status > DPM_ON) {
 606                         dev->power.status = DPM_ON;
 607                         mutex_unlock(&dpm_list_mtx);
 608
 609                         device_complete(dev, state);
 610                         pm_runtime_put_sync(dev);
 611
 612                         mutex_lock(&dpm_list_mtx);
 613                 }
 614                 if (!list_empty(&dev->power.entry))
 615                         list_move(&dev->power.entry, &list);
 616                 put_device(dev);
 617         }
 618         list_splice(&list, &dpm_list);
 619         mutex_unlock(&dpm_list_mtx);
 620 }
 621
 622 /**
 623  * dpm_resume_end - Execute "resume" callbacks and complete system transition.
 624  * @state: PM transition of the system being carried out.
 625  *
 626  * Execute "resume" callbacks for all devices and complete the PM transition of
 627  * the system.
 628  */
 629 void dpm_resume_end(pm_message_t state)
 630 {
 631         might_sleep();
 632         dpm_resume(state);
 633         dpm_complete(state);
 634 }
 635 EXPORT_SYMBOL_GPL(dpm_resume_end);
 636
 637
 638 /*------------------------- Suspend routines -------------------------*/
 639
 640 /**
 641  * resume_event - Return a "resume" message for given "suspend" sleep state.
 642  * @sleep_state: PM message representing a sleep state.
 643  *
 644  * Return a PM message representing the resume event corresponding to given
 645  * sleep state.
 646  */
 647 static pm_message_t resume_event(pm_message_t sleep_state)
 648 {
 649         switch (sleep_state.event) {
 650         case PM_EVENT_SUSPEND:
 651                 return PMSG_RESUME;
 652         case PM_EVENT_FREEZE:
 653         case PM_EVENT_QUIESCE:
 654                 return PMSG_RECOVER;
 655         case PM_EVENT_HIBERNATE:
 656                 return PMSG_RESTORE;
 657         }
 658         return PMSG_ON;
 659 }
 660
 661 /**
 662  * device_suspend_noirq - Execute a "late suspend" callback for given device.
 663  * @dev: Device to handle.
 664  * @state: PM transition of the system being carried out.
 665  *
 666  * The driver of @dev will not receive interrupts while this function is being
 667  * executed.
 668  */
 669 static int device_suspend_noirq(struct device *dev, pm_message_t state)
 670 {
 671         int error = 0;
 672
 673         if (dev->bus && dev->bus->pm) {
 674                 pm_dev_dbg(dev, state, "LATE ");
 675                 error = pm_noirq_op(dev, dev->bus->pm, state);
 676         }
 677         return error;
 678 }
 679
 680 /**
 681  * dpm_suspend_noirq - Execute "late suspend" callbacks for non-sysdev devices.
 682  * @state: PM transition of the system being carried out.
 683  *
 684  * Prevent device drivers from receiving interrupts and call the "noirq" suspend
 685  * handlers for all non-sysdev devices.
 686  */
 687 int dpm_suspend_noirq(pm_message_t state)
 688 {
 689         struct device *dev;
 690         ktime_t starttime = ktime_get();
 691         int error = 0;
 692
 693         suspend_device_irqs();
 694         mutex_lock(&dpm_list_mtx);
 695         list_for_each_entry_reverse(dev, &dpm_list, power.entry) {
 696                 error = device_suspend_noirq(dev, state);
 697                 if (error) {
 698                         pm_dev_err(dev, state, " late", error);
 699                         break;
 700                 }
 701                 dev->power.status = DPM_OFF_IRQ;
 702         }
 703         mutex_unlock(&dpm_list_mtx);
 704         if (error)
 705                 dpm_resume_noirq(resume_event(state));
 706         else
 707                 dpm_show_time(starttime, state, "late");
 708         return error;
 709 }
 710 EXPORT_SYMBOL_GPL(dpm_suspend_noirq);
 711
 712 /**
 713  * legacy_suspend - Execute a legacy (bus or class) suspend callback for device.
 714  * @dev: Device to suspend.
 715  * @state: PM transition of the system being carried out.
 716  * @cb: Suspend callback to execute.
 717  */
 718 static int legacy_suspend(struct device *dev, pm_message_t state,
 719                           int (*cb)(struct device *dev, pm_message_t state))
 720 {
 721         int error;
 722         ktime_t calltime;
 723
 724         calltime = initcall_debug_start(dev);
 725
 726         error = cb(dev, state);
 727         suspend_report_result(cb, error);
 728
 729         initcall_debug_report(dev, calltime, error);
 730
 731         return error;
 732 }
 733
 734 /**
 735  * device_suspend - Execute "suspend" callbacks for given device.
 736  * @dev: Device to handle.
 737  * @state: PM transition of the system being carried out.
 738  */
 739 static int device_suspend(struct device *dev, pm_message_t state)
 740 {
 741         int error = 0;
 742
 743         down(&dev->sem);
 744
 745         if (dev->class) {
 746                 if (dev->class->pm) {
 747                         pm_dev_dbg(dev, state, "class ");
 748                         error = pm_op(dev, dev->class->pm, state);
 749                 } else if (dev->class->suspend) {
 750                         pm_dev_dbg(dev, state, "legacy class ");
 751                         error = legacy_suspend(dev, state, dev->class->suspend);
 752                 }
 753                 if (error)
 754                         goto End;
 755         }
 756
 757         if (dev->type) {
 758                 if (dev->type->pm) {
 759                         pm_dev_dbg(dev, state, "type ");
 760                         error = pm_op(dev, dev->type->pm, state);
 761                 }
 762                 if (error)
 763                         goto End;
 764         }
 765
 766         if (dev->bus) {
 767                 if (dev->bus->pm) {
 768                         pm_dev_dbg(dev, state, "");
 769                         error = pm_op(dev, dev->bus->pm, state);
 770                 } else if (dev->bus->suspend) {
 771                         pm_dev_dbg(dev, state, "legacy ");
 772                         error = legacy_suspend(dev, state, dev->bus->suspend);
 773                 }
 774         }
 775  End:
 776         up(&dev->sem);
 777
 778         return error;
 779 }
 780
 781 /**
 782  * dpm_suspend - Execute "suspend" callbacks for all non-sysdev devices.
 783  * @state: PM transition of the system being carried out.
 784  */
 785 static int dpm_suspend(pm_message_t state)
 786 {
 787         struct list_head list;
 788         ktime_t starttime = ktime_get();
 789         int error = 0;
 790
 791         INIT_LIST_HEAD(&list);
 792         mutex_lock(&dpm_list_mtx);
 793         while (!list_empty(&dpm_list)) {
 794                 struct device *dev = to_device(dpm_list.prev);
 795
 796                 get_device(dev);
 797                 mutex_unlock(&dpm_list_mtx);
 798
 799                 error = device_suspend(dev, state);
 800
 801                 mutex_lock(&dpm_list_mtx);
 802                 if (error) {
 803                         pm_dev_err(dev, state, "", error);
 804                         put_device(dev);
 805                         break;
 806                 }
 807                 dev->power.status = DPM_OFF;
 808                 if (!list_empty(&dev->power.entry))
 809                         list_move(&dev->power.entry, &list);
 810                 put_device(dev);
 811         }
 812         list_splice(&list, dpm_list.prev);
 813         mutex_unlock(&dpm_list_mtx);
 814         if (!error)
 815                 dpm_show_time(starttime, state, NULL);
 816         return error;
 817 }
 818
 819 /**
 820  * device_prepare - Prepare a device for system power transition.
 821  * @dev: Device to handle.
 822  * @state: PM transition of the system being carried out.
 823  *
 824  * Execute the ->prepare() callback(s) for given device.  No new children of the
 825  * device may be registered after this function has returned.
 826  */
 827 static int device_prepare(struct device *dev, pm_message_t state)
 828 {
 829         int error = 0;
 830
 831         down(&dev->sem);
 832
 833         if (dev->bus && dev->bus->pm && dev->bus->pm->prepare) {
 834                 pm_dev_dbg(dev, state, "preparing ");
 835                 error = dev->bus->pm->prepare(dev);
 836                 suspend_report_result(dev->bus->pm->prepare, error);
 837                 if (error)
 838                         goto End;
 839         }
 840
 841         if (dev->type && dev->type->pm && dev->type->pm->prepare) {
 842                 pm_dev_dbg(dev, state, "preparing type ");
 843                 error = dev->type->pm->prepare(dev);
 844                 suspend_report_result(dev->type->pm->prepare, error);
 845                 if (error)
 846                         goto End;
 847         }
 848
 849         if (dev->class && dev->class->pm && dev->class->pm->prepare) {
 850                 pm_dev_dbg(dev, state, "preparing class ");
 851                 error = dev->class->pm->prepare(dev);
 852                 suspend_report_result(dev->class->pm->prepare, error);
 853         }
 854  End:
 855         up(&dev->sem);
 856
 857         return error;
 858 }
 859
 860 /**
 861  * dpm_prepare - Prepare all non-sysdev devices for a system PM transition.
 862  * @state: PM transition of the system being carried out.
 863  *
 864  * Execute the ->prepare() callback(s) for all devices.
 865  */
 866 static int dpm_prepare(pm_message_t state)
 867 {
 868         struct list_head list;
 869         int error = 0;
 870
 871         INIT_LIST_HEAD(&list);
 872         mutex_lock(&dpm_list_mtx);
 873         transition_started = true;
 874         while (!list_empty(&dpm_list)) {
 875                 struct device *dev = to_device(dpm_list.next);
 876
 877                 get_device(dev);
 878                 dev->power.status = DPM_PREPARING;
 879                 mutex_unlock(&dpm_list_mtx);
 880
 881                 pm_runtime_get_noresume(dev);
 882                 if (pm_runtime_barrier(dev) && device_may_wakeup(dev)) {
 883                         /* Wake-up requested during system sleep transition. */
 884                         pm_runtime_put_sync(dev);
 885                         error = -EBUSY;
 886                 } else {
 887                         error = device_prepare(dev, state);
 888                 }
 889
 890                 mutex_lock(&dpm_list_mtx);
 891                 if (error) {
 892                         dev->power.status = DPM_ON;
 893                         if (error == -EAGAIN) {
 894                                 put_device(dev);
 895                                 error = 0;
 896                                 continue;
 897                         }
 898                         printk(KERN_ERR "PM: Failed to prepare device %s "
 899                                 "for power transition: error %d\n",
 900                                 kobject_name(&dev->kobj), error);
 901                         put_device(dev);
 902                         break;
 903                 }
 904                 dev->power.status = DPM_SUSPENDING;
 905                 if (!list_empty(&dev->power.entry))
 906                         list_move_tail(&dev->power.entry, &list);
 907                 put_device(dev);
 908         }
 909         list_splice(&list, &dpm_list);
 910         mutex_unlock(&dpm_list_mtx);
 911         return error;
 912 }
 913
 914 /**
 915  * dpm_suspend_start - Prepare devices for PM transition and suspend them.
 916  * @state: PM transition of the system being carried out.
 917  *
 918  * Prepare all non-sysdev devices for system PM transition and execute "suspend"
 919  * callbacks for them.
 920  */
 921 int dpm_suspend_start(pm_message_t state)
 922 {
 923         int error;
 924
 925         might_sleep();
 926         error = dpm_prepare(state);
 927         if (!error)
 928                 error = dpm_suspend(state);
 929         return error;
 930 }
 931 EXPORT_SYMBOL_GPL(dpm_suspend_start);
 932
 933 void __suspend_report_result(const char *function, void *fn, int ret)
 934 {
 935         if (ret)
 936                 printk(KERN_ERR "%s(): %pF returns %d\n", function, fn, ret);
 937 }
 938 EXPORT_SYMBOL_GPL(__suspend_report_result);