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