1// SPDX-License-Identifier: MIT
2/*
3 * Copyright (C) 2019 Google, Inc.
4 *
5 * Authors:
6 * Sean Paul <seanpaul@chromium.org>
7 */
8#include <linux/average.h>
9#include <linux/bitops.h>
10#include <linux/export.h>
11#include <linux/slab.h>
12#include <linux/workqueue.h>
13
14#include <drm/drm_atomic.h>
15#include <drm/drm_atomic_helper.h>
16#include <drm/drm_connector.h>
17#include <drm/drm_crtc.h>
18#include <drm/drm_device.h>
19#include <drm/drm_mode_config.h>
20#include <drm/drm_modeset_lock.h>
21#include <drm/drm_print.h>
22#include <drm/drm_self_refresh_helper.h>
23
24/**
25 * DOC: overview
26 *
27 * This helper library provides an easy way for drivers to leverage the atomic
28 * framework to implement panel self refresh (SR) support. Drivers are
29 * responsible for initializing and cleaning up the SR helpers on load/unload
30 * (see &drm_self_refresh_helper_init/&drm_self_refresh_helper_cleanup).
31 * The connector is responsible for setting
32 * &drm_connector_state.self_refresh_aware to true at runtime if it is SR-aware
33 * (meaning it knows how to initiate self refresh on the panel).
34 *
35 * Once a crtc has enabled SR using &drm_self_refresh_helper_init, the
36 * helpers will monitor activity and call back into the driver to enable/disable
37 * SR as appropriate. The best way to think about this is that it's a DPMS
38 * on/off request with &drm_crtc_state.self_refresh_active set in crtc state
39 * that tells you to disable/enable SR on the panel instead of power-cycling it.
40 *
41 * During SR, drivers may choose to fully disable their crtc/encoder/bridge
42 * hardware (in which case no driver changes are necessary), or they can inspect
43 * &drm_crtc_state.self_refresh_active if they want to enter low power mode
44 * without full disable (in case full disable/enable is too slow).
45 *
46 * SR will be deactivated if there are any atomic updates affecting the
47 * pipe that is in SR mode. If a crtc is driving multiple connectors, all
48 * connectors must be SR aware and all will enter/exit SR mode at the same time.
49 *
50 * If the crtc and connector are SR aware, but the panel connected does not
51 * support it (or is otherwise unable to enter SR), the driver should fail
52 * atomic_check when &drm_crtc_state.self_refresh_active is true.
53 */
54
55#define SELF_REFRESH_AVG_SEED_MS 200
56
57DECLARE_EWMA(psr_time, 4, 4)
58
59struct drm_self_refresh_data {
60 struct drm_crtc *crtc;
61 struct delayed_work entry_work;
62
63 struct mutex avg_mutex;
64 struct ewma_psr_time entry_avg_ms;
65 struct ewma_psr_time exit_avg_ms;
66};
67
68static void drm_self_refresh_helper_entry_work(struct work_struct *work)
69{
70 struct drm_self_refresh_data *sr_data = container_of(
71 to_delayed_work(work),
72 struct drm_self_refresh_data, entry_work);
73 struct drm_crtc *crtc = sr_data->crtc;
74 struct drm_device *dev = crtc->dev;
75 struct drm_modeset_acquire_ctx ctx;
76 struct drm_atomic_state *state;
77 struct drm_connector *conn;
78 struct drm_connector_state *conn_state;
79 struct drm_crtc_state *crtc_state;
80 int i, ret = 0;
81
82 drm_modeset_acquire_init(ctx: &ctx, flags: 0);
83
84 state = drm_atomic_state_alloc(dev);
85 if (!state) {
86 ret = -ENOMEM;
87 goto out_drop_locks;
88 }
89
90retry:
91 state->acquire_ctx = &ctx;
92
93 crtc_state = drm_atomic_get_crtc_state(state, crtc);
94 if (IS_ERR(ptr: crtc_state)) {
95 ret = PTR_ERR(ptr: crtc_state);
96 goto out;
97 }
98
99 if (!crtc_state->enable)
100 goto out;
101
102 ret = drm_atomic_add_affected_connectors(state, crtc);
103 if (ret)
104 goto out;
105
106 for_each_new_connector_in_state(state, conn, conn_state, i) {
107 if (!conn_state->self_refresh_aware)
108 goto out;
109 }
110
111 crtc_state->active = false;
112 crtc_state->self_refresh_active = true;
113
114 ret = drm_atomic_commit(state);
115 if (ret)
116 goto out;
117
118out:
119 if (ret == -EDEADLK) {
120 drm_atomic_state_clear(state);
121 ret = drm_modeset_backoff(ctx: &ctx);
122 if (!ret)
123 goto retry;
124 }
125
126 drm_atomic_state_put(state);
127
128out_drop_locks:
129 drm_modeset_drop_locks(ctx: &ctx);
130 drm_modeset_acquire_fini(ctx: &ctx);
131}
132
133/**
134 * drm_self_refresh_helper_update_avg_times - Updates a crtc's SR time averages
135 * @state: the state which has just been applied to hardware
136 * @commit_time_ms: the amount of time in ms that this commit took to complete
137 * @new_self_refresh_mask: bitmask of crtc's that have self_refresh_active in
138 * new state
139 *
140 * Called after &drm_mode_config_funcs.atomic_commit_tail, this function will
141 * update the average entry/exit self refresh times on self refresh transitions.
142 * These averages will be used when calculating how long to delay before
143 * entering self refresh mode after activity.
144 */
145void
146drm_self_refresh_helper_update_avg_times(struct drm_atomic_state *state,
147 unsigned int commit_time_ms,
148 unsigned int new_self_refresh_mask)
149{
150 struct drm_crtc *crtc;
151 struct drm_crtc_state *old_crtc_state;
152 int i;
153
154 for_each_old_crtc_in_state(state, crtc, old_crtc_state, i) {
155 bool new_self_refresh_active = new_self_refresh_mask & BIT(i);
156 struct drm_self_refresh_data *sr_data = crtc->self_refresh_data;
157 struct ewma_psr_time *time;
158
159 if (old_crtc_state->self_refresh_active ==
160 new_self_refresh_active)
161 continue;
162
163 if (new_self_refresh_active)
164 time = &sr_data->entry_avg_ms;
165 else
166 time = &sr_data->exit_avg_ms;
167
168 mutex_lock(&sr_data->avg_mutex);
169 ewma_psr_time_add(e: time, val: commit_time_ms);
170 mutex_unlock(lock: &sr_data->avg_mutex);
171 }
172}
173EXPORT_SYMBOL(drm_self_refresh_helper_update_avg_times);
174
175/**
176 * drm_self_refresh_helper_alter_state - Alters the atomic state for SR exit
177 * @state: the state currently being checked
178 *
179 * Called at the end of atomic check. This function checks the state for flags
180 * incompatible with self refresh exit and changes them. This is a bit
181 * disingenuous since userspace is expecting one thing and we're giving it
182 * another. However in order to keep self refresh entirely hidden from
183 * userspace, this is required.
184 *
185 * At the end, we queue up the self refresh entry work so we can enter PSR after
186 * the desired delay.
187 */
188void drm_self_refresh_helper_alter_state(struct drm_atomic_state *state)
189{
190 struct drm_crtc *crtc;
191 struct drm_crtc_state *crtc_state;
192 int i;
193
194 if (state->async_update || !state->allow_modeset) {
195 for_each_old_crtc_in_state(state, crtc, crtc_state, i) {
196 if (crtc_state->self_refresh_active) {
197 state->async_update = false;
198 state->allow_modeset = true;
199 break;
200 }
201 }
202 }
203
204 for_each_new_crtc_in_state(state, crtc, crtc_state, i) {
205 struct drm_self_refresh_data *sr_data;
206 unsigned int delay;
207
208 /* Don't trigger the entry timer when we're already in SR */
209 if (crtc_state->self_refresh_active)
210 continue;
211
212 sr_data = crtc->self_refresh_data;
213 if (!sr_data)
214 continue;
215
216 mutex_lock(&sr_data->avg_mutex);
217 delay = (ewma_psr_time_read(e: &sr_data->entry_avg_ms) +
218 ewma_psr_time_read(e: &sr_data->exit_avg_ms)) * 2;
219 mutex_unlock(lock: &sr_data->avg_mutex);
220
221 mod_delayed_work(wq: system_wq, dwork: &sr_data->entry_work,
222 delay: msecs_to_jiffies(m: delay));
223 }
224}
225EXPORT_SYMBOL(drm_self_refresh_helper_alter_state);
226
227/**
228 * drm_self_refresh_helper_init - Initializes self refresh helpers for a crtc
229 * @crtc: the crtc which supports self refresh supported displays
230 *
231 * Returns zero if successful or -errno on failure
232 */
233int drm_self_refresh_helper_init(struct drm_crtc *crtc)
234{
235 struct drm_self_refresh_data *sr_data = crtc->self_refresh_data;
236
237 /* Helper is already initialized */
238 if (WARN_ON(sr_data))
239 return -EINVAL;
240
241 sr_data = kzalloc(sizeof(*sr_data), GFP_KERNEL);
242 if (!sr_data)
243 return -ENOMEM;
244
245 INIT_DELAYED_WORK(&sr_data->entry_work,
246 drm_self_refresh_helper_entry_work);
247 sr_data->crtc = crtc;
248 mutex_init(&sr_data->avg_mutex);
249 ewma_psr_time_init(e: &sr_data->entry_avg_ms);
250 ewma_psr_time_init(e: &sr_data->exit_avg_ms);
251
252 /*
253 * Seed the averages so they're non-zero (and sufficiently large
254 * for even poorly performing panels). As time goes on, this will be
255 * averaged out and the values will trend to their true value.
256 */
257 ewma_psr_time_add(e: &sr_data->entry_avg_ms, SELF_REFRESH_AVG_SEED_MS);
258 ewma_psr_time_add(e: &sr_data->exit_avg_ms, SELF_REFRESH_AVG_SEED_MS);
259
260 crtc->self_refresh_data = sr_data;
261 return 0;
262}
263EXPORT_SYMBOL(drm_self_refresh_helper_init);
264
265/**
266 * drm_self_refresh_helper_cleanup - Cleans up self refresh helpers for a crtc
267 * @crtc: the crtc to cleanup
268 */
269void drm_self_refresh_helper_cleanup(struct drm_crtc *crtc)
270{
271 struct drm_self_refresh_data *sr_data = crtc->self_refresh_data;
272
273 /* Helper is already uninitialized */
274 if (!sr_data)
275 return;
276
277 crtc->self_refresh_data = NULL;
278
279 cancel_delayed_work_sync(dwork: &sr_data->entry_work);
280 kfree(objp: sr_data);
281}
282EXPORT_SYMBOL(drm_self_refresh_helper_cleanup);
283

source code of linux/drivers/gpu/drm/drm_self_refresh_helper.c