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