drivers/base/power/runtime.c

   1 /*
   2  * drivers/base/power/runtime.c - Helper functions for device runtime PM
   3  *
   4  * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
   5  * Copyright (C) 2010 Alan Stern <stern@rowland.harvard.edu>
   6  *
   7  * This file is released under the GPLv2.
   8  */
   9
  10 #include <linux/sched.h>
  11 #include <linux/pm_runtime.h>
  12 #include <trace/events/rpm.h>
  13 #include "power.h"
  14
  15 static int rpm_resume(struct device *dev, int rpmflags);
  16 static int rpm_suspend(struct device *dev, int rpmflags);
  17
  18 /**
  19  * update_pm_runtime_accounting - Update the time accounting of power states
  20  * @dev: Device to update the accounting for
  21  *
  22  * In order to be able to have time accounting of the various power states
  23  * (as used by programs such as PowerTOP to show the effectiveness of runtime
  24  * PM), we need to track the time spent in each state.
  25  * update_pm_runtime_accounting must be called each time before the
  26  * runtime_status field is updated, to account the time in the old state
  27  * correctly.
  28  */
  29 void update_pm_runtime_accounting(struct device *dev)
  30 {
  31         unsigned long now = jiffies;
  32         int delta;
  33
  34         delta = now - dev->power.accounting_timestamp;
  35
  36         if (delta < 0)
  37                 delta = 0;
  38
  39         dev->power.accounting_timestamp = now;
  40
  41         if (dev->power.disable_depth > 0)
  42                 return;
  43
  44         if (dev->power.runtime_status == RPM_SUSPENDED)
  45                 dev->power.suspended_jiffies += delta;
  46         else
  47                 dev->power.active_jiffies += delta;
  48 }
  49
  50 static void __update_runtime_status(struct device *dev, enum rpm_status status)
  51 {
  52         update_pm_runtime_accounting(dev);
  53         dev->power.runtime_status = status;
  54 }
  55
  56 /**
  57  * pm_runtime_deactivate_timer - Deactivate given device's suspend timer.
  58  * @dev: Device to handle.
  59  */
  60 static void pm_runtime_deactivate_timer(struct device *dev)
  61 {
  62         if (dev->power.timer_expires > 0) {
  63                 del_timer(&dev->power.suspend_timer);
  64                 dev->power.timer_expires = 0;
  65         }
  66 }
  67
  68 /**
  69  * pm_runtime_cancel_pending - Deactivate suspend timer and cancel requests.
  70  * @dev: Device to handle.
  71  */
  72 static void pm_runtime_cancel_pending(struct device *dev)
  73 {
  74         pm_runtime_deactivate_timer(dev);
  75         /*
  76          * In case there's a request pending, make sure its work function will
  77          * return without doing anything.
  78          */
  79         dev->power.request = RPM_REQ_NONE;
  80 }
  81
  82 /*
  83  * pm_runtime_autosuspend_expiration - Get a device's autosuspend-delay expiration time.
  84  * @dev: Device to handle.
  85  *
  86  * Compute the autosuspend-delay expiration time based on the device's
  87  * power.last_busy time.  If the delay has already expired or is disabled
  88  * (negative) or the power.use_autosuspend flag isn't set, return 0.
  89  * Otherwise return the expiration time in jiffies (adjusted to be nonzero).
  90  *
  91  * This function may be called either with or without dev->power.lock held.
  92  * Either way it can be racy, since power.last_busy may be updated at any time.
  93  */
  94 unsigned long pm_runtime_autosuspend_expiration(struct device *dev)
  95 {
  96         int autosuspend_delay;
  97         long elapsed;
  98         unsigned long last_busy;
  99         unsigned long expires = 0;
 100
 101         if (!dev->power.use_autosuspend)
 102                 goto out;
 103
 104         autosuspend_delay = ACCESS_ONCE(dev->power.autosuspend_delay);
 105         if (autosuspend_delay < 0)
 106                 goto out;
 107
 108         last_busy = ACCESS_ONCE(dev->power.last_busy);
 109         elapsed = jiffies - last_busy;
 110         if (elapsed < 0)
 111                 goto out;       /* jiffies has wrapped around. */
 112
 113         /*
 114          * If the autosuspend_delay is >= 1 second, align the timer by rounding
 115          * up to the nearest second.
 116          */
 117         expires = last_busy + msecs_to_jiffies(autosuspend_delay);
 118         if (autosuspend_delay >= 1000)
 119                 expires = round_jiffies(expires);
 120         expires += !expires;
 121         if (elapsed >= expires - last_busy)
 122                 expires = 0;    /* Already expired. */
 123
 124  out:
 125         return expires;
 126 }
 127 EXPORT_SYMBOL_GPL(pm_runtime_autosuspend_expiration);
 128
 129 /**
 130  * rpm_check_suspend_allowed - Test whether a device may be suspended.
 131  * @dev: Device to test.
 132  */
 133 static int rpm_check_suspend_allowed(struct device *dev)
 134 {
 135         int retval = 0;
 136
 137         if (dev->power.runtime_error)
 138                 retval = -EINVAL;
 139         else if (dev->power.disable_depth > 0)
 140                 retval = -EACCES;
 141         else if (atomic_read(&dev->power.usage_count) > 0)
 142                 retval = -EAGAIN;
 143         else if (!pm_children_suspended(dev))
 144                 retval = -EBUSY;
 145
 146         /* Pending resume requests take precedence over suspends. */
 147         else if ((dev->power.deferred_resume
 148                         && dev->power.runtime_status == RPM_SUSPENDING)
 149             || (dev->power.request_pending
 150                         && dev->power.request == RPM_REQ_RESUME))
 151                 retval = -EAGAIN;
 152         else if (dev->power.runtime_status == RPM_SUSPENDED)
 153                 retval = 1;
 154
 155         return retval;
 156 }
 157
 158 /**
 159  * __rpm_callback - Run a given runtime PM callback for a given device.
 160  * @cb: Runtime PM callback to run.
 161  * @dev: Device to run the callback for.
 162  */
 163 static int __rpm_callback(int (*cb)(struct device *), struct device *dev)
 164         __releases(&dev->power.lock) __acquires(&dev->power.lock)
 165 {
 166         int retval;
 167
 168         if (dev->power.irq_safe)
 169                 spin_unlock(&dev->power.lock);
 170         else
 171                 spin_unlock_irq(&dev->power.lock);
 172
 173         retval = cb(dev);
 174
 175         if (dev->power.irq_safe)
 176                 spin_lock(&dev->power.lock);
 177         else
 178                 spin_lock_irq(&dev->power.lock);
 179
 180         return retval;
 181 }
 182
 183 /**
 184  * rpm_idle - Notify device bus type if the device can be suspended.
 185  * @dev: Device to notify the bus type about.
 186  * @rpmflags: Flag bits.
 187  *
 188  * Check if the device's runtime PM status allows it to be suspended.  If
 189  * another idle notification has been started earlier, return immediately.  If
 190  * the RPM_ASYNC flag is set then queue an idle-notification request; otherwise
 191  * run the ->runtime_idle() callback directly.
 192  *
 193  * This function must be called under dev->power.lock with interrupts disabled.
 194  */
 195 static int rpm_idle(struct device *dev, int rpmflags)
 196 {
 197         int (*callback)(struct device *);
 198         int retval;
 199
 200         trace_rpm_idle(dev, rpmflags);
 201         retval = rpm_check_suspend_allowed(dev);
 202         if (retval < 0)
 203                 ;       /* Conditions are wrong. */
 204
 205         /* Idle notifications are allowed only in the RPM_ACTIVE state. */
 206         else if (dev->power.runtime_status != RPM_ACTIVE)
 207                 retval = -EAGAIN;
 208
 209         /*
 210          * Any pending request other than an idle notification takes
 211          * precedence over us, except that the timer may be running.
 212          */
 213         else if (dev->power.request_pending &&
 214             dev->power.request > RPM_REQ_IDLE)
 215                 retval = -EAGAIN;
 216
 217         /* Act as though RPM_NOWAIT is always set. */
 218         else if (dev->power.idle_notification)
 219                 retval = -EINPROGRESS;
 220         if (retval)
 221                 goto out;
 222
 223         /* Pending requests need to be canceled. */
 224         dev->power.request = RPM_REQ_NONE;
 225
 226         if (dev->power.no_callbacks) {
 227                 /* Assume ->runtime_idle() callback would have suspended. */
 228                 retval = rpm_suspend(dev, rpmflags);
 229                 goto out;
 230         }
 231
 232         /* Carry out an asynchronous or a synchronous idle notification. */
 233         if (rpmflags & RPM_ASYNC) {
 234                 dev->power.request = RPM_REQ_IDLE;
 235                 if (!dev->power.request_pending) {
 236                         dev->power.request_pending = true;
 237                         queue_work(pm_wq, &dev->power.work);
 238                 }
 239                 goto out;
 240         }
 241
 242         dev->power.idle_notification = true;
 243
 244         if (dev->pm_domain)
 245                 callback = dev->pm_domain->ops.runtime_idle;
 246         else if (dev->type && dev->type->pm)
 247                 callback = dev->type->pm->runtime_idle;
 248         else if (dev->class && dev->class->pm)
 249                 callback = dev->class->pm->runtime_idle;
 250         else if (dev->bus && dev->bus->pm)
 251                 callback = dev->bus->pm->runtime_idle;
 252         else
 253                 callback = NULL;
 254
 255         if (callback)
 256                 __rpm_callback(callback, dev);
 257
 258         dev->power.idle_notification = false;
 259         wake_up_all(&dev->power.wait_queue);
 260
 261  out:
 262         trace_rpm_return_int(dev, _THIS_IP_, retval);
 263         return retval;
 264 }
 265
 266 /**
 267  * rpm_callback - Run a given runtime PM callback for a given device.
 268  * @cb: Runtime PM callback to run.
 269  * @dev: Device to run the callback for.
 270  */
 271 static int rpm_callback(int (*cb)(struct device *), struct device *dev)
 272 {
 273         int retval;
 274
 275         if (!cb)
 276                 return -ENOSYS;
 277
 278         retval = __rpm_callback(cb, dev);
 279
 280         dev->power.runtime_error = retval;
 281         return retval != -EACCES ? retval : -EIO;
 282 }
 283
 284 /**
 285  * rpm_suspend - Carry out runtime suspend of given device.
 286  * @dev: Device to suspend.
 287  * @rpmflags: Flag bits.
 288  *
 289  * Check if the device's runtime PM status allows it to be suspended.  If
 290  * another suspend has been started earlier, either return immediately or wait
 291  * for it to finish, depending on the RPM_NOWAIT and RPM_ASYNC flags.  Cancel a
 292  * pending idle notification.  If the RPM_ASYNC flag is set then queue a
 293  * suspend request; otherwise run the ->runtime_suspend() callback directly.
 294  * If a deferred resume was requested while the callback was running then carry
 295  * it out; otherwise send an idle notification for the device (if the suspend
 296  * failed) or for its parent (if the suspend succeeded).
 297  *
 298  * This function must be called under dev->power.lock with interrupts disabled.
 299  */
 300 static int rpm_suspend(struct device *dev, int rpmflags)
 301         __releases(&dev->power.lock) __acquires(&dev->power.lock)
 302 {
 303         int (*callback)(struct device *);
 304         struct device *parent = NULL;
 305         int retval;
 306
 307         trace_rpm_suspend(dev, rpmflags);
 308
 309  repeat:
 310         retval = rpm_check_suspend_allowed(dev);
 311
 312         if (retval < 0)
 313                 ;       /* Conditions are wrong. */
 314
 315         /* Synchronous suspends are not allowed in the RPM_RESUMING state. */
 316         else if (dev->power.runtime_status == RPM_RESUMING &&
 317             !(rpmflags & RPM_ASYNC))
 318                 retval = -EAGAIN;
 319         if (retval)
 320                 goto out;
 321
 322         /* If the autosuspend_delay time hasn't expired yet, reschedule. */
 323         if ((rpmflags & RPM_AUTO)
 324             && dev->power.runtime_status != RPM_SUSPENDING) {
 325                 unsigned long expires = pm_runtime_autosuspend_expiration(dev);
 326
 327                 if (expires != 0) {
 328                         /* Pending requests need to be canceled. */
 329                         dev->power.request = RPM_REQ_NONE;
 330
 331                         /*
 332                          * Optimization: If the timer is already running and is
 333                          * set to expire at or before the autosuspend delay,
 334                          * avoid the overhead of resetting it.  Just let it
 335                          * expire; pm_suspend_timer_fn() will take care of the
 336                          * rest.
 337                          */
 338                         if (!(dev->power.timer_expires && time_before_eq(
 339                             dev->power.timer_expires, expires))) {
 340                                 dev->power.timer_expires = expires;
 341                                 mod_timer(&dev->power.suspend_timer, expires);
 342                         }
 343                         dev->power.timer_autosuspends = 1;
 344                         goto out;
 345                 }
 346         }
 347
 348         /* Other scheduled or pending requests need to be canceled. */
 349         pm_runtime_cancel_pending(dev);
 350
 351         if (dev->power.runtime_status == RPM_SUSPENDING) {
 352                 DEFINE_WAIT(wait);
 353
 354                 if (rpmflags & (RPM_ASYNC | RPM_NOWAIT)) {
 355                         retval = -EINPROGRESS;
 356                         goto out;
 357                 }
 358
 359                 if (dev->power.irq_safe) {
 360                         spin_unlock(&dev->power.lock);
 361
 362                         cpu_relax();
 363
 364                         spin_lock(&dev->power.lock);
 365                         goto repeat;
 366                 }
 367
 368                 /* Wait for the other suspend running in parallel with us. */
 369                 for (;;) {
 370                         prepare_to_wait(&dev->power.wait_queue, &wait,
 371                                         TASK_UNINTERRUPTIBLE);
 372                         if (dev->power.runtime_status != RPM_SUSPENDING)
 373                                 break;
 374
 375                         spin_unlock_irq(&dev->power.lock);
 376
 377                         schedule();
 378
 379                         spin_lock_irq(&dev->power.lock);
 380                 }
 381                 finish_wait(&dev->power.wait_queue, &wait);
 382                 goto repeat;
 383         }
 384
 385         dev->power.deferred_resume = false;
 386         if (dev->power.no_callbacks)
 387                 goto no_callback;       /* Assume success. */
 388
 389         /* Carry out an asynchronous or a synchronous suspend. */
 390         if (rpmflags & RPM_ASYNC) {
 391                 dev->power.request = (rpmflags & RPM_AUTO) ?
 392                     RPM_REQ_AUTOSUSPEND : RPM_REQ_SUSPEND;
 393                 if (!dev->power.request_pending) {
 394                         dev->power.request_pending = true;
 395                         queue_work(pm_wq, &dev->power.work);
 396                 }
 397                 goto out;
 398         }
 399
 400         __update_runtime_status(dev, RPM_SUSPENDING);
 401
 402         if (dev->pm_domain)
 403                 callback = dev->pm_domain->ops.runtime_suspend;
 404         else if (dev->type && dev->type->pm)
 405                 callback = dev->type->pm->runtime_suspend;
 406         else if (dev->class && dev->class->pm)
 407                 callback = dev->class->pm->runtime_suspend;
 408         else if (dev->bus && dev->bus->pm)
 409                 callback = dev->bus->pm->runtime_suspend;
 410         else
 411                 callback = NULL;
 412
 413         retval = rpm_callback(callback, dev);
 414         if (retval) {
 415                 __update_runtime_status(dev, RPM_ACTIVE);
 416                 dev->power.deferred_resume = false;
 417                 if (retval == -EAGAIN || retval == -EBUSY)
 418                         dev->power.runtime_error = 0;
 419                 else
 420                         pm_runtime_cancel_pending(dev);
 421         } else {
 422  no_callback:
 423                 __update_runtime_status(dev, RPM_SUSPENDED);
 424                 pm_runtime_deactivate_timer(dev);
 425
 426                 if (dev->parent) {
 427                         parent = dev->parent;
 428                         atomic_add_unless(&parent->power.child_count, -1, 0);
 429                 }
 430         }
 431         wake_up_all(&dev->power.wait_queue);
 432
 433         if (dev->power.deferred_resume) {
 434                 rpm_resume(dev, 0);
 435                 retval = -EAGAIN;
 436                 goto out;
 437         }
 438
 439         /* Maybe the parent is now able to suspend. */
 440         if (parent && !parent->power.ignore_children && !dev->power.irq_safe) {
 441                 spin_unlock(&dev->power.lock);
 442
 443                 spin_lock(&parent->power.lock);
 444                 rpm_idle(parent, RPM_ASYNC);
 445                 spin_unlock(&parent->power.lock);
 446
 447                 spin_lock(&dev->power.lock);
 448         }
 449
 450  out:
 451         trace_rpm_return_int(dev, _THIS_IP_, retval);
 452
 453         return retval;
 454 }
 455
 456 /**
 457  * rpm_resume - Carry out runtime resume of given device.
 458  * @dev: Device to resume.
 459  * @rpmflags: Flag bits.
 460  *
 461  * Check if the device's runtime PM status allows it to be resumed.  Cancel
 462  * any scheduled or pending requests.  If another resume has been started
 463  * earlier, either return immediately or wait for it to finish, depending on the
 464  * RPM_NOWAIT and RPM_ASYNC flags.  Similarly, if there's a suspend running in
 465  * parallel with this function, either tell the other process to resume after
 466  * suspending (deferred_resume) or wait for it to finish.  If the RPM_ASYNC
 467  * flag is set then queue a resume request; otherwise run the
 468  * ->runtime_resume() callback directly.  Queue an idle notification for the
 469  * device if the resume succeeded.
 470  *
 471  * This function must be called under dev->power.lock with interrupts disabled.
 472  */
 473 static int rpm_resume(struct device *dev, int rpmflags)
 474         __releases(&dev->power.lock) __acquires(&dev->power.lock)
 475 {
 476         int (*callback)(struct device *);
 477         struct device *parent = NULL;
 478         int retval = 0;
 479
 480         trace_rpm_resume(dev, rpmflags);
 481
 482  repeat:
 483         if (dev->power.runtime_error)
 484                 retval = -EINVAL;
 485         else if (dev->power.disable_depth > 0)
 486                 retval = -EACCES;
 487         if (retval)
 488                 goto out;
 489
 490         /*
 491          * Other scheduled or pending requests need to be canceled.  Small
 492          * optimization: If an autosuspend timer is running, leave it running
 493          * rather than cancelling it now only to restart it again in the near
 494          * future.
 495          */
 496         dev->power.request = RPM_REQ_NONE;
 497         if (!dev->power.timer_autosuspends)
 498                 pm_runtime_deactivate_timer(dev);
 499
 500         if (dev->power.runtime_status == RPM_ACTIVE) {
 501                 retval = 1;
 502                 goto out;
 503         }
 504
 505         if (dev->power.runtime_status == RPM_RESUMING
 506             || dev->power.runtime_status == RPM_SUSPENDING) {
 507                 DEFINE_WAIT(wait);
 508
 509                 if (rpmflags & (RPM_ASYNC | RPM_NOWAIT)) {
 510                         if (dev->power.runtime_status == RPM_SUSPENDING)
 511                                 dev->power.deferred_resume = true;
 512                         else
 513                                 retval = -EINPROGRESS;
 514                         goto out;
 515                 }
 516
 517                 if (dev->power.irq_safe) {
 518                         spin_unlock(&dev->power.lock);
 519
 520                         cpu_relax();
 521
 522                         spin_lock(&dev->power.lock);
 523                         goto repeat;
 524                 }
 525
 526                 /* Wait for the operation carried out in parallel with us. */
 527                 for (;;) {
 528                         prepare_to_wait(&dev->power.wait_queue, &wait,
 529                                         TASK_UNINTERRUPTIBLE);
 530                         if (dev->power.runtime_status != RPM_RESUMING
 531                             && dev->power.runtime_status != RPM_SUSPENDING)
 532                                 break;
 533
 534                         spin_unlock_irq(&dev->power.lock);
 535
 536                         schedule();
 537
 538                         spin_lock_irq(&dev->power.lock);
 539                 }
 540                 finish_wait(&dev->power.wait_queue, &wait);
 541                 goto repeat;
 542         }
 543
 544         /*
 545          * See if we can skip waking up the parent.  This is safe only if
 546          * power.no_callbacks is set, because otherwise we don't know whether
 547          * the resume will actually succeed.
 548          */
 549         if (dev->power.no_callbacks && !parent && dev->parent) {
 550                 spin_lock_nested(&dev->parent->power.lock, SINGLE_DEPTH_NESTING);
 551                 if (dev->parent->power.disable_depth > 0
 552                     || dev->parent->power.ignore_children
 553                     || dev->parent->power.runtime_status == RPM_ACTIVE) {
 554                         atomic_inc(&dev->parent->power.child_count);
 555                         spin_unlock(&dev->parent->power.lock);
 556                         goto no_callback;       /* Assume success. */
 557                 }
 558                 spin_unlock(&dev->parent->power.lock);
 559         }
 560
 561         /* Carry out an asynchronous or a synchronous resume. */
 562         if (rpmflags & RPM_ASYNC) {
 563                 dev->power.request = RPM_REQ_RESUME;
 564                 if (!dev->power.request_pending) {
 565                         dev->power.request_pending = true;
 566                         queue_work(pm_wq, &dev->power.work);
 567                 }
 568                 retval = 0;
 569                 goto out;
 570         }
 571
 572         if (!parent && dev->parent) {
 573                 /*
 574                  * Increment the parent's usage counter and resume it if
 575                  * necessary.  Not needed if dev is irq-safe; then the
 576                  * parent is permanently resumed.
 577                  */
 578                 parent = dev->parent;
 579                 if (dev->power.irq_safe)
 580                         goto skip_parent;
 581                 spin_unlock(&dev->power.lock);
 582
 583                 pm_runtime_get_noresume(parent);
 584
 585                 spin_lock(&parent->power.lock);
 586                 /*
 587                  * We can resume if the parent's runtime PM is disabled or it
 588                  * is set to ignore children.
 589                  */
 590                 if (!parent->power.disable_depth
 591                     && !parent->power.ignore_children) {
 592                         rpm_resume(parent, 0);
 593                         if (parent->power.runtime_status != RPM_ACTIVE)
 594                                 retval = -EBUSY;
 595                 }
 596                 spin_unlock(&parent->power.lock);
 597
 598                 spin_lock(&dev->power.lock);
 599                 if (retval)
 600                         goto out;
 601                 goto repeat;
 602         }
 603  skip_parent:
 604
 605         if (dev->power.no_callbacks)
 606                 goto no_callback;       /* Assume success. */
 607
 608         __update_runtime_status(dev, RPM_RESUMING);
 609
 610         if (dev->pm_domain)
 611                 callback = dev->pm_domain->ops.runtime_resume;
 612         else if (dev->type && dev->type->pm)
 613                 callback = dev->type->pm->runtime_resume;
 614         else if (dev->class && dev->class->pm)
 615                 callback = dev->class->pm->runtime_resume;
 616         else if (dev->bus && dev->bus->pm)
 617                 callback = dev->bus->pm->runtime_resume;
 618         else
 619                 callback = NULL;
 620
 621         retval = rpm_callback(callback, dev);
 622         if (retval) {
 623                 __update_runtime_status(dev, RPM_SUSPENDED);
 624                 pm_runtime_cancel_pending(dev);
 625         } else {
 626  no_callback:
 627                 __update_runtime_status(dev, RPM_ACTIVE);
 628                 if (parent)
 629                         atomic_inc(&parent->power.child_count);
 630         }
 631         wake_up_all(&dev->power.wait_queue);
 632
 633         if (!retval)
 634                 rpm_idle(dev, RPM_ASYNC);
 635
 636  out:
 637         if (parent && !dev->power.irq_safe) {
 638                 spin_unlock_irq(&dev->power.lock);
 639
 640                 pm_runtime_put(parent);
 641
 642                 spin_lock_irq(&dev->power.lock);
 643         }
 644
 645         trace_rpm_return_int(dev, _THIS_IP_, retval);
 646
 647         return retval;
 648 }
 649
 650 /**
 651  * pm_runtime_work - Universal runtime PM work function.
 652  * @work: Work structure used for scheduling the execution of this function.
 653  *
 654  * Use @work to get the device object the work is to be done for, determine what
 655  * is to be done and execute the appropriate runtime PM function.
 656  */
 657 static void pm_runtime_work(struct work_struct *work)
 658 {
 659         struct device *dev = container_of(work, struct device, power.work);
 660         enum rpm_request req;
 661
 662         spin_lock_irq(&dev->power.lock);
 663
 664         if (!dev->power.request_pending)
 665                 goto out;
 666
 667         req = dev->power.request;
 668         dev->power.request = RPM_REQ_NONE;
 669         dev->power.request_pending = false;
 670
 671         switch (req) {
 672         case RPM_REQ_NONE:
 673                 break;
 674         case RPM_REQ_IDLE:
 675                 rpm_idle(dev, RPM_NOWAIT);
 676                 break;
 677         case RPM_REQ_SUSPEND:
 678                 rpm_suspend(dev, RPM_NOWAIT);
 679                 break;
 680         case RPM_REQ_AUTOSUSPEND:
 681                 rpm_suspend(dev, RPM_NOWAIT | RPM_AUTO);
 682                 break;
 683         case RPM_REQ_RESUME:
 684                 rpm_resume(dev, RPM_NOWAIT);
 685                 break;
 686         }
 687
 688  out:
 689         spin_unlock_irq(&dev->power.lock);
 690 }
 691
 692 /**
 693  * pm_suspend_timer_fn - Timer function for pm_schedule_suspend().
 694  * @data: Device pointer passed by pm_schedule_suspend().
 695  *
 696  * Check if the time is right and queue a suspend request.
 697  */
 698 static void pm_suspend_timer_fn(unsigned long data)
 699 {
 700         struct device *dev = (struct device *)data;
 701         unsigned long flags;
 702         unsigned long expires;
 703
 704         spin_lock_irqsave(&dev->power.lock, flags);
 705
 706         expires = dev->power.timer_expires;
 707         /* If 'expire' is after 'jiffies' we've been called too early. */
 708         if (expires > 0 && !time_after(expires, jiffies)) {
 709                 dev->power.timer_expires = 0;
 710                 rpm_suspend(dev, dev->power.timer_autosuspends ?
 711                     (RPM_ASYNC | RPM_AUTO) : RPM_ASYNC);
 712         }
 713
 714         spin_unlock_irqrestore(&dev->power.lock, flags);
 715 }
 716
 717 /**
 718  * pm_schedule_suspend - Set up a timer to submit a suspend request in future.
 719  * @dev: Device to suspend.
 720  * @delay: Time to wait before submitting a suspend request, in milliseconds.
 721  */
 722 int pm_schedule_suspend(struct device *dev, unsigned int delay)
 723 {
 724         unsigned long flags;
 725         int retval;
 726
 727         spin_lock_irqsave(&dev->power.lock, flags);
 728
 729         if (!delay) {
 730                 retval = rpm_suspend(dev, RPM_ASYNC);
 731                 goto out;
 732         }
 733
 734         retval = rpm_check_suspend_allowed(dev);
 735         if (retval)
 736                 goto out;
 737
 738         /* Other scheduled or pending requests need to be canceled. */
 739         pm_runtime_cancel_pending(dev);
 740
 741         dev->power.timer_expires = jiffies + msecs_to_jiffies(delay);
 742         dev->power.timer_expires += !dev->power.timer_expires;
 743         dev->power.timer_autosuspends = 0;
 744         mod_timer(&dev->power.suspend_timer, dev->power.timer_expires);
 745
 746  out:
 747         spin_unlock_irqrestore(&dev->power.lock, flags);
 748
 749         return retval;
 750 }
 751 EXPORT_SYMBOL_GPL(pm_schedule_suspend);
 752
 753 /**
 754  * __pm_runtime_idle - Entry point for runtime idle operations.
 755  * @dev: Device to send idle notification for.
 756  * @rpmflags: Flag bits.
 757  *
 758  * If the RPM_GET_PUT flag is set, decrement the device's usage count and
 759  * return immediately if it is larger than zero.  Then carry out an idle
 760  * notification, either synchronous or asynchronous.
 761  *
 762  * This routine may be called in atomic context if the RPM_ASYNC flag is set,
 763  * or if pm_runtime_irq_safe() has been called.
 764  */
 765 int __pm_runtime_idle(struct device *dev, int rpmflags)
 766 {
 767         unsigned long flags;
 768         int retval;
 769
 770         might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe);
 771
 772         if (rpmflags & RPM_GET_PUT) {
 773                 if (!atomic_dec_and_test(&dev->power.usage_count))
 774                         return 0;
 775         }
 776
 777         spin_lock_irqsave(&dev->power.lock, flags);
 778         retval = rpm_idle(dev, rpmflags);
 779         spin_unlock_irqrestore(&dev->power.lock, flags);
 780
 781         return retval;
 782 }
 783 EXPORT_SYMBOL_GPL(__pm_runtime_idle);
 784
 785 /**
 786  * __pm_runtime_suspend - Entry point for runtime put/suspend operations.
 787  * @dev: Device to suspend.
 788  * @rpmflags: Flag bits.
 789  *
 790  * If the RPM_GET_PUT flag is set, decrement the device's usage count and
 791  * return immediately if it is larger than zero.  Then carry out a suspend,
 792  * either synchronous or asynchronous.
 793  *
 794  * This routine may be called in atomic context if the RPM_ASYNC flag is set,
 795  * or if pm_runtime_irq_safe() has been called.
 796  */
 797 int __pm_runtime_suspend(struct device *dev, int rpmflags)
 798 {
 799         unsigned long flags;
 800         int retval;
 801
 802         might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe);
 803
 804         if (rpmflags & RPM_GET_PUT) {
 805                 if (!atomic_dec_and_test(&dev->power.usage_count))
 806                         return 0;
 807         }
 808
 809         spin_lock_irqsave(&dev->power.lock, flags);
 810         retval = rpm_suspend(dev, rpmflags);
 811         spin_unlock_irqrestore(&dev->power.lock, flags);
 812
 813         return retval;
 814 }
 815 EXPORT_SYMBOL_GPL(__pm_runtime_suspend);
 816
 817 /**
 818  * __pm_runtime_resume - Entry point for runtime resume operations.
 819  * @dev: Device to resume.
 820  * @rpmflags: Flag bits.
 821  *
 822  * If the RPM_GET_PUT flag is set, increment the device's usage count.  Then
 823  * carry out a resume, either synchronous or asynchronous.
 824  *
 825  * This routine may be called in atomic context if the RPM_ASYNC flag is set,
 826  * or if pm_runtime_irq_safe() has been called.
 827  */
 828 int __pm_runtime_resume(struct device *dev, int rpmflags)
 829 {
 830         unsigned long flags;
 831         int retval;
 832
 833         might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe);
 834
 835         if (rpmflags & RPM_GET_PUT)
 836                 atomic_inc(&dev->power.usage_count);
 837
 838         spin_lock_irqsave(&dev->power.lock, flags);
 839         retval = rpm_resume(dev, rpmflags);
 840         spin_unlock_irqrestore(&dev->power.lock, flags);
 841
 842         return retval;
 843 }
 844 EXPORT_SYMBOL_GPL(__pm_runtime_resume);
 845
 846 /**
 847  * __pm_runtime_set_status - Set runtime PM status of a device.
 848  * @dev: Device to handle.
 849  * @status: New runtime PM status of the device.
 850  *
 851  * If runtime PM of the device is disabled or its power.runtime_error field is
 852  * different from zero, the status may be changed either to RPM_ACTIVE, or to
 853  * RPM_SUSPENDED, as long as that reflects the actual state of the device.
 854  * However, if the device has a parent and the parent is not active, and the
 855  * parent's power.ignore_children flag is unset, the device's status cannot be
 856  * set to RPM_ACTIVE, so -EBUSY is returned in that case.
 857  *
 858  * If successful, __pm_runtime_set_status() clears the power.runtime_error field
 859  * and the device parent's counter of unsuspended children is modified to
 860  * reflect the new status.  If the new status is RPM_SUSPENDED, an idle
 861  * notification request for the parent is submitted.
 862  */
 863 int __pm_runtime_set_status(struct device *dev, unsigned int status)
 864 {
 865         struct device *parent = dev->parent;
 866         unsigned long flags;
 867         bool notify_parent = false;
 868         int error = 0;
 869
 870         if (status != RPM_ACTIVE && status != RPM_SUSPENDED)
 871                 return -EINVAL;
 872
 873         spin_lock_irqsave(&dev->power.lock, flags);
 874
 875         if (!dev->power.runtime_error && !dev->power.disable_depth) {
 876                 error = -EAGAIN;
 877                 goto out;
 878         }
 879
 880         if (dev->power.runtime_status == status)
 881                 goto out_set;
 882
 883         if (status == RPM_SUSPENDED) {
 884                 /* It always is possible to set the status to 'suspended'. */
 885                 if (parent) {
 886                         atomic_add_unless(&parent->power.child_count, -1, 0);
 887                         notify_parent = !parent->power.ignore_children;
 888                 }
 889                 goto out_set;
 890         }
 891
 892         if (parent) {
 893                 spin_lock_nested(&parent->power.lock, SINGLE_DEPTH_NESTING);
 894
 895                 /*
 896                  * It is invalid to put an active child under a parent that is
 897                  * not active, has runtime PM enabled and the
 898                  * 'power.ignore_children' flag unset.
 899                  */
 900                 if (!parent->power.disable_depth
 901                     && !parent->power.ignore_children
 902                     && parent->power.runtime_status != RPM_ACTIVE)
 903                         error = -EBUSY;
 904                 else if (dev->power.runtime_status == RPM_SUSPENDED)
 905                         atomic_inc(&parent->power.child_count);
 906
 907                 spin_unlock(&parent->power.lock);
 908
 909                 if (error)
 910                         goto out;
 911         }
 912
 913  out_set:
 914         __update_runtime_status(dev, status);
 915         dev->power.runtime_error = 0;
 916  out:
 917         spin_unlock_irqrestore(&dev->power.lock, flags);
 918
 919         if (notify_parent)
 920                 pm_request_idle(parent);
 921
 922         return error;
 923 }
 924 EXPORT_SYMBOL_GPL(__pm_runtime_set_status);
 925
 926 /**
 927  * __pm_runtime_barrier - Cancel pending requests and wait for completions.
 928  * @dev: Device to handle.
 929  *
 930  * Flush all pending requests for the device from pm_wq and wait for all
 931  * runtime PM operations involving the device in progress to complete.
 932  *
 933  * Should be called under dev->power.lock with interrupts disabled.
 934  */
 935 static void __pm_runtime_barrier(struct device *dev)
 936 {
 937         pm_runtime_deactivate_timer(dev);
 938
 939         if (dev->power.request_pending) {
 940                 dev->power.request = RPM_REQ_NONE;
 941                 spin_unlock_irq(&dev->power.lock);
 942
 943                 cancel_work_sync(&dev->power.work);
 944
 945                 spin_lock_irq(&dev->power.lock);
 946                 dev->power.request_pending = false;
 947         }
 948
 949         if (dev->power.runtime_status == RPM_SUSPENDING
 950             || dev->power.runtime_status == RPM_RESUMING
 951             || dev->power.idle_notification) {
 952                 DEFINE_WAIT(wait);
 953
 954                 /* Suspend, wake-up or idle notification in progress. */
 955                 for (;;) {
 956                         prepare_to_wait(&dev->power.wait_queue, &wait,
 957                                         TASK_UNINTERRUPTIBLE);
 958                         if (dev->power.runtime_status != RPM_SUSPENDING
 959                             && dev->power.runtime_status != RPM_RESUMING
 960                             && !dev->power.idle_notification)
 961                                 break;
 962                         spin_unlock_irq(&dev->power.lock);
 963
 964                         schedule();
 965
 966                         spin_lock_irq(&dev->power.lock);
 967                 }
 968                 finish_wait(&dev->power.wait_queue, &wait);
 969         }
 970 }
 971
 972 /**
 973  * pm_runtime_barrier - Flush pending requests and wait for completions.
 974  * @dev: Device to handle.
 975  *
 976  * Prevent the device from being suspended by incrementing its usage counter and
 977  * if there's a pending resume request for the device, wake the device up.
 978  * Next, make sure that all pending requests for the device have been flushed
 979  * from pm_wq and wait for all runtime PM operations involving the device in
 980  * progress to complete.
 981  *
 982  * Return value:
 983  * 1, if there was a resume request pending and the device had to be woken up,
 984  * 0, otherwise
 985  */
 986 int pm_runtime_barrier(struct device *dev)
 987 {
 988         int retval = 0;
 989
 990         pm_runtime_get_noresume(dev);
 991         spin_lock_irq(&dev->power.lock);
 992
 993         if (dev->power.request_pending
 994             && dev->power.request == RPM_REQ_RESUME) {
 995                 rpm_resume(dev, 0);
 996                 retval = 1;
 997         }
 998
 999         __pm_runtime_barrier(dev);
1000
1001         spin_unlock_irq(&dev->power.lock);
1002         pm_runtime_put_noidle(dev);
1003
1004         return retval;
1005 }
1006 EXPORT_SYMBOL_GPL(pm_runtime_barrier);
1007
1008 /**
1009  * __pm_runtime_disable - Disable runtime PM of a device.
1010  * @dev: Device to handle.
1011  * @check_resume: If set, check if there's a resume request for the device.
1012  *
1013  * Increment power.disable_depth for the device and if was zero previously,
1014  * cancel all pending runtime PM requests for the device and wait for all
1015  * operations in progress to complete.  The device can be either active or
1016  * suspended after its runtime PM has been disabled.
1017  *
1018  * If @check_resume is set and there's a resume request pending when
1019  * __pm_runtime_disable() is called and power.disable_depth is zero, the
1020  * function will wake up the device before disabling its runtime PM.
1021  */
1022 void __pm_runtime_disable(struct device *dev, bool check_resume)
1023 {
1024         spin_lock_irq(&dev->power.lock);
1025
1026         if (dev->power.disable_depth > 0) {
1027                 dev->power.disable_depth++;
1028                 goto out;
1029         }
1030
1031         /*
1032          * Wake up the device if there's a resume request pending, because that
1033          * means there probably is some I/O to process and disabling runtime PM
1034          * shouldn't prevent the device from processing the I/O.
1035          */
1036         if (check_resume && dev->power.request_pending
1037             && dev->power.request == RPM_REQ_RESUME) {
1038                 /*
1039                  * Prevent suspends and idle notifications from being carried
1040                  * out after we have woken up the device.
1041                  */
1042                 pm_runtime_get_noresume(dev);
1043
1044                 rpm_resume(dev, 0);
1045
1046                 pm_runtime_put_noidle(dev);
1047         }
1048
1049         if (!dev->power.disable_depth++)
1050                 __pm_runtime_barrier(dev);
1051
1052  out:
1053         spin_unlock_irq(&dev->power.lock);
1054 }
1055 EXPORT_SYMBOL_GPL(__pm_runtime_disable);
1056
1057 /**
1058  * pm_runtime_enable - Enable runtime PM of a device.
1059  * @dev: Device to handle.
1060  */
1061 void pm_runtime_enable(struct device *dev)
1062 {
1063         unsigned long flags;
1064
1065         spin_lock_irqsave(&dev->power.lock, flags);
1066
1067         if (dev->power.disable_depth > 0)
1068                 dev->power.disable_depth--;
1069         else
1070                 dev_warn(dev, "Unbalanced %s!\n", __func__);
1071
1072         spin_unlock_irqrestore(&dev->power.lock, flags);
1073 }
1074 EXPORT_SYMBOL_GPL(pm_runtime_enable);
1075
1076 /**
1077  * pm_runtime_forbid - Block runtime PM of a device.
1078  * @dev: Device to handle.
1079  *
1080  * Increase the device's usage count and clear its power.runtime_auto flag,
1081  * so that it cannot be suspended at run time until pm_runtime_allow() is called
1082  * for it.
1083  */
1084 void pm_runtime_forbid(struct device *dev)
1085 {
1086         spin_lock_irq(&dev->power.lock);
1087         if (!dev->power.runtime_auto)
1088                 goto out;
1089
1090         dev->power.runtime_auto = false;
1091         atomic_inc(&dev->power.usage_count);
1092         rpm_resume(dev, 0);
1093
1094  out:
1095         spin_unlock_irq(&dev->power.lock);
1096 }
1097 EXPORT_SYMBOL_GPL(pm_runtime_forbid);
1098
1099 /**
1100  * pm_runtime_allow - Unblock runtime PM of a device.
1101  * @dev: Device to handle.
1102  *
1103  * Decrease the device's usage count and set its power.runtime_auto flag.
1104  */
1105 void pm_runtime_allow(struct device *dev)
1106 {
1107         spin_lock_irq(&dev->power.lock);
1108         if (dev->power.runtime_auto)
1109                 goto out;
1110
1111         dev->power.runtime_auto = true;
1112         if (atomic_dec_and_test(&dev->power.usage_count))
1113                 rpm_idle(dev, RPM_AUTO);
1114
1115  out:
1116         spin_unlock_irq(&dev->power.lock);
1117 }
1118 EXPORT_SYMBOL_GPL(pm_runtime_allow);
1119
1120 /**
1121  * pm_runtime_no_callbacks - Ignore runtime PM callbacks for a device.
1122  * @dev: Device to handle.
1123  *
1124  * Set the power.no_callbacks flag, which tells the PM core that this
1125  * device is power-managed through its parent and has no runtime PM
1126  * callbacks of its own.  The runtime sysfs attributes will be removed.
1127  */
1128 void pm_runtime_no_callbacks(struct device *dev)
1129 {
1130         spin_lock_irq(&dev->power.lock);
1131         dev->power.no_callbacks = 1;
1132         spin_unlock_irq(&dev->power.lock);
1133         if (device_is_registered(dev))
1134                 rpm_sysfs_remove(dev);
1135 }
1136 EXPORT_SYMBOL_GPL(pm_runtime_no_callbacks);
1137
1138 /**
1139  * pm_runtime_irq_safe - Leave interrupts disabled during callbacks.
1140  * @dev: Device to handle
1141  *
1142  * Set the power.irq_safe flag, which tells the PM core that the
1143  * ->runtime_suspend() and ->runtime_resume() callbacks for this device should
1144  * always be invoked with the spinlock held and interrupts disabled.  It also
1145  * causes the parent's usage counter to be permanently incremented, preventing
1146  * the parent from runtime suspending -- otherwise an irq-safe child might have
1147  * to wait for a non-irq-safe parent.
1148  */
1149 void pm_runtime_irq_safe(struct device *dev)
1150 {
1151         if (dev->parent)
1152                 pm_runtime_get_sync(dev->parent);
1153         spin_lock_irq(&dev->power.lock);
1154         dev->power.irq_safe = 1;
1155         spin_unlock_irq(&dev->power.lock);
1156 }
1157 EXPORT_SYMBOL_GPL(pm_runtime_irq_safe);
1158
1159 /**
1160  * update_autosuspend - Handle a change to a device's autosuspend settings.
1161  * @dev: Device to handle.
1162  * @old_delay: The former autosuspend_delay value.
1163  * @old_use: The former use_autosuspend value.
1164  *
1165  * Prevent runtime suspend if the new delay is negative and use_autosuspend is
1166  * set; otherwise allow it.  Send an idle notification if suspends are allowed.
1167  *
1168  * This function must be called under dev->power.lock with interrupts disabled.
1169  */
1170 static void update_autosuspend(struct device *dev, int old_delay, int old_use)
1171 {
1172         int delay = dev->power.autosuspend_delay;
1173
1174         /* Should runtime suspend be prevented now? */
1175         if (dev->power.use_autosuspend && delay < 0) {
1176
1177                 /* If it used to be allowed then prevent it. */
1178                 if (!old_use || old_delay >= 0) {
1179                         atomic_inc(&dev->power.usage_count);
1180                         rpm_resume(dev, 0);
1181                 }
1182         }
1183
1184         /* Runtime suspend should be allowed now. */
1185         else {
1186
1187                 /* If it used to be prevented then allow it. */
1188                 if (old_use && old_delay < 0)
1189                         atomic_dec(&dev->power.usage_count);
1190
1191                 /* Maybe we can autosuspend now. */
1192                 rpm_idle(dev, RPM_AUTO);
1193         }
1194 }
1195
1196 /**
1197  * pm_runtime_set_autosuspend_delay - Set a device's autosuspend_delay value.
1198  * @dev: Device to handle.
1199  * @delay: Value of the new delay in milliseconds.
1200  *
1201  * Set the device's power.autosuspend_delay value.  If it changes to negative
1202  * and the power.use_autosuspend flag is set, prevent runtime suspends.  If it
1203  * changes the other way, allow runtime suspends.
1204  */
1205 void pm_runtime_set_autosuspend_delay(struct device *dev, int delay)
1206 {
1207         int old_delay, old_use;
1208
1209         spin_lock_irq(&dev->power.lock);
1210         old_delay = dev->power.autosuspend_delay;
1211         old_use = dev->power.use_autosuspend;
1212         dev->power.autosuspend_delay = delay;
1213         update_autosuspend(dev, old_delay, old_use);
1214         spin_unlock_irq(&dev->power.lock);
1215 }
1216 EXPORT_SYMBOL_GPL(pm_runtime_set_autosuspend_delay);
1217
1218 /**
1219  * __pm_runtime_use_autosuspend - Set a device's use_autosuspend flag.
1220  * @dev: Device to handle.
1221  * @use: New value for use_autosuspend.
1222  *
1223  * Set the device's power.use_autosuspend flag, and allow or prevent runtime
1224  * suspends as needed.
1225  */
1226 void __pm_runtime_use_autosuspend(struct device *dev, bool use)
1227 {
1228         int old_delay, old_use;
1229
1230         spin_lock_irq(&dev->power.lock);
1231         old_delay = dev->power.autosuspend_delay;
1232         old_use = dev->power.use_autosuspend;
1233         dev->power.use_autosuspend = use;
1234         update_autosuspend(dev, old_delay, old_use);
1235         spin_unlock_irq(&dev->power.lock);
1236 }
1237 EXPORT_SYMBOL_GPL(__pm_runtime_use_autosuspend);
1238
1239 /**
1240  * pm_runtime_init - Initialize runtime PM fields in given device object.
1241  * @dev: Device object to initialize.
1242  */
1243 void pm_runtime_init(struct device *dev)
1244 {
1245         dev->power.runtime_status = RPM_SUSPENDED;
1246         dev->power.idle_notification = false;
1247
1248         dev->power.disable_depth = 1;
1249         atomic_set(&dev->power.usage_count, 0);
1250
1251         dev->power.runtime_error = 0;
1252
1253         atomic_set(&dev->power.child_count, 0);
1254         pm_suspend_ignore_children(dev, false);
1255         dev->power.runtime_auto = true;
1256
1257         dev->power.request_pending = false;
1258         dev->power.request = RPM_REQ_NONE;
1259         dev->power.deferred_resume = false;
1260         dev->power.accounting_timestamp = jiffies;
1261         INIT_WORK(&dev->power.work, pm_runtime_work);
1262
1263         dev->power.timer_expires = 0;
1264         setup_timer(&dev->power.suspend_timer, pm_suspend_timer_fn,
1265                         (unsigned long)dev);
1266
1267         init_waitqueue_head(&dev->power.wait_queue);
1268 }
1269
1270 /**
1271  * pm_runtime_remove - Prepare for removing a device from device hierarchy.
1272  * @dev: Device object being removed from device hierarchy.
1273  */
1274 void pm_runtime_remove(struct device *dev)
1275 {
1276         __pm_runtime_disable(dev, false);
1277
1278         /* Change the status back to 'suspended' to match the initial status. */
1279         if (dev->power.runtime_status == RPM_ACTIVE)
1280                 pm_runtime_set_suspended(dev);
1281         if (dev->power.irq_safe && dev->parent)
1282                 pm_runtime_put_sync(dev->parent);
1283 }