drivers/base/power/runtime.c

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