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