3  * drivers/base/power/runtime.c - Helper functions for device runtime PM
18 #include "power.h"
56  * update_pm_runtime_accounting - Update the time accounting of power states
59  * In order to be able to have time accounting of the various power states
70 	if (dev->power.disable_depth > 0)  in update_pm_runtime_accounting()
73 	last = dev->power.accounting_timestamp;  in update_pm_runtime_accounting()
76 	dev->power.accounting_timestamp = now;  in update_pm_runtime_accounting()
88 	if (dev->power.runtime_status == RPM_SUSPENDED)  in update_pm_runtime_accounting()
89 		dev->power.suspended_time += delta;  in update_pm_runtime_accounting()
91 		dev->power.active_time += delta;  in update_pm_runtime_accounting()
98 	dev->power.runtime_status = status;  in __update_runtime_status()
106 	spin_lock_irqsave(&dev->power.lock, flags);  in rpm_get_accounted_time()
109 	time = suspended ? dev->power.suspended_time : dev->power.active_time;  in rpm_get_accounted_time()
111 	spin_unlock_irqrestore(&dev->power.lock, flags);  in rpm_get_accounted_time()
133 	if (dev->power.timer_expires > 0) {  in pm_runtime_deactivate_timer()
134 		hrtimer_try_to_cancel(&dev->power.suspend_timer);  in pm_runtime_deactivate_timer()
135 		dev->power.timer_expires = 0;  in pm_runtime_deactivate_timer()
150 	dev->power.request = RPM_REQ_NONE;  in pm_runtime_cancel_pending()
158  * power.last_busy time.  If the delay has already expired or is disabled
159  * (negative) or the power.use_autosuspend flag isn't set, return 0.
162  * This function may be called either with or without dev->power.lock held.
163  * Either way it can be racy, since power.last_busy may be updated at any time.
170 	if (!dev->power.use_autosuspend)  in pm_runtime_autosuspend_expiration()
173 	autosuspend_delay = READ_ONCE(dev->power.autosuspend_delay);  in pm_runtime_autosuspend_expiration()
177 	expires  = READ_ONCE(dev->power.last_busy);  in pm_runtime_autosuspend_expiration()
188 	return dev->power.memalloc_noio;  in dev_memalloc_noio()
227 		/* hold power lock since bitfield is not SMP-safe. */  in pm_runtime_set_memalloc_noio()
228 		spin_lock_irq(&dev->power.lock);  in pm_runtime_set_memalloc_noio()
229 		enabled = dev->power.memalloc_noio;  in pm_runtime_set_memalloc_noio()
230 		dev->power.memalloc_noio = enable;  in pm_runtime_set_memalloc_noio()
231 		spin_unlock_irq(&dev->power.lock);  in pm_runtime_set_memalloc_noio()
263 	if (dev->power.runtime_error)  in rpm_check_suspend_allowed()
265 	else if (dev->power.disable_depth > 0)  in rpm_check_suspend_allowed()
267 	else if (atomic_read(&dev->power.usage_count))  in rpm_check_suspend_allowed()
269 	else if (!dev->power.ignore_children && atomic_read(&dev->power.child_count))  in rpm_check_suspend_allowed()
273 	else if ((dev->power.deferred_resume &&  in rpm_check_suspend_allowed()
274 	    dev->power.runtime_status == RPM_SUSPENDING) ||  in rpm_check_suspend_allowed()
275 	    (dev->power.request_pending && dev->power.request == RPM_REQ_RESUME))  in rpm_check_suspend_allowed()
279 	else if (dev->power.runtime_status == RPM_SUSPENDED)  in rpm_check_suspend_allowed()
318 	 * The additional power.usage_count check is a safety net in case  in pm_runtime_release_supplier()
324 	       atomic_read(&supplier->power.usage_count) > 0)  in pm_runtime_release_supplier()
363 	__releases(&dev->power.lock) __acquires(&dev->power.lock)  in __rpm_callback()
366 	bool use_links = dev->power.links_count > 0;  in __rpm_callback()
368 	if (dev->power.irq_safe) {  in __rpm_callback()
369 		spin_unlock(&dev->power.lock);  in __rpm_callback()
371 		spin_unlock_irq(&dev->power.lock);  in __rpm_callback()
380 		if (use_links && dev->power.runtime_status == RPM_RESUMING) {  in __rpm_callback()
396 	if (dev->power.irq_safe) {  in __rpm_callback()
397 		spin_lock(&dev->power.lock);  in __rpm_callback()
407 		    ((dev->power.runtime_status == RPM_SUSPENDING && !retval) ||  in __rpm_callback()
408 		    (dev->power.runtime_status == RPM_RESUMING && retval))) {  in __rpm_callback()
417 		spin_lock_irq(&dev->power.lock);  in __rpm_callback()
432 	if (dev->power.memalloc_noio) {  in rpm_callback()
461 		dev->power.runtime_error = retval;  in rpm_callback()
477  * This function must be called under dev->power.lock with interrupts disabled.
490 	else if (dev->power.runtime_status != RPM_ACTIVE)  in rpm_idle()
497 	else if (dev->power.request_pending &&  in rpm_idle()
498 	    dev->power.request > RPM_REQ_IDLE)  in rpm_idle()
502 	else if (dev->power.idle_notification)  in rpm_idle()
509 	dev->power.request = RPM_REQ_NONE;  in rpm_idle()
514 	if (!callback || dev->power.no_callbacks)  in rpm_idle()
519 		dev->power.request = RPM_REQ_IDLE;  in rpm_idle()
520 		if (!dev->power.request_pending) {  in rpm_idle()
521 			dev->power.request_pending = true;  in rpm_idle()
522 			queue_work(pm_wq, &dev->power.work);  in rpm_idle()
528 	dev->power.idle_notification = true;  in rpm_idle()
530 	if (dev->power.irq_safe)  in rpm_idle()
531 		spin_unlock(&dev->power.lock);  in rpm_idle()
533 		spin_unlock_irq(&dev->power.lock);  in rpm_idle()
537 	if (dev->power.irq_safe)  in rpm_idle()
538 		spin_lock(&dev->power.lock);  in rpm_idle()
540 		spin_lock_irq(&dev->power.lock);  in rpm_idle()
542 	dev->power.idle_notification = false;  in rpm_idle()
543 	wake_up_all(&dev->power.wait_queue);  in rpm_idle()
564  * ignore_children of parent->power and irq_safe of dev->power are not set).
569  * This function must be called under dev->power.lock with interrupts disabled.
572 	__releases(&dev->power.lock) __acquires(&dev->power.lock)  in rpm_suspend()
586 	if (dev->power.runtime_status == RPM_RESUMING && !(rpmflags & RPM_ASYNC))  in rpm_suspend()
593 	if ((rpmflags & RPM_AUTO) && dev->power.runtime_status != RPM_SUSPENDING) {  in rpm_suspend()
598 			dev->power.request = RPM_REQ_NONE;  in rpm_suspend()
607 			if (!(dev->power.timer_expires &&  in rpm_suspend()
608 			    dev->power.timer_expires <= expires)) {  in rpm_suspend()
613 				u64 slack = (u64)READ_ONCE(dev->power.autosuspend_delay) *  in rpm_suspend()
616 				dev->power.timer_expires = expires;  in rpm_suspend()
617 				hrtimer_start_range_ns(&dev->power.suspend_timer,  in rpm_suspend()
622 			dev->power.timer_autosuspends = 1;  in rpm_suspend()
630 	if (dev->power.runtime_status == RPM_SUSPENDING) {  in rpm_suspend()
638 		if (dev->power.irq_safe) {  in rpm_suspend()
639 			spin_unlock(&dev->power.lock);  in rpm_suspend()
643 			spin_lock(&dev->power.lock);  in rpm_suspend()
649 			prepare_to_wait(&dev->power.wait_queue, &wait,  in rpm_suspend()
651 			if (dev->power.runtime_status != RPM_SUSPENDING)  in rpm_suspend()
654 			spin_unlock_irq(&dev->power.lock);  in rpm_suspend()
658 			spin_lock_irq(&dev->power.lock);  in rpm_suspend()
660 		finish_wait(&dev->power.wait_queue, &wait);  in rpm_suspend()
664 	if (dev->power.no_callbacks)  in rpm_suspend()
669 		dev->power.request = (rpmflags & RPM_AUTO) ?  in rpm_suspend()
671 		if (!dev->power.request_pending) {  in rpm_suspend()
672 			dev->power.request_pending = true;  in rpm_suspend()
673 			queue_work(pm_wq, &dev->power.work);  in rpm_suspend()
695 		atomic_add_unless(&parent->power.child_count, -1, 0);  in rpm_suspend()
697 	wake_up_all(&dev->power.wait_queue);  in rpm_suspend()
699 	if (dev->power.deferred_resume) {  in rpm_suspend()
700 		dev->power.deferred_resume = false;  in rpm_suspend()
706 	if (dev->power.irq_safe)  in rpm_suspend()
710 	if (parent && !parent->power.ignore_children) {  in rpm_suspend()
711 		spin_unlock(&dev->power.lock);  in rpm_suspend()
713 		spin_lock(&parent->power.lock);  in rpm_suspend()
715 		spin_unlock(&parent->power.lock);  in rpm_suspend()
717 		spin_lock(&dev->power.lock);  in rpm_suspend()
720 	if (dev->power.links_count > 0) {  in rpm_suspend()
721 		spin_unlock_irq(&dev->power.lock);  in rpm_suspend()
725 		spin_lock_irq(&dev->power.lock);  in rpm_suspend()
736 	dev->power.deferred_resume = false;  in rpm_suspend()
737 	wake_up_all(&dev->power.wait_queue);  in rpm_suspend()
745 	if (!dev->power.runtime_error && (rpmflags & RPM_AUTO) &&  in rpm_suspend()
769  * This function must be called under dev->power.lock with interrupts disabled.
772 	__releases(&dev->power.lock) __acquires(&dev->power.lock)  in rpm_resume()
781 	if (dev->power.runtime_error) {  in rpm_resume()
783 	} else if (dev->power.disable_depth > 0) {  in rpm_resume()
784 		if (dev->power.runtime_status == RPM_ACTIVE &&  in rpm_resume()
785 		    dev->power.last_status == RPM_ACTIVE)  in rpm_resume()
799 	dev->power.request = RPM_REQ_NONE;  in rpm_resume()
800 	if (!dev->power.timer_autosuspends)  in rpm_resume()
803 	if (dev->power.runtime_status == RPM_ACTIVE) {  in rpm_resume()
808 	if (dev->power.runtime_status == RPM_RESUMING ||  in rpm_resume()
809 	    dev->power.runtime_status == RPM_SUSPENDING) {  in rpm_resume()
813 			if (dev->power.runtime_status == RPM_SUSPENDING) {  in rpm_resume()
814 				dev->power.deferred_resume = true;  in rpm_resume()
823 		if (dev->power.irq_safe) {  in rpm_resume()
824 			spin_unlock(&dev->power.lock);  in rpm_resume()
828 			spin_lock(&dev->power.lock);  in rpm_resume()
834 			prepare_to_wait(&dev->power.wait_queue, &wait,  in rpm_resume()
836 			if (dev->power.runtime_status != RPM_RESUMING &&  in rpm_resume()
837 			    dev->power.runtime_status != RPM_SUSPENDING)  in rpm_resume()
840 			spin_unlock_irq(&dev->power.lock);  in rpm_resume()
844 			spin_lock_irq(&dev->power.lock);  in rpm_resume()
846 		finish_wait(&dev->power.wait_queue, &wait);  in rpm_resume()
852 	 * power.no_callbacks is set, because otherwise we don't know whether  in rpm_resume()
855 	if (dev->power.no_callbacks && !parent && dev->parent) {  in rpm_resume()
856 		spin_lock_nested(&dev->parent->power.lock, SINGLE_DEPTH_NESTING);  in rpm_resume()
857 		if (dev->parent->power.disable_depth > 0 ||  in rpm_resume()
858 		    dev->parent->power.ignore_children ||  in rpm_resume()
859 		    dev->parent->power.runtime_status == RPM_ACTIVE) {  in rpm_resume()
860 			atomic_inc(&dev->parent->power.child_count);  in rpm_resume()
861 			spin_unlock(&dev->parent->power.lock);  in rpm_resume()
865 		spin_unlock(&dev->parent->power.lock);  in rpm_resume()
870 		dev->power.request = RPM_REQ_RESUME;  in rpm_resume()
871 		if (!dev->power.request_pending) {  in rpm_resume()
872 			dev->power.request_pending = true;  in rpm_resume()
873 			queue_work(pm_wq, &dev->power.work);  in rpm_resume()
886 		if (dev->power.irq_safe)  in rpm_resume()
889 		spin_unlock(&dev->power.lock);  in rpm_resume()
893 		spin_lock(&parent->power.lock);  in rpm_resume()
898 		if (!parent->power.disable_depth &&  in rpm_resume()
899 		    !parent->power.ignore_children) {  in rpm_resume()
901 			if (parent->power.runtime_status != RPM_ACTIVE)  in rpm_resume()
904 		spin_unlock(&parent->power.lock);  in rpm_resume()
906 		spin_lock(&dev->power.lock);  in rpm_resume()
914 	if (dev->power.no_callbacks)  in rpm_resume()
932 			atomic_inc(&parent->power.child_count);  in rpm_resume()
934 	wake_up_all(&dev->power.wait_queue);  in rpm_resume()
940 	if (parent && !dev->power.irq_safe) {  in rpm_resume()
941 		spin_unlock_irq(&dev->power.lock);  in rpm_resume()
945 		spin_lock_irq(&dev->power.lock);  in rpm_resume()
962 	struct device *dev = container_of(work, struct device, power.work);  in pm_runtime_work()
965 	spin_lock_irq(&dev->power.lock);  in pm_runtime_work()
967 	if (!dev->power.request_pending)  in pm_runtime_work()
970 	req = dev->power.request;  in pm_runtime_work()
971 	dev->power.request = RPM_REQ_NONE;  in pm_runtime_work()
972 	dev->power.request_pending = false;  in pm_runtime_work()
992 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_work()
1003 	struct device *dev = container_of(timer, struct device, power.suspend_timer);  in pm_suspend_timer_fn()
1007 	spin_lock_irqsave(&dev->power.lock, flags);  in pm_suspend_timer_fn()
1009 	expires = dev->power.timer_expires;  in pm_suspend_timer_fn()
1015 		dev->power.timer_expires = 0;  in pm_suspend_timer_fn()
1016 		rpm_suspend(dev, dev->power.timer_autosuspends ?  in pm_suspend_timer_fn()
1020 	spin_unlock_irqrestore(&dev->power.lock, flags);  in pm_suspend_timer_fn()
1036 	spin_lock_irqsave(&dev->power.lock, flags);  in pm_schedule_suspend()
1051 	dev->power.timer_expires = expires;  in pm_schedule_suspend()
1052 	dev->power.timer_autosuspends = 0;  in pm_schedule_suspend()
1053 	hrtimer_start(&dev->power.suspend_timer, expires, HRTIMER_MODE_ABS);  in pm_schedule_suspend()
1056 	spin_unlock_irqrestore(&dev->power.lock, flags);  in pm_schedule_suspend()
1066 	ret = atomic_sub_return(1, &dev->power.usage_count);  in rpm_drop_usage_count()
1076 	atomic_inc(&dev->power.usage_count);  in rpm_drop_usage_count()
1109 	might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe);  in __pm_runtime_idle()
1111 	spin_lock_irqsave(&dev->power.lock, flags);  in __pm_runtime_idle()
1113 	spin_unlock_irqrestore(&dev->power.lock, flags);  in __pm_runtime_idle()
1147 	might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe);  in __pm_runtime_suspend()
1149 	spin_lock_irqsave(&dev->power.lock, flags);  in __pm_runtime_suspend()
1151 	spin_unlock_irqrestore(&dev->power.lock, flags);  in __pm_runtime_suspend()
1173 	might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe &&  in __pm_runtime_resume()
1174 			dev->power.runtime_status != RPM_ACTIVE);  in __pm_runtime_resume()
1177 		atomic_inc(&dev->power.usage_count);  in __pm_runtime_resume()
1179 	spin_lock_irqsave(&dev->power.lock, flags);  in __pm_runtime_resume()
1181 	spin_unlock_irqrestore(&dev->power.lock, flags);  in __pm_runtime_resume()
1214 	spin_lock_irqsave(&dev->power.lock, flags);  in pm_runtime_get_conditional()
1215 	if (dev->power.disable_depth > 0) {  in pm_runtime_get_conditional()
1217 	} else if (dev->power.runtime_status != RPM_ACTIVE) {  in pm_runtime_get_conditional()
1221 		atomic_inc(&dev->power.usage_count);  in pm_runtime_get_conditional()
1223 		retval = atomic_inc_not_zero(&dev->power.usage_count);  in pm_runtime_get_conditional()
1226 	spin_unlock_irqrestore(&dev->power.lock, flags);  in pm_runtime_get_conditional()
1268  * If runtime PM of the device is disabled or its power.runtime_error field is
1272  * parent's power.ignore_children flag is unset, the device's status cannot be
1275  * If successful, __pm_runtime_set_status() clears the power.runtime_error field
1297 	spin_lock_irqsave(&dev->power.lock, flags);  in __pm_runtime_set_status()
1303 	if (dev->power.runtime_error || dev->power.disable_depth)  in __pm_runtime_set_status()
1304 		dev->power.disable_depth++;  in __pm_runtime_set_status()
1308 	spin_unlock_irqrestore(&dev->power.lock, flags);  in __pm_runtime_set_status()
1329 	spin_lock_irqsave(&dev->power.lock, flags);  in __pm_runtime_set_status()
1331 	if (dev->power.runtime_status == status || !parent)  in __pm_runtime_set_status()
1335 		atomic_add_unless(&parent->power.child_count, -1, 0);  in __pm_runtime_set_status()
1336 		notify_parent = !parent->power.ignore_children;  in __pm_runtime_set_status()
1338 		spin_lock_nested(&parent->power.lock, SINGLE_DEPTH_NESTING);  in __pm_runtime_set_status()
1343 		 * 'power.ignore_children' flag unset.  in __pm_runtime_set_status()
1345 		if (!parent->power.disable_depth &&  in __pm_runtime_set_status()
1346 		    !parent->power.ignore_children &&  in __pm_runtime_set_status()
1347 		    parent->power.runtime_status != RPM_ACTIVE) {  in __pm_runtime_set_status()
1352 		} else if (dev->power.runtime_status == RPM_SUSPENDED) {  in __pm_runtime_set_status()
1353 			atomic_inc(&parent->power.child_count);  in __pm_runtime_set_status()
1356 		spin_unlock(&parent->power.lock);  in __pm_runtime_set_status()
1367 		dev->power.runtime_error = 0;  in __pm_runtime_set_status()
1370 	spin_unlock_irqrestore(&dev->power.lock, flags);  in __pm_runtime_set_status()
1396  * Should be called under dev->power.lock with interrupts disabled.
1402 	if (dev->power.request_pending) {  in __pm_runtime_barrier()
1403 		dev->power.request = RPM_REQ_NONE;  in __pm_runtime_barrier()
1404 		spin_unlock_irq(&dev->power.lock);  in __pm_runtime_barrier()
1406 		cancel_work_sync(&dev->power.work);  in __pm_runtime_barrier()
1408 		spin_lock_irq(&dev->power.lock);  in __pm_runtime_barrier()
1409 		dev->power.request_pending = false;  in __pm_runtime_barrier()
1412 	if (dev->power.runtime_status == RPM_SUSPENDING ||  in __pm_runtime_barrier()
1413 	    dev->power.runtime_status == RPM_RESUMING ||  in __pm_runtime_barrier()
1414 	    dev->power.idle_notification) {  in __pm_runtime_barrier()
1419 			prepare_to_wait(&dev->power.wait_queue, &wait,  in __pm_runtime_barrier()
1421 			if (dev->power.runtime_status != RPM_SUSPENDING  in __pm_runtime_barrier()
1422 			    && dev->power.runtime_status != RPM_RESUMING  in __pm_runtime_barrier()
1423 			    && !dev->power.idle_notification)  in __pm_runtime_barrier()
1425 			spin_unlock_irq(&dev->power.lock);  in __pm_runtime_barrier()
1429 			spin_lock_irq(&dev->power.lock);  in __pm_runtime_barrier()
1431 		finish_wait(&dev->power.wait_queue, &wait);  in __pm_runtime_barrier()
1454 	spin_lock_irq(&dev->power.lock);  in pm_runtime_barrier()
1456 	if (dev->power.request_pending  in pm_runtime_barrier()
1457 	    && dev->power.request == RPM_REQ_RESUME) {  in pm_runtime_barrier()
1464 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_barrier()
1475 	spin_lock_irq(&dev->power.lock);  in pm_runtime_block_if_disabled()
1478 	if (ret && dev->power.last_status == RPM_INVALID)  in pm_runtime_block_if_disabled()
1479 		dev->power.last_status = RPM_BLOCKED;  in pm_runtime_block_if_disabled()
1481 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_block_if_disabled()
1488 	spin_lock_irq(&dev->power.lock);  in pm_runtime_unblock()
1490 	if (dev->power.last_status == RPM_BLOCKED)  in pm_runtime_unblock()
1491 		dev->power.last_status = RPM_INVALID;  in pm_runtime_unblock()
1493 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_unblock()
1498 	spin_lock_irq(&dev->power.lock);  in __pm_runtime_disable()
1500 	if (dev->power.disable_depth > 0) {  in __pm_runtime_disable()
1501 		dev->power.disable_depth++;  in __pm_runtime_disable()
1510 	if (check_resume && dev->power.request_pending &&  in __pm_runtime_disable()
1511 	    dev->power.request == RPM_REQ_RESUME) {  in __pm_runtime_disable()
1526 	if (!dev->power.disable_depth++) {  in __pm_runtime_disable()
1528 		dev->power.last_status = dev->power.runtime_status;  in __pm_runtime_disable()
1532 	spin_unlock_irq(&dev->power.lock);  in __pm_runtime_disable()
1544 	spin_lock_irqsave(&dev->power.lock, flags);  in pm_runtime_enable()
1546 	if (!dev->power.disable_depth) {  in pm_runtime_enable()
1551 	if (--dev->power.disable_depth > 0)  in pm_runtime_enable()
1554 	if (dev->power.last_status == RPM_BLOCKED) {  in pm_runtime_enable()
1558 	dev->power.last_status = RPM_INVALID;  in pm_runtime_enable()
1559 	dev->power.accounting_timestamp = ktime_get_mono_fast_ns();  in pm_runtime_enable()
1561 	if (dev->power.runtime_status == RPM_SUSPENDED &&  in pm_runtime_enable()
1562 	    !dev->power.ignore_children &&  in pm_runtime_enable()
1563 	    atomic_read(&dev->power.child_count) > 0)  in pm_runtime_enable()
1567 	spin_unlock_irqrestore(&dev->power.lock, flags);  in pm_runtime_enable()
1597  * Increase the device's usage count and clear its power.runtime_auto flag,
1603 	spin_lock_irq(&dev->power.lock);  in pm_runtime_forbid()
1604 	if (!dev->power.runtime_auto)  in pm_runtime_forbid()
1607 	dev->power.runtime_auto = false;  in pm_runtime_forbid()
1608 	atomic_inc(&dev->power.usage_count);  in pm_runtime_forbid()
1612 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_forbid()
1620  * Decrease the device's usage count and set its power.runtime_auto flag.
1626 	spin_lock_irq(&dev->power.lock);  in pm_runtime_allow()
1627 	if (dev->power.runtime_auto)  in pm_runtime_allow()
1630 	dev->power.runtime_auto = true;  in pm_runtime_allow()
1638 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_allow()
1646  * Set the power.no_callbacks flag, which tells the PM core that this
1647  * device is power-managed through its parent and has no runtime PM
1652 	spin_lock_irq(&dev->power.lock);  in pm_runtime_no_callbacks()
1653 	dev->power.no_callbacks = 1;  in pm_runtime_no_callbacks()
1654 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_no_callbacks()
1664  * Set the power.irq_safe flag, which tells the PM core that the
1676 	spin_lock_irq(&dev->power.lock);  in pm_runtime_irq_safe()
1677 	dev->power.irq_safe = 1;  in pm_runtime_irq_safe()
1678 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_irq_safe()
1691  * This function must be called under dev->power.lock with interrupts disabled.
1695 	int delay = dev->power.autosuspend_delay;  in update_autosuspend()
1698 	if (dev->power.use_autosuspend && delay < 0) {  in update_autosuspend()
1702 			atomic_inc(&dev->power.usage_count);  in update_autosuspend()
1714 			atomic_dec(&dev->power.usage_count);  in update_autosuspend()
1726  * Set the device's power.autosuspend_delay value.  If it changes to negative
1727  * and the power.use_autosuspend flag is set, prevent runtime suspends.  If it
1734 	spin_lock_irq(&dev->power.lock);  in pm_runtime_set_autosuspend_delay()
1735 	old_delay = dev->power.autosuspend_delay;  in pm_runtime_set_autosuspend_delay()
1736 	old_use = dev->power.use_autosuspend;  in pm_runtime_set_autosuspend_delay()
1737 	dev->power.autosuspend_delay = delay;  in pm_runtime_set_autosuspend_delay()
1739 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_set_autosuspend_delay()
1748  * Set the device's power.use_autosuspend flag, and allow or prevent runtime
1755 	spin_lock_irq(&dev->power.lock);  in __pm_runtime_use_autosuspend()
1756 	old_delay = dev->power.autosuspend_delay;  in __pm_runtime_use_autosuspend()
1757 	old_use = dev->power.use_autosuspend;  in __pm_runtime_use_autosuspend()
1758 	dev->power.use_autosuspend = use;  in __pm_runtime_use_autosuspend()
1760 	spin_unlock_irq(&dev->power.lock);  in __pm_runtime_use_autosuspend()
1770 	dev->power.runtime_status = RPM_SUSPENDED;  in pm_runtime_init()
1771 	dev->power.last_status = RPM_INVALID;  in pm_runtime_init()
1772 	dev->power.idle_notification = false;  in pm_runtime_init()
1774 	dev->power.disable_depth = 1;  in pm_runtime_init()
1775 	atomic_set(&dev->power.usage_count, 0);  in pm_runtime_init()
1777 	dev->power.runtime_error = 0;  in pm_runtime_init()
1779 	atomic_set(&dev->power.child_count, 0);  in pm_runtime_init()
1781 	dev->power.runtime_auto = true;  in pm_runtime_init()
1783 	dev->power.request_pending = false;  in pm_runtime_init()
1784 	dev->power.request = RPM_REQ_NONE;  in pm_runtime_init()
1785 	dev->power.deferred_resume = false;  in pm_runtime_init()
1786 	dev->power.needs_force_resume = 0;  in pm_runtime_init()
1787 	INIT_WORK(&dev->power.work, pm_runtime_work);  in pm_runtime_init()
1789 	dev->power.timer_expires = 0;  in pm_runtime_init()
1790 	hrtimer_setup(&dev->power.suspend_timer, pm_suspend_timer_fn, CLOCK_MONOTONIC,  in pm_runtime_init()
1793 	init_waitqueue_head(&dev->power.wait_queue);  in pm_runtime_init()
1803 		if (dev->power.runtime_status == RPM_ACTIVE)  in pm_runtime_reinit()
1805 		if (dev->power.irq_safe) {  in pm_runtime_reinit()
1806 			spin_lock_irq(&dev->power.lock);  in pm_runtime_reinit()
1807 			dev->power.irq_safe = 0;  in pm_runtime_reinit()
1808 			spin_unlock_irq(&dev->power.lock);  in pm_runtime_reinit()
1869 	spin_lock_irq(&dev->power.lock);  in pm_runtime_new_link()
1870 	dev->power.links_count++;  in pm_runtime_new_link()
1871 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_new_link()
1876 	spin_lock_irq(&dev->power.lock);  in pm_runtime_drop_link_count()
1877 	WARN_ON(dev->power.links_count == 0);  in pm_runtime_drop_link_count()
1878 	dev->power.links_count--;  in pm_runtime_drop_link_count()
1879 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_drop_link_count()
1902 	return atomic_read(&dev->power.usage_count) <= 1 &&  in pm_runtime_need_not_resume()
1903 		(atomic_read(&dev->power.child_count) == 0 ||  in pm_runtime_need_not_resume()
1904 		 dev->power.ignore_children);  in pm_runtime_need_not_resume()
1920  * sure the device is put into low power state and it should only be used during
1956 		dev->power.needs_force_resume = 1;  in pm_runtime_force_suspend()
1973  * into low power state by a call to pm_runtime_force_suspend(). Here we reverse
1974  * those actions and bring the device into full power, if it is expected to be
1985 	if (!dev->power.needs_force_resume)  in pm_runtime_force_resume()
2006 	dev->power.needs_force_resume = 0;  in pm_runtime_force_resume()