3  * drivers/base/power/runtime.c - Helper functions for device runtime PM
17 #include "power.h"
55  * update_pm_runtime_accounting - Update the time accounting of power states
58  * In order to be able to have time accounting of the various power states
69 	if (dev->power.disable_depth > 0)  in update_pm_runtime_accounting()
72 	last = dev->power.accounting_timestamp;  in update_pm_runtime_accounting()
75 	dev->power.accounting_timestamp = now;  in update_pm_runtime_accounting()
87 	if (dev->power.runtime_status == RPM_SUSPENDED)  in update_pm_runtime_accounting()
88 		dev->power.suspended_time += delta;  in update_pm_runtime_accounting()
90 		dev->power.active_time += delta;  in update_pm_runtime_accounting()
96 	dev->power.runtime_status = status;  in __update_runtime_status()
104 	spin_lock_irqsave(&dev->power.lock, flags);  in rpm_get_accounted_time()
107 	time = suspended ? dev->power.suspended_time : dev->power.active_time;  in rpm_get_accounted_time()
109 	spin_unlock_irqrestore(&dev->power.lock, flags);  in rpm_get_accounted_time()
131 	if (dev->power.timer_expires > 0) {  in pm_runtime_deactivate_timer()
132 		hrtimer_try_to_cancel(&dev->power.suspend_timer);  in pm_runtime_deactivate_timer()
133 		dev->power.timer_expires = 0;  in pm_runtime_deactivate_timer()
148 	dev->power.request = RPM_REQ_NONE;  in pm_runtime_cancel_pending()
156  * power.last_busy time.  If the delay has already expired or is disabled
157  * (negative) or the power.use_autosuspend flag isn't set, return 0.
160  * This function may be called either with or without dev->power.lock held.
161  * Either way it can be racy, since power.last_busy may be updated at any time.
168 	if (!dev->power.use_autosuspend)  in pm_runtime_autosuspend_expiration()
171 	autosuspend_delay = READ_ONCE(dev->power.autosuspend_delay);  in pm_runtime_autosuspend_expiration()
175 	expires  = READ_ONCE(dev->power.last_busy);  in pm_runtime_autosuspend_expiration()
186 	return dev->power.memalloc_noio;  in dev_memalloc_noio()
225 		/* hold power lock since bitfield is not SMP-safe. */  in pm_runtime_set_memalloc_noio()
226 		spin_lock_irq(&dev->power.lock);  in pm_runtime_set_memalloc_noio()
227 		enabled = dev->power.memalloc_noio;  in pm_runtime_set_memalloc_noio()
228 		dev->power.memalloc_noio = enable;  in pm_runtime_set_memalloc_noio()
229 		spin_unlock_irq(&dev->power.lock);  in pm_runtime_set_memalloc_noio()
262 	if (dev->power.runtime_error)  in rpm_check_suspend_allowed()
264 	else if (dev->power.disable_depth > 0)  in rpm_check_suspend_allowed()
266 	else if (atomic_read(&dev->power.usage_count) > 0)  in rpm_check_suspend_allowed()
268 	else if (!dev->power.ignore_children &&  in rpm_check_suspend_allowed()
269 			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  in rpm_check_suspend_allowed()
276 			&& dev->power.request == RPM_REQ_RESUME))  in rpm_check_suspend_allowed()
280 	else if (dev->power.runtime_status == RPM_SUSPENDED)  in rpm_check_suspend_allowed()
346 	__releases(&dev->power.lock) __acquires(&dev->power.lock)  in __rpm_callback()
349 	bool use_links = dev->power.links_count > 0;  in __rpm_callback()
351 	if (dev->power.irq_safe) {  in __rpm_callback()
352 		spin_unlock(&dev->power.lock);  in __rpm_callback()
354 		spin_unlock_irq(&dev->power.lock);  in __rpm_callback()
363 		if (use_links && dev->power.runtime_status == RPM_RESUMING) {  in __rpm_callback()
379 	if (dev->power.irq_safe) {  in __rpm_callback()
380 		spin_lock(&dev->power.lock);  in __rpm_callback()
390 		    && ((dev->power.runtime_status == RPM_SUSPENDING && !retval)  in __rpm_callback()
391 		    || (dev->power.runtime_status == RPM_RESUMING && retval))) {  in __rpm_callback()
400 		spin_lock_irq(&dev->power.lock);  in __rpm_callback()
417  * This function must be called under dev->power.lock with interrupts disabled.
430 	else if (dev->power.runtime_status != RPM_ACTIVE)  in rpm_idle()
437 	else if (dev->power.request_pending &&  in rpm_idle()
438 	    dev->power.request > RPM_REQ_IDLE)  in rpm_idle()
442 	else if (dev->power.idle_notification)  in rpm_idle()
448 	dev->power.request = RPM_REQ_NONE;  in rpm_idle()
453 	if (!callback || dev->power.no_callbacks)  in rpm_idle()
458 		dev->power.request = RPM_REQ_IDLE;  in rpm_idle()
459 		if (!dev->power.request_pending) {  in rpm_idle()
460 			dev->power.request_pending = true;  in rpm_idle()
461 			queue_work(pm_wq, &dev->power.work);  in rpm_idle()
467 	dev->power.idle_notification = true;  in rpm_idle()
471 	dev->power.idle_notification = false;  in rpm_idle()
472 	wake_up_all(&dev->power.wait_queue);  in rpm_idle()
488 	if (dev->power.memalloc_noio) {  in rpm_callback()
507 	dev->power.runtime_error = retval;  in rpm_callback()
525  * ignore_children of parent->power and irq_safe of dev->power are not set).
530  * This function must be called under dev->power.lock with interrupts disabled.
533 	__releases(&dev->power.lock) __acquires(&dev->power.lock)  in rpm_suspend()
547 	if (dev->power.runtime_status == RPM_RESUMING && !(rpmflags & RPM_ASYNC))  in rpm_suspend()
554 	    && dev->power.runtime_status != RPM_SUSPENDING) {  in rpm_suspend()
559 			dev->power.request = RPM_REQ_NONE;  in rpm_suspend()
568 			if (!(dev->power.timer_expires &&  in rpm_suspend()
569 					dev->power.timer_expires <= expires)) {  in rpm_suspend()
574 				u64 slack = (u64)READ_ONCE(dev->power.autosuspend_delay) *  in rpm_suspend()
577 				dev->power.timer_expires = expires;  in rpm_suspend()
578 				hrtimer_start_range_ns(&dev->power.suspend_timer,  in rpm_suspend()
583 			dev->power.timer_autosuspends = 1;  in rpm_suspend()
591 	if (dev->power.runtime_status == RPM_SUSPENDING) {  in rpm_suspend()
599 		if (dev->power.irq_safe) {  in rpm_suspend()
600 			spin_unlock(&dev->power.lock);  in rpm_suspend()
604 			spin_lock(&dev->power.lock);  in rpm_suspend()
610 			prepare_to_wait(&dev->power.wait_queue, &wait,  in rpm_suspend()
612 			if (dev->power.runtime_status != RPM_SUSPENDING)  in rpm_suspend()
615 			spin_unlock_irq(&dev->power.lock);  in rpm_suspend()
619 			spin_lock_irq(&dev->power.lock);  in rpm_suspend()
621 		finish_wait(&dev->power.wait_queue, &wait);  in rpm_suspend()
625 	if (dev->power.no_callbacks)  in rpm_suspend()
630 		dev->power.request = (rpmflags & RPM_AUTO) ?  in rpm_suspend()
632 		if (!dev->power.request_pending) {  in rpm_suspend()
633 			dev->power.request_pending = true;  in rpm_suspend()
634 			queue_work(pm_wq, &dev->power.work);  in rpm_suspend()
654 		atomic_add_unless(&parent->power.child_count, -1, 0);  in rpm_suspend()
656 	wake_up_all(&dev->power.wait_queue);  in rpm_suspend()
658 	if (dev->power.deferred_resume) {  in rpm_suspend()
659 		dev->power.deferred_resume = false;  in rpm_suspend()
665 	if (dev->power.irq_safe)  in rpm_suspend()
669 	if (parent && !parent->power.ignore_children) {  in rpm_suspend()
670 		spin_unlock(&dev->power.lock);  in rpm_suspend()
672 		spin_lock(&parent->power.lock);  in rpm_suspend()
674 		spin_unlock(&parent->power.lock);  in rpm_suspend()
676 		spin_lock(&dev->power.lock);  in rpm_suspend()
679 	if (dev->power.links_count > 0) {  in rpm_suspend()
680 		spin_unlock_irq(&dev->power.lock);  in rpm_suspend()
684 		spin_lock_irq(&dev->power.lock);  in rpm_suspend()
695 	dev->power.deferred_resume = false;  in rpm_suspend()
696 	wake_up_all(&dev->power.wait_queue);  in rpm_suspend()
699 		dev->power.runtime_error = 0;  in rpm_suspend()
731  * This function must be called under dev->power.lock with interrupts disabled.
734 	__releases(&dev->power.lock) __acquires(&dev->power.lock)  in rpm_resume()
743 	if (dev->power.runtime_error)  in rpm_resume()
745 	else if (dev->power.disable_depth == 1 && dev->power.is_suspended  in rpm_resume()
746 	    && dev->power.runtime_status == RPM_ACTIVE)  in rpm_resume()
748 	else if (dev->power.disable_depth > 0)  in rpm_resume()
759 	dev->power.request = RPM_REQ_NONE;  in rpm_resume()
760 	if (!dev->power.timer_autosuspends)  in rpm_resume()
763 	if (dev->power.runtime_status == RPM_ACTIVE) {  in rpm_resume()
768 	if (dev->power.runtime_status == RPM_RESUMING  in rpm_resume()
769 	    || dev->power.runtime_status == RPM_SUSPENDING) {  in rpm_resume()
773 			if (dev->power.runtime_status == RPM_SUSPENDING)  in rpm_resume()
774 				dev->power.deferred_resume = true;  in rpm_resume()
780 		if (dev->power.irq_safe) {  in rpm_resume()
781 			spin_unlock(&dev->power.lock);  in rpm_resume()
785 			spin_lock(&dev->power.lock);  in rpm_resume()
791 			prepare_to_wait(&dev->power.wait_queue, &wait,  in rpm_resume()
793 			if (dev->power.runtime_status != RPM_RESUMING  in rpm_resume()
794 			    && dev->power.runtime_status != RPM_SUSPENDING)  in rpm_resume()
797 			spin_unlock_irq(&dev->power.lock);  in rpm_resume()
801 			spin_lock_irq(&dev->power.lock);  in rpm_resume()
803 		finish_wait(&dev->power.wait_queue, &wait);  in rpm_resume()
809 	 * power.no_callbacks is set, because otherwise we don't know whether  in rpm_resume()
812 	if (dev->power.no_callbacks && !parent && dev->parent) {  in rpm_resume()
813 		spin_lock_nested(&dev->parent->power.lock, SINGLE_DEPTH_NESTING);  in rpm_resume()
814 		if (dev->parent->power.disable_depth > 0  in rpm_resume()
815 		    || dev->parent->power.ignore_children  in rpm_resume()
816 		    || dev->parent->power.runtime_status == RPM_ACTIVE) {  in rpm_resume()
817 			atomic_inc(&dev->parent->power.child_count);  in rpm_resume()
818 			spin_unlock(&dev->parent->power.lock);  in rpm_resume()
822 		spin_unlock(&dev->parent->power.lock);  in rpm_resume()
827 		dev->power.request = RPM_REQ_RESUME;  in rpm_resume()
828 		if (!dev->power.request_pending) {  in rpm_resume()
829 			dev->power.request_pending = true;  in rpm_resume()
830 			queue_work(pm_wq, &dev->power.work);  in rpm_resume()
843 		if (dev->power.irq_safe)  in rpm_resume()
845 		spin_unlock(&dev->power.lock);  in rpm_resume()
849 		spin_lock(&parent->power.lock);  in rpm_resume()
854 		if (!parent->power.disable_depth  in rpm_resume()
855 		    && !parent->power.ignore_children) {  in rpm_resume()
857 			if (parent->power.runtime_status != RPM_ACTIVE)  in rpm_resume()
860 		spin_unlock(&parent->power.lock);  in rpm_resume()
862 		spin_lock(&dev->power.lock);  in rpm_resume()
869 	if (dev->power.no_callbacks)  in rpm_resume()
887 			atomic_inc(&parent->power.child_count);  in rpm_resume()
889 	wake_up_all(&dev->power.wait_queue);  in rpm_resume()
895 	if (parent && !dev->power.irq_safe) {  in rpm_resume()
896 		spin_unlock_irq(&dev->power.lock);  in rpm_resume()
900 		spin_lock_irq(&dev->power.lock);  in rpm_resume()
917 	struct device *dev = container_of(work, struct device, power.work);  in pm_runtime_work()
920 	spin_lock_irq(&dev->power.lock);  in pm_runtime_work()
922 	if (!dev->power.request_pending)  in pm_runtime_work()
925 	req = dev->power.request;  in pm_runtime_work()
926 	dev->power.request = RPM_REQ_NONE;  in pm_runtime_work()
927 	dev->power.request_pending = false;  in pm_runtime_work()
947 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_work()
958 	struct device *dev = container_of(timer, struct device, power.suspend_timer);  in pm_suspend_timer_fn()
962 	spin_lock_irqsave(&dev->power.lock, flags);  in pm_suspend_timer_fn()
964 	expires = dev->power.timer_expires;  in pm_suspend_timer_fn()
970 		dev->power.timer_expires = 0;  in pm_suspend_timer_fn()
971 		rpm_suspend(dev, dev->power.timer_autosuspends ?  in pm_suspend_timer_fn()
975 	spin_unlock_irqrestore(&dev->power.lock, flags);  in pm_suspend_timer_fn()
991 	spin_lock_irqsave(&dev->power.lock, flags);  in pm_schedule_suspend()
1006 	dev->power.timer_expires = expires;  in pm_schedule_suspend()
1007 	dev->power.timer_autosuspends = 0;  in pm_schedule_suspend()
1008 	hrtimer_start(&dev->power.suspend_timer, expires, HRTIMER_MODE_ABS);  in pm_schedule_suspend()
1011 	spin_unlock_irqrestore(&dev->power.lock, flags);  in pm_schedule_suspend()
1035 		if (!atomic_dec_and_test(&dev->power.usage_count)) {  in __pm_runtime_idle()
1041 	might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe);  in __pm_runtime_idle()
1043 	spin_lock_irqsave(&dev->power.lock, flags);  in __pm_runtime_idle()
1045 	spin_unlock_irqrestore(&dev->power.lock, flags);  in __pm_runtime_idle()
1069 		if (!atomic_dec_and_test(&dev->power.usage_count)) {  in __pm_runtime_suspend()
1075 	might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe);  in __pm_runtime_suspend()
1077 	spin_lock_irqsave(&dev->power.lock, flags);  in __pm_runtime_suspend()
1079 	spin_unlock_irqrestore(&dev->power.lock, flags);  in __pm_runtime_suspend()
1101 	might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe &&  in __pm_runtime_resume()
1102 			dev->power.runtime_status != RPM_ACTIVE);  in __pm_runtime_resume()
1105 		atomic_inc(&dev->power.usage_count);  in __pm_runtime_resume()
1107 	spin_lock_irqsave(&dev->power.lock, flags);  in __pm_runtime_resume()
1109 	spin_unlock_irqrestore(&dev->power.lock, flags);  in __pm_runtime_resume()
1142 	spin_lock_irqsave(&dev->power.lock, flags);  in pm_runtime_get_if_active()
1143 	if (dev->power.disable_depth > 0) {  in pm_runtime_get_if_active()
1145 	} else if (dev->power.runtime_status != RPM_ACTIVE) {  in pm_runtime_get_if_active()
1149 		atomic_inc(&dev->power.usage_count);  in pm_runtime_get_if_active()
1151 		retval = atomic_inc_not_zero(&dev->power.usage_count);  in pm_runtime_get_if_active()
1154 	spin_unlock_irqrestore(&dev->power.lock, flags);  in pm_runtime_get_if_active()
1165  * If runtime PM of the device is disabled or its power.runtime_error field is
1169  * parent's power.ignore_children flag is unset, the device's status cannot be
1172  * If successful, __pm_runtime_set_status() clears the power.runtime_error field
1193 	spin_lock_irq(&dev->power.lock);  in __pm_runtime_set_status()
1199 	if (dev->power.runtime_error || dev->power.disable_depth)  in __pm_runtime_set_status()
1200 		dev->power.disable_depth++;  in __pm_runtime_set_status()
1204 	spin_unlock_irq(&dev->power.lock);  in __pm_runtime_set_status()
1225 	spin_lock_irq(&dev->power.lock);  in __pm_runtime_set_status()
1227 	if (dev->power.runtime_status == status || !parent)  in __pm_runtime_set_status()
1231 		atomic_add_unless(&parent->power.child_count, -1, 0);  in __pm_runtime_set_status()
1232 		notify_parent = !parent->power.ignore_children;  in __pm_runtime_set_status()
1234 		spin_lock_nested(&parent->power.lock, SINGLE_DEPTH_NESTING);  in __pm_runtime_set_status()
1239 		 * 'power.ignore_children' flag unset.  in __pm_runtime_set_status()
1241 		if (!parent->power.disable_depth  in __pm_runtime_set_status()
1242 		    && !parent->power.ignore_children  in __pm_runtime_set_status()
1243 		    && parent->power.runtime_status != RPM_ACTIVE) {  in __pm_runtime_set_status()
1248 		} else if (dev->power.runtime_status == RPM_SUSPENDED) {  in __pm_runtime_set_status()
1249 			atomic_inc(&parent->power.child_count);  in __pm_runtime_set_status()
1252 		spin_unlock(&parent->power.lock);  in __pm_runtime_set_status()
1263 		dev->power.runtime_error = 0;  in __pm_runtime_set_status()
1266 	spin_unlock_irq(&dev->power.lock);  in __pm_runtime_set_status()
1292  * Should be called under dev->power.lock with interrupts disabled.
1298 	if (dev->power.request_pending) {  in __pm_runtime_barrier()
1299 		dev->power.request = RPM_REQ_NONE;  in __pm_runtime_barrier()
1300 		spin_unlock_irq(&dev->power.lock);  in __pm_runtime_barrier()
1302 		cancel_work_sync(&dev->power.work);  in __pm_runtime_barrier()
1304 		spin_lock_irq(&dev->power.lock);  in __pm_runtime_barrier()
1305 		dev->power.request_pending = false;  in __pm_runtime_barrier()
1308 	if (dev->power.runtime_status == RPM_SUSPENDING  in __pm_runtime_barrier()
1309 	    || dev->power.runtime_status == RPM_RESUMING  in __pm_runtime_barrier()
1310 	    || dev->power.idle_notification) {  in __pm_runtime_barrier()
1315 			prepare_to_wait(&dev->power.wait_queue, &wait,  in __pm_runtime_barrier()
1317 			if (dev->power.runtime_status != RPM_SUSPENDING  in __pm_runtime_barrier()
1318 			    && dev->power.runtime_status != RPM_RESUMING  in __pm_runtime_barrier()
1319 			    && !dev->power.idle_notification)  in __pm_runtime_barrier()
1321 			spin_unlock_irq(&dev->power.lock);  in __pm_runtime_barrier()
1325 			spin_lock_irq(&dev->power.lock);  in __pm_runtime_barrier()
1327 		finish_wait(&dev->power.wait_queue, &wait);  in __pm_runtime_barrier()
1350 	spin_lock_irq(&dev->power.lock);  in pm_runtime_barrier()
1352 	if (dev->power.request_pending  in pm_runtime_barrier()
1353 	    && dev->power.request == RPM_REQ_RESUME) {  in pm_runtime_barrier()
1360 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_barrier()
1372  * Increment power.disable_depth for the device and if it was zero previously,
1378  * __pm_runtime_disable() is called and power.disable_depth is zero, the
1383 	spin_lock_irq(&dev->power.lock);  in __pm_runtime_disable()
1385 	if (dev->power.disable_depth > 0) {  in __pm_runtime_disable()
1386 		dev->power.disable_depth++;  in __pm_runtime_disable()
1395 	if (check_resume && dev->power.request_pending  in __pm_runtime_disable()
1396 	    && dev->power.request == RPM_REQ_RESUME) {  in __pm_runtime_disable()
1411 	if (!dev->power.disable_depth++)  in __pm_runtime_disable()
1415 	spin_unlock_irq(&dev->power.lock);  in __pm_runtime_disable()
1427 	spin_lock_irqsave(&dev->power.lock, flags);  in pm_runtime_enable()
1429 	if (dev->power.disable_depth > 0) {  in pm_runtime_enable()
1430 		dev->power.disable_depth--;  in pm_runtime_enable()
1433 		if (!dev->power.disable_depth)  in pm_runtime_enable()
1434 			dev->power.accounting_timestamp = ktime_get_mono_fast_ns();  in pm_runtime_enable()
1439 	WARN(!dev->power.disable_depth &&  in pm_runtime_enable()
1440 	     dev->power.runtime_status == RPM_SUSPENDED &&  in pm_runtime_enable()
1441 	     !dev->power.ignore_children &&  in pm_runtime_enable()
1442 	     atomic_read(&dev->power.child_count) > 0,  in pm_runtime_enable()
1446 	spin_unlock_irqrestore(&dev->power.lock, flags);  in pm_runtime_enable()
1471  * Increase the device's usage count and clear its power.runtime_auto flag,
1477 	spin_lock_irq(&dev->power.lock);  in pm_runtime_forbid()
1478 	if (!dev->power.runtime_auto)  in pm_runtime_forbid()
1481 	dev->power.runtime_auto = false;  in pm_runtime_forbid()
1482 	atomic_inc(&dev->power.usage_count);  in pm_runtime_forbid()
1486 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_forbid()
1494  * Decrease the device's usage count and set its power.runtime_auto flag.
1498 	spin_lock_irq(&dev->power.lock);  in pm_runtime_allow()
1499 	if (dev->power.runtime_auto)  in pm_runtime_allow()
1502 	dev->power.runtime_auto = true;  in pm_runtime_allow()
1503 	if (atomic_dec_and_test(&dev->power.usage_count))  in pm_runtime_allow()
1509 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_allow()
1517  * Set the power.no_callbacks flag, which tells the PM core that this
1518  * device is power-managed through its parent and has no runtime PM
1523 	spin_lock_irq(&dev->power.lock);  in pm_runtime_no_callbacks()
1524 	dev->power.no_callbacks = 1;  in pm_runtime_no_callbacks()
1525 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_no_callbacks()
1535  * Set the power.irq_safe flag, which tells the PM core that the
1546 	spin_lock_irq(&dev->power.lock);  in pm_runtime_irq_safe()
1547 	dev->power.irq_safe = 1;  in pm_runtime_irq_safe()
1548 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_irq_safe()
1561  * This function must be called under dev->power.lock with interrupts disabled.
1565 	int delay = dev->power.autosuspend_delay;  in update_autosuspend()
1568 	if (dev->power.use_autosuspend && delay < 0) {  in update_autosuspend()
1572 			atomic_inc(&dev->power.usage_count);  in update_autosuspend()
1584 			atomic_dec(&dev->power.usage_count);  in update_autosuspend()
1596  * Set the device's power.autosuspend_delay value.  If it changes to negative
1597  * and the power.use_autosuspend flag is set, prevent runtime suspends.  If it
1604 	spin_lock_irq(&dev->power.lock);  in pm_runtime_set_autosuspend_delay()
1605 	old_delay = dev->power.autosuspend_delay;  in pm_runtime_set_autosuspend_delay()
1606 	old_use = dev->power.use_autosuspend;  in pm_runtime_set_autosuspend_delay()
1607 	dev->power.autosuspend_delay = delay;  in pm_runtime_set_autosuspend_delay()
1609 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_set_autosuspend_delay()
1618  * Set the device's power.use_autosuspend flag, and allow or prevent runtime
1625 	spin_lock_irq(&dev->power.lock);  in __pm_runtime_use_autosuspend()
1626 	old_delay = dev->power.autosuspend_delay;  in __pm_runtime_use_autosuspend()
1627 	old_use = dev->power.use_autosuspend;  in __pm_runtime_use_autosuspend()
1628 	dev->power.use_autosuspend = use;  in __pm_runtime_use_autosuspend()
1630 	spin_unlock_irq(&dev->power.lock);  in __pm_runtime_use_autosuspend()
1640 	dev->power.runtime_status = RPM_SUSPENDED;  in pm_runtime_init()
1641 	dev->power.idle_notification = false;  in pm_runtime_init()
1643 	dev->power.disable_depth = 1;  in pm_runtime_init()
1644 	atomic_set(&dev->power.usage_count, 0);  in pm_runtime_init()
1646 	dev->power.runtime_error = 0;  in pm_runtime_init()
1648 	atomic_set(&dev->power.child_count, 0);  in pm_runtime_init()
1650 	dev->power.runtime_auto = true;  in pm_runtime_init()
1652 	dev->power.request_pending = false;  in pm_runtime_init()
1653 	dev->power.request = RPM_REQ_NONE;  in pm_runtime_init()
1654 	dev->power.deferred_resume = false;  in pm_runtime_init()
1655 	dev->power.needs_force_resume = 0;  in pm_runtime_init()
1656 	INIT_WORK(&dev->power.work, pm_runtime_work);  in pm_runtime_init()
1658 	dev->power.timer_expires = 0;  in pm_runtime_init()
1659 	hrtimer_init(&dev->power.suspend_timer, CLOCK_MONOTONIC, HRTIMER_MODE_ABS);  in pm_runtime_init()
1660 	dev->power.suspend_timer.function = pm_suspend_timer_fn;  in pm_runtime_init()
1662 	init_waitqueue_head(&dev->power.wait_queue);  in pm_runtime_init()
1672 		if (dev->power.runtime_status == RPM_ACTIVE)  in pm_runtime_reinit()
1674 		if (dev->power.irq_safe) {  in pm_runtime_reinit()
1675 			spin_lock_irq(&dev->power.lock);  in pm_runtime_reinit()
1676 			dev->power.irq_safe = 0;  in pm_runtime_reinit()
1677 			spin_unlock_irq(&dev->power.lock);  in pm_runtime_reinit()
1733 			spin_lock_irqsave(&dev->power.lock, flags);  in pm_runtime_put_suppliers()
1736 			spin_unlock_irqrestore(&dev->power.lock, flags);  in pm_runtime_put_suppliers()
1746 	spin_lock_irq(&dev->power.lock);  in pm_runtime_new_link()
1747 	dev->power.links_count++;  in pm_runtime_new_link()
1748 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_new_link()
1753 	spin_lock_irq(&dev->power.lock);  in pm_runtime_drop_link_count()
1754 	WARN_ON(dev->power.links_count == 0);  in pm_runtime_drop_link_count()
1755 	dev->power.links_count--;  in pm_runtime_drop_link_count()
1756 	spin_unlock_irq(&dev->power.lock);  in pm_runtime_drop_link_count()
1780 	return atomic_read(&dev->power.usage_count) <= 1 &&  in pm_runtime_need_not_resume()
1781 		(atomic_read(&dev->power.child_count) == 0 ||  in pm_runtime_need_not_resume()
1782 		 dev->power.ignore_children);  in pm_runtime_need_not_resume()
1798  * sure the device is put into low power state and it should only be used during
1827 		dev->power.needs_force_resume = 1;  in pm_runtime_force_suspend()
1843  * into low power state by a call to pm_runtime_force_suspend(). Here we reverse
1844  * those actions and bring the device into full power, if it is expected to be
1855 	if (!pm_runtime_status_suspended(dev) || !dev->power.needs_force_resume)  in pm_runtime_force_resume()
1874 	dev->power.needs_force_resume = 0;  in pm_runtime_force_resume()