drivers/base/power/runtime.c

   1 /*
   2  * drivers/base/power/runtime.c - Helper functions for device run-time PM
   3  *
   4  * Copyright (c) 2009 Rafael J. Wysocki <rjw@sisk.pl>, Novell Inc.
   5  *
   6  * This file is released under the GPLv2.
   7  */
   8
   9 #include <linux/sched.h>
  10 #include <linux/pm_runtime.h>
  11 #include <linux/jiffies.h>
  12
  13 static int __pm_runtime_resume(struct device *dev, bool from_wq);
  14 static int __pm_request_idle(struct device *dev);
  15 static int __pm_request_resume(struct device *dev);
  16
  17 /**
  18  * pm_runtime_deactivate_timer - Deactivate given device's suspend timer.
  19  * @dev: Device to handle.
  20  */
  21 static void pm_runtime_deactivate_timer(struct device *dev)
  22 {
  23         if (dev->power.timer_expires > 0) {
  24                 del_timer(&dev->power.suspend_timer);
  25                 dev->power.timer_expires = 0;
  26         }
  27 }
  28
  29 /**
  30  * pm_runtime_cancel_pending - Deactivate suspend timer and cancel requests.
  31  * @dev: Device to handle.
  32  */
  33 static void pm_runtime_cancel_pending(struct device *dev)
  34 {
  35         pm_runtime_deactivate_timer(dev);
  36         /*
  37          * In case there's a request pending, make sure its work function will
  38          * return without doing anything.
  39          */
  40         dev->power.request = RPM_REQ_NONE;
  41 }
  42
  43 /**
  44  * __pm_runtime_idle - Notify device bus type if the device can be suspended.
  45  * @dev: Device to notify the bus type about.
  46  *
  47  * This function must be called under dev->power.lock with interrupts disabled.
  48  */
  49 static int __pm_runtime_idle(struct device *dev)
  50         __releases(&dev->power.lock) __acquires(&dev->power.lock)
  51 {
  52         int retval = 0;
  53
  54         if (dev->power.runtime_error)
  55                 retval = -EINVAL;
  56         else if (dev->power.idle_notification)
  57                 retval = -EINPROGRESS;
  58         else if (atomic_read(&dev->power.usage_count) > 0
  59             || dev->power.disable_depth > 0
  60             || dev->power.runtime_status != RPM_ACTIVE)
  61                 retval = -EAGAIN;
  62         else if (!pm_children_suspended(dev))
  63                 retval = -EBUSY;
  64         if (retval)
  65                 goto out;
  66
  67         if (dev->power.request_pending) {
  68                 /*
  69                  * If an idle notification request is pending, cancel it.  Any
  70                  * other pending request takes precedence over us.
  71                  */
  72                 if (dev->power.request == RPM_REQ_IDLE) {
  73                         dev->power.request = RPM_REQ_NONE;
  74                 } else if (dev->power.request != RPM_REQ_NONE) {
  75                         retval = -EAGAIN;
  76                         goto out;
  77                 }
  78         }
  79
  80         dev->power.idle_notification = true;
  81
  82         if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_idle) {
  83                 spin_unlock_irq(&dev->power.lock);
  84
  85                 dev->bus->pm->runtime_idle(dev);
  86
  87                 spin_lock_irq(&dev->power.lock);
  88         } else if (dev->type && dev->type->pm && dev->type->pm->runtime_idle) {
  89                 spin_unlock_irq(&dev->power.lock);
  90
  91                 dev->type->pm->runtime_idle(dev);
  92
  93                 spin_lock_irq(&dev->power.lock);
  94         } else if (dev->class && dev->class->pm
  95             && dev->class->pm->runtime_idle) {
  96                 spin_unlock_irq(&dev->power.lock);
  97
  98                 dev->class->pm->runtime_idle(dev);
  99
 100                 spin_lock_irq(&dev->power.lock);
 101         }
 102
 103         dev->power.idle_notification = false;
 104         wake_up_all(&dev->power.wait_queue);
 105
 106  out:
 107         return retval;
 108 }
 109
 110 /**
 111  * pm_runtime_idle - Notify device bus type if the device can be suspended.
 112  * @dev: Device to notify the bus type about.
 113  */
 114 int pm_runtime_idle(struct device *dev)
 115 {
 116         int retval;
 117
 118         spin_lock_irq(&dev->power.lock);
 119         retval = __pm_runtime_idle(dev);
 120         spin_unlock_irq(&dev->power.lock);
 121
 122         return retval;
 123 }
 124 EXPORT_SYMBOL_GPL(pm_runtime_idle);
 125
 126 /**
 127  * __pm_runtime_suspend - Carry out run-time suspend of given device.
 128  * @dev: Device to suspend.
 129  * @from_wq: If set, the function has been called via pm_wq.
 130  *
 131  * Check if the device can be suspended and run the ->runtime_suspend() callback
 132  * provided by its bus type.  If another suspend has been started earlier, wait
 133  * for it to finish.  If an idle notification or suspend request is pending or
 134  * scheduled, cancel it.
 135  *
 136  * This function must be called under dev->power.lock with interrupts disabled.
 137  */
 138 int __pm_runtime_suspend(struct device *dev, bool from_wq)
 139         __releases(&dev->power.lock) __acquires(&dev->power.lock)
 140 {
 141         struct device *parent = NULL;
 142         bool notify = false;
 143         int retval = 0;
 144
 145         dev_dbg(dev, "__pm_runtime_suspend()%s!\n",
 146                 from_wq ? " from workqueue" : "");
 147
 148  repeat:
 149         if (dev->power.runtime_error) {
 150                 retval = -EINVAL;
 151                 goto out;
 152         }
 153
 154         /* Pending resume requests take precedence over us. */
 155         if (dev->power.request_pending
 156             && dev->power.request == RPM_REQ_RESUME) {
 157                 retval = -EAGAIN;
 158                 goto out;
 159         }
 160
 161         /* Other scheduled or pending requests need to be canceled. */
 162         pm_runtime_cancel_pending(dev);
 163
 164         if (dev->power.runtime_status == RPM_SUSPENDED)
 165                 retval = 1;
 166         else if (dev->power.runtime_status == RPM_RESUMING
 167             || dev->power.disable_depth > 0
 168             || atomic_read(&dev->power.usage_count) > 0)
 169                 retval = -EAGAIN;
 170         else if (!pm_children_suspended(dev))
 171                 retval = -EBUSY;
 172         if (retval)
 173                 goto out;
 174
 175         if (dev->power.runtime_status == RPM_SUSPENDING) {
 176                 DEFINE_WAIT(wait);
 177
 178                 if (from_wq) {
 179                         retval = -EINPROGRESS;
 180                         goto out;
 181                 }
 182
 183                 /* Wait for the other suspend running in parallel with us. */
 184                 for (;;) {
 185                         prepare_to_wait(&dev->power.wait_queue, &wait,
 186                                         TASK_UNINTERRUPTIBLE);
 187                         if (dev->power.runtime_status != RPM_SUSPENDING)
 188                                 break;
 189
 190                         spin_unlock_irq(&dev->power.lock);
 191
 192                         schedule();
 193
 194                         spin_lock_irq(&dev->power.lock);
 195                 }
 196                 finish_wait(&dev->power.wait_queue, &wait);
 197                 goto repeat;
 198         }
 199
 200         dev->power.runtime_status = RPM_SUSPENDING;
 201         dev->power.deferred_resume = false;
 202
 203         if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_suspend) {
 204                 spin_unlock_irq(&dev->power.lock);
 205
 206                 retval = dev->bus->pm->runtime_suspend(dev);
 207
 208                 spin_lock_irq(&dev->power.lock);
 209                 dev->power.runtime_error = retval;
 210         } else if (dev->type && dev->type->pm
 211             && dev->type->pm->runtime_suspend) {
 212                 spin_unlock_irq(&dev->power.lock);
 213
 214                 retval = dev->type->pm->runtime_suspend(dev);
 215
 216                 spin_lock_irq(&dev->power.lock);
 217                 dev->power.runtime_error = retval;
 218         } else if (dev->class && dev->class->pm
 219             && dev->class->pm->runtime_suspend) {
 220                 spin_unlock_irq(&dev->power.lock);
 221
 222                 retval = dev->class->pm->runtime_suspend(dev);
 223
 224                 spin_lock_irq(&dev->power.lock);
 225                 dev->power.runtime_error = retval;
 226         } else {
 227                 retval = -ENOSYS;
 228         }
 229
 230         if (retval) {
 231                 dev->power.runtime_status = RPM_ACTIVE;
 232                 if (retval == -EAGAIN || retval == -EBUSY) {
 233                         if (dev->power.timer_expires == 0)
 234                                 notify = true;
 235                         dev->power.runtime_error = 0;
 236                 } else {
 237                         pm_runtime_cancel_pending(dev);
 238                 }
 239         } else {
 240                 dev->power.runtime_status = RPM_SUSPENDED;
 241                 pm_runtime_deactivate_timer(dev);
 242
 243                 if (dev->parent) {
 244                         parent = dev->parent;
 245                         atomic_add_unless(&parent->power.child_count, -1, 0);
 246                 }
 247         }
 248         wake_up_all(&dev->power.wait_queue);
 249
 250         if (dev->power.deferred_resume) {
 251                 __pm_runtime_resume(dev, false);
 252                 retval = -EAGAIN;
 253                 goto out;
 254         }
 255
 256         if (notify)
 257                 __pm_runtime_idle(dev);
 258
 259         if (parent && !parent->power.ignore_children) {
 260                 spin_unlock_irq(&dev->power.lock);
 261
 262                 pm_request_idle(parent);
 263
 264                 spin_lock_irq(&dev->power.lock);
 265         }
 266
 267  out:
 268         dev_dbg(dev, "__pm_runtime_suspend() returns %d!\n", retval);
 269
 270         return retval;
 271 }
 272
 273 /**
 274  * pm_runtime_suspend - Carry out run-time suspend of given device.
 275  * @dev: Device to suspend.
 276  */
 277 int pm_runtime_suspend(struct device *dev)
 278 {
 279         int retval;
 280
 281         spin_lock_irq(&dev->power.lock);
 282         retval = __pm_runtime_suspend(dev, false);
 283         spin_unlock_irq(&dev->power.lock);
 284
 285         return retval;
 286 }
 287 EXPORT_SYMBOL_GPL(pm_runtime_suspend);
 288
 289 /**
 290  * __pm_runtime_resume - Carry out run-time resume of given device.
 291  * @dev: Device to resume.
 292  * @from_wq: If set, the function has been called via pm_wq.
 293  *
 294  * Check if the device can be woken up and run the ->runtime_resume() callback
 295  * provided by its bus type.  If another resume has been started earlier, wait
 296  * for it to finish.  If there's a suspend running in parallel with this
 297  * function, wait for it to finish and resume the device.  Cancel any scheduled
 298  * or pending requests.
 299  *
 300  * This function must be called under dev->power.lock with interrupts disabled.
 301  */
 302 int __pm_runtime_resume(struct device *dev, bool from_wq)
 303         __releases(&dev->power.lock) __acquires(&dev->power.lock)
 304 {
 305         struct device *parent = NULL;
 306         int retval = 0;
 307
 308         dev_dbg(dev, "__pm_runtime_resume()%s!\n",
 309                 from_wq ? " from workqueue" : "");
 310
 311  repeat:
 312         if (dev->power.runtime_error) {
 313                 retval = -EINVAL;
 314                 goto out;
 315         }
 316
 317         pm_runtime_cancel_pending(dev);
 318
 319         if (dev->power.runtime_status == RPM_ACTIVE)
 320                 retval = 1;
 321         else if (dev->power.disable_depth > 0)
 322                 retval = -EAGAIN;
 323         if (retval)
 324                 goto out;
 325
 326         if (dev->power.runtime_status == RPM_RESUMING
 327             || dev->power.runtime_status == RPM_SUSPENDING) {
 328                 DEFINE_WAIT(wait);
 329
 330                 if (from_wq) {
 331                         if (dev->power.runtime_status == RPM_SUSPENDING)
 332                                 dev->power.deferred_resume = true;
 333                         retval = -EINPROGRESS;
 334                         goto out;
 335                 }
 336
 337                 /* Wait for the operation carried out in parallel with us. */
 338                 for (;;) {
 339                         prepare_to_wait(&dev->power.wait_queue, &wait,
 340                                         TASK_UNINTERRUPTIBLE);
 341                         if (dev->power.runtime_status != RPM_RESUMING
 342                             && dev->power.runtime_status != RPM_SUSPENDING)
 343                                 break;
 344
 345                         spin_unlock_irq(&dev->power.lock);
 346
 347                         schedule();
 348
 349                         spin_lock_irq(&dev->power.lock);
 350                 }
 351                 finish_wait(&dev->power.wait_queue, &wait);
 352                 goto repeat;
 353         }
 354
 355         if (!parent && dev->parent) {
 356                 /*
 357                  * Increment the parent's resume counter and resume it if
 358                  * necessary.
 359                  */
 360                 parent = dev->parent;
 361                 spin_unlock(&dev->power.lock);
 362
 363                 pm_runtime_get_noresume(parent);
 364
 365                 spin_lock(&parent->power.lock);
 366                 /*
 367                  * We can resume if the parent's run-time PM is disabled or it
 368                  * is set to ignore children.
 369                  */
 370                 if (!parent->power.disable_depth
 371                     && !parent->power.ignore_children) {
 372                         __pm_runtime_resume(parent, false);
 373                         if (parent->power.runtime_status != RPM_ACTIVE)
 374                                 retval = -EBUSY;
 375                 }
 376                 spin_unlock(&parent->power.lock);
 377
 378                 spin_lock(&dev->power.lock);
 379                 if (retval)
 380                         goto out;
 381                 goto repeat;
 382         }
 383
 384         dev->power.runtime_status = RPM_RESUMING;
 385
 386         if (dev->bus && dev->bus->pm && dev->bus->pm->runtime_resume) {
 387                 spin_unlock_irq(&dev->power.lock);
 388
 389                 retval = dev->bus->pm->runtime_resume(dev);
 390
 391                 spin_lock_irq(&dev->power.lock);
 392                 dev->power.runtime_error = retval;
 393         } else if (dev->type && dev->type->pm
 394             && dev->type->pm->runtime_resume) {
 395                 spin_unlock_irq(&dev->power.lock);
 396
 397                 retval = dev->type->pm->runtime_resume(dev);
 398
 399                 spin_lock_irq(&dev->power.lock);
 400                 dev->power.runtime_error = retval;
 401         } else if (dev->class && dev->class->pm
 402             && dev->class->pm->runtime_resume) {
 403                 spin_unlock_irq(&dev->power.lock);
 404
 405                 retval = dev->class->pm->runtime_resume(dev);
 406
 407                 spin_lock_irq(&dev->power.lock);
 408                 dev->power.runtime_error = retval;
 409         } else {
 410                 retval = -ENOSYS;
 411         }
 412
 413         if (retval) {
 414                 dev->power.runtime_status = RPM_SUSPENDED;
 415                 pm_runtime_cancel_pending(dev);
 416         } else {
 417                 dev->power.runtime_status = RPM_ACTIVE;
 418                 if (parent)
 419                         atomic_inc(&parent->power.child_count);
 420         }
 421         wake_up_all(&dev->power.wait_queue);
 422
 423         if (!retval)
 424                 __pm_request_idle(dev);
 425
 426  out:
 427         if (parent) {
 428                 spin_unlock_irq(&dev->power.lock);
 429
 430                 pm_runtime_put(parent);
 431
 432                 spin_lock_irq(&dev->power.lock);
 433         }
 434
 435         dev_dbg(dev, "__pm_runtime_resume() returns %d!\n", retval);
 436
 437         return retval;
 438 }
 439
 440 /**
 441  * pm_runtime_resume - Carry out run-time resume of given device.
 442  * @dev: Device to suspend.
 443  */
 444 int pm_runtime_resume(struct device *dev)
 445 {
 446         int retval;
 447
 448         spin_lock_irq(&dev->power.lock);
 449         retval = __pm_runtime_resume(dev, false);
 450         spin_unlock_irq(&dev->power.lock);
 451
 452         return retval;
 453 }
 454 EXPORT_SYMBOL_GPL(pm_runtime_resume);
 455
 456 /**
 457  * pm_runtime_work - Universal run-time PM work function.
 458  * @work: Work structure used for scheduling the execution of this function.
 459  *
 460  * Use @work to get the device object the work is to be done for, determine what
 461  * is to be done and execute the appropriate run-time PM function.
 462  */
 463 static void pm_runtime_work(struct work_struct *work)
 464 {
 465         struct device *dev = container_of(work, struct device, power.work);
 466         enum rpm_request req;
 467
 468         spin_lock_irq(&dev->power.lock);
 469
 470         if (!dev->power.request_pending)
 471                 goto out;
 472
 473         req = dev->power.request;
 474         dev->power.request = RPM_REQ_NONE;
 475         dev->power.request_pending = false;
 476
 477         switch (req) {
 478         case RPM_REQ_NONE:
 479                 break;
 480         case RPM_REQ_IDLE:
 481                 __pm_runtime_idle(dev);
 482                 break;
 483         case RPM_REQ_SUSPEND:
 484                 __pm_runtime_suspend(dev, true);
 485                 break;
 486         case RPM_REQ_RESUME:
 487                 __pm_runtime_resume(dev, true);
 488                 break;
 489         }
 490
 491  out:
 492         spin_unlock_irq(&dev->power.lock);
 493 }
 494
 495 /**
 496  * __pm_request_idle - Submit an idle notification request for given device.
 497  * @dev: Device to handle.
 498  *
 499  * Check if the device's run-time PM status is correct for suspending the device
 500  * and queue up a request to run __pm_runtime_idle() for it.
 501  *
 502  * This function must be called under dev->power.lock with interrupts disabled.
 503  */
 504 static int __pm_request_idle(struct device *dev)
 505 {
 506         int retval = 0;
 507
 508         if (dev->power.runtime_error)
 509                 retval = -EINVAL;
 510         else if (atomic_read(&dev->power.usage_count) > 0
 511             || dev->power.disable_depth > 0
 512             || dev->power.runtime_status == RPM_SUSPENDED
 513             || dev->power.runtime_status == RPM_SUSPENDING)
 514                 retval = -EAGAIN;
 515         else if (!pm_children_suspended(dev))
 516                 retval = -EBUSY;
 517         if (retval)
 518                 return retval;
 519
 520         if (dev->power.request_pending) {
 521                 /* Any requests other then RPM_REQ_IDLE take precedence. */
 522                 if (dev->power.request == RPM_REQ_NONE)
 523                         dev->power.request = RPM_REQ_IDLE;
 524                 else if (dev->power.request != RPM_REQ_IDLE)
 525                         retval = -EAGAIN;
 526                 return retval;
 527         }
 528
 529         dev->power.request = RPM_REQ_IDLE;
 530         dev->power.request_pending = true;
 531         queue_work(pm_wq, &dev->power.work);
 532
 533         return retval;
 534 }
 535
 536 /**
 537  * pm_request_idle - Submit an idle notification request for given device.
 538  * @dev: Device to handle.
 539  */
 540 int pm_request_idle(struct device *dev)
 541 {
 542         unsigned long flags;
 543         int retval;
 544
 545         spin_lock_irqsave(&dev->power.lock, flags);
 546         retval = __pm_request_idle(dev);
 547         spin_unlock_irqrestore(&dev->power.lock, flags);
 548
 549         return retval;
 550 }
 551 EXPORT_SYMBOL_GPL(pm_request_idle);
 552
 553 /**
 554  * __pm_request_suspend - Submit a suspend request for given device.
 555  * @dev: Device to suspend.
 556  *
 557  * This function must be called under dev->power.lock with interrupts disabled.
 558  */
 559 static int __pm_request_suspend(struct device *dev)
 560 {
 561         int retval = 0;
 562
 563         if (dev->power.runtime_error)
 564                 return -EINVAL;
 565
 566         if (dev->power.runtime_status == RPM_SUSPENDED)
 567                 retval = 1;
 568         else if (atomic_read(&dev->power.usage_count) > 0
 569             || dev->power.disable_depth > 0)
 570                 retval = -EAGAIN;
 571         else if (dev->power.runtime_status == RPM_SUSPENDING)
 572                 retval = -EINPROGRESS;
 573         else if (!pm_children_suspended(dev))
 574                 retval = -EBUSY;
 575         if (retval < 0)
 576                 return retval;
 577
 578         pm_runtime_deactivate_timer(dev);
 579
 580         if (dev->power.request_pending) {
 581                 /*
 582                  * Pending resume requests take precedence over us, but we can
 583                  * overtake any other pending request.
 584                  */
 585                 if (dev->power.request == RPM_REQ_RESUME)
 586                         retval = -EAGAIN;
 587                 else if (dev->power.request != RPM_REQ_SUSPEND)
 588                         dev->power.request = retval ?
 589                                                 RPM_REQ_NONE : RPM_REQ_SUSPEND;
 590                 return retval;
 591         } else if (retval) {
 592                 return retval;
 593         }
 594
 595         dev->power.request = RPM_REQ_SUSPEND;
 596         dev->power.request_pending = true;
 597         queue_work(pm_wq, &dev->power.work);
 598
 599         return 0;
 600 }
 601
 602 /**
 603  * pm_suspend_timer_fn - Timer function for pm_schedule_suspend().
 604  * @data: Device pointer passed by pm_schedule_suspend().
 605  *
 606  * Check if the time is right and execute __pm_request_suspend() in that case.
 607  */
 608 static void pm_suspend_timer_fn(unsigned long data)
 609 {
 610         struct device *dev = (struct device *)data;
 611         unsigned long flags;
 612         unsigned long expires;
 613
 614         spin_lock_irqsave(&dev->power.lock, flags);
 615
 616         expires = dev->power.timer_expires;
 617         /* If 'expire' is after 'jiffies' we've been called too early. */
 618         if (expires > 0 && !time_after(expires, jiffies)) {
 619                 dev->power.timer_expires = 0;
 620                 __pm_request_suspend(dev);
 621         }
 622
 623         spin_unlock_irqrestore(&dev->power.lock, flags);
 624 }
 625
 626 /**
 627  * pm_schedule_suspend - Set up a timer to submit a suspend request in future.
 628  * @dev: Device to suspend.
 629  * @delay: Time to wait before submitting a suspend request, in milliseconds.
 630  */
 631 int pm_schedule_suspend(struct device *dev, unsigned int delay)
 632 {
 633         unsigned long flags;
 634         int retval = 0;
 635
 636         spin_lock_irqsave(&dev->power.lock, flags);
 637
 638         if (dev->power.runtime_error) {
 639                 retval = -EINVAL;
 640                 goto out;
 641         }
 642
 643         if (!delay) {
 644                 retval = __pm_request_suspend(dev);
 645                 goto out;
 646         }
 647
 648         pm_runtime_deactivate_timer(dev);
 649
 650         if (dev->power.request_pending) {
 651                 /*
 652                  * Pending resume requests take precedence over us, but any
 653                  * other pending requests have to be canceled.
 654                  */
 655                 if (dev->power.request == RPM_REQ_RESUME) {
 656                         retval = -EAGAIN;
 657                         goto out;
 658                 }
 659                 dev->power.request = RPM_REQ_NONE;
 660         }
 661
 662         if (dev->power.runtime_status == RPM_SUSPENDED)
 663                 retval = 1;
 664         else if (atomic_read(&dev->power.usage_count) > 0
 665             || dev->power.disable_depth > 0)
 666                 retval = -EAGAIN;
 667         else if (!pm_children_suspended(dev))
 668                 retval = -EBUSY;
 669         if (retval)
 670                 goto out;
 671
 672         dev->power.timer_expires = jiffies + msecs_to_jiffies(delay);
 673         if (!dev->power.timer_expires)
 674                 dev->power.timer_expires = 1;
 675         mod_timer(&dev->power.suspend_timer, dev->power.timer_expires);
 676
 677  out:
 678         spin_unlock_irqrestore(&dev->power.lock, flags);
 679
 680         return retval;
 681 }
 682 EXPORT_SYMBOL_GPL(pm_schedule_suspend);
 683
 684 /**
 685  * pm_request_resume - Submit a resume request for given device.
 686  * @dev: Device to resume.
 687  *
 688  * This function must be called under dev->power.lock with interrupts disabled.
 689  */
 690 static int __pm_request_resume(struct device *dev)
 691 {
 692         int retval = 0;
 693
 694         if (dev->power.runtime_error)
 695                 return -EINVAL;
 696
 697         if (dev->power.runtime_status == RPM_ACTIVE)
 698                 retval = 1;
 699         else if (dev->power.runtime_status == RPM_RESUMING)
 700                 retval = -EINPROGRESS;
 701         else if (dev->power.disable_depth > 0)
 702                 retval = -EAGAIN;
 703         if (retval < 0)
 704                 return retval;
 705
 706         pm_runtime_deactivate_timer(dev);
 707
 708         if (dev->power.runtime_status == RPM_SUSPENDING) {
 709                 dev->power.deferred_resume = true;
 710                 return retval;
 711         }
 712         if (dev->power.request_pending) {
 713                 /* If non-resume request is pending, we can overtake it. */
 714                 dev->power.request = retval ? RPM_REQ_NONE : RPM_REQ_RESUME;
 715                 return retval;
 716         }
 717         if (retval)
 718                 return retval;
 719
 720         dev->power.request = RPM_REQ_RESUME;
 721         dev->power.request_pending = true;
 722         queue_work(pm_wq, &dev->power.work);
 723
 724         return retval;
 725 }
 726
 727 /**
 728  * pm_request_resume - Submit a resume request for given device.
 729  * @dev: Device to resume.
 730  */
 731 int pm_request_resume(struct device *dev)
 732 {
 733         unsigned long flags;
 734         int retval;
 735
 736         spin_lock_irqsave(&dev->power.lock, flags);
 737         retval = __pm_request_resume(dev);
 738         spin_unlock_irqrestore(&dev->power.lock, flags);
 739
 740         return retval;
 741 }
 742 EXPORT_SYMBOL_GPL(pm_request_resume);
 743
 744 /**
 745  * __pm_runtime_get - Reference count a device and wake it up, if necessary.
 746  * @dev: Device to handle.
 747  * @sync: If set and the device is suspended, resume it synchronously.
 748  *
 749  * Increment the usage count of the device and resume it or submit a resume
 750  * request for it, depending on the value of @sync.
 751  */
 752 int __pm_runtime_get(struct device *dev, bool sync)
 753 {
 754         int retval;
 755
 756         atomic_inc(&dev->power.usage_count);
 757         retval = sync ? pm_runtime_resume(dev) : pm_request_resume(dev);
 758
 759         return retval;
 760 }
 761 EXPORT_SYMBOL_GPL(__pm_runtime_get);
 762
 763 /**
 764  * __pm_runtime_put - Decrement the device's usage counter and notify its bus.
 765  * @dev: Device to handle.
 766  * @sync: If the device's bus type is to be notified, do that synchronously.
 767  *
 768  * Decrement the usage count of the device and if it reaches zero, carry out a
 769  * synchronous idle notification or submit an idle notification request for it,
 770  * depending on the value of @sync.
 771  */
 772 int __pm_runtime_put(struct device *dev, bool sync)
 773 {
 774         int retval = 0;
 775
 776         if (atomic_dec_and_test(&dev->power.usage_count))
 777                 retval = sync ? pm_runtime_idle(dev) : pm_request_idle(dev);
 778
 779         return retval;
 780 }
 781 EXPORT_SYMBOL_GPL(__pm_runtime_put);
 782
 783 /**
 784  * __pm_runtime_set_status - Set run-time PM status of a device.
 785  * @dev: Device to handle.
 786  * @status: New run-time PM status of the device.
 787  *
 788  * If run-time PM of the device is disabled or its power.runtime_error field is
 789  * different from zero, the status may be changed either to RPM_ACTIVE, or to
 790  * RPM_SUSPENDED, as long as that reflects the actual state of the device.
 791  * However, if the device has a parent and the parent is not active, and the
 792  * parent's power.ignore_children flag is unset, the device's status cannot be
 793  * set to RPM_ACTIVE, so -EBUSY is returned in that case.
 794  *
 795  * If successful, __pm_runtime_set_status() clears the power.runtime_error field
 796  * and the device parent's counter of unsuspended children is modified to
 797  * reflect the new status.  If the new status is RPM_SUSPENDED, an idle
 798  * notification request for the parent is submitted.
 799  */
 800 int __pm_runtime_set_status(struct device *dev, unsigned int status)
 801 {
 802         struct device *parent = dev->parent;
 803         unsigned long flags;
 804         bool notify_parent = false;
 805         int error = 0;
 806
 807         if (status != RPM_ACTIVE && status != RPM_SUSPENDED)
 808                 return -EINVAL;
 809
 810         spin_lock_irqsave(&dev->power.lock, flags);
 811
 812         if (!dev->power.runtime_error && !dev->power.disable_depth) {
 813                 error = -EAGAIN;
 814                 goto out;
 815         }
 816
 817         if (dev->power.runtime_status == status)
 818                 goto out_set;
 819
 820         if (status == RPM_SUSPENDED) {
 821                 /* It always is possible to set the status to 'suspended'. */
 822                 if (parent) {
 823                         atomic_add_unless(&parent->power.child_count, -1, 0);
 824                         notify_parent = !parent->power.ignore_children;
 825                 }
 826                 goto out_set;
 827         }
 828
 829         if (parent) {
 830                 spin_lock_nested(&parent->power.lock, SINGLE_DEPTH_NESTING);
 831
 832                 /*
 833                  * It is invalid to put an active child under a parent that is
 834                  * not active, has run-time PM enabled and the
 835                  * 'power.ignore_children' flag unset.
 836                  */
 837                 if (!parent->power.disable_depth
 838                     && !parent->power.ignore_children
 839                     && parent->power.runtime_status != RPM_ACTIVE)
 840                         error = -EBUSY;
 841                 else if (dev->power.runtime_status == RPM_SUSPENDED)
 842                         atomic_inc(&parent->power.child_count);
 843
 844                 spin_unlock(&parent->power.lock);
 845
 846                 if (error)
 847                         goto out;
 848         }
 849
 850  out_set:
 851         dev->power.runtime_status = status;
 852         dev->power.runtime_error = 0;
 853  out:
 854         spin_unlock_irqrestore(&dev->power.lock, flags);
 855
 856         if (notify_parent)
 857                 pm_request_idle(parent);
 858
 859         return error;
 860 }
 861 EXPORT_SYMBOL_GPL(__pm_runtime_set_status);
 862
 863 /**
 864  * __pm_runtime_barrier - Cancel pending requests and wait for completions.
 865  * @dev: Device to handle.
 866  *
 867  * Flush all pending requests for the device from pm_wq and wait for all
 868  * run-time PM operations involving the device in progress to complete.
 869  *
 870  * Should be called under dev->power.lock with interrupts disabled.
 871  */
 872 static void __pm_runtime_barrier(struct device *dev)
 873 {
 874         pm_runtime_deactivate_timer(dev);
 875
 876         if (dev->power.request_pending) {
 877                 dev->power.request = RPM_REQ_NONE;
 878                 spin_unlock_irq(&dev->power.lock);
 879
 880                 cancel_work_sync(&dev->power.work);
 881
 882                 spin_lock_irq(&dev->power.lock);
 883                 dev->power.request_pending = false;
 884         }
 885
 886         if (dev->power.runtime_status == RPM_SUSPENDING
 887             || dev->power.runtime_status == RPM_RESUMING
 888             || dev->power.idle_notification) {
 889                 DEFINE_WAIT(wait);
 890
 891                 /* Suspend, wake-up or idle notification in progress. */
 892                 for (;;) {
 893                         prepare_to_wait(&dev->power.wait_queue, &wait,
 894                                         TASK_UNINTERRUPTIBLE);
 895                         if (dev->power.runtime_status != RPM_SUSPENDING
 896                             && dev->power.runtime_status != RPM_RESUMING
 897                             && !dev->power.idle_notification)
 898                                 break;
 899                         spin_unlock_irq(&dev->power.lock);
 900
 901                         schedule();
 902
 903                         spin_lock_irq(&dev->power.lock);
 904                 }
 905                 finish_wait(&dev->power.wait_queue, &wait);
 906         }
 907 }
 908
 909 /**
 910  * pm_runtime_barrier - Flush pending requests and wait for completions.
 911  * @dev: Device to handle.
 912  *
 913  * Prevent the device from being suspended by incrementing its usage counter and
 914  * if there's a pending resume request for the device, wake the device up.
 915  * Next, make sure that all pending requests for the device have been flushed
 916  * from pm_wq and wait for all run-time PM operations involving the device in
 917  * progress to complete.
 918  *
 919  * Return value:
 920  * 1, if there was a resume request pending and the device had to be woken up,
 921  * 0, otherwise
 922  */
 923 int pm_runtime_barrier(struct device *dev)
 924 {
 925         int retval = 0;
 926
 927         pm_runtime_get_noresume(dev);
 928         spin_lock_irq(&dev->power.lock);
 929
 930         if (dev->power.request_pending
 931             && dev->power.request == RPM_REQ_RESUME) {
 932                 __pm_runtime_resume(dev, false);
 933                 retval = 1;
 934         }
 935
 936         __pm_runtime_barrier(dev);
 937
 938         spin_unlock_irq(&dev->power.lock);
 939         pm_runtime_put_noidle(dev);
 940
 941         return retval;
 942 }
 943 EXPORT_SYMBOL_GPL(pm_runtime_barrier);
 944
 945 /**
 946  * __pm_runtime_disable - Disable run-time PM of a device.
 947  * @dev: Device to handle.
 948  * @check_resume: If set, check if there's a resume request for the device.
 949  *
 950  * Increment power.disable_depth for the device and if was zero previously,
 951  * cancel all pending run-time PM requests for the device and wait for all
 952  * operations in progress to complete.  The device can be either active or
 953  * suspended after its run-time PM has been disabled.
 954  *
 955  * If @check_resume is set and there's a resume request pending when
 956  * __pm_runtime_disable() is called and power.disable_depth is zero, the
 957  * function will wake up the device before disabling its run-time PM.
 958  */
 959 void __pm_runtime_disable(struct device *dev, bool check_resume)
 960 {
 961         spin_lock_irq(&dev->power.lock);
 962
 963         if (dev->power.disable_depth > 0) {
 964                 dev->power.disable_depth++;
 965                 goto out;
 966         }
 967
 968         /*
 969          * Wake up the device if there's a resume request pending, because that
 970          * means there probably is some I/O to process and disabling run-time PM
 971          * shouldn't prevent the device from processing the I/O.
 972          */
 973         if (check_resume && dev->power.request_pending
 974             && dev->power.request == RPM_REQ_RESUME) {
 975                 /*
 976                  * Prevent suspends and idle notifications from being carried
 977                  * out after we have woken up the device.
 978                  */
 979                 pm_runtime_get_noresume(dev);
 980
 981                 __pm_runtime_resume(dev, false);
 982
 983                 pm_runtime_put_noidle(dev);
 984         }
 985
 986         if (!dev->power.disable_depth++)
 987                 __pm_runtime_barrier(dev);
 988
 989  out:
 990         spin_unlock_irq(&dev->power.lock);
 991 }
 992 EXPORT_SYMBOL_GPL(__pm_runtime_disable);
 993
 994 /**
 995  * pm_runtime_enable - Enable run-time PM of a device.
 996  * @dev: Device to handle.
 997  */
 998 void pm_runtime_enable(struct device *dev)
 999 {
1000         unsigned long flags;
1001
1002         spin_lock_irqsave(&dev->power.lock, flags);
1003
1004         if (dev->power.disable_depth > 0)
1005                 dev->power.disable_depth--;
1006         else
1007                 dev_warn(dev, "Unbalanced %s!\n", __func__);
1008
1009         spin_unlock_irqrestore(&dev->power.lock, flags);
1010 }
1011 EXPORT_SYMBOL_GPL(pm_runtime_enable);
1012
1013 /**
1014  * pm_runtime_forbid - Block run-time PM of a device.
1015  * @dev: Device to handle.
1016  *
1017  * Increase the device's usage count and clear its power.runtime_auto flag,
1018  * so that it cannot be suspended at run time until pm_runtime_allow() is called
1019  * for it.
1020  */
1021 void pm_runtime_forbid(struct device *dev)
1022 {
1023         spin_lock_irq(&dev->power.lock);
1024         if (!dev->power.runtime_auto)
1025                 goto out;
1026
1027         dev->power.runtime_auto = false;
1028         atomic_inc(&dev->power.usage_count);
1029         __pm_runtime_resume(dev, false);
1030
1031  out:
1032         spin_unlock_irq(&dev->power.lock);
1033 }
1034 EXPORT_SYMBOL_GPL(pm_runtime_forbid);
1035
1036 /**
1037  * pm_runtime_allow - Unblock run-time PM of a device.
1038  * @dev: Device to handle.
1039  *
1040  * Decrease the device's usage count and set its power.runtime_auto flag.
1041  */
1042 void pm_runtime_allow(struct device *dev)
1043 {
1044         spin_lock_irq(&dev->power.lock);
1045         if (dev->power.runtime_auto)
1046                 goto out;
1047
1048         dev->power.runtime_auto = true;
1049         if (atomic_dec_and_test(&dev->power.usage_count))
1050                 __pm_runtime_idle(dev);
1051
1052  out:
1053         spin_unlock_irq(&dev->power.lock);
1054 }
1055 EXPORT_SYMBOL_GPL(pm_runtime_allow);
1056
1057 /**
1058  * pm_runtime_init - Initialize run-time PM fields in given device object.
1059  * @dev: Device object to initialize.
1060  */
1061 void pm_runtime_init(struct device *dev)
1062 {
1063         spin_lock_init(&dev->power.lock);
1064
1065         dev->power.runtime_status = RPM_SUSPENDED;
1066         dev->power.idle_notification = false;
1067
1068         dev->power.disable_depth = 1;
1069         atomic_set(&dev->power.usage_count, 0);
1070
1071         dev->power.runtime_error = 0;
1072
1073         atomic_set(&dev->power.child_count, 0);
1074         pm_suspend_ignore_children(dev, false);
1075         dev->power.runtime_auto = true;
1076
1077         dev->power.request_pending = false;
1078         dev->power.request = RPM_REQ_NONE;
1079         dev->power.deferred_resume = false;
1080         INIT_WORK(&dev->power.work, pm_runtime_work);
1081
1082         dev->power.timer_expires = 0;
1083         setup_timer(&dev->power.suspend_timer, pm_suspend_timer_fn,
1084                         (unsigned long)dev);
1085
1086         init_waitqueue_head(&dev->power.wait_queue);
1087 }
1088
1089 /**
1090  * pm_runtime_remove - Prepare for removing a device from device hierarchy.
1091  * @dev: Device object being removed from device hierarchy.
1092  */
1093 void pm_runtime_remove(struct device *dev)
1094 {
1095         __pm_runtime_disable(dev, false);
1096
1097         /* Change the status back to 'suspended' to match the initial status. */
1098         if (dev->power.runtime_status == RPM_ACTIVE)
1099                 pm_runtime_set_suspended(dev);
1100 }