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 } 1248