Commit | Line | Data |
---|---|---|
0d5adc5f JN |
1 | /* SPDX-License-Identifier: MIT */ |
2 | /* | |
3 | * Copyright © 2019 Intel Corporation | |
4 | */ | |
5 | ||
6 | #ifndef __INTEL_RUNTIME_PM_H__ | |
7 | #define __INTEL_RUNTIME_PM_H__ | |
8 | ||
8874288c | 9 | #include <linux/pm_runtime.h> |
0d5adc5f JN |
10 | #include <linux/types.h> |
11 | ||
09a93ef3 | 12 | #include "intel_wakeref.h" |
0d5adc5f | 13 | |
1bf676cc | 14 | struct device; |
09a93ef3 JN |
15 | struct drm_i915_private; |
16 | struct drm_printer; | |
0d5adc5f | 17 | |
1bf676cc DCS |
18 | /* |
19 | * This struct helps tracking the state needed for runtime PM, which puts the | |
20 | * device in PCI D3 state. Notice that when this happens, nothing on the | |
21 | * graphics device works, even register access, so we don't get interrupts nor | |
22 | * anything else. | |
23 | * | |
24 | * Every piece of our code that needs to actually touch the hardware needs to | |
25 | * either call intel_runtime_pm_get or call intel_display_power_get with the | |
26 | * appropriate power domain. | |
27 | * | |
28 | * Our driver uses the autosuspend delay feature, which means we'll only really | |
29 | * suspend if we stay with zero refcount for a certain amount of time. The | |
30 | * default value is currently very conservative (see intel_runtime_pm_enable), but | |
31 | * it can be changed with the standard runtime PM files from sysfs. | |
32 | * | |
33 | * The irqs_disabled variable becomes true exactly after we disable the IRQs and | |
34 | * goes back to false exactly before we reenable the IRQs. We use this variable | |
35 | * to check if someone is trying to enable/disable IRQs while they're supposed | |
36 | * to be disabled. This shouldn't happen and we'll print some error messages in | |
37 | * case it happens. | |
38 | * | |
fb4da215 | 39 | * For more, read the Documentation/power/runtime_pm.rst. |
1bf676cc DCS |
40 | */ |
41 | struct intel_runtime_pm { | |
42 | atomic_t wakeref_count; | |
9dc25243 | 43 | struct device *kdev; /* points to i915->drm.dev */ |
1bf676cc | 44 | bool available; |
1bf676cc | 45 | bool irqs_enabled; |
985a0256 | 46 | bool no_wakeref_tracking; |
1bf676cc | 47 | |
e66c8dcf AG |
48 | /* |
49 | * Protects access to lmem usefault list. | |
50 | * It is required, if we are outside of the runtime suspend path, | |
51 | * access to @lmem_userfault_list requires always first grabbing the | |
52 | * runtime pm, to ensure we can't race against runtime suspend. | |
53 | * Once we have that we also need to grab @lmem_userfault_lock, | |
54 | * at which point we have exclusive access. | |
55 | * The runtime suspend path is special since it doesn't really hold any locks, | |
56 | * but instead has exclusive access by virtue of all other accesses requiring | |
57 | * holding the runtime pm wakeref. | |
58 | */ | |
1cacd689 | 59 | spinlock_t lmem_userfault_lock; |
e66c8dcf AG |
60 | |
61 | /* | |
62 | * Keep list of userfaulted gem obj, which require to release their | |
63 | * mmap mappings at runtime suspend path. | |
64 | */ | |
65 | struct list_head lmem_userfault_list; | |
66 | ||
67 | /* Manual runtime pm autosuspend delay for user GGTT/lmem mmaps */ | |
68 | struct intel_wakeref_auto userfault_wakeref; | |
69 | ||
1bf676cc DCS |
70 | #if IS_ENABLED(CONFIG_DRM_I915_DEBUG_RUNTIME_PM) |
71 | /* | |
72 | * To aide detection of wakeref leaks and general misuse, we | |
73 | * track all wakeref holders. With manual markup (i.e. returning | |
74 | * a cookie to each rpm_get caller which they then supply to their | |
75 | * paired rpm_put) we can remove corresponding pairs of and keep | |
76 | * the array trimmed to active wakerefs. | |
77 | */ | |
b49e894c | 78 | struct ref_tracker_dir debug; |
1bf676cc DCS |
79 | #endif |
80 | }; | |
81 | ||
82 | #define BITS_PER_WAKEREF \ | |
89270d00 | 83 | BITS_PER_TYPE(typeof_member(struct intel_runtime_pm, wakeref_count)) |
1bf676cc DCS |
84 | #define INTEL_RPM_WAKELOCK_SHIFT (BITS_PER_WAKEREF / 2) |
85 | #define INTEL_RPM_WAKELOCK_BIAS (1 << INTEL_RPM_WAKELOCK_SHIFT) | |
86 | #define INTEL_RPM_RAW_WAKEREF_MASK (INTEL_RPM_WAKELOCK_BIAS - 1) | |
87 | ||
88 | static inline int | |
89 | intel_rpm_raw_wakeref_count(int wakeref_count) | |
90 | { | |
91 | return wakeref_count & INTEL_RPM_RAW_WAKEREF_MASK; | |
92 | } | |
93 | ||
94 | static inline int | |
95 | intel_rpm_wakelock_count(int wakeref_count) | |
96 | { | |
97 | return wakeref_count >> INTEL_RPM_WAKELOCK_SHIFT; | |
98 | } | |
99 | ||
100 | static inline void | |
101 | assert_rpm_device_not_suspended(struct intel_runtime_pm *rpm) | |
102 | { | |
8874288c | 103 | WARN_ONCE(pm_runtime_suspended(rpm->kdev), |
1bf676cc DCS |
104 | "Device suspended during HW access\n"); |
105 | } | |
106 | ||
107 | static inline void | |
108 | __assert_rpm_raw_wakeref_held(struct intel_runtime_pm *rpm, int wakeref_count) | |
109 | { | |
110 | assert_rpm_device_not_suspended(rpm); | |
111 | WARN_ONCE(!intel_rpm_raw_wakeref_count(wakeref_count), | |
112 | "RPM raw-wakeref not held\n"); | |
113 | } | |
114 | ||
115 | static inline void | |
116 | __assert_rpm_wakelock_held(struct intel_runtime_pm *rpm, int wakeref_count) | |
117 | { | |
118 | __assert_rpm_raw_wakeref_held(rpm, wakeref_count); | |
119 | WARN_ONCE(!intel_rpm_wakelock_count(wakeref_count), | |
120 | "RPM wakelock ref not held during HW access\n"); | |
121 | } | |
122 | ||
123 | static inline void | |
124 | assert_rpm_raw_wakeref_held(struct intel_runtime_pm *rpm) | |
125 | { | |
126 | __assert_rpm_raw_wakeref_held(rpm, atomic_read(&rpm->wakeref_count)); | |
127 | } | |
128 | ||
129 | static inline void | |
130 | assert_rpm_wakelock_held(struct intel_runtime_pm *rpm) | |
131 | { | |
132 | __assert_rpm_wakelock_held(rpm, atomic_read(&rpm->wakeref_count)); | |
133 | } | |
134 | ||
135 | /** | |
136 | * disable_rpm_wakeref_asserts - disable the RPM assert checks | |
137 | * @rpm: the intel_runtime_pm structure | |
138 | * | |
139 | * This function disable asserts that check if we hold an RPM wakelock | |
140 | * reference, while keeping the device-not-suspended checks still enabled. | |
141 | * It's meant to be used only in special circumstances where our rule about | |
142 | * the wakelock refcount wrt. the device power state doesn't hold. According | |
143 | * to this rule at any point where we access the HW or want to keep the HW in | |
144 | * an active state we must hold an RPM wakelock reference acquired via one of | |
145 | * the intel_runtime_pm_get() helpers. Currently there are a few special spots | |
146 | * where this rule doesn't hold: the IRQ and suspend/resume handlers, the | |
147 | * forcewake release timer, and the GPU RPS and hangcheck works. All other | |
148 | * users should avoid using this function. | |
149 | * | |
150 | * Any calls to this function must have a symmetric call to | |
151 | * enable_rpm_wakeref_asserts(). | |
152 | */ | |
153 | static inline void | |
154 | disable_rpm_wakeref_asserts(struct intel_runtime_pm *rpm) | |
155 | { | |
156 | atomic_add(INTEL_RPM_WAKELOCK_BIAS + 1, | |
157 | &rpm->wakeref_count); | |
158 | } | |
159 | ||
160 | /** | |
161 | * enable_rpm_wakeref_asserts - re-enable the RPM assert checks | |
162 | * @rpm: the intel_runtime_pm structure | |
163 | * | |
164 | * This function re-enables the RPM assert checks after disabling them with | |
165 | * disable_rpm_wakeref_asserts. It's meant to be used only in special | |
166 | * circumstances otherwise its use should be avoided. | |
167 | * | |
168 | * Any calls to this function must have a symmetric call to | |
169 | * disable_rpm_wakeref_asserts(). | |
170 | */ | |
171 | static inline void | |
172 | enable_rpm_wakeref_asserts(struct intel_runtime_pm *rpm) | |
173 | { | |
174 | atomic_sub(INTEL_RPM_WAKELOCK_BIAS + 1, | |
175 | &rpm->wakeref_count); | |
176 | } | |
177 | ||
69c66355 DCS |
178 | void intel_runtime_pm_init_early(struct intel_runtime_pm *rpm); |
179 | void intel_runtime_pm_enable(struct intel_runtime_pm *rpm); | |
180 | void intel_runtime_pm_disable(struct intel_runtime_pm *rpm); | |
3b58a945 | 181 | void intel_runtime_pm_driver_release(struct intel_runtime_pm *rpm); |
b49e894c | 182 | void intel_runtime_pm_driver_last_release(struct intel_runtime_pm *rpm); |
0d5adc5f | 183 | |
d858d569 DCS |
184 | intel_wakeref_t intel_runtime_pm_get(struct intel_runtime_pm *rpm); |
185 | intel_wakeref_t intel_runtime_pm_get_if_in_use(struct intel_runtime_pm *rpm); | |
9d58aa46 | 186 | intel_wakeref_t intel_runtime_pm_get_if_active(struct intel_runtime_pm *rpm); |
d858d569 DCS |
187 | intel_wakeref_t intel_runtime_pm_get_noresume(struct intel_runtime_pm *rpm); |
188 | intel_wakeref_t intel_runtime_pm_get_raw(struct intel_runtime_pm *rpm); | |
0d5adc5f | 189 | |
c447ff7d DCS |
190 | #define with_intel_runtime_pm(rpm, wf) \ |
191 | for ((wf) = intel_runtime_pm_get(rpm); (wf); \ | |
192 | intel_runtime_pm_put((rpm), (wf)), (wf) = 0) | |
0d5adc5f | 193 | |
c447ff7d DCS |
194 | #define with_intel_runtime_pm_if_in_use(rpm, wf) \ |
195 | for ((wf) = intel_runtime_pm_get_if_in_use(rpm); (wf); \ | |
196 | intel_runtime_pm_put((rpm), (wf)), (wf) = 0) | |
0d5adc5f | 197 | |
9d58aa46 ID |
198 | #define with_intel_runtime_pm_if_active(rpm, wf) \ |
199 | for ((wf) = intel_runtime_pm_get_if_active(rpm); (wf); \ | |
200 | intel_runtime_pm_put((rpm), (wf)), (wf) = 0) | |
201 | ||
d858d569 | 202 | void intel_runtime_pm_put_unchecked(struct intel_runtime_pm *rpm); |
0d5adc5f | 203 | #if IS_ENABLED(CONFIG_DRM_I915_DEBUG_RUNTIME_PM) |
d858d569 | 204 | void intel_runtime_pm_put(struct intel_runtime_pm *rpm, intel_wakeref_t wref); |
0d5adc5f | 205 | #else |
e0da2d63 | 206 | static inline void |
d858d569 | 207 | intel_runtime_pm_put(struct intel_runtime_pm *rpm, intel_wakeref_t wref) |
e0da2d63 | 208 | { |
d858d569 | 209 | intel_runtime_pm_put_unchecked(rpm); |
e0da2d63 | 210 | } |
0d5adc5f | 211 | #endif |
d858d569 | 212 | void intel_runtime_pm_put_raw(struct intel_runtime_pm *rpm, intel_wakeref_t wref); |
0d5adc5f JN |
213 | |
214 | #if IS_ENABLED(CONFIG_DRM_I915_DEBUG_RUNTIME_PM) | |
69c66355 | 215 | void print_intel_runtime_pm_wakeref(struct intel_runtime_pm *rpm, |
0d5adc5f JN |
216 | struct drm_printer *p); |
217 | #else | |
69c66355 | 218 | static inline void print_intel_runtime_pm_wakeref(struct intel_runtime_pm *rpm, |
0d5adc5f JN |
219 | struct drm_printer *p) |
220 | { | |
221 | } | |
222 | #endif | |
223 | ||
0d5adc5f | 224 | #endif /* __INTEL_RUNTIME_PM_H__ */ |