Lines Matching full:dev
27 static pm_callback_t __rpm_get_driver_callback(struct device *dev, in __rpm_get_driver_callback() argument
30 if (dev->driver && dev->driver->pm) in __rpm_get_driver_callback()
31 return get_callback_ptr(dev->driver->pm, cb_offset); in __rpm_get_driver_callback()
36 static pm_callback_t __rpm_get_callback(struct device *dev, size_t cb_offset) in __rpm_get_callback() argument
41 if (dev->pm_domain) in __rpm_get_callback()
42 ops = &dev->pm_domain->ops; in __rpm_get_callback()
43 else if (dev->type && dev->type->pm) in __rpm_get_callback()
44 ops = dev->type->pm; in __rpm_get_callback()
45 else if (dev->class && dev->class->pm) in __rpm_get_callback()
46 ops = dev->class->pm; in __rpm_get_callback()
47 else if (dev->bus && dev->bus->pm) in __rpm_get_callback()
48 ops = dev->bus->pm; in __rpm_get_callback()
56 cb = __rpm_get_driver_callback(dev, cb_offset); in __rpm_get_callback()
61 #define RPM_GET_CALLBACK(dev, callback) \ argument
62 __rpm_get_callback(dev, offsetof(struct dev_pm_ops, callback))
64 static int rpm_resume(struct device *dev, int rpmflags);
65 static int rpm_suspend(struct device *dev, int rpmflags);
69 * @dev: Device to update the accounting for
78 static void update_pm_runtime_accounting(struct device *dev) in update_pm_runtime_accounting() argument
82 if (dev->power.disable_depth > 0) in update_pm_runtime_accounting()
85 last = dev->power.accounting_timestamp; in update_pm_runtime_accounting()
88 dev->power.accounting_timestamp = now; in update_pm_runtime_accounting()
100 if (dev->power.runtime_status == RPM_SUSPENDED) in update_pm_runtime_accounting()
101 dev->power.suspended_time += delta; in update_pm_runtime_accounting()
103 dev->power.active_time += delta; in update_pm_runtime_accounting()
106 static void __update_runtime_status(struct device *dev, enum rpm_status status) in __update_runtime_status() argument
108 update_pm_runtime_accounting(dev); in __update_runtime_status()
109 trace_rpm_status(dev, status); in __update_runtime_status()
110 dev->power.runtime_status = status; in __update_runtime_status()
113 static u64 rpm_get_accounted_time(struct device *dev, bool suspended) in rpm_get_accounted_time() argument
118 spin_lock_irqsave(&dev->power.lock, flags); in rpm_get_accounted_time()
120 update_pm_runtime_accounting(dev); in rpm_get_accounted_time()
121 time = suspended ? dev->power.suspended_time : dev->power.active_time; in rpm_get_accounted_time()
123 spin_unlock_irqrestore(&dev->power.lock, flags); in rpm_get_accounted_time()
128 u64 pm_runtime_active_time(struct device *dev) in pm_runtime_active_time() argument
130 return rpm_get_accounted_time(dev, false); in pm_runtime_active_time()
133 u64 pm_runtime_suspended_time(struct device *dev) in pm_runtime_suspended_time() argument
135 return rpm_get_accounted_time(dev, true); in pm_runtime_suspended_time()
141 * @dev: Device to handle.
143 static void pm_runtime_deactivate_timer(struct device *dev) in pm_runtime_deactivate_timer() argument
145 if (dev->power.timer_expires > 0) { in pm_runtime_deactivate_timer()
146 hrtimer_try_to_cancel(&dev->power.suspend_timer); in pm_runtime_deactivate_timer()
147 dev->power.timer_expires = 0; in pm_runtime_deactivate_timer()
153 * @dev: Device to handle.
155 static void pm_runtime_cancel_pending(struct device *dev) in pm_runtime_cancel_pending() argument
157 pm_runtime_deactivate_timer(dev); in pm_runtime_cancel_pending()
162 dev->power.request = RPM_REQ_NONE; in pm_runtime_cancel_pending()
167 * @dev: Device to handle.
174 * This function may be called either with or without dev->power.lock held.
177 u64 pm_runtime_autosuspend_expiration(struct device *dev) in pm_runtime_autosuspend_expiration() argument
182 if (!dev->power.use_autosuspend) in pm_runtime_autosuspend_expiration()
185 autosuspend_delay = READ_ONCE(dev->power.autosuspend_delay); in pm_runtime_autosuspend_expiration()
189 expires = READ_ONCE(dev->power.last_busy); in pm_runtime_autosuspend_expiration()
198 static int dev_memalloc_noio(struct device *dev, void *data) in dev_memalloc_noio() argument
200 return dev->power.memalloc_noio; in dev_memalloc_noio()
205 * @dev: Device to handle.
231 void pm_runtime_set_memalloc_noio(struct device *dev, bool enable) in pm_runtime_set_memalloc_noio() argument
240 spin_lock_irq(&dev->power.lock); in pm_runtime_set_memalloc_noio()
241 enabled = dev->power.memalloc_noio; in pm_runtime_set_memalloc_noio()
242 dev->power.memalloc_noio = enable; in pm_runtime_set_memalloc_noio()
243 spin_unlock_irq(&dev->power.lock); in pm_runtime_set_memalloc_noio()
252 dev = dev->parent; in pm_runtime_set_memalloc_noio()
259 if (!dev || (!enable && in pm_runtime_set_memalloc_noio()
260 device_for_each_child(dev, NULL, dev_memalloc_noio))) in pm_runtime_set_memalloc_noio()
269 * @dev: Device to test.
271 static int rpm_check_suspend_allowed(struct device *dev) in rpm_check_suspend_allowed() argument
275 if (dev->power.runtime_error) in rpm_check_suspend_allowed()
277 else if (dev->power.disable_depth > 0) in rpm_check_suspend_allowed()
279 else if (atomic_read(&dev->power.usage_count)) in rpm_check_suspend_allowed()
281 else if (!dev->power.ignore_children && atomic_read(&dev->power.child_count)) in rpm_check_suspend_allowed()
285 else if ((dev->power.deferred_resume && in rpm_check_suspend_allowed()
286 dev->power.runtime_status == RPM_SUSPENDING) || in rpm_check_suspend_allowed()
287 (dev->power.request_pending && dev->power.request == RPM_REQ_RESUME)) in rpm_check_suspend_allowed()
289 else if (__dev_pm_qos_resume_latency(dev) == 0) in rpm_check_suspend_allowed()
291 else if (dev->power.runtime_status == RPM_SUSPENDED) in rpm_check_suspend_allowed()
297 static int rpm_get_suppliers(struct device *dev) in rpm_get_suppliers() argument
301 list_for_each_entry_rcu(link, &dev->links.suppliers, c_node, in rpm_get_suppliers()
340 static void __rpm_put_suppliers(struct device *dev, bool try_to_suspend) in __rpm_put_suppliers() argument
344 list_for_each_entry_rcu(link, &dev->links.suppliers, c_node, in __rpm_put_suppliers()
352 static void rpm_put_suppliers(struct device *dev) in rpm_put_suppliers() argument
354 __rpm_put_suppliers(dev, true); in rpm_put_suppliers()
357 static void rpm_suspend_suppliers(struct device *dev) in rpm_suspend_suppliers() argument
362 list_for_each_entry_rcu(link, &dev->links.suppliers, c_node, in rpm_suspend_suppliers()
372 * @dev: Device to run the callback for.
374 static int __rpm_callback(int (*cb)(struct device *), struct device *dev) in __rpm_callback() argument
375 __releases(&dev->power.lock) __acquires(&dev->power.lock) in __rpm_callback()
378 bool use_links = dev->power.links_count > 0; in __rpm_callback()
380 if (dev->power.irq_safe) { in __rpm_callback()
381 spin_unlock(&dev->power.lock); in __rpm_callback()
383 spin_unlock_irq(&dev->power.lock); in __rpm_callback()
392 if (use_links && dev->power.runtime_status == RPM_RESUMING) { in __rpm_callback()
395 retval = rpm_get_suppliers(dev); in __rpm_callback()
397 rpm_put_suppliers(dev); in __rpm_callback()
406 retval = cb(dev); in __rpm_callback()
408 if (dev->power.irq_safe) { in __rpm_callback()
409 spin_lock(&dev->power.lock); in __rpm_callback()
419 ((dev->power.runtime_status == RPM_SUSPENDING && !retval) || in __rpm_callback()
420 (dev->power.runtime_status == RPM_RESUMING && retval))) { in __rpm_callback()
423 __rpm_put_suppliers(dev, false); in __rpm_callback()
429 spin_lock_irq(&dev->power.lock); in __rpm_callback()
438 * @dev: Device to run the callback for.
440 static int rpm_callback(int (*cb)(struct device *), struct device *dev) in rpm_callback() argument
444 if (dev->power.memalloc_noio) { in rpm_callback()
457 retval = __rpm_callback(cb, dev); in rpm_callback()
460 retval = __rpm_callback(cb, dev); in rpm_callback()
473 dev->power.runtime_error = retval; in rpm_callback()
480 * @dev: Device to notify the bus type about.
489 * This function must be called under dev->power.lock with interrupts disabled.
491 static int rpm_idle(struct device *dev, int rpmflags) in rpm_idle() argument
496 trace_rpm_idle(dev, rpmflags); in rpm_idle()
497 retval = rpm_check_suspend_allowed(dev); in rpm_idle()
505 else if (dev->power.runtime_status != RPM_ACTIVE) in rpm_idle()
512 else if (dev->power.request_pending && in rpm_idle()
513 dev->power.request > RPM_REQ_IDLE) in rpm_idle()
517 else if (dev->power.idle_notification) in rpm_idle()
524 dev->power.request = RPM_REQ_NONE; in rpm_idle()
526 callback = RPM_GET_CALLBACK(dev, runtime_idle); in rpm_idle()
529 if (!callback || dev->power.no_callbacks) in rpm_idle()
534 dev->power.request = RPM_REQ_IDLE; in rpm_idle()
535 if (!dev->power.request_pending) { in rpm_idle()
536 dev->power.request_pending = true; in rpm_idle()
537 queue_work(pm_wq, &dev->power.work); in rpm_idle()
539 trace_rpm_return_int(dev, _THIS_IP_, 0); in rpm_idle()
543 dev->power.idle_notification = true; in rpm_idle()
545 if (dev->power.irq_safe) in rpm_idle()
546 spin_unlock(&dev->power.lock); in rpm_idle()
548 spin_unlock_irq(&dev->power.lock); in rpm_idle()
550 retval = callback(dev); in rpm_idle()
552 if (dev->power.irq_safe) in rpm_idle()
553 spin_lock(&dev->power.lock); in rpm_idle()
555 spin_lock_irq(&dev->power.lock); in rpm_idle()
557 dev->power.idle_notification = false; in rpm_idle()
558 wake_up_all(&dev->power.wait_queue); in rpm_idle()
561 trace_rpm_return_int(dev, _THIS_IP_, retval); in rpm_idle()
562 return retval ? retval : rpm_suspend(dev, rpmflags | RPM_AUTO); in rpm_idle()
567 * @dev: Device to suspend.
579 * ignore_children of parent->power and irq_safe of dev->power are not set).
584 * This function must be called under dev->power.lock with interrupts disabled.
586 static int rpm_suspend(struct device *dev, int rpmflags) in rpm_suspend() argument
587 __releases(&dev->power.lock) __acquires(&dev->power.lock) in rpm_suspend()
593 trace_rpm_suspend(dev, rpmflags); in rpm_suspend()
596 retval = rpm_check_suspend_allowed(dev); in rpm_suspend()
601 if (dev->power.runtime_status == RPM_RESUMING && !(rpmflags & RPM_ASYNC)) in rpm_suspend()
608 if ((rpmflags & RPM_AUTO) && dev->power.runtime_status != RPM_SUSPENDING) { in rpm_suspend()
609 u64 expires = pm_runtime_autosuspend_expiration(dev); in rpm_suspend()
613 dev->power.request = RPM_REQ_NONE; in rpm_suspend()
622 if (!(dev->power.timer_expires && in rpm_suspend()
623 dev->power.timer_expires <= expires)) { in rpm_suspend()
628 u64 slack = (u64)READ_ONCE(dev->power.autosuspend_delay) * in rpm_suspend()
631 dev->power.timer_expires = expires; in rpm_suspend()
632 hrtimer_start_range_ns(&dev->power.suspend_timer, in rpm_suspend()
637 dev->power.timer_autosuspends = 1; in rpm_suspend()
643 pm_runtime_cancel_pending(dev); in rpm_suspend()
645 if (dev->power.runtime_status == RPM_SUSPENDING) { in rpm_suspend()
653 if (dev->power.irq_safe) { in rpm_suspend()
654 spin_unlock(&dev->power.lock); in rpm_suspend()
658 spin_lock(&dev->power.lock); in rpm_suspend()
664 prepare_to_wait(&dev->power.wait_queue, &wait, in rpm_suspend()
666 if (dev->power.runtime_status != RPM_SUSPENDING) in rpm_suspend()
669 spin_unlock_irq(&dev->power.lock); in rpm_suspend()
673 spin_lock_irq(&dev->power.lock); in rpm_suspend()
675 finish_wait(&dev->power.wait_queue, &wait); in rpm_suspend()
679 if (dev->power.no_callbacks) in rpm_suspend()
684 dev->power.request = (rpmflags & RPM_AUTO) ? in rpm_suspend()
686 if (!dev->power.request_pending) { in rpm_suspend()
687 dev->power.request_pending = true; in rpm_suspend()
688 queue_work(pm_wq, &dev->power.work); in rpm_suspend()
693 __update_runtime_status(dev, RPM_SUSPENDING); in rpm_suspend()
695 callback = RPM_GET_CALLBACK(dev, runtime_suspend); in rpm_suspend()
697 dev_pm_enable_wake_irq_check(dev, true); in rpm_suspend()
698 retval = rpm_callback(callback, dev); in rpm_suspend()
702 dev_pm_enable_wake_irq_complete(dev); in rpm_suspend()
705 __update_runtime_status(dev, RPM_SUSPENDED); in rpm_suspend()
706 pm_runtime_deactivate_timer(dev); in rpm_suspend()
708 if (dev->parent) { in rpm_suspend()
709 parent = dev->parent; in rpm_suspend()
712 wake_up_all(&dev->power.wait_queue); in rpm_suspend()
714 if (dev->power.deferred_resume) { in rpm_suspend()
715 dev->power.deferred_resume = false; in rpm_suspend()
716 rpm_resume(dev, 0); in rpm_suspend()
721 if (dev->power.irq_safe) in rpm_suspend()
726 spin_unlock(&dev->power.lock); in rpm_suspend()
732 spin_lock(&dev->power.lock); in rpm_suspend()
735 if (dev->power.links_count > 0) { in rpm_suspend()
736 spin_unlock_irq(&dev->power.lock); in rpm_suspend()
738 rpm_suspend_suppliers(dev); in rpm_suspend()
740 spin_lock_irq(&dev->power.lock); in rpm_suspend()
744 trace_rpm_return_int(dev, _THIS_IP_, retval); in rpm_suspend()
749 dev_pm_disable_wake_irq_check(dev, true); in rpm_suspend()
750 __update_runtime_status(dev, RPM_ACTIVE); in rpm_suspend()
751 dev->power.deferred_resume = false; in rpm_suspend()
752 wake_up_all(&dev->power.wait_queue); in rpm_suspend()
760 if (!dev->power.runtime_error && (rpmflags & RPM_AUTO) && in rpm_suspend()
761 pm_runtime_autosuspend_expiration(dev) != 0) in rpm_suspend()
764 pm_runtime_cancel_pending(dev); in rpm_suspend()
771 * @dev: Device to resume.
784 * This function must be called under dev->power.lock with interrupts disabled.
786 static int rpm_resume(struct device *dev, int rpmflags) in rpm_resume() argument
787 __releases(&dev->power.lock) __acquires(&dev->power.lock) in rpm_resume()
793 trace_rpm_resume(dev, rpmflags); in rpm_resume()
796 if (dev->power.runtime_error) { in rpm_resume()
798 } else if (dev->power.disable_depth > 0) { in rpm_resume()
799 if (dev->power.runtime_status == RPM_ACTIVE && in rpm_resume()
800 dev->power.last_status == RPM_ACTIVE) in rpm_resume()
816 dev->power.request = RPM_REQ_NONE; in rpm_resume()
817 if (!dev->power.timer_autosuspends) in rpm_resume()
818 pm_runtime_deactivate_timer(dev); in rpm_resume()
820 if (dev->power.runtime_status == RPM_ACTIVE) { in rpm_resume()
825 if (dev->power.runtime_status == RPM_RESUMING || in rpm_resume()
826 dev->power.runtime_status == RPM_SUSPENDING) { in rpm_resume()
830 if (dev->power.runtime_status == RPM_SUSPENDING) { in rpm_resume()
831 dev->power.deferred_resume = true; in rpm_resume()
840 if (dev->power.irq_safe) { in rpm_resume()
841 spin_unlock(&dev->power.lock); in rpm_resume()
845 spin_lock(&dev->power.lock); in rpm_resume()
851 prepare_to_wait(&dev->power.wait_queue, &wait, in rpm_resume()
853 if (dev->power.runtime_status != RPM_RESUMING && in rpm_resume()
854 dev->power.runtime_status != RPM_SUSPENDING) in rpm_resume()
857 spin_unlock_irq(&dev->power.lock); in rpm_resume()
861 spin_lock_irq(&dev->power.lock); in rpm_resume()
863 finish_wait(&dev->power.wait_queue, &wait); in rpm_resume()
872 if (dev->power.no_callbacks && !parent && dev->parent) { in rpm_resume()
873 spin_lock_nested(&dev->parent->power.lock, SINGLE_DEPTH_NESTING); in rpm_resume()
874 if (dev->parent->power.disable_depth > 0 || in rpm_resume()
875 dev->parent->power.ignore_children || in rpm_resume()
876 dev->parent->power.runtime_status == RPM_ACTIVE) { in rpm_resume()
877 atomic_inc(&dev->parent->power.child_count); in rpm_resume()
878 spin_unlock(&dev->parent->power.lock); in rpm_resume()
882 spin_unlock(&dev->parent->power.lock); in rpm_resume()
887 dev->power.request = RPM_REQ_RESUME; in rpm_resume()
888 if (!dev->power.request_pending) { in rpm_resume()
889 dev->power.request_pending = true; in rpm_resume()
890 queue_work(pm_wq, &dev->power.work); in rpm_resume()
896 if (!parent && dev->parent) { in rpm_resume()
899 * necessary. Not needed if dev is irq-safe; then the in rpm_resume()
902 parent = dev->parent; in rpm_resume()
903 if (dev->power.irq_safe) in rpm_resume()
906 spin_unlock(&dev->power.lock); in rpm_resume()
923 spin_lock(&dev->power.lock); in rpm_resume()
931 if (dev->power.no_callbacks) in rpm_resume()
934 __update_runtime_status(dev, RPM_RESUMING); in rpm_resume()
936 callback = RPM_GET_CALLBACK(dev, runtime_resume); in rpm_resume()
938 dev_pm_disable_wake_irq_check(dev, false); in rpm_resume()
939 retval = rpm_callback(callback, dev); in rpm_resume()
941 __update_runtime_status(dev, RPM_SUSPENDED); in rpm_resume()
942 pm_runtime_cancel_pending(dev); in rpm_resume()
943 dev_pm_enable_wake_irq_check(dev, false); in rpm_resume()
946 __update_runtime_status(dev, RPM_ACTIVE); in rpm_resume()
947 pm_runtime_mark_last_busy(dev); in rpm_resume()
951 wake_up_all(&dev->power.wait_queue); in rpm_resume()
954 rpm_idle(dev, RPM_ASYNC); in rpm_resume()
957 if (parent && !dev->power.irq_safe) { in rpm_resume()
958 spin_unlock_irq(&dev->power.lock); in rpm_resume()
962 spin_lock_irq(&dev->power.lock); in rpm_resume()
965 trace_rpm_return_int(dev, _THIS_IP_, retval); in rpm_resume()
979 struct device *dev = container_of(work, struct device, power.work); in pm_runtime_work() local
982 spin_lock_irq(&dev->power.lock); in pm_runtime_work()
984 if (!dev->power.request_pending) in pm_runtime_work()
987 req = dev->power.request; in pm_runtime_work()
988 dev->power.request = RPM_REQ_NONE; in pm_runtime_work()
989 dev->power.request_pending = false; in pm_runtime_work()
995 rpm_idle(dev, RPM_NOWAIT); in pm_runtime_work()
998 rpm_suspend(dev, RPM_NOWAIT); in pm_runtime_work()
1001 rpm_suspend(dev, RPM_NOWAIT | RPM_AUTO); in pm_runtime_work()
1004 rpm_resume(dev, RPM_NOWAIT); in pm_runtime_work()
1009 spin_unlock_irq(&dev->power.lock); in pm_runtime_work()
1020 struct device *dev = container_of(timer, struct device, power.suspend_timer); in pm_suspend_timer_fn() local
1024 spin_lock_irqsave(&dev->power.lock, flags); in pm_suspend_timer_fn()
1026 expires = dev->power.timer_expires; in pm_suspend_timer_fn()
1032 dev->power.timer_expires = 0; in pm_suspend_timer_fn()
1033 rpm_suspend(dev, dev->power.timer_autosuspends ? in pm_suspend_timer_fn()
1037 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_suspend_timer_fn()
1044 * @dev: Device to suspend.
1047 int pm_schedule_suspend(struct device *dev, unsigned int delay) in pm_schedule_suspend() argument
1053 spin_lock_irqsave(&dev->power.lock, flags); in pm_schedule_suspend()
1056 retval = rpm_suspend(dev, RPM_ASYNC); in pm_schedule_suspend()
1060 retval = rpm_check_suspend_allowed(dev); in pm_schedule_suspend()
1065 pm_runtime_cancel_pending(dev); in pm_schedule_suspend()
1068 dev->power.timer_expires = expires; in pm_schedule_suspend()
1069 dev->power.timer_autosuspends = 0; in pm_schedule_suspend()
1070 hrtimer_start(&dev->power.suspend_timer, expires, HRTIMER_MODE_ABS); in pm_schedule_suspend()
1073 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_schedule_suspend()
1079 static int rpm_drop_usage_count(struct device *dev) in rpm_drop_usage_count() argument
1083 ret = atomic_sub_return(1, &dev->power.usage_count); in rpm_drop_usage_count()
1093 atomic_inc(&dev->power.usage_count); in rpm_drop_usage_count()
1094 dev_warn(dev, "Runtime PM usage count underflow!\n"); in rpm_drop_usage_count()
1100 * @dev: Device to send idle notification for.
1111 int __pm_runtime_idle(struct device *dev, int rpmflags) in __pm_runtime_idle() argument
1117 retval = rpm_drop_usage_count(dev); in __pm_runtime_idle()
1121 trace_rpm_usage(dev, rpmflags); in __pm_runtime_idle()
1126 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe); in __pm_runtime_idle()
1128 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_idle()
1129 retval = rpm_idle(dev, rpmflags); in __pm_runtime_idle()
1130 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_idle()
1138 * @dev: Device to suspend.
1149 int __pm_runtime_suspend(struct device *dev, int rpmflags) in __pm_runtime_suspend() argument
1155 retval = rpm_drop_usage_count(dev); in __pm_runtime_suspend()
1159 trace_rpm_usage(dev, rpmflags); in __pm_runtime_suspend()
1164 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe); in __pm_runtime_suspend()
1166 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_suspend()
1167 retval = rpm_suspend(dev, rpmflags); in __pm_runtime_suspend()
1168 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_suspend()
1176 * @dev: Device to resume.
1185 int __pm_runtime_resume(struct device *dev, int rpmflags) in __pm_runtime_resume() argument
1190 might_sleep_if(!(rpmflags & RPM_ASYNC) && !dev->power.irq_safe && in __pm_runtime_resume()
1191 dev->power.runtime_status != RPM_ACTIVE); in __pm_runtime_resume()
1194 atomic_inc(&dev->power.usage_count); in __pm_runtime_resume()
1196 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_resume()
1197 retval = rpm_resume(dev, rpmflags); in __pm_runtime_resume()
1198 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_resume()
1206 * @dev: Device to handle.
1209 * Return -EINVAL if runtime PM is disabled for @dev.
1212 * is set, or (2) @dev is not ignoring children and its active child count is
1213 * nonzero, or (3) the runtime PM usage counter of @dev is not zero, increment
1214 * the usage counter of @dev and return 1.
1226 * @dev after this function has returned a positive value for it.
1228 static int pm_runtime_get_conditional(struct device *dev, bool ign_usage_count) in pm_runtime_get_conditional() argument
1233 spin_lock_irqsave(&dev->power.lock, flags); in pm_runtime_get_conditional()
1234 if (dev->power.disable_depth > 0) { in pm_runtime_get_conditional()
1236 } else if (dev->power.runtime_status != RPM_ACTIVE) { in pm_runtime_get_conditional()
1238 } else if (ign_usage_count || (!dev->power.ignore_children && in pm_runtime_get_conditional()
1239 atomic_read(&dev->power.child_count) > 0)) { in pm_runtime_get_conditional()
1241 atomic_inc(&dev->power.usage_count); in pm_runtime_get_conditional()
1243 retval = atomic_inc_not_zero(&dev->power.usage_count); in pm_runtime_get_conditional()
1245 trace_rpm_usage(dev, 0); in pm_runtime_get_conditional()
1246 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_runtime_get_conditional()
1254 * @dev: Target device.
1256 * Increment the runtime PM usage counter of @dev if its runtime PM status is
1261 int pm_runtime_get_if_active(struct device *dev) in pm_runtime_get_if_active() argument
1263 return pm_runtime_get_conditional(dev, true); in pm_runtime_get_if_active()
1269 * @dev: Target device.
1271 * Increment the runtime PM usage counter of @dev if its runtime PM status is
1276 * If @dev is in a different state or it is not in use (that is, its usage
1281 * also the usage counter of @dev is not updated.
1283 int pm_runtime_get_if_in_use(struct device *dev) in pm_runtime_get_if_in_use() argument
1285 return pm_runtime_get_conditional(dev, false); in pm_runtime_get_if_in_use()
1291 * @dev: Device to handle.
1306 * If @dev has any suppliers (as reflected by device links to them), and @status
1308 * of them fails, the status of @dev will be changed to RPM_SUSPENDED (instead
1313 int __pm_runtime_set_status(struct device *dev, unsigned int status) in __pm_runtime_set_status() argument
1315 struct device *parent = dev->parent; in __pm_runtime_set_status()
1323 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_set_status()
1329 if (dev->power.runtime_error || dev->power.disable_depth) in __pm_runtime_set_status()
1330 dev->power.disable_depth++; in __pm_runtime_set_status()
1334 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_set_status()
1348 error = rpm_get_suppliers(dev); in __pm_runtime_set_status()
1355 spin_lock_irqsave(&dev->power.lock, flags); in __pm_runtime_set_status()
1357 if (dev->power.runtime_status == status || !parent) in __pm_runtime_set_status()
1374 dev_err(dev, "runtime PM trying to activate child device %s but parent (%s) is not active\n", in __pm_runtime_set_status()
1375 dev_name(dev), in __pm_runtime_set_status()
1378 } else if (dev->power.runtime_status == RPM_SUSPENDED) { in __pm_runtime_set_status()
1391 __update_runtime_status(dev, status); in __pm_runtime_set_status()
1393 dev->power.runtime_error = 0; in __pm_runtime_set_status()
1396 spin_unlock_irqrestore(&dev->power.lock, flags); in __pm_runtime_set_status()
1404 rpm_put_suppliers(dev); in __pm_runtime_set_status()
1409 pm_runtime_enable(dev); in __pm_runtime_set_status()
1417 * @dev: Device to handle.
1422 * Should be called under dev->power.lock with interrupts disabled.
1424 static void __pm_runtime_barrier(struct device *dev) in __pm_runtime_barrier() argument
1426 pm_runtime_deactivate_timer(dev); in __pm_runtime_barrier()
1428 if (dev->power.request_pending) { in __pm_runtime_barrier()
1429 dev->power.request = RPM_REQ_NONE; in __pm_runtime_barrier()
1430 spin_unlock_irq(&dev->power.lock); in __pm_runtime_barrier()
1432 cancel_work_sync(&dev->power.work); in __pm_runtime_barrier()
1434 spin_lock_irq(&dev->power.lock); in __pm_runtime_barrier()
1435 dev->power.request_pending = false; in __pm_runtime_barrier()
1438 if (dev->power.runtime_status == RPM_SUSPENDING || in __pm_runtime_barrier()
1439 dev->power.runtime_status == RPM_RESUMING || in __pm_runtime_barrier()
1440 dev->power.idle_notification) { in __pm_runtime_barrier()
1445 prepare_to_wait(&dev->power.wait_queue, &wait, in __pm_runtime_barrier()
1447 if (dev->power.runtime_status != RPM_SUSPENDING in __pm_runtime_barrier()
1448 && dev->power.runtime_status != RPM_RESUMING in __pm_runtime_barrier()
1449 && !dev->power.idle_notification) in __pm_runtime_barrier()
1451 spin_unlock_irq(&dev->power.lock); in __pm_runtime_barrier()
1455 spin_lock_irq(&dev->power.lock); in __pm_runtime_barrier()
1457 finish_wait(&dev->power.wait_queue, &wait); in __pm_runtime_barrier()
1463 * @dev: Device to handle.
1471 void pm_runtime_barrier(struct device *dev) in pm_runtime_barrier() argument
1473 pm_runtime_get_noresume(dev); in pm_runtime_barrier()
1474 spin_lock_irq(&dev->power.lock); in pm_runtime_barrier()
1476 if (dev->power.request_pending in pm_runtime_barrier()
1477 && dev->power.request == RPM_REQ_RESUME) in pm_runtime_barrier()
1478 rpm_resume(dev, 0); in pm_runtime_barrier()
1480 __pm_runtime_barrier(dev); in pm_runtime_barrier()
1482 spin_unlock_irq(&dev->power.lock); in pm_runtime_barrier()
1483 pm_runtime_put_noidle(dev); in pm_runtime_barrier()
1487 bool pm_runtime_block_if_disabled(struct device *dev) in pm_runtime_block_if_disabled() argument
1491 spin_lock_irq(&dev->power.lock); in pm_runtime_block_if_disabled()
1493 ret = !pm_runtime_enabled(dev); in pm_runtime_block_if_disabled()
1494 if (ret && dev->power.last_status == RPM_INVALID) in pm_runtime_block_if_disabled()
1495 dev->power.last_status = RPM_BLOCKED; in pm_runtime_block_if_disabled()
1497 spin_unlock_irq(&dev->power.lock); in pm_runtime_block_if_disabled()
1502 void pm_runtime_unblock(struct device *dev) in pm_runtime_unblock() argument
1504 spin_lock_irq(&dev->power.lock); in pm_runtime_unblock()
1506 if (dev->power.last_status == RPM_BLOCKED) in pm_runtime_unblock()
1507 dev->power.last_status = RPM_INVALID; in pm_runtime_unblock()
1509 spin_unlock_irq(&dev->power.lock); in pm_runtime_unblock()
1512 void __pm_runtime_disable(struct device *dev, bool check_resume) in __pm_runtime_disable() argument
1514 spin_lock_irq(&dev->power.lock); in __pm_runtime_disable()
1516 if (dev->power.disable_depth > 0) { in __pm_runtime_disable()
1517 dev->power.disable_depth++; in __pm_runtime_disable()
1526 if (check_resume && dev->power.request_pending && in __pm_runtime_disable()
1527 dev->power.request == RPM_REQ_RESUME) { in __pm_runtime_disable()
1532 pm_runtime_get_noresume(dev); in __pm_runtime_disable()
1534 rpm_resume(dev, 0); in __pm_runtime_disable()
1536 pm_runtime_put_noidle(dev); in __pm_runtime_disable()
1540 update_pm_runtime_accounting(dev); in __pm_runtime_disable()
1542 if (!dev->power.disable_depth++) { in __pm_runtime_disable()
1543 __pm_runtime_barrier(dev); in __pm_runtime_disable()
1544 dev->power.last_status = dev->power.runtime_status; in __pm_runtime_disable()
1548 spin_unlock_irq(&dev->power.lock); in __pm_runtime_disable()
1554 * @dev: Device to handle.
1556 void pm_runtime_enable(struct device *dev) in pm_runtime_enable() argument
1560 spin_lock_irqsave(&dev->power.lock, flags); in pm_runtime_enable()
1562 if (!dev->power.disable_depth) { in pm_runtime_enable()
1563 dev_warn(dev, "Unbalanced %s!\n", __func__); in pm_runtime_enable()
1567 if (--dev->power.disable_depth > 0) in pm_runtime_enable()
1570 if (dev->power.last_status == RPM_BLOCKED) { in pm_runtime_enable()
1571 dev_warn(dev, "Attempt to enable runtime PM when it is blocked\n"); in pm_runtime_enable()
1574 dev->power.last_status = RPM_INVALID; in pm_runtime_enable()
1575 dev->power.accounting_timestamp = ktime_get_mono_fast_ns(); in pm_runtime_enable()
1577 if (dev->power.runtime_status == RPM_SUSPENDED && in pm_runtime_enable()
1578 !dev->power.ignore_children && in pm_runtime_enable()
1579 atomic_read(&dev->power.child_count) > 0) in pm_runtime_enable()
1580 dev_warn(dev, "Enabling runtime PM for inactive device with active children\n"); in pm_runtime_enable()
1583 spin_unlock_irqrestore(&dev->power.lock, flags); in pm_runtime_enable()
1595 * @dev: Device to handle.
1597 int devm_pm_runtime_set_active_enabled(struct device *dev) in devm_pm_runtime_set_active_enabled() argument
1601 err = pm_runtime_set_active(dev); in devm_pm_runtime_set_active_enabled()
1605 err = devm_add_action_or_reset(dev, pm_runtime_set_suspended_action, dev); in devm_pm_runtime_set_active_enabled()
1609 return devm_pm_runtime_enable(dev); in devm_pm_runtime_set_active_enabled()
1625 * @dev: Device to handle.
1627 int devm_pm_runtime_enable(struct device *dev) in devm_pm_runtime_enable() argument
1629 pm_runtime_enable(dev); in devm_pm_runtime_enable()
1631 return devm_add_action_or_reset(dev, pm_runtime_disable_action, dev); in devm_pm_runtime_enable()
1643 * @dev: Device to handle.
1645 int devm_pm_runtime_get_noresume(struct device *dev) in devm_pm_runtime_get_noresume() argument
1647 pm_runtime_get_noresume(dev); in devm_pm_runtime_get_noresume()
1649 return devm_add_action_or_reset(dev, pm_runtime_put_noidle_action, dev); in devm_pm_runtime_get_noresume()
1655 * @dev: Device to handle.
1657 * Resume @dev if already suspended and block runtime suspend of @dev in such
1664 void pm_runtime_forbid(struct device *dev) in pm_runtime_forbid() argument
1666 spin_lock_irq(&dev->power.lock); in pm_runtime_forbid()
1667 if (!dev->power.runtime_auto) in pm_runtime_forbid()
1670 dev->power.runtime_auto = false; in pm_runtime_forbid()
1671 atomic_inc(&dev->power.usage_count); in pm_runtime_forbid()
1672 rpm_resume(dev, 0); in pm_runtime_forbid()
1675 spin_unlock_irq(&dev->power.lock); in pm_runtime_forbid()
1681 * @dev: Device to handle.
1683 * Unblock runtime suspend of @dev after it has been blocked by
1685 * /sys/devices/.../power/control interface), check if @dev can be
1691 void pm_runtime_allow(struct device *dev) in pm_runtime_allow() argument
1695 spin_lock_irq(&dev->power.lock); in pm_runtime_allow()
1696 if (dev->power.runtime_auto) in pm_runtime_allow()
1699 dev->power.runtime_auto = true; in pm_runtime_allow()
1700 ret = rpm_drop_usage_count(dev); in pm_runtime_allow()
1702 rpm_idle(dev, RPM_AUTO | RPM_ASYNC); in pm_runtime_allow()
1704 trace_rpm_usage(dev, RPM_AUTO | RPM_ASYNC); in pm_runtime_allow()
1707 spin_unlock_irq(&dev->power.lock); in pm_runtime_allow()
1713 * @dev: Device to handle.
1719 void pm_runtime_no_callbacks(struct device *dev) in pm_runtime_no_callbacks() argument
1721 spin_lock_irq(&dev->power.lock); in pm_runtime_no_callbacks()
1722 dev->power.no_callbacks = 1; in pm_runtime_no_callbacks()
1723 spin_unlock_irq(&dev->power.lock); in pm_runtime_no_callbacks()
1724 if (device_is_registered(dev)) in pm_runtime_no_callbacks()
1725 rpm_sysfs_remove(dev); in pm_runtime_no_callbacks()
1731 * @dev: Device to handle
1740 void pm_runtime_irq_safe(struct device *dev) in pm_runtime_irq_safe() argument
1742 if (dev->parent) in pm_runtime_irq_safe()
1743 pm_runtime_get_sync(dev->parent); in pm_runtime_irq_safe()
1745 spin_lock_irq(&dev->power.lock); in pm_runtime_irq_safe()
1746 dev->power.irq_safe = 1; in pm_runtime_irq_safe()
1747 spin_unlock_irq(&dev->power.lock); in pm_runtime_irq_safe()
1753 * @dev: Device to handle.
1760 * This function must be called under dev->power.lock with interrupts disabled.
1762 static void update_autosuspend(struct device *dev, int old_delay, int old_use) in update_autosuspend() argument
1764 int delay = dev->power.autosuspend_delay; in update_autosuspend()
1767 if (dev->power.use_autosuspend && delay < 0) { in update_autosuspend()
1771 atomic_inc(&dev->power.usage_count); in update_autosuspend()
1772 rpm_resume(dev, 0); in update_autosuspend()
1774 trace_rpm_usage(dev, 0); in update_autosuspend()
1783 atomic_dec(&dev->power.usage_count); in update_autosuspend()
1786 rpm_idle(dev, RPM_AUTO); in update_autosuspend()
1792 * @dev: Device to handle.
1799 void pm_runtime_set_autosuspend_delay(struct device *dev, int delay) in pm_runtime_set_autosuspend_delay() argument
1803 spin_lock_irq(&dev->power.lock); in pm_runtime_set_autosuspend_delay()
1804 old_delay = dev->power.autosuspend_delay; in pm_runtime_set_autosuspend_delay()
1805 old_use = dev->power.use_autosuspend; in pm_runtime_set_autosuspend_delay()
1806 dev->power.autosuspend_delay = delay; in pm_runtime_set_autosuspend_delay()
1807 update_autosuspend(dev, old_delay, old_use); in pm_runtime_set_autosuspend_delay()
1808 spin_unlock_irq(&dev->power.lock); in pm_runtime_set_autosuspend_delay()
1814 * @dev: Device to handle.
1820 void __pm_runtime_use_autosuspend(struct device *dev, bool use) in __pm_runtime_use_autosuspend() argument
1824 spin_lock_irq(&dev->power.lock); in __pm_runtime_use_autosuspend()
1825 old_delay = dev->power.autosuspend_delay; in __pm_runtime_use_autosuspend()
1826 old_use = dev->power.use_autosuspend; in __pm_runtime_use_autosuspend()
1827 dev->power.use_autosuspend = use; in __pm_runtime_use_autosuspend()
1828 update_autosuspend(dev, old_delay, old_use); in __pm_runtime_use_autosuspend()
1829 spin_unlock_irq(&dev->power.lock); in __pm_runtime_use_autosuspend()
1835 * @dev: Device object to initialize.
1837 void pm_runtime_init(struct device *dev) in pm_runtime_init() argument
1839 dev->power.runtime_status = RPM_SUSPENDED; in pm_runtime_init()
1840 dev->power.last_status = RPM_INVALID; in pm_runtime_init()
1841 dev->power.idle_notification = false; in pm_runtime_init()
1843 dev->power.disable_depth = 1; in pm_runtime_init()
1844 atomic_set(&dev->power.usage_count, 0); in pm_runtime_init()
1846 dev->power.runtime_error = 0; in pm_runtime_init()
1848 atomic_set(&dev->power.child_count, 0); in pm_runtime_init()
1849 pm_suspend_ignore_children(dev, false); in pm_runtime_init()
1850 dev->power.runtime_auto = true; in pm_runtime_init()
1852 dev->power.request_pending = false; in pm_runtime_init()
1853 dev->power.request = RPM_REQ_NONE; in pm_runtime_init()
1854 dev->power.deferred_resume = false; in pm_runtime_init()
1855 dev->power.needs_force_resume = false; in pm_runtime_init()
1856 INIT_WORK(&dev->power.work, pm_runtime_work); in pm_runtime_init()
1858 dev->power.timer_expires = 0; in pm_runtime_init()
1859 hrtimer_setup(&dev->power.suspend_timer, pm_suspend_timer_fn, CLOCK_MONOTONIC, in pm_runtime_init()
1862 init_waitqueue_head(&dev->power.wait_queue); in pm_runtime_init()
1867 * @dev: Device object to re-initialize.
1869 void pm_runtime_reinit(struct device *dev) in pm_runtime_reinit() argument
1871 if (pm_runtime_enabled(dev)) in pm_runtime_reinit()
1874 if (dev->power.runtime_status == RPM_ACTIVE) in pm_runtime_reinit()
1875 pm_runtime_set_suspended(dev); in pm_runtime_reinit()
1877 if (dev->power.irq_safe) { in pm_runtime_reinit()
1878 spin_lock_irq(&dev->power.lock); in pm_runtime_reinit()
1879 dev->power.irq_safe = 0; in pm_runtime_reinit()
1880 spin_unlock_irq(&dev->power.lock); in pm_runtime_reinit()
1881 if (dev->parent) in pm_runtime_reinit()
1882 pm_runtime_put(dev->parent); in pm_runtime_reinit()
1888 dev->power.needs_force_resume = false; in pm_runtime_reinit()
1893 * @dev: Device object being removed from device hierarchy.
1895 void pm_runtime_remove(struct device *dev) in pm_runtime_remove() argument
1897 __pm_runtime_disable(dev, false); in pm_runtime_remove()
1898 pm_runtime_reinit(dev); in pm_runtime_remove()
1903 * @dev: Consumer device.
1905 void pm_runtime_get_suppliers(struct device *dev) in pm_runtime_get_suppliers() argument
1912 dev_for_each_link_to_supplier(link, dev) in pm_runtime_get_suppliers()
1923 * @dev: Consumer device.
1925 void pm_runtime_put_suppliers(struct device *dev) in pm_runtime_put_suppliers() argument
1932 list_for_each_entry_rcu(link, &dev->links.suppliers, c_node, in pm_runtime_put_suppliers()
1942 void pm_runtime_new_link(struct device *dev) in pm_runtime_new_link() argument
1944 spin_lock_irq(&dev->power.lock); in pm_runtime_new_link()
1945 dev->power.links_count++; in pm_runtime_new_link()
1946 spin_unlock_irq(&dev->power.lock); in pm_runtime_new_link()
1949 static void pm_runtime_drop_link_count(struct device *dev) in pm_runtime_drop_link_count() argument
1951 spin_lock_irq(&dev->power.lock); in pm_runtime_drop_link_count()
1952 WARN_ON(dev->power.links_count == 0); in pm_runtime_drop_link_count()
1953 dev->power.links_count--; in pm_runtime_drop_link_count()
1954 spin_unlock_irq(&dev->power.lock); in pm_runtime_drop_link_count()
1975 static pm_callback_t get_callback(struct device *dev, size_t cb_offset) in get_callback() argument
1983 if (dev_pm_strict_midlayer_is_set(dev)) in get_callback()
1984 return __rpm_get_driver_callback(dev, cb_offset); in get_callback()
1986 return __rpm_get_callback(dev, cb_offset); in get_callback()
1989 #define GET_CALLBACK(dev, callback) \ argument
1990 get_callback(dev, offsetof(struct dev_pm_ops, callback))
1994 * @dev: Device to suspend.
2009 int pm_runtime_force_suspend(struct device *dev) in pm_runtime_force_suspend() argument
2014 pm_runtime_disable(dev); in pm_runtime_force_suspend()
2015 if (pm_runtime_status_suspended(dev) || dev->power.needs_force_resume) in pm_runtime_force_suspend()
2018 callback = GET_CALLBACK(dev, runtime_suspend); in pm_runtime_force_suspend()
2020 dev_pm_enable_wake_irq_check(dev, true); in pm_runtime_force_suspend()
2021 ret = callback ? callback(dev) : 0; in pm_runtime_force_suspend()
2025 dev_pm_enable_wake_irq_complete(dev); in pm_runtime_force_suspend()
2036 if (pm_runtime_need_not_resume(dev)) in pm_runtime_force_suspend()
2037 pm_runtime_set_suspended(dev); in pm_runtime_force_suspend()
2039 dev->power.needs_force_resume = true; in pm_runtime_force_suspend()
2044 dev_pm_disable_wake_irq_check(dev, true); in pm_runtime_force_suspend()
2045 pm_runtime_enable(dev); in pm_runtime_force_suspend()
2054 * @dev: Device to resume.
2071 int pm_runtime_force_resume(struct device *dev) in pm_runtime_force_resume() argument
2076 if (!dev->power.needs_force_resume && (!dev_pm_smart_suspend(dev) || in pm_runtime_force_resume()
2077 pm_runtime_status_suspended(dev))) in pm_runtime_force_resume()
2080 callback = GET_CALLBACK(dev, runtime_resume); in pm_runtime_force_resume()
2082 dev_pm_disable_wake_irq_check(dev, false); in pm_runtime_force_resume()
2083 ret = callback ? callback(dev) : 0; in pm_runtime_force_resume()
2085 pm_runtime_set_suspended(dev); in pm_runtime_force_resume()
2086 dev_pm_enable_wake_irq_check(dev, false); in pm_runtime_force_resume()
2090 pm_runtime_mark_last_busy(dev); in pm_runtime_force_resume()
2098 dev->power.smart_suspend = false; in pm_runtime_force_resume()
2103 dev->power.needs_force_resume = false; in pm_runtime_force_resume()
2105 pm_runtime_enable(dev); in pm_runtime_force_resume()
2110 bool pm_runtime_need_not_resume(struct device *dev) in pm_runtime_need_not_resume() argument
2112 return atomic_read(&dev->power.usage_count) <= 1 && in pm_runtime_need_not_resume()
2113 (atomic_read(&dev->power.child_count) == 0 || in pm_runtime_need_not_resume()
2114 dev->power.ignore_children); in pm_runtime_need_not_resume()